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
(3) |
|
2
(8) |
3
(19) |
4
(24) |
5
(23) |
6
(16) |
7
(33) |
8
(5) |
|
9
(4) |
10
(23) |
11
(22) |
12
(40) |
13
(30) |
14
(31) |
15
(17) |
|
16
(18) |
17
(20) |
18
(41) |
19
(36) |
20
(25) |
21
(8) |
22
(9) |
|
23
(17) |
24
(12) |
25
(15) |
26
(15) |
27
(16) |
28
(22) |
29
(6) |
|
30
(7) |
31
(10) |
|
|
|
|
|
|
From: <sv...@va...> - 2009-08-02 23:03:18
|
Author: njn
Date: 2009-08-03 00:03:06 +0100 (Mon, 03 Aug 2009)
New Revision: 10690
Log:
In the "Command:" line in the preamble, escape special chars such as ' ' and
'\\'.
Modified:
trunk/coregrind/m_main.c
trunk/none/tests/Makefile.am
Modified: trunk/coregrind/m_main.c
===================================================================
--- trunk/coregrind/m_main.c 2009-08-02 12:21:31 UTC (rev 10689)
+++ trunk/coregrind/m_main.c 2009-08-02 23:03:06 UTC (rev 10690)
@@ -958,6 +958,21 @@
/*=== Printing the preamble ===*/
/*====================================================================*/
+// Print the command, escaping any chars that require it.
+static void umsg_or_xml_arg(Char* arg,
+ UInt (*umsg_or_xml)( const HChar*, ... ) )
+{
+ SizeT len = VG_(strlen)(arg);
+ Char* special = " \\<>";
+ Int i;
+ for (i = 0; i < len; i++) {
+ if (VG_(strchr)(special, arg[i])) {
+ umsg_or_xml("\\"); // escape with a backslash if necessary
+ }
+ umsg_or_xml("%c", arg[i]);
+ }
+}
+
/* Ok, the logging sink is running now. Print a suitable preamble.
If logging to file or a socket, write details of parent PID and
command line args, to help people trying to interpret the
@@ -1030,7 +1045,7 @@
*/
umsg_or_xml("Command: ");
if (VG_(args_the_exename))
- umsg_or_xml("%s", VG_(args_the_exename));
+ umsg_or_xml_arg(VG_(args_the_exename), umsg_or_xml);
n = 0;
for (i = 0; i < VG_(sizeXA)( VG_(args_for_client) ); i++) {
HChar* s = *(HChar**)VG_(indexXA)( VG_(args_for_client), i );
@@ -1043,7 +1058,8 @@
VG_(umsg)("\n ");
n = slen;
}
- umsg_or_xml(" %s", s);
+ umsg_or_xml(" ");
+ umsg_or_xml_arg(s, umsg_or_xml);
}
umsg_or_xml("\n");
Modified: trunk/none/tests/Makefile.am
===================================================================
--- trunk/none/tests/Makefile.am 2009-08-02 12:21:31 UTC (rev 10689)
+++ trunk/none/tests/Makefile.am 2009-08-02 23:03:06 UTC (rev 10690)
@@ -57,6 +57,7 @@
cmdline4.stderr.exp cmdline4.vgtest \
cmdline5.stderr.exp cmdline5.vgtest \
cmdline6.stderr.exp cmdline6.vgtest \
+ cmd-with-special.stderr.exp cmd-with-special.vgtest \
coolo_sigaction.stderr.exp \
coolo_sigaction.stdout.exp coolo_sigaction.vgtest \
coolo_strlen.stderr.exp coolo_strlen.vgtest \
|
|
From: <sv...@va...> - 2009-08-02 14:35:59
|
Author: sewardj
Date: 2009-08-02 15:35:45 +0100 (Sun, 02 Aug 2009)
New Revision: 1913
Log:
Implement mfpvr (mfspr 287) (bug #201585).
Also, fix a type mismatch in the generated IR for mfspr 268/269 which
would have caused an IR checker assertion failure when handling those
insns on ppc64.
Modified:
trunk/priv/guest_ppc_defs.h
trunk/priv/guest_ppc_helpers.c
trunk/priv/guest_ppc_toIR.c
Modified: trunk/priv/guest_ppc_defs.h
===================================================================
--- trunk/priv/guest_ppc_defs.h 2009-07-22 11:06:17 UTC (rev 1912)
+++ trunk/priv/guest_ppc_defs.h 2009-08-02 14:35:45 UTC (rev 1913)
@@ -150,6 +150,8 @@
extern UInt ppc32g_dirtyhelper_MFSPR_268_269 ( UInt );
+extern UInt ppc32g_dirtyhelper_MFSPR_287 ( void );
+
extern void ppc32g_dirtyhelper_LVS ( VexGuestPPC32State* gst,
UInt vD_idx, UInt sh,
UInt shift_right );
Modified: trunk/priv/guest_ppc_helpers.c
===================================================================
--- trunk/priv/guest_ppc_helpers.c 2009-07-22 11:06:17 UTC (rev 1912)
+++ trunk/priv/guest_ppc_helpers.c 2009-08-02 14:35:45 UTC (rev 1913)
@@ -118,6 +118,20 @@
/* CALLED FROM GENERATED CODE */
+/* DIRTY HELPER (I'm not really sure what the side effects are) */
+UInt ppc32g_dirtyhelper_MFSPR_287 ( void )
+{
+# if defined(__powerpc__) || defined(_AIX)
+ UInt spr;
+ __asm__ __volatile__("mfspr %0,287" : "=b"(spr));
+ return spr;
+# else
+ return 0;
+# endif
+}
+
+
+/* CALLED FROM GENERATED CODE */
/* DIRTY HELPER (reads guest state, writes guest mem) */
void ppc32g_dirtyhelper_LVS ( VexGuestPPC32State* gst,
UInt vD_off, UInt sh, UInt shift_right )
Modified: trunk/priv/guest_ppc_toIR.c
===================================================================
--- trunk/priv/guest_ppc_toIR.c 2009-07-22 11:06:17 UTC (rev 1912)
+++ trunk/priv/guest_ppc_toIR.c 2009-08-02 14:35:45 UTC (rev 1913)
@@ -5471,11 +5471,33 @@
);
/* execute the dirty call, dumping the result in val. */
stmt( IRStmt_Dirty(d) );
- putIReg( rD_addr, mkexpr(val) );
+ putIReg( rD_addr,
+ mkWidenFrom32(ty, mkexpr(val), False/*unsigned*/) );
DIP("mfspr r%u,%u", rD_addr, (UInt)SPR);
break;
}
+ /* Again, runs natively on PPC7400 (7447, really). Not
+ bothering with a feature test. */
+ case 287: /* 0x11F */ {
+ IRTemp val = newTemp(Ity_I32);
+ IRExpr** args = mkIRExprVec_0();
+ IRDirty* d = unsafeIRDirty_1_N(
+ val,
+ 0/*regparms*/,
+ "ppc32g_dirtyhelper_MFSPR_287",
+ fnptr_to_fnentry
+ (vbi, &ppc32g_dirtyhelper_MFSPR_287),
+ args
+ );
+ /* execute the dirty call, dumping the result in val. */
+ stmt( IRStmt_Dirty(d) );
+ putIReg( rD_addr,
+ mkWidenFrom32(ty, mkexpr(val), False/*unsigned*/) );
+ DIP("mfspr r%u,%u", rD_addr, (UInt)SPR);
+ break;
+ }
+
default:
vex_printf("dis_proc_ctl(ppc)(mfspr,SPR)(0x%x)\n", SPR);
return False;
|
|
From: <sv...@va...> - 2009-08-02 12:22:18
|
Author: sewardj
Date: 2009-08-02 13:21:31 +0100 (Sun, 02 Aug 2009)
New Revision: 10689
Log:
Reinstating a heavily modified version of r10402. This is to do
with #190429.
This patch (originally from Jakub Jelinek) makes the redir of strlen
in ld.so on amd64-linux ld.so mandatory, but only for glibc 2.10 and
above. For glibc-2.2 (our earliest supported version) to glibc-2.9
it is still optional.
Also, makes more verbose, the message that is printed if a mandatory
ld.so redirection on Linux cannot be set up.
Is believed to fix #190429.
Modified:
trunk/coregrind/m_redir.c
trunk/coregrind/m_trampoline.S
trunk/coregrind/pub_core_trampoline.h
Modified: trunk/coregrind/m_redir.c
===================================================================
--- trunk/coregrind/m_redir.c 2009-08-02 10:16:03 UTC (rev 10688)
+++ trunk/coregrind/m_redir.c 2009-08-02 12:21:31 UTC (rev 10689)
@@ -223,8 +223,8 @@
HChar* from_fnpatt; /* from fnname pattern */
Addr to_addr; /* where redirecting to */
Bool isWrap; /* wrap or replacement? */
- const HChar* mandatory; /* non-NULL ==> abort V and print the
- string if from_sopatt is loaded but
+ HChar** mandatory; /* non-NULL ==> abort V and print the
+ strings if from_sopatt is loaded but
from_fnpatt cannot be found */
/* VARIABLE PARTS -- used transiently whilst processing redirections */
Bool mark; /* set if spec requires further processing */
@@ -555,6 +555,7 @@
break;
}
if (sp) {
+ HChar** strp;
HChar* v = "valgrind: ";
vg_assert(sp->mark);
vg_assert(!sp->done);
@@ -581,9 +582,12 @@
v, VG_(DebugInfo_get_soname)(di));
VG_(printf)(
"%s\n", v);
+
+ for (strp = sp->mandatory; *strp; strp++)
+ VG_(printf)(
+ "%s%s\n", v, *strp);
+
VG_(printf)(
- "%s%s\n", v, sp->mandatory);
- VG_(printf)(
"%s\n", v);
VG_(printf)(
"%sCannot continue -- exiting now. Sorry.\n", v);
@@ -809,7 +813,7 @@
__attribute__((unused)) /* not used on all platforms */
static void add_hardwired_spec ( HChar* sopatt, HChar* fnpatt,
Addr to_addr,
- const HChar* const mandatory )
+ HChar** mandatory )
{
Spec* spec = dinfo_zalloc("redir.ahs.1", sizeof(Spec));
vg_assert(spec);
@@ -838,6 +842,18 @@
}
+__attribute__((unused)) /* not used on all platforms */
+static const HChar* complain_about_stripped_glibc_ldso[]
+= { "Possible fixes: (1, short term): install glibc's debuginfo",
+ "package on this machine. (2, longer term): ask the packagers",
+ "for your Linux distribution to please in future ship a non-",
+ "stripped ld.so (or whatever the dynamic linker .so is called)",
+ "that exports the above-named function using the standard",
+ "calling conventions for this platform.",
+ NULL
+ };
+
+
/* Initialise the redir system, and create the initial Spec list and
for amd64-linux a couple of permanent active mappings. The initial
Specs are not converted into Actives yet, on the (checked)
@@ -880,11 +896,26 @@
(Addr)&VG_(amd64_linux_REDIR_FOR_vtime)
);
+ /* If we're using memcheck, use these intercepts right from
+ the start, otherwise ld.so makes a lot of noise. */
+ if (0==VG_(strcmp)("Memcheck", VG_(details).name)) {
+
+ add_hardwired_spec(
+ "ld-linux-x86-64.so.2", "strlen",
+ (Addr)&VG_(amd64_linux_REDIR_FOR_strlen),
+# if defined(GLIBC_2_2) || defined(GLIBC_2_3) || defined(GLIBC_2_4) \
+ || defined(GLIBC_2_5) || defined(GLIBC_2_6) || defined(GLIBC_2_7) \
+ || defined(GLIBC_2_8) || defined(GLIBC_2_9)
+ NULL
+# else
+ /* for glibc-2.10 and later, this is mandatory - can't sanely
+ continue without it */
+ complain_about_stripped_glibc_ldso
+# endif
+ );
+ }
+
# elif defined(VGP_ppc32_linux)
- {
- static const HChar croakage[]
- = "Possible fix: install glibc's debuginfo package on this machine.";
-
/* If we're using memcheck, use these intercepts right from
the start, otherwise ld.so makes a lot of noise. */
if (0==VG_(strcmp)("Memcheck", VG_(details).name)) {
@@ -893,7 +924,7 @@
add_hardwired_spec(
"ld.so.1", "strlen",
(Addr)&VG_(ppc32_linux_REDIR_FOR_strlen),
- croakage
+ complain_about_stripped_glibc_ldso
);
add_hardwired_spec(
"ld.so.1", "strcmp",
@@ -908,13 +939,8 @@
/* glibc-2.6.1 (openSUSE 10.3, ppc32) seems fine without it */
);
}
- }
# elif defined(VGP_ppc64_linux)
- {
- static const HChar croakage[]
- = "Possible fix: install glibc's debuginfo package on this machine.";
-
/* If we're using memcheck, use these intercepts right from
the start, otherwise ld.so makes a lot of noise. */
if (0==VG_(strcmp)("Memcheck", VG_(details).name)) {
@@ -923,7 +949,7 @@
add_hardwired_spec(
"ld64.so.1", "strlen",
(Addr)VG_(fnptr_to_fnentry)( &VG_(ppc64_linux_REDIR_FOR_strlen) ),
- croakage
+ complain_about_stripped_glibc_ldso
);
add_hardwired_spec(
@@ -933,7 +959,6 @@
/* glibc-2.5 (FC6, ppc64) seems fine without it */
);
}
- }
# elif defined(VGP_ppc32_aix5)
/* nothing so far */
@@ -955,11 +980,11 @@
(Addr)&VG_(darwin_REDIR_FOR_strcpy), NULL);
add_hardwired_spec("dyld", "strlcat",
(Addr)&VG_(darwin_REDIR_FOR_strlcat), NULL);
-#if defined(VGP_amd64_darwin)
+# if defined(VGP_amd64_darwin)
// DDD: #warning fixme rdar://6166275
add_hardwired_spec("dyld", "arc4random",
(Addr)&VG_(darwin_REDIR_FOR_arc4random), NULL);
-#endif
+# endif
}
# else
Modified: trunk/coregrind/m_trampoline.S
===================================================================
--- trunk/coregrind/m_trampoline.S 2009-08-02 10:16:03 UTC (rev 10688)
+++ trunk/coregrind/m_trampoline.S 2009-08-02 12:21:31 UTC (rev 10689)
@@ -168,7 +168,29 @@
.LfnE3:
.size VG_(amd64_linux_REDIR_FOR_vtime), .-.LfnB3
-/* A CIE for the above two functions, followed by their FDEs */
+/* There's no particular reason that this needs to be handwritten
+ assembly, but since that's what this file contains, here's a
+ simple strlen implementation (written in C and compiled by gcc.)
+*/
+.global VG_(amd64_linux_REDIR_FOR_strlen)
+.type VG_(amd64_linux_REDIR_FOR_strlen), @function
+VG_(amd64_linux_REDIR_FOR_strlen):
+.LfnB4:
+ xorl %eax, %eax
+ cmpb $0, (%rdi)
+ movq %rdi, %rdx
+ je .L41
+.L40: addq $1, %rdx
+ cmpb $0, (%rdx)
+ jne .L40
+ movq %rdx, %rax
+ subq %rdi, %rax
+.L41: ret
+.LfnE4:
+.size VG_(amd64_linux_REDIR_FOR_strlen), .-VG_(amd64_linux_REDIR_FOR_strlen)
+
+
+/* A CIE for the above three functions, followed by their FDEs */
.section .eh_frame,"a",@progbits
.Lframe1:
.long .LEcie1-.LScie1
@@ -206,6 +228,15 @@
.uleb128 0x0
.align 8
.LEfde3:
+.LSfde4:
+ .long .LEfde4-.LASfde4
+.LASfde4:
+ .long .LASfde4-.Lframe1
+ .long .LfnB4
+ .long .LfnE4-.LfnB4
+ .uleb128 0x0
+ .align 8
+.LEfde4:
.previous
.global VG_(trampoline_stuff_end)
Modified: trunk/coregrind/pub_core_trampoline.h
===================================================================
--- trunk/coregrind/pub_core_trampoline.h 2009-08-02 10:16:03 UTC (rev 10688)
+++ trunk/coregrind/pub_core_trampoline.h 2009-08-02 12:21:31 UTC (rev 10689)
@@ -66,6 +66,7 @@
extern void VG_(amd64_linux_SUBST_FOR_rt_sigreturn);
extern void VG_(amd64_linux_REDIR_FOR_vgettimeofday);
extern void VG_(amd64_linux_REDIR_FOR_vtime);
+extern UInt VG_(amd64_linux_REDIR_FOR_strlen)( void* );
#endif
#if defined(VGP_ppc32_linux)
|
|
From: <sv...@va...> - 2009-08-02 10:16:16
|
Author: sewardj
Date: 2009-08-02 11:16:03 +0100 (Sun, 02 Aug 2009)
New Revision: 10688
Log:
Change name of H1 history flag from --history-level=partial (which I can
never remember) to --history-level=approx.
Modified:
trunk/helgrind/hg_basics.h
trunk/helgrind/hg_main.c
Modified: trunk/helgrind/hg_basics.h
===================================================================
--- trunk/helgrind/hg_basics.h 2009-08-02 10:15:07 UTC (rev 10687)
+++ trunk/helgrind/hg_basics.h 2009-08-02 10:16:03 UTC (rev 10688)
@@ -78,7 +78,7 @@
0: "none": don't collect any history. Fastest, but means we can
only show one of the two stacks in a race.
- 1: "partial": collect one stack trace per (notional) segment, that
+ 1: "approx": collect one stack trace per (notional) segment, that
is, collect a stack trace for a thread every time its vector
clock changes. This faciliates showing the bounds of the
conflicting segment(s), with relatively small overhead.
Modified: trunk/helgrind/hg_main.c
===================================================================
--- trunk/helgrind/hg_main.c 2009-08-02 10:15:07 UTC (rev 10687)
+++ trunk/helgrind/hg_main.c 2009-08-02 10:16:03 UTC (rev 10688)
@@ -4169,7 +4169,7 @@
else if VG_XACT_CLO(arg, "--history-level=none",
HG_(clo_history_level), 0);
- else if VG_XACT_CLO(arg, "--history-level=partial",
+ else if VG_XACT_CLO(arg, "--history-level=approx",
HG_(clo_history_level), 1);
else if VG_XACT_CLO(arg, "--history-level=full",
HG_(clo_history_level), 2);
@@ -4211,9 +4211,9 @@
VG_(printf)(
" --track-lockorders=no|yes show lock ordering errors? [yes]\n"
" --history-level=none|partial|full [full]\n"
-" full: show both stack traces for a data race (can be very slow)\n"
-" partial: full trace for one thread, approx for the other (faster)\n"
-" none: only show trace for one thread in a race (fastest)\n"
+" full: show both stack traces for a data race (can be very slow)\n"
+" approx: full trace for one thread, approx for the other (faster)\n"
+" none: only show trace for one thread in a race (fastest)\n"
" --conflict-cache-size=N size of 'full' history cache [1000000]\n"
);
VG_(replacement_malloc_print_usage)();
|
|
From: <sv...@va...> - 2009-08-02 10:15:18
|
Author: sewardj
Date: 2009-08-02 11:15:07 +0100 (Sun, 02 Aug 2009)
New Revision: 10687
Log:
Attend to space leaks, to the extent that I can.
Modified:
trunk/helgrind/libhb_core.c
Modified: trunk/helgrind/libhb_core.c
===================================================================
--- trunk/helgrind/libhb_core.c 2009-08-02 09:34:35 UTC (rev 10686)
+++ trunk/helgrind/libhb_core.c 2009-08-02 10:15:07 UTC (rev 10687)
@@ -2886,8 +2886,13 @@
thr->viW = VtsID_INVALID;
thr->still_alive = True;
thr->filter = HG_(zalloc)( "libhb.Thr__new.2", sizeof(Filter) );
+ /* We only really need this at history level 1, but unfortunately
+ this routine is called before the command line processing is
+ done (sigh), so we can't rely on HG_(clo_history_level) at this
+ point. Hence always allocate it. Bah. */
thr->local_Kws_n_stacks
- = VG_(newXA)( HG_(zalloc), "libhb.Thr__new.3 (local_Kws_and_stacks)",
+ = VG_(newXA)( HG_(zalloc),
+ "libhb.Thr__new.3 (local_Kws_and_stacks)",
HG_(free), sizeof(ULong_n_EC) );
return thr;
}
@@ -5251,14 +5256,18 @@
void libhb_Thr_resumes ( Thr* thr )
{
if (0) VG_(printf)("resume %p\n", thr);
+ tl_assert(thr);
+ tl_assert(thr->still_alive);
Filter__clear(thr->filter, "libhb_Thr_resumes");
/* A kludge, but .. if this thread doesn't have any marker stacks
at all, get one right now. This is easier than figuring out
exactly when at thread startup we can and can't take a stack
snapshot. */
- tl_assert(thr->local_Kws_n_stacks);
- if (VG_(sizeXA)( thr->local_Kws_n_stacks ) == 0)
- note_local_Kw_n_stack_for(thr);
+ if (HG_(clo_history_level) == 1) {
+ tl_assert(thr->local_Kws_n_stacks);
+ if (VG_(sizeXA)( thr->local_Kws_n_stacks ) == 0)
+ note_local_Kw_n_stack_for(thr);
+ }
}
@@ -5521,8 +5530,24 @@
void libhb_async_exit ( Thr* thr )
{
tl_assert(thr);
+ tl_assert(thr->still_alive);
thr->still_alive = False;
- /* XXX free up Filter and local_Kws_n_stacks */
+
+ /* free up Filter and local_Kws_n_stacks (well, actually not the
+ latter ..) */
+ tl_assert(thr->filter);
+ HG_(free)(thr->filter);
+ thr->filter = NULL;
+
+ /* Another space-accuracy tradeoff. Do we want to be able to show
+ H1 history for conflicts in threads which have since exited? If
+ yes, then we better not free up thr->local_Kws_n_stacks. The
+ downside is a potential per-thread leak of up to
+ N_KWs_N_STACKs_PER_THREAD * sizeof(ULong_n_EC) * whatever the
+ XArray average overcommit factor is (1.5 I'd guess). */
+ // hence:
+ // VG_(deleteXA)(thr->local_Kws_n_stacks);
+ // thr->local_Kws_n_stacks = NULL;
}
/* Both Segs and SOs point to VTSs. However, there is no sharing, so
@@ -5583,9 +5608,10 @@
VtsID__rcdec(thr->viW);
thr->viR = VtsID__tick( thr->viR, thr );
thr->viW = VtsID__tick( thr->viW, thr );
- Filter__clear(thr->filter, "libhb_so_send");
- if (thr->still_alive)
+ if (thr->still_alive) {
+ Filter__clear(thr->filter, "libhb_so_send");
note_local_Kw_n_stack_for(thr);
+ }
VtsID__rcinc(thr->viR);
VtsID__rcinc(thr->viW);
|
|
From: <sv...@va...> - 2009-08-02 09:34:47
|
Author: sewardj
Date: 2009-08-02 10:34:35 +0100 (Sun, 02 Aug 2009)
New Revision: 10686
Log:
Small improvements, including some commenting, for the H1 history
mechanism.
Modified:
trunk/helgrind/libhb_core.c
Modified: trunk/helgrind/libhb_core.c
===================================================================
--- trunk/helgrind/libhb_core.c 2009-08-02 08:35:05 UTC (rev 10685)
+++ trunk/helgrind/libhb_core.c 2009-08-02 09:34:35 UTC (rev 10686)
@@ -2839,6 +2839,18 @@
// QQQ move this somewhere else
typedef struct { ULong ull; ExeContext* ec; } ULong_n_EC;
+/* How many of the above records to collect for each thread? Older
+ ones are dumped when we run out of space. 62.5k requires 1MB per
+ thread, since each ULong_n_EC record is 16 bytes long. When more
+ than N_KWs_N_STACKs_PER_THREAD are present, the older half are
+ deleted to make space. Hence in the worst case we will be able to
+ produce a stack at least for the last N_KWs_N_STACKs_PER_THREAD / 2
+ Kw transitions (segments in this thread). For the current setting
+ that gives a guaranteed stack for at least the last 31.25k
+ segments. */
+#define N_KWs_N_STACKs_PER_THREAD 62500
+
+
struct _Thr {
/* Current VTSs for this thread. They change as we go along. viR
is the VTS to be used for reads, viW for writes. Usually they
@@ -2861,11 +2873,11 @@
/* opaque (to us) data we hold on behalf of the library's user. */
void* opaque;
- /* The ULongs (scalar Krs) in this accumulate in strictly
+ /* The ULongs (scalar Kws) in this accumulate in strictly
increasing order, without duplicates. This is important because
- we need to be able to find a given scalar Kr in this array
+ we need to be able to find a given scalar Kw in this array
later, by binary search. */
- XArray* /* ULong_n_EC */ local_Krs_n_stacks;
+ XArray* /* ULong_n_EC */ local_Kws_n_stacks;
};
static Thr* Thr__new ( void ) {
@@ -2874,13 +2886,13 @@
thr->viW = VtsID_INVALID;
thr->still_alive = True;
thr->filter = HG_(zalloc)( "libhb.Thr__new.2", sizeof(Filter) );
- thr->local_Krs_n_stacks
- = VG_(newXA)( HG_(zalloc), "libhb.Thr__new.3 (local_Krs_and_stacks)",
+ thr->local_Kws_n_stacks
+ = VG_(newXA)( HG_(zalloc), "libhb.Thr__new.3 (local_Kws_and_stacks)",
HG_(free), sizeof(ULong_n_EC) );
return thr;
}
-static void note_local_Kr_n_stack_for ( Thr* thr )
+static void note_local_Kw_n_stack_for ( Thr* thr )
{
Word nPresent;
ULong_n_EC pair;
@@ -2890,38 +2902,38 @@
if (HG_(clo_history_level) != 1)
return;
- /* This is the scalar Kr for thr. */
- pair.ull = VtsID__indexAt( thr->viR, thr );
+ /* This is the scalar Kw for thr. */
+ pair.ull = VtsID__indexAt( thr->viW, thr );
pair.ec = main_get_EC( thr );
tl_assert(pair.ec);
- tl_assert(thr->local_Krs_n_stacks);
+ tl_assert(thr->local_Kws_n_stacks);
/* check that we're not adding duplicates */
- nPresent = VG_(sizeXA)( thr->local_Krs_n_stacks );
+ nPresent = VG_(sizeXA)( thr->local_Kws_n_stacks );
/* Throw away old stacks, if necessary. We can't accumulate stuff
indefinitely. */
- if (nPresent > 10000) {
- VG_(dropHeadXA)( thr->local_Krs_n_stacks, nPresent / 2 );
- nPresent = VG_(sizeXA)( thr->local_Krs_n_stacks );
- if (1)
- VG_(printf)("LOCAL Kr: thr %p, Kr %llu, ec %p (!!! gc !!!)\n",
+ if (nPresent >= N_KWs_N_STACKs_PER_THREAD) {
+ VG_(dropHeadXA)( thr->local_Kws_n_stacks, nPresent / 2 );
+ nPresent = VG_(sizeXA)( thr->local_Kws_n_stacks );
+ if (0)
+ VG_(printf)("LOCAL Kw: thr %p, Kw %llu, ec %p (!!! gc !!!)\n",
thr, pair.ull, pair.ec );
}
if (nPresent > 0) {
ULong_n_EC* prevPair
- = (ULong_n_EC*)VG_(indexXA)( thr->local_Krs_n_stacks, nPresent-1 );
- tl_assert( prevPair->ull < pair.ull );
+ = (ULong_n_EC*)VG_(indexXA)( thr->local_Kws_n_stacks, nPresent-1 );
+ tl_assert( prevPair->ull <= pair.ull );
}
if (nPresent == 0)
pair.ec = NULL;
- VG_(addToXA)( thr->local_Krs_n_stacks, &pair );
+ VG_(addToXA)( thr->local_Kws_n_stacks, &pair );
if (0)
- VG_(printf)("LOCAL Kr: thr %p, Kr %llu, ec %p\n",
+ VG_(printf)("LOCAL Kw: thr %p, Kw %llu, ec %p\n",
thr, pair.ull, pair.ec );
if (0)
VG_(pp_ExeContext)(pair.ec);
@@ -4047,10 +4059,56 @@
static ULong stats__msmcwrite = 0;
static ULong stats__msmcwrite_change = 0;
+/* Some notes on the H1 history mechanism:
+
+ Transition rules are:
+
+ read_{Kr,Kw}(Cr,Cw) = (Cr, Cr `join` Kw)
+ write_{Kr,Kw}(Cr,Cw) = (Cr `join` Kw, Cr `join` Kw)
+
+ After any access by a thread T to a location L, L's constraint pair
+ (Cr,Cw) has Cw[T] == T's Kw[T], that is, == T's scalar W-clock.
+
+ After a race by thread T conflicting with some previous access by
+ some other thread U, for a location with constraint (before
+ processing the later access) (Cr,Cw), then Cw[U] is the segment in
+ which the previously access lies.
+
+ Hence in record_race_info, we pass in Cfailed and Kfailed, which
+ are compared so as to find out which thread(s) this access
+ conflicts with. Once that is established, we also require the
+ pre-update Cw for the location, so we can index into it for those
+ threads, to get the scalar clock values for the point at which the
+ former accesses were made. (In fact we only bother to do any of
+ this for an arbitrarily chosen one of the conflicting threads, as
+ that's simpler, it avoids flooding the user with vast amounts of
+ mostly useless information, and because the program is wrong if it
+ contains any races at all -- so we don't really need to show all
+ conflicting access pairs initially, so long as we only show none if
+ none exist).
+
+ ---
+
+ That requires the auxiliary proof that
+
+ (Cr `join` Kw)[T] == Kw[T]
+
+ Why should that be true? Because for any thread T, Kw[T] >= the
+ scalar clock value for T known by any other thread. In other
+ words, because T's value for its own scalar clock is at least as up
+ to date as the value for it known by any other thread (that is true
+ for both the R- and W- scalar clocks). Hence no other thread will
+ be able to feed in a value for that element (indirectly via a
+ constraint) which will exceed Kw[T], and hence the join cannot
+ cause that particular element to advance.
+*/
+
__attribute__((noinline))
static void record_race_info ( Thr* acc_thr,
Addr acc_addr, SizeT szB, Bool isWrite,
- VtsID vtsConstraint, VtsID vtsKlock )
+ VtsID Cfailed,
+ VtsID Kfailed,
+ VtsID Cw )
{
/* Call here to report a race. We just hand it onwards to
HG_(record_error_Race). If that in turn discovers that the
@@ -4078,8 +4136,8 @@
/* At history_level 1, we must round up the relevant stack-pair
for the conflicting segment right now. This is because
- deferring it is complex; we can't (easily) put vtsKlock and
- vtsConstraint into the XError and wait for later without
+ deferring it is complex; we can't (easily) put Kfailed and
+ Cfailed into the XError and wait for later without
getting tied up in difficulties with VtsID reference
counting. So just do it now. */
Thr* confThr;
@@ -4087,9 +4145,12 @@
/* Which thread are we in conflict with? There may be more than
one, in which case VtsID__findFirst_notLEQ selects one arbitrarily
(in fact it's the one with the lowest Thr* value). */
- confThr = VtsID__findFirst_notLEQ( vtsConstraint, vtsKlock );
+ confThr = VtsID__findFirst_notLEQ( Cfailed, Kfailed );
/* This must exist! since if it was NULL then there's no
- conflict (semantics of return value of VtsID__findFirst_notLEQ) */
+ conflict (semantics of return value of
+ VtsID__findFirst_notLEQ), and msmc{read,write}, which has
+ called us, just checked exactly this -- that there was in
+ fact a race. */
tl_assert(confThr);
/* Get the scalar clock value that the conflicting thread
@@ -4098,7 +4159,7 @@
conflicting thread's scalar clock when it created this
constraint. Hence we know the scalar clock of the
conflicting thread when the conflicting access was made. */
- confTym = VtsID__indexAt( vtsConstraint, confThr );
+ confTym = VtsID__indexAt( Cfailed, confThr );
/* Using this scalar clock, index into the conflicting thread's
collection of stack traces made each time its vector clock
@@ -4109,34 +4170,39 @@
key.ull = confTym;
key.ec = NULL;
/* tl_assert(confThr); -- asserted just above */
- tl_assert(confThr->local_Krs_n_stacks);
+ tl_assert(confThr->local_Kws_n_stacks);
firstIx = lastIx = 0;
found = VG_(lookupXA_UNSAFE)(
- confThr->local_Krs_n_stacks,
+ confThr->local_Kws_n_stacks,
&key, &firstIx, &lastIx,
(Int(*)(void*,void*))cmp__ULong_n_EC__by_ULong
);
- if (0) VG_(printf)("record_race_info %u %u confThr %p "
+ if (0) VG_(printf)("record_race_info %u %u %u confThr %p "
"confTym %llu found %d (%lu,%lu)\n",
- vtsConstraint, vtsKlock,
+ Cfailed, Kfailed, Cw,
confThr, confTym, found, firstIx, lastIx);
/* We can't indefinitely collect stack traces at VTS
transitions, since we'd eventually run out of memory. Hence
- note_local_Kr_n_stack_for will eventually throw away old
+ note_local_Kw_n_stack_for will eventually throw away old
ones, which in turn means we might fail to find index value
confTym in the array. */
if (found) {
ULong_n_EC *pair_start, *pair_end;
pair_start
- = (ULong_n_EC*)VG_(indexXA)( confThr->local_Krs_n_stacks, lastIx );
+ = (ULong_n_EC*)VG_(indexXA)( confThr->local_Kws_n_stacks, lastIx );
hist1_seg_start = pair_start->ec;
- if (lastIx+1 < VG_(sizeXA)( confThr->local_Krs_n_stacks )) {
+ if (lastIx+1 < VG_(sizeXA)( confThr->local_Kws_n_stacks )) {
pair_end
- = (ULong_n_EC*)VG_(indexXA)( confThr->local_Krs_n_stacks,
+ = (ULong_n_EC*)VG_(indexXA)( confThr->local_Kws_n_stacks,
lastIx+1 );
/* from properties of VG_(lookupXA) and the comparison fn used: */
tl_assert(pair_start->ull < pair_end->ull);
hist1_seg_end = pair_end->ec;
+ /* Could do a bit better here. It may be that pair_end
+ doesn't have a stack, but the following entries in the
+ array have the same scalar Kw and to have a stack. So
+ we should search a bit further along the array than
+ lastIx+1 if hist1_seg_end is NULL. */
} else {
if (confThr->still_alive)
hist1_seg_end = main_get_EC( confThr );
@@ -4194,7 +4260,9 @@
// same as in non-race case
svNew = SVal__mkC( rmini, VtsID__join2(wmini, tviW) );
record_race_info( acc_thr, acc_addr, szB, False/*!isWrite*/,
- rmini, tviR );
+ rmini, /* Cfailed */
+ tviR, /* Kfailed */
+ wmini /* Cw */ );
goto out;
}
}
@@ -4265,7 +4333,9 @@
svNew = SVal__mkC( VtsID__join2(rmini, tviW),
VtsID__join2(wmini, tviW) );
record_race_info( acc_thr, acc_addr, szB, True/*isWrite*/,
- wmini, acc_thr->viW );
+ wmini, /* Cfailed */
+ tviW, /* Kfailed */
+ wmini /* Cw */ );
goto out;
}
}
@@ -5186,9 +5256,9 @@
at all, get one right now. This is easier than figuring out
exactly when at thread startup we can and can't take a stack
snapshot. */
- tl_assert(thr->local_Krs_n_stacks);
- if (VG_(sizeXA)( thr->local_Krs_n_stacks ) == 0)
- note_local_Kr_n_stack_for(thr);
+ tl_assert(thr->local_Kws_n_stacks);
+ if (VG_(sizeXA)( thr->local_Kws_n_stacks ) == 0)
+ note_local_Kw_n_stack_for(thr);
}
@@ -5300,7 +5370,7 @@
Filter__clear(child->filter, "libhb_create(child)");
VtsID__rcinc(child->viR);
VtsID__rcinc(child->viW);
- /* We need to do note_local_Kr_n_stack_for( child ), but it's too
+ /* We need to do note_local_Kw_n_stack_for( child ), but it's too
early for that - it may not have a valid TId yet. So, let
libhb_Thr_resumes pick it up the first time the thread runs. */
@@ -5315,7 +5385,7 @@
Filter__clear(parent->filter, "libhb_create(parent)");
VtsID__rcinc(parent->viR);
VtsID__rcinc(parent->viW);
- note_local_Kr_n_stack_for( parent );
+ note_local_Kw_n_stack_for( parent );
show_thread_state(" child", child);
show_thread_state("parent", parent);
@@ -5452,7 +5522,7 @@
{
tl_assert(thr);
thr->still_alive = False;
- /* XXX free up Filter and local_Krs_n_stacks */
+ /* XXX free up Filter and local_Kws_n_stacks */
}
/* Both Segs and SOs point to VTSs. However, there is no sharing, so
@@ -5515,7 +5585,7 @@
thr->viW = VtsID__tick( thr->viW, thr );
Filter__clear(thr->filter, "libhb_so_send");
if (thr->still_alive)
- note_local_Kr_n_stack_for(thr);
+ note_local_Kw_n_stack_for(thr);
VtsID__rcinc(thr->viR);
VtsID__rcinc(thr->viW);
@@ -5564,7 +5634,7 @@
}
Filter__clear(thr->filter, "libhb_so_recv");
- note_local_Kr_n_stack_for(thr);
+ note_local_Kw_n_stack_for(thr);
if (strong_recv)
show_thread_state("s-recv", thr);
|
|
From: <sv...@va...> - 2009-08-02 08:35:24
|
Author: bart
Date: 2009-08-02 09:35:05 +0100 (Sun, 02 Aug 2009)
New Revision: 10685
Log:
Restored two of the suppression patterns removed in the previous commit.
Modified:
trunk/glibc-2.X-drd.supp
Modified: trunk/glibc-2.X-drd.supp
===================================================================
--- trunk/glibc-2.X-drd.supp 2009-08-02 07:46:43 UTC (rev 10684)
+++ trunk/glibc-2.X-drd.supp 2009-08-02 08:35:05 UTC (rev 10685)
@@ -52,12 +52,24 @@
fun:pthread_create*
}
{
- drd-libpthread
+ drd-libpthread-pthread_join
drd:ConflictingAccess
+ fun:pthread_join
+ fun:pthread_join
+}
+{
+ drd-libpthread-__deallocate_stack
+ drd:ConflictingAccess
...
fun:__deallocate_stack
}
{
+ drd-libpthread-__free_tcb
+ drd:ConflictingAccess
+ ...
+ fun:__free_tcb
+}
+{
drd-libpthread-pthread_detach
drd:ConflictingAccess
fun:pthread_detach
|
|
From: <sv...@va...> - 2009-08-02 07:46:55
|
Author: bart
Date: 2009-08-02 08:46:43 +0100 (Sun, 02 Aug 2009)
New Revision: 10684
Log:
Cleaned up DRD's Linux suppression patterns:
- Grouped the three suppression patterns for ld into a single suppression
pattern.
- Assigned more descriptive names to the suppression patterns.
- Improved suppression pattern documentation.
- Removed suppression patterns that were added before VEX supported atomic
instructions and that are no longer necessary with the current version
of VEX.
Modified:
trunk/glibc-2.X-drd.supp
Modified: trunk/glibc-2.X-drd.supp
===================================================================
--- trunk/glibc-2.X-drd.supp 2009-07-31 19:00:05 UTC (rev 10683)
+++ trunk/glibc-2.X-drd.supp 2009-08-02 07:46:43 UTC (rev 10684)
@@ -1,264 +1,100 @@
+#
+# Suppression patterns for ld, the dynamic loader.
+#
+
+# Suppress all data races triggered by ld.
{
- dl
+ drd-ld
drd:ConflictingAccess
- fun:_dl_fixup
- fun:_dl_runtime_resolve
-}
-{
- dl
- drd:ConflictingAccess
- fun:_dl_fini
- fun:exit
-}
-{
- dl-2.6.*
- drd:ConflictingAccess
obj:/lib*/ld-*.so
}
+
+#
+# Suppression patterns for libc.
+#
+
+# Suppress all data races where the topmost frame is inside libc.so. Although
+# this could hide some real data races, unfortunately this is the only way to
+# not report any false positives on stdio functions. The glibc functions
+# manipulating FILE objects use locking primitives that cannot be intercepted
+# easily. See also the definitions of _IO_lock_lock() etc. in the file
+# nptl/sysdeps/pthread/bits/stdio-lock.h in the glibc source tree.
{
- dl-dlsym-1
+ drd-libc-stdio
drd:ConflictingAccess
- ...
- fun:_dl_sym
-}
-{
- dl-dlsym-2
- drd:ConflictingAccess
- ...
- fun:dlsym
-}
-{
- dl-dlsym-3
- drd:ConflictingAccess
- ...
- fun:__libc_dlsym
-}
-{
- dl-backtrace_symbols
- drd:ConflictingAccess
- fun:_dl_addr
- fun:backtrace_symbols
-}
-{
- libc-stdio
- drd:ConflictingAccess
obj:/lib*/libc-*
}
+
+#
+# Suppression patterns for libstdc++, the implementation of the standard C++
+# library included with the gcc compiler.
+#
+# Note: several versions of the libstdc++ library (4.2.2, 4.3.2, 4.4.0, 4.5.0
+# and their predecessors) contain an implementation of the std::string class
+# that triggers conflicting memory accesses. See also
+# http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40518
+#
+
+# {
+# drd-libstdc++-std::string::string()
+# drd:ConflictingAccess
+# fun:_ZNSsC1ERKSs
+# }
+
+#
+# Suppression patterns for libpthread.
+#
+
{
- libc
+ drd-libpthread-pthread_create
drd:ConflictingAccess
- fun:__libc_enable_asynccancel
- obj:/lib*/libc-*
-}
-{
- libc
- drd:ConflictingAccess
- fun:__libc_disable_asynccancel
- obj:/lib*/libc-*
-}
-{
- libc-exit-io-cleanup
- drd:ConflictingAccess
...
- fun:exit
-}
-{
- libc-random_r
- drd:ConflictingAccess
- fun:random_r
-}
-{
- libc:stdio
- drd:ConflictingAccess
- ...
- fun:_IO_file_xsputn*
- fun:vfprintf
-}
-{
- libc:stdio
- drd:ConflictingAccess
- ...
- fun:fflush
-}
-{
- librt
- drd:ConflictingAccess
- fun:__librt_enable_asynccancel
-}
-{
- librt
- drd:ConflictingAccess
- fun:__librt_disable_asynccancel
-}
-{
- libstdc++
- drd:ConflictingAccess
- fun:_ZN9__gnu_cxx12__atomic_addEPVii
-}
-{
- libstdc++ std::string::string()
- drd:ConflictingAccess
- fun:_ZNSsC1ERKSs
-}
-{
- libstdc++
- drd:ConflictingAccess
- fun:_ZN9__gnu_cxx18__exchange_and_addEPVii
-}
-{
- pthread
- drd:ConflictingAccess
- fun:start_thread
- fun:clone
-}
-{
- pthread
- drd:ConflictingAccess
- obj:/lib*/libpthread-*.so
- fun:start_thread
- fun:clone
-}
-{
- pthread
- drd:ConflictingAccess
- ...
fun:pthread_create*
}
{
- pthread
+ drd-libpthread
drd:ConflictingAccess
...
- fun:__libc_thread_freeres
- fun:start_thread
- fun:clone
-}
-{
- pthread
- drd:ConflictingAccess
- fun:__nptl_deallocate_tsd
- fun:start_thread
- fun:clone
-}
-{
- pthread
- drd:ConflictingAccess
- fun:pthread_mutex_lock
- fun:pthread_mutex_lock
-}
-{
- pthread
- drd:ConflictingAccess
- fun:__pthread_mutex_cond_lock
- fun:pthread_cond_wait@@GLIBC_*
-}
-{
- pthread
- drd:ConflictingAccess
- fun:pthread_join
- fun:pthread_join
-}
-{
- pthread
- drd:ConflictingAccess
- ...
fun:__deallocate_stack
}
{
- pthread
+ drd-libpthread-pthread_detach
drd:ConflictingAccess
- ...
- fun:__free_tcb
-}
-{
- pthread
- drd:ConflictingAccess
- fun:__pthread_enable_asynccancel
-}
-{
- pthread
- drd:ConflictingAccess
- fun:__pthread_disable_asynccancel
-}
-{
- pthread
- drd:ConflictingAccess
- fun:pthread_cancel
-}
-{
- pthread
- drd:ConflictingAccess
- ...
- fun:pthread_cancel_init
-}
-{
- pthread
- drd:ConflictingAccess
- fun:sigcancel_handler
- obj:/lib*/libpthread-*
-}
-{
- pthread
- drd:ConflictingAccess
fun:pthread_detach
fun:pthread_detach
}
{
- pthread
+ drd-libpthread-_Unwind_ForcedUnwind
drd:ConflictingAccess
- fun:pthread_getspecific
-}
-{
- pthread
- drd:ConflictingAccess
- fun:pthread_setspecific
-}
-{
- pthread
- drd:ConflictingAccess
- fun:pthread_key_delete
-}
-{
- pthread
- drd:ConflictingAccess
- fun:_pthread_cleanup_push_defer
-}
-{
- pthread-unwind
- drd:ConflictingAccess
...
- fun:__pthread_unwind
+ fun:_Unwind_ForcedUnwind
}
{
- pthread-unwind
+ drd-libpthread-_Unwind_Resume
drd:ConflictingAccess
...
fun:_Unwind_Resume
}
+
+#
+# Suppression patterns for libgomp.
+#
+
+# Unfortunately many statements in libgomp trigger conflicting accesses. It is
+# not clear to me which of these are safe and which ones not. See also
+# http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40362
{
- pthread-unwind
+ drd-libgomp
drd:ConflictingAccess
- fun:_Unwind_GetCFA
- fun:unwind_stop
-}
-{
- pthread-unwind
- drd:ConflictingAccess
- ...
- fun:_Unwind_ForcedUnwind
-}
-{
- pthread-unwind
- drd:ConflictingAccess
- ...
- fun:_Unwind_ForcedUnwind_Phase2
-}
-{
- gomp
- drd:ConflictingAccess
obj:/usr/lib*/libgomp.so*
}
+
+#
+# Suppression patterns for libX11.
+#
+
{
- libX11-XCreateFontSet
+ drd-libX11-XCreateFontSet
drd:CondErr
fun:pthread_cond_init*
fun:_XReply
@@ -267,21 +103,31 @@
fun:XCreateOC
fun:XCreateFontSet
}
+
+#
+# Suppression patterns for libxcb.
+#
+
{
- libxcb-xcb_wait_for_reply
+ drd-libxcb-xcb_wait_for_reply
drd:CondErr
fun:pthread_cond_destroy*
fun:xcb_wait_for_reply
}
+
+#
+# Suppression patterns for libglib.
+#
+
{
- libglib-access-g_threads_got_initialized
+ drd-libglib-access-g_threads_got_initialized
drd:ConflictingAccess
...
fun:g_slice_alloc
fun:g_ptr_array_sized_new
}
{
- libglib-access-g_threads_got_initialized
+ drd-libglib-access-g_threads_got_initialized
drd:ConflictingAccess
fun:_ZN27QEventDispatcherGlibPrivateC1EP13_GMainContext
fun:_ZN20QEventDispatcherGlibC1EP7QObject
@@ -289,48 +135,53 @@
obj:/usr/lib*/libQtCore.so.4.*
}
{
- libglib-access-g_mem_initialized
+ drd-libglib-access-g_mem_initialized
drd:ConflictingAccess
fun:g_malloc0
}
{
- libglib-g_private_get_posix_impl
+ drd-libglib-g_private_get_posix_impl
drd:ConflictingAccess
fun:g_private_get_posix_impl
}
{
- libglib-g_private_set_posix_impl
+ drd-libglib-g_private_set_posix_impl
drd:ConflictingAccess
fun:g_private_set_posix_impl
}
{
- libglib-g_get_language_names
+ drd-libglib-g_get_language_names
drd:ConflictingAccess
fun:g_slice_free_chain_with_offset
}
+
+#
+# Suppression patterns for libQtCore.
+#
+
{
- libQtCore-deref-that-calls-QThreadData-destructor
+ drd-libQtCore-deref-that-calls-QThreadData-destructor
drd:ConflictingAccess
fun:_ZN11QThreadDataD1Ev
fun:_ZN11QThreadData5derefEv
obj:/usr/lib*/libQtCore.so.4.*
}
{
- libQtCore-4.0/4.1-Q_GLOBAL_STATIC-connectionList
+ drd-libQtCore-4.0/4.1-Q_GLOBAL_STATIC-connectionList
drd:ConflictingAccess
obj:/usr/lib*/libQtCore.so.4.*
fun:_ZN11QMetaObject8activateEP7QObjectiiPPv
fun:_ZN11QMetaObject8activateEP7QObjectPKS_iPPv
}
{
- libQtCore-QObjectPrivate::clearGuards(QObject*)
+ drd-libQtCore-QObjectPrivate::clearGuards(QObject*)
drd:ConflictingAccess
fun:_ZN14QReadWriteLock12lockForWriteEv
fun:_ZN14QObjectPrivate11clearGuardsEP7QObject
fun:_ZN7QObjectD2Ev
}
{
- libQtCore-QObjectPrivate::clearGuards(QObject*)
+ drd-libQtCore-QObjectPrivate::clearGuards(QObject*)
drd:ConflictingAccess
fun:_ZN14QReadWriteLock12lockForWriteEv
fun:_ZN12QWriteLocker6relockEv
@@ -340,10 +191,18 @@
fun:_ZN24QAbstractEventDispatcherD2Ev
fun:_ZN20QEventDispatcherGlibD0Ev
}
+
+#
+# Suppression patterns for libboost.
+#
+
+# Suppress the races on boost::once_flag::epoch and on
+# boost::detail::once_global_epoch. See also the source file
+# boost/thread/pthread/once.hpp in the Boost source tree.
{
- libboost_thread_1
+ drd-libboost-boost::call_once<void (*)()>(boost::once_flag&, void (*)())
drd:ConflictingAccess
...
fun:_ZN5boost9call_onceIPFvvEEEvRNS_9once_flagET_
- fun:_ZN5boost6detail23get_current_thread_dataEv
}
+
|