You can subscribe to this list here.
| 2002 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(1) |
Oct
(122) |
Nov
(152) |
Dec
(69) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2003 |
Jan
(6) |
Feb
(25) |
Mar
(73) |
Apr
(82) |
May
(24) |
Jun
(25) |
Jul
(10) |
Aug
(11) |
Sep
(10) |
Oct
(54) |
Nov
(203) |
Dec
(182) |
| 2004 |
Jan
(307) |
Feb
(305) |
Mar
(430) |
Apr
(312) |
May
(187) |
Jun
(342) |
Jul
(487) |
Aug
(637) |
Sep
(336) |
Oct
(373) |
Nov
(441) |
Dec
(210) |
| 2005 |
Jan
(385) |
Feb
(480) |
Mar
(636) |
Apr
(544) |
May
(679) |
Jun
(625) |
Jul
(810) |
Aug
(838) |
Sep
(634) |
Oct
(521) |
Nov
(965) |
Dec
(543) |
| 2006 |
Jan
(494) |
Feb
(431) |
Mar
(546) |
Apr
(411) |
May
(406) |
Jun
(322) |
Jul
(256) |
Aug
(401) |
Sep
(345) |
Oct
(542) |
Nov
(308) |
Dec
(481) |
| 2007 |
Jan
(427) |
Feb
(326) |
Mar
(367) |
Apr
(255) |
May
(244) |
Jun
(204) |
Jul
(223) |
Aug
(231) |
Sep
(354) |
Oct
(374) |
Nov
(497) |
Dec
(362) |
| 2008 |
Jan
(322) |
Feb
(482) |
Mar
(658) |
Apr
(422) |
May
(476) |
Jun
(396) |
Jul
(455) |
Aug
(267) |
Sep
(280) |
Oct
(253) |
Nov
(232) |
Dec
(304) |
| 2009 |
Jan
(486) |
Feb
(470) |
Mar
(458) |
Apr
(423) |
May
(696) |
Jun
(461) |
Jul
(551) |
Aug
(575) |
Sep
(134) |
Oct
(110) |
Nov
(157) |
Dec
(102) |
| 2010 |
Jan
(226) |
Feb
(86) |
Mar
(147) |
Apr
(117) |
May
(107) |
Jun
(203) |
Jul
(193) |
Aug
(238) |
Sep
(300) |
Oct
(246) |
Nov
(23) |
Dec
(75) |
| 2011 |
Jan
(133) |
Feb
(195) |
Mar
(315) |
Apr
(200) |
May
(267) |
Jun
(293) |
Jul
(353) |
Aug
(237) |
Sep
(278) |
Oct
(611) |
Nov
(274) |
Dec
(260) |
| 2012 |
Jan
(303) |
Feb
(391) |
Mar
(417) |
Apr
(441) |
May
(488) |
Jun
(655) |
Jul
(590) |
Aug
(610) |
Sep
(526) |
Oct
(478) |
Nov
(359) |
Dec
(372) |
| 2013 |
Jan
(467) |
Feb
(226) |
Mar
(391) |
Apr
(281) |
May
(299) |
Jun
(252) |
Jul
(311) |
Aug
(352) |
Sep
(481) |
Oct
(571) |
Nov
(222) |
Dec
(231) |
| 2014 |
Jan
(185) |
Feb
(329) |
Mar
(245) |
Apr
(238) |
May
(281) |
Jun
(399) |
Jul
(382) |
Aug
(500) |
Sep
(579) |
Oct
(435) |
Nov
(487) |
Dec
(256) |
| 2015 |
Jan
(338) |
Feb
(357) |
Mar
(330) |
Apr
(294) |
May
(191) |
Jun
(108) |
Jul
(142) |
Aug
(261) |
Sep
(190) |
Oct
(54) |
Nov
(83) |
Dec
(22) |
| 2016 |
Jan
(49) |
Feb
(89) |
Mar
(33) |
Apr
(50) |
May
(27) |
Jun
(34) |
Jul
(53) |
Aug
(53) |
Sep
(98) |
Oct
(206) |
Nov
(93) |
Dec
(53) |
| 2017 |
Jan
(65) |
Feb
(82) |
Mar
(102) |
Apr
(86) |
May
(187) |
Jun
(67) |
Jul
(23) |
Aug
(93) |
Sep
(65) |
Oct
(45) |
Nov
(35) |
Dec
(17) |
| 2018 |
Jan
(26) |
Feb
(35) |
Mar
(38) |
Apr
(32) |
May
(8) |
Jun
(43) |
Jul
(27) |
Aug
(30) |
Sep
(43) |
Oct
(42) |
Nov
(38) |
Dec
(67) |
| 2019 |
Jan
(32) |
Feb
(37) |
Mar
(53) |
Apr
(64) |
May
(49) |
Jun
(18) |
Jul
(14) |
Aug
(53) |
Sep
(25) |
Oct
(30) |
Nov
(49) |
Dec
(31) |
| 2020 |
Jan
(87) |
Feb
(45) |
Mar
(37) |
Apr
(51) |
May
(99) |
Jun
(36) |
Jul
(11) |
Aug
(14) |
Sep
(20) |
Oct
(24) |
Nov
(40) |
Dec
(23) |
| 2021 |
Jan
(14) |
Feb
(53) |
Mar
(85) |
Apr
(15) |
May
(19) |
Jun
(3) |
Jul
(14) |
Aug
(1) |
Sep
(57) |
Oct
(73) |
Nov
(56) |
Dec
(22) |
| 2022 |
Jan
(3) |
Feb
(22) |
Mar
(6) |
Apr
(55) |
May
(46) |
Jun
(39) |
Jul
(15) |
Aug
(9) |
Sep
(11) |
Oct
(34) |
Nov
(20) |
Dec
(36) |
| 2023 |
Jan
(79) |
Feb
(41) |
Mar
(99) |
Apr
(169) |
May
(48) |
Jun
(16) |
Jul
(16) |
Aug
(57) |
Sep
(19) |
Oct
|
Nov
|
Dec
|
| S | M | T | W | T | F | S |
|---|---|---|---|---|---|---|
|
|
|
|
|
|
|
1
(1) |
|
2
(19) |
3
(17) |
4
(15) |
5
(20) |
6
(29) |
7
(13) |
8
(16) |
|
9
(20) |
10
(5) |
11
(10) |
12
(17) |
13
(17) |
14
(22) |
15
(8) |
|
16
(4) |
17
(15) |
18
(7) |
19
(14) |
20
(16) |
21
(18) |
22
(9) |
|
23
(2) |
24
(12) |
25
(3) |
26
(3) |
27
(20) |
28
(9) |
29
(4) |
|
30
(3) |
31
(4) |
|
|
|
|
|
|
From: <sv...@va...> - 2012-12-16 22:49:13
|
florian 2012-12-16 22:49:05 +0000 (Sun, 16 Dec 2012)
New Revision: 2592
Log:
Fix an assert in s390 disassembly. Eliminate a few magic array
width constants and use S390_MAX_MNEMONIC_LEN instead.
New function "mnemonic" to construct a mnemonic string padded with
blanks for alignment.
Modified files:
trunk/priv/guest_s390_toIR.c
trunk/priv/s390_disasm.c
Modified: trunk/priv/guest_s390_toIR.c (+6 -6)
===================================================================
--- trunk/priv/guest_s390_toIR.c 2012-12-16 22:44:32 +00:00 (rev 2591)
+++ trunk/priv/guest_s390_toIR.c 2012-12-16 22:49:05 +00:00 (rev 2592)
@@ -9509,32 +9509,32 @@
case 0xd200000000000000ULL:
/* special case MVC */
s390_irgen_EX_SS(r1, addr2, s390_irgen_MVC_EX, 64);
- return "mvc via ex";
+ return "ex@mvc";
case 0xd500000000000000ULL:
/* special case CLC */
s390_irgen_EX_SS(r1, addr2, s390_irgen_CLC_EX, 64);
- return "clc via ex";
+ return "ex@clc";
case 0xd700000000000000ULL:
/* special case XC */
s390_irgen_EX_SS(r1, addr2, s390_irgen_XC_EX, 32);
- return "xc via ex";
+ return "ex@xc";
case 0xd600000000000000ULL:
/* special case OC */
s390_irgen_EX_SS(r1, addr2, s390_irgen_OC_EX, 32);
- return "oc via ex";
+ return "ex@oc";
case 0xd400000000000000ULL:
/* special case NC */
s390_irgen_EX_SS(r1, addr2, s390_irgen_NC_EX, 32);
- return "nc via ex";
+ return "ex@nc";
case 0xdc00000000000000ULL:
/* special case TR */
s390_irgen_EX_SS(r1, addr2, s390_irgen_TR_EX, 64);
- return "tr via ex";
+ return "ex@tr";
default:
{
Modified: trunk/priv/s390_disasm.c (+31 -11)
===================================================================
--- trunk/priv/s390_disasm.c 2012-12-16 22:44:32 +00:00 (rev 2591)
+++ trunk/priv/s390_disasm.c 2012-12-16 22:49:05 +00:00 (rev 2592)
@@ -36,10 +36,25 @@
#include "main_globals.h" // vex_traceflags
#include "s390_disasm.h"
-/* The format that is used to write out a mnemonic. */
-static const HChar s390_mnm_fmt[] = "%-8s";
+/* The length of the longest mnemonic: locgrnhe */
+#define S390_MAX_MNEMONIC_LEN 8
+/* Return the mnemonic padded with blanks to its right */
+static const HChar *
+mnemonic(const HChar *mnm)
+{
+ vex_printf("MNEMONIC = |%s|\n", mnm);
+ vassert(vex_strlen(mnm) <= S390_MAX_MNEMONIC_LEN);
+
+ static HChar buf[S390_MAX_MNEMONIC_LEN + 1];
+
+ vex_sprintf(buf, "%-*s", S390_MAX_MNEMONIC_LEN, mnm);
+
+ return buf;
+}
+
+
/* Return the name of a general purpose register for dis-assembly purposes. */
static const HChar *
gpr_operand(UInt archreg)
@@ -100,12 +115,15 @@
HChar *to;
const HChar *from;
- static HChar buf[10]; /* Maximum is 6 + 2 */
+ static HChar buf[S390_MAX_MNEMONIC_LEN + 1];
- static const HChar *suffix[] = {
+ static const HChar suffix[8][3] = {
"", "h", "l", "ne", "e", "nl", "nh", ""
};
+ /* Guard against buffer overflow */
+ vassert(vex_strlen(base) + sizeof suffix[0] <= sizeof buf);
+
/* strcpy(buf, from); */
for (from = base, to = buf; *from; ++from, ++to) {
*to = *from;
@@ -119,6 +137,7 @@
return buf;
}
+
/* Common function used to construct a mnemonic based on a condition code
mask. */
static const HChar *
@@ -127,7 +146,7 @@
HChar *to;
const HChar *from;
- static HChar buf[10];
+ static HChar buf[S390_MAX_MNEMONIC_LEN + 1];
static HChar mask_id[16][4] = {
"", /* 0 -> unused */
@@ -137,7 +156,8 @@
};
/* Guard against buffer overflow */
- vassert(vex_strlen(prefix) + vex_strlen(suffix) + sizeof mask_id[0] <= sizeof buf);
+ vassert(vex_strlen(prefix) + vex_strlen(suffix) +
+ sizeof mask_id[0] <= sizeof buf);
/* strcpy(buf, prefix); */
for (from = prefix, to = buf; *from; ++from, ++to) {
@@ -304,7 +324,7 @@
/* argument */
switch (argkind) {
case S390_ARG_MNM:
- p += vex_sprintf(p, s390_mnm_fmt, va_arg(args, HChar *));
+ p += vex_sprintf(p, "%s", mnemonic(va_arg(args, HChar *)));
separator = ' ';
continue;
@@ -320,7 +340,7 @@
case S390_XMNM_BCR:
mask = va_arg(args, UInt);
mnm = kind == S390_XMNM_BCR ? bcr_operand(mask) : bc_operand(mask);
- p += vex_sprintf(p, s390_mnm_fmt, mnm);
+ p += vex_sprintf(p, "%s", mnemonic(mnm));
/* mask == 0 is a NOP and has no argument */
if (mask == 0) goto done;
break;
@@ -329,7 +349,7 @@
case S390_XMNM_BRCL:
mask = va_arg(args, UInt);
mnm = kind == S390_XMNM_BRC ? brc_operand(mask) : brcl_operand(mask);
- p += vex_sprintf(p, s390_mnm_fmt, mnm);
+ p += vex_sprintf(p, "%s", mnemonic(mnm));
/* mask == 0 has no special mnemonic */
if (mask == 0) {
@@ -341,7 +361,7 @@
case S390_XMNM_CAB:
mnm = va_arg(args, HChar *);
mask = va_arg(args, UInt);
- p += vex_sprintf(p, s390_mnm_fmt, cab_operand(mnm, mask));
+ p += vex_sprintf(p, "%s", mnemonic(cab_operand(mnm, mask)));
break;
case S390_XMNM_LOCR:
@@ -352,7 +372,7 @@
case S390_XMNM_STOCG:
mask = va_arg(args, UInt);
mnm = cls_operand(kind, mask);
- p += vex_sprintf(p, s390_mnm_fmt, mnm);
+ p += vex_sprintf(p, "%s", mnemonic(mnm));
/* There are no special opcodes when mask == 0 or 15. In that case
the integer mask is appended as the final operand */
if (mask == 0 || mask == 15) mask_suffix = mask;
|
|
From: <sv...@va...> - 2012-12-16 22:44:40
|
florian 2012-12-16 22:44:32 +0000 (Sun, 16 Dec 2012)
New Revision: 2591
Log:
Teach vprintf_wrk about '*' as format width, in which case the width
is given in an argument.
Modified files:
trunk/priv/main_util.c
Modified: trunk/priv/main_util.c (+7 -2)
===================================================================
--- trunk/priv/main_util.c 2012-12-13 18:29:56 +00:00 (rev 2590)
+++ trunk/priv/main_util.c 2012-12-16 22:44:32 +00:00 (rev 2591)
@@ -366,9 +366,14 @@
format++;
padchar = '0';
}
- while (*format >= '0' && *format <= '9') {
- fwidth = fwidth * 10 + (*format - '0');
+ if (*format == '*') {
+ fwidth = va_arg(ap, Int);
format++;
+ } else {
+ while (*format >= '0' && *format <= '9') {
+ fwidth = fwidth * 10 + (*format - '0');
+ format++;
+ }
}
if (*format == 'l') {
format++;
|
|
From: <sv...@va...> - 2012-12-16 13:21:30
|
sewardj 2012-12-16 13:21:17 +0000 (Sun, 16 Dec 2012)
New Revision: 13183
Log:
Mostly complete code for instrumentation of origin tracking for
guarded loads and stores. Still lacks proper setting of defaults in
the helper calls.
Modified files:
branches/COMEM/memcheck/mc_translate.c
Modified: branches/COMEM/memcheck/mc_translate.c (+122 -30)
===================================================================
--- branches/COMEM/memcheck/mc_translate.c 2012-12-16 09:52:38 +00:00 (rev 13182)
+++ branches/COMEM/memcheck/mc_translate.c 2012-12-16 13:21:17 +00:00 (rev 13183)
@@ -4112,7 +4112,7 @@
/* The most general handler for guarded loads. Assumes the
definedness of GUARD and ADDR have already been checked by the
- caller. A GUARD of NULL it is assumed to mean "always True".
+ caller. A GUARD of NULL is assumed to mean "always True".
Generate IR to do a shadow load from ADDR and return the V bits.
The loaded type is TY. The loaded data is then (shadow) widened by
@@ -6055,8 +6055,18 @@
return assignNew( 'B', mce, Ity_I32, binop(Iop_Max32U, b1, b2) );
}
-static IRAtom* gen_load_b ( MCEnv* mce, Int szB,
- IRAtom* baseaddr, Int offset )
+
+/* Make a guarded origin load, with no special handling in the
+ didn't-happen case. A GUARD of NULL is assumed to mean "always
+ True".
+
+ Generate IR to do a shadow origins load from BASEADDR+OFFSET and
+ return the otag. The loaded size is SZB. If GUARD evaluates to
+ False at run time then the returned otag is zero.
+*/
+static IRAtom* gen_guarded_load_b ( MCEnv* mce, Int szB,
+ IRAtom* baseaddr,
+ Int offset, IRExpr* guard )
{
void* hFun;
const HChar* hName;
@@ -6099,6 +6109,7 @@
bTmp, 1/*regparms*/, hName, VG_(fnptr_to_fnentry)( hFun ),
mkIRExprVec_1( ea )
);
+ if (guard) di->guard = guard;
/* no need to mess with any annotations. This call accesses
neither guest state nor guest memory. */
stmt( 'B', mce, IRStmt_Dirty(di) );
@@ -6113,25 +6124,56 @@
}
}
-static IRAtom* gen_guarded_load_b ( MCEnv* mce, Int szB, IRAtom* baseaddr,
- Int offset, IRAtom* guard )
+
+/* Generate IR to do a shadow origins load from BASEADDR+OFFSET. The
+ loaded size is SZB. The load is regarded as unconditional (always
+ happens).
+*/
+static IRAtom* gen_load_b ( MCEnv* mce, Int szB, IRAtom* baseaddr,
+ Int offset )
{
- if (guard) {
- IRAtom *cond, *iffalse, *iftrue;
+ return gen_guarded_load_b(mce, szB, baseaddr, offset, NULL/*guard*/);
+}
- cond = assignNew('B', mce, Ity_I8, unop(Iop_1Uto8, guard));
- iftrue = assignNew('B', mce, Ity_I32,
- gen_load_b(mce, szB, baseaddr, offset));
- iffalse = mkU32(0);
- return assignNew('B', mce, Ity_I32, IRExpr_Mux0X(cond, iffalse, iftrue));
- }
+/* The most general handler for guarded origin loads. A GUARD of NULL
+ is assumed to mean "always True".
- return gen_load_b(mce, szB, baseaddr, offset);
+ Generate IR to do a shadow origin load from ADDR+BIAS and return
+ the B bits. The loaded type is TY. If GUARD evaluates to False at
+ run time then the returned B bits are simply BALT instead.
+*/
+static
+IRAtom* expr2ori_Load_guarded_General ( MCEnv* mce,
+ IRType ty,
+ IRAtom* addr, UInt bias,
+ IRAtom* guard, IRAtom* balt )
+{
+ /* If the guard evaluates to True, this will hold the loaded
+ origin. If the guard evaluates to False, this will be zero,
+ meaning "unknown origin", in which case we will have to replace
+ it using a Mux0X below. */
+ IRAtom* iftrue
+ = assignNew('B', mce, Ity_I32,
+ gen_guarded_load_b(mce, sizeofIRType(ty),
+ addr, bias, guard));
+ /* These are the bits we will return if the load doesn't take
+ place. */
+ IRAtom* iffalse
+ = balt;
+ /* Prepare the cond for the Mux0X. Convert a NULL cond into
+ something that iropt knows how to fold out later. */
+ IRAtom* cond
+ = guard == NULL
+ ? mkU8(1)
+ : assignNew('B', mce, Ity_I8, unop(Iop_1Uto8, guard));
+ /* And assemble the final result. */
+ return assignNew('B', mce, Ity_I32, IRExpr_Mux0X(cond, iffalse, iftrue));
}
-/* Generate a shadow store. guard :: Ity_I1 controls whether the
- store really happens; NULL means it unconditionally does. */
+
+/* Generate a shadow origins store. guard :: Ity_I1 controls whether
+ the store really happens; NULL means it unconditionally does. */
static void gen_store_b ( MCEnv* mce, Int szB,
IRAtom* baseaddr, Int offset, IRAtom* dataB,
IRAtom* guard )
@@ -6528,8 +6570,8 @@
}
/* handle possible 16-bit excess */
while (toDo >= 2) {
- gen_store_b( mce, 2, d->mAddr, d->mSize - toDo, curr,
- d->guard );
+ gen_store_b( mce, 2, d->mAddr, d->mSize - toDo, curr,
+ d->guard );
toDo -= 2;
}
/* chew off the remaining 8-bit chunk, if any */
@@ -6543,10 +6585,12 @@
}
-static void do_origins_Store ( MCEnv* mce,
- IREndness stEnd,
- IRExpr* stAddr,
- IRExpr* stData )
+/* Generate IR for origin shadowing for a general guarded store. */
+static void do_origins_Store_guarded ( MCEnv* mce,
+ IREndness stEnd,
+ IRExpr* stAddr,
+ IRExpr* stData,
+ IRExpr* guard )
{
Int dszB;
IRAtom* dataB;
@@ -6557,11 +6601,51 @@
tl_assert(isIRAtom(stData));
dszB = sizeofIRType( typeOfIRExpr(mce->sb->tyenv, stData ) );
dataB = schemeE( mce, stData );
- gen_store_b( mce, dszB, stAddr, 0/*offset*/, dataB,
- NULL/*guard*/ );
+ gen_store_b( mce, dszB, stAddr, 0/*offset*/, dataB, guard );
}
+/* Generate IR for origin shadowing for a plain store. */
+static void do_origins_Store_plain ( MCEnv* mce,
+ IREndness stEnd,
+ IRExpr* stAddr,
+ IRExpr* stData )
+{
+ do_origins_Store_guarded ( mce, stEnd, stAddr, stData,
+ NULL/*guard*/ );
+}
+
+
+/* ---- Dealing with LoadG/StoreG (not entirely simple) ---- */
+
+static void do_origins_StoreG ( MCEnv* mce, IRStoreG* sg )
+{
+ do_origins_Store_guarded( mce, sg->end, sg->addr,
+ sg->data, sg->guard );
+}
+
+static void do_origins_LoadG ( MCEnv* mce, IRLoadG* lg )
+{
+ IRType loadedTy = Ity_INVALID;
+ switch (lg->cvt) {
+ case ILGop_Ident32: loadedTy = Ity_I32; break;
+ case ILGop_16Uto32: loadedTy = Ity_I16; break;
+ case ILGop_16Sto32: loadedTy = Ity_I16; break;
+ case ILGop_8Uto32: loadedTy = Ity_I8; break;
+ case ILGop_8Sto32: loadedTy = Ity_I8; break;
+ default: VG_(tool_panic)("schemeS.IRLoadG");
+ }
+ IRAtom* ori_alt
+ = schemeE( mce,lg->alt );
+ IRAtom* ori_final
+ = expr2ori_Load_guarded_General(mce, loadedTy,
+ lg->addr, 0/*addr bias*/,
+ lg->guard, ori_alt );
+ /* And finally, bind the origin to the destination temporary. */
+ assign( 'B', mce, findShadowTmpB(mce, lg->dst), ori_final );
+}
+
+
static void schemeS ( MCEnv* mce, IRStmt* st )
{
tl_assert(MC_(clo_mc_level) == 3);
@@ -6609,11 +6693,19 @@
break;
case Ist_Store:
- do_origins_Store( mce, st->Ist.Store.end,
- st->Ist.Store.addr,
- st->Ist.Store.data );
+ do_origins_Store_plain( mce, st->Ist.Store.end,
+ st->Ist.Store.addr,
+ st->Ist.Store.data );
break;
+ case Ist_StoreG:
+ do_origins_StoreG( mce, st->Ist.StoreG.details );
+ break;
+
+ case Ist_LoadG:
+ do_origins_LoadG( mce, st->Ist.LoadG.details );
+ break;
+
case Ist_LLSC: {
/* In short: treat a load-linked like a normal load followed
by an assignment of the loaded (shadow) data the result
@@ -6631,9 +6723,9 @@
schemeE(mce, vanillaLoad));
} else {
/* Store conditional */
- do_origins_Store( mce, st->Ist.LLSC.end,
- st->Ist.LLSC.addr,
- st->Ist.LLSC.storedata );
+ do_origins_Store_plain( mce, st->Ist.LLSC.end,
+ st->Ist.LLSC.addr,
+ st->Ist.LLSC.storedata );
/* For the rationale behind this, see comments at the
place where the V-shadow for .result is constructed, in
do_shadow_LLSC. In short, we regard .result as
|
|
From: <sv...@va...> - 2012-12-16 09:52:46
|
tom 2012-12-16 09:52:38 +0000 (Sun, 16 Dec 2012)
New Revision: 13182
Log:
Make sure the stack pointer is properly aligned when invoking a
signal on amd64-linux systems.
The amd64 ABI describes the required alignment on function entry
as follows:
"In other words, the value (%rsp − 8) is always a multiple
of 16 when control is transferred to the function entry point.
So we need to 16 byte align and then subtract an extra 8 bytes
to achieve the correct alignment.
Patch from fj...@gm... to fix BZ#280114.
Modified files:
trunk/coregrind/m_sigframe/sigframe-amd64-linux.c
Modified: trunk/coregrind/m_sigframe/sigframe-amd64-linux.c (+1 -1)
===================================================================
--- trunk/coregrind/m_sigframe/sigframe-amd64-linux.c 2012-12-14 12:51:08 +00:00 (rev 13181)
+++ trunk/coregrind/m_sigframe/sigframe-amd64-linux.c 2012-12-16 09:52:38 +00:00 (rev 13182)
@@ -452,7 +452,7 @@
UWord err;
rsp -= sizeof(*frame);
- rsp = VG_ROUNDDN(rsp, 16);
+ rsp = VG_ROUNDDN(rsp, 16) - 8;
frame = (struct rt_sigframe *)rsp;
if (!extend(tst, rsp, sizeof(*frame)))
|