Import thrcheck from the THRCHECK branch, and rename it Helgrind (with
permission of the existing Helgrind authors).
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@7116 a5019735-40e9-0310-863c-91ae7b9d1cf9
diff --git a/helgrind/Makefile.am b/helgrind/Makefile.am
new file mode 100644
index 0000000..4a9d93d
--- /dev/null
+++ b/helgrind/Makefile.am
@@ -0,0 +1,121 @@
+include $(top_srcdir)/Makefile.tool.am
+
+noinst_PROGRAMS =
+if VGP_X86_LINUX
+noinst_PROGRAMS += helgrind-x86-linux vgpreload_helgrind-x86-linux.so
+endif
+if VGP_AMD64_LINUX
+noinst_PROGRAMS += helgrind-amd64-linux vgpreload_helgrind-amd64-linux.so
+endif
+if VGP_PPC32_LINUX
+noinst_PROGRAMS += helgrind-ppc32-linux vgpreload_helgrind-ppc32-linux.so
+endif
+if VGP_PPC64_LINUX
+noinst_PROGRAMS += helgrind-ppc64-linux vgpreload_helgrind-ppc64-linux.so
+endif
+if VGP_PPC32_AIX5
+noinst_PROGRAMS += helgrind-ppc32-aix5 vgpreload_helgrind-ppc32-aix5.so
+endif
+if VGP_PPC64_AIX5
+noinst_PROGRAMS += helgrind-ppc64-aix5 vgpreload_helgrind-ppc64-aix5.so
+endif
+
+VGPRELOAD_HELGRIND_SOURCES_COMMON = hg_intercepts.c
+
+vgpreload_helgrind_x86_linux_so_SOURCES = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_x86_linux_so_CPPFLAGS = $(AM_CPPFLAGS_X86_LINUX) -O -g -fno-omit-frame-pointer
+vgpreload_helgrind_x86_linux_so_CFLAGS = $(AM_CFLAGS_X86_LINUX) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_x86_linux_so_DEPENDENCIES = $(LIBREPLACEMALLOC_X86_LINUX)
+vgpreload_helgrind_x86_linux_so_LDFLAGS = \
+ $(PRELOAD_LDFLAGS_X86_LINUX) \
+ $(LIBREPLACEMALLOC_LDFLAGS_X86_LINUX)
+
+vgpreload_helgrind_amd64_linux_so_SOURCES = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_amd64_linux_so_CPPFLAGS = $(AM_CPPFLAGS_AMD64_LINUX) -O -g
+vgpreload_helgrind_amd64_linux_so_CFLAGS = $(AM_CFLAGS_AMD64_LINUX) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_amd64_linux_so_DEPENDENCIES = $(LIBREPLACEMALLOC_AMD64_LINUX)
+vgpreload_helgrind_amd64_linux_so_LDFLAGS = \
+ $(PRELOAD_LDFLAGS_AMD64_LINUX) \
+ $(LIBREPLACEMALLOC_LDFLAGS_AMD64_LINUX)
+
+vgpreload_helgrind_ppc32_linux_so_SOURCES = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_ppc32_linux_so_CPPFLAGS = $(AM_CPPFLAGS_PPC32_LINUX) -O -g
+vgpreload_helgrind_ppc32_linux_so_CFLAGS = $(AM_CFLAGS_PPC32_LINUX) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_ppc32_linux_so_DEPENDENCIES = $(LIBREPLACEMALLOC_PPC32_LINUX)
+vgpreload_helgrind_ppc32_linux_so_LDFLAGS = \
+ $(PRELOAD_LDFLAGS_PPC32_LINUX) \
+ $(LIBREPLACEMALLOC_LDFLAGS_PPC32_LINUX)
+
+vgpreload_helgrind_ppc64_linux_so_SOURCES = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_ppc64_linux_so_CPPFLAGS = $(AM_CPPFLAGS_PPC64_LINUX) -O -g
+vgpreload_helgrind_ppc64_linux_so_CFLAGS = $(AM_CFLAGS_PPC64_LINUX) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_ppc64_linux_so_DEPENDENCIES = $(LIBREPLACEMALLOC_PPC64_LINUX)
+vgpreload_helgrind_ppc64_linux_so_LDFLAGS = \
+ $(PRELOAD_LDFLAGS_PPC64_LINUX) \
+ $(LIBREPLACEMALLOC_LDFLAGS_PPC64_LINUX)
+
+vgpreload_helgrind_ppc32_aix5_so_SOURCES = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_ppc32_aix5_so_CPPFLAGS = $(AM_CPPFLAGS_PPC32_AIX5) -O -g
+vgpreload_helgrind_ppc32_aix5_so_CFLAGS = $(AM_CFLAGS_PPC32_AIX5) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_ppc32_aix5_so_DEPENDENCIES = $(LIBREPLACEMALLOC_PPC32_AIX5)
+vgpreload_helgrind_ppc32_aix5_so_LDFLAGS = \
+ $(PRELOAD_LDFLAGS_PPC32_AIX5) \
+ $(LIBREPLACEMALLOC_LDFLAGS_PPC32_AIX5)
+
+vgpreload_helgrind_ppc64_aix5_so_SOURCES = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_ppc64_aix5_so_CPPFLAGS = $(AM_CPPFLAGS_PPC64_AIX5) -O -g
+vgpreload_helgrind_ppc64_aix5_so_CFLAGS = $(AM_CFLAGS_PPC64_AIX5) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_ppc64_aix5_so_DEPENDENCIES = $(LIBREPLACEMALLOC_PPC64_AIX5)
+vgpreload_helgrind_ppc64_aix5_so_LDFLAGS = \
+ $(PRELOAD_LDFLAGS_PPC64_AIX5) \
+ $(LIBREPLACEMALLOC_LDFLAGS_PPC64_AIX5)
+
+HELGRIND_SOURCES_COMMON = hg_wordfm.c hg_wordset.c hg_main.c
+
+helgrind_x86_linux_SOURCES = $(HELGRIND_SOURCES_COMMON)
+helgrind_x86_linux_CPPFLAGS = $(AM_CPPFLAGS_X86_LINUX)
+helgrind_x86_linux_CFLAGS = $(AM_CFLAGS_X86_LINUX) -O2
+helgrind_x86_linux_DEPENDENCIES = $(COREGRIND_LIBS_X86_LINUX)
+helgrind_x86_linux_LDADD = $(TOOL_LDADD_X86_LINUX)
+helgrind_x86_linux_LDFLAGS = $(TOOL_LDFLAGS_X86_LINUX)
+
+helgrind_amd64_linux_SOURCES = $(HELGRIND_SOURCES_COMMON)
+helgrind_amd64_linux_CPPFLAGS = $(AM_CPPFLAGS_AMD64_LINUX)
+helgrind_amd64_linux_CFLAGS = $(AM_CFLAGS_AMD64_LINUX) -O2
+helgrind_amd64_linux_DEPENDENCIES = $(COREGRIND_LIBS_AMD64_LINUX)
+helgrind_amd64_linux_LDADD = $(TOOL_LDADD_AMD64_LINUX)
+helgrind_amd64_linux_LDFLAGS = $(TOOL_LDFLAGS_AMD64_LINUX)
+
+helgrind_ppc32_linux_SOURCES = $(HELGRIND_SOURCES_COMMON)
+helgrind_ppc32_linux_CPPFLAGS = $(AM_CPPFLAGS_PPC32_LINUX)
+helgrind_ppc32_linux_CFLAGS = $(AM_CFLAGS_PPC32_LINUX) -O2
+helgrind_ppc32_linux_DEPENDENCIES = $(COREGRIND_LIBS_PPC32_LINUX)
+helgrind_ppc32_linux_LDADD = $(TOOL_LDADD_PPC32_LINUX)
+helgrind_ppc32_linux_LDFLAGS = $(TOOL_LDFLAGS_PPC32_LINUX)
+
+helgrind_ppc64_linux_SOURCES = $(HELGRIND_SOURCES_COMMON)
+helgrind_ppc64_linux_CPPFLAGS = $(AM_CPPFLAGS_PPC64_LINUX)
+helgrind_ppc64_linux_CFLAGS = $(AM_CFLAGS_PPC64_LINUX) -O2
+helgrind_ppc64_linux_DEPENDENCIES = $(COREGRIND_LIBS_PPC64_LINUX)
+helgrind_ppc64_linux_LDADD = $(TOOL_LDADD_PPC64_LINUX)
+helgrind_ppc64_linux_LDFLAGS = $(TOOL_LDFLAGS_PPC64_LINUX)
+
+helgrind_ppc32_aix5_SOURCES = $(HELGRIND_SOURCES_COMMON)
+helgrind_ppc32_aix5_CPPFLAGS = $(AM_CPPFLAGS_PPC32_AIX5)
+helgrind_ppc32_aix5_CFLAGS = $(AM_CFLAGS_PPC32_AIX5) -O2
+helgrind_ppc32_aix5_DEPENDENCIES = $(COREGRIND_LIBS_PPC32_AIX5)
+helgrind_ppc32_aix5_LDADD = $(TOOL_LDADD_PPC32_AIX5)
+helgrind_ppc32_aix5_LDFLAGS = $(TOOL_LDFLAGS_PPC32_AIX5)
+
+helgrind_ppc64_aix5_SOURCES = $(HELGRIND_SOURCES_COMMON)
+helgrind_ppc64_aix5_CPPFLAGS = $(AM_CPPFLAGS_PPC64_AIX5)
+helgrind_ppc64_aix5_CFLAGS = $(AM_CFLAGS_PPC64_AIX5) -O2
+helgrind_ppc64_aix5_DEPENDENCIES = $(COREGRIND_LIBS_PPC64_AIX5)
+helgrind_ppc64_aix5_LDADD = $(TOOL_LDADD_PPC64_AIX5)
+helgrind_ppc64_aix5_LDFLAGS = $(TOOL_LDFLAGS_PPC64_AIX5)
+
+hgincludedir = $(includedir)/valgrind
+
+hginclude_HEADERS = helgrind.h
+
+noinst_HEADERS = hg_wordfm.h hg_wordset.h
diff --git a/helgrind/docs/Makefile.am b/helgrind/docs/Makefile.am
new file mode 100644
index 0000000..84f630f
--- /dev/null
+++ b/helgrind/docs/Makefile.am
@@ -0,0 +1 @@
+EXTRA_DIST = hg-manual.xml
diff --git a/helgrind/docs/hg-manual.xml b/helgrind/docs/hg-manual.xml
new file mode 100644
index 0000000..5090cfc
--- /dev/null
+++ b/helgrind/docs/hg-manual.xml
@@ -0,0 +1,1311 @@
+<?xml version="1.0"?> <!-- -*- sgml -*- -->
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
+ "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
+
+
+<chapter id="tc-manual" xreflabel="Thrcheck: thread error detector">
+ <title>Thrcheck: a thread error detector</title>
+
+<para>To use this tool, you must specify
+<computeroutput>--tool=thrcheck</computeroutput> on the Valgrind
+command line.</para>
+
+
+
+
+<sect1 id="tc-manual.overview" xreflabel="Overview">
+<title>Overview</title>
+
+<para>Thrcheck is a Valgrind tool for detecting synchronisation errors
+in C, C++ and Fortran programs that use the POSIX pthreads
+threading primitives.</para>
+
+<para>The main abstractions in POSIX pthreads are: a set of threads
+sharing a common address space, thread creation, thread joinage,
+thread exit, mutexes (locks), condition variables (inter-thread event
+notifications), reader-writer locks, and semaphores.</para>
+
+<para>Thrcheck is aware of all these abstractions and tracks their
+effects as accurately as it can. Currently it does not correctly
+handle pthread barriers and pthread spinlocks, although it will not
+object if you use them. On x86 and amd64 platforms, it understands
+and partially handles implicit locking arising from the use of the
+LOCK instruction prefix.
+</para>
+
+<para>Thrcheck can detect three classes of errors, which are discussed
+in detail in the next three sections:</para>
+
+<orderedlist>
+ <listitem>
+ <para><link linkend="tc-manual.api-checks">
+ Misuses of the POSIX pthreads API.</link></para>
+ </listitem>
+ <listitem>
+ <para><link linkend="tc-manual.lock-orders">
+ Potential deadlocks arising from lock
+ ordering problems.</link></para>
+ </listitem>
+ <listitem>
+ <para><link linkend="tc-manual.data-races">
+ Data races -- accessing memory without adequate locking.
+ </link></para>
+ </listitem>
+</orderedlist>
+
+<para>Following those is a section containing
+<link linkend="tc-manual.effective-use">
+hints and tips on how to get the best out of Thrcheck.</link>
+</para>
+
+<para>Then there is a
+<link linkend="tc-manual.options">summary of command-line
+options.</link>
+</para>
+
+<para>Finally, there is
+<link linkend="tc-manual.todolist">a brief summary of areas in which Thrcheck
+could be improved.</link>
+</para>
+
+</sect1>
+
+
+
+
+<sect1 id="tc-manual.api-checks" xreflabel="API Checks">
+<title>Detected errors: Misuses of the POSIX pthreads API</title>
+
+<para>Thrcheck intercepts calls to many POSIX pthreads functions, and
+is therefore able to report on various common problems. Although
+these are unglamourous errors, their presence can lead to undefined
+program behaviour and hard-to-find bugs later in execution. The
+detected errors are:</para>
+
+<itemizedlist>
+ <listitem><para>unlocking an invalid mutex</para></listitem>
+ <listitem><para>unlocking a not-locked mutex</para></listitem>
+ <listitem><para>unlocking a mutex held by a different
+ thread</para></listitem>
+ <listitem><para>destroying an invalid or a locked mutex</para></listitem>
+ <listitem><para>recursively locking a non-recursive mutex</para></listitem>
+ <listitem><para>deallocation of memory that contains a
+ locked mutex</para></listitem>
+ <listitem><para>passing mutex arguments to functions expecting
+ reader-writer lock arguments, and vice
+ versa</para></listitem>
+ <listitem><para>when a POSIX pthread function fails with an
+ error code that must be handled</para></listitem>
+ <listitem><para>when a thread exits whilst still holding locked
+ locks</para></listitem>
+ <listitem><para>calling <computeroutput>pthread_cond_wait</computeroutput>
+ with a not-locked mutex, or one locked by a different
+ thread</para></listitem>
+</itemizedlist>
+
+<para>Checks pertaining to the validity of mutexes are generally also
+performed for reader-writer locks.</para>
+
+<para>Various kinds of this-can't-possibly-happen events are also
+reported. These usually indicate bugs in the system threading
+library.</para>
+
+<para>Reported errors always contain a primary stack trace indicating
+where the error was detected. They may also contain auxiliary stack
+traces giving additional information. In particular, most errors
+relating to mutexes will also tell you where that mutex first came to
+Thrcheck's attention (the "<computeroutput>was first observed
+at</computeroutput>" part), so you have a chance of figuring out which
+mutex it is referring to. For example:</para>
+
+<programlisting><![CDATA[
+Thread #1 unlocked a not-locked lock at 0x7FEFFFA90
+ at 0x4C2408D: pthread_mutex_unlock (tc_intercepts.c:492)
+ by 0x40073A: nearly_main (tc09_bad_unlock.c:27)
+ by 0x40079B: main (tc09_bad_unlock.c:50)
+ Lock at 0x7FEFFFA90 was first observed
+ at 0x4C25D01: pthread_mutex_init (tc_intercepts.c:326)
+ by 0x40071F: nearly_main (tc09_bad_unlock.c:23)
+ by 0x40079B: main (tc09_bad_unlock.c:50)
+]]></programlisting>
+
+<para>Thrcheck has a way of summarising thread identities, as
+evidenced here by the text "<computeroutput>Thread
+#1</computeroutput>". This is so that it can speak about threads and
+sets of threads without overwhelming you with details. See
+<link linkend="tc-manual.data-races.errmsgs">below</link>
+for more information on interpreting error messages.</para>
+
+</sect1>
+
+
+
+
+<sect1 id="tc-manual.lock-orders" xreflabel="Lock Orders">
+<title>Detected errors: Inconsistent Lock Orderings</title>
+
+<para>In this section, and in general, to "acquire" a lock simply
+means to lock that lock, and to "release" a lock means to unlock
+it.</para>
+
+<para>Thrcheck monitors the order in which threads acquire locks.
+This allows it to detect potential deadlocks which could arise from
+the formation of cycles of locks. Detecting such inconsistencies is
+useful because, whilst actual deadlocks are fairly obvious, potential
+deadlocks may never be discovered during testing and could later lead
+to hard-to-diagnose in-service failures.</para>
+
+<para>The simplest example of such a problem is as
+follows.</para>
+
+<itemizedlist>
+ <listitem><para>Imagine some shared resource R, which, for whatever
+ reason, is guarded by two locks, L1 and L2, which must both be held
+ when R is accessed.</para>
+ </listitem>
+ <listitem><para>Suppose a thread acquires L1, then L2, and proceeds
+ to access R. The implication of this is that all threads in the
+ program must acquire the two locks in the order first L1 then L2.
+ Not doing so risks deadlock.</para>
+ </listitem>
+ <listitem><para>The deadlock could happen if two threads -- call them
+ T1 and T2 -- both want to access R. Suppose T1 acquires L1 first,
+ and T2 acquires L2 first. Then T1 tries to acquire L2, and T2 tries
+ to acquire L1, but those locks are both already held. So T1 and T2
+ become deadlocked.</para>
+ </listitem>
+</itemizedlist>
+
+<para>Thrcheck builds a directed graph indicating the order in which
+locks have been acquired in the past. When a thread acquires a new
+lock, the graph is updated, and then checked to see if it now contains
+a cycle. The presence of a cycle indicates a potential deadlock involving
+the locks in the cycle.</para>
+
+<para>In simple situations, where the cycle only contains two locks,
+Thrcheck will show where the required order was established:</para>
+
+<programlisting><![CDATA[
+Thread #1: lock order "0x7FEFFFAB0 before 0x7FEFFFA80" violated
+ at 0x4C23C91: pthread_mutex_lock (tc_intercepts.c:388)
+ by 0x40081F: main (tc13_laog1.c:24)
+ Required order was established by acquisition of lock at 0x7FEFFFAB0
+ at 0x4C23C91: pthread_mutex_lock (tc_intercepts.c:388)
+ by 0x400748: main (tc13_laog1.c:17)
+ followed by a later acquisition of lock at 0x7FEFFFA80
+ at 0x4C23C91: pthread_mutex_lock (tc_intercepts.c:388)
+ by 0x400773: main (tc13_laog1.c:18)
+]]></programlisting>
+
+<para>When there are more than two locks in the cycle, the error is
+equally serious. However, at present Thrcheck does not show the locks
+involved, so as to avoid flooding you with information. That could be
+fixed in future. For example, here is a an example involving a cycle
+of five locks from a naive implementation the famous Dining
+Philosophers problem
+(see <computeroutput>thrcheck/tests/tc14_laog_dinphils.c</computeroutput>).
+In this case Thrcheck has detected that all 5 philosophers could
+simultaneously pick up their left fork and then deadlock whilst
+waiting to pick up their right forks.</para>
+
+<programlisting><![CDATA[
+Thread #6: lock order "0x6010C0 before 0x601160" violated
+ at 0x4C23C91: pthread_mutex_lock (tc_intercepts.c:388)
+ by 0x4007C0: dine (tc14_laog_dinphils.c:19)
+ by 0x4C25DF7: mythread_wrapper (tc_intercepts.c:178)
+ by 0x4E2F09D: start_thread (in /lib64/libpthread-2.5.so)
+ by 0x51054CC: clone (in /lib64/libc-2.5.so)
+]]></programlisting>
+
+</sect1>
+
+
+
+
+<sect1 id="tc-manual.data-races" xreflabel="Data Races">
+<title>Detected errors: Data Races</title>
+
+<para>A data race happens, or could happen, when two threads
+access a shared memory location without using suitable locks to
+ensure single-threaded access. Such missing locking can cause
+obscure timing dependent bugs. Ensuring programs are race-free is
+one of the central difficulties of threaded programming.</para>
+
+<para>Reliably detecting races is a difficult problem, and most
+of Thrcheck's internals are devoted to do dealing with it.
+As a consequence this section is somewhat long and involved.
+We begin with a simple example.</para>
+
+
+<sect2 id="tc-manual.data-races.example" xreflabel="Simple Race">
+<title>A Simple Data Race</title>
+
+<para>About the simplest possible example of a race is as follows. In
+this program, it is impossible to know what the value
+of <computeroutput>var</computeroutput> is at the end of the program.
+Is it 2 ? Or 1 ?</para>
+
+<programlisting><![CDATA[
+#include <pthread.h>
+
+int var = 0;
+
+void* child_fn ( void* arg ) {
+ var++; /* Unprotected relative to parent */ /* this is line 6 */
+ return NULL;
+}
+
+int main ( void ) {
+ pthread_t child;
+ pthread_create(&child, NULL, child_fn, NULL);
+ var++; /* Unprotected relative to child */ /* this is line 13 */
+ pthread_join(child, NULL);
+ return 0;
+}
+]]></programlisting>
+
+<para>The problem is there is nothing to
+stop <computeroutput>var</computeroutput> being updated simultaneously
+by both threads. A correct program would
+protect <computeroutput>var</computeroutput> with a lock of type
+<computeroutput>pthread_mutex_t</computeroutput>, which is acquired
+before each access and released afterwards. Thrcheck's output for
+this program is:</para>
+
+<programlisting><![CDATA[
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x510548E: clone (in /lib64/libc-2.5.so)
+ by 0x4E2F305: do_clone (in /lib64/libpthread-2.5.so)
+ by 0x4E2F7C5: pthread_create@@GLIBC_2.2.5 (in /lib64/libpthread-2.5.so)
+ by 0x4C23870: pthread_create@* (tc_intercepts.c:198)
+ by 0x4005F1: main (simple_race.c:12)
+
+Possible data race during write of size 4 at 0x601034
+ at 0x4005F2: main (simple_race.c:13)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x601034 has never been protected by any lock
+]]></programlisting>
+
+<para>This is quite a lot of detail for an apparently simple error.
+The last clause is the main error message. It says there is a race as
+a result of a write of size 4 (bytes), at 0x601034, which is
+presumably the address of <computeroutput>var</computeroutput>,
+happening in function <computeroutput>main</computeroutput> at line 13
+in the program.</para>
+
+<para>Note that it is purely by chance that the race is
+reported for the parent thread's access. It could equally have been
+reported instead for the child's access, at line 6. The error will
+only be reported for one of the locations, since neither the parent
+nor child is, by itself, incorrect. It is only when both access
+<computeroutput>var</computeroutput> without a lock that an error
+exists.</para>
+
+<para>The error message shows some other interesting details. The
+sections below explain them. Here we merely note their presence:</para>
+
+<itemizedlist>
+ <listitem><para>Thrcheck maintains some kind of state machine for the
+ memory location in question, hence the "<computeroutput>Old
+ state:</computeroutput>" and "<computeroutput>New
+ state:</computeroutput>" lines.</para>
+ </listitem>
+ <listitem><para>Thrcheck keeps track of which threads have accessed
+ the location: "<computeroutput>threads #1, #2</computeroutput>".
+ Before printing the main error message, it prints the creation
+ points of these two threads, so you can see which threads it is
+ referring to.</para>
+ </listitem>
+ <listitem><para>Thrcheck tries to provide an explaination of why the
+ race exists: "<computeroutput>Location 0x601034 has never been
+ protected by any lock</computeroutput>".</para>
+ </listitem>
+</itemizedlist>
+
+<para>Understanding the memory state machine is central to
+understanding Thrcheck's race-detection algorithm. The next three
+subsections explain this.</para>
+
+</sect2>
+
+
+<sect2 id="tc-manual.data-races.memstates" xreflabel="Memory States">
+<title>Thrcheck's Memory State Machine</title>
+
+<para>Thrcheck tracks the state of every byte of memory used by your
+program. There are a number of states, but only three are
+interesting:</para>
+
+<itemizedlist>
+ <listitem><para>Exclusive: memory in this state is regarded as owned
+ exclusively by one particular thread. That thread may read and
+ write it without a lock. Even in highly threaded programs, the
+ majority of locations never leave the Exclusive state, since most
+ data is thread-private.</para>
+ </listitem>
+ <listitem><para>Shared-Readonly: memory in this state is regarded as
+ shared by multiple threads. In this state, any thread may read the
+ memory without a lock, reflecting the fact that readonly data may
+ safely be shared between threads without locking.</para>
+ </listitem>
+ <listitem><para>Shared-Modified: memory in this state is regarded as
+ shared by multiple threads, at least one of which has written to it.
+ All participating threads must hold at least one lock in common when
+ accessing the memory. If no such lock exists, Thrcheck reports a
+ race error.</para>
+ </listitem>
+</itemizedlist>
+
+<para>Let's review the simple example above with this in mind. When
+the program starts, <computeroutput>var</computeroutput> is not in any
+of these states. Either the parent or child thread gets to its
+<computeroutput>var++</computeroutput> first, and thereby
+thereby gets Exclusive ownership of the location.</para>
+
+<para>The later-running thread now arrives at
+its <computeroutput>var++</computeroutput> statement. It first reads
+the existing value from memory.
+Because <computeroutput>var</computeroutput> is currently marked as
+owned exclusively by the other thread, its state is changed to
+shared-readonly by both threads.</para>
+
+<para>This same thread adds one to the value it has and stores it back
+in <computeroutput>var</computeroutput>. This causes another state
+change, this time to the shared-modified state. Because Thrcheck has
+also been tracking which threads hold which locks, it can see that
+<computeroutput>var</computeroutput> is in shared-modified state but
+no lock has been used to consistently protect it. Hence a race is
+reported exactly at the transition from shared-readonly to
+shared-modified.</para>
+
+<para>The essence of the algorithm is this. Thrcheck keeps track of
+each memory location that has been accessed by more than one thread.
+For each such location it incrementally infers the set of locks which
+have consistently been used to protect that location. If the
+location's lockset becomes empty, and at some point one of the threads
+attempts to write to it, a race is then reported.</para>
+
+<para>This technique is known as "lockset inference" and was
+introduced in: "Eraser: A Dynamic Data Race Detector for Multithreaded
+Programs" (Stefan Savage, Michael Burrows, Greg Nelson, Patrick
+Sobalvarro and Thomas Anderson, ACM Transactions on Computer Systems,
+15(4):391-411, November 1997).</para>
+
+<para>Lockset inference has since been widely implemented, studied and
+extended. Thrcheck incorporates several refinements aimed at avoiding
+the high false error rate that naive versions of the algorithm suffer
+from. A
+<link linkend="tc-manual.data-races.summary">summary of the complete
+algorithm used by Thrcheck</link> is presented below. First, however,
+it is important to understand details of transitions pertaining to the
+Exclusive-ownership state.</para>
+
+</sect2>
+
+
+
+<sect2 id="tc-manual.data-races.exclusive" xreflabel="Excl Transfers">
+<title>Transfers of Exclusive Ownership Between Threads</title>
+
+<para>As presented, the algorithm is far too strict. It reports many
+errors in perfectly correct, widely used parallel programming
+constructions, for example, using child worker threads and worker
+thread pools.</para>
+
+<para>To avoid these false errors, we must refine the algorithm so
+that it keeps memory in an Exclusive ownership state in cases where it
+would otherwise decay into a shared-readonly or shared-modified state.
+Recall that Exclusive ownership is special in that it grants the
+owning thread the right to access memory without use of any locks. In
+order to support worker-thread and worker-thread-pool idioms, we will
+allow threads to steal exclusive ownership of memory from other
+threads under certain circumstances.</para>
+
+<para>Here's an example. Imagine a parent thread creates child
+threads to do units of work. For each unit of work, the parent
+allocates a work buffer, fills it in, and creates the child thread,
+handing it a pointer to the buffer. The child reads/writes the buffer
+and eventually exits, and the waiting parent then extracts the results
+from the buffer:</para>
+
+<programlisting><![CDATA[
+typedef ... Buffer;
+
+pthread_t child;
+Buffer buf;
+
+/* ---- Parent ---- */ /* ---- Child ---- */
+
+/* parent writes workload into buf */
+pthread_create( &child, child_fn, &buf );
+
+/* parent does not read */ void child_fn ( Buffer* buf ) {
+/* or write buf */ /* read/write buf */
+ }
+
+pthread_join ( child );
+/* parent reads results from buf */
+]]></programlisting>
+
+<para>Although <computeroutput>buf</computeroutput> is accessed by
+both threads, neither uses locks, yet the program is race-free. The
+essential observation is that the child's creation and exit create
+synchronisation events between it and the parent. These force the
+child's accesses to <computeroutput>buf</computeroutput> to happen
+after the parent initialises <computeroutput>buf</computeroutput>, and
+before the parent reads the results
+from <computeroutput>buf</computeroutput>.</para>
+
+<para>To model this, Thrcheck allows the child to steal, from the
+parent, exclusive ownership of any memory exclusively owned by the
+parent before the pthread_create call. Similarly, once the parent's
+pthread_join call returns, it can steal back ownership of memory
+exclusively owned by the child. In this way ownership
+of <computeroutput>buf</computeroutput> is transferred from parent to
+child and back, so the basic algorithm does not report any races
+despite the absence of any locking.</para>
+
+<para>Note that the child may only steal memory owned by the parent
+prior to the pthread_create call. If the child attempts to read or
+write memory which is also accessed by the parent in between the
+pthread_create and pthread_join calls, an error is still
+reported.</para>
+
+<para>This technique was introduced with the name "thread lifetime
+segments" in "Runtime Checking of Multithreaded Applications with
+Visual Threads" (Jerry J. Harrow, Jr, Proceedings of the 7th
+International SPIN Workshop on Model Checking of Software Stanford,
+California, USA, August 2000, LNCS 1885, pp331--342). Thrcheck
+implements an extended version of it. Specifically, Thrcheck allows
+transfer of exclusive ownership in the following situations:</para>
+
+<itemizedlist>
+ <listitem><para>At thread creation: a child can acquire ownership of
+ memory held exclusively by the parent prior to the child's
+ creation.</para>
+ </listitem>
+ <listitem><para>At thread joining: the joiner (thread not exiting)
+ can acquire ownership of memory held exclusively by the joinee
+ (thread that is exiting) at the point it exited.</para>
+ </listitem>
+ <listitem><para>At condition variable signallings and broadcasts. A
+ thread Tw which completes a pthread_cond_wait call as a result of
+ a signal or broadcast on the same condition variable by some other
+ thread Ts, may acquire ownership of memory held exclusively by
+ Ts prior to the pthread_cond_signal/broadcast
+ call.</para>
+ </listitem>
+ <listitem><para>At semaphore posts (sem_post) calls. A thread Tw
+ which completes a sem_wait call call as a result of a sem_post call
+ on the same semaphore by some other thread Tp, may acquire
+ ownership of memory held exclusively by Tp prior to the sem_post
+ call.</para>
+ </listitem>
+</itemizedlist>
+
+</sect2>
+
+
+
+<sect2 id="tc-manual.data-races.re-excl" xreflabel="Re-Excl Transfers">
+<title>Restoration of Exclusive Ownership</title>
+
+<para>Another common idiom is to partition the lifetime of the program
+as a whole into several distinct phases. In some of those phases, a
+memory location may be accessed by multiple threads and so require
+locking. In other phases only one thread exists and so can access the
+memory without locking. For example:</para>
+
+<programlisting><![CDATA[
+int var = 0; /* shared variable */
+pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER; /* guard for var */
+pthread_t child;
+
+/* ---- Parent ---- */ /* ---- Child ---- */
+
+var += 1; /* no lock used */
+
+pthread_create( &child, child_fn, NULL );
+
+ void child_fn ( void* uu ) {
+pthread_mutex_lock(&mx); pthread_mutex_lock(&mx);
+var += 2; var += 3;
+pthread_mutex_unlock(&mx); pthread_mutex_unlock(&mx);
+ }
+
+pthread_join ( child );
+
+var += 4; /* no lock used */
+]]></programlisting>
+
+<para>This program is correct, but using only the mechanisms described
+so far, Thrcheck would report an error at
+<computeroutput>var += 4</computeroutput>. This is because, by that
+point, <computeroutput>var</computeroutput> is marked as being in the
+state "shared-modified and protected by the
+lock <computeroutput>mx</computeroutput>", but is being accessed
+without locking. Really, what we want is
+for <computeroutput>var</computeroutput> to return to the parent
+thread's exclusive ownership after the child thread has exited.</para>
+
+<para>To make this possible, for every memory location Thrcheck also keeps
+track of all the threads that have accessed that location
+-- its threadset. When a thread Tquitter joins back to Tstayer,
+Thrcheck examines the locksets of all memory in shared-modified or
+shared-readable state. In each such lockset, if Tquitter is
+mentioned, it is removed and replaced by Tstayer. If, as a result, a
+lockset becomes a singleton set containing Tstayer, then the
+location's state is changed to belongs-exclusively-to-Tstayer.</para>
+
+<para>In our example, the result is exactly as we desire:
+<computeroutput>var</computeroutput> is reacquired exclusively by the
+parent after the child exits.</para>
+
+<para>More generally, when a group of threads merges back to a single
+thread via a cascade of pthread_join calls, any memory shared by the
+group (or a subset of it) ends up being owned exclusively by the sole
+surviving thread. This significantly enhances Thrcheck's flexibility,
+since it means that each memory location may make arbitrarily many
+transitions between exclusive and shared ownership. Furthermore, a
+different lock may protect the location during each period of shared
+ownership.</para>
+
+</sect2>
+
+
+
+<sect2 id="tc-manual.data-races.summary" xreflabel="Race Det Summary">
+<title>A Summary of the Race Detection Algorithm</title>
+
+<para>Thrcheck looks for memory locations which are accessed by more
+than one thread. For each such location, Thrcheck records which of
+the program's locks were held by the accessing thread at the time of
+each access. The hope is to discover that there is indeed at least
+one lock which is consistently used by all threads to protect that
+location. If no such lock can be found, then there is apparently no
+consistent locking strategy being applied for that location, and so a
+possible data race might result. Thrcheck accordingly reports an
+error.</para>
+
+<para>In practice this discipline is far too simplistic, and is
+unusable since it reports many races in some widely used and
+known-correct programming disciplines. Thrcheck's checking therefore
+incorporates many refinements to this basic idea, and can be
+summarised as follows:</para>
+
+<para>The following thread events are intercepted and monitored:</para>
+
+<itemizedlist>
+ <listitem><para>thread creation and exiting (pthread_create,
+ pthread_join, pthread_exit)</para>
+ </listitem>
+ <listitem>
+ <para>lock acquisition and release (pthread_mutex_lock,
+ pthread_mutex_unlock, pthread_rwlock_rdlock,
+ pthread_rwlock_wrlock,
+ pthread_rwlock_unlock)</para>
+ </listitem>
+ <listitem>
+ <para>inter-thread event notifications (pthread_cond_wait,
+ pthread_cond_signal, pthread_cond_broadcast,
+ sem_wait, sem_post)</para>
+ </listitem>
+</itemizedlist>
+
+<para>Memory allocation and deallocation events are intercepted and
+monitored:</para>
+
+<itemizedlist>
+ <listitem>
+ <para>malloc/new/free/delete and variants</para>
+ </listitem>
+ <listitem>
+ <para>stack allocation and deallocation</para>
+ </listitem>
+</itemizedlist>
+
+<para>All memory accesses are intercepted and monitored.</para>
+
+<para>By observing the above events, Thrcheck can infer certain
+aspects of the program's locking discipline. Programs which adhere to
+the following rules are considered to be acceptable:
+</para>
+
+<itemizedlist>
+ <listitem>
+ <para>A thread may allocate memory, and write initial values into
+ it, without locking. That thread is regarded as owning the memory
+ exclusively.</para>
+ </listitem>
+ <listitem>
+ <para>A thread may read and write memory which it owns exclusively,
+ without locking.</para>
+ </listitem>
+ <listitem>
+ <para>Memory which is owned exclusively by one thread may be read by
+ that thread and others without locking. However, in this situation
+ no thread may do unlocked writes to the memory (except for the owner
+ thread's initializing write).</para>
+ </listitem>
+ <listitem>
+ <para>Memory which is shared between multiple threads, one or more
+ of which writes to it, must be protected by a lock which is
+ correctly acquired and released by all threads accessing the
+ memory.</para>
+ </listitem>
+</itemizedlist>
+
+<para>Any violation of this discipline will cause an error to be reported.
+However, two exemptions apply:</para>
+
+<itemizedlist>
+ <listitem>
+ <para>A thread Y can acquire exclusive ownership of memory
+ previously owned exclusively by a different thread X providing
+ X's last access and Y's first access are separated by one of the
+ following synchronization events:</para>
+ <itemizedlist>
+ <listitem><para>X creates thread Y</para></listitem>
+ <listitem><para>X joins back to Y</para></listitem>
+ <listitem><para>X uses a condition-variable to signal at Y, and Y is
+ waiting for that event</para></listitem>
+ <listitem><para>Y completes a semaphore wait as a result of X signalling
+ on that same semaphore</para></listitem>
+ </itemizedlist>
+ <para>
+ This refinement allows Thrcheck to correctly track the ownership
+ state of inter-thread buffers used in the worker-thread and
+ worker-thread-pool concurrent programming idioms (styles).</para>
+ </listitem>
+ <listitem>
+ <para>Similarly, if thread Y joins back to thread X, memory
+ exclusively owned by Y becomes exclusively owned by X instead.
+ Also, memory that has been shared only by X and Y becomes
+ exclusively owned by X. More generally, memory that has been shared
+ by X, Y and some arbitrary other set S of threads is re-marked as
+ shared by X and S. Hence, under the right circumstances, memory
+ shared amongst multiple threads, all of which join into just one,
+ can revert to the exclusive ownership state.</para>
+ <para>
+ In effect, each memory location may make arbitrarily many
+ transitions between exclusive and shared ownership. Furthermore, a
+ different lock may protect the location during each period of shared
+ ownership. This significantly enhances the flexibility of the
+ algorithm.</para>
+ </listitem>
+</itemizedlist>
+
+<para>The ownership state, accessing thread-set and related lock-set
+for each memory location are tracked at 8-bit granularity. This means
+the algorithm is precise even for 16- and 8-bit memory
+accesses.</para>
+
+<para>Thrcheck correctly handles reader-writer locks in this
+framework. Locations shared between multiple threads can be protected
+during reads by locks held in either read-mode or write-mode, but can
+only be protected during writes by locks held in write-mode. Normal
+POSIX mutexes are treated as if they are reader-writer locks which are
+only ever held in write-mode.</para>
+
+<para>Thrcheck correctly handles POSIX mutexes for which recursive
+locking is allowed.</para>
+
+<para>Thrcheck partially correctly handles x86 and amd64 memory access
+instructions preceded by a LOCK prefix. Writes are correctly handled,
+by pretending that the LOCK prefix implies acquisition and release of
+a magic "bus hardware lock" mutex before and after the instruction.
+This unfortunately requires subsequent reads from such locations to
+also use a LOCK prefix, which is not required by the real hardware.
+Thrcheck does not offer any equivalent handling for atomic sequences
+on PowerPC/POWER platforms created by the use of lwarx/stwcx
+instructions.</para>
+
+</sect2>
+
+
+
+<sect2 id="tc-manual.data-races.errmsgs" xreflabel="Race Error Messages">
+<title>Interpreting Race Error Messages</title>
+
+<para>Thrcheck's race detection algorithm collects a lot of
+information, and tries to present it in a helpful way when a race is
+detected. Here's an example:</para>
+
+<programlisting><![CDATA[
+Thread #2 was created
+ at 0x510548E: clone (in /lib64/libc-2.5.so)
+ by 0x4E2F305: do_clone (in /lib64/libpthread-2.5.so)
+ by 0x4E2F7C5: pthread_create@@GLIBC_2.2.5 (in /lib64/libpthread-2.5.so)
+ by 0x4C23870: pthread_create@* (tc_intercepts.c:198)
+ by 0x400CEF: main (tc17_sembar.c:195)
+
+// And the same for threads #3, #4 and #5 -- omitted for conciseness
+
+Possible data race during read of size 4 at 0x602174
+ at 0x400BE5: gomp_barrier_wait (tc17_sembar.c:122)
+ by 0x400C44: child (tc17_sembar.c:161)
+ by 0x4C25DF7: mythread_wrapper (tc_intercepts.c:178)
+ by 0x4E2F09D: start_thread (in /lib64/libpthread-2.5.so)
+ by 0x51054CC: clone (in /lib64/libc-2.5.so)
+ Old state: shared-modified by threads #2, #3, #4, #5
+ New state: shared-modified by threads #2, #3, #4, #5
+ Reason: this thread, #2, holds no consistent locks
+ Last consistently used lock for 0x602174 was first observed
+ at 0x4C25D01: pthread_mutex_init (tc_intercepts.c:326)
+ by 0x4009E4: gomp_barrier_init (tc17_sembar.c:46)
+ by 0x400CBC: main (tc17_sembar.c:192)
+]]></programlisting>
+
+<para>Thrcheck first announces the creation points of any threads
+referenced in the error message. This is so it can speak concisely
+about threads and sets of threads without repeatedly printing their
+creation point call stacks. Each thread is only ever announced once,
+the first time it appears in any Thrcheck error message.</para>
+
+<para>The main error message begins at the text
+"<computeroutput>Possible data race during read</computeroutput>".
+At the start is information you would expect to see -- address and
+size of the racing access, whether a read or a write, and the call
+stack at the point it was detected.</para>
+
+<para>More interesting is the state transition caused by this access.
+This memory is already in the shared-modified state, and up to now has
+been consistently protected by at least one lock. However, the thread
+making the access in question (thread #2, here) does not hold any
+locks in common with those held during all previous accesses to the
+location -- "no consistent locks", in other words.</para>
+
+<para>Finally, Thrcheck shows the lock which has protected this
+location in all previous accesses. (If there is more than one, only
+one is shown). This can be a useful hint, because it typically shows
+the lock that the programmers intended to use to protect the location,
+but in this case forgot.</para>
+
+<para>Here are some more examples of race reports. This not an
+exhaustive list of combinations, but should give you some insight into
+how to interpret the output.</para>
+
+<programlisting><![CDATA[
+Possible data race during write ...
+ Old state: shared-readonly by threads #1, #2, #3
+ New state: shared-modified by threads #1, #2, #3
+ Reason: this thread, #3, holds no consistent locks
+ Location ... has never been protected by any lock
+]]></programlisting>
+
+<para>The location is shared by 3 threads, all of which have been
+reading it without locking ("has never been protected by any lock").
+Now one of them is writing it. Regardless of whether the writer has a
+lock or not, this is still an error, because the write races against
+the previously observed reads.</para>
+
+<programlisting><![CDATA[
+Possible data race during read ...
+ Old state: shared-modified by threads #1, #2, #3
+ New state: shared-modified by threads #1, #2, #3
+ Reason: this thread, #3, holds no consistent locks
+ Last consistently used lock for ... was first observed ...
+]]></programlisting>
+
+<para>The location is shared by 3 threads, all of which have been
+reading and writing it while (as required) holding at least one lock
+in common. Now it is being read without that lock being held. In the
+"Last consistently used lock" part, Thrcheck offers its best guess as
+to the identity of the lock that should have been used.</para>
+
+<programlisting><![CDATA[
+Possible data race during write ...
+ Old state: owned exclusively by thread #4
+ New state: shared-modified by threads #4, #5
+ Reason: this thread, #5, holds no locks at all
+]]></programlisting>
+
+<para>A location that has so far been accessed exclusively by thread
+#4 has now been written by thread #5, without use of any lock. This
+can be a sign that the programmer did not consider the possibility of
+the location being shared between threads, or, alternatively, forgot
+to use the appropriate lock.</para>
+
+<para>Note that thread #4 exclusively owns the location, and so has
+the right to access it without holding a lock. However, this message
+does not say that thread #4 is not using a lock for this location.
+Indeed, it could be using a lock for the location because it intends
+to make it available to other threads, one of which is thread #5 --
+and thread #5 has forgotten to use the lock.</para>
+
+<para>Also, this message implies that Thrcheck did not see any
+synchronisation event between threads #4 and #5 that would have
+allowed #5 to acquire exclusive ownership from #4. See
+<link linkend="tc-manual.data-races.exclusive">above</link>
+for a discussion of transfers of exclusive ownership states between
+threads.</para>
+
+</sect2>
+
+
+</sect1>
+
+<sect1 id="tc-manual.effective-use" xreflabel="Thrcheck Effective Use">
+<title>Hints and Tips for Effective Use of Thrcheck</title>
+
+<para>Thrcheck can be very helpful in finding and resolving
+threading-related problems. Like all sophisticated tools, it is most
+effective when you understand how to play to its strengths.</para>
+
+<para>Thrcheck will be less effective when you merely throw an
+existing threaded program at it and try to make sense of any reported
+errors. It will be more effective if you design threaded programs
+from the start in a way that helps Thrcheck verify correctness. The
+same is true for finding memory errors with Memcheck, but applies more
+here, because thread checking is a harder problem. Consequently it is
+much easier to write a correct program for which Thrcheck falsely
+reports (threading) errors than it is to write a correct program for
+which Memcheck falsely reports (memory) errors.</para>
+
+<para>With that in mind, here are some tips, listed most important first,
+for getting reliable results and avoiding false errors. The first two
+are critical. Any violations of them will swamp you with huge numbers
+of false data-race errors.</para>
+
+
+<orderedlist>
+
+ <listitem>
+ <para>Make sure your application, and all the libraries it uses,
+ use the POSIX threading primitives. Thrcheck needs to be able to
+ see all events pertaining to thread creation, exit, locking and
+ other syncronisation events. To do so it intercepts many POSIX
+ pthread_ functions.</para>
+
+ <para>Do not roll your own threading primitives (mutexes, etc)
+ from combinations of the Linux futex syscall, counters and wotnot.
+ These throw Thrcheck's internal what's-going-on models way off
+ course and will give bogus results.</para>
+
+ <para>Also, do not reimplement existing POSIX abstractions using
+ other POSIX abstractions. For example, don't build your own
+ semaphore routines or reader-writer locks from POSIX mutexes and
+ condition variables. Instead use POSIX reader-writer locks and
+ semaphores directly, since Thrcheck supports them directly.</para>
+
+ <para>Thrcheck directly supports the following POSIX threading
+ abstractions: mutexes, reader-writer locks, condition variables
+ (but see below), and semaphores. Currently spinlocks and barriers
+ are not supported, although they could be in future. A prototype
+ "safe" implementation of barriers, based on semaphores, is
+ available: please contact the Valgrind authors for details.</para>
+
+ <para>At the time of writing, the following popular Linux packages
+ are known to implement their own threading primitives:</para>
+
+ <itemizedlist>
+ <listitem><para>Qt version 4.X. Qt 3.X is fine, but not 4.X.
+ Thrcheck contains partial direct support for Qt 4.X threading,
+ but this is not yet in a usable state. Assistance from folks
+ knowledgeable in Qt 4 threading internals would be
+ appreciated.</para></listitem>
+
+ <listitem><para>Runtime support library for GNU OpenMP (part of
+ GCC), at least GCC versions 4.2 and 4.3. With some minor effort
+ of modifying the GNU OpenMP runtime support sources, it is
+ possible to use Thrcheck on GNU OpenMP compiled codes. Please
+ contact the Valgrind authors for details.</para></listitem>
+ </itemizedlist>
+ </listitem>
+
+ <listitem>
+ <para>Avoid memory recycling. If you can't avoid it, you must use
+ tell Thrcheck what is going on via the VALGRIND_HG_CLEAN_MEMORY
+ client request
+ (in <computeroutput>thrcheck.h</computeroutput>).</para>
+
+ <para>Thrcheck is aware of standard memory allocation and
+ deallocation that occurs via malloc/free/new/delete and from entry
+ and exit of stack frames. In particular, when memory is
+ deallocated via free, delete, or function exit, Thrcheck considers
+ that memory clean, so when it is eventually reallocated, its
+ history is irrelevant.</para>
+
+ <para>However, it is common practice to implement memory recycling
+ schemes. In these, memory to be freed is not handed to
+ malloc/delete, but instead put into a pool of free buffers to be
+ handed out again as required. The problem is that Thrcheck has no
+ way to know that such memory is logically no longer in use, and
+ its history is irrelevant. Hence you must make that explicit,
+ using the VALGRIND_HG_CLEAN_MEMORY client request to specify the
+ relevant address ranges. It's easiest to put these requests into
+ the pool manager code, and use them either when memory is returned
+ to the pool, or is allocated from it.</para>
+ </listitem>
+
+ <listitem>
+ <para>Avoid POSIX condition variables. If you can, use POSIX
+ semaphores (sem_t, sem_post, sem_wait) to do inter-thread event
+ signalling. Semaphores with an initial value of zero are
+ particularly useful for this.</para>
+
+ <para>Thrcheck only partially correctly handles POSIX condition
+ variables. This is because Thrcheck can see inter-thread
+ dependencies between a pthread_cond_wait call and a
+ pthread_cond_signal/broadcast call only if the waiting thread
+ actually gets to the rendezvous first (so that it actually calls
+ pthread_cond_wait). It can't see dependencies between the threads
+ if the signaller arrives first. In the latter case, POSIX
+ guidelines imply that the associated boolean condition still
+ provides an inter-thread synchronisation event, but one which is
+ invisible to Thrcheck.</para>
+
+ <para>The result of Thrcheck missing some inter-thread
+ synchronisation events is to cause it to report false positives.
+ That's because missing such events reduces the extent to which it
+ can transfer exclusive memory ownership between threads. So
+ memory may end up in a shared-modified state when that was not
+ intended by the application programmers.</para>
+
+ <para>The root cause of this synchronisation lossage is
+ particularly hard to understand, so an example is helpful. It was
+ discussed at length by Arndt Muehlenfeld ("Runtime Race Detection
+ in Multi-Threaded Programs", Dissertation, TU Graz, Austria). The
+ canonical POSIX-recommended usage scheme for condition variables
+ is as follows:</para>
+
+<programlisting><![CDATA[
+b is a Boolean condition, which is False most of the time
+cv is a condition variable
+mx is its associated mutex
+
+Signaller: Waiter:
+
+lock(mx) lock(mx)
+b = True while (b == False)
+signal(cv) wait(cv,mx)
+unlock(mx) unlock(mx)
+]]></programlisting>
+
+ <para>Assume <computeroutput>b</computeroutput> is False most of
+ the time. If the waiter arrives at the rendezvous first, it
+ enters its while-loop, waits for the signaller to signal, and
+ eventually proceeds. Thrcheck sees the signal, notes the
+ dependency, and all is well.</para>
+
+ <para>If the signaller arrives
+ first, <computeroutput>b</computeroutput> is set to true, and the
+ signal disappears into nowhere. When the waiter later arrives, it
+ does not enter its while-loop and simply carries on. But even in
+ this case, the waiter code following the while-loop cannot execute
+ until the signaller sets <computeroutput>b</computeroutput> to
+ True. Hence there is still the same inter-thread dependency, but
+ this time it is through an arbitrary in-memory condition, and
+ Thrcheck cannot see it.</para>
+
+ <para>By comparison, Thrcheck's detection of inter-thread
+ dependencies caused by semaphore operations is believed to be
+ exactly correct.</para>
+
+ <para>As far as I know, a solution to this problem that does not
+ require source-level annotation of condition-variable wait loops
+ is beyond the current state of the art.</para>
+ </listitem>
+
+ <listitem>
+ <para>Make sure you are using a supported Linux distribution. At
+ present, Thrcheck only properly supports x86-linux and amd64-linux
+ with glibc-2.3 or later. The latter restriction means we only
+ support glibc's NPTL threading implementation. The old
+ LinuxThreads implementation is not supported.</para>
+
+ <para>Unsupported targets may work to varying degrees. In
+ particular ppc32-linux and ppc64-linux running NTPL should work,
+ but you will get false race errors because Thrcheck does not know
+ how to properly handle atomic instruction sequences created using
+ the lwarx/stwcx instructions.</para>
+ </listitem>
+
+ <listitem>
+ <para>Round up all finished threads using pthread_join. Avoid
+ detaching threads: don't create threads in the detached state, and
+ don't call pthread_detach on existing threads.</para>
+
+ <para>Using pthread_join to round up finished threads provides a
+ clear synchronisation point that both Thrcheck and programmers can
+ see. This synchronisation point allows Thrcheck to adjust its
+ memory ownership
+ models <link linkend="tc-manual.data-races.exclusive">as described
+ extensively above</link>, which helps Thrcheck produce more
+ accurate error reports.</para>
+
+ <para>If you don't call pthread_join on a thread, Thrcheck has no
+ way to know when it finishes, relative to any significant
+ synchronisation points for other threads in the program. So it
+ assumes that the thread lingers indefinitely and can potentially
+ interfere indefinitely with the memory state of the program. It
+ has every right to assume that -- after all, it might really be
+ the case that, for scheduling reasons, the exiting thread did run
+ very slowly in the last stages of its life.</para>
+ </listitem>
+
+ <listitem>
+ <para>Perform thread debugging (with Thrcheck) and memory
+ debugging (with Memcheck) together.</para>
+
+ <para>Thrcheck tracks the state of memory in detail, and memory
+ management bugs in the application are liable to cause confusion.
+ In extreme cases, applications which do many invalid reads and
+ writes (particularly to freed memory) have been known to crash
+ Thrcheck. So, ideally, you should make your application
+ Memcheck-clean before using Thrcheck.</para>
+
+ <para>It may be impossible to make your application Memcheck-clean
+ unless you first remove threading bugs. In particular, it may be
+ difficult to remove all reads and writes to freed memory in
+ multithreaded C++ destructor sequences at program termination.
+ So, ideally, you should make your application Thrcheck-clean
+ before using Memcheck.</para>
+
+ <para>Since this circularity is obviously unresolvable, at least
+ bear in mind that Memcheck and Thrcheck are to some extent
+ complementary, and you may need to use them together.</para>
+ </listitem>
+
+ <listitem>
+ <para>POSIX requires that implementations of standard I/O (printf,
+ fprintf, fwrite, fread, etc) are thread safe. Unfortunately GNU
+ libc implements this by using internal locking primitives that
+ Thrcheck is unable to intercept. Consequently Thrcheck generates
+ many false race reports when you use these functions.</para>
+
+ <para>Thrcheck attempts to hide these errors using the standard
+ Valgrind error-suppression mechanism. So, at least for simple
+ test cases, you don't see any. Nevertheless, some may slip
+ through. Just something to be aware of.</para>
+ </listitem>
+
+ <listitem>
+ <para>Thrcheck's error checks do not work properly inside the
+ system threading library itself
+ (<computeroutput>libpthread.so</computeroutput>), and it usually
+ observes large numbers of (false) errors in there. Valgrind's
+ suppression system then filters these out, so you should not see
+ them.</para>
+
+ <para>If you see any race errors reported
+ where <computeroutput>libpthread.so</computeroutput> or
+ <computeroutput>ld.so</computeroutput> is the object associated
+ with the innermost stack frame, please file a bug report at
+ http://www.valgrind.org.</para>
+ </listitem>
+
+</orderedlist>
+
+</sect1>
+
+
+
+
+<sect1 id="tc-manual.options" xreflabel="Thrcheck Options">
+<title>Thrcheck Options</title>
+
+<para>The following end-user options are available:</para>
+
+<!-- start of xi:include in the manpage -->
+<variablelist id="tc.opts.list">
+
+ <varlistentry id="opt.happens-before" xreflabel="--happens-before">
+ <term>
+ <option><![CDATA[--happens-before=none|threads|all
+ [default: all] ]]></option>
+ </term>
+ <listitem>
+ <para>Thrcheck always regards locks as the basis for
+ inter-thread synchronisation. However, by default, before
+ reporting a race error, Thrcheck will also check whether
+ certain other kinds of inter-thread synchronisation events
+ happened. It may be that if such events took place, then no
+ race really occurred, and so no error needs to be reported.
+ See <link linkend="tc-manual.data-races.exclusive">above</link>
+ for a discussion of transfers of exclusive ownership states
+ between threads.
+ </para>
+ <para>With <varname>--happens-before=all</varname>, the
+ following events are regarded as sources of synchronisation:
+ thread creation/joinage, condition variable
+ signal/broadcast/waits, and semaphore posts/waits.
+ </para>
+ <para>With <varname>--happens-before=threads</varname>, only
+ thread creation/joinage events are regarded as sources of
+ synchronisation.
+ </para>
+ <para>With <varname>--happens-before=none</varname>, no events
+ (apart, of course, from locking) are regarded as sources of
+ synchronisation.
+ </para>
+ <para>Changing this setting from the default will increase your
+ false-error rate but give little or no gain. The only advantage
+ is that <option>--happens-before=threads</option> and
+ <option>--happens-before=none</option> should make Thrcheck
+ less and less sensitive to the scheduling of threads, and hence
+ the output more and more repeatable across runs.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry id="opt.trace-addr" xreflabel="--trace-addr">
+ <term>
+ <option><![CDATA[--trace-addr=0xXXYYZZ
+ ]]></option> and
+ <option><![CDATA[--trace-level=0|1|2 [default: 1]
+ ]]></option>
+ </term>
+ <listitem>
+ <para>Requests that Thrcheck produces a log of all state changes
+ to location 0xXXYYZZ. This can be helpful in tracking down
+ tricky races. <varname>--trace-level</varname> controls the
+ verbosity of the log. At the default setting (1), a one-line
+ summary of is printed for each state change. At level 2 a
+ complete stack trace is printed for each state change.</para>
+ </listitem>
+ </varlistentry>
+
+</variablelist>
+<!-- end of xi:include in the manpage -->
+
+<!-- start of xi:include in the manpage -->
+<para>In addition, the following debugging options are available for
+Thrcheck:</para>
+
+<variablelist id="tc.debugopts.list">
+
+ <varlistentry id="opt.trace-malloc" xreflabel="--trace-malloc">
+ <term>
+ <option><![CDATA[--trace-malloc=no|yes [no]
+ ]]></option>
+ </term>
+ <listitem>
+ <para>Show all client malloc (etc) and free (etc) requests.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry id="opt.gen-vcg" xreflabel="--gen-vcg">
+ <term>
+ <option><![CDATA[--gen-vcg=no|yes|yes-w-vts [no]
+ ]]></option>
+ </term>
+ <listitem>
+ <para>At exit, write to stderr a dump of the happens-before
+ graph computed by Thrcheck, in a format suitable for the VCG
+ graph visualisation tool. A suitable command line is:</para>
+ <para><computeroutput>valgrind --tool=thrcheck
+ --gen-vcg=yes my_app 2>&1
+ | grep xxxxxx | sed "s/xxxxxx//g"
+ | xvcg -</computeroutput></para>
+ <para>With <varname>--gen-vcg=yes</varname>, the basic
+ happens-before graph is shown. With
+ <varname>--gen-vcg=yes-w-vts</varname>, the vector timestamp
+ for each node is also shown.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry id="opt.cmp-race-err-addrs"
+ xreflabel="--cmp-race-err-addrs">
+ <term>
+ <option><![CDATA[--cmp-race-err-addrs=no|yes [no]
+ ]]></option>
+ </term>
+ <listitem>
+ <para>Controls whether or not race (data) addresses should be
+ taken into account when removing duplicates of race errors.
+ With <varname>--cmp-race-err-addrs=no</varname>, two otherwise
+ identical race errors will be considered to be the same if
+ their race addresses differ. With
+ With <varname>--cmp-race-err-addrs=yes</varname> they will be
+ considered different. This is provided to help make certain
+ regression tests work reliably.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry id="opt.tc-sanity-flags" xreflabel="--tc-sanity-flags">
+ <term>
+ <option><![CDATA[--tc-sanity-flags=<XXXXX> (X = 0|1) [00000]
+ ]]></option>
+ </term>
+ <listitem>
+ <para>Run extensive sanity checks on Thrcheck's internal
+ data structures at events defined by the bitstring, as
+ follows:</para>
+ <para><computeroutput>10000 </computeroutput>after changes to
+ the lock order acquisition graph</para>
+ <para><computeroutput>01000 </computeroutput>after every client
+ memory access (NB: not currently used)</para>
+ <para><computeroutput>00100 </computeroutput>after every client
+ memory range permission setting of 256 bytes or greater</para>
+ <para><computeroutput>00010 </computeroutput>after every client
+ lock or unlock event</para>
+ <para><computeroutput>00001 </computeroutput>after every client
+ thread creation or joinage event</para>
+ <para>Note these will make Thrcheck run very slowly, often to
+ the point of being completely unusable.</para>
+ </listitem>
+ </varlistentry>
+
+</variablelist>
+<!-- end of xi:include in the manpage -->
+
+
+</sect1>
+
+<sect1 id="tc-manual.todolist" xreflabel="To Do List">
+<title>A To-Do List for Thrcheck</title>
+
+<para>The following is a list of loose ends which should be tidied up
+some time.</para>
+
+<itemizedlist>
+ <listitem><para>Track which mutexes are associated with which
+ condition variables, and emit a warning if this becomes
+ inconsistent.</para>
+ </listitem>
+ <listitem><para>For lock order errors, print the complete lock
+ cycle, rather than only doing for size-2 cycles as at
+ present.</para>
+ </listitem>
+ <listitem><para>Document the VALGRIND_HG_CLEAN_MEMORY client
+ request.</para>
+ </listitem>
+ <listitem><para>Possibly a client request to forcibly transfer
+ ownership of memory from one thread to another. Requires further
+ consideration.</para>
+ </listitem>
+ <listitem><para>Add a new client request that marks an address range
+ as being "shared-modified with empty lockset" (the error state),
+ and describe how to use it.</para>
+ </listitem>
+ <listitem><para>Document races caused by gcc's thread-unsafe code
+ generation for speculative stores. In the interim see
+ <computeroutput>http://gcc.gnu.org/ml/gcc/2007-10/msg00266.html
+ </computeroutput>
+ and <computeroutput>http://lkml.org/lkml/2007/10/24/673</computeroutput>.
+ </para>
+ </listitem>
+ <listitem><para>Don't update the lock-order graph, and don't check
+ for errors, when a "try"-style lock operation happens (eg
+ pthread_mutex_trylock). Such calls do not add any real
+ restrictions to the locking order, since they can always fail to
+ acquire the lock, resulting in the caller going off and doing Plan
+ B (presumably it will have a Plan B). Doing such checks could
+ generate false lock-order errors and confuse users.</para>
+ </listitem>
+ <listitem><para> Performance can be very poor. Slowdowns on the
+ order of 100:1 are not unusual. There is quite some scope for
+ performance improvements, though.
+ </para>
+ </listitem>
+
+</itemizedlist>
+
+</sect1>
+
+</chapter>
diff --git a/helgrind/helgrind.h b/helgrind/helgrind.h
new file mode 100644
index 0000000..b2f6ed3
--- /dev/null
+++ b/helgrind/helgrind.h
@@ -0,0 +1,109 @@
+/*
+ ----------------------------------------------------------------
+
+ Notice that the above BSD-style license applies to this one file
+ (helgrind.h) only. The entire rest of Valgrind is licensed under
+ the terms of the GNU General Public License, version 2. See the
+ COPYING file in the source distribution for details.
+
+ ----------------------------------------------------------------
+
+ This file is part of Helgrind, a Valgrind tool for detecting errors
+ in threaded programs.
+
+ Copyright (C) 2007-2007 OpenWorks LLP
+ info@open-works.co.uk
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
+ documentation would be appreciated but is not required.
+
+ 3. Altered source versions must be plainly marked as such, and must
+ not be misrepresented as being the original software.
+
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
+ permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ----------------------------------------------------------------
+
+ Notice that the above BSD-style license applies to this one file
+ (helgrind.h) only. The entire rest of Valgrind is licensed under
+ the terms of the GNU General Public License, version 2. See the
+ COPYING file in the source distribution for details.
+
+ ----------------------------------------------------------------
+*/
+
+#ifndef __HELGRIND_H
+#define __HELGRIND_H
+
+#include "valgrind.h"
+
+typedef
+ enum {
+ VG_USERREQ__HG_CLEAN_MEMORY = VG_USERREQ_TOOL_BASE('H','G'),
+
+ /* The rest are for Helgrind's internal use. Not for end-user
+ use. Do not use them unless you are a Valgrind developer. */
+
+ /* Notify the tool what this thread's pthread_t is. */
+ _VG_USERREQ__HG_SET_MY_PTHREAD_T = VG_USERREQ_TOOL_BASE('H','G')
+ + 256,
+ _VG_USERREQ__HG_PTH_API_ERROR, /* char*, int */
+ _VG_USERREQ__HG_PTHREAD_JOIN_POST, /* pthread_t of quitter */
+ _VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST, /* pth_mx_t*, long mbRec */
+ _VG_USERREQ__HG_PTHREAD_MUTEX_DESTROY_PRE, /* pth_mx_t* */
+ _VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE, /* pth_mx_t* */
+ _VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST, /* pth_mx_t* */
+ _VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE, /* pth_mx_t*, long isTryLock */
+ _VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST, /* pth_mx_t* */
+ _VG_USERREQ__HG_PTHREAD_COND_SIGNAL_PRE, /* pth_cond_t* */
+ _VG_USERREQ__HG_PTHREAD_COND_BROADCAST_PRE, /* pth_cond_t* */
+ _VG_USERREQ__HG_PTHREAD_COND_WAIT_PRE, /* pth_cond_t*, pth_mx_t* */
+ _VG_USERREQ__HG_PTHREAD_COND_WAIT_POST, /* pth_cond_t*, pth_mx_t* */
+ _VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST, /* pth_rwlk_t* */
+ _VG_USERREQ__HG_PTHREAD_RWLOCK_DESTROY_PRE, /* pth_rwlk_t* */
+ _VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE, /* pth_rwlk_t*, long isW */
+ _VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST, /* pth_rwlk_t*, long isW */
+ _VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE, /* pth_rwlk_t* */
+ _VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_POST, /* pth_rwlk_t* */
+ _VG_USERREQ__HG_POSIX_SEMPOST_PRE, /* sem_t* */
+ _VG_USERREQ__HG_POSIX_SEMWAIT_POST, /* sem_t* */
+ _VG_USERREQ__HG_POSIX_SEM_ZAPSTACK, /* sem_t* */
+ _VG_USERREQ__HG_GET_MY_SEGMENT /* -> Segment* */
+ } Vg_TCheckClientRequest;
+
+/* Clean memory state. This makes Helgrind forget everything it knew
+ about the specified memory range, and resets it to New. This is
+ particularly useful for memory allocators that wish to recycle
+ memory. */
+#define VALGRIND_HG_CLEAN_MEMORY(_qzz_start, _qzz_len) \
+ do { \
+ unsigned long _qzz_res; \
+ VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, VG_USERREQ__HG_CLEAN_MEMORY, \
+ _qzz_start, _qzz_len, 0, 0, 0); \
+ (void)0; \
+ } while(0)
+
+#endif /* __HELGRIND_H */
diff --git a/helgrind/hg_intercepts.c b/helgrind/hg_intercepts.c
new file mode 100644
index 0000000..10be82b
--- /dev/null
+++ b/helgrind/hg_intercepts.c
@@ -0,0 +1,1219 @@
+
+/*--------------------------------------------------------------------*/
+/*--- pthread intercepts for thread checking. ---*/
+/*--- tc_intercepts.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+ This file is part of Helgrind, a Valgrind tool for detecting errors
+ in threaded programs.
+
+ Copyright (C) 2007-2007 OpenWorks LLP
+ info@open-works.co.uk
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307, USA.
+
+ The GNU General Public License is contained in the file COPYING.
+
+ Neither the names of the U.S. Department of Energy nor the
+ University of California nor the names of its contributors may be
+ used to endorse or promote products derived from this software
+ without prior written permission.
+*/
+
+/* RUNS ON SIMULATED CPU
+ Interceptors for pthread_* functions, so that tc_main can see
+ significant thread events.
+
+ Important: when adding a function wrapper to this file, remember to
+ add a test case to tc20_verifywrap.c. A common cause of failure is
+ for wrappers to not engage on different distros, and
+ tc20_verifywrap essentially checks that each wrapper is really
+ doing something.
+*/
+
+#include "pub_tool_basics.h"
+#include "valgrind.h"
+#include "helgrind.h"
+
+#define TRACE_PTH_FNS 0
+#define TRACE_QT4_FNS 0
+
+
+/*----------------------------------------------------------------*/
+/*--- ---*/
+/*----------------------------------------------------------------*/
+
+#define PTH_FUNC(ret_ty, f, args...) \
+ ret_ty I_WRAP_SONAME_FNNAME_ZZ(libpthreadZdsoZd0,f)(args); \
+ ret_ty I_WRAP_SONAME_FNNAME_ZZ(libpthreadZdsoZd0,f)(args)
+
+// Do a client request. This is a macro rather than a function
+// so as to avoid having an extra function in the stack trace.
+
+#define DO_CREQ_v_W(_creqF, _ty1F,_arg1F) \
+ do { \
+ Word _unused_res, _arg1; \
+ assert(sizeof(_ty1F) == sizeof(Word)); \
+ _arg1 = (Word)(_arg1F); \
+ VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \
+ (_creqF), \
+ _arg1, 0,0,0,0); \
+ } while (0)
+
+#define DO_CREQ_v_WW(_creqF, _ty1F,_arg1F, _ty2F,_arg2F) \
+ do { \
+ Word _unused_res, _arg1, _arg2; \
+ assert(sizeof(_ty1F) == sizeof(Word)); \
+ assert(sizeof(_ty2F) == sizeof(Word)); \
+ _arg1 = (Word)(_arg1F); \
+ _arg2 = (Word)(_arg2F); \
+ VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \
+ (_creqF), \
+ _arg1,_arg2,0,0,0); \
+ } while (0)
+
+#define DO_CREQ_W_WW(_resF, _creqF, _ty1F,_arg1F, _ty2F,_arg2F) \
+ do { \
+ Word _res, _arg1, _arg2; \
+ assert(sizeof(_ty1F) == sizeof(Word)); \
+ assert(sizeof(_ty2F) == sizeof(Word)); \
+ _arg1 = (Word)(_arg1F); \
+ _arg2 = (Word)(_arg2F); \
+ VALGRIND_DO_CLIENT_REQUEST(_res, 2, \
+ (_creqF), \
+ _arg1,_arg2,0,0,0); \
+ _resF = _res; \
+ } while (0)
+
+#define DO_CREQ_v_WWW(_creqF, _ty1F,_arg1F, \
+ _ty2F,_arg2F, _ty3F, _arg3F) \
+ do { \
+ Word _unused_res, _arg1, _arg2, _arg3; \
+ assert(sizeof(_ty1F) == sizeof(Word)); \
+ assert(sizeof(_ty2F) == sizeof(Word)); \
+ assert(sizeof(_ty3F) == sizeof(Word)); \
+ _arg1 = (Word)(_arg1F); \
+ _arg2 = (Word)(_arg2F); \
+ _arg3 = (Word)(_arg3F); \
+ VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \
+ (_creqF), \
+ _arg1,_arg2,_arg3,0,0); \
+ } while (0)
+
+
+#define DO_PthAPIerror(_fnnameF, _errF) \
+ do { \
+ char* _fnname = (char*)(_fnnameF); \
+ long _err = (long)(int)(_errF); \
+ char* _errstr = lame_strerror(_err); \
+ DO_CREQ_v_WWW(_VG_USERREQ__HG_PTH_API_ERROR, \
+ char*,_fnname, \
+ long,_err, char*,_errstr); \
+ } while (0)
+
+
+/* Needed for older glibcs (2.3 and older, at least) who don't
+ otherwise "know" about pthread_rwlock_anything or about
+ PTHREAD_MUTEX_RECURSIVE (amongst things). */
+#define _GNU_SOURCE 1
+
+#include <stdio.h>
+#include <assert.h>
+#include <errno.h>
+#include <pthread.h>
+
+
+/* A lame version of strerror which doesn't use the real libc
+ strerror_r, since using the latter just generates endless more
+ threading errors (glibc goes off and does tons of crap w.r.t.
+ locales etc) */
+static char* lame_strerror ( long err )
+{ switch (err) {
+ case EPERM: return "EPERM: Operation not permitted";
+ case ENOENT: return "ENOENT: No such file or directory";
+ case ESRCH: return "ESRCH: No such process";
+ case EINTR: return "EINTR: Interrupted system call";
+ case EBADF: return "EBADF: Bad file number";
+ case EAGAIN: return "EAGAIN: Try again";
+ case ENOMEM: return "ENOMEM: Out of memory";
+ case EACCES: return "EACCES: Permission denied";
+ case EFAULT: return "EFAULT: Bad address";
+ case EEXIST: return "EEXIST: File exists";
+ case EINVAL: return "EINVAL: Invalid argument";
+ case EMFILE: return "EMFILE: Too many open files";
+ case ENOSYS: return "ENOSYS: Function not implemented";
+ case EOVERFLOW: return "EOVERFLOW: Value too large "
+ "for defined data type";
+ case EBUSY: return "EBUSY: Device or resource busy";
+ case ETIMEDOUT: return "ETIMEDOUT: Connection timed out";
+ case EDEADLK: return "EDEADLK: Resource deadlock would occur";
+ case EOPNOTSUPP: return "EOPNOTSUPP: Operation not supported on "
+ "transport endpoint"; /* honest, guv */
+ default: return "tc_intercepts.c: lame_strerror(): "
+ "unhandled case -- please fix me!";
+ }
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- pthread_create, pthread_join, pthread_exit ---*/
+/*----------------------------------------------------------------*/
+
+static void* mythread_wrapper ( void* xargsV )
+{
+ volatile Word volatile* xargs = (volatile Word volatile*) xargsV;
+ void*(*fn)(void*) = (void*(*)(void*))xargs[0];
+ void* arg = (void*)xargs[1];
+ pthread_t me = pthread_self();
+ /* Tell the tool what my pthread_t is. */
+ DO_CREQ_v_W(_VG_USERREQ__HG_SET_MY_PTHREAD_T, pthread_t,me);
+ /* allow the parent to proceed. We can't let it proceed until
+ we're ready because (1) we need to make sure it doesn't exit and
+ hence deallocate xargs[] while we still need it, and (2) we
+ don't want either parent nor child to proceed until the tool has
+ been notified of the child's pthread_t. */
+ xargs[2] = 0;
+ /* Now we can no longer safely use xargs[]. */
+ return (void*) fn( (void*)arg );
+}
+
+// pthread_create
+PTH_FUNC(int, pthreadZucreateZAZa, // pthread_create@*
+ pthread_t *thread, const pthread_attr_t *attr,
+ void *(*start) (void *), void *arg)
+{
+ int ret;
+ OrigFn fn;
+ volatile Word xargs[3];
+
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_create wrapper"); fflush(stderr);
+ }
+ xargs[0] = (Word)start;
+ xargs[1] = (Word)arg;
+ xargs[2] = 1; /* serves as a spinlock -- sigh */
+
+ CALL_FN_W_WWWW(ret, fn, thread,attr,mythread_wrapper,&xargs[0]);
+
+ if (ret == 0) {
+ /* we have to wait for the child to notify the tool of its
+ pthread_t before continuing */
+ while (xargs[2] != 0) {
+ // FIXME: add a yield client request
+ /* do nothing */
+ }
+ } else {
+ DO_PthAPIerror( "pthread_create", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: pth_create -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+// pthread_join
+PTH_FUNC(int, pthreadZujoin, // pthread_join
+ pthread_t thread, void** value_pointer)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_join wrapper"); fflush(stderr);
+ }
+
+ CALL_FN_W_WW(ret, fn, thread,value_pointer);
+
+ /* At least with NPTL as the thread library, this is safe because
+ it is guaranteed (by NPTL) that the joiner will completely gone
+ before pthread_join (the original) returns. See email below.*/
+ if (ret == 0 /*success*/) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_JOIN_POST, pthread_t,thread);
+ } else {
+ DO_PthAPIerror( "pthread_join", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: pth_join -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+/* Behaviour of pthread_join on NPTL:
+
+Me:
+I have a question re the NPTL pthread_join implementation.
+
+ Suppose I am the thread 'stayer'.
+
+ If I call pthread_join(quitter), is it guaranteed that the
+ thread 'quitter' has really exited before pthread_join returns?
+
+ IOW, is it guaranteed that 'quitter' will not execute any further
+ instructions after pthread_join returns?
+
+I believe this is true based on the following analysis of
+glibc-2.5 sources. However am not 100% sure and would appreciate
+confirmation.
+
+ 'quitter' will be running start_thread() in nptl/pthread_create.c
+
+ The last action of start_thread() is to exit via
+ __exit_thread_inline(0), which simply does sys_exit
+ (nptl/pthread_create.c:403)
+
+ 'stayer' meanwhile is waiting for lll_wait_tid (pd->tid)
+ (call at nptl/pthread_join.c:89)
+
+ As per comment at nptl/sysdeps/unix/sysv/linux/i386/lowlevellock.h:536,
+ lll_wait_tid will not return until kernel notifies via futex
+ wakeup that 'quitter' has terminated.
+
+ Hence pthread_join cannot return until 'quitter' really has
+ completely disappeared.
+
+Drepper:
+> As per comment at nptl/sysdeps/unix/sysv/linux/i386/lowlevellock.h:536,
+> lll_wait_tid will not return until kernel notifies via futex
+> wakeup that 'quitter' has terminated.
+That's the key. The kernel resets the TID field after the thread is
+done. No way the joiner can return before the thread is gone.
+*/
+
+
+/*----------------------------------------------------------------*/
+/*--- pthread_mutex_t functions ---*/
+/*----------------------------------------------------------------*/
+
+/* Handled: pthread_mutex_init pthread_mutex_destroy
+ pthread_mutex_lock
+ pthread_mutex_trylock pthread_mutex_timedlock
+ pthread_mutex_unlock
+
+ Unhandled: pthread_spin_init pthread_spin_destroy
+ pthread_spin_lock
+ pthread_spin_trylock
+ pthread_spin_unlock
+*/
+
+// pthread_mutex_init
+PTH_FUNC(int, pthreadZumutexZuinit, // pthread_mutex_init
+ pthread_mutex_t *mutex,
+ pthread_mutexattr_t* attr)
+{
+ int ret;
+ long mbRec;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_mxinit %p", mutex); fflush(stderr);
+ }
+
+ mbRec = 0;
+ if (attr) {
+ int ty, zzz;
+ zzz = pthread_mutexattr_gettype(attr, &ty);
+ if (zzz == 0 && ty == PTHREAD_MUTEX_RECURSIVE)
+ mbRec = 1;
+ }
+
+ CALL_FN_W_WW(ret, fn, mutex,attr);
+
+ if (ret == 0 /*success*/) {
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST,
+ pthread_mutex_t*,mutex, long,mbRec);
+ } else {
+ DO_PthAPIerror( "pthread_mutex_init", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: mxinit -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+// pthread_mutex_destroy
+PTH_FUNC(int, pthreadZumutexZudestroy, // pthread_mutex_destroy
+ pthread_mutex_t *mutex)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_mxdestroy %p", mutex); fflush(stderr);
+ }
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_DESTROY_PRE,
+ pthread_mutex_t*,mutex);
+
+ CALL_FN_W_W(ret, fn, mutex);
+
+ if (ret != 0) {
+ DO_PthAPIerror( "pthread_mutex_destroy", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: mxdestroy -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+// pthread_mutex_lock
+PTH_FUNC(int, pthreadZumutexZulock, // pthread_mutex_lock
+ pthread_mutex_t *mutex)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_mxlock %p", mutex); fflush(stderr);
+ }
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
+ pthread_mutex_t*,mutex, long,0/*!isTryLock*/);
+
+ CALL_FN_W_W(ret, fn, mutex);
+
+ /* There's a hole here: libpthread now knows the lock is locked,
+ but the tool doesn't, so some other thread could run and detect
+ that the lock has been acquired by someone (this thread). Does
+ this matter? Not sure, but I don't think so. */
+
+ if (ret == 0 /*success*/) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+ pthread_mutex_t*,mutex);
+ } else {
+ DO_PthAPIerror( "pthread_mutex_lock", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: mxlock -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+// pthread_mutex_trylock. The handling needed here is very similar
+// to that for pthread_mutex_lock, except that we need to tell
+// the pre-lock creq that this is a trylock-style operation, and
+// therefore not to complain if the lock is nonrecursive and
+// already locked by this thread -- because then it'll just fail
+// immediately with EBUSY.
+PTH_FUNC(int, pthreadZumutexZutrylock, // pthread_mutex_trylock
+ pthread_mutex_t *mutex)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_mxtrylock %p", mutex); fflush(stderr);
+ }
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
+ pthread_mutex_t*,mutex, long,1/*isTryLock*/);
+
+ CALL_FN_W_W(ret, fn, mutex);
+
+ /* There's a hole here: libpthread now knows the lock is locked,
+ but the tool doesn't, so some other thread could run and detect
+ that the lock has been acquired by someone (this thread). Does
+ this matter? Not sure, but I don't think so. */
+
+ if (ret == 0 /*success*/) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+ pthread_mutex_t*,mutex);
+ } else {
+ if (ret != EBUSY)
+ DO_PthAPIerror( "pthread_mutex_trylock", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: mxtrylock -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+// pthread_mutex_timedlock. Identical logic to pthread_mutex_trylock.
+PTH_FUNC(int, pthreadZumutexZutimedlock, // pthread_mutex_timedlock
+ pthread_mutex_t *mutex,
+ void* timeout)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_mxtimedlock %p %p", mutex, timeout);
+ fflush(stderr);
+ }
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
+ pthread_mutex_t*,mutex, long,1/*isTryLock-ish*/);
+
+ CALL_FN_W_WW(ret, fn, mutex,timeout);
+
+ /* There's a hole here: libpthread now knows the lock is locked,
+ but the tool doesn't, so some other thread could run and detect
+ that the lock has been acquired by someone (this thread). Does
+ this matter? Not sure, but I don't think so. */
+
+ if (ret == 0 /*success*/) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+ pthread_mutex_t*,mutex);
+ } else {
+ if (ret != ETIMEDOUT)
+ DO_PthAPIerror( "pthread_mutex_timedlock", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: mxtimedlock -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+// pthread_mutex_unlock
+PTH_FUNC(int, pthreadZumutexZuunlock, // pthread_mutex_unlock
+ pthread_mutex_t *mutex)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_mxunlk %p", mutex); fflush(stderr);
+ }
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
+ pthread_mutex_t*,mutex);
+
+ CALL_FN_W_W(ret, fn, mutex);
+
+ if (ret == 0 /*success*/) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST,
+ pthread_mutex_t*,mutex);
+ } else {
+ DO_PthAPIerror( "pthread_mutex_unlock", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " mxunlk -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- pthread_cond_t functions ---*/
+/*----------------------------------------------------------------*/
+
+/* Handled: pthread_cond_wait pthread_cond_timedwait
+ pthread_cond_signal pthread_cond_broadcast
+
+ Unhandled: pthread_cond_init pthread_cond_destroy
+ -- are these important?
+*/
+
+// pthread_cond_wait
+PTH_FUNC(int, pthreadZucondZuwaitZAZa, // pthread_cond_wait@*
+ pthread_cond_t* cond, pthread_mutex_t* mutex)
+{
+ int ret;
+ OrigFn fn;
+ unsigned long mutex_is_valid;
+
+ VALGRIND_GET_ORIG_FN(fn);
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_cond_wait %p %p", cond, mutex);
+ fflush(stderr);
+ }
+
+ /* Tell the tool a cond-wait is about to happen, so it can check
+ for bogus argument values. In return it tells us whether it
+ thinks the mutex is valid or not. */
+ DO_CREQ_W_WW(mutex_is_valid,
+ _VG_USERREQ__HG_PTHREAD_COND_WAIT_PRE,
+ pthread_cond_t*,cond, pthread_mutex_t*,mutex);
+ assert(mutex_is_valid == 1 || mutex_is_valid == 0);
+
+ /* Tell the tool we're about to drop the mutex. This reflects the
+ fact that in a cond_wait, we show up holding the mutex, and the
+ call atomically drops the mutex and waits for the cv to be
+ signalled. */
+ if (mutex_is_valid) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
+ pthread_mutex_t*,mutex);
+ }
+
+ CALL_FN_W_WW(ret, fn, cond,mutex);
+
+ /* these conditionals look stupid, but compare w/ same logic for
+ pthread_cond_timedwait below */
+ if (ret == 0 && mutex_is_valid) {
+ /* and now we have the mutex again */
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+ pthread_mutex_t*,mutex);
+ }
+
+ if (ret == 0 && mutex_is_valid) {
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_COND_WAIT_POST,
+ pthread_cond_t*,cond, pthread_mutex_t*,mutex);
+ }
+
+ if (ret != 0) {
+ DO_PthAPIerror( "pthread_cond_wait", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " cowait -> %d >>\n", ret);
+ }
+
+ return ret;
+}
+
+
+// pthread_cond_timedwait
+PTH_FUNC(int, pthreadZucondZutimedwaitZAZa, // pthread_cond_timedwait@*
+ pthread_cond_t* cond, pthread_mutex_t* mutex,
+ struct timespec* abstime)
+{
+ int ret;
+ OrigFn fn;
+ unsigned long mutex_is_valid;
+ VALGRIND_GET_ORIG_FN(fn);
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_cond_timedwait %p %p %p",
+ cond, mutex, abstime);
+ fflush(stderr);
+ }
+
+ /* Tell the tool a cond-wait is about to happen, so it can check
+ for bogus argument values. In return it tells us whether it
+ thinks the mutex is valid or not. */
+ DO_CREQ_W_WW(mutex_is_valid,
+ _VG_USERREQ__HG_PTHREAD_COND_WAIT_PRE,
+ pthread_cond_t*,cond, pthread_mutex_t*,mutex);
+ assert(mutex_is_valid == 1 || mutex_is_valid == 0);
+
+ /* Tell the tool we're about to drop the mutex. This reflects the
+ fact that in a cond_wait, we show up holding the mutex, and the
+ call atomically drops the mutex and waits for the cv to be
+ signalled. */
+ if (mutex_is_valid) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
+ pthread_mutex_t*,mutex);
+ }
+
+ CALL_FN_W_WWW(ret, fn, cond,mutex,abstime);
+
+ if ((ret == 0 || ret == ETIMEDOUT) && mutex_is_valid) {
+ /* and now we have the mutex again */
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+ pthread_mutex_t*,mutex);
+ }
+
+ if (ret == 0 && mutex_is_valid) {
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_COND_WAIT_POST,
+ pthread_cond_t*,cond, pthread_mutex_t*,mutex);
+ }
+
+ if (ret != 0 && ret != ETIMEDOUT) {
+ DO_PthAPIerror( "pthread_cond_timedwait", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " cotimedwait -> %d >>\n", ret);
+ }
+
+ return ret;
+}
+
+
+// pthread_cond_signal
+PTH_FUNC(int, pthreadZucondZusignalZAZa, // pthread_cond_signal@*
+ pthread_cond_t* cond)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_cond_signal %p", cond);
+ fflush(stderr);
+ }
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_COND_SIGNAL_PRE,
+ pthread_cond_t*,cond);
+
+ CALL_FN_W_W(ret, fn, cond);
+
+ if (ret != 0) {
+ DO_PthAPIerror( "pthread_cond_signal", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " cosig -> %d >>\n", ret);
+ }
+
+ return ret;
+}
+
+
+// pthread_cond_broadcast
+// Note, this is pretty much identical, from a dependency-graph
+// point of view, with cond_signal, so the code is duplicated.
+// Maybe it should be commoned up.
+PTH_FUNC(int, pthreadZucondZubroadcastZAZa, // pthread_cond_broadcast@*
+ pthread_cond_t* cond)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_broadcast_signal %p", cond);
+ fflush(stderr);
+ }
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_COND_BROADCAST_PRE,
+ pthread_cond_t*,cond);
+
+ CALL_FN_W_W(ret, fn, cond);
+
+ if (ret != 0) {
+ DO_PthAPIerror( "pthread_cond_broadcast", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " cobro -> %d >>\n", ret);
+ }
+
+ return ret;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- pthread_rwlock_t functions ---*/
+/*----------------------------------------------------------------*/
+
+/* Handled: pthread_rwlock_init pthread_rwlock_destroy
+ pthread_rwlock_rdlock
+ pthread_rwlock_wrlock
+ pthread_rwlock_unlock
+
+ Unhandled: pthread_rwlock_timedrdlock
+ pthread_rwlock_tryrdlock
+
+ pthread_rwlock_timedwrlock
+ pthread_rwlock_trywrlock
+*/
+
+// pthread_rwlock_init
+PTH_FUNC(int, pthreadZurwlockZuinit, // pthread_rwlock_init
+ pthread_rwlock_t *rwl,
+ pthread_rwlockattr_t* attr)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_rwl_init %p", rwl); fflush(stderr);
+ }
+
+ CALL_FN_W_WW(ret, fn, rwl,attr);
+
+ if (ret == 0 /*success*/) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST,
+ pthread_rwlock_t*,rwl);
+ } else {
+ DO_PthAPIerror( "pthread_rwlock_init", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: rwl_init -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+// pthread_rwlock_destroy
+PTH_FUNC(int, pthreadZurwlockZudestroy, // pthread_rwlock_destroy
+ pthread_rwlock_t *rwl)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_rwl_destroy %p", rwl); fflush(stderr);
+ }
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_DESTROY_PRE,
+ pthread_rwlock_t*,rwl);
+
+ CALL_FN_W_W(ret, fn, rwl);
+
+ if (ret != 0) {
+ DO_PthAPIerror( "pthread_rwlock_destroy", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: rwl_destroy -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+PTH_FUNC(int, pthreadZurwlockZuwrlock, // pthread_rwlock_wrlock
+ pthread_rwlock_t* rwlock)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_rwl_wlk %p", rwlock); fflush(stderr);
+ }
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
+ pthread_rwlock_t*,rwlock, long,1/*isW*/);
+
+ CALL_FN_W_W(ret, fn, rwlock);
+
+ if (ret == 0 /*success*/) {
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
+ pthread_rwlock_t*,rwlock, long,1/*isW*/);
+ } else {
+ DO_PthAPIerror( "pthread_rwlock_wrlock", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: rwl_wlk -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+PTH_FUNC(int, pthreadZurwlockZurdlock, // pthread_rwlock_rdlock
+ pthread_rwlock_t* rwlock)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_rwl_rlk %p", rwlock); fflush(stderr);
+ }
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
+ pthread_rwlock_t*,rwlock, long,0/*!isW*/);
+
+ CALL_FN_W_W(ret, fn, rwlock);
+
+ if (ret == 0 /*success*/) {
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
+ pthread_rwlock_t*,rwlock, long,0/*!isW*/);
+ } else {
+ DO_PthAPIerror( "pthread_rwlock_rdlock", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: rwl_rlk -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+PTH_FUNC(int, pthreadZurwlockZuunlock, // pthread_rwlock_unlock
+ pthread_rwlock_t* rwlock)
+{
+ int ret;
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, "<< pthread_rwl_unlk %p", rwlock); fflush(stderr);
+ }
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE,
+ pthread_rwlock_t*,rwlock);
+
+ CALL_FN_W_W(ret, fn, rwlock);
+
+ if (ret == 0 /*success*/) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_POST,
+ pthread_rwlock_t*,rwlock);
+ } else {
+ DO_PthAPIerror( "pthread_rwlock_unlock", ret );
+ }
+
+ if (TRACE_PTH_FNS) {
+ fprintf(stderr, " :: rwl_unlk -> %d >>\n", ret);
+ }
+ return ret;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- POSIX semaphores ---*/
+/*----------------------------------------------------------------*/
+
+#include <semaphore.h>
+
+#define TRACE_SEM_FNS 0
+
+/* Handled:
+ int sem_init(sem_t *sem, int pshared, unsigned value);
+ int sem_destroy(sem_t *sem);
+ int sem_wait(sem_t *sem);
+ int sem_post(sem_t *sem);
+
+ Unhandled:
+ int sem_trywait(sem_t *sem);
+ int sem_timedwait(sem_t *restrict sem,
+ const struct timespec *restrict abs_timeout);
+*/
+
+/* glibc-2.5 has sem_init@@GLIBC_2.2.5 (amd64-linux)
+ and sem_init@@GLIBC_2.1 (x86-linux): match sem_init@* */
+PTH_FUNC(int, semZuinitZAZa, sem_t* sem, int pshared, unsigned long value)
+{
+ OrigFn fn;
+ int ret;
+ VALGRIND_GET_ORIG_FN(fn);
+
+ if (TRACE_SEM_FNS) {
+ fprintf(stderr, "<< sem_init(%p,%d,%lu) ", sem,pshared,value);
+ fflush(stderr);
+ }
+
+ CALL_FN_W_WWW(ret, fn, sem,pshared,value);
+
+ if (ret == 0) {
+ /* Probably overly paranoid, but still ... */
+ DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_ZAPSTACK, sem_t*,sem);
+ } else {
+ DO_PthAPIerror( "sem_init", errno );
+ }
+
+ if (TRACE_SEM_FNS) {
+ fprintf(stderr, " sem_init -> %d >>\n", ret);
+ fflush(stderr);
+ }
+
+ return ret;
+}
+
+
+/* glibc-2.5 has sem_destroy@@GLIBC_2.2.5 (amd64-linux)
+ and sem_destroy@@GLIBC_2.1 (x86-linux); match sem_destroy@* */
+PTH_FUNC(int, semZudestroyZAZa, sem_t* sem)
+{
+ OrigFn fn;
+ int ret;
+ VALGRIND_GET_ORIG_FN(fn);
+
+ if (TRACE_SEM_FNS) {
+ fprintf(stderr, "<< sem_destroy(%p) ", sem);
+ fflush(stderr);
+ }
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_ZAPSTACK, sem_t*,sem);
+
+ CALL_FN_W_W(ret, fn, sem);
+
+ if (ret != 0) {
+ DO_PthAPIerror( "sem_destroy", errno );
+ }
+
+ if (TRACE_SEM_FNS) {
+ fprintf(stderr, " sem_destroy -> %d >>\n", ret);
+ fflush(stderr);
+ }
+
+ return ret;
+}
+
+
+/* glibc-2.5 has sem_wait (amd64-linux); match sem_wait
+ and sem_wait@@GLIBC_2.1 (x86-linux); match sem_wait@* */
+/* wait: decrement semaphore - acquire lockage */
+static int sem_wait_WRK(sem_t* sem)
+{
+ OrigFn fn;
+ int ret;
+ VALGRIND_GET_ORIG_FN(fn);
+
+ if (TRACE_SEM_FNS) {
+ fprintf(stderr, "<< sem_wait(%p) ", sem);
+ fflush(stderr);
+ }
+
+ CALL_FN_W_W(ret, fn, sem);
+
+ if (ret == 0) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEMWAIT_POST, sem_t*,sem);
+ } else {
+ DO_PthAPIerror( "sem_wait", errno );
+ }
+
+ if (TRACE_SEM_FNS) {
+ fprintf(stderr, " sem_wait -> %d >>\n", ret);
+ fflush(stderr);
+ }
+
+ return ret;
+}
+PTH_FUNC(int, semZuwait, sem_t* sem) { /* sem_wait */
+ return sem_wait_WRK(sem);
+}
+PTH_FUNC(int, semZuwaitZAZa, sem_t* sem) { /* sem_wait@* */
+ return sem_wait_WRK(sem);
+}
+
+
+/* glibc-2.5 has sem_post (amd64-linux); match sem_post
+ and sem_post@@GLIBC_2.1 (x86-linux); match sem_post@* */
+/* post: increment semaphore - release lockage */
+static int sem_post_WRK(sem_t* sem)
+{
+ OrigFn fn;
+ int ret;
+
+ VALGRIND_GET_ORIG_FN(fn);
+
+ if (TRACE_SEM_FNS) {
+ fprintf(stderr, "<< sem_post(%p) ", sem);
+ fflush(stderr);
+ }
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEMPOST_PRE, sem_t*,sem);
+
+ CALL_FN_W_W(ret, fn, sem);
+
+ if (ret != 0) {
+ DO_PthAPIerror( "sem_post", errno );
+ }
+
+ if (TRACE_SEM_FNS) {
+ fprintf(stderr, " sem_post -> %d >>\n", ret);
+ fflush(stderr);
+ }
+
+ return ret;
+}
+PTH_FUNC(int, semZupost, sem_t* sem) { /* sem_post */
+ return sem_post_WRK(sem);
+}
+PTH_FUNC(int, semZupostZAZa, sem_t* sem) { /* sem_post@* */
+ return sem_post_WRK(sem);
+}
+
+
+
+/*----------------------------------------------------------------*/
+/*--- Qt 4 threading functions (w/ GNU name mangling) ---*/
+/*----------------------------------------------------------------*/
+
+/* Handled: QMutex::lock()
+ QMutex::unlock()
+ QMutex::tryLock
+ QReadWriteLock::lockForRead()
+ QReadWriteLock::lockForWrite()
+ QReadWriteLock::unlock()
+
+ Unhandled: QMutex::tryLock(int)
+ QReadWriteLock::tryLockForRead(int)
+ QReadWriteLock::tryLockForRead()
+ QReadWriteLock::tryLockForWrite(int)
+ QReadWriteLock::tryLockForWrite()
+
+ maybe not the next 3; qt-4.3.1 on Unix merely
+ implements QWaitCondition using pthread_cond_t
+ QWaitCondition::wait(QMutex*, unsigned long)
+ QWaitCondition::wakeAll()
+ QWaitCondition::wakeOne()
+*/
+
+// soname is libQtCore.so.4 ; match against libQtCore.so*
+#define QT4_FUNC(ret_ty, f, args...) \
+ ret_ty I_WRAP_SONAME_FNNAME_ZZ(libQtCoreZdsoZa,f)(args); \
+ ret_ty I_WRAP_SONAME_FNNAME_ZZ(libQtCoreZdsoZa,f)(args)
+
+// QMutex::lock()
+QT4_FUNC(void, ZuZZN6QMutex4lockEv, // _ZN6QMutex4lockEv == QMutex::lock()
+ void* self)
+{
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, "<< QMutex::lock %p", self); fflush(stderr);
+ }
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
+ void*,self, long,0/*!isTryLock*/);
+
+ CALL_FN_v_W(fn, self);
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+ void*, self);
+
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, " :: Q::lock done >>\n");
+ }
+}
+
+// QMutex::unlock()
+QT4_FUNC(void, ZuZZN6QMutex6unlockEv, // _ZN6QMutex6unlockEv == QMutex::unlock()
+ void* self)
+{
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, "<< QMutex::unlock %p", self); fflush(stderr);
+ }
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
+ void*, self);
+
+ CALL_FN_v_W(fn, self);
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST,
+ void*, self);
+
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, " Q::unlock done >>\n");
+ }
+}
+
+// QMutex::tryLock
+// _ZN6QMutex7tryLockEv == bool QMutex::tryLock()
+// using 'long' to mimic C++ 'bool'
+QT4_FUNC(long, ZuZZN6QMutex7tryLockEv,
+ void* self)
+{
+ OrigFn fn;
+ long ret;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, "<< QMutex::tryLock %p", self); fflush(stderr);
+ }
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
+ void*,self, long,1/*isTryLock*/);
+
+ CALL_FN_W_W(ret, fn, self);
+
+ // assumes that only the low 8 bits of the 'bool' are significant
+ if (ret & 0xFF) {
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+ void*, self);
+ }
+
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, " :: Q::tryLock -> %lu >>\n", ret);
+ }
+
+ return ret;
+}
+
+
+// QReadWriteLock::lockForRead()
+// _ZN14QReadWriteLock11lockForReadEv == QReadWriteLock::lockForRead()
+QT4_FUNC(void, ZuZZN14QReadWriteLock11lockForReadEv,
+ // _ZN14QReadWriteLock11lockForReadEv
+ void* self)
+{
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, "<< QReadWriteLock::lockForRead %p", self);
+ fflush(stderr);
+ }
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
+ void*,self, long,0/*!isW*/);
+
+ CALL_FN_v_W(fn, self);
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
+ void*,self, long,0/*!isW*/);
+
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, " :: Q::lockForRead :: done >>\n");
+ }
+}
+
+// QReadWriteLock::lockForWrite()
+// _ZN14QReadWriteLock12lockForWriteEv == QReadWriteLock::lockForWrite()
+QT4_FUNC(void, ZuZZN14QReadWriteLock12lockForWriteEv,
+ // _ZN14QReadWriteLock12lockForWriteEv
+ void* self)
+{
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, "<< QReadWriteLock::lockForWrite %p", self);
+ fflush(stderr);
+ }
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
+ void*,self, long,1/*isW*/);
+
+ CALL_FN_v_W(fn, self);
+
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
+ void*,self, long,1/*isW*/);
+
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, " :: Q::lockForWrite :: done >>\n");
+ }
+}
+
+// QReadWriteLock::unlock()
+// _ZN14QReadWriteLock6unlockEv == QReadWriteLock::unlock()
+QT4_FUNC(void, ZuZZN14QReadWriteLock6unlockEv,
+ // _ZN14QReadWriteLock6unlockEv
+ void* self)
+{
+ OrigFn fn;
+ VALGRIND_GET_ORIG_FN(fn);
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, "<< QReadWriteLock::unlock %p", self);
+ fflush(stderr);
+ }
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE,
+ void*,self);
+
+ CALL_FN_v_W(fn, self);
+
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_POST,
+ void*,self);
+
+ if (TRACE_QT4_FNS) {
+ fprintf(stderr, " :: Q::unlock :: done >>\n");
+ }
+}
+
+
+/*--------------------------------------------------------------------*/
+/*--- end tc_intercepts.c ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/hg_main.c b/helgrind/hg_main.c
new file mode 100644
index 0000000..0a97571
--- /dev/null
+++ b/helgrind/hg_main.c
@@ -0,0 +1,8782 @@
+
+/*--------------------------------------------------------------------*/
+/*--- Helgrind: a Valgrind tool for detecting errors ---*/
+/*--- in threaded programs. hg_main.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+ This file is part of Helgrind, a Valgrind tool for detecting errors
+ in threaded programs.
+
+ Copyright (C) 2007-2007 OpenWorks LLP
+ info@open-works.co.uk
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307, USA.
+
+ The GNU General Public License is contained in the file COPYING.
+
+ Neither the names of the U.S. Department of Energy nor the
+ University of California nor the names of its contributors may be
+ used to endorse or promote products derived from this software
+ without prior written permission.
+*/
+
+#include "pub_tool_basics.h"
+#include "pub_tool_aspacemgr.h"
+#include "pub_tool_libcassert.h"
+#include "pub_tool_libcbase.h"
+#include "pub_tool_libcprint.h"
+#include "pub_tool_mallocfree.h"
+#include "pub_tool_threadstate.h"
+#include "pub_tool_tooliface.h"
+#include "pub_tool_hashtable.h"
+#include "pub_tool_replacemalloc.h"
+#include "pub_tool_machine.h"
+#include "pub_tool_options.h"
+#include "pub_tool_xarray.h"
+#include "pub_tool_stacktrace.h"
+
+#include "helgrind.h"
+
+#define HG_(str) VGAPPEND(vgHelgrind_,str)
+#include "hg_wordfm.h"
+#include "hg_wordset.h"
+
+/*----------------------------------------------------------------*/
+/*--- ---*/
+/*----------------------------------------------------------------*/
+
+/* Note there are a whole bunch of ugly double casts of the form
+ (Word*)(void*)&p. These placate gcc at -O2. The obvious form
+ (Word*)&p causes gcc to complain that 'dereferencing a type-punned
+ pointer ill break strict-aliasing rules'. It stops complaining
+ when the intermediate void* type is inserted. Is this a reasonable
+ "fix"? I don't know. */
+
+// FIXME what is supposed to happen to locks in memory which
+// is relocated as a result of client realloc?
+
+// FIXME some kind of ownership recycling problem in
+// init_thread_specific_state() for programs which use the same thread
+// slot more than once?
+
+// FIXME put referencing ThreadId into Thread and get
+// rid of the slow reverse mapping function.
+
+// FIXME accesses to NoAccess areas: change state to Excl?
+
+// FIXME report errors for accesses of NoAccess memory?
+
+// FIXME pth_cond_wait/timedwait wrappers. Even if these fail,
+// the thread still holds the lock.
+
+/* ------------ Debug/trace options ------------ */
+
+// this is:
+// shadow_mem_make_NoAccess: 29156 SMs, 1728 scanned
+// happens_before_wrk: 1000
+// ev__post_thread_join: 3360 SMs, 29 scanned, 252 re-Excls
+#define SHOW_EXPENSIVE_STUFF 0
+
+// 0 for silent, 1 for some stuff, 2 for lots of stuff
+#define SHOW_EVENTS 0
+
+// Flags for controlling for which events sanity checking is done
+#define SCE_THREADS (1<<0) // Sanity check at thread create/join
+#define SCE_LOCKS (1<<1) // Sanity check at lock events
+#define SCE_BIGRANGE (1<<2) // Sanity check at big mem range events
+#define SCE_ACCESS (1<<3) // Sanity check at mem accesses
+#define SCE_LAOG (1<<4) // Sanity check at significant LAOG events
+
+#define SCE_BIGRANGE_T 256 // big mem range minimum size
+
+
+/* For the shadow mem cache stuff we may want more intrusive
+ checks. Unfortunately there's no almost-zero-cost way to make them
+ selectable at run time. Hence set the #if 0 to #if 1 and
+ rebuild if you want them. */
+#if 0
+# define SCE_CACHELINE 1 /* do sanity-check CacheLine stuff */
+# define inline __attribute__((noinline))
+ /* probably want to ditch -fomit-frame-pointer too */
+#else
+# define SCE_CACHELINE 0 /* don't sanity-check CacheLine stuff */
+#endif
+
+static void all__sanity_check ( Char* who ); /* fwds */
+
+#define HG_CLI__MALLOC_REDZONE_SZB 16 /* let's say */
+
+// 0 for none, 1 for dump at end of run
+#define SHOW_DATA_STRUCTURES 0
+
+
+/* ------------ Command line options ------------ */
+
+// 0 = no segments at all
+// 1 = segments at thread create/join
+// 2 = as 1 + segments at condition variable signal/broadcast/wait too
+static Int clo_happens_before = 2; /* default setting */
+
+/* Generate .vcg output of the happens-before graph?
+ 0: no 1: yes, without VTSs 2: yes, with VTSs */
+static Int clo_gen_vcg = 0;
+
+/* When comparing race errors for equality, should the race address be
+ taken into account? For users, no, but for verification purposes
+ (regtesting) this is sometimes important. */
+static Bool clo_cmp_race_err_addrs = False;
+
+/* Tracing memory accesses, so we can see what's going on.
+ clo_trace_addr is the address to monitor. clo_trace_level = 0 for
+ no tracing, 1 for summary, 2 for detailed. */
+static Addr clo_trace_addr = 0;
+static Int clo_trace_level = 0;
+
+/* Sanity check level. This is an or-ing of
+ SCE_{THREADS,LOCKS,BIGRANGE,ACCESS,LAOG}. */
+static Int clo_sanity_flags = 0;
+
+/* This has to do with printing error messages. See comments on
+ announce_threadset() and summarise_threadset(). Perhaps it
+ should be a command line option. */
+#define N_THREADS_TO_ANNOUNCE 5
+
+
+/* ------------ Misc comments ------------ */
+
+// FIXME: don't hardwire initial entries for root thread.
+// Instead, let the pre_thread_ll_create handler do this.
+
+// FIXME: when a SecMap is completely set via and address range
+// setting operation to a non-ShR/M state, clear its .mbHasShared
+// bit
+
+/* FIXME: figure out what the real rules are for Excl->ShR/M
+ transitions w.r.t locksets.
+
+ Muelenfeld thesis Sec 2.2.1 p 8/9 says that
+
+ When another thread accesses the memory location, the lock-set
+ is initialized with all active locks and the algorithm reports
+ the next access that results in an empty lock-set.
+
+ What does "all active locks" mean? All locks held by the accessing
+ thread, or all locks held by the system as a whole?
+
+ However: Muelenfeld's enhanced Helgrind (eraser_mem_read_word)
+ seems to use simply the set of locks held by the thread causing the
+ transition into a shared state at the time of the transition:
+
+ *sword = SW(Vge_Shar, packLockSet(thread_locks_rd[tid]));
+
+ Original Eraser paper also says "all active locks".
+*/
+
+// Major stuff to fix:
+// - reader-writer locks
+
+/* Thread async exit:
+
+ remove the map_threads entry
+ leave the Thread object in place
+ complain if holds any locks
+
+ unlike with Join, do not change any memory states
+
+ I _think_ this is correctly handled now.
+*/
+
+/*----------------------------------------------------------------*/
+/*--- Some very basic stuff ---*/
+/*----------------------------------------------------------------*/
+
+static void* hg_zalloc ( SizeT n ) {
+ void* p;
+ tl_assert(n > 0);
+ p = VG_(malloc)( n );
+ tl_assert(p);
+ VG_(memset)(p, 0, n);
+ return p;
+}
+static void hg_free ( void* p ) {
+ tl_assert(p);
+ VG_(free)(p);
+}
+
+/* Round a up to the next multiple of N. N must be a power of 2 */
+#define ROUNDUP(a, N) ((a + N - 1) & ~(N-1))
+/* Round a down to the next multiple of N. N must be a power of 2 */
+#define ROUNDDN(a, N) ((a) & ~(N-1))
+
+#ifdef HAVE_BUILTIN_EXPECT
+#define LIKELY(cond) __builtin_expect((cond),1)
+#define UNLIKELY(cond) __builtin_expect((cond),0)
+#else
+#define LIKELY(cond) (cond)
+#define UNLIKELY(cond) (cond)
+#endif
+
+
+/*----------------------------------------------------------------*/
+/*--- Primary data definitions ---*/
+/*----------------------------------------------------------------*/
+
+/* These are handles for thread segments. CONSTRAINTS: Must be small
+ ints numbered from zero, since 30-bit versions of them must are
+ used to represent Exclusive shadow states. Are used as keys in
+ WordFMs so must be castable to Words at the appropriate points. */
+typedef UInt SegmentID;
+
+
+/* These are handles for Word sets. CONSTRAINTS: must be (very) small
+ ints numbered from zero, since < 30-bit versions of them are used to
+ encode thread-sets and lock-sets in 32-bit shadow words. */
+typedef WordSet WordSetID;
+
+
+/* Stores information about a thread. Addresses of these also serve
+ as unique thread identifiers and so are never freed, so they should
+ be as small as possible. */
+typedef
+ struct _Thread {
+ /* ADMIN */
+ struct _Thread* admin;
+ UInt magic;
+ /* USEFUL */
+ WordSetID locksetA; /* WordSet of Lock* currently held by thread */
+ WordSetID locksetW; /* subset of locksetA held in w-mode */
+ SegmentID csegid; /* current thread segment for thread */
+ /* EXPOSITION */
+ /* Place where parent was when this thread was created. */
+ ExeContext* created_at;
+ Bool announced;
+ /* Index for generating references in error messages. */
+ Int errmsg_index;
+ }
+ Thread;
+
+
+/* Stores information about a lock's current state. These are
+ allocated and later freed (when the containing memory becomes
+ NoAccess). This gives a problem for the XError type, which
+ contains Lock*s. Solution is to copy any Lock which is to be
+ incorporated into an XErrors, so as to make it independent from the
+ 'normal' collection of Locks, which can come and go. When the lock
+ is copied, its .magic is changed from LockN_Magic to
+ LockP_Magic. */
+
+/* Lock kinds. */
+typedef
+ enum {
+ LK_mbRec=1001, /* normal mutex, possibly recursive */
+ LK_nonRec, /* normal mutex, definitely non recursive */
+ LK_rdwr /* reader-writer lock */
+ }
+ LockKind;
+
+typedef
+ struct _Lock {
+ /* ADMIN */
+ struct _Lock* admin;
+ ULong unique; /* used for persistence-hashing */
+ UInt magic; /* LockN_MAGIC or LockP_MAGIC */
+ /* EXPOSITION */
+ /* Place where lock first came to the attention of Helgrind. */
+ ExeContext* appeared_at;
+ /* Place where the lock most recently made an unlocked->locked
+ transition. */
+ ExeContext* acquired_at;
+ /* USEFUL-STATIC */
+ Addr guestaddr; /* Guest address of lock */
+ LockKind kind; /* what kind of lock this is */
+ /* USEFUL-DYNAMIC */
+ Bool heldW;
+ WordBag* heldBy; /* bag of threads that hold this lock */
+ /* .heldBy is NULL: lock is unheld, and .heldW is meaningless
+ but arbitrarily set to False
+ .heldBy is non-NULL:
+ .heldW is True: lock is w-held by threads in heldBy
+ .heldW is False: lock is r-held by threads in heldBy
+ Either way, heldBy may not validly be an empty Bag.
+
+ for LK_nonRec, r-holdings are not allowed, and w-holdings may
+ only have sizeTotal(heldBy) == 1
+
+ for LK_mbRec, r-holdings are not allowed, and w-holdings may
+ only have sizeUnique(heldBy) == 1
+
+ for LK_rdwr, w-holdings may only have sizeTotal(heldBy) == 1 */
+ }
+ Lock;
+
+
+/* Stores information about thread segments. .prev can be NULL only
+ when this is the first segment for the thread. .other is NULL
+ unless this segment depends on a message (create, join, signal)
+ from some other thread. Segments are never freed (!) */
+typedef
+ struct _Segment {
+ /* ADMIN */
+ struct _Segment* admin;
+ UInt magic;
+ /* USEFUL */
+ UInt dfsver; /* Version # for depth-first searches */
+ Thread* thr; /* The thread that I am part of */
+ struct _Segment* prev; /* The previous segment in this thread */
+ struct _Segment* other; /* Possibly a segment from some other
+ thread, which happened-before me */
+ XArray* vts; /* XArray of ScalarTS */
+ /* DEBUGGING ONLY: what does 'other' arise from?
+ c=thread creation, j=join, s=cvsignal, S=semaphore */
+ Char other_hint;
+ }
+ Segment;
+
+
+/* ------ CacheLine ------ */
+
+#define N_LINE_BITS 5 /* must be >= 3 */
+#define N_LINE_ARANGE (1 << N_LINE_BITS)
+#define N_LINE_TREES (N_LINE_ARANGE >> 3)
+
+typedef
+ struct {
+ UShort descrs[N_LINE_TREES];
+ UInt svals[N_LINE_ARANGE]; // == N_LINE_TREES * 8
+ }
+ CacheLine;
+
+#define TREE_DESCR_16_0 (1<<0)
+#define TREE_DESCR_32_0 (1<<1)
+#define TREE_DESCR_16_1 (1<<2)
+#define TREE_DESCR_64 (1<<3)
+#define TREE_DESCR_16_2 (1<<4)
+#define TREE_DESCR_32_1 (1<<5)
+#define TREE_DESCR_16_3 (1<<6)
+#define TREE_DESCR_8_0 (1<<7)
+#define TREE_DESCR_8_1 (1<<8)
+#define TREE_DESCR_8_2 (1<<9)
+#define TREE_DESCR_8_3 (1<<10)
+#define TREE_DESCR_8_4 (1<<11)
+#define TREE_DESCR_8_5 (1<<12)
+#define TREE_DESCR_8_6 (1<<13)
+#define TREE_DESCR_8_7 (1<<14)
+#define TREE_DESCR_DTY (1<<15)
+
+typedef
+ struct {
+ UInt dict[4]; /* can represent up to 4 diff values in the line */
+ UChar ix2s[N_LINE_ARANGE/4]; /* array of N_LINE_ARANGE 2-bit
+ dict indexes */
+ /* if dict[0] == 0 then dict[1] is the index of the CacheLineF
+ to use */
+ }
+ CacheLineZ; /* compressed rep for a cache line */
+
+typedef
+ struct {
+ Bool inUse;
+ UInt w32s[N_LINE_ARANGE];
+ }
+ CacheLineF; /* full rep for a cache line */
+
+
+/* Shadow memory.
+ Primary map is a WordFM Addr SecMap*.
+ SecMaps cover some page-size-ish section of address space and hold
+ a compressed representation.
+ CacheLine-sized chunks of SecMaps are copied into a Cache, being
+ decompressed when moved into the cache and recompressed on the
+ way out. Because of this, the cache must operate as a writeback
+ cache, not a writethrough one.
+*/
+/* See comments below on shadow_mem_make_NoAccess re performance
+ effects of N_SECMAP_BITS settings. On a 2.4GHz Core2,
+ starting/quitting OOo (32-bit), I have these rough numbers:
+ N_SECMAP_BITS = 11 2m23
+ N_SECMAP_BITS = 12 1m58
+ N_SECMAP_BITS = 13 1m53
+
+ Each SecMap must hold a power-of-2 number of CacheLines. Hence
+ N_SECMAP_BITS must >= N_LINE_BITS.
+*/
+#define N_SECMAP_BITS 13
+#define N_SECMAP_ARANGE (1 << N_SECMAP_BITS)
+
+// # CacheLines held by a SecMap
+#define N_SECMAP_ZLINES (N_SECMAP_ARANGE / N_LINE_ARANGE)
+typedef
+ struct {
+ UInt magic;
+ Bool mbHasLocks; /* hint: any locks in range? safe: True */
+ Bool mbHasShared; /* hint: any ShM/ShR states in range? safe: True */
+ CacheLineZ linesZ[N_SECMAP_ZLINES];
+ CacheLineF* linesF;
+ Int linesF_size;
+ }
+ SecMap;
+
+typedef
+ struct {
+ Int line_no; /* which Z-line are we in? */
+ Int word_no; /* inside the line, which word is current? */
+ }
+ SecMapIter;
+
+static void initSecMapIter ( SecMapIter* itr ) {
+ itr->line_no = 0;
+ itr->word_no = 0;
+}
+
+/* Get the current val, and move to the next position. This is called
+ a huge amount in some programs (eg OpenOffice). Hence the
+ 'inline'. */
+static UWord stats__secmap_iterator_steppings; /* fwds */
+
+inline
+static Bool stepSecMapIter ( /*OUT*/UInt** pVal,
+ /*MOD*/SecMapIter* itr, SecMap* sm )
+{
+ CacheLineZ* lineZ = NULL;
+ CacheLineF* lineF = NULL;
+ /* Either it points to a valid place, or to (-1,-1) */
+ stats__secmap_iterator_steppings++;
+ if (UNLIKELY(itr->line_no == -1)) {
+ tl_assert(itr->word_no == -1);
+ return False;
+ }
+ /* so now it must be a valid place in the SecMap. */
+ if (0) VG_(printf)("%p %d %d\n", sm, (Int)itr->line_no, (Int)itr->word_no);
+ tl_assert(itr->line_no >= 0 && itr->line_no < N_SECMAP_ZLINES);
+ lineZ = &sm->linesZ[itr->line_no];
+ if (UNLIKELY(lineZ->dict[0] == 0)) {
+ tl_assert(sm->linesF);
+ tl_assert(sm->linesF_size > 0);
+ tl_assert(lineZ->dict[1] >= 0);
+ tl_assert(lineZ->dict[1] < sm->linesF_size);
+ lineF = &sm->linesF[ lineZ->dict[1] ];
+ tl_assert(lineF->inUse);
+ tl_assert(itr->word_no >= 0 && itr->word_no < N_LINE_ARANGE);
+ *pVal = &lineF->w32s[itr->word_no];
+ itr->word_no++;
+ if (itr->word_no == N_LINE_ARANGE)
+ itr->word_no = 0;
+ } else {
+ tl_assert(itr->word_no >= 0 && itr->word_no <= 3);
+ tl_assert(lineZ->dict[itr->word_no] != 0);
+ *pVal = &lineZ->dict[itr->word_no];
+ itr->word_no++;
+ if (itr->word_no == 4 || lineZ->dict[itr->word_no] == 0)
+ itr->word_no = 0;
+ }
+
+ if (itr->word_no == 0) {
+ itr->line_no++;
+ if (itr->line_no == N_SECMAP_ZLINES) {
+ itr->line_no = -1;
+ itr->word_no = -1;
+ }
+ }
+
+ return True;
+}
+
+/* ------ Cache ------ */
+
+#define N_WAY_BITS 16
+#define N_WAY_NENT (1 << N_WAY_BITS)
+
+/* Each tag is the address of the associated CacheLine, rounded down
+ to a CacheLine address boundary. A CacheLine size must be a power
+ of 2 and must be 8 or more. Hence an easy way to initialise the
+ cache so it is empty is to set all the tag values to any value % 8
+ != 0, eg 1. This means all queries in the cache initially miss.
+ It does however require us to detect and not writeback, any line
+ with a bogus tag. */
+typedef
+ struct {
+ CacheLine lyns0[N_WAY_NENT];
+ Addr tags0[N_WAY_NENT];
+ }
+ Cache;
+
+
+/* --------- Primary data structures --------- */
+
+/* Admin linked list of Threads */
+static Thread* admin_threads = NULL;
+
+/* Admin linked list of Locks */
+static Lock* admin_locks = NULL;
+
+/* Admin linked list of Segments */
+static Segment* admin_segments = NULL;
+
+/* Shadow memory primary map */
+static WordFM* map_shmem = NULL; /* WordFM Addr SecMap* */
+static Cache cache_shmem;
+
+/* Mapping table for core ThreadIds to Thread* */
+static Thread** map_threads = NULL; /* Array[VG_N_THREADS] of Thread* */
+
+/* Mapping table for thread segments IDs to Segment* */
+static WordFM* map_segments = NULL; /* WordFM SegmentID Segment* */
+
+/* Mapping table for lock guest addresses to Lock* */
+static WordFM* map_locks = NULL; /* WordFM LockAddr Lock* */
+
+/* The word-set universes for thread sets and lock sets. */
+static WordSetU* univ_tsets = NULL; /* sets of Thread* */
+static WordSetU* univ_lsets = NULL; /* sets of Lock* */
+static WordSetU* univ_laog = NULL; /* sets of Lock*, for LAOG */
+
+/* never changed; we only care about its address. Is treated as if it
+ was a standard userspace lock. Also we have a Lock* describing it
+ so it can participate in lock sets in the usual way. */
+static Int __bus_lock = 0;
+static Lock* __bus_lock_Lock = NULL;
+
+
+/*----------------------------------------------------------------*/
+/*--- Simple helpers for the data structures ---*/
+/*----------------------------------------------------------------*/
+
+static UWord stats__lockN_acquires = 0;
+static UWord stats__lockN_releases = 0;
+
+static ThreadId map_threads_maybe_reverse_lookup_SLOW ( Thread* ); /*fwds*/
+
+#define Thread_MAGIC 0x504fc5e5
+#define LockN_MAGIC 0x6545b557 /* normal nonpersistent locks */
+#define LockP_MAGIC 0x755b5456 /* persistent (copied) locks */
+#define Segment_MAGIC 0x49e94d81
+#define SecMap_MAGIC 0x571e58cb
+
+static UWord stats__mk_Segment = 0;
+
+/* --------- Constructors --------- */
+
+static inline Bool is_sane_LockN ( Lock* lock ); /* fwds */
+
+static Thread* mk_Thread ( SegmentID csegid ) {
+ static Int indx = 1;
+ Thread* thread = hg_zalloc( sizeof(Lock) );
+ thread->locksetA = HG_(emptyWS)( univ_lsets );
+ thread->locksetW = HG_(emptyWS)( univ_lsets );
+ thread->csegid = csegid;
+ thread->magic = Thread_MAGIC;
+ thread->created_at = NULL;
+ thread->announced = False;
+ thread->errmsg_index = indx++;
+ thread->admin = admin_threads;
+ admin_threads = thread;
+ return thread;
+}
+// Make a new lock which is unlocked (hence ownerless)
+static Lock* mk_LockN ( LockKind kind, Addr guestaddr ) {
+ static ULong unique = 0;
+ Lock* lock = hg_zalloc( sizeof(Lock) );
+ lock->admin = admin_locks;
+ lock->unique = unique++;
+ lock->magic = LockN_MAGIC;
+ lock->appeared_at = NULL;
+ lock->acquired_at = NULL;
+ lock->guestaddr = guestaddr;
+ lock->kind = kind;
+ lock->heldW = False;
+ lock->heldBy = NULL;
+ tl_assert(is_sane_LockN(lock));
+ admin_locks = lock;
+ return lock;
+}
+static Segment* mk_Segment ( Thread* thr, Segment* prev, Segment* other ) {
+ Segment* seg = hg_zalloc( sizeof(Segment) );
+ seg->dfsver = 0;
+ seg->thr = thr;
+ seg->prev = prev;
+ seg->other = other;
+ seg->vts = NULL;
+ seg->other_hint = ' ';
+ seg->magic = Segment_MAGIC;
+ seg->admin = admin_segments;
+ admin_segments = seg;
+ stats__mk_Segment++;
+ return seg;
+}
+
+static inline Bool is_sane_Segment ( Segment* seg ) {
+ return seg != NULL && seg->magic == Segment_MAGIC;
+}
+static inline Bool is_sane_Thread ( Thread* thr ) {
+ return thr != NULL && thr->magic == Thread_MAGIC;
+}
+
+static Bool is_sane_Bag_of_Threads ( WordBag* bag )
+{
+ Thread* thr;
+ Word count;
+ HG_(initIterBag)( bag );
+ while (HG_(nextIterBag)( bag, (Word*)(void*)&thr, &count )) {
+ if (count < 1) return False;
+ if (!is_sane_Thread(thr)) return False;
+ }
+ HG_(doneIterBag)( bag );
+ return True;
+}
+static Bool is_sane_Lock_BASE ( Lock* lock )
+{
+ if (lock == NULL
+ || (lock->magic != LockN_MAGIC && lock->magic != LockP_MAGIC))
+ return False;
+ switch (lock->kind) {
+ case LK_mbRec: case LK_nonRec: case LK_rdwr: break;
+ default: return False;
+ }
+ if (lock->heldBy == NULL) {
+ if (lock->acquired_at != NULL) return False;
+ /* Unheld. We arbitrarily require heldW to be False. */
+ return !lock->heldW;
+ } else {
+ if (lock->acquired_at == NULL) return False;
+ }
+
+ /* If heldBy is non-NULL, we require it to contain at least one
+ thread. */
+ if (HG_(isEmptyBag)(lock->heldBy))
+ return False;
+
+ /* Lock is either r- or w-held. */
+ if (!is_sane_Bag_of_Threads(lock->heldBy))
+ return False;
+ if (lock->heldW) {
+ /* Held in write-mode */
+ if ((lock->kind == LK_nonRec || lock->kind == LK_rdwr)
+ && !HG_(isSingletonTotalBag)(lock->heldBy))
+ return False;
+ } else {
+ /* Held in read-mode */
+ if (lock->kind != LK_rdwr) return False;
+ }
+ return True;
+}
+static inline Bool is_sane_LockP ( Lock* lock ) {
+ return lock != NULL
+ && lock->magic == LockP_MAGIC
+ && is_sane_Lock_BASE(lock);
+}
+static inline Bool is_sane_LockN ( Lock* lock ) {
+ return lock != NULL
+ && lock->magic == LockN_MAGIC
+ && is_sane_Lock_BASE(lock);
+}
+static inline Bool is_sane_LockNorP ( Lock* lock ) {
+ return is_sane_Lock_BASE(lock);
+}
+
+/* Release storage for a Lock. Also release storage in .heldBy, if
+ any. */
+static void del_LockN ( Lock* lk )
+{
+ tl_assert(is_sane_LockN(lk));
+ if (lk->heldBy)
+ HG_(deleteBag)( lk->heldBy );
+ VG_(memset)(lk, 0xAA, sizeof(*lk));
+ hg_free(lk);
+}
+
+/* Update 'lk' to reflect that 'thr' now has a write-acquisition of
+ it. This is done strictly: only combinations resulting from
+ correct program and libpthread behaviour are allowed. */
+static void lockN_acquire_writer ( Lock* lk, Thread* thr )
+{
+ tl_assert(is_sane_LockN(lk));
+ tl_assert(is_sane_Thread(thr));
+
+ stats__lockN_acquires++;
+
+ /* EXPOSITION only */
+ /* We need to keep recording snapshots of where the lock was
+ acquired, so as to produce better lock-order error messages. */
+ if (lk->acquired_at == NULL) {
+ ThreadId tid;
+ tl_assert(lk->heldBy == NULL);
+ tid = map_threads_maybe_reverse_lookup_SLOW(thr);
+ lk->acquired_at
+ = VG_(record_ExeContext(tid, 0/*first_ip_delta*/));
+ } else {
+ tl_assert(lk->heldBy != NULL);
+ }
+ /* end EXPOSITION only */
+
+ switch (lk->kind) {
+ case LK_nonRec:
+ case_LK_nonRec:
+ tl_assert(lk->heldBy == NULL); /* can't w-lock recursively */
+ tl_assert(!lk->heldW);
+ lk->heldW = True;
+ lk->heldBy = HG_(newBag)( hg_zalloc, hg_free );
+ HG_(addToBag)( lk->heldBy, (Word)thr );
+ break;
+ case LK_mbRec:
+ if (lk->heldBy == NULL)
+ goto case_LK_nonRec;
+ /* 2nd and subsequent locking of a lock by its owner */
+ tl_assert(lk->heldW);
+ /* assert: lk is only held by one thread .. */
+ tl_assert(HG_(sizeUniqueBag(lk->heldBy)) == 1);
+ /* assert: .. and that thread is 'thr'. */
+ tl_assert(HG_(elemBag)(lk->heldBy, (Word)thr)
+ == HG_(sizeTotalBag)(lk->heldBy));
+ HG_(addToBag)(lk->heldBy, (Word)thr);
+ break;
+ case LK_rdwr:
+ tl_assert(lk->heldBy == NULL && !lk->heldW); /* must be unheld */
+ goto case_LK_nonRec;
+ default:
+ tl_assert(0);
+ }
+ tl_assert(is_sane_LockN(lk));
+}
+
+static void lockN_acquire_reader ( Lock* lk, Thread* thr )
+{
+ tl_assert(is_sane_LockN(lk));
+ tl_assert(is_sane_Thread(thr));
+ /* can only add reader to a reader-writer lock. */
+ tl_assert(lk->kind == LK_rdwr);
+ /* lk must be free or already r-held. */
+ tl_assert(lk->heldBy == NULL
+ || (lk->heldBy != NULL && !lk->heldW));
+
+ stats__lockN_acquires++;
+
+ /* EXPOSITION only */
+ /* We need to keep recording snapshots of where the lock was
+ acquired, so as to produce better lock-order error messages. */
+ if (lk->acquired_at == NULL) {
+ ThreadId tid;
+ tl_assert(lk->heldBy == NULL);
+ tid = map_threads_maybe_reverse_lookup_SLOW(thr);
+ lk->acquired_at
+ = VG_(record_ExeContext(tid, 0/*first_ip_delta*/));
+ } else {
+ tl_assert(lk->heldBy != NULL);
+ }
+ /* end EXPOSITION only */
+
+ if (lk->heldBy) {
+ HG_(addToBag)(lk->heldBy, (Word)thr);
+ } else {
+ lk->heldW = False;
+ lk->heldBy = HG_(newBag)( hg_zalloc, hg_free );
+ HG_(addToBag)( lk->heldBy, (Word)thr );
+ }
+ tl_assert(!lk->heldW);
+ tl_assert(is_sane_LockN(lk));
+}
+
+/* Update 'lk' to reflect a release of it by 'thr'. This is done
+ strictly: only combinations resulting from correct program and
+ libpthread behaviour are allowed. */
+
+static void lockN_release ( Lock* lk, Thread* thr )
+{
+ Bool b;
+ tl_assert(is_sane_LockN(lk));
+ tl_assert(is_sane_Thread(thr));
+ /* lock must be held by someone */
+ tl_assert(lk->heldBy);
+ stats__lockN_releases++;
+ /* Remove it from the holder set */
+ b = HG_(delFromBag)(lk->heldBy, (Word)thr);
+ /* thr must actually have been a holder of lk */
+ tl_assert(b);
+ /* normalise */
+ tl_assert(lk->acquired_at);
+ if (HG_(isEmptyBag)(lk->heldBy)) {
+ HG_(deleteBag)(lk->heldBy);
+ lk->heldBy = NULL;
+ lk->heldW = False;
+ lk->acquired_at = NULL;
+ }
+ tl_assert(is_sane_LockN(lk));
+}
+
+static void remove_Lock_from_locksets_of_all_owning_Threads( Lock* lk )
+{
+ Thread* thr;
+ if (!lk->heldBy) {
+ tl_assert(!lk->heldW);
+ return;
+ }
+ /* for each thread that holds this lock do ... */
+ HG_(initIterBag)( lk->heldBy );
+ while (HG_(nextIterBag)( lk->heldBy, (Word*)(void*)&thr, NULL )) {
+ tl_assert(is_sane_Thread(thr));
+ tl_assert(HG_(elemWS)( univ_lsets,
+ thr->locksetA, (Word)lk ));
+ thr->locksetA
+ = HG_(delFromWS)( univ_lsets, thr->locksetA, (Word)lk );
+
+ if (lk->heldW) {
+ tl_assert(HG_(elemWS)( univ_lsets,
+ thr->locksetW, (Word)lk ));
+ thr->locksetW
+ = HG_(delFromWS)( univ_lsets, thr->locksetW, (Word)lk );
+ }
+ }
+ HG_(doneIterBag)( lk->heldBy );
+}
+
+/* --------- xxxID functions --------- */
+
+/* Proposal (for debugging sanity):
+
+ SegmentIDs from 0x1000000 .. 0x1FFFFFF (16777216)
+
+ All other xxxID handles are invalid.
+*/
+static inline Bool is_sane_SegmentID ( SegmentID tseg ) {
+ return tseg >= 0x1000000 && tseg <= 0x1FFFFFF;
+}
+static inline Bool is_sane_ThreadId ( ThreadId coretid ) {
+ return coretid >= 0 && coretid < VG_N_THREADS;
+}
+static SegmentID alloc_SegmentID ( void ) {
+ static SegmentID next = 0x1000000;
+ tl_assert(is_sane_SegmentID(next));
+ return next++;
+}
+
+/* --------- Shadow memory --------- */
+
+static inline Bool is_valid_scache_tag ( Addr tag ) {
+ /* a valid tag should be naturally aligned to the start of
+ a CacheLine. */
+ return 0 == (tag & (N_LINE_ARANGE - 1));
+}
+
+static inline Bool is_sane_SecMap ( SecMap* sm ) {
+ return sm != NULL && sm->magic == SecMap_MAGIC;
+}
+
+/* Shadow value encodings:
+
+ 11 WordSetID:TSID_BITS WordSetID:LSID_BITS ShM thread-set lock-set
+ 10 WordSetID:TSID_BITS WordSetID:LSID_BITS ShR thread-set lock-set
+ 01 TSegmentID:30 Excl thread-segment
+ 00 0--(20)--0 10 0000 0000 New
+ 00 0--(20)--0 01 0000 0000 NoAccess
+ 00 0--(20)--0 00 0000 0000 Invalid
+
+ TSID_BITS + LSID_BITS must equal 30.
+ The elements in thread sets are Thread*, casted to Word.
+ The elements in lock sets are Lock*, casted to Word.
+*/
+
+#define N_LSID_BITS 17
+#define N_LSID_MASK ((1 << (N_LSID_BITS)) - 1)
+#define N_LSID_SHIFT 0
+
+#define N_TSID_BITS (30 - (N_LSID_BITS))
+#define N_TSID_MASK ((1 << (N_TSID_BITS)) - 1)
+#define N_TSID_SHIFT (N_LSID_BITS)
+
+static inline Bool is_sane_WordSetID_LSet ( WordSetID wset ) {
+ return wset >= 0 && wset <= N_LSID_MASK;
+}
+static inline Bool is_sane_WordSetID_TSet ( WordSetID wset ) {
+ return wset >= 0 && wset <= N_TSID_MASK;
+}
+
+
+__attribute__((noinline))
+__attribute__((noreturn))
+static void mk_SHVAL_fail ( WordSetID tset, WordSetID lset, HChar* who ) {
+ VG_(printf)("\n");
+ VG_(printf)("Helgrind: Fatal internal error -- cannot continue.\n");
+ VG_(printf)("Helgrind: mk_SHVAL_ShR(tset=%d,lset=%d): FAILED\n",
+ (Int)tset, (Int)lset);
+ VG_(printf)("Helgrind: max allowed tset=%d, lset=%d\n",
+ (Int)N_TSID_MASK, (Int)N_LSID_MASK);
+ VG_(printf)("Helgrind: program has too many thread "
+ "sets or lock sets to track.\n");
+ tl_assert(0);
+}
+
+static inline UInt mk_SHVAL_ShM ( WordSetID tset, WordSetID lset ) {
+ if (LIKELY(is_sane_WordSetID_TSet(tset)
+ && is_sane_WordSetID_LSet(lset))) {
+ return (UInt)( (3<<30) | (tset << N_TSID_SHIFT)
+ | (lset << N_LSID_SHIFT));
+ } else {
+ mk_SHVAL_fail(tset, lset, "mk_SHVAL_ShM");
+ }
+}
+static inline UInt mk_SHVAL_ShR ( WordSetID tset, WordSetID lset ) {
+ if (LIKELY(is_sane_WordSetID_TSet(tset)
+ && is_sane_WordSetID_LSet(lset))) {
+ return (UInt)( (2<<30) | (tset << N_TSID_SHIFT)
+ | (lset << N_LSID_SHIFT) );
+ } else {
+ mk_SHVAL_fail(tset, lset, "mk_SHVAL_ShR");
+ }
+}
+static inline UInt mk_SHVAL_Excl ( SegmentID tseg ) {
+ tl_assert(is_sane_SegmentID(tseg));
+ return (UInt)( (1<<30) | tseg );
+}
+#define SHVAL_New ((UInt)(2<<8))
+#define SHVAL_NoAccess ((UInt)(1<<8))
+#define SHVAL_Invalid ((UInt)(0<<8))
+
+static inline Bool is_SHVAL_ShM ( UInt w32 ) {
+ return (w32 >> 30) == 3;
+}
+static inline Bool is_SHVAL_ShR ( UInt w32 ) {
+ return (w32 >> 30) == 2;
+}
+static inline Bool is_SHVAL_Sh ( UInt w32 ) {
+ return (w32 >> 31) == 1;
+}
+static inline Bool is_SHVAL_Excl ( UInt w32 ) {
+ return (w32 >> 30) == 1;
+}
+static inline Bool is_SHVAL_New ( UInt w32 ) {
+ return w32 == SHVAL_New;
+}
+static inline Bool is_SHVAL_NoAccess ( UInt w32 ) {
+ return w32 == SHVAL_NoAccess;
+}
+static inline Bool is_SHVAL_valid ( UInt w32 ) {
+ return is_SHVAL_Excl(w32) || is_SHVAL_NoAccess(w32)
+ || is_SHVAL_Sh(w32) || is_SHVAL_New(w32);
+}
+
+static inline SegmentID un_SHVAL_Excl ( UInt w32 ) {
+ tl_assert(is_SHVAL_Excl(w32));
+ return w32 & ~(3<<30);
+}
+static inline WordSetID un_SHVAL_ShR_tset ( UInt w32 ) {
+ tl_assert(is_SHVAL_ShR(w32));
+ return (w32 >> N_TSID_SHIFT) & N_TSID_MASK;
+}
+static inline WordSetID un_SHVAL_ShR_lset ( UInt w32 ) {
+ tl_assert(is_SHVAL_ShR(w32));
+ return (w32 >> N_LSID_SHIFT) & N_LSID_MASK;
+}
+static inline WordSetID un_SHVAL_ShM_tset ( UInt w32 ) {
+ tl_assert(is_SHVAL_ShM(w32));
+ return (w32 >> N_TSID_SHIFT) & N_TSID_MASK;
+}
+static inline WordSetID un_SHVAL_ShM_lset ( UInt w32 ) {
+ tl_assert(is_SHVAL_ShM(w32));
+ return (w32 >> N_LSID_SHIFT) & N_LSID_MASK;
+}
+static inline WordSetID un_SHVAL_Sh_tset ( UInt w32 ) {
+ tl_assert(is_SHVAL_Sh(w32));
+ return (w32 >> N_TSID_SHIFT) & N_TSID_MASK;
+}
+static inline WordSetID un_SHVAL_Sh_lset ( UInt w32 ) {
+ tl_assert(is_SHVAL_Sh(w32));
+ return (w32 >> N_LSID_SHIFT) & N_LSID_MASK;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Print out the primary data structures ---*/
+/*----------------------------------------------------------------*/
+
+static WordSetID del_BHL ( WordSetID lockset ); /* fwds */
+static
+void get_ZF_by_index ( /*OUT*/CacheLineZ** zp, /*OUT*/CacheLineF** fp,
+ SecMap* sm, Int zix ); /* fwds */
+static
+Segment* map_segments_maybe_lookup ( SegmentID segid ); /* fwds */
+
+#define PP_THREADS (1<<1)
+#define PP_LOCKS (1<<2)
+#define PP_SEGMENTS (1<<3)
+#define PP_SHMEM_SHARED (1<<4)
+#define PP_ALL (PP_THREADS | PP_LOCKS | PP_SEGMENTS | PP_SHMEM_SHARED)
+
+
+static const Int sHOW_ADMIN = 0;
+
+static void space ( Int n )
+{
+ Int i;
+ Char spaces[128+1];
+ tl_assert(n >= 0 && n < 128);
+ if (n == 0)
+ return;
+ for (i = 0; i < n; i++)
+ spaces[i] = ' ';
+ spaces[i] = 0;
+ tl_assert(i < 128+1);
+ VG_(printf)("%s", spaces);
+}
+
+static void pp_Thread ( Int d, Thread* t )
+{
+ space(d+0); VG_(printf)("Thread %p {\n", t);
+ if (sHOW_ADMIN) {
+ space(d+3); VG_(printf)("admin %p\n", t->admin);
+ space(d+3); VG_(printf)("magic 0x%x\n", (UInt)t->magic);
+ }
+ space(d+3); VG_(printf)("locksetA %d\n", (Int)t->locksetA);
+ space(d+3); VG_(printf)("locksetW %d\n", (Int)t->locksetW);
+ space(d+3); VG_(printf)("csegid 0x%x\n", (UInt)t->csegid);
+ space(d+0); VG_(printf)("}\n");
+}
+
+static void pp_admin_threads ( Int d )
+{
+ Int i, n;
+ Thread* t;
+ for (n = 0, t = admin_threads; t; n++, t = t->admin) {
+ /* nothing */
+ }
+ space(d); VG_(printf)("admin_threads (%d records) {\n", n);
+ for (i = 0, t = admin_threads; t; i++, t = t->admin) {
+ if (0) {
+ space(n);
+ VG_(printf)("admin_threads record %d of %d:\n", i, n);
+ }
+ pp_Thread(d+3, t);
+ }
+ space(d); VG_(printf)("}\n", n);
+}
+
+static void pp_map_threads ( Int d )
+{
+ Int i, n;
+ n = 0;
+ space(d); VG_(printf)("map_threads ");
+ n = 0;
+ for (i = 0; i < VG_N_THREADS; i++) {
+ if (map_threads[i] != NULL)
+ n++;
+ }
+ VG_(printf)("(%d entries) {\n", n);
+ for (i = 0; i < VG_N_THREADS; i++) {
+ if (map_threads[i] == NULL)
+ continue;
+ space(d+3);
+ VG_(printf)("coretid %d -> Thread %p\n", i, map_threads[i]);
+ }
+ space(d); VG_(printf)("}\n");
+}
+
+static const HChar* show_LockKind ( LockKind lkk ) {
+ switch (lkk) {
+ case LK_mbRec: return "mbRec";
+ case LK_nonRec: return "nonRec";
+ case LK_rdwr: return "rdwr";
+ default: tl_assert(0);
+ }
+}
+
+static void pp_Lock ( Int d, Lock* lk )
+{
+ space(d+0); VG_(printf)("Lock %p (ga %p) {\n", lk, lk->guestaddr);
+ if (sHOW_ADMIN) {
+ space(d+3); VG_(printf)("admin %p\n", lk->admin);
+ space(d+3); VG_(printf)("magic 0x%x\n", (UInt)lk->magic);
+ }
+ space(d+3); VG_(printf)("unique %llu\n", lk->unique);
+ space(d+3); VG_(printf)("kind %s\n", show_LockKind(lk->kind));
+ space(d+3); VG_(printf)("heldW %s\n", lk->heldW ? "yes" : "no");
+ space(d+3); VG_(printf)("heldBy %p", lk->heldBy);
+ if (lk->heldBy) {
+ Thread* thr;
+ Word count;
+ VG_(printf)(" { ");
+ HG_(initIterBag)( lk->heldBy );
+ while (HG_(nextIterBag)( lk->heldBy, (Word*)(void*)&thr, &count ))
+ VG_(printf)("%lu:%p ", count, thr);
+ HG_(doneIterBag)( lk->heldBy );
+ VG_(printf)("}");
+ }
+ VG_(printf)("\n");
+ space(d+0); VG_(printf)("}\n");
+}
+
+static void pp_admin_locks ( Int d )
+{
+ Int i, n;
+ Lock* lk;
+ for (n = 0, lk = admin_locks; lk; n++, lk = lk->admin) {
+ /* nothing */
+ }
+ space(d); VG_(printf)("admin_locks (%d records) {\n", n);
+ for (i = 0, lk = admin_locks; lk; i++, lk = lk->admin) {
+ if (0) {
+ space(n);
+ VG_(printf)("admin_locks record %d of %d:\n", i, n);
+ }
+ pp_Lock(d+3, lk);
+ }
+ space(d); VG_(printf)("}\n", n);
+}
+
+static void pp_map_locks ( Int d )
+{
+ void* gla;
+ Lock* lk;
+ space(d); VG_(printf)("map_locks (%d entries) {\n",
+ (Int)HG_(sizeFM)( map_locks ));
+ HG_(initIterFM)( map_locks );
+ while (HG_(nextIterFM)( map_locks, (Word*)(void*)&gla,
+ (Word*)(void*)&lk )) {
+ space(d+3);
+ VG_(printf)("guest %p -> Lock %p\n", gla, lk);
+ }
+ HG_(doneIterFM)( map_locks );
+ space(d); VG_(printf)("}\n");
+}
+
+static void pp_Segment ( Int d, Segment* s )
+{
+ space(d+0); VG_(printf)("Segment %p {\n", s);
+ if (sHOW_ADMIN) {
+ space(d+3); VG_(printf)("admin %p\n", s->admin);
+ space(d+3); VG_(printf)("magic 0x%x\n", (UInt)s->magic);
+ }
+ space(d+3); VG_(printf)("dfsver %u\n", s->dfsver);
+ space(d+3); VG_(printf)("thr %p\n", s->thr);
+ space(d+3); VG_(printf)("prev %p\n", s->prev);
+ space(d+3); VG_(printf)("other[%c] %p\n", s->other_hint, s->other);
+ space(d+0); VG_(printf)("}\n");
+}
+
+static void pp_admin_segments ( Int d )
+{
+ Int i, n;
+ Segment* s;
+ for (n = 0, s = admin_segments; s; n++, s = s->admin) {
+ /* nothing */
+ }
+ space(d); VG_(printf)("admin_segments (%d records) {\n", n);
+ for (i = 0, s = admin_segments; s; i++, s = s->admin) {
+ if (0) {
+ space(n);
+ VG_(printf)("admin_segments record %d of %d:\n", i, n);
+ }
+ pp_Segment(d+3, s);
+ }
+ space(d); VG_(printf)("}\n", n);
+}
+
+static void pp_map_segments ( Int d )
+{
+ SegmentID segid;
+ Segment* seg;
+ space(d); VG_(printf)("map_segments (%d entries) {\n",
+ (Int)HG_(sizeFM)( map_segments ));
+ HG_(initIterFM)( map_segments );
+ while (HG_(nextIterFM)( map_segments, (Word*)(void*)&segid,
+ (Word*)(void*)&seg )) {
+ space(d+3);
+ VG_(printf)("segid 0x%x -> Segment %p\n", (UInt)segid, seg);
+ }
+ HG_(doneIterFM)( map_segments );
+ space(d); VG_(printf)("}\n");
+}
+
+static void show_shadow_w32 ( /*OUT*/Char* buf, Int nBuf, UInt w32 )
+{
+ tl_assert(nBuf-1 >= 99);
+ VG_(memset)(buf, 0, nBuf);
+ if (is_SHVAL_ShM(w32)) {
+ VG_(sprintf)(buf, "ShM(%u,%u)",
+ un_SHVAL_ShM_tset(w32), un_SHVAL_ShM_lset(w32));
+ }
+ else
+ if (is_SHVAL_ShR(w32)) {
+ VG_(sprintf)(buf, "ShR(%u,%u)",
+ un_SHVAL_ShR_tset(w32), un_SHVAL_ShR_lset(w32));
+ }
+ else
+ if (is_SHVAL_Excl(w32)) {
+ VG_(sprintf)(buf, "Excl(%u)", un_SHVAL_Excl(w32));
+ }
+ else
+ if (is_SHVAL_New(w32)) {
+ VG_(sprintf)(buf, "%s", "New");
+ }
+ else
+ if (is_SHVAL_NoAccess(w32)) {
+ VG_(sprintf)(buf, "%s", "NoAccess");
+ }
+ else {
+ VG_(sprintf)(buf, "Invalid-shadow-word(%u)", w32);
+ }
+}
+
+static
+void show_shadow_w32_for_user ( /*OUT*/Char* buf, Int nBuf, UInt w32 )
+{
+ tl_assert(nBuf-1 >= 99);
+ VG_(memset)(buf, 0, nBuf);
+ if (is_SHVAL_ShM(w32)) {
+ WordSetID tset = un_SHVAL_ShM_tset(w32);
+ WordSetID lset = del_BHL( un_SHVAL_ShM_lset(w32) );
+ VG_(sprintf)(buf, "ShMod(#Tset=%d,#Lset=%d)",
+ HG_(cardinalityWS)(univ_tsets, tset),
+ HG_(cardinalityWS)(univ_lsets, lset));
+ }
+ else
+ if (is_SHVAL_ShR(w32)) {
+ WordSetID tset = un_SHVAL_ShR_tset(w32);
+ WordSetID lset = del_BHL( un_SHVAL_ShR_lset(w32) );
+ VG_(sprintf)(buf, "ShRO(#Tset=%d,#Lset=%d)",
+ HG_(cardinalityWS)(univ_tsets, tset),
+ HG_(cardinalityWS)(univ_lsets, lset));
+ }
+ else
+ if (is_SHVAL_Excl(w32)) {
+ SegmentID segid = un_SHVAL_Excl(w32);
+ Segment* mb_seg = map_segments_maybe_lookup(segid);
+ if (mb_seg && mb_seg->thr && is_sane_Thread(mb_seg->thr)) {
+ VG_(sprintf)(buf, "Exclusive(thr#%d)", mb_seg->thr->errmsg_index);
+ } else {
+ VG_(sprintf)(buf, "Exclusive(segid=%u)", un_SHVAL_Excl(w32));
+ }
+ }
+ else
+ if (is_SHVAL_New(w32)) {
+ VG_(sprintf)(buf, "%s", "New");
+ }
+ else
+ if (is_SHVAL_NoAccess(w32)) {
+ VG_(sprintf)(buf, "%s", "NoAccess");
+ }
+ else {
+ VG_(sprintf)(buf, "Invalid-shadow-word(%u)", w32);
+ }
+}
+
+static void pp_SecMap_shared ( Int d, SecMap* sm, Addr ga )
+{
+ Int i;
+#if 0
+ Addr a;
+ UInt w32;
+ Char buf[100];
+#endif
+ CacheLineZ* lineZ;
+ CacheLineF* lineF;
+ space(d+0); VG_(printf)("SecMap %p (ga %p) {\n", sm, (void*)ga);
+
+ for (i = 0; i < N_SECMAP_ZLINES; i++) {
+ get_ZF_by_index( &lineZ, &lineF, sm, i );
+ space(d+3); VG_(printf)("// pp_SecMap_shared: not implemented\n");
+ }
+
+#if 0
+ for (i = 0; i < N_SECMAP_ARANGE; i++) {
+ w32 = sm->w32s[i];
+ a = ga + 1 * i;
+ if (! (is_SHVAL_ShM(w32) || is_SHVAL_ShR(w32)))
+ continue;
+ space(d+3); VG_(printf)("%p -> 0x%08x ", (void*)a, w32);
+ show_shadow_w32(buf, sizeof(buf), w32);
+ VG_(printf)("%s\n", buf);
+ }
+#endif
+
+ space(d+0); VG_(printf)("}\n");
+}
+
+static void pp_map_shmem_shared ( Int d )
+{
+ Addr ga;
+ SecMap* sm;
+ space(d); VG_(printf)("map_shmem_ShR_and_ShM_only {\n");
+ HG_(initIterFM)( map_shmem );
+ while (HG_(nextIterFM)( map_shmem, (Word*)(void*)&ga,
+ (Word*)(void*)&sm )) {
+ pp_SecMap_shared( d+3, sm, ga );
+ }
+ HG_(doneIterFM) ( map_shmem );
+ space(d); VG_(printf)("}\n");
+}
+
+static void pp_everything ( Int flags, Char* caller )
+{
+ Int d = 0;
+ VG_(printf)("\n");
+ VG_(printf)("All_Data_Structures (caller = \"%s\") {\n", caller);
+ if (flags & PP_THREADS) {
+ VG_(printf)("\n");
+ pp_admin_threads(d+3);
+ VG_(printf)("\n");
+ pp_map_threads(d+3);
+ }
+ if (flags & PP_LOCKS) {
+ VG_(printf)("\n");
+ pp_admin_locks(d+3);
+ VG_(printf)("\n");
+ pp_map_locks(d+3);
+ }
+ if (flags & PP_SEGMENTS) {
+ VG_(printf)("\n");
+ pp_admin_segments(d+3);
+ VG_(printf)("\n");
+ pp_map_segments(d+3);
+ }
+ if (flags & PP_SHMEM_SHARED) {
+ VG_(printf)("\n");
+ pp_map_shmem_shared( d+3 );
+ }
+
+ VG_(printf)("\n");
+ VG_(printf)("}\n");
+ VG_(printf)("\n");
+}
+
+#undef SHOW_ADMIN
+
+
+/*----------------------------------------------------------------*/
+/*--- Initialise the primary data structures ---*/
+/*----------------------------------------------------------------*/
+
+/* fwds */
+static void map_segments_add ( SegmentID segid, Segment* seg );
+static void shmem__invalidate_scache ( void );
+static void hbefore__invalidate_cache ( void );
+static void shmem__set_mbHasLocks ( Addr a, Bool b );
+static Bool shmem__get_mbHasLocks ( Addr a );
+static void shadow_mem_set8 ( Thread* uu_thr_acc, Addr a, UInt svNew );
+static XArray* singleton_VTS ( Thread* thr, UWord tym );
+
+static void initialise_data_structures ( void )
+{
+ SegmentID segid;
+ Segment* seg;
+ Thread* thr;
+
+ /* Get everything initialised and zeroed. */
+ tl_assert(admin_threads == NULL);
+ tl_assert(admin_locks == NULL);
+ tl_assert(admin_segments == NULL);
+
+ tl_assert(sizeof(Addr) == sizeof(Word));
+ tl_assert(map_shmem == NULL);
+ map_shmem = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxed Word cmp*/);
+ tl_assert(map_shmem != NULL);
+ shmem__invalidate_scache();
+
+ tl_assert(map_threads == NULL);
+ map_threads = hg_zalloc( VG_N_THREADS * sizeof(Thread*) );
+ tl_assert(map_threads != NULL);
+
+ /* re <=: < on 64-bit platforms, == on 32-bit ones */
+ tl_assert(sizeof(SegmentID) <= sizeof(Word));
+ tl_assert(sizeof(Segment*) == sizeof(Word));
+ tl_assert(map_segments == NULL);
+ map_segments = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxed Word cmp*/);
+ tl_assert(map_segments != NULL);
+ hbefore__invalidate_cache();
+
+ tl_assert(sizeof(Addr) == sizeof(Word));
+ tl_assert(map_locks == NULL);
+ map_locks = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxed Word cmp*/);
+ tl_assert(map_locks != NULL);
+
+ __bus_lock_Lock = mk_LockN( LK_nonRec, (Addr)&__bus_lock );
+ tl_assert(is_sane_LockN(__bus_lock_Lock));
+ HG_(addToFM)( map_locks, (Word)&__bus_lock, (Word)__bus_lock_Lock );
+
+ tl_assert(univ_tsets == NULL);
+ univ_tsets = HG_(newWordSetU)( hg_zalloc, hg_free, 8/*cacheSize*/ );
+ tl_assert(univ_tsets != NULL);
+
+ tl_assert(univ_lsets == NULL);
+ univ_lsets = HG_(newWordSetU)( hg_zalloc, hg_free, 8/*cacheSize*/ );
+ tl_assert(univ_lsets != NULL);
+
+ tl_assert(univ_laog == NULL);
+ univ_laog = HG_(newWordSetU)( hg_zalloc, hg_free, 24/*cacheSize*/ );
+ tl_assert(univ_laog != NULL);
+
+ /* Set up entries for the root thread */
+ // FIXME: this assumes that the first real ThreadId is 1
+
+ /* a segment for the new thread ... */
+ // FIXME: code duplication in ev__post_thread_create
+ segid = alloc_SegmentID();
+ seg = mk_Segment( NULL, NULL, NULL );
+ map_segments_add( segid, seg );
+
+ /* a Thread for the new thread ... */
+ thr = mk_Thread( segid );
+ seg->thr = thr;
+
+ /* Give the thread a starting-off vector timestamp. */
+ seg->vts = singleton_VTS( seg->thr, 1 );
+
+ /* and bind it in the thread-map table.
+ FIXME: assumes root ThreadId == 1. */
+ map_threads[1] = thr;
+
+ tl_assert(VG_INVALID_THREADID == 0);
+
+ /* Mark the new bus lock correctly (to stop the sanity checks
+ complaining) */
+ tl_assert( sizeof(__bus_lock) == 4 );
+ shadow_mem_set8( NULL/*unused*/, __bus_lock_Lock->guestaddr,
+ mk_SHVAL_Excl(segid) );
+ shmem__set_mbHasLocks( __bus_lock_Lock->guestaddr, True );
+
+ all__sanity_check("initialise_data_structures");
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- map_threads :: WordFM core-ThreadId Thread* ---*/
+/*----------------------------------------------------------------*/
+
+/* Doesn't assert if the relevant map_threads entry is NULL. */
+static Thread* map_threads_maybe_lookup ( ThreadId coretid )
+{
+ Thread* thr;
+ tl_assert( is_sane_ThreadId(coretid) );
+ thr = map_threads[coretid];
+ return thr;
+}
+
+/* Asserts if the relevant map_threads entry is NULL. */
+static inline Thread* map_threads_lookup ( ThreadId coretid )
+{
+ Thread* thr;
+ tl_assert( is_sane_ThreadId(coretid) );
+ thr = map_threads[coretid];
+ tl_assert(thr);
+ return thr;
+}
+
+/* Do a reverse lookup. Warning: POTENTIALLY SLOW. Does not assert
+ if 'thr' is not found in map_threads. */
+static ThreadId map_threads_maybe_reverse_lookup_SLOW ( Thread* thr )
+{
+ Int i;
+ tl_assert(is_sane_Thread(thr));
+ /* Check nobody used the invalid-threadid slot */
+ tl_assert(VG_INVALID_THREADID >= 0 && VG_INVALID_THREADID < VG_N_THREADS);
+ tl_assert(map_threads[VG_INVALID_THREADID] == NULL);
+ for (i = 0; i < VG_N_THREADS; i++) {
+ if (i != VG_INVALID_THREADID && map_threads[i] == thr)
+ return (ThreadId)i;
+ }
+ return VG_INVALID_THREADID;
+}
+
+/* Do a reverse lookup. Warning: POTENTIALLY SLOW. Asserts if 'thr'
+ is not found in map_threads. */
+static ThreadId map_threads_reverse_lookup_SLOW ( Thread* thr )
+{
+ ThreadId tid = map_threads_maybe_reverse_lookup_SLOW( thr );
+ tl_assert(tid != VG_INVALID_THREADID);
+ return tid;
+}
+
+static void map_threads_delete ( ThreadId coretid )
+{
+ Thread* thr;
+ tl_assert(coretid != 0);
+ tl_assert( is_sane_ThreadId(coretid) );
+ thr = map_threads[coretid];
+ tl_assert(thr);
+ map_threads[coretid] = NULL;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- map_locks :: WordFM guest-Addr-of-lock Lock* ---*/
+/*----------------------------------------------------------------*/
+
+/* Make sure there is a lock table entry for the given (lock) guest
+ address. If not, create one of the stated 'kind' in unheld state.
+ In any case, return the address of the existing or new Lock. */
+static
+Lock* map_locks_lookup_or_create ( LockKind lkk, Addr ga, ThreadId tid )
+{
+ Bool found;
+ Lock* oldlock = NULL;
+ tl_assert(is_sane_ThreadId(tid));
+ found = HG_(lookupFM)( map_locks,
+ NULL, (Word*)(void*)&oldlock, (Word)ga );
+ if (!found) {
+ Lock* lock = mk_LockN(lkk, ga);
+ lock->appeared_at = VG_(record_ExeContext)( tid, 0 );
+ tl_assert(is_sane_LockN(lock));
+ HG_(addToFM)( map_locks, (Word)ga, (Word)lock );
+ tl_assert(oldlock == NULL);
+ // mark the relevant secondary map has .mbHasLocks
+ shmem__set_mbHasLocks( ga, True );
+ return lock;
+ } else {
+ tl_assert(oldlock != NULL);
+ tl_assert(is_sane_LockN(oldlock));
+ tl_assert(oldlock->guestaddr == ga);
+ // check the relevant secondary map has .mbHasLocks?
+ tl_assert(shmem__get_mbHasLocks(ga) == True);
+ return oldlock;
+ }
+}
+
+static Lock* map_locks_maybe_lookup ( Addr ga )
+{
+ Bool found;
+ Lock* lk = NULL;
+ found = HG_(lookupFM)( map_locks, NULL, (Word*)(void*)&lk, (Word)ga );
+ tl_assert(found ? lk != NULL : lk == NULL);
+ if (found) {
+ // check the relevant secondary map has .mbHasLocks?
+ tl_assert(shmem__get_mbHasLocks(ga) == True);
+ }
+ return lk;
+}
+
+static void map_locks_delete ( Addr ga )
+{
+ Addr ga2 = 0;
+ Lock* lk = NULL;
+ HG_(delFromFM)( map_locks,
+ (Word*)(void*)&ga2, (Word*)(void*)&lk, (Word)ga );
+ /* delFromFM produces the val which is being deleted, if it is
+ found. So assert it is non-null; that in effect asserts that we
+ are deleting a (ga, Lock) pair which actually exists. */
+ tl_assert(lk != NULL);
+ tl_assert(ga2 == ga);
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- map_segments :: WordFM SegmentID Segment* ---*/
+/*--- the DAG of thread segments ---*/
+/*----------------------------------------------------------------*/
+
+static void segments__generate_vcg ( void ); /* fwds */
+
+/*--------------- SegmentID to Segment* maps ---------------*/
+
+static Segment* map_segments_lookup ( SegmentID segid )
+{
+ Bool found;
+ Segment* seg = NULL;
+ tl_assert( is_sane_SegmentID(segid) );
+ found = HG_(lookupFM)( map_segments,
+ NULL, (Word*)(void*)&seg, (Word)segid );
+ tl_assert(found);
+ tl_assert(seg != NULL);
+ return seg;
+}
+
+static Segment* map_segments_maybe_lookup ( SegmentID segid )
+{
+ Bool found;
+ Segment* seg = NULL;
+ tl_assert( is_sane_SegmentID(segid) );
+ found = HG_(lookupFM)( map_segments,
+ NULL, (Word*)(void*)&seg, (Word)segid );
+ if (!found) tl_assert(seg == NULL);
+ return seg;
+}
+
+static void map_segments_add ( SegmentID segid, Segment* seg )
+{
+ /* This is a bit inefficient. Oh well. */
+ tl_assert( !HG_(lookupFM)( map_segments, NULL, NULL, segid ));
+ HG_(addToFM)( map_segments, (Word)segid, (Word)seg );
+}
+
+/*--------------- to do with Vector Timestamps ---------------*/
+
+/* Scalar Timestamp */
+typedef
+ struct {
+ Thread* thr;
+ UWord tym;
+ }
+ ScalarTS;
+
+/* Vector Timestamp = XArray* ScalarTS */
+
+static Bool is_sane_VTS ( XArray* vts )
+{
+ UWord i, n;
+ ScalarTS *st1, *st2;
+ n = VG_(sizeXA)( vts );
+ if (n >= 2) {
+ for (i = 0; i < n-1; i++) {
+ st1 = VG_(indexXA)( vts, i );
+ st2 = VG_(indexXA)( vts, i+1 );
+ if (st1->thr >= st2->thr)
+ return False;
+ if (st1->tym == 0 || st2->tym == 0)
+ return False;
+ }
+ }
+ return True;
+}
+
+static XArray* new_VTS ( void ) {
+ return VG_(newXA)( hg_zalloc, hg_free, sizeof(ScalarTS) );
+}
+static XArray* singleton_VTS ( Thread* thr, UWord tym ) {
+ ScalarTS st;
+ XArray* vts;
+ tl_assert(thr);
+ tl_assert(tym >= 1);
+ vts = new_VTS();
+ tl_assert(vts);
+ st.thr = thr;
+ st.tym = tym;
+ VG_(addToXA)( vts, &st );
+ return vts;
+}
+
+
+static Bool cmpGEQ_VTS ( XArray* a, XArray* b )
+{
+ Word ia, ib, useda, usedb;
+ UWord tyma, tymb;
+ Thread* thr;
+ ScalarTS *tmpa, *tmpb;
+
+ Bool all_leq = True;
+ Bool all_geq = True;
+
+ tl_assert(a);
+ tl_assert(b);
+ useda = VG_(sizeXA)( a );
+ usedb = VG_(sizeXA)( b );
+
+ ia = ib = 0;
+
+ while (1) {
+
+ /* This logic is to enumerate triples (thr, tyma, tymb) drawn
+ from a and b in order, where thr is the next Thread*
+ occurring in either a or b, and tyma/b are the relevant
+ scalar timestamps, taking into account implicit zeroes. */
+ tl_assert(ia >= 0 && ia <= useda);
+ tl_assert(ib >= 0 && ib <= usedb);
+ tmpa = tmpb = NULL;
+
+ if (ia == useda && ib == usedb) {
+ /* both empty - done */
+ break;
+ }
+ else
+ if (ia == useda && ib != usedb) {
+ /* a empty, use up b */
+ tmpb = VG_(indexXA)( b, ib );
+ thr = tmpb->thr;
+ tyma = 0;
+ tymb = tmpb->tym;
+ ib++;
+ }
+ else
+ if (ia != useda && ib == usedb) {
+ /* b empty, use up a */
+ tmpa = VG_(indexXA)( a, ia );
+ thr = tmpa->thr;
+ tyma = tmpa->tym;
+ tymb = 0;
+ ia++;
+ }
+ else {
+ /* both not empty; extract lowest-Thread*'d triple */
+ tmpa = VG_(indexXA)( a, ia );
+ tmpb = VG_(indexXA)( b, ib );
+ if (tmpa->thr < tmpb->thr) {
+ /* a has the lowest unconsidered Thread* */
+ thr = tmpa->thr;
+ tyma = tmpa->tym;
+ tymb = 0;
+ ia++;
+ }
+ else
+ if (tmpa->thr > tmpb->thr) {
+ /* b has the lowest unconsidered Thread* */
+ thr = tmpb->thr;
+ tyma = 0;
+ tymb = tmpb->tym;
+ ib++;
+ } else {
+ /* they both next mention the same Thread* */
+ tl_assert(tmpa->thr == tmpb->thr);
+ thr = tmpa->thr; /* == tmpb->thr */
+ tyma = tmpa->tym;
+ tymb = tmpb->tym;
+ ia++;
+ ib++;
+ }
+ }
+
+ /* having laboriously determined (thr, tyma, tymb), do something
+ useful with it. */
+ if (tyma < tymb)
+ all_geq = False;
+ if (tyma > tymb)
+ all_leq = False;
+ }
+
+ if (all_leq && all_geq)
+ return True; /* PordEQ */
+ /* now we know they aren't equal, so either all_leq or all_geq or
+ both are false. */
+ if (all_leq)
+ return False; /* PordLT */
+ if (all_geq)
+ return True; /* PordGT */
+ /* hmm, neither all_geq or all_leq. This means unordered. */
+ return False; /* PordUN */
+}
+
+
+/* Compute max((tick(thra,a),b) into a new XArray. a and b are
+ unchanged. If neither a nor b supply a value for 'thra',
+ assert. */
+static
+XArray* tickL_and_joinR_VTS ( Thread* thra, XArray* a, XArray* b )
+{
+ Word ia, ib, useda, usedb, ticks_found;
+ UWord tyma, tymb, tymMax;
+ Thread* thr;
+ XArray* res;
+ ScalarTS *tmpa, *tmpb;
+
+ tl_assert(a);
+ tl_assert(b);
+ tl_assert(thra);
+ useda = VG_(sizeXA)( a );
+ usedb = VG_(sizeXA)( b );
+
+ res = new_VTS();
+ ia = ib = ticks_found = 0;
+
+ while (1) {
+
+ /* This logic is to enumerate triples (thr, tyma, tymb) drawn
+ from a and b in order, where thr is the next Thread*
+ occurring in either a or b, and tyma/b are the relevant
+ scalar timestamps, taking into account implicit zeroes. */
+ tl_assert(ia >= 0 && ia <= useda);
+ tl_assert(ib >= 0 && ib <= usedb);
+ tmpa = tmpb = NULL;
+
+ if (ia == useda && ib == usedb) {
+ /* both empty - done */
+ break;
+ }
+ else
+ if (ia == useda && ib != usedb) {
+ /* a empty, use up b */
+ tmpb = VG_(indexXA)( b, ib );
+ thr = tmpb->thr;
+ tyma = 0;
+ tymb = tmpb->tym;
+ ib++;
+ }
+ else
+ if (ia != useda && ib == usedb) {
+ /* b empty, use up a */
+ tmpa = VG_(indexXA)( a, ia );
+ thr = tmpa->thr;
+ tyma = tmpa->tym;
+ tymb = 0;
+ ia++;
+ }
+ else {
+ /* both not empty; extract lowest-Thread*'d triple */
+ tmpa = VG_(indexXA)( a, ia );
+ tmpb = VG_(indexXA)( b, ib );
+ if (tmpa->thr < tmpb->thr) {
+ /* a has the lowest unconsidered Thread* */
+ thr = tmpa->thr;
+ tyma = tmpa->tym;
+ tymb = 0;
+ ia++;
+ }
+ else
+ if (tmpa->thr > tmpb->thr) {
+ /* b has the lowest unconsidered Thread* */
+ thr = tmpb->thr;
+ tyma = 0;
+ tymb = tmpb->tym;
+ ib++;
+ } else {
+ /* they both next mention the same Thread* */
+ tl_assert(tmpa->thr == tmpb->thr);
+ thr = tmpa->thr; /* == tmpb->thr */
+ tyma = tmpa->tym;
+ tymb = tmpb->tym;
+ ia++;
+ ib++;
+ }
+ }
+
+ /* having laboriously determined (thr, tyma, tymb), do something
+ useful with it. */
+ if (thr == thra) {
+ if (tyma > 0) {
+ /* VTS 'a' actually supplied this value; it is not a
+ default zero. Do the required 'tick' action. */
+ tyma++;
+ ticks_found++;
+ } else {
+ /* 'a' didn't supply this value, so 'b' must have. */
+ tl_assert(tymb > 0);
+ }
+ }
+ tymMax = tyma > tymb ? tyma : tymb;
+ if (tymMax > 0) {
+ ScalarTS st;
+ st.thr = thr;
+ st.tym = tymMax;
+ VG_(addToXA)( res, &st );
+ }
+
+ }
+
+ tl_assert(is_sane_VTS( res ));
+
+ if (thra != NULL) {
+ tl_assert(ticks_found == 1);
+ } else {
+ tl_assert(ticks_found == 0);
+ }
+
+ return res;
+}
+
+
+/* Do 'vts[me]++', so to speak. If 'me' does not have an entry in
+ 'vts', set it to 1 in the returned VTS. */
+
+static XArray* tick_VTS ( Thread* me, XArray* vts ) {
+ ScalarTS* here = NULL;
+ ScalarTS tmp;
+ XArray* res;
+ Word i, n;
+ tl_assert(me);
+ tl_assert(is_sane_VTS(vts));
+ if (0) VG_(printf)("tick vts thrno %ld szin %d\n",
+ (Word)me->errmsg_index, (Int)VG_(sizeXA)(vts) );
+ res = new_VTS();
+ n = VG_(sizeXA)( vts );
+ for (i = 0; i < n; i++) {
+ here = VG_(indexXA)( vts, i );
+ if (me < here->thr) {
+ /* We just went past 'me', without seeing it. */
+ tmp.thr = me;
+ tmp.tym = 1;
+ VG_(addToXA)( res, &tmp );
+ tmp = *here;
+ VG_(addToXA)( res, &tmp );
+ i++;
+ break;
+ }
+ else if (me == here->thr) {
+ tmp = *here;
+ tmp.tym++;
+ VG_(addToXA)( res, &tmp );
+ i++;
+ break;
+ }
+ else /* me > here->thr */ {
+ tmp = *here;
+ VG_(addToXA)( res, &tmp );
+ }
+ }
+ tl_assert(i >= 0 && i <= n);
+ if (i == n && here && here->thr < me) {
+ tmp.thr = me;
+ tmp.tym = 1;
+ VG_(addToXA)( res, &tmp );
+ } else {
+ for (/*keepgoing*/; i < n; i++) {
+ here = VG_(indexXA)( vts, i );
+ tmp = *here;
+ VG_(addToXA)( res, &tmp );
+ }
+ }
+ tl_assert(is_sane_VTS(res));
+ if (0) VG_(printf)("tick vts thrno %ld szou %d\n",
+ (Word)me->errmsg_index, (Int)VG_(sizeXA)(res) );
+ return res;
+}
+
+static void show_VTS ( HChar* buf, Int nBuf, XArray* vts ) {
+ ScalarTS* st;
+ HChar unit[64];
+ Word i, n;
+ Int avail = nBuf;
+ tl_assert(avail > 16);
+ buf[0] = '[';
+ buf[1] = 0;
+ n = VG_(sizeXA)( vts );
+ for (i = 0; i < n; i++) {
+ tl_assert(avail >= 10);
+ st = VG_(indexXA)( vts, i );
+ VG_(memset)(unit, 0, sizeof(unit));
+ VG_(sprintf)(unit, i < n-1 ? "%ld:%ld " : "%ld:%ld",
+ (Word)st->thr->errmsg_index, st->tym);
+ if (avail < VG_(strlen)(unit) + 10/*let's say*/) {
+ VG_(strcat)(buf, " ...]");
+ return;
+ }
+ VG_(strcat)(buf, unit);
+ avail -= VG_(strlen)(unit);
+ }
+ VG_(strcat)(buf, "]");
+}
+
+
+/*------------ searching the happens-before graph ------------*/
+
+static UWord stats__hbefore_queries = 0; // total # queries
+static UWord stats__hbefore_cache0s = 0; // hits at cache[0]
+static UWord stats__hbefore_cacheNs = 0; // hits at cache[> 0]
+static UWord stats__hbefore_probes = 0; // # checks in cache
+static UWord stats__hbefore_gsearches = 0; // # searches in graph
+static UWord stats__hbefore_gsearchFs = 0; // # fast searches in graph
+static UWord stats__hbefore_invals = 0; // # cache invals
+static UWord stats__hbefore_stk_hwm = 0; // stack high water mark
+
+/* Running marker for depth-first searches */
+/* NOTE: global variable */
+static UInt dfsver_current = 0;
+
+/* A stack of possibly-unexplored nodes used in the depth first search */
+/* NOTE: global variable */
+static XArray* dfsver_stack = NULL;
+
+// FIXME: check this - is it really correct?
+__attribute__((noinline))
+static Bool happens_before_do_dfs_from_to ( Segment* src, Segment* dst )
+{
+ Segment* here;
+ Word ssz;
+
+ /* begin SPEEDUP HACK -- the following can safely be omitted */
+ /* fast track common case, without favouring either the
+ ->prev or ->other links */
+ tl_assert(src);
+ tl_assert(dst);
+ if ((src->prev && src->prev == dst)
+ || (src->other && src->other == dst)) {
+ stats__hbefore_gsearchFs++;
+ return True;
+ }
+ /* end SPEEDUP HACK */
+
+ /* empty out the stack */
+ tl_assert(dfsver_stack);
+ VG_(dropTailXA)( dfsver_stack, VG_(sizeXA)( dfsver_stack ));
+ tl_assert(VG_(sizeXA)( dfsver_stack ) == 0);
+
+ /* push starting point */
+ (void) VG_(addToXA)( dfsver_stack, &src );
+
+ while (True) {
+ /* While the stack is not empty, pop the next node off it and
+ consider. */
+ ssz = VG_(sizeXA)( dfsver_stack );
+ tl_assert(ssz >= 0);
+ if (ssz == 0)
+ return False; /* stack empty ==> no path from src to dst */
+
+ if (UNLIKELY( ((UWord)ssz) > stats__hbefore_stk_hwm ))
+ stats__hbefore_stk_hwm = (UWord)ssz;
+
+ /* here = pop(stack) */
+ here = *(Segment**) VG_(indexXA)( dfsver_stack, ssz-1 );
+ VG_(dropTailXA)( dfsver_stack, 1 );
+
+ again:
+ /* consider the node 'here' */
+ if (here == dst)
+ return True; /* found a path from src and dst */
+
+ /* have we been to 'here' before? */
+ tl_assert(here->dfsver <= dfsver_current);
+ if (here->dfsver == dfsver_current)
+ continue; /* We've been 'here' before - node is not interesting*/
+
+ /* Mark that we've been here */
+ here->dfsver = dfsver_current;
+
+ /* Now push both children on the stack */
+
+ /* begin SPEEDUP hack -- the following can safely be omitted */
+ /* idea is, if there is exactly one child, avoid the overhead of
+ pushing it on the stack and immediately popping it off again.
+ Kinda like doing a tail-call. */
+ if (here->prev && !here->other) {
+ here = here->prev;
+ goto again;
+ }
+ if (here->other && !here->prev) {
+ here = here->other;
+ goto again;
+ }
+ /* end of SPEEDUP HACK */
+
+ /* Push all available children on stack. From some quick
+ experimentation it seems like exploring ->other first leads
+ to lower maximum stack use, although getting repeatable
+ results is difficult. */
+ if (here->prev)
+ (void) VG_(addToXA)( dfsver_stack, &(here->prev) );
+ if (here->other)
+ (void) VG_(addToXA)( dfsver_stack, &(here->other) );
+ }
+}
+
+__attribute__((noinline))
+static Bool happens_before_wrk ( Segment* seg1, Segment* seg2 )
+{
+ Bool reachable;
+
+ { static Int nnn = 0;
+ if (SHOW_EXPENSIVE_STUFF && (nnn++ % 1000) == 0)
+ VG_(printf)("happens_before_wrk: %d\n", nnn);
+ }
+
+ /* Now the question is, is there a chain of pointers through the
+ .prev and .other fields, that leads from seg2 back to seg1 ? */
+ tl_assert(dfsver_current < 0xFFFFFFFF);
+ dfsver_current++;
+
+ if (dfsver_stack == NULL) {
+ dfsver_stack = VG_(newXA)( hg_zalloc, hg_free, sizeof(Segment*) );
+ tl_assert(dfsver_stack);
+ }
+
+ reachable = happens_before_do_dfs_from_to( seg2, seg1 );
+
+ return reachable;
+}
+
+/*--------------- the happens_before cache ---------------*/
+
+#define HBEFORE__N_CACHE 64
+typedef
+ struct { SegmentID segid1; SegmentID segid2; Bool result; }
+ HBeforeCacheEnt;
+
+static HBeforeCacheEnt hbefore__cache[HBEFORE__N_CACHE];
+
+static void hbefore__invalidate_cache ( void )
+{
+ Int i;
+ SegmentID bogus = 0;
+ tl_assert(!is_sane_SegmentID(bogus));
+ stats__hbefore_invals++;
+ for (i = 0; i < HBEFORE__N_CACHE; i++) {
+ hbefore__cache[i].segid1 = bogus;
+ hbefore__cache[i].segid2 = bogus;
+ hbefore__cache[i].result = False;
+ }
+}
+
+static Bool happens_before ( SegmentID segid1, SegmentID segid2 )
+{
+ Bool hbG, hbV;
+ Int i, j, iNSERT_POINT;
+ Segment *seg1, *seg2;
+ tl_assert(is_sane_SegmentID(segid1));
+ tl_assert(is_sane_SegmentID(segid2));
+ tl_assert(segid1 != segid2);
+ stats__hbefore_queries++;
+ stats__hbefore_probes++;
+ if (segid1 == hbefore__cache[0].segid1
+ && segid2 == hbefore__cache[0].segid2) {
+ stats__hbefore_cache0s++;
+ return hbefore__cache[0].result;
+ }
+ for (i = 1; i < HBEFORE__N_CACHE; i++) {
+ stats__hbefore_probes++;
+ if (segid1 == hbefore__cache[i].segid1
+ && segid2 == hbefore__cache[i].segid2) {
+ /* Found it. Move it 1 step closer to the front. */
+ HBeforeCacheEnt tmp = hbefore__cache[i];
+ hbefore__cache[i] = hbefore__cache[i-1];
+ hbefore__cache[i-1] = tmp;
+ stats__hbefore_cacheNs++;
+ return tmp.result;
+ }
+ }
+ /* Not found. Search the graph and add an entry to the cache. */
+ stats__hbefore_gsearches++;
+
+ seg1 = map_segments_lookup(segid1);
+ seg2 = map_segments_lookup(segid2);
+ tl_assert(is_sane_Segment(seg1));
+ tl_assert(is_sane_Segment(seg2));
+ tl_assert(seg1 != seg2);
+ tl_assert(seg1->vts);
+ tl_assert(seg2->vts);
+
+ hbV = cmpGEQ_VTS( seg2->vts, seg1->vts );
+ if (0) {
+ /* Crosscheck the vector-timestamp comparison result against that
+ obtained from the explicit graph approach. Can be very
+ slow. */
+ hbG = happens_before_wrk( seg1, seg2 );
+ } else {
+ /* Assume the vector-timestamp comparison result is correct, and
+ use it as-is. */
+ hbG = hbV;
+ }
+
+ if (hbV != hbG) {
+ VG_(printf)("seg1 %p seg2 %p hbV %d hbG %d\n",
+ seg1,seg2,(Int)hbV,(Int)hbG);
+ segments__generate_vcg();
+ }
+ tl_assert(hbV == hbG);
+
+ iNSERT_POINT = (1*HBEFORE__N_CACHE)/4 - 1;
+ /* if (iNSERT_POINT > 4) iNSERT_POINT = 4; */
+
+ for (j = HBEFORE__N_CACHE-1; j > iNSERT_POINT; j--) {
+ hbefore__cache[j] = hbefore__cache[j-1];
+ }
+ hbefore__cache[iNSERT_POINT].segid1 = segid1;
+ hbefore__cache[iNSERT_POINT].segid2 = segid2;
+ hbefore__cache[iNSERT_POINT].result = hbG;
+
+ if (0)
+ VG_(printf)("hb %d %d\n", (Int)segid1-(1<<24), (Int)segid2-(1<<24));
+ return hbG;
+}
+
+/*--------------- generating .vcg output ---------------*/
+
+static void segments__generate_vcg ( void )
+{
+#define PFX "xxxxxx"
+ /* Edge colours:
+ Black -- the chain of .prev links
+ Green -- thread creation, link to parent
+ Red -- thread exit, link to exiting thread
+ Yellow -- signal edge
+ Pink -- semaphore-up edge
+ */
+ Segment* seg;
+ HChar vtsstr[128];
+ VG_(printf)(PFX "graph: { title: \"Segments\"\n");
+ VG_(printf)(PFX "orientation: top_to_bottom\n");
+ VG_(printf)(PFX "height: 900\n");
+ VG_(printf)(PFX "width: 500\n");
+ VG_(printf)(PFX "x: 20\n");
+ VG_(printf)(PFX "y: 20\n");
+ VG_(printf)(PFX "color: lightgrey\n");
+ for (seg = admin_segments; seg; seg=seg->admin) {
+
+ VG_(printf)(PFX "node: { title: \"%p\" color: lightcyan "
+ "textcolor: darkgreen label: \"Seg %p\\n",
+ seg, seg);
+ if (seg->thr->errmsg_index == 1) {
+ VG_(printf)("ROOT_THREAD");
+ } else {
+ VG_(printf)("Thr# %d", seg->thr->errmsg_index);
+ }
+
+ if (clo_gen_vcg >= 2) {
+ show_VTS( vtsstr, sizeof(vtsstr)-1, seg->vts );
+ vtsstr[sizeof(vtsstr)-1] = 0;
+ VG_(printf)("\\n%s", vtsstr);
+ }
+
+ VG_(printf)("\" }\n", vtsstr);
+
+ if (seg->prev)
+ VG_(printf)(PFX "edge: { sourcename: \"%p\" targetname: \"%p\""
+ "color: black }\n", seg->prev, seg );
+ if (seg->other) {
+ HChar* colour = "orange";
+ switch (seg->other_hint) {
+ case 'c': colour = "darkgreen"; break; /* creation */
+ case 'j': colour = "red"; break; /* join (exit) */
+ case 's': colour = "orange"; break; /* signal */
+ case 'S': colour = "pink"; break; /* sem_post->wait */
+ case 'u': colour = "cyan"; break; /* unlock */
+ default: tl_assert(0);
+ }
+ VG_(printf)(PFX "edge: { sourcename: \"%p\" targetname: \"%p\""
+ " color: %s }\n", seg->other, seg, colour );
+ }
+ }
+ VG_(printf)(PFX "}\n");
+#undef PFX
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- map_shmem :: WordFM Addr SecMap ---*/
+/*--- shadow memory (low level handlers) (shmem__* fns) ---*/
+/*----------------------------------------------------------------*/
+
+
+static UWord stats__secmaps_allocd = 0; // # SecMaps issued
+static UWord stats__secmap_ga_space_covered = 0; // # ga bytes covered
+static UWord stats__secmap_linesZ_allocd = 0; // # CacheLineZ's issued
+static UWord stats__secmap_linesZ_bytes = 0; // .. using this much storage
+static UWord stats__secmap_linesF_allocd = 0; // # CacheLineF's issued
+static UWord stats__secmap_linesF_bytes = 0; // .. using this much storage
+static UWord stats__secmap_iterator_steppings = 0; // # calls to stepSMIter
+static UWord stats__cache_Z_fetches = 0; // # Z lines fetched
+static UWord stats__cache_Z_wbacks = 0; // # Z lines written back
+static UWord stats__cache_F_fetches = 0; // # F lines fetched
+static UWord stats__cache_F_wbacks = 0; // # F lines written back
+static UWord stats__cache_invals = 0; // # cache invals
+static UWord stats__cache_flushes = 0; // # cache flushes
+static UWord stats__cache_totrefs = 0; // # total accesses
+static UWord stats__cache_totmisses = 0; // # misses
+static UWord stats__cline_normalises = 0; // # calls to cacheline_normalise
+static UWord stats__cline_read64s = 0; // # calls to s_m_read64
+static UWord stats__cline_read32s = 0; // # calls to s_m_read32
+static UWord stats__cline_read16s = 0; // # calls to s_m_read16
+static UWord stats__cline_read8s = 0; // # calls to s_m_read8
+static UWord stats__cline_write64s = 0; // # calls to s_m_write64
+static UWord stats__cline_write32s = 0; // # calls to s_m_write32
+static UWord stats__cline_write16s = 0; // # calls to s_m_write16
+static UWord stats__cline_write8s = 0; // # calls to s_m_write8
+static UWord stats__cline_set64s = 0; // # calls to s_m_set64
+static UWord stats__cline_set32s = 0; // # calls to s_m_set32
+static UWord stats__cline_set16s = 0; // # calls to s_m_set16
+static UWord stats__cline_set8s = 0; // # calls to s_m_set8
+static UWord stats__cline_get8s = 0; // # calls to s_m_get8
+static UWord stats__cline_copy8s = 0; // # calls to s_m_copy8
+static UWord stats__cline_64to32splits = 0; // # 64-bit accesses split
+static UWord stats__cline_32to16splits = 0; // # 32-bit accesses split
+static UWord stats__cline_16to8splits = 0; // # 16-bit accesses split
+static UWord stats__cline_64to32pulldown = 0; // # calls to pulldown_to_32
+static UWord stats__cline_32to16pulldown = 0; // # calls to pulldown_to_16
+static UWord stats__cline_16to8pulldown = 0; // # calls to pulldown_to_8
+
+
+static UInt shadow_mem_get8 ( Addr a ); /* fwds */
+
+static inline Addr shmem__round_to_SecMap_base ( Addr a ) {
+ return a & ~(N_SECMAP_ARANGE - 1);
+}
+static inline UWord shmem__get_SecMap_offset ( Addr a ) {
+ return a & (N_SECMAP_ARANGE - 1);
+}
+
+/*--------------- SecMap allocation --------------- */
+
+static HChar* shmem__bigchunk_next = NULL;
+static HChar* shmem__bigchunk_end1 = NULL;
+
+static void* shmem__bigchunk_alloc ( SizeT n )
+{
+ const SizeT sHMEM__BIGCHUNK_SIZE = 4096 * 256;
+ tl_assert(n > 0);
+ n = ROUNDUP(n, 16);
+ tl_assert(shmem__bigchunk_next <= shmem__bigchunk_end1);
+ tl_assert(shmem__bigchunk_end1 - shmem__bigchunk_next
+ <= (SSizeT)sHMEM__BIGCHUNK_SIZE);
+ if (shmem__bigchunk_next + n > shmem__bigchunk_end1) {
+ if (0)
+ VG_(printf)("XXXXX bigchunk: abandoning %d bytes\n",
+ (Int)(shmem__bigchunk_end1 - shmem__bigchunk_next));
+ shmem__bigchunk_next = VG_(am_shadow_alloc)( sHMEM__BIGCHUNK_SIZE );
+ shmem__bigchunk_end1 = shmem__bigchunk_next + sHMEM__BIGCHUNK_SIZE;
+ }
+ tl_assert(shmem__bigchunk_next);
+ tl_assert( 0 == (((Addr)shmem__bigchunk_next) & (16-1)) );
+ tl_assert(shmem__bigchunk_next + n <= shmem__bigchunk_end1);
+ shmem__bigchunk_next += n;
+ return shmem__bigchunk_next - n;
+}
+
+static SecMap* shmem__alloc_SecMap ( void )
+{
+ Word i, j;
+ SecMap* sm = shmem__bigchunk_alloc( sizeof(SecMap) );
+ if (0) VG_(printf)("alloc_SecMap %p\n",sm);
+ tl_assert(sm);
+ sm->magic = SecMap_MAGIC;
+ sm->mbHasLocks = False; /* dangerous */
+ sm->mbHasShared = False; /* dangerous */
+ for (i = 0; i < N_SECMAP_ZLINES; i++) {
+ sm->linesZ[i].dict[0] = SHVAL_NoAccess;
+ sm->linesZ[i].dict[1] = 0; /* completely invalid SHVAL */
+ sm->linesZ[i].dict[2] = 0;
+ sm->linesZ[i].dict[3] = 0;
+ for (j = 0; j < N_LINE_ARANGE/4; j++)
+ sm->linesZ[i].ix2s[j] = 0; /* all reference dict[0] */
+ }
+ sm->linesF = NULL;
+ sm->linesF_size = 0;
+ stats__secmaps_allocd++;
+ stats__secmap_ga_space_covered += N_SECMAP_ARANGE;
+ stats__secmap_linesZ_allocd += N_SECMAP_ZLINES;
+ stats__secmap_linesZ_bytes += N_SECMAP_ZLINES * sizeof(CacheLineZ);
+ return sm;
+}
+
+static SecMap* shmem__find_or_alloc_SecMap ( Addr ga )
+{
+ SecMap* sm = NULL;
+ Addr gaKey = shmem__round_to_SecMap_base(ga);
+ if (HG_(lookupFM)( map_shmem,
+ NULL/*keyP*/, (Word*)(void*)&sm, (Word)gaKey )) {
+ /* Found; address of SecMap is in sm */
+ tl_assert(sm);
+ } else {
+ /* create a new one */
+ sm = shmem__alloc_SecMap();
+ tl_assert(sm);
+ HG_(addToFM)( map_shmem, (Word)gaKey, (Word)sm );
+ }
+ return sm;
+}
+
+
+/*--------------- cache management/lookup --------------- */
+
+/*--------------- misc --------------- */
+
+static Bool shmem__get_mbHasLocks ( Addr a )
+{
+ SecMap* sm;
+ Addr aKey = shmem__round_to_SecMap_base(a);
+ if (HG_(lookupFM)( map_shmem,
+ NULL/*keyP*/, (Word*)(void*)&sm, (Word)aKey )) {
+ /* Found */
+ return sm->mbHasLocks;
+ } else {
+ return False;
+ }
+}
+
+static void shmem__set_mbHasLocks ( Addr a, Bool b )
+{
+ SecMap* sm;
+ Addr aKey = shmem__round_to_SecMap_base(a);
+ tl_assert(b == False || b == True);
+ if (HG_(lookupFM)( map_shmem,
+ NULL/*keyP*/, (Word*)(void*)&sm, (Word)aKey )) {
+ /* Found; address of SecMap is in sm */
+ } else {
+ /* create a new one */
+ sm = shmem__alloc_SecMap();
+ tl_assert(sm);
+ HG_(addToFM)( map_shmem, (Word)aKey, (Word)sm );
+ }
+ sm->mbHasLocks = b;
+}
+
+static void shmem__set_mbHasShared ( Addr a, Bool b )
+{
+ SecMap* sm;
+ Addr aKey = shmem__round_to_SecMap_base(a);
+ tl_assert(b == False || b == True);
+ if (HG_(lookupFM)( map_shmem,
+ NULL/*keyP*/, (Word*)(void*)&sm, (Word)aKey )) {
+ /* Found; address of SecMap is in sm */
+ } else {
+ /* create a new one */
+ sm = shmem__alloc_SecMap();
+ tl_assert(sm);
+ HG_(addToFM)( map_shmem, (Word)aKey, (Word)sm );
+ }
+ sm->mbHasShared = b;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Sanity checking the data structures ---*/
+/*----------------------------------------------------------------*/
+
+static UWord stats__sanity_checks = 0;
+
+static Bool is_sane_CacheLine ( CacheLine* cl ); /* fwds */
+static Bool cmpGEQ_VTS ( XArray* a, XArray* b ); /* fwds */
+static void laog__sanity_check ( Char* who ); /* fwds */
+
+/* REQUIRED INVARIANTS:
+
+ Thread vs Segment/Lock/SecMaps
+
+ for each t in Threads {
+
+ // Thread.lockset: each element is really a valid Lock
+
+ // Thread.lockset: each Lock in set is actually held by that thread
+ for lk in Thread.lockset
+ lk == LockedBy(t)
+
+ // Thread.csegid is a valid SegmentID
+ // and the associated Segment has .thr == t
+
+ }
+
+ all thread Locksets are pairwise empty under intersection
+ (that is, no lock is claimed to be held by more than one thread)
+ -- this is guaranteed if all locks in locksets point back to their
+ owner threads
+
+ Lock vs Thread/Segment/SecMaps
+
+ for each entry (gla, la) in map_locks
+ gla == la->guest_addr
+
+ for each lk in Locks {
+
+ lk->tag is valid
+ lk->guest_addr does not have shadow state NoAccess
+ if lk == LockedBy(t), then t->lockset contains lk
+ if lk == UnlockedBy(segid) then segid is valid SegmentID
+ and can be mapped to a valid Segment(seg)
+ and seg->thr->lockset does not contain lk
+ if lk == UnlockedNew then (no lockset contains lk)
+
+ secmaps for lk has .mbHasLocks == True
+
+ }
+
+ Segment vs Thread/Lock/SecMaps
+
+ the Segment graph is a dag (no cycles)
+ all of the Segment graph must be reachable from the segids
+ mentioned in the Threads
+
+ for seg in Segments {
+
+ seg->thr is a sane Thread
+
+ }
+
+ SecMaps vs Segment/Thread/Lock
+
+ for sm in SecMaps {
+
+ sm properly aligned
+ if any shadow word is ShR or ShM then .mbHasShared == True
+
+ for each Excl(segid) state
+ map_segments_lookup maps to a sane Segment(seg)
+ for each ShM/ShR(tsetid,lsetid) state
+ each lk in lset is a valid Lock
+ each thr in tset is a valid thread, which is non-dead
+
+ }
+*/
+
+
+/* Return True iff 'thr' holds 'lk' in some mode. */
+static Bool thread_is_a_holder_of_Lock ( Thread* thr, Lock* lk )
+{
+ if (lk->heldBy)
+ return HG_(elemBag)( lk->heldBy, (Word)thr ) > 0;
+ else
+ return False;
+}
+
+/* Sanity check Threads, as far as possible */
+__attribute__((noinline))
+static void threads__sanity_check ( Char* who )
+{
+#define BAD(_str) do { how = (_str); goto bad; } while (0)
+ Char* how = "no error";
+ Thread* thr;
+ WordSetID wsA, wsW;
+ Word* ls_words;
+ Word ls_size, i;
+ Lock* lk;
+ Segment* seg;
+ for (thr = admin_threads; thr; thr = thr->admin) {
+ if (!is_sane_Thread(thr)) BAD("1");
+ wsA = thr->locksetA;
+ wsW = thr->locksetW;
+ // locks held in W mode are a subset of all locks held
+ if (!HG_(isSubsetOf)( univ_lsets, wsW, wsA )) BAD("7");
+ HG_(getPayloadWS)( &ls_words, &ls_size, univ_lsets, wsA );
+ for (i = 0; i < ls_size; i++) {
+ lk = (Lock*)ls_words[i];
+ // Thread.lockset: each element is really a valid Lock
+ if (!is_sane_LockN(lk)) BAD("2");
+ // Thread.lockset: each Lock in set is actually held by that
+ // thread
+ if (!thread_is_a_holder_of_Lock(thr,lk)) BAD("3");
+ // Thread.csegid is a valid SegmentID
+ if (!is_sane_SegmentID(thr->csegid)) BAD("4");
+ // and the associated Segment has .thr == t
+ seg = map_segments_maybe_lookup(thr->csegid);
+ if (!is_sane_Segment(seg)) BAD("5");
+ if (seg->thr != thr) BAD("6");
+ }
+ }
+ return;
+ bad:
+ VG_(printf)("threads__sanity_check: who=\"%s\", bad=\"%s\"\n", who, how);
+ tl_assert(0);
+#undef BAD
+}
+
+
+/* Sanity check Locks, as far as possible */
+__attribute__((noinline))
+static void locks__sanity_check ( Char* who )
+{
+#define BAD(_str) do { how = (_str); goto bad; } while (0)
+ Char* how = "no error";
+ Addr gla;
+ Lock* lk;
+ Int i;
+ // # entries in admin_locks == # entries in map_locks
+ for (i = 0, lk = admin_locks; lk; i++, lk = lk->admin)
+ ;
+ if (i != HG_(sizeFM)(map_locks)) BAD("1");
+ // for each entry (gla, lk) in map_locks
+ // gla == lk->guest_addr
+ HG_(initIterFM)( map_locks );
+ while (HG_(nextIterFM)( map_locks,
+ (Word*)(void*)&gla, (Word*)(void*)&lk )) {
+ if (lk->guestaddr != gla) BAD("2");
+ }
+ HG_(doneIterFM)( map_locks );
+ // scan through admin_locks ...
+ for (lk = admin_locks; lk; lk = lk->admin) {
+ // lock is sane. Quite comprehensive, also checks that
+ // referenced (holder) threads are sane.
+ if (!is_sane_LockN(lk)) BAD("3");
+ // map_locks binds guest address back to this lock
+ if (lk != map_locks_maybe_lookup(lk->guestaddr)) BAD("4");
+ // lk->guest_addr does not have shadow state NoAccess
+ // FIXME: this could legitimately arise from a buggy guest
+ // that attempts to lock in (eg) freed memory. Detect this
+ // and warn about it in the pre/post-mutex-lock event handler.
+ if (is_SHVAL_NoAccess(shadow_mem_get8(lk->guestaddr))) BAD("5");
+ // look at all threads mentioned as holders of this lock. Ensure
+ // this lock is mentioned in their locksets.
+ if (lk->heldBy) {
+ Thread* thr;
+ Word count;
+ HG_(initIterBag)( lk->heldBy );
+ while (HG_(nextIterBag)( lk->heldBy,
+ (Word*)(void*)&thr, &count )) {
+ // is_sane_LockN above ensures these
+ tl_assert(count >= 1);
+ tl_assert(is_sane_Thread(thr));
+ if (!HG_(elemWS)(univ_lsets, thr->locksetA, (Word)lk))
+ BAD("6");
+ // also check the w-only lockset
+ if (lk->heldW
+ && !HG_(elemWS)(univ_lsets, thr->locksetW, (Word)lk))
+ BAD("7");
+ if ((!lk->heldW)
+ && HG_(elemWS)(univ_lsets, thr->locksetW, (Word)lk))
+ BAD("8");
+ }
+ HG_(doneIterBag)( lk->heldBy );
+ } else {
+ /* lock not held by anybody */
+ if (lk->heldW) BAD("9"); /* should be False if !heldBy */
+ // since lk is unheld, then (no lockset contains lk)
+ // hmm, this is really too expensive to check. Hmm.
+ }
+ // secmaps for lk has .mbHasLocks == True
+ if (!shmem__get_mbHasLocks(lk->guestaddr)) BAD("10");
+ }
+
+ return;
+ bad:
+ VG_(printf)("locks__sanity_check: who=\"%s\", bad=\"%s\"\n", who, how);
+ tl_assert(0);
+#undef BAD
+}
+
+
+/* Sanity check Segments, as far as possible */
+__attribute__((noinline))
+static void segments__sanity_check ( Char* who )
+{
+#define BAD(_str) do { how = (_str); goto bad; } while (0)
+ Char* how = "no error";
+ Int i;
+ Segment* seg;
+ // FIXME
+ // the Segment graph is a dag (no cycles)
+ // all of the Segment graph must be reachable from the segids
+ // mentioned in the Threads
+ // # entries in admin_segments == # entries in map_segments
+ for (i = 0, seg = admin_segments; seg; i++, seg = seg->admin)
+ ;
+ if (i != HG_(sizeFM)(map_segments)) BAD("1");
+ // for seg in Segments {
+ for (seg = admin_segments; seg; seg = seg->admin) {
+ if (!is_sane_Segment(seg)) BAD("2");
+ if (!is_sane_Thread(seg->thr)) BAD("3");
+ if (!seg->vts) BAD("4");
+ if (seg->prev && seg->prev->vts
+ && !cmpGEQ_VTS(seg->vts, seg->prev->vts))
+ BAD("5");
+ if (seg->other && seg->other->vts
+ && !cmpGEQ_VTS(seg->vts, seg->other->vts))
+ BAD("6");
+ }
+ return;
+ bad:
+ VG_(printf)("segments__sanity_check: who=\"%s\", bad=\"%s\"\n",
+ who, how);
+ tl_assert(0);
+#undef BAD
+}
+
+
+/* Sanity check shadow memory, as far as possible */
+static Int cmp_Addr_for_ssort ( void* p1, void* p2 ) {
+ Addr a1 = *(Addr*)p1;
+ Addr a2 = *(Addr*)p2;
+ if (a1 < a2) return -1;
+ if (a1 > a2) return 1;
+ return 0;
+}
+__attribute__((noinline))
+static void shmem__sanity_check ( Char* who )
+{
+#define BAD(_str) do { how = (_str); goto bad; } while (0)
+ Char* how = "no error";
+ Word smga;
+ SecMap* sm;
+ Word i, j, ws_size, n_valid_tags;
+ Word* ws_words;
+ Addr* valid_tags;
+ HG_(initIterFM)( map_shmem );
+ // for sm in SecMaps {
+ while (HG_(nextIterFM)( map_shmem,
+ (Word*)(void*)&smga, (Word*)(void*)&sm )) {
+ SecMapIter itr;
+ UInt* w32p;
+ Bool mbHasShared = False;
+ Bool allNoAccess = True;
+ if (!is_sane_SecMap(sm)) BAD("1");
+ // sm properly aligned
+ if (smga != shmem__round_to_SecMap_base(smga)) BAD("2");
+ // if any shadow word is ShR or ShM then .mbHasShared == True
+ initSecMapIter( &itr );
+ while (stepSecMapIter( &w32p, &itr, sm )) {
+ UInt w32 = *w32p;
+ if (is_SHVAL_Sh(w32))
+ mbHasShared = True;
+ if (!is_SHVAL_NoAccess(w32))
+ allNoAccess = False;
+ if (is_SHVAL_Excl(w32)) {
+ // for each Excl(segid) state
+ // map_segments_lookup maps to a sane Segment(seg)
+ Segment* seg;
+ SegmentID segid = un_SHVAL_Excl(w32);
+ if (!is_sane_SegmentID(segid)) BAD("3");
+ seg = map_segments_maybe_lookup(segid);
+ if (!is_sane_Segment(seg)) BAD("4");
+ }
+ else if (is_SHVAL_Sh(w32)) {
+ WordSetID tset = un_SHVAL_Sh_tset(w32);
+ WordSetID lset = un_SHVAL_Sh_lset(w32);
+ if (!HG_(plausibleWS)( univ_tsets, tset )) BAD("5");
+ if (!HG_(saneWS_SLOW)( univ_tsets, tset )) BAD("6");
+ if (HG_(cardinalityWS)( univ_tsets, tset ) < 2) BAD("7");
+ if (!HG_(plausibleWS)( univ_lsets, lset )) BAD("8");
+ if (!HG_(saneWS_SLOW)( univ_lsets, lset )) BAD("9");
+ HG_(getPayloadWS)( &ws_words, &ws_size, univ_lsets, lset );
+ for (j = 0; j < ws_size; j++) {
+ Lock* lk = (Lock*)ws_words[j];
+ // for each ShM/ShR(tsetid,lsetid) state
+ // each lk in lset is a valid Lock
+ if (!is_sane_LockN(lk)) BAD("10");
+ }
+ HG_(getPayloadWS)( &ws_words, &ws_size, univ_tsets, tset );
+ for (j = 0; j < ws_size; j++) {
+ Thread* thr = (Thread*)ws_words[j];
+ //for each ShM/ShR(tsetid,lsetid) state
+ // each thr in tset is a valid thread, which is non-dead
+ if (!is_sane_Thread(thr)) BAD("11");
+ }
+ }
+ else if (is_SHVAL_NoAccess(w32) || is_SHVAL_New(w32)) {
+ /* nothing to check */
+ }
+ else {
+ /* bogus shadow mem value */
+ BAD("12");
+ }
+ } /* iterating over a SecMap */
+ // Check essential safety property
+ if (mbHasShared && !sm->mbHasShared) BAD("13");
+ // This is optional - check that destroyed memory has its hint
+ // bits cleared. NB won't work properly unless full, eager
+ // GCing of SecMaps is implemented
+ //if (allNoAccess && sm->mbHasLocks) BAD("13a");
+ }
+ HG_(doneIterFM)( map_shmem );
+
+ // check the cache
+ valid_tags = hg_zalloc(N_WAY_NENT * sizeof(Addr));
+ n_valid_tags = 0;
+ tl_assert(valid_tags);
+ for (i = 0; i < N_WAY_NENT; i++) {
+ CacheLine* cl;
+ Addr tag;
+ /* way0, dude */
+ cl = &cache_shmem.lyns0[i];
+ tag = cache_shmem.tags0[i];
+ if (tag != 1) {
+ if (!is_valid_scache_tag(tag)) BAD("14-0");
+ if (!is_sane_CacheLine(cl)) BAD("15-0");
+ /* A valid tag should be of the form
+ X---X line_number:N_WAY_BITS 0:N_LINE_BITS */
+ if (tag & (N_LINE_ARANGE-1)) BAD("16-0");
+ if ( i != ((tag >> N_LINE_BITS) & (N_WAY_NENT-1)) ) BAD("16-1");
+ valid_tags[n_valid_tags++] = tag;
+ }
+ }
+ tl_assert(n_valid_tags <= N_WAY_NENT);
+ if (n_valid_tags > 1) {
+ /* Check that the valid tags are unique */
+ VG_(ssort)( valid_tags, n_valid_tags, sizeof(Addr), cmp_Addr_for_ssort );
+ for (i = 0; i < n_valid_tags-1; i++) {
+ if (valid_tags[i] >= valid_tags[i+1])
+ BAD("16-2");
+ }
+ }
+ hg_free(valid_tags);
+ return;
+ bad:
+ VG_(printf)("shmem__sanity_check: who=\"%s\", bad=\"%s\"\n", who, how);
+ tl_assert(0);
+#undef BAD
+}
+
+static void all_except_Locks__sanity_check ( Char* who ) {
+ stats__sanity_checks++;
+ if (0) VG_(printf)("all_except_Locks__sanity_check(%s)\n", who);
+ threads__sanity_check(who);
+ segments__sanity_check(who);
+ shmem__sanity_check(who);
+ laog__sanity_check(who);
+}
+static void all__sanity_check ( Char* who ) {
+ all_except_Locks__sanity_check(who);
+ locks__sanity_check(who);
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- the core memory state machine (msm__* functions) ---*/
+/*----------------------------------------------------------------*/
+
+static UWord stats__msm_read_Excl_nochange = 0;
+static UWord stats__msm_read_Excl_transfer = 0;
+static UWord stats__msm_read_Excl_to_ShR = 0;
+static UWord stats__msm_read_ShR_to_ShR = 0;
+static UWord stats__msm_read_ShM_to_ShM = 0;
+static UWord stats__msm_read_New_to_Excl = 0;
+static UWord stats__msm_read_NoAccess = 0;
+
+static UWord stats__msm_write_Excl_nochange = 0;
+static UWord stats__msm_write_Excl_transfer = 0;
+static UWord stats__msm_write_Excl_to_ShM = 0;
+static UWord stats__msm_write_ShR_to_ShM = 0;
+static UWord stats__msm_write_ShM_to_ShM = 0;
+static UWord stats__msm_write_New_to_Excl = 0;
+static UWord stats__msm_write_NoAccess = 0;
+
+/* fwds */
+static void record_error_Race ( Thread* thr,
+ Addr data_addr, Bool isWrite, Int szB,
+ UInt old_sv, UInt new_sv,
+ ExeContext* mb_lastlock );
+
+static void record_error_FreeMemLock ( Thread* thr, Lock* lk );
+
+static void record_error_UnlockUnlocked ( Thread*, Lock* );
+static void record_error_UnlockForeign ( Thread*, Thread*, Lock* );
+static void record_error_UnlockBogus ( Thread*, Addr );
+static void record_error_PthAPIerror ( Thread*, HChar*, Word, HChar* );
+static void record_error_LockOrder ( Thread*, Addr, Addr,
+ ExeContext*, ExeContext* );
+
+static void record_error_Misc ( Thread*, HChar* );
+static void announce_one_thread ( Thread* thr ); /* fwds */
+
+static WordSetID add_BHL ( WordSetID lockset ) {
+ return HG_(addToWS)( univ_lsets, lockset, (Word)__bus_lock_Lock );
+}
+static WordSetID del_BHL ( WordSetID lockset ) {
+ return HG_(delFromWS)( univ_lsets, lockset, (Word)__bus_lock_Lock );
+}
+
+
+/* Last-lock-lossage records. This mechanism exists to help explain
+ to programmers why we are complaining about a race. The idea is to
+ monitor all lockset transitions. When a previously nonempty
+ lockset becomes empty, the lock(s) that just disappeared (the
+ "lossage") are the locks that have consistently protected the
+ location (ga_of_access) in question for the longest time. Most of
+ the time the lossage-set is a single lock. Because the
+ lossage-lock is the one that has survived longest, there is there
+ is a good chance that it is indeed the lock that the programmer
+ intended to use to protect the location.
+
+ Note that we cannot in general just look at the lossage set when we
+ see a transition to ShM(...,empty-set), because a transition to an
+ empty lockset can happen arbitrarily far before the point where we
+ want to report an error. This is in the case where there are many
+ transitions ShR -> ShR, all with an empty lockset, and only later
+ is there a transition to ShM. So what we want to do is note the
+ lossage lock at the point where a ShR -> ShR transition empties out
+ the lockset, so we can present it later if there should be a
+ transition to ShM.
+
+ So this function finds such transitions. For each, it associates
+ in ga_to_lastlock, the guest address and the lossage lock. In fact
+ we do not record the Lock* directly as that may disappear later,
+ but instead the ExeContext inside the Lock which says where it was
+ initialised or first locked. ExeContexts are permanent so keeping
+ them indefinitely is safe.
+
+ A boring detail: the hardware bus lock is not interesting in this
+ respect, so we first remove that from the pre/post locksets.
+*/
+
+static UWord stats__ga_LL_adds = 0;
+
+static WordFM* ga_to_lastlock = NULL; /* GuestAddr -> ExeContext* */
+
+static
+void record_last_lock_lossage ( Addr ga_of_access,
+ WordSetID lset_old, WordSetID lset_new )
+{
+ Lock* lk;
+ Int card_old, card_new;
+
+ tl_assert(lset_old != lset_new);
+
+ if (0) VG_(printf)("XX1: %d (card %d) -> %d (card %d) %p\n",
+ (Int)lset_old,
+ HG_(cardinalityWS)(univ_lsets,lset_old),
+ (Int)lset_new,
+ HG_(cardinalityWS)(univ_lsets,lset_new),
+ ga_of_access );
+
+ /* This is slow, but at least it's simple. The bus hardware lock
+ just confuses the logic, so remove it from the locksets we're
+ considering before doing anything else. */
+ lset_new = del_BHL( lset_new );
+
+ if (!HG_(isEmptyWS)( univ_lsets, lset_new )) {
+ /* The post-transition lock set is not empty. So we are not
+ interested. We're only interested in spotting transitions
+ that make locksets become empty. */
+ return;
+ }
+
+ /* lset_new is now empty */
+ card_new = HG_(cardinalityWS)( univ_lsets, lset_new );
+ tl_assert(card_new == 0);
+
+ lset_old = del_BHL( lset_old );
+ card_old = HG_(cardinalityWS)( univ_lsets, lset_old );
+
+ if (0) VG_(printf)(" X2: %d (card %d) -> %d (card %d)\n",
+ (Int)lset_old, card_old, (Int)lset_new, card_new );
+
+ if (card_old == 0) {
+ /* The old lockset was also empty. Not interesting. */
+ return;
+ }
+
+ tl_assert(card_old > 0);
+ tl_assert(!HG_(isEmptyWS)( univ_lsets, lset_old ));
+
+ /* Now we know we've got a transition from a nonempty lockset to an
+ empty one. So lset_old must be the set of locks lost. Record
+ some details. If there is more than one element in the lossage
+ set, just choose one arbitrarily -- not the best, but at least
+ it's simple. */
+
+ lk = (Lock*)HG_(anyElementOfWS)( univ_lsets, lset_old );
+ if (0) VG_(printf)("lossage %d %p\n",
+ HG_(cardinalityWS)( univ_lsets, lset_old), lk );
+ if (lk->appeared_at) {
+ if (ga_to_lastlock == NULL)
+ ga_to_lastlock = HG_(newFM)( hg_zalloc, hg_free, NULL );
+ HG_(addToFM)( ga_to_lastlock, ga_of_access, (Word)lk->appeared_at );
+ stats__ga_LL_adds++;
+ }
+}
+
+/* This queries the table (ga_to_lastlock) made by
+ record_last_lock_lossage, when constructing error messages. It
+ attempts to find the ExeContext of the allocation or initialisation
+ point for the lossage lock associated with 'ga'. */
+
+static ExeContext* maybe_get_lastlock_initpoint ( Addr ga )
+{
+ ExeContext* ec_hint = NULL;
+ if (ga_to_lastlock != NULL
+ && HG_(lookupFM)(ga_to_lastlock,
+ NULL, (Word*)(void*)&ec_hint, ga)) {
+ tl_assert(ec_hint != NULL);
+ return ec_hint;
+ } else {
+ return NULL;
+ }
+}
+
+
+static void msm__show_state_change ( Thread* thr_acc, Addr a, Int szB,
+ Char howC,
+ UInt sv_old, UInt sv_new )
+{
+ ThreadId tid;
+ UChar txt_old[100], txt_new[100];
+ Char* how = "";
+ tl_assert(is_sane_Thread(thr_acc));
+ tl_assert(clo_trace_level == 1 || clo_trace_level == 2);
+ switch (howC) {
+ case 'r': how = "rd"; break;
+ case 'w': how = "wr"; break;
+ case 'p': how = "pa"; break;
+ default: tl_assert(0);
+ }
+ show_shadow_w32_for_user(txt_old, sizeof(txt_old), sv_old);
+ show_shadow_w32_for_user(txt_new, sizeof(txt_new), sv_new);
+ txt_old[sizeof(txt_old)-1] = 0;
+ txt_new[sizeof(txt_new)-1] = 0;
+ if (clo_trace_level == 2) {
+ /* show everything */
+ VG_(message)(Vg_UserMsg, "");
+ announce_one_thread( thr_acc );
+ VG_(message)(Vg_UserMsg,
+ "TRACE: %p %s %d thr#%d :: %s --> %s",
+ a, how, szB, thr_acc->errmsg_index, txt_old, txt_new );
+ tid = map_threads_maybe_reverse_lookup_SLOW(thr_acc);
+ if (tid != VG_INVALID_THREADID) {
+ VG_(get_and_pp_StackTrace)( tid, 8 );
+ }
+ } else {
+ /* Just print one line */
+ VG_(message)(Vg_UserMsg,
+ "TRACE: %p %s %d thr#%d :: %22s --> %22s",
+ a, how, szB, thr_acc->errmsg_index, txt_old, txt_new );
+ }
+}
+
+
+/* Here are some MSM stats from startup/shutdown of OpenOffice.
+
+ msm: 489,734,723 80,278,862 rd/wr_Excl_nochange
+ msm: 3,171,542 93,738 rd/wr_Excl_transfer
+ msm: 45,036 167 rd/wr_Excl_to_ShR/ShM
+ msm: 13,352,594 285 rd/wr_ShR_to_ShR/ShM
+ msm: 1,125,879 815,779 rd/wr_ShM_to_ShM
+ msm: 7,561,842 250,629,935 rd/wr_New_to_Excl
+ msm: 17,778 0 rd/wr_NoAccess
+
+ This says how the clauses should be ordered for greatest speed:
+
+ * the vast majority of memory reads (490 million out of a total of
+ 515 million) are of memory in an exclusive state, and the state
+ is unchanged. All other read accesses are insignificant by
+ comparison.
+
+ * 75% (251 million out of a total of 332 million) writes are 'first
+ time' writes, which take New memory into exclusive ownership.
+ Almost all the rest (80 million) are accesses to exclusive state,
+ which remains unchanged. All other write accesses are
+ insignificant. */
+
+/* The core MSM. If 'wold' is the old 32-bit shadow word for a
+ location, return the new shadow word that would result for a read
+ of the location, and report any errors necessary on the way. This
+ does not update shadow memory - it merely produces new shadow words
+ from old. 'thr_acc' and 'a' are supplied only so it can produce
+ coherent error messages if necessary. */
+static
+UInt msm__handle_read ( Thread* thr_acc, Addr a, UInt wold, Int szB )
+{
+ UInt wnew = SHVAL_Invalid;
+
+ tl_assert(is_sane_Thread(thr_acc));
+
+ if (0) VG_(printf)("read thr=%p %p\n", thr_acc, a);
+
+ /* Exclusive */
+ if (LIKELY(is_SHVAL_Excl(wold))) {
+ /* read Excl(segid)
+ | segid_old == segid-of-thread
+ -> no change
+ | segid_old `happens_before` segid-of-this-thread
+ -> Excl(segid-of-this-thread)
+ | otherwise
+ -> ShR
+ */
+ SegmentID segid_old = un_SHVAL_Excl(wold);
+ tl_assert(is_sane_SegmentID(segid_old));
+ if (LIKELY(segid_old == thr_acc->csegid)) {
+ /* no change */
+ stats__msm_read_Excl_nochange++;
+ /*NOCHANGE*/return wold;
+ }
+ if (happens_before(segid_old, thr_acc->csegid)) {
+ /* -> Excl(segid-of-this-thread) */
+ wnew = mk_SHVAL_Excl(thr_acc->csegid);
+ stats__msm_read_Excl_transfer++;
+ goto changed;
+ }
+ /* else */ {
+ /* Enter the shared-readonly (ShR) state. */
+ WordSetID tset, lset;
+ /* This location has been accessed by precisely two threads.
+ Make an appropriate tset. */
+ // FIXME: performance: duplicate map_segments_lookup(segid_old)
+ // since must also be done in happens_before()
+ Segment* seg_old = map_segments_lookup( segid_old );
+ Thread* thr_old = seg_old->thr;
+ tset = HG_(doubletonWS)( univ_tsets, (Word)thr_old, (Word)thr_acc );
+ lset = add_BHL( thr_acc->locksetA ); /* read ==> use all locks */
+ wnew = mk_SHVAL_ShR( tset, lset );
+ stats__msm_read_Excl_to_ShR++;
+ goto changed;
+ }
+ /*NOTREACHED*/
+ }
+
+ /* Shared-Readonly */
+ if (is_SHVAL_ShR(wold)) {
+ /* read Shared-Readonly(threadset, lockset)
+ We remain in ShR state, but add this thread to the
+ threadset and refine the lockset accordingly. Do not
+ complain if the lockset becomes empty -- that's ok. */
+ WordSetID tset_old = un_SHVAL_ShR_tset(wold);
+ WordSetID lset_old = un_SHVAL_ShR_lset(wold);
+ WordSetID tset_new = HG_(addToWS)( univ_tsets,
+ tset_old, (Word)thr_acc );
+ WordSetID lset_new = HG_(intersectWS)( univ_lsets,
+ lset_old,
+ add_BHL(thr_acc->locksetA)
+ /* read ==> use all locks */ );
+ /*UInt*/ wnew = mk_SHVAL_ShR( tset_new, lset_new );
+ if (lset_old != lset_new)
+ record_last_lock_lossage(a,lset_old,lset_new);
+ stats__msm_read_ShR_to_ShR++;
+ goto changed;
+ }
+
+ /* Shared-Modified */
+ if (is_SHVAL_ShM(wold)) {
+ /* read Shared-Modified(threadset, lockset)
+ We remain in ShM state, but add this thread to the
+ threadset and refine the lockset accordingly.
+ If the lockset becomes empty, complain. */
+ WordSetID tset_old = un_SHVAL_ShM_tset(wold);
+ WordSetID lset_old = un_SHVAL_ShM_lset(wold);
+ WordSetID tset_new = HG_(addToWS)( univ_tsets,
+ tset_old, (Word)thr_acc );
+ WordSetID lset_new = HG_(intersectWS)( univ_lsets,
+ lset_old,
+ add_BHL(thr_acc->locksetA)
+ /* read ==> use all locks */ );
+ /*UInt*/ wnew = mk_SHVAL_ShM( tset_new, lset_new );
+ if (lset_old != lset_new)
+ record_last_lock_lossage(a,lset_old,lset_new);
+ if (HG_(isEmptyWS)(univ_lsets, lset_new)
+ && !HG_(isEmptyWS)(univ_lsets, lset_old)) {
+ record_error_Race( thr_acc, a,
+ False/*isWrite*/, szB, wold, wnew,
+ maybe_get_lastlock_initpoint(a) );
+ }
+ stats__msm_read_ShM_to_ShM++;
+ goto changed;
+ }
+
+ /* New */
+ if (is_SHVAL_New(wold)) {
+ /* read New -> Excl(segid) */
+ wnew = mk_SHVAL_Excl( thr_acc->csegid );
+ stats__msm_read_New_to_Excl++;
+ goto changed;
+ }
+
+ /* NoAccess */
+ if (is_SHVAL_NoAccess(wold)) {
+ // FIXME: complain if accessing here
+ // FIXME: transition to Excl?
+ if (0)
+ VG_(printf)(
+ "msm__handle_read_aligned_32(thr=%p, addr=%p): NoAccess\n",
+ thr_acc, (void*)a );
+ stats__msm_read_NoAccess++;
+ /*NOCHANGE*/return wold; /* no change */
+ }
+
+ /* hmm, bogus state */
+ tl_assert(0);
+
+ changed:
+ if (UNLIKELY(clo_trace_level > 0)) {
+ if (a <= clo_trace_addr && clo_trace_addr < a+szB
+ && wold != wnew) {
+ msm__show_state_change( thr_acc, a, szB, 'r', wold, wnew );
+ }
+ }
+ return wnew;
+}
+
+/* Similar to msm__handle_read, compute a new 32-bit shadow word
+ resulting from a write to a location, and report any errors
+ necessary on the way. */
+static
+UInt msm__handle_write ( Thread* thr_acc, Addr a, UInt wold, Int szB )
+{
+ UInt wnew = SHVAL_Invalid;
+
+ tl_assert(is_sane_Thread(thr_acc));
+
+ if (0) VG_(printf)("write32 thr=%p %p\n", thr_acc, a);
+
+ /* New */
+ if (LIKELY(is_SHVAL_New(wold))) {
+ /* write New -> Excl(segid) */
+ wnew = mk_SHVAL_Excl( thr_acc->csegid );
+ stats__msm_write_New_to_Excl++;
+ goto changed;
+ }
+
+ /* Exclusive */
+ if (is_SHVAL_Excl(wold)) {
+ // I believe is identical to case for read Excl
+ // apart from enters ShM rather than ShR
+ /* read Excl(segid)
+ | segid_old == segid-of-thread
+ -> no change
+ | segid_old `happens_before` segid-of-this-thread
+ -> Excl(segid-of-this-thread)
+ | otherwise
+ -> ShM
+ */
+ SegmentID segid_old = un_SHVAL_Excl(wold);
+ tl_assert(is_sane_SegmentID(segid_old));
+ if (segid_old == thr_acc->csegid) {
+ /* no change */
+ stats__msm_write_Excl_nochange++;
+ /*NOCHANGE*/return wold;
+ }
+ if (happens_before(segid_old, thr_acc->csegid)) {
+ /* -> Excl(segid-of-this-thread) */
+ wnew = mk_SHVAL_Excl(thr_acc->csegid);
+ stats__msm_write_Excl_transfer++;
+ goto changed;
+ }
+ /* else */ {
+ /* Enter the shared-modified (ShM) state. */
+ WordSetID tset, lset;
+ /* This location has been accessed by precisely two threads.
+ Make an appropriate tset. */
+ // FIXME: performance: duplicate map_segments_lookup(segid_old)
+ // since must also be done in happens_before()
+ Segment* seg_old = map_segments_lookup( segid_old );
+ Thread* thr_old = seg_old->thr;
+ tset = HG_(doubletonWS)( univ_tsets, (Word)thr_old, (Word)thr_acc );
+ lset = thr_acc->locksetW; /* write ==> use only w-held locks */
+ wnew = mk_SHVAL_ShM( tset, lset );
+ if (HG_(isEmptyWS)(univ_lsets, lset)) {
+ record_error_Race( thr_acc,
+ a, True/*isWrite*/, szB, wold, wnew,
+ maybe_get_lastlock_initpoint(a) );
+ }
+ stats__msm_write_Excl_to_ShM++;
+ goto changed;
+ }
+ /*NOTREACHED*/
+ }
+
+ /* Shared-Readonly */
+ if (is_SHVAL_ShR(wold)) {
+ /* write Shared-Readonly(threadset, lockset)
+ We move to ShM state, add this thread to the
+ threadset and refine the lockset accordingly.
+ If the lockset becomes empty, complain. */
+ WordSetID tset_old = un_SHVAL_ShR_tset(wold);
+ WordSetID lset_old = un_SHVAL_ShR_lset(wold);
+ WordSetID tset_new = HG_(addToWS)( univ_tsets,
+ tset_old, (Word)thr_acc );
+ WordSetID lset_new = HG_(intersectWS)(
+ univ_lsets,
+ lset_old,
+ thr_acc->locksetW
+ /* write ==> use only w-held locks */
+ );
+ /*UInt*/ wnew = mk_SHVAL_ShM( tset_new, lset_new );
+ if (lset_old != lset_new)
+ record_last_lock_lossage(a,lset_old,lset_new);
+ if (HG_(isEmptyWS)(univ_lsets, lset_new)) {
+ record_error_Race( thr_acc, a,
+ True/*isWrite*/, szB, wold, wnew,
+ maybe_get_lastlock_initpoint(a) );
+ }
+ stats__msm_write_ShR_to_ShM++;
+ goto changed;
+ }
+
+ /* Shared-Modified */
+ else if (is_SHVAL_ShM(wold)) {
+ /* write Shared-Modified(threadset, lockset)
+ We remain in ShM state, but add this thread to the
+ threadset and refine the lockset accordingly.
+ If the lockset becomes empty, complain. */
+ WordSetID tset_old = un_SHVAL_ShM_tset(wold);
+ WordSetID lset_old = un_SHVAL_ShM_lset(wold);
+ WordSetID tset_new = HG_(addToWS)( univ_tsets,
+ tset_old, (Word)thr_acc );
+ WordSetID lset_new = HG_(intersectWS)(
+ univ_lsets,
+ lset_old,
+ thr_acc->locksetW
+ /* write ==> use only w-held locks */
+ );
+ /*UInt*/ wnew = mk_SHVAL_ShM( tset_new, lset_new );
+ if (lset_old != lset_new)
+ record_last_lock_lossage(a,lset_old,lset_new);
+ if (HG_(isEmptyWS)(univ_lsets, lset_new)
+ && !HG_(isEmptyWS)(univ_lsets, lset_old)) {
+ record_error_Race( thr_acc, a,
+ True/*isWrite*/, szB, wold, wnew,
+ maybe_get_lastlock_initpoint(a) );
+ }
+ stats__msm_write_ShM_to_ShM++;
+ goto changed;
+ }
+
+ /* NoAccess */
+ if (is_SHVAL_NoAccess(wold)) {
+ // FIXME: complain if accessing here
+ // FIXME: transition to Excl?
+ if (0)
+ VG_(printf)(
+ "msm__handle_write_aligned_32(thr=%p, addr=%p): NoAccess\n",
+ thr_acc, (void*)a );
+ stats__msm_write_NoAccess++;
+ /*NOCHANGE*/return wold;
+ }
+
+ /* hmm, bogus state */
+ VG_(printf)("msm__handle_write_aligned_32: bogus old state 0x%x\n",
+ wold);
+ tl_assert(0);
+
+ changed:
+ if (UNLIKELY(clo_trace_level > 0)) {
+ if (a <= clo_trace_addr && clo_trace_addr < a+szB
+ && wold != wnew) {
+ msm__show_state_change( thr_acc, a, szB, 'w', wold, wnew );
+ }
+ }
+ return wnew;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Shadow value and address range handlers ---*/
+/*----------------------------------------------------------------*/
+
+static void laog__pre_thread_acquires_lock ( Thread*, Lock* ); /* fwds */
+static void laog__handle_lock_deletions ( WordSetID ); /* fwds */
+static inline Thread* get_current_Thread ( void ); /* fwds */
+
+/* ------------ CacheLineF and CacheLineZ related ------------ */
+
+static void write_twobit_array ( UChar* arr, UWord ix, UWord b2 ) {
+ Word bix, shft, mask, prep;
+ tl_assert((b2 & ~3) == 0);
+ tl_assert(ix >= 0);
+ bix = ix >> 2;
+ shft = 2 * (ix & 3); /* 0, 2, 4 or 6 */
+ mask = 3 << shft;
+ prep = b2 << shft;
+ arr[bix] = (arr[bix] & ~mask) | prep;
+}
+
+static UWord read_twobit_array ( UChar* arr, UWord ix ) {
+ Word bix, shft;
+ tl_assert(ix >= 0);
+ bix = ix >> 2;
+ shft = 2 * (ix & 3); /* 0, 2, 4 or 6 */
+ return (arr[bix] >> shft) & 3;
+}
+
+/* Given a lineZ index and a SecMap, return the CacheLineZ* and CacheLineF*
+ for that index. */
+static void get_ZF_by_index ( /*OUT*/CacheLineZ** zp,
+ /*OUT*/CacheLineF** fp,
+ SecMap* sm, Int zix ) {
+ CacheLineZ* lineZ;
+ tl_assert(zp);
+ tl_assert(fp);
+ tl_assert(zix >= 0 && zix < N_SECMAP_ZLINES);
+ tl_assert(is_sane_SecMap(sm));
+ lineZ = &sm->linesZ[zix];
+ if (lineZ->dict[0] == 0) {
+ Int fix = lineZ->dict[1];
+ tl_assert(sm->linesF);
+ tl_assert(sm->linesF_size > 0);
+ tl_assert(fix >= 0 && fix < sm->linesF_size);
+ *zp = NULL;
+ *fp = &sm->linesF[fix];
+ tl_assert(sm->linesF[fix].inUse);
+ } else {
+ *zp = lineZ;
+ *fp = NULL;
+ }
+}
+
+static void find_ZF_for_reading ( /*OUT*/CacheLineZ** zp,
+ /*OUT*/CacheLineF** fp, Addr tag ) {
+ CacheLineZ* lineZ;
+ CacheLineF* lineF;
+ UWord zix;
+ SecMap* sm = shmem__find_or_alloc_SecMap(tag);
+ UWord smoff = shmem__get_SecMap_offset(tag);
+ /* since smoff is derived from a valid tag, it should be
+ cacheline-aligned. */
+ tl_assert(0 == (smoff & (N_LINE_ARANGE - 1)));
+ zix = smoff >> N_LINE_BITS;
+ tl_assert(zix < N_SECMAP_ZLINES);
+ lineZ = &sm->linesZ[zix];
+ lineF = NULL;
+ if (lineZ->dict[0] == 0) {
+ Word fix = lineZ->dict[1];
+ tl_assert(sm->linesF);
+ tl_assert(sm->linesF_size > 0);
+ tl_assert(fix >= 0 && fix < sm->linesF_size);
+ lineF = &sm->linesF[fix];
+ tl_assert(lineF->inUse);
+ lineZ = NULL;
+ }
+ *zp = lineZ;
+ *fp = lineF;
+}
+
+static void find_Z_for_writing ( /*OUT*/SecMap** smp,
+ /*OUT*/Word* zixp,
+ Addr tag ) {
+ CacheLineZ* lineZ;
+ CacheLineF* lineF;
+ UWord zix;
+ SecMap* sm = shmem__find_or_alloc_SecMap(tag);
+ UWord smoff = shmem__get_SecMap_offset(tag);
+ /* since smoff is derived from a valid tag, it should be
+ cacheline-aligned. */
+ tl_assert(0 == (smoff & (N_LINE_ARANGE - 1)));
+ zix = smoff >> N_LINE_BITS;
+ tl_assert(zix < N_SECMAP_ZLINES);
+ lineZ = &sm->linesZ[zix];
+ lineF = NULL;
+ /* If lineZ has an associated lineF, free it up. */
+ if (lineZ->dict[0] == 0) {
+ Word fix = lineZ->dict[1];
+ tl_assert(sm->linesF);
+ tl_assert(sm->linesF_size > 0);
+ tl_assert(fix >= 0 && fix < sm->linesF_size);
+ lineF = &sm->linesF[fix];
+ tl_assert(lineF->inUse);
+ lineF->inUse = False;
+ }
+ *smp = sm;
+ *zixp = zix;
+}
+
+static
+void alloc_F_for_writing ( /*MOD*/SecMap* sm, /*OUT*/Word* fixp ) {
+ Word i, new_size;
+ CacheLineF* nyu;
+
+ if (sm->linesF) {
+ tl_assert(sm->linesF_size > 0);
+ } else {
+ tl_assert(sm->linesF_size == 0);
+ }
+
+ if (sm->linesF) {
+ for (i = 0; i < sm->linesF_size; i++) {
+ if (!sm->linesF[i].inUse) {
+ *fixp = (Word)i;
+ return;
+ }
+ }
+ }
+
+ /* No free F line found. Expand existing array and try again. */
+ new_size = sm->linesF_size==0 ? 1 : 2 * sm->linesF_size;
+ nyu = hg_zalloc( new_size * sizeof(CacheLineF) );
+ tl_assert(nyu);
+
+ stats__secmap_linesF_allocd += (new_size - sm->linesF_size);
+ stats__secmap_linesF_bytes += (new_size - sm->linesF_size)
+ * sizeof(CacheLineF);
+
+ if (0)
+ VG_(printf)("SM %p: expand F array from %d to %d\n",
+ sm, (Int)sm->linesF_size, new_size);
+
+ for (i = 0; i < new_size; i++)
+ nyu[i].inUse = False;
+
+ if (sm->linesF) {
+ for (i = 0; i < sm->linesF_size; i++) {
+ tl_assert(sm->linesF[i].inUse);
+ nyu[i] = sm->linesF[i];
+ }
+ VG_(memset)(sm->linesF, 0, sm->linesF_size * sizeof(CacheLineF) );
+ hg_free(sm->linesF);
+ }
+
+ sm->linesF = nyu;
+ sm->linesF_size = new_size;
+
+ for (i = 0; i < sm->linesF_size; i++) {
+ if (!sm->linesF[i].inUse) {
+ *fixp = (Word)i;
+ return;
+ }
+ }
+
+ /*NOTREACHED*/
+ tl_assert(0);
+}
+
+
+/* ------------ CacheLine and implicit-tree related ------------ */
+
+__attribute__((unused))
+static void pp_CacheLine ( CacheLine* cl ) {
+ Word i;
+ if (!cl) {
+ VG_(printf)("pp_CacheLine(NULL)\n");
+ return;
+ }
+ for (i = 0; i < N_LINE_TREES; i++)
+ VG_(printf)(" descr: %04lx\n", (UWord)cl->descrs[i]);
+ for (i = 0; i < N_LINE_ARANGE; i++)
+ VG_(printf)(" sval: %08lx\n", (UWord)cl->svals[i]);
+}
+
+static UChar descr_to_validbits ( UShort descr )
+{
+ /* a.k.a Party Time for gcc's constant folder */
+# define DESCR(b8_7, b8_6, b8_5, b8_4, b8_3, b8_2, b8_1, b8_0, \
+ b16_3, b32_1, b16_2, b64, b16_1, b32_0, b16_0) \
+ ( (UShort) ( ( (b8_7) << 14) | ( (b8_6) << 13) | \
+ ( (b8_5) << 12) | ( (b8_4) << 11) | \
+ ( (b8_3) << 10) | ( (b8_2) << 9) | \
+ ( (b8_1) << 8) | ( (b8_0) << 7) | \
+ ( (b16_3) << 6) | ( (b32_1) << 5) | \
+ ( (b16_2) << 4) | ( (b64) << 3) | \
+ ( (b16_1) << 2) | ( (b32_0) << 1) | \
+ ( (b16_0) << 0) ) )
+
+# define BYTE(bit7, bit6, bit5, bit4, bit3, bit2, bit1, bit0) \
+ ( (UChar) ( ( (bit7) << 7) | ( (bit6) << 6) | \
+ ( (bit5) << 5) | ( (bit4) << 4) | \
+ ( (bit3) << 3) | ( (bit2) << 2) | \
+ ( (bit1) << 1) | ( (bit0) << 0) ) )
+
+ /* these should all get folded out at compile time */
+ tl_assert(DESCR(1,0,0,0,0,0,0,0, 0,0,0, 0, 0,0,0) == TREE_DESCR_8_7);
+ tl_assert(DESCR(0,0,0,0,0,0,0,1, 0,0,0, 0, 0,0,0) == TREE_DESCR_8_0);
+ tl_assert(DESCR(0,0,0,0,0,0,0,0, 1,0,0, 0, 0,0,0) == TREE_DESCR_16_3);
+ tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,1,0, 0, 0,0,0) == TREE_DESCR_32_1);
+ tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,0,1, 0, 0,0,0) == TREE_DESCR_16_2);
+ tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,0,0, 1, 0,0,0) == TREE_DESCR_64);
+ tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,0,0, 0, 1,0,0) == TREE_DESCR_16_1);
+ tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,0,0, 0, 0,1,0) == TREE_DESCR_32_0);
+ tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,0,0, 0, 0,0,1) == TREE_DESCR_16_0);
+
+ switch (descr) {
+ /*
+ +--------------------------------- TREE_DESCR_8_7
+ | +------------------- TREE_DESCR_8_0
+ | | +---------------- TREE_DESCR_16_3
+ | | | +-------------- TREE_DESCR_32_1
+ | | | | +------------ TREE_DESCR_16_2
+ | | | | | +--------- TREE_DESCR_64
+ | | | | | | +------ TREE_DESCR_16_1
+ | | | | | | | +---- TREE_DESCR_32_0
+ | | | | | | | | +-- TREE_DESCR_16_0
+ | | | | | | | | |
+ | | | | | | | | | GRANULARITY, 7 -> 0 */
+ case DESCR(1,1,1,1,1,1,1,1, 0,0,0, 0, 0,0,0): /* 8 8 8 8 8 8 8 8 */
+ return BYTE(1,1,1,1,1,1,1,1);
+ case DESCR(1,1,0,0,1,1,1,1, 0,0,1, 0, 0,0,0): /* 8 8 16 8 8 8 8 */
+ return BYTE(1,1,0,1,1,1,1,1);
+ case DESCR(0,0,1,1,1,1,1,1, 1,0,0, 0, 0,0,0): /* 16 8 8 8 8 8 8 */
+ return BYTE(0,1,1,1,1,1,1,1);
+ case DESCR(0,0,0,0,1,1,1,1, 1,0,1, 0, 0,0,0): /* 16 16 8 8 8 8 */
+ return BYTE(0,1,0,1,1,1,1,1);
+
+ case DESCR(1,1,1,1,1,1,0,0, 0,0,0, 0, 0,0,1): /* 8 8 8 8 8 8 16 */
+ return BYTE(1,1,1,1,1,1,0,1);
+ case DESCR(1,1,0,0,1,1,0,0, 0,0,1, 0, 0,0,1): /* 8 8 16 8 8 16 */
+ return BYTE(1,1,0,1,1,1,0,1);
+ case DESCR(0,0,1,1,1,1,0,0, 1,0,0, 0, 0,0,1): /* 16 8 8 8 8 16 */
+ return BYTE(0,1,1,1,1,1,0,1);
+ case DESCR(0,0,0,0,1,1,0,0, 1,0,1, 0, 0,0,1): /* 16 16 8 8 16 */
+ return BYTE(0,1,0,1,1,1,0,1);
+
+ case DESCR(1,1,1,1,0,0,1,1, 0,0,0, 0, 1,0,0): /* 8 8 8 8 16 8 8 */
+ return BYTE(1,1,1,1,0,1,1,1);
+ case DESCR(1,1,0,0,0,0,1,1, 0,0,1, 0, 1,0,0): /* 8 8 16 16 8 8 */
+ return BYTE(1,1,0,1,0,1,1,1);
+ case DESCR(0,0,1,1,0,0,1,1, 1,0,0, 0, 1,0,0): /* 16 8 8 16 8 8 */
+ return BYTE(0,1,1,1,0,1,1,1);
+ case DESCR(0,0,0,0,0,0,1,1, 1,0,1, 0, 1,0,0): /* 16 16 16 8 8 */
+ return BYTE(0,1,0,1,0,1,1,1);
+
+ case DESCR(1,1,1,1,0,0,0,0, 0,0,0, 0, 1,0,1): /* 8 8 8 8 16 16 */
+ return BYTE(1,1,1,1,0,1,0,1);
+ case DESCR(1,1,0,0,0,0,0,0, 0,0,1, 0, 1,0,1): /* 8 8 16 16 16 */
+ return BYTE(1,1,0,1,0,1,0,1);
+ case DESCR(0,0,1,1,0,0,0,0, 1,0,0, 0, 1,0,1): /* 16 8 8 16 16 */
+ return BYTE(0,1,1,1,0,1,0,1);
+ case DESCR(0,0,0,0,0,0,0,0, 1,0,1, 0, 1,0,1): /* 16 16 16 16 */
+ return BYTE(0,1,0,1,0,1,0,1);
+
+ case DESCR(0,0,0,0,1,1,1,1, 0,1,0, 0, 0,0,0): /* 32 8 8 8 8 */
+ return BYTE(0,0,0,1,1,1,1,1);
+ case DESCR(0,0,0,0,1,1,0,0, 0,1,0, 0, 0,0,1): /* 32 8 8 16 */
+ return BYTE(0,0,0,1,1,1,0,1);
+ case DESCR(0,0,0,0,0,0,1,1, 0,1,0, 0, 1,0,0): /* 32 16 8 8 */
+ return BYTE(0,0,0,1,0,1,1,1);
+ case DESCR(0,0,0,0,0,0,0,0, 0,1,0, 0, 1,0,1): /* 32 16 16 */
+ return BYTE(0,0,0,1,0,1,0,1);
+
+ case DESCR(1,1,1,1,0,0,0,0, 0,0,0, 0, 0,1,0): /* 8 8 8 8 32 */
+ return BYTE(1,1,1,1,0,0,0,1);
+ case DESCR(1,1,0,0,0,0,0,0, 0,0,1, 0, 0,1,0): /* 8 8 16 32 */
+ return BYTE(1,1,0,1,0,0,0,1);
+ case DESCR(0,0,1,1,0,0,0,0, 1,0,0, 0, 0,1,0): /* 16 8 8 32 */
+ return BYTE(0,1,1,1,0,0,0,1);
+ case DESCR(0,0,0,0,0,0,0,0, 1,0,1, 0, 0,1,0): /* 16 16 32 */
+ return BYTE(0,1,0,1,0,0,0,1);
+
+ case DESCR(0,0,0,0,0,0,0,0, 0,1,0, 0, 0,1,0): /* 32 32 */
+ return BYTE(0,0,0,1,0,0,0,1);
+
+ case DESCR(0,0,0,0,0,0,0,0, 0,0,0, 1, 0,0,0): /* 64 */
+ return BYTE(0,0,0,0,0,0,0,1);
+
+ default: return BYTE(0,0,0,0,0,0,0,0);
+ /* INVALID - any valid descr produces at least one
+ valid bit in tree[0..7]*/
+ }
+ /* NOTREACHED*/
+ tl_assert(0);
+
+# undef DESCR
+# undef BYTE
+}
+
+__attribute__((unused))
+static Bool is_sane_Descr ( UShort descr ) {
+ return descr_to_validbits(descr) != 0;
+}
+
+static void sprintf_Descr ( /*OUT*/UChar* dst, UShort descr ) {
+ VG_(sprintf)(dst,
+ "%d%d%d%d%d%d%d%d %d%d%d %d %d%d%d",
+ (Int)((descr & TREE_DESCR_8_7) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_8_6) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_8_5) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_8_4) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_8_3) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_8_2) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_8_1) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_8_0) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_16_3) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_32_1) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_16_2) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_64) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_16_1) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_32_0) ? 1 : 0),
+ (Int)((descr & TREE_DESCR_16_0) ? 1 : 0)
+ );
+}
+static void sprintf_Byte ( /*OUT*/UChar* dst, UChar byte ) {
+ VG_(sprintf)(dst, "%d%d%d%d%d%d%d%d",
+ (Int)((byte & 128) ? 1 : 0),
+ (Int)((byte & 64) ? 1 : 0),
+ (Int)((byte & 32) ? 1 : 0),
+ (Int)((byte & 16) ? 1 : 0),
+ (Int)((byte & 8) ? 1 : 0),
+ (Int)((byte & 4) ? 1 : 0),
+ (Int)((byte & 2) ? 1 : 0),
+ (Int)((byte & 1) ? 1 : 0)
+ );
+}
+
+static Bool is_sane_Descr_and_Tree ( UShort descr, UInt* tree ) {
+ Word i;
+ UChar validbits = descr_to_validbits(descr);
+ UChar buf[128], buf2[128];
+ if (validbits == 0)
+ goto bad;
+ for (i = 0; i < 8; i++) {
+ if (validbits & (1<<i)) {
+ if (!is_SHVAL_valid(tree[i]))
+ goto bad;
+ } else {
+ if (tree[i] != 0)
+ goto bad;
+ }
+ }
+ return True;
+ bad:
+ sprintf_Descr( buf, descr );
+ sprintf_Byte( buf2, validbits );
+ VG_(printf)("is_sane_Descr_and_Tree: bad tree {\n");
+ VG_(printf)(" validbits 0x%02lx %s\n", (UWord)validbits, buf2);
+ VG_(printf)(" descr 0x%04lx %s\n", (UWord)descr, buf);
+ for (i = 0; i < 8; i++)
+ VG_(printf)(" [%ld] 0x%08x\n", i, tree[i]);
+ VG_(printf)("}\n");
+ return 0;
+}
+
+
+static Bool is_sane_CacheLine ( CacheLine* cl )
+{
+ Word tno, cloff;
+
+ if (!cl) goto bad;
+
+ for (tno = 0, cloff = 0; tno < N_LINE_TREES; tno++, cloff += 8) {
+ UShort descr = cl->descrs[tno];
+ UInt* tree = &cl->svals[cloff];
+ if (!is_sane_Descr_and_Tree(descr, tree))
+ goto bad;
+ }
+ tl_assert(cloff == N_LINE_ARANGE);
+ return True;
+ bad:
+ pp_CacheLine(cl);
+ return False;
+}
+
+
+static UShort normalise_tree ( /*MOD*/UInt* tree ) {
+ Word i;
+ UShort descr;
+ /* pre: incoming tree[0..7] does not have any invalid shvals, in
+ particular no zeroes. */
+ for (i = 0; i < 8; i++)
+ tl_assert(tree[i] != 0);
+
+ descr = TREE_DESCR_8_7 | TREE_DESCR_8_6 | TREE_DESCR_8_5
+ | TREE_DESCR_8_4 | TREE_DESCR_8_3 | TREE_DESCR_8_2
+ | TREE_DESCR_8_1 | TREE_DESCR_8_0;
+ /* build 16-bit layer */
+ if (tree[1] == tree[0]) {
+ tree[1] = 0/*INVALID*/;
+ descr &= ~(TREE_DESCR_8_1 | TREE_DESCR_8_0);
+ descr |= TREE_DESCR_16_0;
+ }
+ if (tree[3] == tree[2]) {
+ tree[3] = 0/*INVALID*/;
+ descr &= ~(TREE_DESCR_8_3 | TREE_DESCR_8_2);
+ descr |= TREE_DESCR_16_1;
+ }
+ if (tree[5] == tree[4]) {
+ tree[5] = 0/*INVALID*/;
+ descr &= ~(TREE_DESCR_8_5 | TREE_DESCR_8_4);
+ descr |= TREE_DESCR_16_2;
+ }
+ if (tree[7] == tree[6]) {
+ tree[7] = 0/*INVALID*/;
+ descr &= ~(TREE_DESCR_8_7 | TREE_DESCR_8_6);
+ descr |= TREE_DESCR_16_3;
+ }
+ /* build 32-bit layer */
+ if (tree[2] == tree[0]
+ && (descr & TREE_DESCR_16_1) && (descr & TREE_DESCR_16_0)) {
+ tree[2] = 0; /* [3,1] must already be 0 */
+ descr &= ~(TREE_DESCR_16_1 | TREE_DESCR_16_0);
+ descr |= TREE_DESCR_32_0;
+ }
+ if (tree[6] == tree[4]
+ && (descr & TREE_DESCR_16_3) && (descr & TREE_DESCR_16_2)) {
+ tree[6] = 0; /* [7,5] must already be 0 */
+ descr &= ~(TREE_DESCR_16_3 | TREE_DESCR_16_2);
+ descr |= TREE_DESCR_32_1;
+ }
+ /* build 64-bit layer */
+ if (tree[4] == tree[0]
+ && (descr & TREE_DESCR_32_1) && (descr & TREE_DESCR_32_0)) {
+ tree[4] = 0; /* [7,6,5,3,2,1] must already be 0 */
+ descr &= ~(TREE_DESCR_32_1 | TREE_DESCR_32_0);
+ descr |= TREE_DESCR_64;
+ }
+ return descr;
+}
+
+/* This takes a cacheline where all the data is at the leaves
+ (w8[..]) and builds a correctly normalised tree. */
+static void normalise_CacheLine ( /*MOD*/CacheLine* cl )
+{
+ Word tno, cloff;
+ for (tno = 0, cloff = 0; tno < N_LINE_TREES; tno++, cloff += 8) {
+ UInt* tree = &cl->svals[cloff];
+ cl->descrs[tno] = normalise_tree( tree );
+ }
+ tl_assert(cloff == N_LINE_ARANGE);
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ stats__cline_normalises++;
+}
+
+
+static
+UInt* sequentialise_tree ( /*MOD*/UInt* dst, /*OUT*/Bool* anyShared,
+ UShort descr, UInt* tree ) {
+ UInt* dst0 = dst;
+ *anyShared = False;
+
+# define PUT(_n,_v) \
+ do { Word i; \
+ if (is_SHVAL_Sh(_v)) \
+ *anyShared = True; \
+ for (i = 0; i < (_n); i++) \
+ *dst++ = (_v); \
+ } while (0)
+
+ /* byte 0 */
+ if (descr & TREE_DESCR_64) PUT(8, tree[0]); else
+ if (descr & TREE_DESCR_32_0) PUT(4, tree[0]); else
+ if (descr & TREE_DESCR_16_0) PUT(2, tree[0]); else
+ if (descr & TREE_DESCR_8_0) PUT(1, tree[0]);
+ /* byte 1 */
+ if (descr & TREE_DESCR_8_1) PUT(1, tree[1]);
+ /* byte 2 */
+ if (descr & TREE_DESCR_16_1) PUT(2, tree[2]); else
+ if (descr & TREE_DESCR_8_2) PUT(1, tree[2]);
+ /* byte 3 */
+ if (descr & TREE_DESCR_8_3) PUT(1, tree[3]);
+ /* byte 4 */
+ if (descr & TREE_DESCR_32_1) PUT(4, tree[4]); else
+ if (descr & TREE_DESCR_16_2) PUT(2, tree[4]); else
+ if (descr & TREE_DESCR_8_4) PUT(1, tree[4]);
+ /* byte 5 */
+ if (descr & TREE_DESCR_8_5) PUT(1, tree[5]);
+ /* byte 6 */
+ if (descr & TREE_DESCR_16_3) PUT(2, tree[6]); else
+ if (descr & TREE_DESCR_8_6) PUT(1, tree[6]);
+ /* byte 7 */
+ if (descr & TREE_DESCR_8_7) PUT(1, tree[7]);
+
+# undef PUT
+
+ tl_assert( (((Char*)dst) - ((Char*)dst0)) == 8 * sizeof(UInt) );
+ return dst;
+}
+
+/* Write the cacheline 'wix' to backing store. Where it ends up
+ is determined by its tag field. */
+static
+Bool sequentialise_CacheLine ( /*OUT*/UInt* dst, Word nDst, CacheLine* src )
+{
+ Word tno, cloff;
+ Bool anyShared = False;
+ UInt* dst0 = dst;
+
+ for (tno = 0, cloff = 0; tno < N_LINE_TREES; tno++, cloff += 8) {
+ UShort descr = src->descrs[tno];
+ UInt* tree = &src->svals[cloff];
+ Bool bTmp = False;
+ dst = sequentialise_tree ( dst, &bTmp, descr, tree );
+ anyShared |= bTmp;
+ }
+ tl_assert(cloff == N_LINE_ARANGE);
+
+ /* Assert we wrote N_LINE_ARANGE shadow values. */
+ tl_assert( ((HChar*)dst) - ((HChar*)dst0)
+ == nDst * sizeof(UInt) );
+
+ return anyShared;
+}
+
+
+static __attribute__((noinline)) void cacheline_wback ( UWord wix )
+{
+ Word i, j;
+ Bool anyShared = False;
+ Addr tag;
+ SecMap* sm;
+ CacheLine* cl;
+ CacheLineZ* lineZ;
+ CacheLineF* lineF;
+ Word zix, fix;
+ UInt shvals[N_LINE_ARANGE];
+ UInt sv;
+
+ if (0)
+ VG_(printf)("scache wback line %d\n", (Int)wix);
+
+ tl_assert(wix >= 0 && wix < N_WAY_NENT);
+
+ tag = cache_shmem.tags0[wix];
+ cl = &cache_shmem.lyns0[wix];
+
+ /* The cache line may have been invalidated; if so, ignore it. */
+ if (!is_valid_scache_tag(tag))
+ return;
+
+ /* Where are we going to put it? */
+ sm = NULL;
+ lineZ = NULL;
+ lineF = NULL;
+ zix = fix = -1;
+
+ find_Z_for_writing( &sm, &zix, tag );
+ tl_assert(sm);
+ tl_assert(zix >= 0 && zix < N_SECMAP_ZLINES);
+ lineZ = &sm->linesZ[zix];
+
+ /* Generate the data to be stored */
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ anyShared = sequentialise_CacheLine( shvals, N_LINE_ARANGE, cl );
+
+ lineZ->dict[0] = lineZ->dict[1]
+ = lineZ->dict[2] = lineZ->dict[3] = 0;
+
+ for (i = 0; i < N_LINE_ARANGE; i++) {
+
+ sv = shvals[i];
+ for (j = 0; j < 4; j++) {
+ if (sv == lineZ->dict[j])
+ goto dict_ok;
+ }
+ for (j = 0; j < 4; j++) {
+ if (lineZ->dict[j] == 0)
+ break;
+ }
+ tl_assert(j >= 0 && j <= 4);
+ if (j == 4) break; /* we'll have to use the f rep */
+ tl_assert(is_SHVAL_valid(sv));
+ lineZ->dict[j] = sv;
+ dict_ok:
+ write_twobit_array( lineZ->ix2s, i, j );
+
+ }
+
+ tl_assert(i >= 0 && i <= N_LINE_ARANGE);
+
+ if (i < N_LINE_ARANGE) {
+ /* cannot use the compressed rep. Use f rep instead. */
+ alloc_F_for_writing( sm, &fix );
+ tl_assert(sm->linesF);
+ tl_assert(sm->linesF_size > 0);
+ tl_assert(fix >= 0 && fix < sm->linesF_size);
+ lineF = &sm->linesF[fix];
+ tl_assert(!lineF->inUse);
+ lineZ->dict[0] = lineZ->dict[2] = lineZ->dict[3] = 0;
+ lineZ->dict[1] = (UInt)fix;
+ lineF->inUse = True;
+ for (i = 0; i < N_LINE_ARANGE; i++) {
+ sv = shvals[i];
+ tl_assert(is_SHVAL_valid(sv));
+ lineF->w32s[i] = sv;
+ }
+ stats__cache_F_wbacks++;
+ } else {
+ stats__cache_Z_wbacks++;
+ }
+
+ if (anyShared)
+ sm->mbHasShared = True;
+
+ /* mb_tidy_one_cacheline(); */
+}
+
+/* Fetch the cacheline 'wix' from the backing store. The tag
+ associated with 'wix' is assumed to have already been filled in;
+ hence that is used to determine where in the backing store to read
+ from. */
+static __attribute__((noinline)) void cacheline_fetch ( UWord wix )
+{
+ Word i;
+ Addr tag;
+ CacheLine* cl;
+ CacheLineZ* lineZ;
+ CacheLineF* lineF;
+
+ if (0)
+ VG_(printf)("scache fetch line %d\n", (Int)wix);
+
+ tl_assert(wix >= 0 && wix < N_WAY_NENT);
+
+ tag = cache_shmem.tags0[wix];
+ cl = &cache_shmem.lyns0[wix];
+
+ /* reject nonsense requests */
+ tl_assert(is_valid_scache_tag(tag));
+
+ lineZ = NULL;
+ lineF = NULL;
+ find_ZF_for_reading( &lineZ, &lineF, tag );
+ tl_assert( (lineZ && !lineF) || (!lineZ && lineF) );
+
+ /* expand the data into the bottom layer of the tree, then get
+ cacheline_normalise to build the descriptor array. */
+ if (lineF) {
+ tl_assert(lineF->inUse);
+ for (i = 0; i < N_LINE_ARANGE; i++) {
+ cl->svals[i] = lineF->w32s[i];
+ }
+ stats__cache_F_fetches++;
+ } else {
+ for (i = 0; i < N_LINE_ARANGE; i++) {
+ UInt sv;
+ UWord ix = read_twobit_array( lineZ->ix2s, i );
+ tl_assert(ix >= 0 && ix <= 3);
+ sv = lineZ->dict[ix];
+ tl_assert(sv != 0);
+ cl->svals[i] = sv;
+ }
+ stats__cache_Z_fetches++;
+ }
+ normalise_CacheLine( cl );
+}
+
+static void shmem__invalidate_scache ( void ) {
+ Word wix;
+ if (0) VG_(printf)("scache inval\n");
+ tl_assert(!is_valid_scache_tag(1));
+ for (wix = 0; wix < N_WAY_NENT; wix++) {
+ cache_shmem.tags0[wix] = 1/*INVALID*/;
+ }
+ stats__cache_invals++;
+}
+
+static void shmem__flush_and_invalidate_scache ( void ) {
+ Word wix;
+ Addr tag;
+ if (0) VG_(printf)("scache flush and invalidate\n");
+ tl_assert(!is_valid_scache_tag(1));
+ for (wix = 0; wix < N_WAY_NENT; wix++) {
+ tag = cache_shmem.tags0[wix];
+ if (tag == 1/*INVALID*/) {
+ /* already invalid; nothing to do */
+ } else {
+ tl_assert(is_valid_scache_tag(tag));
+ cacheline_wback( wix );
+ }
+ cache_shmem.tags0[wix] = 1/*INVALID*/;
+ }
+ stats__cache_flushes++;
+ stats__cache_invals++;
+}
+
+
+/* ------------ Basic shadow memory read/write ops ------------ */
+
+static inline Bool aligned16 ( Addr a ) {
+ return 0 == (a & 1);
+}
+static inline Bool aligned32 ( Addr a ) {
+ return 0 == (a & 3);
+}
+static inline Bool aligned64 ( Addr a ) {
+ return 0 == (a & 7);
+}
+static inline UWord get_cacheline_offset ( Addr a ) {
+ return (UWord)(a & (N_LINE_ARANGE - 1));
+}
+static inline UWord get_treeno ( Addr a ) {
+ return get_cacheline_offset(a) >> 3;
+}
+static inline UWord get_tree_offset ( Addr a ) {
+ return a & 7;
+}
+
+static __attribute__((noinline))
+ CacheLine* get_cacheline_MISS ( Addr a ); /* fwds */
+static inline CacheLine* get_cacheline ( Addr a )
+{
+ /* tag is 'a' with the in-line offset masked out,
+ eg a[31]..a[4] 0000 */
+ Addr tag = a & ~(N_LINE_ARANGE - 1);
+ UWord wix = (a >> N_LINE_BITS) & (N_WAY_NENT - 1);
+ stats__cache_totrefs++;
+ if (LIKELY(tag == cache_shmem.tags0[wix])) {
+ return &cache_shmem.lyns0[wix];
+ } else {
+ return get_cacheline_MISS( a );
+ }
+}
+
+static __attribute__((noinline))
+ CacheLine* get_cacheline_MISS ( Addr a )
+{
+ /* tag is 'a' with the in-line offset masked out,
+ eg a[31]..a[4] 0000 */
+
+ CacheLine* cl;
+ Addr* tag_old_p;
+ Addr tag = a & ~(N_LINE_ARANGE - 1);
+ UWord wix = (a >> N_LINE_BITS) & (N_WAY_NENT - 1);
+
+ tl_assert(tag != cache_shmem.tags0[wix]);
+
+ /* Dump the old line into the backing store. */
+ stats__cache_totmisses++;
+
+ cl = &cache_shmem.lyns0[wix];
+ tag_old_p = &cache_shmem.tags0[wix];
+
+ if (is_valid_scache_tag( *tag_old_p )) {
+ /* EXPENSIVE and REDUNDANT: callee does it */
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ cacheline_wback( wix );
+ }
+ /* and reload the new one */
+ *tag_old_p = tag;
+ cacheline_fetch( wix );
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ return cl;
+}
+
+static UShort pulldown_to_32 ( /*MOD*/UInt* tree, UWord toff, UShort descr ) {
+ stats__cline_64to32pulldown++;
+ switch (toff) {
+ case 0: case 4:
+ tl_assert(descr & TREE_DESCR_64);
+ tree[4] = tree[0];
+ descr &= ~TREE_DESCR_64;
+ descr |= (TREE_DESCR_32_1 | TREE_DESCR_32_0);
+ break;
+ default:
+ tl_assert(0);
+ }
+ return descr;
+}
+
+static UShort pulldown_to_16 ( /*MOD*/UInt* tree, UWord toff, UShort descr ) {
+ stats__cline_32to16pulldown++;
+ switch (toff) {
+ case 0: case 2:
+ if (!(descr & TREE_DESCR_32_0)) {
+ descr = pulldown_to_32(tree, 0, descr);
+ }
+ tl_assert(descr & TREE_DESCR_32_0);
+ tree[2] = tree[0];
+ descr &= ~TREE_DESCR_32_0;
+ descr |= (TREE_DESCR_16_1 | TREE_DESCR_16_0);
+ break;
+ case 4: case 6:
+ if (!(descr & TREE_DESCR_32_1)) {
+ descr = pulldown_to_32(tree, 4, descr);
+ }
+ tl_assert(descr & TREE_DESCR_32_1);
+ tree[6] = tree[4];
+ descr &= ~TREE_DESCR_32_1;
+ descr |= (TREE_DESCR_16_3 | TREE_DESCR_16_2);
+ break;
+ default:
+ tl_assert(0);
+ }
+ return descr;
+}
+
+static UShort pulldown_to_8 ( /*MOD*/UInt* tree, UWord toff, UShort descr ) {
+ stats__cline_16to8pulldown++;
+ switch (toff) {
+ case 0: case 1:
+ if (!(descr & TREE_DESCR_16_0)) {
+ descr = pulldown_to_16(tree, 0, descr);
+ }
+ tl_assert(descr & TREE_DESCR_16_0);
+ tree[1] = tree[0];
+ descr &= ~TREE_DESCR_16_0;
+ descr |= (TREE_DESCR_8_1 | TREE_DESCR_8_0);
+ break;
+ case 2: case 3:
+ if (!(descr & TREE_DESCR_16_1)) {
+ descr = pulldown_to_16(tree, 2, descr);
+ }
+ tl_assert(descr & TREE_DESCR_16_1);
+ tree[3] = tree[2];
+ descr &= ~TREE_DESCR_16_1;
+ descr |= (TREE_DESCR_8_3 | TREE_DESCR_8_2);
+ break;
+ case 4: case 5:
+ if (!(descr & TREE_DESCR_16_2)) {
+ descr = pulldown_to_16(tree, 4, descr);
+ }
+ tl_assert(descr & TREE_DESCR_16_2);
+ tree[5] = tree[4];
+ descr &= ~TREE_DESCR_16_2;
+ descr |= (TREE_DESCR_8_5 | TREE_DESCR_8_4);
+ break;
+ case 6: case 7:
+ if (!(descr & TREE_DESCR_16_3)) {
+ descr = pulldown_to_16(tree, 6, descr);
+ }
+ tl_assert(descr & TREE_DESCR_16_3);
+ tree[7] = tree[6];
+ descr &= ~TREE_DESCR_16_3;
+ descr |= (TREE_DESCR_8_7 | TREE_DESCR_8_6);
+ break;
+ default:
+ tl_assert(0);
+ }
+ return descr;
+}
+
+
+static UShort pullup_descr_to_16 ( UShort descr, UWord toff ) {
+ UShort mask;
+ switch (toff) {
+ case 0:
+ mask = TREE_DESCR_8_1 | TREE_DESCR_8_0;
+ tl_assert( (descr & mask) == mask );
+ descr &= ~mask;
+ descr |= TREE_DESCR_16_0;
+ break;
+ case 2:
+ mask = TREE_DESCR_8_3 | TREE_DESCR_8_2;
+ tl_assert( (descr & mask) == mask );
+ descr &= ~mask;
+ descr |= TREE_DESCR_16_1;
+ break;
+ case 4:
+ mask = TREE_DESCR_8_5 | TREE_DESCR_8_4;
+ tl_assert( (descr & mask) == mask );
+ descr &= ~mask;
+ descr |= TREE_DESCR_16_2;
+ break;
+ case 6:
+ mask = TREE_DESCR_8_7 | TREE_DESCR_8_6;
+ tl_assert( (descr & mask) == mask );
+ descr &= ~mask;
+ descr |= TREE_DESCR_16_3;
+ break;
+ default:
+ tl_assert(0);
+ }
+ return descr;
+}
+
+static UShort pullup_descr_to_32 ( UShort descr, UWord toff ) {
+ UShort mask;
+ switch (toff) {
+ case 0:
+ if (!(descr & TREE_DESCR_16_0))
+ descr = pullup_descr_to_16(descr, 0);
+ if (!(descr & TREE_DESCR_16_1))
+ descr = pullup_descr_to_16(descr, 2);
+ mask = TREE_DESCR_16_1 | TREE_DESCR_16_0;
+ tl_assert( (descr & mask) == mask );
+ descr &= ~mask;
+ descr |= TREE_DESCR_32_0;
+ break;
+ case 4:
+ if (!(descr & TREE_DESCR_16_2))
+ descr = pullup_descr_to_16(descr, 4);
+ if (!(descr & TREE_DESCR_16_3))
+ descr = pullup_descr_to_16(descr, 6);
+ mask = TREE_DESCR_16_3 | TREE_DESCR_16_2;
+ tl_assert( (descr & mask) == mask );
+ descr &= ~mask;
+ descr |= TREE_DESCR_32_1;
+ break;
+ default:
+ tl_assert(0);
+ }
+ return descr;
+}
+
+static Bool valid_value_is_above_me_32 ( UShort descr, UWord toff ) {
+ switch (toff) {
+ case 0: case 4:
+ return 0 != (descr & TREE_DESCR_64);
+ default:
+ tl_assert(0);
+ }
+}
+
+static Bool valid_value_is_below_me_16 ( UShort descr, UWord toff ) {
+ switch (toff) {
+ case 0:
+ return 0 != (descr & (TREE_DESCR_8_1 | TREE_DESCR_8_0));
+ case 2:
+ return 0 != (descr & (TREE_DESCR_8_3 | TREE_DESCR_8_2));
+ case 4:
+ return 0 != (descr & (TREE_DESCR_8_5 | TREE_DESCR_8_4));
+ case 6:
+ return 0 != (descr & (TREE_DESCR_8_7 | TREE_DESCR_8_6));
+ default:
+ tl_assert(0);
+ }
+}
+
+static void shadow_mem_read8 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UInt svOld, svNew;
+ UShort descr;
+ stats__cline_read8s++;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0 .. 7 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_8_0 << toff)) )) {
+ UInt* tree = &cl->svals[tno << 3];
+ cl->descrs[tno] = pulldown_to_8(tree, toff, descr);
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ }
+ svOld = cl->svals[cloff];
+ svNew = msm__handle_read( thr_acc, a, svOld, 1 );
+ cl->svals[cloff] = svNew;
+}
+static void shadow_mem_read16 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UInt svOld, svNew;
+ UShort descr;
+ stats__cline_read16s++;
+ if (UNLIKELY(!aligned16(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0, 2, 4 or 6 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_16_0 << toff)) )) {
+ if (valid_value_is_below_me_16(descr, toff)) {
+ goto slowcase;
+ } else {
+ UInt* tree = &cl->svals[tno << 3];
+ cl->descrs[tno] = pulldown_to_16(tree, toff, descr);
+ }
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ }
+ svOld = cl->svals[cloff];
+ svNew = msm__handle_read( thr_acc, a, svOld, 2 );
+ cl->svals[cloff] = svNew;
+ return;
+ slowcase: /* misaligned, or must go further down the tree */
+ stats__cline_16to8splits++;
+ shadow_mem_read8( thr_acc, a + 0, 0/*unused*/ );
+ shadow_mem_read8( thr_acc, a + 1, 0/*unused*/ );
+}
+
+__attribute__((noinline))
+static void shadow_mem_read32_SLOW ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UInt svOld, svNew;
+ UShort descr;
+ if (UNLIKELY(!aligned32(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0 or 4 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_32_0 << toff)) )) {
+ if (valid_value_is_above_me_32(descr, toff)) {
+ UInt* tree = &cl->svals[tno << 3];
+ cl->descrs[tno] = pulldown_to_32(tree, toff, descr);
+ } else {
+ goto slowcase;
+ }
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ }
+ svOld = cl->svals[cloff];
+ svNew = msm__handle_read( thr_acc, a, svOld, 4 );
+ cl->svals[cloff] = svNew;
+ return;
+ slowcase: /* misaligned, or must go further down the tree */
+ stats__cline_32to16splits++;
+ shadow_mem_read16( thr_acc, a + 0, 0/*unused*/ );
+ shadow_mem_read16( thr_acc, a + 2, 0/*unused*/ );
+}
+inline
+static void shadow_mem_read32 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UShort descr;
+ stats__cline_read32s++;
+ if (UNLIKELY(!aligned32(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0 or 4 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_32_0 << toff)) )) goto slowcase;
+ { UInt* p = &cl->svals[cloff];
+ *p = msm__handle_read( thr_acc, a, *p, 4 );
+ }
+ return;
+ slowcase: /* misaligned, or not at this level in the tree */
+ shadow_mem_read32_SLOW( thr_acc, a, uuOpaque );
+}
+
+inline
+static void shadow_mem_read64 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UInt svOld, svNew;
+ UShort descr;
+ stats__cline_read64s++;
+ if (UNLIKELY(!aligned64(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0, unused */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & TREE_DESCR_64) )) {
+ goto slowcase;
+ }
+ svOld = cl->svals[cloff];
+ svNew = msm__handle_read( thr_acc, a, svOld, 8 );
+ cl->svals[cloff] = svNew;
+ return;
+ slowcase: /* misaligned, or must go further down the tree */
+ stats__cline_64to32splits++;
+ shadow_mem_read32( thr_acc, a + 0, 0/*unused*/ );
+ shadow_mem_read32( thr_acc, a + 4, 0/*unused*/ );
+}
+
+static void shadow_mem_write8 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UInt svOld, svNew;
+ UShort descr;
+ stats__cline_write8s++;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0 .. 7 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_8_0 << toff)) )) {
+ UInt* tree = &cl->svals[tno << 3];
+ cl->descrs[tno] = pulldown_to_8(tree, toff, descr);
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ }
+ svOld = cl->svals[cloff];
+ svNew = msm__handle_write( thr_acc, a, svOld, 1 );
+ cl->svals[cloff] = svNew;
+}
+static void shadow_mem_write16 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UInt svOld, svNew;
+ UShort descr;
+ stats__cline_write16s++;
+ if (UNLIKELY(!aligned16(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0, 2, 4 or 6 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_16_0 << toff)) )) {
+ if (valid_value_is_below_me_16(descr, toff)) {
+ goto slowcase;
+ } else {
+ UInt* tree = &cl->svals[tno << 3];
+ cl->descrs[tno] = pulldown_to_16(tree, toff, descr);
+ }
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ }
+ svOld = cl->svals[cloff];
+ svNew = msm__handle_write( thr_acc, a, svOld, 2 );
+ cl->svals[cloff] = svNew;
+ return;
+ slowcase: /* misaligned, or must go further down the tree */
+ stats__cline_16to8splits++;
+ shadow_mem_write8( thr_acc, a + 0, 0/*unused*/ );
+ shadow_mem_write8( thr_acc, a + 1, 0/*unused*/ );
+}
+
+__attribute__((noinline))
+static void shadow_mem_write32_SLOW ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UInt svOld, svNew;
+ UShort descr;
+ if (UNLIKELY(!aligned32(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0 or 4 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_32_0 << toff)) )) {
+ if (valid_value_is_above_me_32(descr, toff)) {
+ UInt* tree = &cl->svals[tno << 3];
+ cl->descrs[tno] = pulldown_to_32(tree, toff, descr);
+ } else {
+ goto slowcase;
+ }
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ }
+ svOld = cl->svals[cloff];
+ svNew = msm__handle_write( thr_acc, a, svOld, 4 );
+ cl->svals[cloff] = svNew;
+ return;
+ slowcase: /* misaligned, or must go further down the tree */
+ stats__cline_32to16splits++;
+ shadow_mem_write16( thr_acc, a + 0, 0/*unused*/ );
+ shadow_mem_write16( thr_acc, a + 2, 0/*unused*/ );
+}
+inline
+static void shadow_mem_write32 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UShort descr;
+ stats__cline_write32s++;
+ if (UNLIKELY(!aligned32(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0 or 4 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_32_0 << toff)) )) goto slowcase;
+ { UInt* p = &cl->svals[cloff];
+ *p = msm__handle_write( thr_acc, a, *p, 4 );
+ }
+ return;
+ slowcase: /* misaligned, or must go further down the tree */
+ shadow_mem_write32_SLOW( thr_acc, a, uuOpaque );
+}
+
+inline
+static void shadow_mem_write64 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UInt svOld, svNew;
+ UShort descr;
+ stats__cline_write64s++;
+ if (UNLIKELY(!aligned64(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0, unused */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & TREE_DESCR_64) )) {
+ goto slowcase;
+ }
+ svOld = cl->svals[cloff];
+ svNew = msm__handle_write( thr_acc, a, svOld, 8 );
+ cl->svals[cloff] = svNew;
+ return;
+ slowcase: /* misaligned, or must go further down the tree */
+ stats__cline_64to32splits++;
+ shadow_mem_write32( thr_acc, a + 0, 0/*unused*/ );
+ shadow_mem_write32( thr_acc, a + 4, 0/*unused*/ );
+}
+
+static void shadow_mem_set8 ( Thread* uu_thr_acc, Addr a, UInt svNew ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UShort descr;
+ stats__cline_set8s++;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0 .. 7 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_8_0 << toff)) )) {
+ UInt* tree = &cl->svals[tno << 3];
+ cl->descrs[tno] = pulldown_to_8(tree, toff, descr);
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ }
+ cl->svals[cloff] = svNew;
+}
+static void shadow_mem_set16 ( Thread* uu_thr_acc, Addr a, UInt svNew ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UShort descr;
+ stats__cline_set16s++;
+ if (UNLIKELY(!aligned16(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0, 2, 4 or 6 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_16_0 << toff)) )) {
+ if (valid_value_is_below_me_16(descr, toff)) {
+ /* Writing at this level. Need to fix up 'descr'. */
+ cl->descrs[tno] = pullup_descr_to_16(descr, toff);
+ /* At this point, the tree does not match cl->descr[tno] any
+ more. The assignments below will fix it up. */
+ } else {
+ /* We can't indiscriminately write on the w16 node as in the
+ w64 case, as that might make the node inconsistent with
+ its parent. So first, pull down to this level. */
+ UInt* tree = &cl->svals[tno << 3];
+ cl->descrs[tno] = pulldown_to_16(tree, toff, descr);
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ }
+ }
+ cl->svals[cloff + 0] = svNew;
+ cl->svals[cloff + 1] = 0;
+ return;
+ slowcase: /* misaligned */
+ stats__cline_16to8splits++;
+ shadow_mem_set8( uu_thr_acc, a + 0, svNew );
+ shadow_mem_set8( uu_thr_acc, a + 1, svNew );
+}
+static void shadow_mem_set32 ( Thread* uu_thr_acc, Addr a, UInt svNew ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UShort descr;
+ stats__cline_set32s++;
+ if (UNLIKELY(!aligned32(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0 or 4 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_32_0 << toff)) )) {
+ if (valid_value_is_above_me_32(descr, toff)) {
+ /* We can't indiscriminately write on the w32 node as in the
+ w64 case, as that might make the node inconsistent with
+ its parent. So first, pull down to this level. */
+ UInt* tree = &cl->svals[tno << 3];
+ cl->descrs[tno] = pulldown_to_32(tree, toff, descr);
+ if (SCE_CACHELINE)
+ tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+ } else {
+ /* Writing at this level. Need to fix up 'descr'. */
+ cl->descrs[tno] = pullup_descr_to_32(descr, toff);
+ /* At this point, the tree does not match cl->descr[tno] any
+ more. The assignments below will fix it up. */
+ }
+ }
+ cl->svals[cloff + 0] = svNew;
+ cl->svals[cloff + 1] = 0;
+ cl->svals[cloff + 2] = 0;
+ cl->svals[cloff + 3] = 0;
+ return;
+ slowcase: /* misaligned */
+ stats__cline_32to16splits++;
+ shadow_mem_set16( uu_thr_acc, a + 0, svNew );
+ shadow_mem_set16( uu_thr_acc, a + 2, svNew );
+}
+inline
+static void shadow_mem_set64 ( Thread* uu_thr_acc, Addr a, UInt svNew ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ stats__cline_set64s++;
+ if (UNLIKELY(!aligned64(a))) goto slowcase;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0 */
+ cl->descrs[tno] = TREE_DESCR_64;
+ cl->svals[cloff + 0] = svNew;
+ cl->svals[cloff + 1] = 0;
+ cl->svals[cloff + 2] = 0;
+ cl->svals[cloff + 3] = 0;
+ cl->svals[cloff + 4] = 0;
+ cl->svals[cloff + 5] = 0;
+ cl->svals[cloff + 6] = 0;
+ cl->svals[cloff + 7] = 0;
+ return;
+ slowcase: /* misaligned */
+ stats__cline_64to32splits++;
+ shadow_mem_set32( uu_thr_acc, a + 0, svNew );
+ shadow_mem_set32( uu_thr_acc, a + 4, svNew );
+}
+
+static UInt shadow_mem_get8 ( Addr a ) {
+ CacheLine* cl;
+ UWord cloff, tno, toff;
+ UShort descr;
+ stats__cline_get8s++;
+ cl = get_cacheline(a);
+ cloff = get_cacheline_offset(a);
+ tno = get_treeno(a);
+ toff = get_tree_offset(a); /* == 0 .. 7 */
+ descr = cl->descrs[tno];
+ if (UNLIKELY( !(descr & (TREE_DESCR_8_0 << toff)) )) {
+ UInt* tree = &cl->svals[tno << 3];
+ cl->descrs[tno] = pulldown_to_8(tree, toff, descr);
+ }
+ return cl->svals[cloff];
+}
+
+static void shadow_mem_copy8 ( Addr src, Addr dst, Bool normalise ) {
+ UInt sv;
+ stats__cline_copy8s++;
+ sv = shadow_mem_get8( src );
+
+ if (UNLIKELY(clo_trace_level > 0)) {
+ if (dst == clo_trace_addr) {
+ Thread* thr = get_current_Thread();
+ UInt sv_old = shadow_mem_get8( dst );
+ msm__show_state_change( thr, dst, 1, 'w', sv_old, sv );
+ }
+ }
+
+ shadow_mem_set8( NULL/*unused*/, dst, sv );
+}
+
+
+/* ------------ Shadow memory range setting ops ------------ */
+
+static void shadow_mem_modify_range(
+ Thread* thr,
+ Addr a,
+ SizeT len,
+ void (*fn8) (Thread*,Addr,UInt),
+ void (*fn16)(Thread*,Addr,UInt),
+ void (*fn32)(Thread*,Addr,UInt),
+ void (*fn64)(Thread*,Addr,UInt),
+ UInt opaque
+ )
+{
+ /* fast track a couple of common cases */
+ if (len == 4 && aligned32(a)) {
+ fn32( thr, a, opaque );
+ return;
+ }
+ if (len == 8 && aligned64(a)) {
+ fn64( thr, a, opaque );
+ return;
+ }
+
+ /* be completely general (but as efficient as possible) */
+ if (len == 0) return;
+
+ if (!aligned16(a) && len >= 1) {
+ fn8( thr, a, opaque );
+ a += 1;
+ len -= 1;
+ tl_assert(aligned16(a));
+ }
+ if (len == 0) return;
+
+ if (!aligned32(a) && len >= 2) {
+ fn16( thr, a, opaque );
+ a += 2;
+ len -= 2;
+ tl_assert(aligned32(a));
+ }
+ if (len == 0) return;
+
+ if (!aligned64(a) && len >= 4) {
+ fn32( thr, a, opaque );
+ a += 4;
+ len -= 4;
+ tl_assert(aligned64(a));
+ }
+ if (len == 0) return;
+
+ if (len >= 8) {
+ tl_assert(aligned64(a));
+ while (len >= 8) {
+ fn64( thr, a, opaque );
+ a += 8;
+ len -= 8;
+ }
+ tl_assert(aligned64(a));
+ }
+ if (len == 0) return;
+
+ if (len >= 4)
+ tl_assert(aligned32(a));
+ if (len >= 4) {
+ fn32( thr, a, opaque );
+ a += 4;
+ len -= 4;
+ }
+ if (len == 0) return;
+
+ if (len >= 2)
+ tl_assert(aligned16(a));
+ if (len >= 2) {
+ fn16( thr, a, opaque );
+ a += 2;
+ len -= 2;
+ }
+ if (len == 0) return;
+
+ if (len >= 1) {
+ fn8( thr, a, opaque );
+ a += 1;
+ len -= 1;
+ }
+ tl_assert(len == 0);
+}
+
+/* Block-copy states (needed for implementing realloc()). */
+static void shadow_mem_copy_range ( Addr src, Addr dst, SizeT len )
+{
+ SizeT i;
+ if (len == 0)
+ return;
+ /* To be simple, just copy byte by byte. But so as not to wreck
+ performance for later accesses to dst[0 .. len-1], normalise
+ destination lines as we finish with them, and also normalise the
+ line containing the first and last address. */
+ for (i = 0; i < len; i++) {
+ Bool normalise
+ = get_cacheline_offset( dst+i+1 ) == 0 /* last in line */
+ || i == 0 /* first in range */
+ || i == len-1; /* last in range */
+ shadow_mem_copy8( src+i, dst+i, normalise );
+ }
+}
+
+static void shadow_mem_read_range ( Thread* thr, Addr a, SizeT len ) {
+ shadow_mem_modify_range( thr, a, len,
+ shadow_mem_read8,
+ shadow_mem_read16,
+ shadow_mem_read32,
+ shadow_mem_read64,
+ 0/*opaque,ignored*/ );
+}
+
+static void shadow_mem_write_range ( Thread* thr, Addr a, SizeT len ) {
+ shadow_mem_modify_range( thr, a, len,
+ shadow_mem_write8,
+ shadow_mem_write16,
+ shadow_mem_write32,
+ shadow_mem_write64,
+ 0/*opaque,ignored*/ );
+}
+
+static void shadow_mem_make_New ( Thread* thr, Addr a, SizeT len )
+{
+ if (UNLIKELY(clo_trace_level > 0)) {
+ if (len > 0 && a <= clo_trace_addr && clo_trace_addr < a+len) {
+ UInt sv_old = shadow_mem_get8( clo_trace_addr );
+ msm__show_state_change( thr, a, (Int)len, 'p', sv_old, SHVAL_New );
+ }
+ }
+ shadow_mem_modify_range( thr, a, len,
+ shadow_mem_set8,
+ shadow_mem_set16,
+ shadow_mem_set32,
+ shadow_mem_set64,
+ SHVAL_New/*opaque*/ );
+}
+
+
+/* Putting memory into the NoAccess state. This is hugely complicated
+ by the problem of memory that contains locks.
+
+ 1. Examine the .mbHasLocks fields in all SecMaps in the range to be
+ deleted. This quickly indicates if there are or might be any
+ locks in the range to be deleted. Note that .mbHasLocks fields on
+ SecMaps are not subject to scaching, so it safe to look at them
+ without flushing the scache.
+
+ 2. Set the range to NoAccess. Clear the .mbHasShared and
+ .mbHasLocks hint bits for any completely vacated SecMaps.
+ Clearing the hint bits isn't necessary for correctness, but it
+ is important to avoid ending up with hint bits being permanently
+ set, which would render them pointless.
+
+ 3. If (1) indicated "definitely no locks", we're done. This is
+ the fast and hopefully common case.
+
+ Otherwise, the range contains some locks (or may do), so we have to
+ go to considerable effort to tidy up.
+
+ 4. Make up a set containing the locks which are deleted:
+
+ ToDelete = NULL
+
+ for each lk in map_locks {
+ if lk's guest addr falls in the range to memory be deleted
+ add lk to ToDelete
+
+ if lk is held, issue an error message - freeing memory
+ containing a held lock
+ }
+
+ 5. If ToDelete is empty, there were in fact no locks in the range,
+ despite what the .mbHasLocks hint bits indicated. We're done.
+
+ 6. Flush the scache. This is necessary both to bring the SecMap
+ .mbHasShared fields up to date, and to bring the actual shadow
+ values up to date. We will need to examine both of these.
+
+ Invalidate the scache. This is necessary because we will be
+ modifying values in the backing store (SecMaps) and need
+ subsequent shmem accesses to get the new values.
+
+ 7. Modify all shadow words, by removing ToDelete from the lockset
+ of all ShM and ShR states. Note this involves a complete scan
+ over map_shmem, which is very expensive according to OProfile.
+ Hence it depends critically on the size of each entry in
+ map_shmem. See comments on definition of N_SECMAP_BITS above.
+
+ Why is it safe to do (7) after (2) ? Because we're not
+ interested in messing with ShR/M states which are going to be
+ set to NoAccess anyway.
+
+ Optimisation 1 (implemented): skip this step for SecMaps which
+ do not have .mbHasShared set
+
+ Optimisation 2 (not implemented): for each SecMap, have a
+ summary lock set which is the union of all locks mentioned in
+ locksets on this page (or any superset of it). Then skip step
+ (2) if the summary lockset does not intersect with ToDelete.
+
+ That's potentially cheap, since the usual lockset refinement
+ only shrinks locksets; hence there is no point in updating the
+ summary lockset for ShM/R -> ShM/R transitions. Therefore only
+ need to do this for Excl->ShM/R transitions.
+
+ 8. Tell laog that these locks have disappeared.
+*/
+static void shadow_mem_make_NoAccess ( Thread* thr, Addr aIN, SizeT len )
+{
+ Lock* lk;
+ Addr gla, sma, firstSM, lastSM, firstA, lastA;
+ WordSetID locksToDelete;
+ Bool mbHasLocks;
+
+ if (0 && len > 500)
+ VG_(printf)("make NoAccess ( %p, %d )\n", aIN, len );
+
+ if (len == 0)
+ return;
+
+ /* --- Step 1 --- */
+
+ firstA = aIN;
+ lastA = aIN + len - 1;
+
+ firstSM = shmem__round_to_SecMap_base( firstA );
+ lastSM = shmem__round_to_SecMap_base( lastA );
+ tl_assert(firstSM <= lastSM);
+
+ mbHasLocks = False;
+ for (sma = firstSM; sma <= lastSM; sma += N_SECMAP_ARANGE) {
+ if (shmem__get_mbHasLocks(sma)) {
+ mbHasLocks = True;
+ break;
+ }
+ }
+
+ /* --- Step 2 --- */
+
+ if (UNLIKELY(clo_trace_level > 0)) {
+ if (len > 0 && firstA <= clo_trace_addr && clo_trace_addr <= lastA) {
+ UInt sv_old = shadow_mem_get8( clo_trace_addr );
+ msm__show_state_change( thr, firstA, (Int)len, 'p',
+ sv_old, SHVAL_NoAccess );
+ }
+ }
+ shadow_mem_modify_range( thr, firstA, len,
+ shadow_mem_set8,
+ shadow_mem_set16,
+ shadow_mem_set32,
+ shadow_mem_set64,
+ SHVAL_NoAccess/*opaque*/ );
+
+ for (sma = firstSM; sma <= lastSM; sma += N_SECMAP_ARANGE) {
+ /* Is this sm entirely within the deleted range? */
+ if (firstA <= sma && sma + N_SECMAP_ARANGE - 1 <= lastA) {
+ /* Yes. Clear the hint bits. */
+ shmem__set_mbHasLocks( sma, False );
+ shmem__set_mbHasShared( sma, False );
+ }
+ }
+
+ /* --- Step 3 --- */
+
+ if (!mbHasLocks)
+ return;
+
+ /* --- Step 4 --- */
+
+ if (0)
+ VG_(printf)("shadow_mem_make_NoAccess(%p, %u, %p): maybe slow case\n",
+ (void*)firstA, (UWord)len, (void*)lastA);
+ locksToDelete = HG_(emptyWS)( univ_lsets );
+
+ /* FIXME: don't iterate over the complete lock set */
+ HG_(initIterFM)( map_locks );
+ while (HG_(nextIterFM)( map_locks,
+ (Word*)(void*)&gla, (Word*)(void*)&lk )) {
+ tl_assert(is_sane_LockN(lk));
+ if (gla < firstA || gla > lastA)
+ continue;
+ locksToDelete = HG_(addToWS)( univ_lsets, locksToDelete, (Word)lk );
+ /* If the lock is held, we must remove it from the currlock sets
+ of all threads that hold it. Also take the opportunity to
+ report an error. To report an error we need to know at least
+ one of the threads that holds it; really we should mention
+ them all, but that's too much hassle. So choose one
+ arbitrarily. */
+ if (lk->heldBy) {
+ tl_assert(!HG_(isEmptyBag)(lk->heldBy));
+ record_error_FreeMemLock( (Thread*)HG_(anyElementOfBag)(lk->heldBy),
+ lk );
+ /* remove lock from locksets of all owning threads */
+ remove_Lock_from_locksets_of_all_owning_Threads( lk );
+ /* Leave lk->heldBy in place; del_Lock below will free it up. */
+ }
+ }
+ HG_(doneIterFM)( map_locks );
+
+ /* --- Step 5 --- */
+
+ if (HG_(isEmptyWS)( univ_lsets, locksToDelete ))
+ return;
+
+ /* --- Step 6 --- */
+
+ shmem__flush_and_invalidate_scache();
+
+ /* --- Step 7 --- */
+
+ if (0)
+ VG_(printf)("shadow_mem_make_NoAccess(%p, %u, %p): definitely slow case\n",
+ (void*)firstA, (UWord)len, (void*)lastA);
+
+ /* Modify all shadow words, by removing locksToDelete from the lockset
+ of all ShM and ShR states.
+ Optimisation 1: skip SecMaps which do not have .mbHasShared set
+ */
+ { Int stats_SMs = 0, stats_SMs_scanned = 0;
+ Addr ga;
+ SecMap* sm;
+ SecMapIter itr;
+ UInt* w32p;
+
+ HG_(initIterFM)( map_shmem );
+ while (HG_(nextIterFM)( map_shmem,
+ (Word*)(void*)&ga, (Word*)(void*)&sm )) {
+ tl_assert(sm);
+ stats_SMs++;
+ /* Skip this SecMap if the summary bit indicates it is safe to
+ do so. */
+ if (!sm->mbHasShared)
+ continue;
+ stats_SMs_scanned++;
+ initSecMapIter( &itr );
+ while (stepSecMapIter( &w32p, &itr, sm )) {
+ Bool isM;
+ UInt wold, wnew, lset_old, tset_old, lset_new;
+ wold = *w32p;
+ if (LIKELY( !is_SHVAL_Sh(wold) ))
+ continue;
+ isM = is_SHVAL_ShM(wold);
+ lset_old = un_SHVAL_Sh_lset(wold);
+ tset_old = un_SHVAL_Sh_tset(wold);
+ lset_new = HG_(minusWS)( univ_lsets, lset_old, locksToDelete );
+ wnew = isM ? mk_SHVAL_ShM(tset_old, lset_new)
+ : mk_SHVAL_ShR(tset_old, lset_new);
+ if (wnew != wold)
+ *w32p = wnew;
+ }
+ }
+ HG_(doneIterFM)( map_shmem );
+ if (SHOW_EXPENSIVE_STUFF)
+ VG_(printf)("shadow_mem_make_NoAccess: %d SMs, %d scanned\n",
+ stats_SMs, stats_SMs_scanned);
+ }
+
+ /* Now we have to free up the Locks in locksToDelete and remove
+ any mention of them from admin_locks and map_locks. This is
+ inefficient. */
+ { Lock* lkprev = NULL;
+ lk = admin_locks;
+ while (True) {
+ if (lk == NULL) break;
+ if (lkprev) tl_assert(lkprev->admin == lk);
+
+ if (!HG_(elemWS)(univ_lsets, locksToDelete, (Word)lk)) {
+ lkprev = lk;
+ lk = lk->admin;
+ continue;
+ }
+ /* Need to delete 'lk' */
+ if (lkprev == NULL) {
+ admin_locks = lk->admin;
+ } else {
+ lkprev->admin = lk->admin;
+ }
+ /* and get it out of map_locks */
+ map_locks_delete(lk->guestaddr);
+ /* release storage (incl. associated .heldBy Bag) */
+ { Lock* tmp = lk->admin;
+ del_LockN(lk);
+ lk = tmp;
+ }
+ }
+ }
+
+ /* --- Step 8 --- */
+
+ /* update lock order acquisition graph */
+ laog__handle_lock_deletions( locksToDelete );
+
+ if (0) all__sanity_check("Make NoAccess");
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Event handlers (evh__* functions) ---*/
+/*--- plus helpers (evhH__* functions) ---*/
+/*----------------------------------------------------------------*/
+
+/*--------- Event handler helpers (evhH__* functions) ---------*/
+
+/* Create a new segment for 'thr', making it depend (.prev) on its
+ existing segment, bind together the SegmentID and Segment, and
+ return both of them. Also update 'thr' so it references the new
+ Segment. */
+static
+void evhH__start_new_segment_for_thread ( /*OUT*/SegmentID* new_segidP,
+ /*OUT*/Segment** new_segP,
+ Thread* thr )
+{
+ Segment* cur_seg;
+ tl_assert(new_segP);
+ tl_assert(new_segidP);
+ tl_assert(is_sane_Thread(thr));
+ cur_seg = map_segments_lookup( thr->csegid );
+ tl_assert(cur_seg);
+ tl_assert(cur_seg->thr == thr); /* all sane segs should point back
+ at their owner thread. */
+ *new_segP = mk_Segment( thr, cur_seg, NULL/*other*/ );
+ *new_segidP = alloc_SegmentID();
+ map_segments_add( *new_segidP, *new_segP );
+ thr->csegid = *new_segidP;
+}
+
+
+/* The lock at 'lock_ga' has acquired a writer. Make all necessary
+ updates, and also do all possible error checks. */
+static
+void evhH__post_thread_w_acquires_lock ( Thread* thr,
+ LockKind lkk, Addr lock_ga )
+{
+ Lock* lk;
+
+ /* Basically what we need to do is call lockN_acquire_writer.
+ However, that will barf if any 'invalid' lock states would
+ result. Therefore check before calling. Side effect is that
+ 'is_sane_LockN(lk)' is both a pre- and post-condition of this
+ routine.
+
+ Because this routine is only called after successful lock
+ acquisition, we should not be asked to move the lock into any
+ invalid states. Requests to do so are bugs in libpthread, since
+ that should have rejected any such requests. */
+
+ /* be paranoid w.r.t hint bits, even if lock_ga is complete
+ nonsense */
+ shmem__set_mbHasLocks( lock_ga, True );
+
+ tl_assert(is_sane_Thread(thr));
+ /* Try to find the lock. If we can't, then create a new one with
+ kind 'lkk'. */
+ lk = map_locks_lookup_or_create(
+ lkk, lock_ga, map_threads_reverse_lookup_SLOW(thr) );
+ tl_assert( is_sane_LockN(lk) );
+ shmem__set_mbHasLocks( lock_ga, True );
+
+ if (lk->heldBy == NULL) {
+ /* the lock isn't held. Simple. */
+ tl_assert(!lk->heldW);
+ lockN_acquire_writer( lk, thr );
+ goto noerror;
+ }
+
+ /* So the lock is already held. If held as a r-lock then
+ libpthread must be buggy. */
+ tl_assert(lk->heldBy);
+ if (!lk->heldW) {
+ record_error_Misc( thr, "Bug in libpthread: write lock "
+ "granted on rwlock which is currently rd-held");
+ goto error;
+ }
+
+ /* So the lock is held in w-mode. If it's held by some other
+ thread, then libpthread must be buggy. */
+ tl_assert(HG_(sizeUniqueBag)(lk->heldBy) == 1); /* from precondition */
+
+ if (thr != (Thread*)HG_(anyElementOfBag)(lk->heldBy)) {
+ record_error_Misc( thr, "Bug in libpthread: write lock "
+ "granted on mutex/rwlock which is currently "
+ "wr-held by a different thread");
+ goto error;
+ }
+
+ /* So the lock is already held in w-mode by 'thr'. That means this
+ is an attempt to lock it recursively, which is only allowable
+ for LK_mbRec kinded locks. Since this routine is called only
+ once the lock has been acquired, this must also be a libpthread
+ bug. */
+ if (lk->kind != LK_mbRec) {
+ record_error_Misc( thr, "Bug in libpthread: recursive write lock "
+ "granted on mutex/wrlock which does not "
+ "support recursion");
+ goto error;
+ }
+
+ /* So we are recursively re-locking a lock we already w-hold. */
+ lockN_acquire_writer( lk, thr );
+ goto noerror;
+
+ noerror:
+ /* check lock order acquisition graph, and update. This has to
+ happen before the lock is added to the thread's locksetA/W. */
+ laog__pre_thread_acquires_lock( thr, lk );
+ /* update the thread's held-locks set */
+ thr->locksetA = HG_(addToWS)( univ_lsets, thr->locksetA, (Word)lk );
+ thr->locksetW = HG_(addToWS)( univ_lsets, thr->locksetW, (Word)lk );
+ /* fall through */
+
+ error:
+ tl_assert(is_sane_LockN(lk));
+}
+
+
+/* The lock at 'lock_ga' has acquired a reader. Make all necessary
+ updates, and also do all possible error checks. */
+static
+void evhH__post_thread_r_acquires_lock ( Thread* thr,
+ LockKind lkk, Addr lock_ga )
+{
+ Lock* lk;
+
+ /* Basically what we need to do is call lockN_acquire_reader.
+ However, that will barf if any 'invalid' lock states would
+ result. Therefore check before calling. Side effect is that
+ 'is_sane_LockN(lk)' is both a pre- and post-condition of this
+ routine.
+
+ Because this routine is only called after successful lock
+ acquisition, we should not be asked to move the lock into any
+ invalid states. Requests to do so are bugs in libpthread, since
+ that should have rejected any such requests. */
+
+ /* be paranoid w.r.t hint bits, even if lock_ga is complete
+ nonsense */
+ shmem__set_mbHasLocks( lock_ga, True );
+
+ tl_assert(is_sane_Thread(thr));
+ /* Try to find the lock. If we can't, then create a new one with
+ kind 'lkk'. Only a reader-writer lock can be read-locked,
+ hence the first assertion. */
+ tl_assert(lkk == LK_rdwr);
+ lk = map_locks_lookup_or_create(
+ lkk, lock_ga, map_threads_reverse_lookup_SLOW(thr) );
+ tl_assert( is_sane_LockN(lk) );
+ shmem__set_mbHasLocks( lock_ga, True );
+
+ if (lk->heldBy == NULL) {
+ /* the lock isn't held. Simple. */
+ tl_assert(!lk->heldW);
+ lockN_acquire_reader( lk, thr );
+ goto noerror;
+ }
+
+ /* So the lock is already held. If held as a w-lock then
+ libpthread must be buggy. */
+ tl_assert(lk->heldBy);
+ if (lk->heldW) {
+ record_error_Misc( thr, "Bug in libpthread: read lock "
+ "granted on rwlock which is "
+ "currently wr-held");
+ goto error;
+ }
+
+ /* Easy enough. In short anybody can get a read-lock on a rwlock
+ provided it is either unlocked or already in rd-held. */
+ lockN_acquire_reader( lk, thr );
+ goto noerror;
+
+ noerror:
+ /* check lock order acquisition graph, and update. This has to
+ happen before the lock is added to the thread's locksetA/W. */
+ laog__pre_thread_acquires_lock( thr, lk );
+ /* update the thread's held-locks set */
+ thr->locksetA = HG_(addToWS)( univ_lsets, thr->locksetA, (Word)lk );
+ /* but don't update thr->locksetW, since lk is only rd-held */
+ /* fall through */
+
+ error:
+ tl_assert(is_sane_LockN(lk));
+}
+
+
+/* The lock at 'lock_ga' is just about to be unlocked. Make all
+ necessary updates, and also do all possible error checks. */
+static
+void evhH__pre_thread_releases_lock ( Thread* thr,
+ Addr lock_ga, Bool isRDWR )
+{
+ Lock* lock;
+ Word n;
+
+ /* This routine is called prior to a lock release, before
+ libpthread has had a chance to validate the call. Hence we need
+ to detect and reject any attempts to move the lock into an
+ invalid state. Such attempts are bugs in the client.
+
+ isRDWR is True if we know from the wrapper context that lock_ga
+ should refer to a reader-writer lock, and is False if [ditto]
+ lock_ga should refer to a standard mutex. */
+
+ /* be paranoid w.r.t hint bits, even if lock_ga is complete
+ nonsense */
+ shmem__set_mbHasLocks( lock_ga, True );
+
+ tl_assert(is_sane_Thread(thr));
+ lock = map_locks_maybe_lookup( lock_ga );
+
+ if (!lock) {
+ /* We know nothing about a lock at 'lock_ga'. Nevertheless
+ the client is trying to unlock it. So complain, then ignore
+ the attempt. */
+ record_error_UnlockBogus( thr, lock_ga );
+ return;
+ }
+
+ tl_assert(lock->guestaddr == lock_ga);
+ tl_assert(is_sane_LockN(lock));
+
+ if (isRDWR && lock->kind != LK_rdwr) {
+ record_error_Misc( thr, "pthread_rwlock_unlock with a "
+ "pthread_mutex_t* argument " );
+ }
+ if ((!isRDWR) && lock->kind == LK_rdwr) {
+ record_error_Misc( thr, "pthread_mutex_unlock with a "
+ "pthread_rwlock_t* argument " );
+ }
+
+ if (!lock->heldBy) {
+ /* The lock is not held. This indicates a serious bug in the
+ client. */
+ tl_assert(!lock->heldW);
+ record_error_UnlockUnlocked( thr, lock );
+ tl_assert(!HG_(elemWS)( univ_lsets, thr->locksetA, (Word)lock ));
+ tl_assert(!HG_(elemWS)( univ_lsets, thr->locksetW, (Word)lock ));
+ goto error;
+ }
+
+ /* The lock is held. Is this thread one of the holders? If not,
+ report a bug in the client. */
+ n = HG_(elemBag)( lock->heldBy, (Word)thr );
+ tl_assert(n >= 0);
+ if (n == 0) {
+ /* We are not a current holder of the lock. This is a bug in
+ the guest, and (per POSIX pthread rules) the unlock
+ attempt will fail. So just complain and do nothing
+ else. */
+ Thread* realOwner = (Thread*)HG_(anyElementOfBag)( lock->heldBy );
+ tl_assert(is_sane_Thread(realOwner));
+ tl_assert(realOwner != thr);
+ tl_assert(!HG_(elemWS)( univ_lsets, thr->locksetA, (Word)lock ));
+ tl_assert(!HG_(elemWS)( univ_lsets, thr->locksetW, (Word)lock ));
+ record_error_UnlockForeign( thr, realOwner, lock );
+ goto error;
+ }
+
+ /* Ok, we hold the lock 'n' times. */
+ tl_assert(n >= 1);
+
+ lockN_release( lock, thr );
+
+ n--;
+ tl_assert(n >= 0);
+
+ if (n > 0) {
+ tl_assert(lock->heldBy);
+ tl_assert(n == HG_(elemBag)( lock->heldBy, (Word)thr ));
+ /* We still hold the lock. So either it's a recursive lock
+ or a rwlock which is currently r-held. */
+ tl_assert(lock->kind == LK_mbRec
+ || (lock->kind == LK_rdwr && !lock->heldW));
+ tl_assert(HG_(elemWS)( univ_lsets, thr->locksetA, (Word)lock ));
+ if (lock->heldW)
+ tl_assert(HG_(elemWS)( univ_lsets, thr->locksetW, (Word)lock ));
+ else
+ tl_assert(!HG_(elemWS)( univ_lsets, thr->locksetW, (Word)lock ));
+ } else {
+ /* We no longer hold the lock. */
+ if (lock->heldBy) {
+ tl_assert(0 == HG_(elemBag)( lock->heldBy, (Word)thr ));
+ }
+ /* update this thread's lockset accordingly. */
+ thr->locksetA
+ = HG_(delFromWS)( univ_lsets, thr->locksetA, (Word)lock );
+ thr->locksetW
+ = HG_(delFromWS)( univ_lsets, thr->locksetW, (Word)lock );
+ }
+ /* fall through */
+
+ error:
+ tl_assert(is_sane_LockN(lock));
+}
+
+
+/*--------- Event handlers proper (evh__* functions) ---------*/
+
+/* What is the Thread* for the currently running thread? This is
+ absolutely performance critical. We receive notifications from the
+ core for client code starts/stops, and cache the looked-up result
+ in 'current_Thread'. Hence, for the vast majority of requests,
+ finding the current thread reduces to a read of a global variable,
+ provided get_current_Thread_in_C_C is inlined.
+
+ Outside of client code, current_Thread is NULL, and presumably
+ any uses of it will cause a segfault. Hence:
+
+ - for uses definitely within client code, use
+ get_current_Thread_in_C_C.
+
+ - for all other uses, use get_current_Thread.
+*/
+
+static Thread* current_Thread = NULL;
+
+static void evh__start_client_code ( ThreadId tid, ULong nDisp ) {
+ if (0) VG_(printf)("start %d %llu\n", (Int)tid, nDisp);
+ tl_assert(current_Thread == NULL);
+ current_Thread = map_threads_lookup( tid );
+ tl_assert(current_Thread != NULL);
+}
+static void evh__stop_client_code ( ThreadId tid, ULong nDisp ) {
+ if (0) VG_(printf)(" stop %d %llu\n", (Int)tid, nDisp);
+ tl_assert(current_Thread != NULL);
+ current_Thread = NULL;
+}
+static inline Thread* get_current_Thread_in_C_C ( void ) {
+ return current_Thread;
+}
+static inline Thread* get_current_Thread ( void ) {
+ ThreadId coretid;
+ Thread* thr;
+ thr = get_current_Thread_in_C_C();
+ if (LIKELY(thr))
+ return thr;
+ /* evidently not in client code. Do it the slow way. */
+ coretid = VG_(get_running_tid)();
+ /* FIXME: get rid of the following kludge. It exists because
+ evim__new_mem is called during initialisation (as notification
+ of initial memory layout) and VG_(get_running_tid)() returns
+ VG_INVALID_THREADID at that point. */
+ if (coretid == VG_INVALID_THREADID)
+ coretid = 1; /* KLUDGE */
+ thr = map_threads_lookup( coretid );
+ return thr;
+}
+
+static
+void evh__new_mem ( Addr a, SizeT len ) {
+ if (SHOW_EVENTS >= 2)
+ VG_(printf)("evh__new_mem(%p, %lu)\n", (void*)a, len );
+ shadow_mem_make_New( get_current_Thread(), a, len );
+ if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+ all__sanity_check("evh__new_mem-post");
+}
+
+static
+void evh__new_mem_w_perms ( Addr a, SizeT len,
+ Bool rr, Bool ww, Bool xx ) {
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__new_mem_w_perms(%p, %lu, %d,%d,%d)\n",
+ (void*)a, len, (Int)rr, (Int)ww, (Int)xx );
+ if (rr || ww || xx)
+ shadow_mem_make_New( get_current_Thread(), a, len );
+ if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+ all__sanity_check("evh__new_mem_w_perms-post");
+}
+
+static
+void evh__set_perms ( Addr a, SizeT len,
+ Bool rr, Bool ww, Bool xx ) {
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__set_perms(%p, %lu, %d,%d,%d)\n",
+ (void*)a, len, (Int)rr, (Int)ww, (Int)xx );
+ /* Hmm. What should we do here, that actually makes any sense?
+ Let's say: if neither readable nor writable, then declare it
+ NoAccess, else leave it alone. */
+ if (!(rr || ww))
+ shadow_mem_make_NoAccess( get_current_Thread(), a, len );
+ if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+ all__sanity_check("evh__set_perms-post");
+}
+
+static
+void evh__die_mem ( Addr a, SizeT len ) {
+ if (SHOW_EVENTS >= 2)
+ VG_(printf)("evh__die_mem(%p, %lu)\n", (void*)a, len );
+ shadow_mem_make_NoAccess( get_current_Thread(), a, len );
+ if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+ all__sanity_check("evh__die_mem-post");
+}
+
+static
+void evh__pre_thread_ll_create ( ThreadId parent, ThreadId child )
+{
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__pre_thread_ll_create(p=%d, c=%d)\n",
+ (Int)parent, (Int)child );
+
+ if (parent != VG_INVALID_THREADID) {
+ Thread* thr_p;
+ Thread* thr_c;
+ SegmentID segid_c;
+ Segment* seg_c;
+
+ tl_assert(is_sane_ThreadId(parent));
+ tl_assert(is_sane_ThreadId(child));
+ tl_assert(parent != child);
+
+ thr_p = map_threads_maybe_lookup( parent );
+ thr_c = map_threads_maybe_lookup( child );
+
+ tl_assert(thr_p != NULL);
+ tl_assert(thr_c == NULL);
+
+ /* Create a new thread record for the child. */
+ // FIXME: code duplication from init_data_structures
+ segid_c = alloc_SegmentID();
+ seg_c = mk_Segment( NULL/*thr*/, NULL/*prev*/, NULL/*other*/ );
+ map_segments_add( segid_c, seg_c );
+
+ /* a Thread for the new thread ... */
+ thr_c = mk_Thread( segid_c );
+ seg_c->thr = thr_c;
+
+ /* and bind it in the thread-map table */
+ map_threads[child] = thr_c;
+
+ /* Record where the parent is so we can later refer to this in
+ error messages.
+
+ On amd64-linux, this entails a nasty glibc-2.5 specific hack.
+ The stack snapshot is taken immediately after the parent has
+ returned from its sys_clone call. Unfortunately there is no
+ unwind info for the insn following "syscall" - reading the
+ glibc sources confirms this. So we ask for a snapshot to be
+ taken as if RIP was 3 bytes earlier, in a place where there
+ is unwind info. Sigh.
+ */
+ { Word first_ip_delta = 0;
+# if defined(VGP_amd64_linux)
+ first_ip_delta = -3;
+# endif
+ thr_c->created_at = VG_(record_ExeContext)(parent, first_ip_delta);
+ }
+
+ /* Now, mess with segments. */
+ if (clo_happens_before >= 1) {
+ /* Make the child's new segment depend on the parent */
+ seg_c->other = map_segments_lookup( thr_p->csegid );
+ seg_c->other_hint = 'c';
+ seg_c->vts = tick_VTS( thr_c, seg_c->other->vts );
+ tl_assert(seg_c->prev == NULL);
+ /* and start a new segment for the parent. */
+ { SegmentID new_segid = 0; /* bogus */
+ Segment* new_seg = NULL;
+ evhH__start_new_segment_for_thread( &new_segid, &new_seg,
+ thr_p );
+ tl_assert(is_sane_SegmentID(new_segid));
+ tl_assert(is_sane_Segment(new_seg));
+ new_seg->vts = tick_VTS( thr_p, new_seg->prev->vts );
+ tl_assert(new_seg->other == NULL);
+ }
+ }
+ }
+
+ if (clo_sanity_flags & SCE_THREADS)
+ all__sanity_check("evh__pre_thread_create-post");
+}
+
+static
+void evh__pre_thread_ll_exit ( ThreadId quit_tid )
+{
+ Int nHeld;
+ Thread* thr_q;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__pre_thread_ll_exit(thr=%d)\n",
+ (Int)quit_tid );
+
+ /* quit_tid has disappeared without joining to any other thread.
+ Therefore there is no synchronisation event associated with its
+ exit and so we have to pretty much treat it as if it was still
+ alive but mysteriously making no progress. That is because, if
+ we don't know when it really exited, then we can never say there
+ is a point in time when we're sure the thread really has
+ finished, and so we need to consider the possibility that it
+ lingers indefinitely and continues to interact with other
+ threads. */
+ /* However, it might have rendezvous'd with a thread that called
+ pthread_join with this one as arg, prior to this point (that's
+ how NPTL works). In which case there has already been a prior
+ sync event. So in any case, just let the thread exit. On NPTL,
+ all thread exits go through here. */
+ tl_assert(is_sane_ThreadId(quit_tid));
+ thr_q = map_threads_maybe_lookup( quit_tid );
+ tl_assert(thr_q != NULL);
+
+ /* Complain if this thread holds any locks. */
+ nHeld = HG_(cardinalityWS)( univ_lsets, thr_q->locksetA );
+ tl_assert(nHeld >= 0);
+ if (nHeld > 0) {
+ HChar buf[80];
+ VG_(sprintf)(buf, "Exiting thread still holds %d lock%s",
+ nHeld, nHeld > 1 ? "s" : "");
+ record_error_Misc( thr_q, buf );
+ }
+
+ /* About the only thing we do need to do is clear the map_threads
+ entry, in order that the Valgrind core can re-use it. */
+ map_threads_delete( quit_tid );
+
+ if (clo_sanity_flags & SCE_THREADS)
+ all__sanity_check("evh__pre_thread_ll_exit-post");
+}
+
+static
+void evh__HG_PTHREAD_JOIN_POST ( ThreadId stay_tid, Thread* quit_thr )
+{
+ Int stats_SMs, stats_SMs_scanned, stats_reExcls;
+ Addr ga;
+ SecMap* sm;
+ Thread* thr_s;
+ Thread* thr_q;
+
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__post_thread_join(stayer=%d, quitter=%p)\n",
+ (Int)stay_tid, quit_thr );
+
+ tl_assert(is_sane_ThreadId(stay_tid));
+
+ thr_s = map_threads_maybe_lookup( stay_tid );
+ thr_q = quit_thr;
+ tl_assert(thr_s != NULL);
+ tl_assert(thr_q != NULL);
+ tl_assert(thr_s != thr_q);
+
+ if (clo_happens_before >= 1) {
+ /* Start a new segment for the stayer */
+ SegmentID new_segid = 0; /* bogus */
+ Segment* new_seg = NULL;
+ evhH__start_new_segment_for_thread( &new_segid, &new_seg, thr_s );
+ tl_assert(is_sane_SegmentID(new_segid));
+ tl_assert(is_sane_Segment(new_seg));
+ /* and make it depend on the quitter's last segment */
+ tl_assert(new_seg->other == NULL);
+ new_seg->other = map_segments_lookup( thr_q->csegid );
+ new_seg->other_hint = 'j';
+ tl_assert(new_seg->thr == thr_s);
+ new_seg->vts = tickL_and_joinR_VTS( thr_s, new_seg->prev->vts,
+ new_seg->other->vts );
+ }
+
+ // FIXME: error-if: exiting thread holds any locks
+ // or should evh__pre_thread_ll_exit do that?
+
+ /* Delete thread from ShM/ShR thread sets and restore Excl states
+ where appropriate */
+
+ /* When Thread(t) joins to Thread(u):
+
+ scan all shadow memory. For each ShM/ShR thread set, replace
+ 't' in each set with 'u'. If this results in a singleton 'u',
+ change the state to Excl(u->csegid).
+
+ Optimisation: tag each SecMap with a superset of the union of
+ the thread sets in the SecMap. Then if the tag set does not
+ include 't' then the SecMap can be skipped, because there is no
+ 't' to change to anything else.
+
+ Problem is that the tag set needs to be updated often, after
+ every ShR/ShM store. (that increases the thread set of the
+ shadow value.)
+
+ --> Compromise. Tag each SecMap with a .mbHasShared bit which
+ must be set true if any ShR/ShM on the page. Set this for
+ any transitions into ShR/ShM on the page. Then skip page if
+ not set.
+
+ .mbHasShared bits are (effectively) cached in cache_shmem.
+ Hence that must be flushed before we can safely consult them.
+
+ Since we're modifying the backing store, we also need to
+ invalidate cache_shmem, so that subsequent memory references get
+ up to date shadow values.
+ */
+ shmem__flush_and_invalidate_scache();
+
+ stats_SMs = stats_SMs_scanned = stats_reExcls = 0;
+ HG_(initIterFM)( map_shmem );
+ while (HG_(nextIterFM)( map_shmem,
+ (Word*)(void*)&ga, (Word*)(void*)&sm )) {
+ SecMapIter itr;
+ UInt* w32p;
+ tl_assert(sm);
+ stats_SMs++;
+ /* Skip this SecMap if the summary bit indicates it is safe to
+ do so. */
+ if (!sm->mbHasShared)
+ continue;
+ stats_SMs_scanned++;
+ initSecMapIter( &itr );
+ while (stepSecMapIter( &w32p, &itr, sm )) {
+ Bool isM;
+ UInt wnew, wold, lset_old, tset_old, tset_new;
+ wold = *w32p;
+ if (!is_SHVAL_Sh(wold))
+ continue;
+ isM = is_SHVAL_ShM(wold);
+ lset_old = un_SHVAL_Sh_lset(wold);
+ tset_old = un_SHVAL_Sh_tset(wold);
+ /* Subst thr_q -> thr_s in the thread set. Longwindedly, if
+ thr_q is in the set, delete it and add thr_s; else leave
+ it alone. FIXME: is inefficient - make a special
+ substInWS method for this. */
+ tset_new
+ = HG_(elemWS)( univ_tsets, tset_old, (Word)thr_q )
+ ? HG_(addToWS)(
+ univ_tsets,
+ HG_(delFromWS)( univ_tsets, tset_old, (Word)thr_q ),
+ (Word)thr_s
+ )
+ : tset_old;
+
+ tl_assert(HG_(cardinalityWS)(univ_tsets, tset_new)
+ <= HG_(cardinalityWS)(univ_tsets, tset_old));
+
+ if (0) {
+ VG_(printf)("smga %p: old 0x%x new 0x%x ",
+ ga, tset_old, tset_new);
+ HG_(ppWS)( univ_tsets, tset_old );
+ VG_(printf)(" --> ");
+ HG_(ppWS)( univ_tsets, tset_new );
+ VG_(printf)("\n");
+ }
+ if (HG_(isSingletonWS)( univ_tsets, tset_new, (Word)thr_s )) {
+ /* This word returns to Excl state */
+ wnew = mk_SHVAL_Excl(thr_s->csegid);
+ stats_reExcls++;
+ } else {
+ wnew = isM ? mk_SHVAL_ShM(tset_new, lset_old)
+ : mk_SHVAL_ShR(tset_new, lset_old);
+ }
+ *w32p = wnew;
+ }
+ }
+ HG_(doneIterFM)( map_shmem );
+
+ if (SHOW_EXPENSIVE_STUFF)
+ VG_(printf)("evh__post_thread_join: %d SMs, "
+ "%d scanned, %d re-Excls\n",
+ stats_SMs, stats_SMs_scanned, stats_reExcls);
+
+ /* This holds because, at least when using NPTL as the thread
+ library, we should be notified the low level thread exit before
+ we hear of any join event on it. The low level exit
+ notification feeds through into evh__pre_thread_ll_exit,
+ which should clear the map_threads entry for it. Hence we
+ expect there to be no map_threads entry at this point. */
+ tl_assert( map_threads_maybe_reverse_lookup_SLOW(thr_q)
+ == VG_INVALID_THREADID);
+
+ if (clo_sanity_flags & SCE_THREADS)
+ all__sanity_check("evh__post_thread_join-post");
+}
+
+static
+void evh__pre_mem_read ( CorePart part, ThreadId tid, Char* s,
+ Addr a, SizeT size) {
+ if (SHOW_EVENTS >= 2
+ || (SHOW_EVENTS >= 1 && size != 1))
+ VG_(printf)("evh__pre_mem_read(ctid=%d, \"%s\", %p, %lu)\n",
+ (Int)tid, s, (void*)a, size );
+ shadow_mem_read_range( map_threads_lookup(tid), a, size);
+ if (size >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+ all__sanity_check("evh__pre_mem_read-post");
+}
+
+static
+void evh__pre_mem_read_asciiz ( CorePart part, ThreadId tid,
+ Char* s, Addr a ) {
+ Int len;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__pre_mem_asciiz(ctid=%d, \"%s\", %p)\n",
+ (Int)tid, s, (void*)a );
+ // FIXME: think of a less ugly hack
+ len = VG_(strlen)( (Char*) a );
+ shadow_mem_read_range( map_threads_lookup(tid), a, len+1 );
+ if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+ all__sanity_check("evh__pre_mem_read_asciiz-post");
+}
+
+static
+void evh__pre_mem_write ( CorePart part, ThreadId tid, Char* s,
+ Addr a, SizeT size ) {
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__pre_mem_write(ctid=%d, \"%s\", %p, %lu)\n",
+ (Int)tid, s, (void*)a, size );
+ shadow_mem_write_range( map_threads_lookup(tid), a, size);
+ if (size >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+ all__sanity_check("evh__pre_mem_write-post");
+}
+
+static
+void evh__new_mem_heap ( Addr a, SizeT len, Bool is_inited ) {
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__new_mem_heap(%p, %lu, inited=%d)\n",
+ (void*)a, len, (Int)is_inited );
+ // FIXME: this is kinda stupid
+ if (is_inited) {
+ shadow_mem_make_New(get_current_Thread(), a, len);
+ } else {
+ shadow_mem_make_New(get_current_Thread(), a, len);
+ }
+ if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+ all__sanity_check("evh__pre_mem_read-post");
+}
+
+static
+void evh__die_mem_heap ( Addr a, SizeT len ) {
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__die_mem_heap(%p, %lu)\n", (void*)a, len );
+ shadow_mem_make_NoAccess( get_current_Thread(), a, len );
+ if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+ all__sanity_check("evh__pre_mem_read-post");
+}
+
+// thread async exit?
+
+static VG_REGPARM(1)
+void evh__mem_help_read_1(Addr a) {
+ shadow_mem_read8( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_read_2(Addr a) {
+ shadow_mem_read16( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_read_4(Addr a) {
+ shadow_mem_read32( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_read_8(Addr a) {
+ shadow_mem_read64( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(2)
+void evh__mem_help_read_N(Addr a, SizeT size) {
+ shadow_mem_read_range( get_current_Thread_in_C_C(), a, size );
+}
+
+static VG_REGPARM(1)
+void evh__mem_help_write_1(Addr a) {
+ shadow_mem_write8( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_write_2(Addr a) {
+ shadow_mem_write16( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_write_4(Addr a) {
+ shadow_mem_write32( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_write_8(Addr a) {
+ shadow_mem_write64( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(2)
+void evh__mem_help_write_N(Addr a, SizeT size) {
+ shadow_mem_write_range( get_current_Thread_in_C_C(), a, size );
+}
+
+static void evh__bus_lock(void) {
+ Thread* thr;
+ if (0) VG_(printf)("evh__bus_lock()\n");
+ thr = get_current_Thread();
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+ evhH__post_thread_w_acquires_lock( thr, LK_nonRec, (Addr)&__bus_lock );
+}
+static void evh__bus_unlock(void) {
+ Thread* thr;
+ if (0) VG_(printf)("evh__bus_unlock()\n");
+ thr = get_current_Thread();
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+ evhH__pre_thread_releases_lock( thr, (Addr)&__bus_lock, False/*!isRDWR*/ );
+}
+
+
+/* -------------- events to do with mutexes -------------- */
+
+/* EXPOSITION only: by intercepting lock init events we can show the
+ user where the lock was initialised, rather than only being able to
+ show where it was first locked. Intercepting lock initialisations
+ is not necessary for the basic operation of the race checker. */
+static
+void evh__HG_PTHREAD_MUTEX_INIT_POST( ThreadId tid,
+ void* mutex, Word mbRec )
+{
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__hg_PTHREAD_MUTEX_INIT_POST(ctid=%d, mbRec=%ld, %p)\n",
+ (Int)tid, mbRec, (void*)mutex );
+ tl_assert(mbRec == 0 || mbRec == 1);
+ map_locks_lookup_or_create( mbRec ? LK_mbRec : LK_nonRec,
+ (Addr)mutex, tid );
+ if (clo_sanity_flags & SCE_LOCKS)
+ all__sanity_check("evh__hg_PTHREAD_MUTEX_INIT_POST");
+}
+
+static
+void evh__HG_PTHREAD_MUTEX_DESTROY_PRE( ThreadId tid, void* mutex )
+{
+ Thread* thr;
+ Lock* lk;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__hg_PTHREAD_MUTEX_DESTROY_PRE(ctid=%d, %p)\n",
+ (Int)tid, (void*)mutex );
+
+ thr = map_threads_maybe_lookup( tid );
+ /* cannot fail - Thread* must already exist */
+ tl_assert( is_sane_Thread(thr) );
+
+ lk = map_locks_maybe_lookup( (Addr)mutex );
+
+ if (lk == NULL || (lk->kind != LK_nonRec && lk->kind != LK_mbRec)) {
+ record_error_Misc( thr,
+ "pthread_mutex_destroy with invalid argument" );
+ }
+
+ if (lk) {
+ tl_assert( is_sane_LockN(lk) );
+ tl_assert( lk->guestaddr == (Addr)mutex );
+ if (lk->heldBy) {
+ /* Basically act like we unlocked the lock */
+ record_error_Misc( thr, "pthread_mutex_destroy of a locked mutex" );
+ /* remove lock from locksets of all owning threads */
+ remove_Lock_from_locksets_of_all_owning_Threads( lk );
+ HG_(deleteBag)( lk->heldBy );
+ lk->heldBy = NULL;
+ lk->heldW = False;
+ lk->acquired_at = NULL;
+ }
+ tl_assert( !lk->heldBy );
+ tl_assert( is_sane_LockN(lk) );
+ }
+
+ if (clo_sanity_flags & SCE_LOCKS)
+ all__sanity_check("evh__hg_PTHREAD_MUTEX_DESTROY_PRE");
+}
+
+static void evh__HG_PTHREAD_MUTEX_LOCK_PRE ( ThreadId tid,
+ void* mutex, Word isTryLock )
+{
+ /* Just check the mutex is sane; nothing else to do. */
+ // 'mutex' may be invalid - not checked by wrapper
+ Thread* thr;
+ Lock* lk;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__hg_PTHREAD_MUTEX_LOCK_PRE(ctid=%d, mutex=%p)\n",
+ (Int)tid, (void*)mutex );
+
+ tl_assert(isTryLock == 0 || isTryLock == 1);
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ lk = map_locks_maybe_lookup( (Addr)mutex );
+
+ if (lk && (lk->kind == LK_rdwr)) {
+ record_error_Misc( thr, "pthread_mutex_lock with a "
+ "pthread_rwlock_t* argument " );
+ }
+
+ if ( lk
+ && isTryLock == 0
+ && (lk->kind == LK_nonRec || lk->kind == LK_rdwr)
+ && lk->heldBy
+ && lk->heldW
+ && HG_(elemBag)( lk->heldBy, (Word)thr ) > 0 ) {
+ /* uh, it's a non-recursive lock and we already w-hold it, and
+ this is a real lock operation (not a speculative "tryLock"
+ kind of thing). Duh. Deadlock coming up; but at least
+ produce an error message. */
+ record_error_Misc( thr, "Attempt to re-lock a "
+ "non-recursive lock I already hold" );
+ }
+}
+
+static void evh__HG_PTHREAD_MUTEX_LOCK_POST ( ThreadId tid, void* mutex )
+{
+ // only called if the real library call succeeded - so mutex is sane
+ Thread* thr;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__HG_PTHREAD_MUTEX_LOCK_POST(ctid=%d, mutex=%p)\n",
+ (Int)tid, (void*)mutex );
+
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ evhH__post_thread_w_acquires_lock(
+ thr,
+ LK_mbRec, /* if not known, create new lock with this LockKind */
+ (Addr)mutex
+ );
+}
+
+static void evh__HG_PTHREAD_MUTEX_UNLOCK_PRE ( ThreadId tid, void* mutex )
+{
+ // 'mutex' may be invalid - not checked by wrapper
+ Thread* thr;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__HG_PTHREAD_MUTEX_UNLOCK_PRE(ctid=%d, mutex=%p)\n",
+ (Int)tid, (void*)mutex );
+
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ evhH__pre_thread_releases_lock( thr, (Addr)mutex, False/*!isRDWR*/ );
+}
+
+static void evh__HG_PTHREAD_MUTEX_UNLOCK_POST ( ThreadId tid, void* mutex )
+{
+ // only called if the real library call succeeded - so mutex is sane
+ Thread* thr;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__hg_PTHREAD_MUTEX_UNLOCK_POST(ctid=%d, mutex=%p)\n",
+ (Int)tid, (void*)mutex );
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ // anything we should do here?
+}
+
+
+/* --------------- events to do with CVs --------------- */
+
+/* A mapping from CV to the thread segment which has most recently
+ signalled/broadcasted on it. This makes it possible to create
+ thread segments to model happens-before events arising from CV
+ signallings/broadcasts.
+*/
+
+/* pthread_mutex_cond* -> Segment* */
+static WordFM* map_cond_to_Segment = NULL;
+
+static void map_cond_to_Segment_INIT ( void ) {
+ if (UNLIKELY(map_cond_to_Segment == NULL)) {
+ map_cond_to_Segment = HG_(newFM)( hg_zalloc, hg_free, NULL );
+ tl_assert(map_cond_to_Segment != NULL);
+ }
+}
+
+static void evh__HG_PTHREAD_COND_SIGNAL_PRE ( ThreadId tid, void* cond )
+{
+ /* 'tid' has signalled on 'cond'. Start a new segment for this
+ thread, and make a binding from 'cond' to our old segment in the
+ mapping. This is later used by other thread(s) which
+ successfully exit from a pthread_cond_wait on the same cv; then
+ they know what the signalling segment was, so a dependency edge
+ back to it can be constructed. */
+
+ Thread* thr;
+ SegmentID new_segid;
+ Segment* new_seg;
+
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__HG_PTHREAD_COND_SIGNAL_PRE(ctid=%d, cond=%p)\n",
+ (Int)tid, (void*)cond );
+
+ map_cond_to_Segment_INIT();
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ // error-if: mutex is bogus
+ // error-if: mutex is not locked
+
+ if (clo_happens_before >= 2) {
+ /* create a new segment ... */
+ new_segid = 0; /* bogus */
+ new_seg = NULL;
+ evhH__start_new_segment_for_thread( &new_segid, &new_seg, thr );
+ tl_assert( is_sane_SegmentID(new_segid) );
+ tl_assert( is_sane_Segment(new_seg) );
+ tl_assert( new_seg->thr == thr );
+ tl_assert( is_sane_Segment(new_seg->prev) );
+ tl_assert( new_seg->prev->vts );
+ new_seg->vts = tick_VTS( new_seg->thr, new_seg->prev->vts );
+
+ /* ... and add the binding. */
+ HG_(addToFM)( map_cond_to_Segment, (Word)cond,
+ (Word)(new_seg->prev) );
+ }
+}
+
+/* returns True if it reckons 'mutex' is valid and held by this
+ thread, else False */
+static Bool evh__HG_PTHREAD_COND_WAIT_PRE ( ThreadId tid,
+ void* cond, void* mutex )
+{
+ Thread* thr;
+ Lock* lk;
+ Bool lk_valid = True;
+
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__hg_PTHREAD_COND_WAIT_PRE"
+ "(ctid=%d, cond=%p, mutex=%p)\n",
+ (Int)tid, (void*)cond, (void*)mutex );
+
+ map_cond_to_Segment_INIT();
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ lk = map_locks_maybe_lookup( (Addr)mutex );
+
+ /* Check for stupid mutex arguments. There are various ways to be
+ a bozo. Only complain once, though, even if more than one thing
+ is wrong. */
+ if (lk == NULL) {
+ lk_valid = False;
+ record_error_Misc(
+ thr,
+ "pthread_cond_{timed}wait called with invalid mutex" );
+ } else {
+ tl_assert( is_sane_LockN(lk) );
+ if (lk->kind == LK_rdwr) {
+ lk_valid = False;
+ record_error_Misc(
+ thr, "pthread_cond_{timed}wait called with mutex "
+ "of type pthread_rwlock_t*" );
+ } else
+ if (lk->heldBy == NULL) {
+ lk_valid = False;
+ record_error_Misc(
+ thr, "pthread_cond_{timed}wait called with un-held mutex");
+ } else
+ if (lk->heldBy != NULL
+ && HG_(elemBag)( lk->heldBy, (Word)thr ) == 0) {
+ lk_valid = False;
+ record_error_Misc(
+ thr, "pthread_cond_{timed}wait called with mutex "
+ "held by a different thread" );
+ }
+ }
+
+ // error-if: cond is also associated with a different mutex
+
+ return lk_valid;
+}
+
+static void evh__HG_PTHREAD_COND_WAIT_POST ( ThreadId tid,
+ void* cond, void* mutex )
+{
+ /* A pthread_cond_wait(cond, mutex) completed successfully. Start
+ a new segment for this thread. Look up the signalling-segment
+ for the 'cond' in the mapping, and add a dependency edge from
+ the new segment back to it. */
+
+ Thread* thr;
+ SegmentID new_segid;
+ Segment* new_seg;
+ Segment* signalling_seg;
+ Bool found;
+
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__HG_PTHREAD_COND_WAIT_POST"
+ "(ctid=%d, cond=%p, mutex=%p)\n",
+ (Int)tid, (void*)cond, (void*)mutex );
+
+ map_cond_to_Segment_INIT();
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ // error-if: cond is also associated with a different mutex
+
+ if (clo_happens_before >= 2) {
+ /* create a new segment ... */
+ new_segid = 0; /* bogus */
+ new_seg = NULL;
+ evhH__start_new_segment_for_thread( &new_segid, &new_seg, thr );
+ tl_assert( is_sane_SegmentID(new_segid) );
+ tl_assert( is_sane_Segment(new_seg) );
+ tl_assert( new_seg->thr == thr );
+ tl_assert( is_sane_Segment(new_seg->prev) );
+ tl_assert( new_seg->other == NULL);
+
+ /* and find out which thread signalled us; then add a dependency
+ edge back to it. */
+ signalling_seg = NULL;
+ found = HG_(lookupFM)( map_cond_to_Segment,
+ NULL, (Word*)(void*)&signalling_seg,
+ (Word)cond );
+ if (found) {
+ tl_assert(is_sane_Segment(signalling_seg));
+ tl_assert(new_seg->prev);
+ tl_assert(new_seg->prev->vts);
+ new_seg->other = signalling_seg;
+ new_seg->other_hint = 's';
+ tl_assert(new_seg->other->vts);
+ new_seg->vts = tickL_and_joinR_VTS(
+ new_seg->thr,
+ new_seg->prev->vts,
+ new_seg->other->vts );
+ } else {
+ /* Hmm. How can a wait on 'cond' succeed if nobody signalled
+ it? If this happened it would surely be a bug in the
+ threads library. Or one of those fabled "spurious
+ wakeups". */
+ record_error_Misc( thr, "Bug in libpthread: pthread_cond_wait "
+ "succeeded on"
+ " without prior pthread_cond_post");
+ tl_assert(new_seg->prev->vts);
+ new_seg->vts = tick_VTS( new_seg->thr, new_seg->prev->vts );
+ }
+ }
+}
+
+
+/* -------------- events to do with rwlocks -------------- */
+
+/* EXPOSITION only */
+static
+void evh__HG_PTHREAD_RWLOCK_INIT_POST( ThreadId tid, void* rwl )
+{
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__hg_PTHREAD_RWLOCK_INIT_POST(ctid=%d, %p)\n",
+ (Int)tid, (void*)rwl );
+ map_locks_lookup_or_create( LK_rdwr, (Addr)rwl, tid );
+ if (clo_sanity_flags & SCE_LOCKS)
+ all__sanity_check("evh__hg_PTHREAD_RWLOCK_INIT_POST");
+}
+
+static
+void evh__HG_PTHREAD_RWLOCK_DESTROY_PRE( ThreadId tid, void* rwl )
+{
+ Thread* thr;
+ Lock* lk;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__hg_PTHREAD_RWLOCK_DESTROY_PRE(ctid=%d, %p)\n",
+ (Int)tid, (void*)rwl );
+
+ thr = map_threads_maybe_lookup( tid );
+ /* cannot fail - Thread* must already exist */
+ tl_assert( is_sane_Thread(thr) );
+
+ lk = map_locks_maybe_lookup( (Addr)rwl );
+
+ if (lk == NULL || lk->kind != LK_rdwr) {
+ record_error_Misc( thr,
+ "pthread_rwlock_destroy with invalid argument" );
+ }
+
+ if (lk) {
+ tl_assert( is_sane_LockN(lk) );
+ tl_assert( lk->guestaddr == (Addr)rwl );
+ if (lk->heldBy) {
+ /* Basically act like we unlocked the lock */
+ record_error_Misc( thr, "pthread_rwlock_destroy of a locked mutex" );
+ /* remove lock from locksets of all owning threads */
+ remove_Lock_from_locksets_of_all_owning_Threads( lk );
+ HG_(deleteBag)( lk->heldBy );
+ lk->heldBy = NULL;
+ lk->heldW = False;
+ }
+ tl_assert( !lk->heldBy );
+ tl_assert( is_sane_LockN(lk) );
+ }
+
+ if (clo_sanity_flags & SCE_LOCKS)
+ all__sanity_check("evh__hg_PTHREAD_RWLOCK_DESTROY_PRE");
+}
+
+static
+void evh__HG_PTHREAD_RWLOCK_LOCK_PRE ( ThreadId tid, void* rwl, Word isW )
+{
+ /* Just check the rwl is sane; nothing else to do. */
+ // 'rwl' may be invalid - not checked by wrapper
+ Thread* thr;
+ Lock* lk;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__hg_PTHREAD_RWLOCK_LOCK_PRE(ctid=%d, isW=%d, %p)\n",
+ (Int)tid, (Int)isW, (void*)rwl );
+
+ tl_assert(isW == 0 || isW == 1); /* assured us by wrapper */
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ lk = map_locks_maybe_lookup( (Addr)rwl );
+ if ( lk
+ && (lk->kind == LK_nonRec || lk->kind == LK_mbRec) ) {
+ /* Wrong kind of lock. Duh. */
+ record_error_Misc( thr, "pthread_rwlock_{rd,rw}lock with a "
+ "pthread_mutex_t* argument " );
+ }
+}
+
+static
+void evh__HG_PTHREAD_RWLOCK_LOCK_POST ( ThreadId tid, void* rwl, Word isW )
+{
+ // only called if the real library call succeeded - so mutex is sane
+ Thread* thr;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__hg_PTHREAD_RWLOCK_LOCK_POST(ctid=%d, isW=%d, %p)\n",
+ (Int)tid, (Int)isW, (void*)rwl );
+
+ tl_assert(isW == 0 || isW == 1); /* assured us by wrapper */
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ (isW ? evhH__post_thread_w_acquires_lock
+ : evhH__post_thread_r_acquires_lock)(
+ thr,
+ LK_rdwr, /* if not known, create new lock with this LockKind */
+ (Addr)rwl
+ );
+}
+
+static void evh__HG_PTHREAD_RWLOCK_UNLOCK_PRE ( ThreadId tid, void* rwl )
+{
+ // 'rwl' may be invalid - not checked by wrapper
+ Thread* thr;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__HG_PTHREAD_RWLOCK_UNLOCK_PRE(ctid=%d, rwl=%p)\n",
+ (Int)tid, (void*)rwl );
+
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ evhH__pre_thread_releases_lock( thr, (Addr)rwl, True/*isRDWR*/ );
+}
+
+static void evh__HG_PTHREAD_RWLOCK_UNLOCK_POST ( ThreadId tid, void* rwl )
+{
+ // only called if the real library call succeeded - so mutex is sane
+ Thread* thr;
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__hg_PTHREAD_RWLOCK_UNLOCK_POST(ctid=%d, rwl=%p)\n",
+ (Int)tid, (void*)rwl );
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ // anything we should do here?
+}
+
+
+/* --------------- events to do with semaphores --------------- */
+
+/* This is similar but not identical the handling for condition
+ variables. */
+
+/* For each semaphore, we maintain a stack of Segments. When a 'post'
+ operation is done on a semaphore (unlocking, essentially), a new
+ segment is created for the posting thread, and the old segment is
+ pushed on the semaphore's stack.
+
+ Later, when a (probably different) thread completes 'wait' on the
+ semaphore, we pop a Segment off the semaphore's stack (which should
+ be nonempty). We start a new segment for the thread and make it
+ also depend on the just-popped segment. This mechanism creates
+ dependencies between posters and waiters of the semaphore.
+
+ It may not be necessary to use a stack - perhaps a bag of Segments
+ would do. But we do need to keep track of how many unused-up posts
+ have happened for the semaphore.
+
+ Imagine T1 and T2 both post once on a semphore S, and T3 waits
+ twice on S. T3 cannot complete its waits without both T1 and T2
+ posting. The above mechanism will ensure that T3 acquires
+ dependencies on both T1 and T2.
+*/
+
+/* sem_t* -> XArray* Segment* */
+static WordFM* map_sem_to_Segment_stack = NULL;
+
+static void map_sem_to_Segment_stack_INIT ( void ) {
+ if (map_sem_to_Segment_stack == NULL) {
+ map_sem_to_Segment_stack = HG_(newFM)( hg_zalloc, hg_free, NULL );
+ tl_assert(map_sem_to_Segment_stack != NULL);
+ }
+}
+
+static void push_Segment_for_sem ( void* sem, Segment* seg ) {
+ XArray* xa;
+ tl_assert(seg);
+ map_sem_to_Segment_stack_INIT();
+ if (HG_(lookupFM)( map_sem_to_Segment_stack,
+ NULL, (Word*)(void*)&xa, (Word)sem )) {
+ tl_assert(xa);
+ VG_(addToXA)( xa, &seg );
+ } else {
+ xa = VG_(newXA)( hg_zalloc, hg_free, sizeof(Segment*) );
+ VG_(addToXA)( xa, &seg );
+ HG_(addToFM)( map_sem_to_Segment_stack, (Word)sem, (Word)xa );
+ }
+}
+
+static Segment* mb_pop_Segment_for_sem ( void* sem ) {
+ XArray* xa;
+ Segment* seg;
+ map_sem_to_Segment_stack_INIT();
+ if (HG_(lookupFM)( map_sem_to_Segment_stack,
+ NULL, (Word*)(void*)&xa, (Word)sem )) {
+ /* xa is the stack for this semaphore. */
+ Word sz = VG_(sizeXA)( xa );
+ tl_assert(sz >= 0);
+ if (sz == 0)
+ return NULL; /* odd, the stack is empty */
+ seg = *(Segment**)VG_(indexXA)( xa, sz-1 );
+ tl_assert(seg);
+ VG_(dropTailXA)( xa, 1 );
+ return seg;
+ } else {
+ /* hmm, that's odd. No stack for this semaphore. */
+ return NULL;
+ }
+}
+
+static void evh__HG_POSIX_SEM_ZAPSTACK ( ThreadId tid, void* sem )
+{
+ Segment* seg;
+
+ /* Empty out the semaphore's segment stack. Occurs at
+ sem_init and sem_destroy time. */
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__HG_POSIX_SEM_ZAPSTACK(ctid=%d, sem=%p)\n",
+ (Int)tid, (void*)sem );
+
+ /* This is stupid, but at least it's easy. */
+ do {
+ seg = mb_pop_Segment_for_sem( sem );
+ } while (seg);
+
+ tl_assert(!seg);
+}
+
+static void evh__HG_POSIX_SEMPOST_PRE ( ThreadId tid, void* sem )
+{
+ /* 'tid' has posted on 'sem'. Start a new segment for this thread,
+ and push the old segment on a stack of segments associated with
+ 'sem'. This is later used by other thread(s) which successfully
+ exit from a sem_wait on the same sem; then they know what the
+ posting segment was, so a dependency edge back to it can be
+ constructed. */
+
+ Thread* thr;
+ SegmentID new_segid;
+ Segment* new_seg;
+
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__HG_POSIX_SEMPOST_PRE(ctid=%d, sem=%p)\n",
+ (Int)tid, (void*)sem );
+
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ // error-if: sem is bogus
+
+ if (clo_happens_before >= 2) {
+ /* create a new segment ... */
+ new_segid = 0; /* bogus */
+ new_seg = NULL;
+ evhH__start_new_segment_for_thread( &new_segid, &new_seg, thr );
+ tl_assert( is_sane_SegmentID(new_segid) );
+ tl_assert( is_sane_Segment(new_seg) );
+ tl_assert( new_seg->thr == thr );
+ tl_assert( is_sane_Segment(new_seg->prev) );
+ tl_assert( new_seg->prev->vts );
+ new_seg->vts = tick_VTS( new_seg->thr, new_seg->prev->vts );
+
+ /* ... and add the binding. */
+ push_Segment_for_sem( sem, new_seg->prev );
+ }
+}
+
+static void evh__HG_POSIX_SEMWAIT_POST ( ThreadId tid, void* sem )
+{
+ /* A sem_wait(sem) completed successfully. Start a new segment for
+ this thread. Pop the posting-segment for the 'sem' in the
+ mapping, and add a dependency edge from the new segment back to
+ it. */
+
+ Thread* thr;
+ SegmentID new_segid;
+ Segment* new_seg;
+ Segment* posting_seg;
+
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__HG_POSIX_SEMWAIT_POST(ctid=%d, sem=%p)\n",
+ (Int)tid, (void*)sem );
+
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ // error-if: sem is bogus
+
+ if (clo_happens_before >= 2) {
+ /* create a new segment ... */
+ new_segid = 0; /* bogus */
+ new_seg = NULL;
+ evhH__start_new_segment_for_thread( &new_segid, &new_seg, thr );
+ tl_assert( is_sane_SegmentID(new_segid) );
+ tl_assert( is_sane_Segment(new_seg) );
+ tl_assert( new_seg->thr == thr );
+ tl_assert( is_sane_Segment(new_seg->prev) );
+ tl_assert( new_seg->other == NULL);
+
+ /* and find out which thread posted last on sem; then add a
+ dependency edge back to it. */
+ posting_seg = mb_pop_Segment_for_sem( sem );
+ if (posting_seg) {
+ tl_assert(is_sane_Segment(posting_seg));
+ tl_assert(new_seg->prev);
+ tl_assert(new_seg->prev->vts);
+ new_seg->other = posting_seg;
+ new_seg->other_hint = 'S';
+ tl_assert(new_seg->other->vts);
+ new_seg->vts = tickL_and_joinR_VTS(
+ new_seg->thr,
+ new_seg->prev->vts,
+ new_seg->other->vts );
+ } else {
+ /* Hmm. How can a wait on 'sem' succeed if nobody posted to
+ it? If this happened it would surely be a bug in the
+ threads library. */
+ record_error_Misc( thr, "Bug in libpthread: sem_wait succeeded on"
+ " semaphore without prior sem_post");
+ tl_assert(new_seg->prev->vts);
+ new_seg->vts = tick_VTS( new_seg->thr, new_seg->prev->vts );
+ }
+ }
+}
+
+
+/*--------------------------------------------------------------*/
+/*--- Lock acquisition order monitoring ---*/
+/*--------------------------------------------------------------*/
+
+/* FIXME: here are some optimisations still to do in
+ laog__pre_thread_acquires_lock.
+
+ The graph is structured so that if L1 --*--> L2 then L1 must be
+ acquired before L2.
+
+ The common case is that some thread T holds (eg) L1 L2 and L3 and
+ is repeatedly acquiring and releasing Ln, and there is no ordering
+ error in what it is doing. Hence it repeatly:
+
+ (1) searches laog to see if Ln --*--> {L1,L2,L3}, which always
+ produces the answer No (because there is no error).
+
+ (2) adds edges {L1,L2,L3} --> Ln to laog, which are already present
+ (because they already got added the first time T acquired Ln).
+
+ Hence cache these two events:
+
+ (1) Cache result of the query from last time. Invalidate the cache
+ any time any edges are added to or deleted from laog.
+
+ (2) Cache these add-edge requests and ignore them if said edges
+ have already been added to laog. Invalidate the cache any time
+ any edges are deleted from laog.
+*/
+
+typedef
+ struct {
+ WordSetID inns; /* in univ_laog */
+ WordSetID outs; /* in univ_laog */
+ }
+ LAOGLinks;
+
+/* lock order acquisition graph */
+static WordFM* laog = NULL; /* WordFM Lock* LAOGLinks* */
+
+/* EXPOSITION ONLY: for each edge in 'laog', record the two places
+ where that edge was created, so that we can show the user later if
+ we need to. */
+typedef
+ struct {
+ Addr src_ga; /* Lock guest addresses for */
+ Addr dst_ga; /* src/dst of the edge */
+ ExeContext* src_ec; /* And corresponding places where that */
+ ExeContext* dst_ec; /* ordering was established */
+ }
+ LAOGLinkExposition;
+
+static Word cmp_LAOGLinkExposition ( Word llx1W, Word llx2W ) {
+ /* Compare LAOGLinkExposition*s by (src_ga,dst_ga) field pair. */
+ LAOGLinkExposition* llx1 = (LAOGLinkExposition*)llx1W;
+ LAOGLinkExposition* llx2 = (LAOGLinkExposition*)llx2W;
+ if (llx1->src_ga < llx2->src_ga) return -1;
+ if (llx1->src_ga > llx2->src_ga) return 1;
+ if (llx1->dst_ga < llx2->dst_ga) return -1;
+ if (llx1->dst_ga > llx2->dst_ga) return 1;
+ return 0;
+}
+
+static WordFM* laog_exposition = NULL; /* WordFM LAOGLinkExposition* NULL */
+/* end EXPOSITION ONLY */
+
+
+static void laog__show ( Char* who ) {
+ Word i, ws_size;
+ Word* ws_words;
+ Lock* me;
+ LAOGLinks* links;
+ VG_(printf)("laog (requested by %s) {\n", who);
+ HG_(initIterFM)( laog );
+ me = NULL;
+ links = NULL;
+ while (HG_(nextIterFM)( laog, (Word*)(void*)&me,
+ (Word*)(void*)&links )) {
+ tl_assert(me);
+ tl_assert(links);
+ VG_(printf)(" node %p:\n", me);
+ HG_(getPayloadWS)( &ws_words, &ws_size, univ_laog, links->inns );
+ for (i = 0; i < ws_size; i++)
+ VG_(printf)(" inn %p\n", ws_words[i] );
+ HG_(getPayloadWS)( &ws_words, &ws_size, univ_laog, links->outs );
+ for (i = 0; i < ws_size; i++)
+ VG_(printf)(" out %p\n", ws_words[i] );
+ me = NULL;
+ links = NULL;
+ }
+ HG_(doneIterFM)( laog );
+ VG_(printf)("}\n");
+}
+
+__attribute__((noinline))
+static void laog__add_edge ( Lock* src, Lock* dst ) {
+ Word keyW;
+ LAOGLinks* links;
+ Bool presentF, presentR;
+ if (0) VG_(printf)("laog__add_edge %p %p\n", src, dst);
+
+ /* Take the opportunity to sanity check the graph. Record in
+ presentF if there is already a src->dst mapping in this node's
+ forwards links, and presentR if there is already a src->dst
+ mapping in this node's backwards links. They should agree!
+ Also, we need to know whether the edge was already present so as
+ to decide whether or not to update the link details mapping. We
+ can compute presentF and presentR essentially for free, so may
+ as well do this always. */
+ presentF = presentR = False;
+
+ /* Update the out edges for src */
+ keyW = 0;
+ links = NULL;
+ if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)src )) {
+ WordSetID outs_new;
+ tl_assert(links);
+ tl_assert(keyW == (Word)src);
+ outs_new = HG_(addToWS)( univ_laog, links->outs, (Word)dst );
+ presentF = outs_new == links->outs;
+ links->outs = outs_new;
+ } else {
+ links = hg_zalloc(sizeof(LAOGLinks));
+ links->inns = HG_(emptyWS)( univ_laog );
+ links->outs = HG_(singletonWS)( univ_laog, (Word)dst );
+ HG_(addToFM)( laog, (Word)src, (Word)links );
+ }
+ /* Update the in edges for dst */
+ keyW = 0;
+ links = NULL;
+ if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)dst )) {
+ WordSetID inns_new;
+ tl_assert(links);
+ tl_assert(keyW == (Word)dst);
+ inns_new = HG_(addToWS)( univ_laog, links->inns, (Word)src );
+ presentR = inns_new == links->inns;
+ links->inns = inns_new;
+ } else {
+ links = hg_zalloc(sizeof(LAOGLinks));
+ links->inns = HG_(singletonWS)( univ_laog, (Word)src );
+ links->outs = HG_(emptyWS)( univ_laog );
+ HG_(addToFM)( laog, (Word)dst, (Word)links );
+ }
+
+ tl_assert( (presentF && presentR) || (!presentF && !presentR) );
+
+ if (!presentF && src->acquired_at && dst->acquired_at) {
+ LAOGLinkExposition expo;
+ /* If this edge is entering the graph, and we have acquired_at
+ information for both src and dst, record those acquisition
+ points. Hence, if there is later a violation of this
+ ordering, we can show the user the two places in which the
+ required src-dst ordering was previously established. */
+ if (0) VG_(printf)("acquire edge %p %p\n",
+ src->guestaddr, dst->guestaddr);
+ expo.src_ga = src->guestaddr;
+ expo.dst_ga = dst->guestaddr;
+ expo.src_ec = NULL;
+ expo.dst_ec = NULL;
+ tl_assert(laog_exposition);
+ if (HG_(lookupFM)( laog_exposition, NULL, NULL, (Word)&expo )) {
+ /* we already have it; do nothing */
+ } else {
+ LAOGLinkExposition* expo2 = hg_zalloc(sizeof(LAOGLinkExposition));
+ expo2->src_ga = src->guestaddr;
+ expo2->dst_ga = dst->guestaddr;
+ expo2->src_ec = src->acquired_at;
+ expo2->dst_ec = dst->acquired_at;
+ HG_(addToFM)( laog_exposition, (Word)expo2, (Word)NULL );
+ }
+ }
+}
+
+__attribute__((noinline))
+static void laog__del_edge ( Lock* src, Lock* dst ) {
+ Word keyW;
+ LAOGLinks* links;
+ if (0) VG_(printf)("laog__del_edge %p %p\n", src, dst);
+ /* Update the out edges for src */
+ keyW = 0;
+ links = NULL;
+ if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)src )) {
+ tl_assert(links);
+ tl_assert(keyW == (Word)src);
+ links->outs = HG_(delFromWS)( univ_laog, links->outs, (Word)dst );
+ }
+ /* Update the in edges for dst */
+ keyW = 0;
+ links = NULL;
+ if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)dst )) {
+ tl_assert(links);
+ tl_assert(keyW == (Word)dst);
+ links->inns = HG_(delFromWS)( univ_laog, links->inns, (Word)src );
+ }
+}
+
+__attribute__((noinline))
+static WordSetID /* in univ_laog */ laog__succs ( Lock* lk ) {
+ Word keyW;
+ LAOGLinks* links;
+ keyW = 0;
+ links = NULL;
+ if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)lk )) {
+ tl_assert(links);
+ tl_assert(keyW == (Word)lk);
+ return links->outs;
+ } else {
+ return HG_(emptyWS)( univ_laog );
+ }
+}
+
+__attribute__((noinline))
+static WordSetID /* in univ_laog */ laog__preds ( Lock* lk ) {
+ Word keyW;
+ LAOGLinks* links;
+ keyW = 0;
+ links = NULL;
+ if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)lk )) {
+ tl_assert(links);
+ tl_assert(keyW == (Word)lk);
+ return links->inns;
+ } else {
+ return HG_(emptyWS)( univ_laog );
+ }
+}
+
+__attribute__((noinline))
+static void laog__sanity_check ( Char* who ) {
+ Word i, ws_size;
+ Word* ws_words;
+ Lock* me;
+ LAOGLinks* links;
+ if ( !laog )
+ return; /* nothing much we can do */
+ HG_(initIterFM)( laog );
+ me = NULL;
+ links = NULL;
+ if (0) VG_(printf)("laog sanity check\n");
+ while (HG_(nextIterFM)( laog, (Word*)(void*)&me,
+ (Word*)(void*)&links )) {
+ tl_assert(me);
+ tl_assert(links);
+ HG_(getPayloadWS)( &ws_words, &ws_size, univ_laog, links->inns );
+ for (i = 0; i < ws_size; i++) {
+ if ( ! HG_(elemWS)( univ_laog,
+ laog__succs( (Lock*)ws_words[i] ),
+ (Word)me ))
+ goto bad;
+ }
+ HG_(getPayloadWS)( &ws_words, &ws_size, univ_laog, links->outs );
+ for (i = 0; i < ws_size; i++) {
+ if ( ! HG_(elemWS)( univ_laog,
+ laog__preds( (Lock*)ws_words[i] ),
+ (Word)me ))
+ goto bad;
+ }
+ me = NULL;
+ links = NULL;
+ }
+ HG_(doneIterFM)( laog );
+ return;
+
+ bad:
+ VG_(printf)("laog__sanity_check(%s) FAILED\n", who);
+ laog__show(who);
+ tl_assert(0);
+}
+
+/* If there is a path in laog from 'src' to any of the elements in
+ 'dst', return an arbitrarily chosen element of 'dst' reachable from
+ 'src'. If no path exist from 'src' to any element in 'dst', return
+ NULL. */
+__attribute__((noinline))
+static
+Lock* laog__do_dfs_from_to ( Lock* src, WordSetID dsts /* univ_lsets */ )
+{
+ Lock* ret;
+ Word i, ssz;
+ XArray* stack; /* of Lock* */
+ WordFM* visited; /* Lock* -> void, iow, Set(Lock*) */
+ Lock* here;
+ WordSetID succs;
+ Word succs_size;
+ Word* succs_words;
+ //laog__sanity_check();
+
+ /* If the destination set is empty, we can never get there from
+ 'src' :-), so don't bother to try */
+ if (HG_(isEmptyWS)( univ_lsets, dsts ))
+ return NULL;
+
+ ret = NULL;
+ stack = VG_(newXA)( hg_zalloc, hg_free, sizeof(Lock*) );
+ visited = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxedcmp*/ );
+
+ (void) VG_(addToXA)( stack, &src );
+
+ while (True) {
+
+ ssz = VG_(sizeXA)( stack );
+
+ if (ssz == 0) { ret = NULL; break; }
+
+ here = *(Lock**) VG_(indexXA)( stack, ssz-1 );
+ VG_(dropTailXA)( stack, 1 );
+
+ if (HG_(elemWS)( univ_lsets, dsts, (Word)here )) { ret = here; break; }
+
+ if (HG_(lookupFM)( visited, NULL, NULL, (Word)here ))
+ continue;
+
+ HG_(addToFM)( visited, (Word)here, 0 );
+
+ succs = laog__succs( here );
+ HG_(getPayloadWS)( &succs_words, &succs_size, univ_laog, succs );
+ for (i = 0; i < succs_size; i++)
+ (void) VG_(addToXA)( stack, &succs_words[i] );
+ }
+
+ HG_(deleteFM)( visited, NULL, NULL );
+ VG_(deleteXA)( stack );
+ return ret;
+}
+
+
+/* Thread 'thr' is acquiring 'lk'. Check for inconsistent ordering
+ between 'lk' and the locks already held by 'thr' and issue a
+ complaint if so. Also, update the ordering graph appropriately.
+*/
+__attribute__((noinline))
+static void laog__pre_thread_acquires_lock (
+ Thread* thr, /* NB: BEFORE lock is added */
+ Lock* lk
+ )
+{
+ Word* ls_words;
+ Word ls_size, i;
+ Lock* other;
+
+ /* It may be that 'thr' already holds 'lk' and is recursively
+ relocking in. In this case we just ignore the call. */
+ /* NB: univ_lsets really is correct here */
+ if (HG_(elemWS)( univ_lsets, thr->locksetA, (Word)lk ))
+ return;
+
+ if (!laog)
+ laog = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxedcmp*/ );
+ if (!laog_exposition)
+ laog_exposition = HG_(newFM)( hg_zalloc, hg_free,
+ cmp_LAOGLinkExposition );
+
+ /* First, the check. Complain if there is any path in laog from lk
+ to any of the locks already held by thr, since if any such path
+ existed, it would mean that previously lk was acquired before
+ (rather than after, as we are doing here) at least one of those
+ locks.
+ */
+ other = laog__do_dfs_from_to(lk, thr->locksetA);
+ if (other) {
+ LAOGLinkExposition key, *found;
+ /* So we managed to find a path lk --*--> other in the graph,
+ which implies that 'lk' should have been acquired before
+ 'other' but is in fact being acquired afterwards. We present
+ the lk/other arguments to record_error_LockOrder in the order
+ in which they should have been acquired. */
+ /* Go look in the laog_exposition mapping, to find the allocation
+ points for this edge, so we can show the user. */
+ key.src_ga = lk->guestaddr;
+ key.dst_ga = other->guestaddr;
+ key.src_ec = NULL;
+ key.dst_ec = NULL;
+ found = NULL;
+ if (HG_(lookupFM)( laog_exposition,
+ (Word*)(void*)&found, NULL, (Word)&key )) {
+ tl_assert(found != &key);
+ tl_assert(found->src_ga == key.src_ga);
+ tl_assert(found->dst_ga == key.dst_ga);
+ tl_assert(found->src_ec);
+ tl_assert(found->dst_ec);
+ record_error_LockOrder( thr,
+ lk->guestaddr, other->guestaddr,
+ found->src_ec, found->dst_ec );
+ } else {
+ /* Hmm. This can't happen (can it?) */
+ record_error_LockOrder( thr,
+ lk->guestaddr, other->guestaddr,
+ NULL, NULL );
+ }
+ }
+
+ /* Second, add to laog the pairs
+ (old, lk) | old <- locks already held by thr
+ Since both old and lk are currently held by thr, their acquired_at
+ fields must be non-NULL.
+ */
+ tl_assert(lk->acquired_at);
+ HG_(getPayloadWS)( &ls_words, &ls_size, univ_lsets, thr->locksetA );
+ for (i = 0; i < ls_size; i++) {
+ Lock* old = (Lock*)ls_words[i];
+ tl_assert(old->acquired_at);
+ laog__add_edge( old, lk );
+ }
+
+ /* Why "except_Locks" ? We're here because a lock is being
+ acquired by a thread, and we're in an inconsistent state here.
+ See the call points in evhH__post_thread_{r,w}_acquires_lock.
+ When called in this inconsistent state, locks__sanity_check duly
+ barfs. */
+ if (clo_sanity_flags & SCE_LAOG)
+ all_except_Locks__sanity_check("laog__pre_thread_acquires_lock-post");
+}
+
+
+/* Delete from 'laog' any pair mentioning a lock in locksToDelete */
+
+__attribute__((noinline))
+static void laog__handle_one_lock_deletion ( Lock* lk )
+{
+ WordSetID preds, succs;
+ Word preds_size, succs_size, i, j;
+ Word *preds_words, *succs_words;
+
+ preds = laog__preds( lk );
+ succs = laog__succs( lk );
+
+ HG_(getPayloadWS)( &preds_words, &preds_size, univ_laog, preds );
+ for (i = 0; i < preds_size; i++)
+ laog__del_edge( (Lock*)preds_words[i], lk );
+
+ HG_(getPayloadWS)( &succs_words, &succs_size, univ_laog, succs );
+ for (j = 0; j < succs_size; j++)
+ laog__del_edge( lk, (Lock*)succs_words[j] );
+
+ for (i = 0; i < preds_size; i++) {
+ for (j = 0; j < succs_size; j++) {
+ if (preds_words[i] != succs_words[j]) {
+ /* This can pass unlocked locks to laog__add_edge, since
+ we're deleting stuff. So their acquired_at fields may
+ be NULL. */
+ laog__add_edge( (Lock*)preds_words[i], (Lock*)succs_words[j] );
+ }
+ }
+ }
+}
+
+__attribute__((noinline))
+static void laog__handle_lock_deletions (
+ WordSetID /* in univ_laog */ locksToDelete
+ )
+{
+ Word i, ws_size;
+ Word* ws_words;
+
+ if (!laog)
+ laog = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxedcmp*/ );
+ if (!laog_exposition)
+ laog_exposition = HG_(newFM)( hg_zalloc, hg_free,
+ cmp_LAOGLinkExposition );
+
+ HG_(getPayloadWS)( &ws_words, &ws_size, univ_lsets, locksToDelete );
+ for (i = 0; i < ws_size; i++)
+ laog__handle_one_lock_deletion( (Lock*)ws_words[i] );
+
+ if (clo_sanity_flags & SCE_LAOG)
+ all__sanity_check("laog__handle_lock_deletions-post");
+}
+
+
+/*--------------------------------------------------------------*/
+/*--- Malloc/free replacements ---*/
+/*--------------------------------------------------------------*/
+
+typedef
+ struct {
+ void* next; /* required by m_hashtable */
+ Addr payload; /* ptr to actual block */
+ SizeT szB; /* size requested */
+ ExeContext* where; /* where it was allocated */
+ Thread* thr; /* allocating thread */
+ }
+ MallocMeta;
+
+/* A hash table of MallocMetas, used to track malloc'd blocks
+ (obviously). */
+static VgHashTable hg_mallocmeta_table = NULL;
+
+
+static MallocMeta* new_MallocMeta ( void ) {
+ MallocMeta* md = hg_zalloc( sizeof(MallocMeta) );
+ tl_assert(md);
+ return md;
+}
+static void delete_MallocMeta ( MallocMeta* md ) {
+ hg_free(md);
+}
+
+
+/* Allocate a client block and set up the metadata for it. */
+
+static
+void* handle_alloc ( ThreadId tid,
+ SizeT szB, SizeT alignB, Bool is_zeroed )
+{
+ Addr p;
+ MallocMeta* md;
+
+ tl_assert( ((SSizeT)szB) >= 0 );
+ p = (Addr)VG_(cli_malloc)(alignB, szB);
+ if (!p) {
+ return NULL;
+ }
+ if (is_zeroed)
+ VG_(memset)((void*)p, 0, szB);
+
+ /* Note that map_threads_lookup must succeed (cannot assert), since
+ memory can only be allocated by currently alive threads, hence
+ they must have an entry in map_threads. */
+ md = new_MallocMeta();
+ md->payload = p;
+ md->szB = szB;
+ md->where = VG_(record_ExeContext)( tid, 0 );
+ md->thr = map_threads_lookup( tid );
+
+ VG_(HT_add_node)( hg_mallocmeta_table, (VgHashNode*)md );
+
+ /* Tell the lower level memory wranglers. */
+ evh__new_mem_heap( p, szB, is_zeroed );
+
+ return (void*)p;
+}
+
+/* Re the checks for less-than-zero (also in hg_cli__realloc below):
+ Cast to a signed type to catch any unexpectedly negative args.
+ We're assuming here that the size asked for is not greater than
+ 2^31 bytes (for 32-bit platforms) or 2^63 bytes (for 64-bit
+ platforms). */
+static void* hg_cli__malloc ( ThreadId tid, SizeT n ) {
+ if (((SSizeT)n) < 0) return NULL;
+ return handle_alloc ( tid, n, VG_(clo_alignment),
+ /*is_zeroed*/False );
+}
+static void* hg_cli____builtin_new ( ThreadId tid, SizeT n ) {
+ if (((SSizeT)n) < 0) return NULL;
+ return handle_alloc ( tid, n, VG_(clo_alignment),
+ /*is_zeroed*/False );
+}
+static void* hg_cli____builtin_vec_new ( ThreadId tid, SizeT n ) {
+ if (((SSizeT)n) < 0) return NULL;
+ return handle_alloc ( tid, n, VG_(clo_alignment),
+ /*is_zeroed*/False );
+}
+static void* hg_cli__memalign ( ThreadId tid, SizeT align, SizeT n ) {
+ if (((SSizeT)n) < 0) return NULL;
+ return handle_alloc ( tid, n, align,
+ /*is_zeroed*/False );
+}
+static void* hg_cli__calloc ( ThreadId tid, SizeT nmemb, SizeT size1 ) {
+ if ( ((SSizeT)nmemb) < 0 || ((SSizeT)size1) < 0 ) return NULL;
+ return handle_alloc ( tid, nmemb*size1, VG_(clo_alignment),
+ /*is_zeroed*/True );
+}
+
+
+/* Free a client block, including getting rid of the relevant
+ metadata. */
+
+static void handle_free ( ThreadId tid, void* p )
+{
+ MallocMeta *md, *old_md;
+ SizeT szB;
+
+ /* First see if we can find the metadata for 'p'. */
+ md = (MallocMeta*) VG_(HT_lookup)( hg_mallocmeta_table, (UWord)p );
+ if (!md)
+ return; /* apparently freeing a bogus address. Oh well. */
+
+ tl_assert(md->payload == (Addr)p);
+ szB = md->szB;
+
+ /* Nuke the metadata block */
+ old_md = (MallocMeta*)
+ VG_(HT_remove)( hg_mallocmeta_table, (UWord)p );
+ tl_assert(old_md); /* it must be present - we just found it */
+ tl_assert(old_md == md);
+ tl_assert(old_md->payload == (Addr)p);
+
+ VG_(cli_free)((void*)old_md->payload);
+ delete_MallocMeta(old_md);
+
+ /* Tell the lower level memory wranglers. */
+ evh__die_mem_heap( (Addr)p, szB );
+}
+
+static void hg_cli__free ( ThreadId tid, void* p ) {
+ handle_free(tid, p);
+}
+static void hg_cli____builtin_delete ( ThreadId tid, void* p ) {
+ handle_free(tid, p);
+}
+static void hg_cli____builtin_vec_delete ( ThreadId tid, void* p ) {
+ handle_free(tid, p);
+}
+
+
+static void* hg_cli__realloc ( ThreadId tid, void* payloadV, SizeT new_size )
+{
+ MallocMeta *md, *md_new, *md_tmp;
+ SizeT i;
+
+ Addr payload = (Addr)payloadV;
+
+ if (((SSizeT)new_size) < 0) return NULL;
+
+ md = (MallocMeta*) VG_(HT_lookup)( hg_mallocmeta_table, (UWord)payload );
+ if (!md)
+ return NULL; /* apparently realloc-ing a bogus address. Oh well. */
+
+ tl_assert(md->payload == payload);
+
+ if (md->szB == new_size) {
+ /* size unchanged */
+ md->where = VG_(record_ExeContext)(tid, 0);
+ return payloadV;
+ }
+
+ if (md->szB > new_size) {
+ /* new size is smaller */
+ md->szB = new_size;
+ md->where = VG_(record_ExeContext)(tid, 0);
+ evh__die_mem_heap( md->payload + new_size, md->szB - new_size );
+ return payloadV;
+ }
+
+ /* else */ {
+ /* new size is bigger */
+ Addr p_new = (Addr)VG_(cli_malloc)(VG_(clo_alignment), new_size);
+
+ /* First half kept and copied, second half new */
+ // FIXME: shouldn't we use a copier which implements the
+ // memory state machine?
+ shadow_mem_copy_range( payload, p_new, md->szB );
+ evh__new_mem_heap ( p_new + md->szB, new_size - md->szB,
+ /*inited*/False );
+ /* FIXME: can anything funny happen here? specifically, if the
+ old range contained a lock, then die_mem_heap will complain.
+ Is that the correct behaviour? Not sure. */
+ evh__die_mem_heap( payload, md->szB );
+
+ /* Copy from old to new */
+ for (i = 0; i < md->szB; i++)
+ ((UChar*)p_new)[i] = ((UChar*)payload)[i];
+
+ /* Because the metadata hash table is index by payload address,
+ we have to get rid of the old hash table entry and make a new
+ one. We can't just modify the existing metadata in place,
+ because then it would (almost certainly) be in the wrong hash
+ chain. */
+ md_new = new_MallocMeta();
+ *md_new = *md;
+
+ md_tmp = VG_(HT_remove)( hg_mallocmeta_table, payload );
+ tl_assert(md_tmp);
+ tl_assert(md_tmp == md);
+
+ VG_(cli_free)((void*)md->payload);
+ delete_MallocMeta(md);
+
+ /* Update fields */
+ md_new->where = VG_(record_ExeContext)( tid, 0 );
+ md_new->szB = new_size;
+ md_new->payload = p_new;
+ md_new->thr = map_threads_lookup( tid );
+
+ /* and add */
+ VG_(HT_add_node)( hg_mallocmeta_table, (VgHashNode*)md_new );
+
+ return (void*)p_new;
+ }
+}
+
+
+/*--------------------------------------------------------------*/
+/*--- Instrumentation ---*/
+/*--------------------------------------------------------------*/
+
+static void instrument_mem_access ( IRSB* bbOut,
+ IRExpr* addr,
+ Int szB,
+ Bool isStore,
+ Int hWordTy_szB )
+{
+ IRType tyAddr = Ity_INVALID;
+ HChar* hName = NULL;
+ void* hAddr = NULL;
+ Int regparms = 0;
+ IRExpr** argv = NULL;
+ IRDirty* di = NULL;
+
+ tl_assert(isIRAtom(addr));
+ tl_assert(hWordTy_szB == 4 || hWordTy_szB == 8);
+
+ tyAddr = typeOfIRExpr( bbOut->tyenv, addr );
+ tl_assert(tyAddr == Ity_I32 || tyAddr == Ity_I64);
+
+ /* So the effective address is in 'addr' now. */
+ regparms = 1; // unless stated otherwise
+ if (isStore) {
+ switch (szB) {
+ case 1:
+ hName = "evh__mem_help_write_1";
+ hAddr = &evh__mem_help_write_1;
+ argv = mkIRExprVec_1( addr );
+ break;
+ case 2:
+ hName = "evh__mem_help_write_2";
+ hAddr = &evh__mem_help_write_2;
+ argv = mkIRExprVec_1( addr );
+ break;
+ case 4:
+ hName = "evh__mem_help_write_4";
+ hAddr = &evh__mem_help_write_4;
+ argv = mkIRExprVec_1( addr );
+ break;
+ case 8:
+ hName = "evh__mem_help_write_8";
+ hAddr = &evh__mem_help_write_8;
+ argv = mkIRExprVec_1( addr );
+ break;
+ default:
+ tl_assert(szB > 8 && szB <= 512); /* stay sane */
+ regparms = 2;
+ hName = "evh__mem_help_write_N";
+ hAddr = &evh__mem_help_write_N;
+ argv = mkIRExprVec_2( addr, mkIRExpr_HWord( szB ));
+ break;
+ }
+ } else {
+ switch (szB) {
+ case 1:
+ hName = "evh__mem_help_read_1";
+ hAddr = &evh__mem_help_read_1;
+ argv = mkIRExprVec_1( addr );
+ break;
+ case 2:
+ hName = "evh__mem_help_read_2";
+ hAddr = &evh__mem_help_read_2;
+ argv = mkIRExprVec_1( addr );
+ break;
+ case 4:
+ hName = "evh__mem_help_read_4";
+ hAddr = &evh__mem_help_read_4;
+ argv = mkIRExprVec_1( addr );
+ break;
+ case 8:
+ hName = "evh__mem_help_read_8";
+ hAddr = &evh__mem_help_read_8;
+ argv = mkIRExprVec_1( addr );
+ break;
+ default:
+ tl_assert(szB > 8 && szB <= 512); /* stay sane */
+ regparms = 2;
+ hName = "evh__mem_help_read_N";
+ hAddr = &evh__mem_help_read_N;
+ argv = mkIRExprVec_2( addr, mkIRExpr_HWord( szB ));
+ break;
+ }
+ }
+
+ /* Add the helper. */
+ tl_assert(hName);
+ tl_assert(hAddr);
+ tl_assert(argv);
+ di = unsafeIRDirty_0_N( regparms,
+ hName, VG_(fnptr_to_fnentry)( hAddr ),
+ argv );
+ addStmtToIRSB( bbOut, IRStmt_Dirty(di) );
+}
+
+
+static void instrument_memory_bus_event ( IRSB* bbOut, IRMBusEvent event )
+{
+ switch (event) {
+ case Imbe_Fence:
+ break; /* not interesting */
+ case Imbe_BusLock:
+ case Imbe_BusUnlock:
+ addStmtToIRSB(
+ bbOut,
+ IRStmt_Dirty(
+ unsafeIRDirty_0_N(
+ 0/*regparms*/,
+ event == Imbe_BusLock ? "evh__bus_lock"
+ : "evh__bus_unlock",
+ VG_(fnptr_to_fnentry)(
+ event == Imbe_BusLock ? &evh__bus_lock
+ : &evh__bus_unlock
+ ),
+ mkIRExprVec_0()
+ )
+ )
+ );
+ break;
+ default:
+ tl_assert(0);
+ }
+}
+
+
+static
+IRSB* hg_instrument ( VgCallbackClosure* closure,
+ IRSB* bbIn,
+ VexGuestLayout* layout,
+ VexGuestExtents* vge,
+ IRType gWordTy, IRType hWordTy )
+{
+ Int i;
+ IRSB* bbOut;
+
+ if (gWordTy != hWordTy) {
+ /* We don't currently support this case. */
+ VG_(tool_panic)("host/guest word size mismatch");
+ }
+
+ /* Set up BB */
+ bbOut = emptyIRSB();
+ bbOut->tyenv = deepCopyIRTypeEnv(bbIn->tyenv);
+ bbOut->next = deepCopyIRExpr(bbIn->next);
+ bbOut->jumpkind = bbIn->jumpkind;
+
+ // Copy verbatim any IR preamble preceding the first IMark
+ i = 0;
+ while (i < bbIn->stmts_used && bbIn->stmts[i]->tag != Ist_IMark) {
+ addStmtToIRSB( bbOut, bbIn->stmts[i] );
+ i++;
+ }
+
+ for (/*use current i*/; i < bbIn->stmts_used; i++) {
+ IRStmt* st = bbIn->stmts[i];
+ tl_assert(st);
+ tl_assert(isFlatIRStmt(st));
+ switch (st->tag) {
+ case Ist_NoOp:
+ case Ist_AbiHint:
+ case Ist_Put:
+ case Ist_PutI:
+ case Ist_IMark:
+ case Ist_Exit:
+ /* None of these can contain any memory references. */
+ break;
+
+ case Ist_MBE:
+ instrument_memory_bus_event( bbOut, st->Ist.MBE.event );
+ break;
+
+ case Ist_Store:
+ instrument_mem_access(
+ bbOut,
+ st->Ist.Store.addr,
+ sizeofIRType(typeOfIRExpr(bbIn->tyenv, st->Ist.Store.data)),
+ True/*isStore*/,
+ sizeofIRType(hWordTy)
+ );
+ break;
+
+ case Ist_WrTmp: {
+ IRExpr* data = st->Ist.WrTmp.data;
+ if (data->tag == Iex_Load) {
+ instrument_mem_access(
+ bbOut,
+ data->Iex.Load.addr,
+ sizeofIRType(data->Iex.Load.ty),
+ False/*!isStore*/,
+ sizeofIRType(hWordTy)
+ );
+ }
+ break;
+ }
+
+ case Ist_Dirty: {
+ Int dataSize;
+ IRDirty* d = st->Ist.Dirty.details;
+ if (d->mFx != Ifx_None) {
+ /* This dirty helper accesses memory. Collect the
+ details. */
+ tl_assert(d->mAddr != NULL);
+ tl_assert(d->mSize != 0);
+ dataSize = d->mSize;
+ if (d->mFx == Ifx_Read || d->mFx == Ifx_Modify) {
+ instrument_mem_access(
+ bbOut, d->mAddr, dataSize, False/*!isStore*/,
+ sizeofIRType(hWordTy)
+ );
+ }
+ if (d->mFx == Ifx_Write || d->mFx == Ifx_Modify) {
+ instrument_mem_access(
+ bbOut, d->mAddr, dataSize, True/*isStore*/,
+ sizeofIRType(hWordTy)
+ );
+ }
+ } else {
+ tl_assert(d->mAddr == NULL);
+ tl_assert(d->mSize == 0);
+ }
+ break;
+ }
+
+ default:
+ tl_assert(0);
+
+ } /* switch (st->tag) */
+
+ addStmtToIRSB( bbOut, st );
+ } /* iterate over bbIn->stmts */
+
+ return bbOut;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Client requests ---*/
+/*----------------------------------------------------------------*/
+
+/* Sheesh. Yet another goddam finite map. */
+static WordFM* map_pthread_t_to_Thread = NULL; /* pthread_t -> Thread* */
+
+static void map_pthread_t_to_Thread_INIT ( void ) {
+ if (UNLIKELY(map_pthread_t_to_Thread == NULL)) {
+ map_pthread_t_to_Thread = HG_(newFM)( hg_zalloc, hg_free, NULL );
+ tl_assert(map_pthread_t_to_Thread != NULL);
+ }
+}
+
+
+static
+Bool hg_handle_client_request ( ThreadId tid, UWord* args, UWord* ret)
+{
+ if (!VG_IS_TOOL_USERREQ('H','G',args[0]))
+ return False;
+
+ /* Anything that gets past the above check is one of ours, so we
+ should be able to handle it. */
+
+ /* default, meaningless return value, unless otherwise set */
+ *ret = 0;
+
+ switch (args[0]) {
+
+ /* --- --- User-visible client requests --- --- */
+
+ case VG_USERREQ__HG_CLEAN_MEMORY:
+ if (0) VG_(printf)("VG_USERREQ__HG_CLEAN_MEMORY(%p,%d)\n",
+ args[1], args[2]);
+ /* Call die_mem to (expensively) tidy up properly, if there
+ are any held locks etc in the area */
+ if (args[2] > 0) { /* length */
+ evh__die_mem(args[1], args[2]);
+ /* and then set it to New */
+ evh__new_mem(args[1], args[2]);
+ }
+ break;
+
+ /* --- --- Client requests for Helgrind's use only --- --- */
+
+ /* Some thread is telling us its pthread_t value. Record the
+ binding between that and the associated Thread*, so we can
+ later find the Thread* again when notified of a join by the
+ thread. */
+ case _VG_USERREQ__HG_SET_MY_PTHREAD_T: {
+ Thread* my_thr = NULL;
+ if (0)
+ VG_(printf)("SET_MY_PTHREAD_T (tid %d): pthread_t = %p\n", (Int)tid,
+ (void*)args[1]);
+ map_pthread_t_to_Thread_INIT();
+ my_thr = map_threads_maybe_lookup( tid );
+ /* This assertion should hold because the map_threads (tid to
+ Thread*) binding should have been made at the point of
+ low-level creation of this thread, which should have
+ happened prior to us getting this client request for it.
+ That's because this client request is sent from
+ client-world from the 'thread_wrapper' function, which
+ only runs once the thread has been low-level created. */
+ tl_assert(my_thr != NULL);
+ /* So now we know that (pthread_t)args[1] is associated with
+ (Thread*)my_thr. Note that down. */
+ if (0)
+ VG_(printf)("XXXX: bind pthread_t %p to Thread* %p\n",
+ (void*)args[1], (void*)my_thr );
+ HG_(addToFM)( map_pthread_t_to_Thread, (Word)args[1], (Word)my_thr );
+ break;
+ }
+
+ case _VG_USERREQ__HG_PTH_API_ERROR: {
+ Thread* my_thr = NULL;
+ map_pthread_t_to_Thread_INIT();
+ my_thr = map_threads_maybe_lookup( tid );
+ tl_assert(my_thr); /* See justification above in SET_MY_PTHREAD_T */
+ record_error_PthAPIerror( my_thr, (HChar*)args[1],
+ (Word)args[2], (HChar*)args[3] );
+ break;
+ }
+
+ /* This thread (tid) has completed a join with the quitting
+ thread whose pthread_t is in args[1]. */
+ case _VG_USERREQ__HG_PTHREAD_JOIN_POST: {
+ Thread* thr_q = NULL; /* quitter Thread* */
+ Bool found = False;
+ if (0)
+ VG_(printf)("NOTIFY_JOIN_COMPLETE (tid %d): quitter = %p\n", (Int)tid,
+ (void*)args[1]);
+ map_pthread_t_to_Thread_INIT();
+ found = HG_(lookupFM)( map_pthread_t_to_Thread,
+ NULL, (Word*)(void*)&thr_q, (Word)args[1] );
+ /* Can this fail? It would mean that our pthread_join
+ wrapper observed a successful join on args[1] yet that
+ thread never existed (or at least, it never lodged an
+ entry in the mapping (via SET_MY_PTHREAD_T)). Which
+ sounds like a bug in the threads library. */
+ // FIXME: get rid of this assertion; handle properly
+ tl_assert(found);
+ if (found) {
+ if (0)
+ VG_(printf)(".................... quitter Thread* = %p\n",
+ thr_q);
+ evh__HG_PTHREAD_JOIN_POST( tid, thr_q );
+ }
+ break;
+ }
+
+ /* EXPOSITION only: by intercepting lock init events we can show
+ the user where the lock was initialised, rather than only
+ being able to show where it was first locked. Intercepting
+ lock initialisations is not necessary for the basic operation
+ of the race checker. */
+ case _VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST:
+ evh__HG_PTHREAD_MUTEX_INIT_POST( tid, (void*)args[1], args[2] );
+ break;
+
+ case _VG_USERREQ__HG_PTHREAD_MUTEX_DESTROY_PRE:
+ evh__HG_PTHREAD_MUTEX_DESTROY_PRE( tid, (void*)args[1] );
+ break;
+
+ case _VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE: // pth_mx_t*
+ evh__HG_PTHREAD_MUTEX_UNLOCK_PRE( tid, (void*)args[1] );
+ break;
+
+ case _VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST: // pth_mx_t*
+ evh__HG_PTHREAD_MUTEX_UNLOCK_POST( tid, (void*)args[1] );
+ break;
+
+ case _VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE: // pth_mx_t*, Word
+ evh__HG_PTHREAD_MUTEX_LOCK_PRE( tid, (void*)args[1], args[2] );
+ break;
+
+ case _VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST: // pth_mx_t*
+ evh__HG_PTHREAD_MUTEX_LOCK_POST( tid, (void*)args[1] );
+ break;
+
+ /* This thread is about to do pthread_cond_signal on the
+ pthread_cond_t* in arg[1]. Ditto pthread_cond_broadcast. */
+ case _VG_USERREQ__HG_PTHREAD_COND_SIGNAL_PRE:
+ case _VG_USERREQ__HG_PTHREAD_COND_BROADCAST_PRE:
+ evh__HG_PTHREAD_COND_SIGNAL_PRE( tid, (void*)args[1] );
+ break;
+
+ /* Entry into pthread_cond_wait, cond=arg[1], mutex=arg[2].
+ Returns a flag indicating whether or not the mutex is believed to be
+ valid for this operation. */
+ case _VG_USERREQ__HG_PTHREAD_COND_WAIT_PRE: {
+ Bool mutex_is_valid
+ = evh__HG_PTHREAD_COND_WAIT_PRE( tid, (void*)args[1],
+ (void*)args[2] );
+ *ret = mutex_is_valid ? 1 : 0;
+ break;
+ }
+
+ /* Thread successfully completed pthread_cond_wait, cond=arg[1],
+ mutex=arg[2] */
+ case _VG_USERREQ__HG_PTHREAD_COND_WAIT_POST:
+ evh__HG_PTHREAD_COND_WAIT_POST( tid,
+ (void*)args[1], (void*)args[2] );
+ break;
+
+ case _VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST:
+ evh__HG_PTHREAD_RWLOCK_INIT_POST( tid, (void*)args[1] );
+ break;
+
+ case _VG_USERREQ__HG_PTHREAD_RWLOCK_DESTROY_PRE:
+ evh__HG_PTHREAD_RWLOCK_DESTROY_PRE( tid, (void*)args[1] );
+ break;
+
+ /* rwlock=arg[1], isW=arg[2] */
+ case _VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE:
+ evh__HG_PTHREAD_RWLOCK_LOCK_PRE( tid, (void*)args[1], args[2] );
+ break;
+
+ /* rwlock=arg[1], isW=arg[2] */
+ case _VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST:
+ evh__HG_PTHREAD_RWLOCK_LOCK_POST( tid, (void*)args[1], args[2] );
+ break;
+
+ case _VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE:
+ evh__HG_PTHREAD_RWLOCK_UNLOCK_PRE( tid, (void*)args[1] );
+ break;
+
+ case _VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_POST:
+ evh__HG_PTHREAD_RWLOCK_UNLOCK_POST( tid, (void*)args[1] );
+ break;
+
+ case _VG_USERREQ__HG_POSIX_SEMPOST_PRE: /* sem_t* */
+ evh__HG_POSIX_SEMPOST_PRE( tid, (void*)args[1] );
+ break;
+
+ case _VG_USERREQ__HG_POSIX_SEMWAIT_POST: /* sem_t* */
+ evh__HG_POSIX_SEMWAIT_POST( tid, (void*)args[1] );
+ break;
+
+ case _VG_USERREQ__HG_POSIX_SEM_ZAPSTACK: /* sem_t* */
+ evh__HG_POSIX_SEM_ZAPSTACK( tid, (void*)args[1] );
+ break;
+
+ case _VG_USERREQ__HG_GET_MY_SEGMENT: { // -> Segment*
+ Thread* thr;
+ SegmentID segid;
+ Segment* seg;
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail */
+ segid = thr->csegid;
+ tl_assert(is_sane_SegmentID(segid));
+ seg = map_segments_lookup( segid );
+ tl_assert(seg);
+ *ret = (UWord)seg;
+ break;
+ }
+
+ default:
+ /* Unhandled Helgrind client request! */
+ tl_assert2(0, "unhandled Helgrind client request!");
+ }
+
+ return True;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Error management ---*/
+/*----------------------------------------------------------------*/
+
+/* maps (by value) strings to a copy of them in ARENA_TOOL */
+static UWord stats__string_table_queries = 0;
+static WordFM* string_table = NULL;
+static Word string_table_cmp ( Word s1, Word s2 ) {
+ return (Word)VG_(strcmp)( (HChar*)s1, (HChar*)s2 );
+}
+static HChar* string_table_strdup ( HChar* str ) {
+ HChar* copy = NULL;
+ stats__string_table_queries++;
+ if (!str)
+ str = "(null)";
+ if (!string_table) {
+ string_table = HG_(newFM)( hg_zalloc, hg_free, string_table_cmp );
+ tl_assert(string_table);
+ }
+ if (HG_(lookupFM)( string_table,
+ NULL, (Word*)(void*)©, (Word)str )) {
+ tl_assert(copy);
+ if (0) VG_(printf)("string_table_strdup: %p -> %p\n", str, copy );
+ return copy;
+ } else {
+ copy = VG_(strdup)(str);
+ tl_assert(copy);
+ HG_(addToFM)( string_table, (Word)copy, (Word)copy );
+ return copy;
+ }
+}
+
+/* maps from Lock .unique fields to LockP*s */
+static UWord stats__ga_LockN_to_P_queries = 0;
+static WordFM* yaWFM = NULL;
+static Word lock_unique_cmp ( Word lk1W, Word lk2W )
+{
+ Lock* lk1 = (Lock*)lk1W;
+ Lock* lk2 = (Lock*)lk2W;
+ tl_assert( is_sane_LockNorP(lk1) );
+ tl_assert( is_sane_LockNorP(lk2) );
+ if (lk1->unique < lk2->unique) return -1;
+ if (lk1->unique > lk2->unique) return 1;
+ return 0;
+}
+static Lock* mk_LockP_from_LockN ( Lock* lkn )
+{
+ Lock* lkp = NULL;
+ stats__ga_LockN_to_P_queries++;
+ tl_assert( is_sane_LockN(lkn) );
+ if (!yaWFM) {
+ yaWFM = HG_(newFM)( hg_zalloc, hg_free, lock_unique_cmp );
+ tl_assert(yaWFM);
+ }
+ if (!HG_(lookupFM)( yaWFM, NULL, (Word*)(void*)&lkp, (Word)lkn)) {
+ lkp = hg_zalloc( sizeof(Lock) );
+ *lkp = *lkn;
+ lkp->admin = NULL;
+ lkp->magic = LockP_MAGIC;
+ /* Forget about the bag of lock holders - don't copy that.
+ Also, acquired_at should be NULL whenever heldBy is, and vice
+ versa. */
+ lkp->heldW = False;
+ lkp->heldBy = NULL;
+ lkp->acquired_at = NULL;
+ HG_(addToFM)( yaWFM, (Word)lkp, (Word)lkp );
+ }
+ tl_assert( is_sane_LockP(lkp) );
+ return lkp;
+}
+
+/* Errors:
+
+ race: program counter
+ read or write
+ data size
+ previous state
+ current state
+
+ FIXME: how does state printing interact with lockset gc?
+ Are the locksets in prev/curr state always valid?
+ Ditto question for the threadsets
+ ThreadSets - probably are always valid if Threads
+ are never thrown away.
+ LockSets - could at least print the lockset elements that
+ correspond to actual locks at the time of printing. Hmm.
+*/
+
+/* Error kinds */
+typedef
+ enum {
+ XE_Race=1101, // race
+ XE_FreeMemLock, // freeing memory containing a locked lock
+ XE_UnlockUnlocked, // unlocking a not-locked lock
+ XE_UnlockForeign, // unlocking a lock held by some other thread
+ XE_UnlockBogus, // unlocking an address not known to be a lock
+ XE_PthAPIerror, // error from the POSIX pthreads API
+ XE_LockOrder, // lock order error
+ XE_Misc // misc other error (w/ string to describe it)
+ }
+ XErrorTag;
+
+/* Extra contexts for kinds */
+typedef
+ struct {
+ XErrorTag tag;
+ union {
+ struct {
+ Addr data_addr;
+ Int szB;
+ Bool isWrite;
+ UInt new_state;
+ UInt old_state;
+ ExeContext* mb_lastlock;
+ Thread* thr;
+ } Race;
+ struct {
+ Thread* thr; /* doing the freeing */
+ Lock* lock; /* lock which is locked */
+ } FreeMemLock;
+ struct {
+ Thread* thr; /* doing the unlocking */
+ Lock* lock; /* lock (that is already unlocked) */
+ } UnlockUnlocked;
+ struct {
+ Thread* thr; /* doing the unlocking */
+ Thread* owner; /* thread that actually holds the lock */
+ Lock* lock; /* lock (that is held by 'owner') */
+ } UnlockForeign;
+ struct {
+ Thread* thr; /* doing the unlocking */
+ Addr lock_ga; /* purported address of the lock */
+ } UnlockBogus;
+ struct {
+ Thread* thr;
+ HChar* fnname; /* persistent, in tool-arena */
+ Word err; /* pth error code */
+ HChar* errstr; /* persistent, in tool-arena */
+ } PthAPIerror;
+ struct {
+ Thread* thr;
+ Addr before_ga; /* always locked first in prog. history */
+ Addr after_ga;
+ ExeContext* before_ec;
+ ExeContext* after_ec;
+ } LockOrder;
+ struct {
+ Thread* thr;
+ HChar* errstr; /* persistent, in tool-arena */
+ } Misc;
+ } XE;
+ }
+ XError;
+
+static void init_XError ( XError* xe ) {
+ VG_(memset)(xe, 0, sizeof(*xe) );
+ xe->tag = XE_Race-1; /* bogus */
+}
+
+
+/* Extensions of suppressions */
+typedef
+ enum {
+ XS_Race=1201, /* race */
+ XS_FreeMemLock,
+ XS_UnlockUnlocked,
+ XS_UnlockForeign,
+ XS_UnlockBogus,
+ XS_PthAPIerror,
+ XS_LockOrder,
+ XS_Misc
+ }
+ XSuppTag;
+
+
+/* Updates the copy with address info if necessary. */
+static UInt hg_update_extra ( Error* err )
+{
+ XError* extra = (XError*)VG_(get_error_extra)(err);
+ tl_assert(extra);
+ //if (extra != NULL && Undescribed == extra->addrinfo.akind) {
+ // describe_addr ( VG_(get_error_address)(err), &(extra->addrinfo) );
+ //}
+ return sizeof(XError);
+}
+
+static void record_error_Race ( Thread* thr,
+ Addr data_addr, Bool isWrite, Int szB,
+ UInt old_sv, UInt new_sv,
+ ExeContext* mb_lastlock ) {
+ XError xe;
+ tl_assert( is_sane_Thread(thr) );
+ init_XError(&xe);
+ xe.tag = XE_Race;
+ xe.XE.Race.data_addr = data_addr;
+ xe.XE.Race.szB = szB;
+ xe.XE.Race.isWrite = isWrite;
+ xe.XE.Race.new_state = new_sv;
+ xe.XE.Race.old_state = old_sv;
+ xe.XE.Race.mb_lastlock = mb_lastlock;
+ xe.XE.Race.thr = thr;
+ // FIXME: tid vs thr
+ tl_assert(isWrite == False || isWrite == True);
+ tl_assert(szB == 8 || szB == 4 || szB == 2 || szB == 1);
+ VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+ XE_Race, data_addr, NULL, &xe );
+}
+
+static void record_error_FreeMemLock ( Thread* thr, Lock* lk ) {
+ XError xe;
+ tl_assert( is_sane_Thread(thr) );
+ tl_assert( is_sane_LockN(lk) );
+ init_XError(&xe);
+ xe.tag = XE_FreeMemLock;
+ xe.XE.FreeMemLock.thr = thr;
+ xe.XE.FreeMemLock.lock = mk_LockP_from_LockN(lk);
+ // FIXME: tid vs thr
+ VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+ XE_FreeMemLock, 0, NULL, &xe );
+}
+
+static void record_error_UnlockUnlocked ( Thread* thr, Lock* lk ) {
+ XError xe;
+ tl_assert( is_sane_Thread(thr) );
+ tl_assert( is_sane_LockN(lk) );
+ init_XError(&xe);
+ xe.tag = XE_UnlockUnlocked;
+ xe.XE.UnlockUnlocked.thr = thr;
+ xe.XE.UnlockUnlocked.lock = mk_LockP_from_LockN(lk);
+ // FIXME: tid vs thr
+ VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+ XE_UnlockUnlocked, 0, NULL, &xe );
+}
+
+static void record_error_UnlockForeign ( Thread* thr,
+ Thread* owner, Lock* lk ) {
+ XError xe;
+ tl_assert( is_sane_Thread(thr) );
+ tl_assert( is_sane_Thread(owner) );
+ tl_assert( is_sane_LockN(lk) );
+ init_XError(&xe);
+ xe.tag = XE_UnlockForeign;
+ xe.XE.UnlockForeign.thr = thr;
+ xe.XE.UnlockForeign.owner = owner;
+ xe.XE.UnlockForeign.lock = mk_LockP_from_LockN(lk);
+ // FIXME: tid vs thr
+ VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+ XE_UnlockForeign, 0, NULL, &xe );
+}
+
+static void record_error_UnlockBogus ( Thread* thr, Addr lock_ga ) {
+ XError xe;
+ tl_assert( is_sane_Thread(thr) );
+ init_XError(&xe);
+ xe.tag = XE_UnlockBogus;
+ xe.XE.UnlockBogus.thr = thr;
+ xe.XE.UnlockBogus.lock_ga = lock_ga;
+ // FIXME: tid vs thr
+ VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+ XE_UnlockBogus, 0, NULL, &xe );
+}
+
+static
+void record_error_LockOrder ( Thread* thr, Addr before_ga, Addr after_ga,
+ ExeContext* before_ec, ExeContext* after_ec ) {
+ XError xe;
+ tl_assert( is_sane_Thread(thr) );
+ init_XError(&xe);
+ xe.tag = XE_LockOrder;
+ xe.XE.LockOrder.thr = thr;
+ xe.XE.LockOrder.before_ga = before_ga;
+ xe.XE.LockOrder.before_ec = before_ec;
+ xe.XE.LockOrder.after_ga = after_ga;
+ xe.XE.LockOrder.after_ec = after_ec;
+ // FIXME: tid vs thr
+ VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+ XE_LockOrder, 0, NULL, &xe );
+}
+
+static
+void record_error_PthAPIerror ( Thread* thr, HChar* fnname,
+ Word err, HChar* errstr ) {
+ XError xe;
+ tl_assert( is_sane_Thread(thr) );
+ tl_assert(fnname);
+ tl_assert(errstr);
+ init_XError(&xe);
+ xe.tag = XE_PthAPIerror;
+ xe.XE.PthAPIerror.thr = thr;
+ xe.XE.PthAPIerror.fnname = string_table_strdup(fnname);
+ xe.XE.PthAPIerror.err = err;
+ xe.XE.PthAPIerror.errstr = string_table_strdup(errstr);
+ // FIXME: tid vs thr
+ VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+ XE_PthAPIerror, 0, NULL, &xe );
+}
+
+static void record_error_Misc ( Thread* thr, HChar* errstr ) {
+ XError xe;
+ tl_assert( is_sane_Thread(thr) );
+ tl_assert(errstr);
+ init_XError(&xe);
+ xe.tag = XE_Misc;
+ xe.XE.Misc.thr = thr;
+ xe.XE.Misc.errstr = string_table_strdup(errstr);
+ // FIXME: tid vs thr
+ VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+ XE_Misc, 0, NULL, &xe );
+}
+
+static Bool hg_eq_Error ( VgRes not_used, Error* e1, Error* e2 )
+{
+ XError *xe1, *xe2;
+
+ tl_assert(VG_(get_error_kind)(e1) == VG_(get_error_kind)(e2));
+
+ xe1 = (XError*)VG_(get_error_extra)(e1);
+ xe2 = (XError*)VG_(get_error_extra)(e2);
+ tl_assert(xe1);
+ tl_assert(xe2);
+
+ switch (VG_(get_error_kind)(e1)) {
+ case XE_Race:
+ return xe1->XE.Race.szB == xe2->XE.Race.szB
+ && xe1->XE.Race.isWrite == xe2->XE.Race.isWrite
+ && (clo_cmp_race_err_addrs
+ ? xe1->XE.Race.data_addr == xe2->XE.Race.data_addr
+ : True);
+ case XE_FreeMemLock:
+ return xe1->XE.FreeMemLock.thr == xe2->XE.FreeMemLock.thr
+ && xe1->XE.FreeMemLock.lock == xe2->XE.FreeMemLock.lock;
+ case XE_UnlockUnlocked:
+ return xe1->XE.UnlockUnlocked.thr == xe2->XE.UnlockUnlocked.thr
+ && xe1->XE.UnlockUnlocked.lock == xe2->XE.UnlockUnlocked.lock;
+ case XE_UnlockForeign:
+ return xe1->XE.UnlockForeign.thr == xe2->XE.UnlockForeign.thr
+ && xe1->XE.UnlockForeign.owner == xe2->XE.UnlockForeign.owner
+ && xe1->XE.UnlockForeign.lock == xe2->XE.UnlockForeign.lock;
+ case XE_UnlockBogus:
+ return xe1->XE.UnlockBogus.thr == xe2->XE.UnlockBogus.thr
+ && xe1->XE.UnlockBogus.lock_ga == xe2->XE.UnlockBogus.lock_ga;
+ case XE_PthAPIerror:
+ return xe1->XE.PthAPIerror.thr == xe2->XE.PthAPIerror.thr
+ && 0==VG_(strcmp)(xe1->XE.PthAPIerror.fnname,
+ xe2->XE.PthAPIerror.fnname)
+ && xe1->XE.PthAPIerror.err == xe2->XE.PthAPIerror.err;
+ case XE_LockOrder:
+ return xe1->XE.LockOrder.thr == xe2->XE.LockOrder.thr;
+ case XE_Misc:
+ return xe1->XE.Misc.thr == xe2->XE.Misc.thr
+ && 0==VG_(strcmp)(xe1->XE.Misc.errstr, xe2->XE.Misc.errstr);
+ default:
+ tl_assert(0);
+ }
+
+ /*NOTREACHED*/
+ tl_assert(0);
+}
+
+/* Given a WordSetID in univ_tsets (that is, a Thread set ID), produce
+ an XArray* with the corresponding Thread*'s sorted by their
+ errmsg_index fields. This is for printing out thread sets in
+ repeatable orders, which is important for for repeatable regression
+ testing. The returned XArray* is dynamically allocated (of course)
+ and so must be hg_freed by the caller. */
+static Int cmp_Thread_by_errmsg_index ( void* thr1V, void* thr2V ) {
+ Thread* thr1 = *(Thread**)thr1V;
+ Thread* thr2 = *(Thread**)thr2V;
+ if (thr1->errmsg_index < thr2->errmsg_index) return -1;
+ if (thr1->errmsg_index > thr2->errmsg_index) return 1;
+ return 0;
+}
+static XArray* /* of Thread* */ get_sorted_thread_set ( WordSetID tset )
+{
+ XArray* xa;
+ Word* ts_words;
+ Word ts_size, i;
+ xa = VG_(newXA)( hg_zalloc, hg_free, sizeof(Thread*) );
+ tl_assert(xa);
+ HG_(getPayloadWS)( &ts_words, &ts_size, univ_tsets, tset );
+ tl_assert(ts_words);
+ tl_assert(ts_size >= 0);
+ /* This isn't a very clever scheme, but we don't expect this to be
+ called very often. */
+ for (i = 0; i < ts_size; i++) {
+ Thread* thr = (Thread*)ts_words[i];
+ tl_assert(is_sane_Thread(thr));
+ VG_(addToXA)( xa, (void*)&thr );
+ }
+ tl_assert(ts_size == VG_(sizeXA)( xa ));
+ VG_(setCmpFnXA)( xa, cmp_Thread_by_errmsg_index );
+ VG_(sortXA)( xa );
+ return xa;
+}
+
+
+/* Announce (that is, print the point-of-creation) of the threads in
+ 'tset'. Only do this once, as we only want to see these
+ announcements once each. Also, first sort the threads by their
+ errmsg_index fields, and show only the first N_THREADS_TO_ANNOUNCE.
+ That's because we only want to bother to announce threads
+ enumerated by summarise_threadset() below, and that in turn does
+ the same: it sorts them and then only shows the first
+ N_THREADS_TO_ANNOUNCE. */
+
+static void announce_threadset ( WordSetID tset )
+{
+ const Word limit = N_THREADS_TO_ANNOUNCE;
+ Thread* thr;
+ XArray* sorted;
+ Word ts_size, i, loopmax;
+ sorted = get_sorted_thread_set( tset );
+ ts_size = VG_(sizeXA)( sorted );
+ tl_assert(ts_size >= 0);
+ loopmax = limit < ts_size ? limit : ts_size; /* min(limit, ts_size) */
+ tl_assert(loopmax >= 0 && loopmax <= limit);
+ for (i = 0; i < loopmax; i++) {
+ thr = *(Thread**)VG_(indexXA)( sorted, i );
+ tl_assert(is_sane_Thread(thr));
+ tl_assert(thr->errmsg_index >= 1);
+ if (thr->announced)
+ continue;
+ if (thr->errmsg_index == 1/*FIXME: this hardwires an assumption
+ about the identity of the root
+ thread*/) {
+ tl_assert(thr->created_at == NULL);
+ VG_(message)(Vg_UserMsg, "Thread #%d is the program's root thread",
+ thr->errmsg_index);
+ } else {
+ tl_assert(thr->created_at != NULL);
+ VG_(message)(Vg_UserMsg, "Thread #%d was created",
+ thr->errmsg_index);
+ VG_(pp_ExeContext)( thr->created_at );
+ }
+ VG_(message)(Vg_UserMsg, "");
+ thr->announced = True;
+ }
+ VG_(deleteXA)( sorted );
+}
+static void announce_one_thread ( Thread* thr ) {
+ announce_threadset( HG_(singletonWS)(univ_tsets, (Word)thr ));
+}
+
+/* Generate into buf[0 .. nBuf-1] a 1-line summary of a thread set, of
+ the form "#1, #3, #77, #78, #79 and 42 others". The first
+ N_THREADS_TO_ANNOUNCE are listed explicitly (as '#n') and the
+ leftovers lumped into the 'and n others' bit. */
+
+static void summarise_threadset ( WordSetID tset, Char* buf, UInt nBuf )
+{
+ const Word limit = N_THREADS_TO_ANNOUNCE;
+ Thread* thr;
+ XArray* sorted;
+ Word ts_size, i, loopmax;
+ UInt off = 0;
+ tl_assert(nBuf > 0);
+ tl_assert(nBuf >= 40 + 20*limit);
+ tl_assert(buf);
+ sorted = get_sorted_thread_set( tset );
+ ts_size = VG_(sizeXA)( sorted );
+ tl_assert(ts_size >= 0);
+ loopmax = limit < ts_size ? limit : ts_size; /* min(limit, ts_size) */
+ tl_assert(loopmax >= 0 && loopmax <= limit);
+ VG_(memset)(buf, 0, nBuf);
+ for (i = 0; i < loopmax; i++) {
+ thr = *(Thread**)VG_(indexXA)( sorted, i );
+ tl_assert(is_sane_Thread(thr));
+ tl_assert(thr->errmsg_index >= 1);
+ off += VG_(sprintf)(&buf[off], "#%d", (Int)thr->errmsg_index);
+ if (i < loopmax-1)
+ off += VG_(sprintf)(&buf[off], ", ");
+ }
+ if (limit < ts_size) {
+ Word others = ts_size - limit;
+ off += VG_(sprintf)(&buf[off], " and %d other%s",
+ (Int)others, others > 1 ? "s" : "");
+ }
+ tl_assert(off < nBuf);
+ tl_assert(buf[nBuf-1] == 0);
+ VG_(deleteXA)( sorted );
+}
+
+static void hg_pp_Error ( Error* err )
+{
+ const Bool show_raw_states = False;
+ XError *xe = (XError*)VG_(get_error_extra)(err);
+
+ switch (VG_(get_error_kind)(err)) {
+
+ case XE_Misc: {
+ tl_assert(xe);
+ tl_assert( is_sane_Thread( xe->XE.Misc.thr ) );
+ announce_one_thread( xe->XE.Misc.thr );
+ VG_(message)(Vg_UserMsg,
+ "Thread #%d: %s",
+ (Int)xe->XE.Misc.thr->errmsg_index,
+ xe->XE.Misc.errstr);
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ break;
+ }
+
+ case XE_LockOrder: {
+ tl_assert(xe);
+ tl_assert( is_sane_Thread( xe->XE.LockOrder.thr ) );
+ announce_one_thread( xe->XE.LockOrder.thr );
+ VG_(message)(Vg_UserMsg,
+ "Thread #%d: lock order \"%p before %p\" violated",
+ (Int)xe->XE.LockOrder.thr->errmsg_index,
+ (void*)xe->XE.LockOrder.before_ga,
+ (void*)xe->XE.LockOrder.after_ga);
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ if (xe->XE.LockOrder.before_ec && xe->XE.LockOrder.after_ec) {
+ VG_(message)(Vg_UserMsg,
+ " Required order was established by acquisition of lock at %p",
+ (void*)xe->XE.LockOrder.before_ga);
+ VG_(pp_ExeContext)( xe->XE.LockOrder.before_ec );
+ VG_(message)(Vg_UserMsg,
+ " followed by a later acquisition of lock at %p",
+ (void*)xe->XE.LockOrder.after_ga);
+ VG_(pp_ExeContext)( xe->XE.LockOrder.after_ec );
+ }
+ break;
+ }
+
+ case XE_PthAPIerror: {
+ tl_assert(xe);
+ tl_assert( is_sane_Thread( xe->XE.PthAPIerror.thr ) );
+ announce_one_thread( xe->XE.PthAPIerror.thr );
+ VG_(message)(Vg_UserMsg,
+ "Thread #%d's call to %s failed",
+ (Int)xe->XE.PthAPIerror.thr->errmsg_index,
+ xe->XE.PthAPIerror.fnname);
+ VG_(message)(Vg_UserMsg,
+ " with error code %ld (%s)",
+ xe->XE.PthAPIerror.err,
+ xe->XE.PthAPIerror.errstr);
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ break;
+ }
+
+ case XE_UnlockBogus: {
+ tl_assert(xe);
+ tl_assert( is_sane_Thread( xe->XE.UnlockBogus.thr ) );
+ announce_one_thread( xe->XE.UnlockBogus.thr );
+ VG_(message)(Vg_UserMsg,
+ "Thread #%d unlocked an invalid lock at %p ",
+ (Int)xe->XE.UnlockBogus.thr->errmsg_index,
+ (void*)xe->XE.UnlockBogus.lock_ga);
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ break;
+ }
+
+ case XE_UnlockForeign: {
+ tl_assert(xe);
+ tl_assert( is_sane_LockP( xe->XE.UnlockForeign.lock ) );
+ tl_assert( is_sane_Thread( xe->XE.UnlockForeign.owner ) );
+ tl_assert( is_sane_Thread( xe->XE.UnlockForeign.thr ) );
+ announce_one_thread( xe->XE.UnlockForeign.thr );
+ announce_one_thread( xe->XE.UnlockForeign.owner );
+ VG_(message)(Vg_UserMsg,
+ "Thread #%d unlocked lock at %p "
+ "currently held by thread #%d",
+ (Int)xe->XE.UnlockForeign.thr->errmsg_index,
+ (void*)xe->XE.UnlockForeign.lock->guestaddr,
+ (Int)xe->XE.UnlockForeign.owner->errmsg_index );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ if (xe->XE.UnlockForeign.lock->appeared_at) {
+ VG_(message)(Vg_UserMsg,
+ " Lock at %p was first observed",
+ (void*)xe->XE.UnlockForeign.lock->guestaddr);
+ VG_(pp_ExeContext)( xe->XE.UnlockForeign.lock->appeared_at );
+ }
+ break;
+ }
+
+ case XE_UnlockUnlocked: {
+ tl_assert(xe);
+ tl_assert( is_sane_LockP( xe->XE.UnlockUnlocked.lock ) );
+ tl_assert( is_sane_Thread( xe->XE.UnlockUnlocked.thr ) );
+ announce_one_thread( xe->XE.UnlockUnlocked.thr );
+ VG_(message)(Vg_UserMsg,
+ "Thread #%d unlocked a not-locked lock at %p ",
+ (Int)xe->XE.UnlockUnlocked.thr->errmsg_index,
+ (void*)xe->XE.UnlockUnlocked.lock->guestaddr);
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ if (xe->XE.UnlockUnlocked.lock->appeared_at) {
+ VG_(message)(Vg_UserMsg,
+ " Lock at %p was first observed",
+ (void*)xe->XE.UnlockUnlocked.lock->guestaddr);
+ VG_(pp_ExeContext)( xe->XE.UnlockUnlocked.lock->appeared_at );
+ }
+ break;
+ }
+
+ case XE_FreeMemLock: {
+ tl_assert(xe);
+ tl_assert( is_sane_LockP( xe->XE.FreeMemLock.lock ) );
+ tl_assert( is_sane_Thread( xe->XE.FreeMemLock.thr ) );
+ announce_one_thread( xe->XE.FreeMemLock.thr );
+ VG_(message)(Vg_UserMsg,
+ "Thread #%d deallocated location %p "
+ "containing a locked lock",
+ (Int)xe->XE.FreeMemLock.thr->errmsg_index,
+ (void*)xe->XE.FreeMemLock.lock->guestaddr);
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ if (xe->XE.FreeMemLock.lock->appeared_at) {
+ VG_(message)(Vg_UserMsg,
+ " Lock at %p was first observed",
+ (void*)xe->XE.FreeMemLock.lock->guestaddr);
+ VG_(pp_ExeContext)( xe->XE.FreeMemLock.lock->appeared_at );
+ }
+ break;
+ }
+
+ case XE_Race: {
+ Addr err_ga;
+ Char old_buf[100], new_buf[100];
+ Char old_tset_buf[140], new_tset_buf[140];
+ UInt old_state, new_state;
+ Thread* thr_acc;
+ HChar* what;
+ Int szB;
+ WordSetID tset_to_announce = HG_(emptyWS)( univ_tsets );
+
+ /* First extract some essential info */
+ tl_assert(xe);
+ old_state = xe->XE.Race.old_state;
+ new_state = xe->XE.Race.new_state;
+ thr_acc = xe->XE.Race.thr;
+ what = xe->XE.Race.isWrite ? "write" : "read";
+ szB = xe->XE.Race.szB;
+ tl_assert(is_sane_Thread(thr_acc));
+ err_ga = VG_(get_error_address)(err);
+
+ /* Format the low level state print descriptions */
+ show_shadow_w32(old_buf, sizeof(old_buf), old_state);
+ show_shadow_w32(new_buf, sizeof(new_buf), new_state);
+
+ /* Now we have to 'announce' the threadset mentioned in the
+ error message, if it hasn't already been announced.
+ Unfortunately the precise threadset and error message text
+ depends on the nature of the transition involved. So now
+ fall into a case analysis of the error state transitions. */
+
+ /* CASE of Excl -> ShM */
+ if (is_SHVAL_Excl(old_state) && is_SHVAL_ShM(new_state)) {
+ SegmentID old_segid;
+ Segment* old_seg;
+ Thread* old_thr;
+ WordSetID new_tset;
+ old_segid = un_SHVAL_Excl( old_state );
+ tl_assert(is_sane_SegmentID(old_segid));
+ old_seg = map_segments_lookup( old_segid );
+ tl_assert(is_sane_Segment(old_seg));
+ tl_assert(old_seg->thr);
+ old_thr = old_seg->thr;
+ tl_assert(is_sane_Thread(old_thr));
+
+ new_tset = un_SHVAL_ShM_tset(new_state);
+ tset_to_announce = HG_(addToWS)( univ_tsets,
+ new_tset, (Word)old_thr );
+ announce_threadset( tset_to_announce );
+
+ VG_(message)(Vg_UserMsg,
+ "Possible data race during %s of size %d at %p",
+ what, szB, err_ga);
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ /* pp_AddrInfo(err_addr, &extra->addrinfo); */
+ if (show_raw_states)
+ VG_(message)(Vg_UserMsg,
+ " Old state 0x%08x=%s, new state 0x%08x=%s",
+ old_state, old_buf, new_state, new_buf);
+ VG_(message)(Vg_UserMsg,
+ " Old state: owned exclusively by thread #%d",
+ old_thr->errmsg_index);
+ // This should always show exactly 2 threads
+ summarise_threadset( new_tset, new_tset_buf, sizeof(new_tset_buf) );
+ VG_(message)(Vg_UserMsg,
+ " New state: shared-modified by threads %s",
+ new_tset_buf );
+ VG_(message)(Vg_UserMsg,
+ " Reason: this thread, #%d, holds no locks at all",
+ thr_acc->errmsg_index);
+ }
+ else
+ /* Case of ShR/M -> ShM */
+ if (is_SHVAL_Sh(old_state) && is_SHVAL_ShM(new_state)) {
+ WordSetID old_tset = un_SHVAL_Sh_tset(old_state);
+ WordSetID new_tset = un_SHVAL_Sh_tset(new_state);
+
+ tset_to_announce = HG_(unionWS)( univ_tsets, old_tset, new_tset );
+ announce_threadset( tset_to_announce );
+
+ VG_(message)(Vg_UserMsg,
+ "Possible data race during %s of size %d at %p",
+ what, szB, err_ga);
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ /* pp_AddrInfo(err_addr, &extra->addrinfo); */
+ if (show_raw_states)
+ VG_(message)(Vg_UserMsg,
+ " Old state 0x%08x=%s, new state 0x%08x=%s",
+ old_state, old_buf, new_state, new_buf);
+
+ summarise_threadset( old_tset, old_tset_buf, sizeof(old_tset_buf) );
+ summarise_threadset( new_tset, new_tset_buf, sizeof(new_tset_buf) );
+
+ VG_(message)(Vg_UserMsg,
+ " Old state: shared-%s by threads %s",
+ is_SHVAL_ShM(old_state) ? "modified" : "readonly",
+ old_tset_buf);
+ VG_(message)(Vg_UserMsg,
+ " New state: shared-modified by threads %s",
+ new_tset_buf);
+ VG_(message)(Vg_UserMsg,
+ " Reason: this thread, #%d, holds no "
+ "consistent locks",
+ thr_acc->errmsg_index);
+ if (xe->XE.Race.mb_lastlock) {
+ VG_(message)(Vg_UserMsg, " Last consistently used lock for %p was "
+ "first observed", err_ga);
+ VG_(pp_ExeContext)(xe->XE.Race.mb_lastlock);
+ } else {
+ VG_(message)(Vg_UserMsg, " Location %p has never been protected "
+ "by any lock", err_ga);
+ }
+ }
+ /* Hmm, unknown transition. Just print what we do know. */
+ else {
+ VG_(message)(Vg_UserMsg,
+ "Possible data race during %s of size %d at %p",
+ what, szB, err_ga);
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+
+ //pp_AddrInfo(err_addr, &extra->addrinfo);
+ VG_(message)(Vg_UserMsg,
+ " Old state 0x%08x=%s, new state 0x%08x=%s",
+ old_state, old_buf, new_state, new_buf);
+ }
+
+ break; /* case XE_Race */
+ } /* case XE_Race */
+
+ default:
+ tl_assert(0);
+ } /* switch (VG_(get_error_kind)(err)) */
+}
+
+static Char* hg_get_error_name ( Error* err )
+{
+ switch (VG_(get_error_kind)(err)) {
+ case XE_Race: return "Race";
+ case XE_FreeMemLock: return "FreeMemLock";
+ case XE_UnlockUnlocked: return "UnlockUnlocked";
+ case XE_UnlockForeign: return "UnlockForeign";
+ case XE_UnlockBogus: return "UnlockBogus";
+ case XE_PthAPIerror: return "PthAPIerror";
+ case XE_LockOrder: return "LockOrder";
+ case XE_Misc: return "Misc";
+ default: tl_assert(0); /* fill in missing case */
+ }
+}
+
+static Bool hg_recognised_suppression ( Char* name, Supp *su )
+{
+# define TRY(_name,_xskind) \
+ if (0 == VG_(strcmp)(name, (_name))) { \
+ VG_(set_supp_kind)(su, (_xskind)); \
+ return True; \
+ }
+ TRY("Race", XS_Race);
+ TRY("FreeMemLock", XS_FreeMemLock);
+ TRY("UnlockUnlocked", XS_UnlockUnlocked);
+ TRY("UnlockForeign", XS_UnlockForeign);
+ TRY("UnlockBogus", XS_UnlockBogus);
+ TRY("PthAPIerror", XS_PthAPIerror);
+ TRY("LockOrder", XS_LockOrder);
+ TRY("Misc", XS_Misc);
+ return False;
+# undef TRY
+}
+
+static Bool hg_read_extra_suppression_info ( Int fd, Char* buf, Int nBuf,
+ Supp* su )
+{
+ /* do nothing -- no extra suppression info present. Return True to
+ indicate nothing bad happened. */
+ return True;
+}
+
+static Bool hg_error_matches_suppression ( Error* err, Supp* su )
+{
+ switch (VG_(get_supp_kind)(su)) {
+ case XS_Race: return VG_(get_error_kind)(err) == XE_Race;
+ case XS_FreeMemLock: return VG_(get_error_kind)(err) == XE_FreeMemLock;
+ case XS_UnlockUnlocked: return VG_(get_error_kind)(err) == XE_UnlockUnlocked;
+ case XS_UnlockForeign: return VG_(get_error_kind)(err) == XE_UnlockForeign;
+ case XS_UnlockBogus: return VG_(get_error_kind)(err) == XE_UnlockBogus;
+ case XS_PthAPIerror: return VG_(get_error_kind)(err) == XE_PthAPIerror;
+ case XS_LockOrder: return VG_(get_error_kind)(err) == XE_LockOrder;
+ case XS_Misc: return VG_(get_error_kind)(err) == XE_Misc;
+ //case XS_: return VG_(get_error_kind)(err) == XE_;
+ default: tl_assert(0); /* fill in missing cases */
+ }
+}
+
+static void hg_print_extra_suppression_info ( Error* err )
+{
+ /* Do nothing */
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Setup ---*/
+/*----------------------------------------------------------------*/
+
+static Bool hg_process_cmd_line_option ( Char* arg )
+{
+ if (VG_CLO_STREQ(arg, "--happens-before=none"))
+ clo_happens_before = 0;
+ else if (VG_CLO_STREQ(arg, "--happens-before=threads"))
+ clo_happens_before = 1;
+ else if (VG_CLO_STREQ(arg, "--happens-before=all"))
+ clo_happens_before = 2;
+
+ else if (VG_CLO_STREQ(arg, "--gen-vcg=no"))
+ clo_gen_vcg = 0;
+ else if (VG_CLO_STREQ(arg, "--gen-vcg=yes"))
+ clo_gen_vcg = 1;
+ else if (VG_CLO_STREQ(arg, "--gen-vcg=yes-w-vts"))
+ clo_gen_vcg = 2;
+
+ else if (VG_CLO_STREQ(arg, "--cmp-race-err-addrs=no"))
+ clo_cmp_race_err_addrs = False;
+ else if (VG_CLO_STREQ(arg, "--cmp-race-err-addrs=yes"))
+ clo_cmp_race_err_addrs = True;
+
+ else if (VG_CLO_STREQN(13, arg, "--trace-addr=")) {
+ clo_trace_addr = VG_(atoll16)(&arg[13]);
+ if (clo_trace_level == 0)
+ clo_trace_level = 1;
+ }
+ else VG_BNUM_CLO(arg, "--trace-level", clo_trace_level, 0, 2)
+
+ /* "stuvw" --> stuvw (binary) */
+ else if (VG_CLO_STREQN(18, arg, "--tc-sanity-flags=")) {
+ Int j;
+ char* opt = & arg[18];
+
+ if (5 != VG_(strlen)(opt)) {
+ VG_(message)(Vg_UserMsg,
+ "--tc-sanity-flags argument must have 5 digits");
+ return False;
+ }
+ for (j = 0; j < 5; j++) {
+ if ('0' == opt[j]) { /* do nothing */ }
+ else if ('1' == opt[j]) clo_sanity_flags |= (1 << (5-1-j));
+ else {
+ VG_(message)(Vg_UserMsg, "--tc-sanity-flags argument can "
+ "only contain 0s and 1s");
+ return False;
+ }
+ }
+ if (0) VG_(printf)("XXX sanity flags: 0x%x\n", clo_sanity_flags);
+ }
+
+ else
+ return VG_(replacement_malloc_process_cmd_line_option)(arg);
+
+ return True;
+}
+
+static void hg_print_usage ( void )
+{
+ VG_(printf)(
+" --happens-before=none|threads|all [all] consider no events, thread\n"
+" create/join, create/join/cvsignal/cvwait/semwait/post as sync points\n"
+" --trace-addr=0xXXYYZZ show all state changes for address 0xXXYYZZ\n"
+" --trace-level=0|1|2 verbosity level of --trace-addr [1]\n"
+ );
+ VG_(replacement_malloc_print_usage)();
+}
+
+static void hg_print_debug_usage ( void )
+{
+ VG_(replacement_malloc_print_debug_usage)();
+ VG_(printf)(" --gen-vcg=no|yes|yes-w-vts show happens-before graph "
+ "in .vcg format [no]\n");
+ VG_(printf)(" --cmp-race-err-addrs=no|yes are data addresses in "
+ "race errors significant? [no]\n");
+ VG_(printf)(" --tc-sanity-flags=<XXXXX> sanity check "
+ " at events (X = 0|1) [00000]\n");
+ VG_(printf)(" --tc-sanity-flags values:\n");
+ VG_(printf)(" 10000 after changes to "
+ "lock-order-acquisition-graph\n");
+ VG_(printf)(" 01000 at memory accesses (NB: not curently used)\n");
+ VG_(printf)(" 00100 at mem permission setting for "
+ "ranges >= %d bytes\n", SCE_BIGRANGE_T);
+ VG_(printf)(" 00010 at lock/unlock events\n");
+ VG_(printf)(" 00001 at thread create/join events\n");
+}
+
+static void hg_post_clo_init ( void )
+{
+}
+
+static void hg_fini ( Int exitcode )
+{
+ if (SHOW_DATA_STRUCTURES)
+ pp_everything( PP_ALL, "SK_(fini)" );
+ if (clo_sanity_flags)
+ all__sanity_check("SK_(fini)");
+
+ if (clo_gen_vcg > 0)
+ segments__generate_vcg();
+
+ if (VG_(clo_verbosity) >= 2) {
+
+ if (1) {
+ VG_(printf)("\n");
+ HG_(ppWSUstats)( univ_tsets, "univ_tsets" );
+ VG_(printf)("\n");
+ HG_(ppWSUstats)( univ_lsets, "univ_lsets" );
+ VG_(printf)("\n");
+ HG_(ppWSUstats)( univ_laog, "univ_laog" );
+ }
+
+ VG_(printf)("\n");
+ VG_(printf)(" hbefore: %,10lu queries\n", stats__hbefore_queries);
+ VG_(printf)(" hbefore: %,10lu cache 0 hits\n", stats__hbefore_cache0s);
+ VG_(printf)(" hbefore: %,10lu cache > 0 hits\n", stats__hbefore_cacheNs);
+ VG_(printf)(" hbefore: %,10lu graph searches\n", stats__hbefore_gsearches);
+ VG_(printf)(" hbefore: %,10lu of which slow\n",
+ stats__hbefore_gsearches - stats__hbefore_gsearchFs);
+ VG_(printf)(" hbefore: %,10lu stack high water mark\n",
+ stats__hbefore_stk_hwm);
+ VG_(printf)(" hbefore: %,10lu cache invals\n", stats__hbefore_invals);
+ VG_(printf)(" hbefore: %,10lu probes\n", stats__hbefore_probes);
+
+ VG_(printf)("\n");
+ VG_(printf)(" segments: %,8lu Segment objects allocated\n",
+ stats__mk_Segment);
+ VG_(printf)(" locksets: %,8d unique lock sets\n",
+ (Int)HG_(cardinalityWSU)( univ_lsets ));
+ VG_(printf)(" threadsets: %,8d unique thread sets\n",
+ (Int)HG_(cardinalityWSU)( univ_tsets ));
+ VG_(printf)(" univ_laog: %,8d unique lock sets\n",
+ (Int)HG_(cardinalityWSU)( univ_laog ));
+
+ VG_(printf)("L(ast)L(ock) map: %,8lu inserts (%d map size)\n",
+ stats__ga_LL_adds,
+ (Int)(ga_to_lastlock ? HG_(sizeFM)( ga_to_lastlock ) : 0) );
+
+ VG_(printf)(" LockN-to-P map: %,8lu queries (%d map size)\n",
+ stats__ga_LockN_to_P_queries,
+ (Int)(yaWFM ? HG_(sizeFM)( yaWFM ) : 0) );
+
+ VG_(printf)("string table map: %,8lu queries (%d map size)\n",
+ stats__string_table_queries,
+ (Int)(string_table ? HG_(sizeFM)( string_table ) : 0) );
+ VG_(printf)(" LAOG: %,8d map size\n",
+ (Int)(laog ? HG_(sizeFM)( laog ) : 0));
+ VG_(printf)(" LAOG exposition: %,8d map size\n",
+ (Int)(laog_exposition ? HG_(sizeFM)( laog_exposition ) : 0));
+ VG_(printf)(" locks: %,8lu acquires, "
+ "%,lu releases\n",
+ stats__lockN_acquires,
+ stats__lockN_releases
+ );
+ VG_(printf)(" sanity checks: %,8lu\n", stats__sanity_checks);
+
+ VG_(printf)("\n");
+ VG_(printf)(" msm: %,12lu %,12lu rd/wr_Excl_nochange\n",
+ stats__msm_read_Excl_nochange, stats__msm_write_Excl_nochange);
+ VG_(printf)(" msm: %,12lu %,12lu rd/wr_Excl_transfer\n",
+ stats__msm_read_Excl_transfer, stats__msm_write_Excl_transfer);
+ VG_(printf)(" msm: %,12lu %,12lu rd/wr_Excl_to_ShR/ShM\n",
+ stats__msm_read_Excl_to_ShR, stats__msm_write_Excl_to_ShM);
+ VG_(printf)(" msm: %,12lu %,12lu rd/wr_ShR_to_ShR/ShM\n",
+ stats__msm_read_ShR_to_ShR, stats__msm_write_ShR_to_ShM);
+ VG_(printf)(" msm: %,12lu %,12lu rd/wr_ShM_to_ShM\n",
+ stats__msm_read_ShM_to_ShM, stats__msm_write_ShM_to_ShM);
+ VG_(printf)(" msm: %,12lu %,12lu rd/wr_New_to_Excl\n",
+ stats__msm_read_New_to_Excl, stats__msm_write_New_to_Excl);
+ VG_(printf)(" msm: %,12lu %,12lu rd/wr_NoAccess\n",
+ stats__msm_read_NoAccess, stats__msm_write_NoAccess);
+
+ VG_(printf)("\n");
+ VG_(printf)(" secmaps: %,10lu allocd (%,12lu g-a-range)\n",
+ stats__secmaps_allocd,
+ stats__secmap_ga_space_covered);
+ VG_(printf)(" linesZ: %,10lu allocd (%,12lu bytes occupied)\n",
+ stats__secmap_linesZ_allocd,
+ stats__secmap_linesZ_bytes);
+ VG_(printf)(" linesF: %,10lu allocd (%,12lu bytes occupied)\n",
+ stats__secmap_linesF_allocd,
+ stats__secmap_linesF_bytes);
+ VG_(printf)(" secmaps: %,10lu iterator steppings\n",
+ stats__secmap_iterator_steppings);
+
+ VG_(printf)("\n");
+ VG_(printf)(" cache: %,lu totrefs (%,lu misses)\n",
+ stats__cache_totrefs, stats__cache_totmisses );
+ VG_(printf)(" cache: %,12lu Z-fetch, %,12lu F-fetch\n",
+ stats__cache_Z_fetches, stats__cache_F_fetches );
+ VG_(printf)(" cache: %,12lu Z-wback, %,12lu F-wback\n",
+ stats__cache_Z_wbacks, stats__cache_F_wbacks );
+ VG_(printf)(" cache: %,12lu invals, %,12lu flushes\n",
+ stats__cache_invals, stats__cache_flushes );
+
+ VG_(printf)("\n");
+ VG_(printf)(" cline: %,10lu normalises\n",
+ stats__cline_normalises );
+ VG_(printf)(" cline: reads 8/4/2/1: %,12lu %,12lu %,12lu %,12lu\n",
+ stats__cline_read64s,
+ stats__cline_read32s,
+ stats__cline_read16s,
+ stats__cline_read8s );
+ VG_(printf)(" cline: writes 8/4/2/1: %,12lu %,12lu %,12lu %,12lu\n",
+ stats__cline_write64s,
+ stats__cline_write32s,
+ stats__cline_write16s,
+ stats__cline_write8s );
+ VG_(printf)(" cline: sets 8/4/2/1: %,12lu %,12lu %,12lu %,12lu\n",
+ stats__cline_set64s,
+ stats__cline_set32s,
+ stats__cline_set16s,
+ stats__cline_set8s );
+ VG_(printf)(" cline: get1s %,lu, copy1s %,lu\n",
+ stats__cline_get8s, stats__cline_copy8s );
+ VG_(printf)(" cline: splits: 8to4 %,12lu 4to2 %,12lu 2to1 %,12lu\n",
+ stats__cline_64to32splits,
+ stats__cline_32to16splits,
+ stats__cline_16to8splits );
+ VG_(printf)(" cline: pulldowns: 8to4 %,12lu 4to2 %,12lu 2to1 %,12lu\n",
+ stats__cline_64to32pulldown,
+ stats__cline_32to16pulldown,
+ stats__cline_16to8pulldown );
+
+ VG_(printf)("\n");
+ }
+}
+
+static void hg_pre_clo_init ( void )
+{
+ VG_(details_name) ("Helgrind");
+ VG_(details_version) (NULL);
+ VG_(details_description) ("a thread error detector");
+ VG_(details_copyright_author)(
+ "Copyright (C) 2007-2007, and GNU GPL'd, by OpenWorks LLP et al.");
+ VG_(details_bug_reports_to) (VG_BUGS_TO);
+ VG_(details_avg_translation_sizeB) ( 200 );
+
+ VG_(basic_tool_funcs) (hg_post_clo_init,
+ hg_instrument,
+ hg_fini);
+
+ VG_(needs_core_errors) ();
+ VG_(needs_tool_errors) (hg_eq_Error,
+ hg_pp_Error,
+ False,/*show TIDs for errors*/
+ hg_update_extra,
+ hg_recognised_suppression,
+ hg_read_extra_suppression_info,
+ hg_error_matches_suppression,
+ hg_get_error_name,
+ hg_print_extra_suppression_info);
+
+ VG_(needs_command_line_options)(hg_process_cmd_line_option,
+ hg_print_usage,
+ hg_print_debug_usage);
+ VG_(needs_client_requests) (hg_handle_client_request);
+
+ // FIXME?
+ //VG_(needs_sanity_checks) (hg_cheap_sanity_check,
+ // hg_expensive_sanity_check);
+
+ VG_(needs_malloc_replacement) (hg_cli__malloc,
+ hg_cli____builtin_new,
+ hg_cli____builtin_vec_new,
+ hg_cli__memalign,
+ hg_cli__calloc,
+ hg_cli__free,
+ hg_cli____builtin_delete,
+ hg_cli____builtin_vec_delete,
+ hg_cli__realloc,
+ HG_CLI__MALLOC_REDZONE_SZB );
+
+ VG_(needs_data_syms)();
+
+ //VG_(needs_xml_output) ();
+
+ VG_(track_new_mem_startup) ( evh__new_mem_w_perms );
+ VG_(track_new_mem_stack_signal)( evh__die_mem );
+ VG_(track_new_mem_brk) ( evh__new_mem );
+ VG_(track_new_mem_mmap) ( evh__new_mem_w_perms );
+ VG_(track_new_mem_stack) ( evh__new_mem );
+
+ // FIXME: surely this isn't thread-aware
+ VG_(track_copy_mem_remap) ( shadow_mem_copy_range );
+
+ VG_(track_change_mem_mprotect) ( evh__set_perms );
+
+ VG_(track_die_mem_stack_signal)( evh__die_mem );
+ VG_(track_die_mem_brk) ( evh__die_mem );
+ VG_(track_die_mem_munmap) ( evh__die_mem );
+ VG_(track_die_mem_stack) ( evh__die_mem );
+
+ // FIXME: what is this for?
+ VG_(track_ban_mem_stack) (NULL);
+
+ VG_(track_pre_mem_read) ( evh__pre_mem_read );
+ VG_(track_pre_mem_read_asciiz) ( evh__pre_mem_read_asciiz );
+ VG_(track_pre_mem_write) ( evh__pre_mem_write );
+ VG_(track_post_mem_write) (NULL);
+
+ /////////////////
+
+ VG_(track_pre_thread_ll_create)( evh__pre_thread_ll_create );
+ VG_(track_pre_thread_ll_exit) ( evh__pre_thread_ll_exit );
+
+ VG_(track_start_client_code)( evh__start_client_code );
+ VG_(track_stop_client_code)( evh__stop_client_code );
+
+ initialise_data_structures();
+
+ /* Ensure that requirements for "dodgy C-as-C++ style inheritance"
+ as described in comments at the top of pub_tool_hashtable.h, are
+ met. Blargh. */
+ tl_assert( sizeof(void*) == sizeof(struct _MallocMeta*) );
+ tl_assert( sizeof(UWord) == sizeof(Addr) );
+ hg_mallocmeta_table
+ = VG_(HT_construct)( "hg_malloc_metadata_table" );
+
+ /* a SecMap must contain an integral number of CacheLines */
+ tl_assert(0 == (N_SECMAP_ARANGE % N_LINE_ARANGE));
+ /* also ... a CacheLine holds an integral number of trees */
+ tl_assert(0 == (N_LINE_ARANGE % 8));
+}
+
+VG_DETERMINE_INTERFACE_VERSION(hg_pre_clo_init)
+
+/*--------------------------------------------------------------------*/
+/*--- end hg_main.c ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/hg_wordfm.c b/helgrind/hg_wordfm.c
new file mode 100644
index 0000000..b839a38
--- /dev/null
+++ b/helgrind/hg_wordfm.c
@@ -0,0 +1,834 @@
+
+/*--------------------------------------------------------------------*/
+/*--- An AVL tree based finite map for word keys and word values. ---*/
+/*--- Inspired by Haskell's "FiniteMap" library. ---*/
+/*--- hg_wordfm.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+ This file is part of Helgrind, a Valgrind tool for detecting errors
+ in threaded programs.
+
+ Copyright (C) 2007-2007 Julian Seward
+ jseward@acm.org
+
+ This code is based on previous work by Nicholas Nethercote
+ (coregrind/m_oset.c) which is
+
+ Copyright (C) 2005-2007 Nicholas Nethercote
+ njn@valgrind.org
+
+ which in turn was derived partially from:
+
+ AVL C library
+ Copyright (C) 2000,2002 Daniel Nagy
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+ [...]
+
+ (taken from libavl-0.4/debian/copyright)
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307, USA.
+
+ The GNU General Public License is contained in the file COPYING.
+*/
+
+#include "pub_tool_basics.h"
+#include "pub_tool_libcassert.h"
+#include "pub_tool_libcbase.h"
+
+#define HG_(str) VGAPPEND(vgHelgrind_,str)
+#include "hg_wordfm.h"
+
+//------------------------------------------------------------------//
+//--- WordFM ---//
+//--- Implementation ---//
+//------------------------------------------------------------------//
+
+/* One element of the AVL tree */
+typedef
+ struct _AvlNode {
+ Word key;
+ Word val;
+ struct _AvlNode* child[2]; /* [0] is left subtree, [1] is right */
+ Char balance; /* do not make this unsigned */
+ }
+ AvlNode;
+
+typedef
+ struct {
+ Word w;
+ Bool b;
+ }
+ MaybeWord;
+
+#define WFM_STKMAX 32 // At most 2**32 entries can be iterated over
+
+struct _WordFM {
+ AvlNode* root;
+ void* (*alloc_nofail)( SizeT );
+ void (*dealloc)(void*);
+ Word (*kCmp)(Word,Word);
+ AvlNode* nodeStack[WFM_STKMAX]; // Iterator node stack
+ Int numStack[WFM_STKMAX]; // Iterator num stack
+ Int stackTop; // Iterator stack pointer, one past end
+};
+
+/* forward */
+static Bool avl_removeroot_wrk(AvlNode** t, Word(*kCmp)(Word,Word));
+
+/* Swing to the left. Warning: no balance maintainance. */
+static void avl_swl ( AvlNode** root )
+{
+ AvlNode* a = *root;
+ AvlNode* b = a->child[1];
+ *root = b;
+ a->child[1] = b->child[0];
+ b->child[0] = a;
+}
+
+/* Swing to the right. Warning: no balance maintainance. */
+static void avl_swr ( AvlNode** root )
+{
+ AvlNode* a = *root;
+ AvlNode* b = a->child[0];
+ *root = b;
+ a->child[0] = b->child[1];
+ b->child[1] = a;
+}
+
+/* Balance maintainance after especially nasty swings. */
+static void avl_nasty ( AvlNode* root )
+{
+ switch (root->balance) {
+ case -1:
+ root->child[0]->balance = 0;
+ root->child[1]->balance = 1;
+ break;
+ case 1:
+ root->child[0]->balance = -1;
+ root->child[1]->balance = 0;
+ break;
+ case 0:
+ root->child[0]->balance = 0;
+ root->child[1]->balance = 0;
+ break;
+ default:
+ tl_assert(0);
+ }
+ root->balance=0;
+}
+
+/* Find size of a non-NULL tree. */
+static Word size_avl_nonNull ( AvlNode* nd )
+{
+ return 1 + (nd->child[0] ? size_avl_nonNull(nd->child[0]) : 0)
+ + (nd->child[1] ? size_avl_nonNull(nd->child[1]) : 0);
+}
+
+/* Insert element a into the AVL tree t. Returns True if the depth of
+ the tree has grown. If element with that key is already present,
+ just copy a->val to existing node, first returning old ->val field
+ of existing node in *oldV, so that the caller can finalize it
+ however it wants.
+*/
+static
+Bool avl_insert_wrk ( AvlNode** rootp,
+ /*OUT*/MaybeWord* oldV,
+ AvlNode* a,
+ Word (*kCmp)(Word,Word) )
+{
+ Word cmpres;
+
+ /* initialize */
+ a->child[0] = 0;
+ a->child[1] = 0;
+ a->balance = 0;
+ oldV->b = False;
+
+ /* insert into an empty tree? */
+ if (!(*rootp)) {
+ (*rootp) = a;
+ return True;
+ }
+
+ cmpres = kCmp ? /*boxed*/ kCmp( (*rootp)->key, a->key )
+ : /*unboxed*/ ((Word)(*rootp)->key) - ((Word)a->key);
+
+ if (cmpres > 0) {
+ /* insert into the left subtree */
+ if ((*rootp)->child[0]) {
+ AvlNode* left_subtree = (*rootp)->child[0];
+ if (avl_insert_wrk(&left_subtree, oldV, a, kCmp)) {
+ switch ((*rootp)->balance--) {
+ case 1: return False;
+ case 0: return True;
+ case -1: break;
+ default: tl_assert(0);
+ }
+ if ((*rootp)->child[0]->balance < 0) {
+ avl_swr( rootp );
+ (*rootp)->balance = 0;
+ (*rootp)->child[1]->balance = 0;
+ } else {
+ avl_swl( &((*rootp)->child[0]) );
+ avl_swr( rootp );
+ avl_nasty( *rootp );
+ }
+ } else {
+ (*rootp)->child[0] = left_subtree;
+ }
+ return False;
+ } else {
+ (*rootp)->child[0] = a;
+ if ((*rootp)->balance--)
+ return False;
+ return True;
+ }
+ tl_assert(0);/*NOTREACHED*/
+ }
+ else
+ if (cmpres < 0) {
+ /* insert into the right subtree */
+ if ((*rootp)->child[1]) {
+ AvlNode* right_subtree = (*rootp)->child[1];
+ if (avl_insert_wrk(&right_subtree, oldV, a, kCmp)) {
+ switch((*rootp)->balance++){
+ case -1: return False;
+ case 0: return True;
+ case 1: break;
+ default: tl_assert(0);
+ }
+ if ((*rootp)->child[1]->balance > 0) {
+ avl_swl( rootp );
+ (*rootp)->balance = 0;
+ (*rootp)->child[0]->balance = 0;
+ } else {
+ avl_swr( &((*rootp)->child[1]) );
+ avl_swl( rootp );
+ avl_nasty( *rootp );
+ }
+ } else {
+ (*rootp)->child[1] = right_subtree;
+ }
+ return False;
+ } else {
+ (*rootp)->child[1] = a;
+ if ((*rootp)->balance++)
+ return False;
+ return True;
+ }
+ tl_assert(0);/*NOTREACHED*/
+ }
+ else {
+ /* cmpres == 0, a duplicate - replace the val, but don't
+ incorporate the node in the tree */
+ oldV->b = True;
+ oldV->w = (*rootp)->val;
+ (*rootp)->val = a->val;
+ return False;
+ }
+}
+
+/* Remove an element a from the AVL tree t. a must be part of
+ the tree. Returns True if the depth of the tree has shrunk.
+*/
+static
+Bool avl_remove_wrk ( AvlNode** rootp,
+ AvlNode* a,
+ Word(*kCmp)(Word,Word) )
+{
+ Bool ch;
+ Word cmpres;
+ cmpres = kCmp ? /*boxed*/ kCmp( (*rootp)->key, a->key )
+ : /*unboxed*/ ((Word)(*rootp)->key) - ((Word)a->key);
+
+ if (cmpres > 0){
+ /* remove from the left subtree */
+ AvlNode* left_subtree = (*rootp)->child[0];
+ tl_assert(left_subtree);
+ ch = avl_remove_wrk(&left_subtree, a, kCmp);
+ (*rootp)->child[0]=left_subtree;
+ if (ch) {
+ switch ((*rootp)->balance++) {
+ case -1: return True;
+ case 0: return False;
+ case 1: break;
+ default: tl_assert(0);
+ }
+ switch ((*rootp)->child[1]->balance) {
+ case 0:
+ avl_swl( rootp );
+ (*rootp)->balance = -1;
+ (*rootp)->child[0]->balance = 1;
+ return False;
+ case 1:
+ avl_swl( rootp );
+ (*rootp)->balance = 0;
+ (*rootp)->child[0]->balance = 0;
+ return True;
+ case -1:
+ break;
+ default:
+ tl_assert(0);
+ }
+ avl_swr( &((*rootp)->child[1]) );
+ avl_swl( rootp );
+ avl_nasty( *rootp );
+ return True;
+ }
+ }
+ else
+ if (cmpres < 0) {
+ /* remove from the right subtree */
+ AvlNode* right_subtree = (*rootp)->child[1];
+ tl_assert(right_subtree);
+ ch = avl_remove_wrk(&right_subtree, a, kCmp);
+ (*rootp)->child[1] = right_subtree;
+ if (ch) {
+ switch ((*rootp)->balance--) {
+ case 1: return True;
+ case 0: return False;
+ case -1: break;
+ default: tl_assert(0);
+ }
+ switch ((*rootp)->child[0]->balance) {
+ case 0:
+ avl_swr( rootp );
+ (*rootp)->balance = 1;
+ (*rootp)->child[1]->balance = -1;
+ return False;
+ case -1:
+ avl_swr( rootp );
+ (*rootp)->balance = 0;
+ (*rootp)->child[1]->balance = 0;
+ return True;
+ case 1:
+ break;
+ default:
+ tl_assert(0);
+ }
+ avl_swl( &((*rootp)->child[0]) );
+ avl_swr( rootp );
+ avl_nasty( *rootp );
+ return True;
+ }
+ }
+ else {
+ tl_assert(cmpres == 0);
+ tl_assert((*rootp)==a);
+ return avl_removeroot_wrk(rootp, kCmp);
+ }
+ return 0;
+}
+
+/* Remove the root of the AVL tree *rootp.
+ * Warning: dumps core if *rootp is empty
+ */
+static
+Bool avl_removeroot_wrk ( AvlNode** rootp,
+ Word(*kCmp)(Word,Word) )
+{
+ Bool ch;
+ AvlNode* a;
+ if (!(*rootp)->child[0]) {
+ if (!(*rootp)->child[1]) {
+ (*rootp) = 0;
+ return True;
+ }
+ (*rootp) = (*rootp)->child[1];
+ return True;
+ }
+ if (!(*rootp)->child[1]) {
+ (*rootp) = (*rootp)->child[0];
+ return True;
+ }
+ if ((*rootp)->balance < 0) {
+ /* remove from the left subtree */
+ a = (*rootp)->child[0];
+ while (a->child[1]) a = a->child[1];
+ } else {
+ /* remove from the right subtree */
+ a = (*rootp)->child[1];
+ while (a->child[0]) a = a->child[0];
+ }
+ ch = avl_remove_wrk(rootp, a, kCmp);
+ a->child[0] = (*rootp)->child[0];
+ a->child[1] = (*rootp)->child[1];
+ a->balance = (*rootp)->balance;
+ (*rootp) = a;
+ if(a->balance == 0) return ch;
+ return False;
+}
+
+static
+AvlNode* avl_find_node ( AvlNode* t, Word k, Word(*kCmp)(Word,Word) )
+{
+ if (kCmp) {
+ /* Boxed comparisons */
+ Word cmpres;
+ while (True) {
+ if (t == NULL) return NULL;
+ cmpres = kCmp(t->key, k);
+ if (cmpres > 0) t = t->child[0]; else
+ if (cmpres < 0) t = t->child[1]; else
+ return t;
+ }
+ } else {
+ /* Unboxed comparisons */
+ Word cmpres; /* signed */
+ UWord cmpresU; /* unsigned */
+ while (True) {
+ if (t == NULL) return NULL; /* unlikely ==> predictable */
+ cmpres = ((Word)t->key) - ((Word)k);
+ if (cmpres == 0) return t; /* unlikely ==> predictable */
+ cmpresU = (UWord)cmpres;
+ cmpresU >>=/*unsigned*/ (8 * sizeof(cmpres) - 1);
+ t = t->child[cmpresU];
+ }
+ }
+}
+
+// Clear the iterator stack.
+static void stackClear(WordFM* fm)
+{
+ Int i;
+ tl_assert(fm);
+ for (i = 0; i < WFM_STKMAX; i++) {
+ fm->nodeStack[i] = NULL;
+ fm->numStack[i] = 0;
+ }
+ fm->stackTop = 0;
+}
+
+// Push onto the iterator stack.
+static inline void stackPush(WordFM* fm, AvlNode* n, Int i)
+{
+ tl_assert(fm->stackTop < WFM_STKMAX);
+ tl_assert(1 <= i && i <= 3);
+ fm->nodeStack[fm->stackTop] = n;
+ fm-> numStack[fm->stackTop] = i;
+ fm->stackTop++;
+}
+
+// Pop from the iterator stack.
+static inline Bool stackPop(WordFM* fm, AvlNode** n, Int* i)
+{
+ tl_assert(fm->stackTop <= WFM_STKMAX);
+
+ if (fm->stackTop > 0) {
+ fm->stackTop--;
+ *n = fm->nodeStack[fm->stackTop];
+ *i = fm-> numStack[fm->stackTop];
+ tl_assert(1 <= *i && *i <= 3);
+ fm->nodeStack[fm->stackTop] = NULL;
+ fm-> numStack[fm->stackTop] = 0;
+ return True;
+ } else {
+ return False;
+ }
+}
+
+static
+AvlNode* avl_dopy ( AvlNode* nd,
+ Word(*dopyK)(Word),
+ Word(*dopyV)(Word),
+ void*(alloc_nofail)(SizeT) )
+{
+ AvlNode* nyu;
+ if (! nd)
+ return NULL;
+ nyu = alloc_nofail(sizeof(AvlNode));
+ tl_assert(nyu);
+
+ nyu->child[0] = nd->child[0];
+ nyu->child[1] = nd->child[1];
+ nyu->balance = nd->balance;
+
+ /* Copy key */
+ if (dopyK) {
+ nyu->key = dopyK( nd->key );
+ if (nd->key != 0 && nyu->key == 0)
+ return NULL; /* oom in key dcopy */
+ } else {
+ /* copying assumedly unboxed keys */
+ nyu->key = nd->key;
+ }
+
+ /* Copy val */
+ if (dopyV) {
+ nyu->val = dopyV( nd->val );
+ if (nd->val != 0 && nyu->val == 0)
+ return NULL; /* oom in val dcopy */
+ } else {
+ /* copying assumedly unboxed vals */
+ nyu->val = nd->val;
+ }
+
+ /* Copy subtrees */
+ if (nyu->child[0]) {
+ nyu->child[0] = avl_dopy( nyu->child[0], dopyK, dopyV, alloc_nofail );
+ if (! nyu->child[0])
+ return NULL;
+ }
+ if (nyu->child[1]) {
+ nyu->child[1] = avl_dopy( nyu->child[1], dopyK, dopyV, alloc_nofail );
+ if (! nyu->child[1])
+ return NULL;
+ }
+
+ return nyu;
+}
+
+/* Initialise a WordFM. */
+static void initFM ( WordFM* fm,
+ void* (*alloc_nofail)( SizeT ),
+ void (*dealloc)(void*),
+ Word (*kCmp)(Word,Word) )
+{
+ fm->root = 0;
+ fm->kCmp = kCmp;
+ fm->alloc_nofail = alloc_nofail;
+ fm->dealloc = dealloc;
+ fm->stackTop = 0;
+}
+
+/* --- Public interface functions --- */
+
+/* Allocate and Initialise a WordFM. */
+WordFM* HG_(newFM) ( void* (*alloc_nofail)( SizeT ),
+ void (*dealloc)(void*),
+ Word (*kCmp)(Word,Word) )
+{
+ WordFM* fm = alloc_nofail(sizeof(WordFM));
+ tl_assert(fm);
+ initFM(fm, alloc_nofail, dealloc, kCmp);
+ return fm;
+}
+
+static void avl_free ( AvlNode* nd,
+ void(*kFin)(Word),
+ void(*vFin)(Word),
+ void(*dealloc)(void*) )
+{
+ if (!nd)
+ return;
+ if (nd->child[0])
+ avl_free(nd->child[0], kFin, vFin, dealloc);
+ if (nd->child[1])
+ avl_free(nd->child[1], kFin, vFin, dealloc);
+ if (kFin)
+ kFin( nd->key );
+ if (vFin)
+ vFin( nd->val );
+ VG_(memset)(nd, 0, sizeof(AvlNode));
+ dealloc(nd);
+}
+
+/* Free up the FM. If kFin is non-NULL, it is applied to keys
+ before the FM is deleted; ditto with vFin for vals. */
+void HG_(deleteFM) ( WordFM* fm, void(*kFin)(Word), void(*vFin)(Word) )
+{
+ void(*dealloc)(void*) = fm->dealloc;
+ avl_free( fm->root, kFin, vFin, dealloc );
+ VG_(memset)(fm, 0, sizeof(WordFM) );
+ dealloc(fm);
+}
+
+/* Add (k,v) to fm. */
+void HG_(addToFM) ( WordFM* fm, Word k, Word v )
+{
+ MaybeWord oldV;
+ AvlNode* node;
+ node = fm->alloc_nofail( sizeof(struct _AvlNode) );
+ node->key = k;
+ node->val = v;
+ oldV.b = False;
+ oldV.w = 0;
+ avl_insert_wrk( &fm->root, &oldV, node, fm->kCmp );
+ //if (oldV.b && fm->vFin)
+ // fm->vFin( oldV.w );
+ if (oldV.b)
+ fm->dealloc(node);
+}
+
+// Delete key from fm, returning associated key and val if found
+Bool HG_(delFromFM) ( WordFM* fm,
+ /*OUT*/Word* oldK, /*OUT*/Word* oldV, Word key )
+{
+ AvlNode* node = avl_find_node( fm->root, key, fm->kCmp );
+ if (node) {
+ avl_remove_wrk( &fm->root, node, fm->kCmp );
+ if (oldK)
+ *oldK = node->key;
+ if (oldV)
+ *oldV = node->val;
+ fm->dealloc(node);
+ return True;
+ } else {
+ return False;
+ }
+}
+
+// Look up in fm, assigning found key & val at spec'd addresses
+Bool HG_(lookupFM) ( WordFM* fm,
+ /*OUT*/Word* keyP, /*OUT*/Word* valP, Word key )
+{
+ AvlNode* node = avl_find_node( fm->root, key, fm->kCmp );
+ if (node) {
+ if (keyP)
+ *keyP = node->key;
+ if (valP)
+ *valP = node->val;
+ return True;
+ } else {
+ return False;
+ }
+}
+
+Word HG_(sizeFM) ( WordFM* fm )
+{
+ // Hmm, this is a bad way to do this
+ return fm->root ? size_avl_nonNull( fm->root ) : 0;
+}
+
+// set up FM for iteration
+void HG_(initIterFM) ( WordFM* fm )
+{
+ tl_assert(fm);
+ stackClear(fm);
+ if (fm->root)
+ stackPush(fm, fm->root, 1);
+}
+
+// get next key/val pair. Will tl_assert if fm has been modified
+// or looked up in since initIterFM was called.
+Bool HG_(nextIterFM) ( WordFM* fm, /*OUT*/Word* pKey, /*OUT*/Word* pVal )
+{
+ Int i = 0;
+ AvlNode* n = NULL;
+
+ tl_assert(fm);
+
+ // This in-order traversal requires each node to be pushed and popped
+ // three times. These could be avoided by updating nodes in-situ on the
+ // top of the stack, but the push/pop cost is so small that it's worth
+ // keeping this loop in this simpler form.
+ while (stackPop(fm, &n, &i)) {
+ switch (i) {
+ case 1: case_1:
+ stackPush(fm, n, 2);
+ /* if (n->child[0]) stackPush(fm, n->child[0], 1); */
+ if (n->child[0]) { n = n->child[0]; goto case_1; }
+ break;
+ case 2:
+ stackPush(fm, n, 3);
+ if (pKey) *pKey = n->key;
+ if (pVal) *pVal = n->val;
+ return True;
+ case 3:
+ /* if (n->child[1]) stackPush(fm, n->child[1], 1); */
+ if (n->child[1]) { n = n->child[1]; goto case_1; }
+ break;
+ default:
+ tl_assert(0);
+ }
+ }
+
+ // Stack empty, iterator is exhausted, return NULL
+ return False;
+}
+
+// clear the I'm iterating flag
+void HG_(doneIterFM) ( WordFM* fm )
+{
+}
+
+WordFM* HG_(dopyFM) ( WordFM* fm, Word(*dopyK)(Word), Word(*dopyV)(Word) )
+{
+ WordFM* nyu;
+
+ /* can't clone the fm whilst iterating on it */
+ tl_assert(fm->stackTop == 0);
+
+ nyu = fm->alloc_nofail( sizeof(WordFM) );
+ tl_assert(nyu);
+
+ *nyu = *fm;
+
+ fm->stackTop = 0;
+ VG_(memset)(fm->nodeStack, 0, sizeof(fm->nodeStack));
+ VG_(memset)(fm->numStack, 0, sizeof(fm->numStack));
+
+ if (nyu->root) {
+ nyu->root = avl_dopy( nyu->root, dopyK, dopyV, fm->alloc_nofail );
+ if (! nyu->root)
+ return NULL;
+ }
+
+ return nyu;
+}
+
+//------------------------------------------------------------------//
+//--- end WordFM ---//
+//--- Implementation ---//
+//------------------------------------------------------------------//
+
+//------------------------------------------------------------------//
+//--- WordBag (unboxed words only) ---//
+//--- Implementation ---//
+//------------------------------------------------------------------//
+
+/* A trivial container, to make it opaque. */
+struct _WordBag {
+ WordFM* fm;
+};
+
+WordBag* HG_(newBag) ( void* (*alloc_nofail)( SizeT ),
+ void (*dealloc)(void*) )
+{
+ WordBag* bag = alloc_nofail(sizeof(WordBag));
+ bag->fm = HG_(newFM)( alloc_nofail, dealloc, NULL );
+ return bag;
+}
+
+void HG_(deleteBag) ( WordBag* bag )
+{
+ void (*dealloc)(void*) = bag->fm->dealloc;
+ HG_(deleteFM)( bag->fm, NULL, NULL );
+ VG_(memset)(bag, 0, sizeof(WordBag));
+ dealloc(bag);
+}
+
+void HG_(addToBag)( WordBag* bag, Word w )
+{
+ Word key, count;
+ if (HG_(lookupFM)(bag->fm, &key, &count, w)) {
+ tl_assert(key == w);
+ tl_assert(count >= 1);
+ HG_(addToFM)(bag->fm, w, count+1);
+ } else {
+ HG_(addToFM)(bag->fm, w, 1);
+ }
+}
+
+Word HG_(elemBag) ( WordBag* bag, Word w )
+{
+ Word key, count;
+ if (HG_(lookupFM)( bag->fm, &key, &count, w)) {
+ tl_assert(key == w);
+ tl_assert(count >= 1);
+ return count;
+ } else {
+ return 0;
+ }
+}
+
+Word HG_(sizeUniqueBag) ( WordBag* bag )
+{
+ return HG_(sizeFM)( bag->fm );
+}
+
+static Word sizeTotalBag_wrk ( AvlNode* nd )
+{
+ /* unchecked pre: nd is non-NULL */
+ Word w = nd->val;
+ tl_assert(w >= 1);
+ if (nd->child[0])
+ w += sizeTotalBag_wrk(nd->child[0]);
+ if (nd->child[1])
+ w += sizeTotalBag_wrk(nd->child[1]);
+ return w;
+}
+Word HG_(sizeTotalBag)( WordBag* bag )
+{
+ if (bag->fm->root)
+ return sizeTotalBag_wrk(bag->fm->root);
+ else
+ return 0;
+}
+
+Bool HG_(delFromBag)( WordBag* bag, Word w )
+{
+ Word key, count;
+ if (HG_(lookupFM)(bag->fm, &key, &count, w)) {
+ tl_assert(key == w);
+ tl_assert(count >= 1);
+ if (count > 1) {
+ HG_(addToFM)(bag->fm, w, count-1);
+ } else {
+ tl_assert(count == 1);
+ HG_(delFromFM)( bag->fm, NULL, NULL, w );
+ }
+ return True;
+ } else {
+ return False;
+ }
+}
+
+Bool HG_(isEmptyBag)( WordBag* bag )
+{
+ return HG_(sizeFM)(bag->fm) == 0;
+}
+
+Bool HG_(isSingletonTotalBag)( WordBag* bag )
+{
+ AvlNode* nd;
+ if (HG_(sizeFM)(bag->fm) != 1)
+ return False;
+ nd = bag->fm->root;
+ tl_assert(nd);
+ tl_assert(!nd->child[0]);
+ tl_assert(!nd->child[1]);
+ return nd->val == 1;
+}
+
+Word HG_(anyElementOfBag)( WordBag* bag )
+{
+ /* Return an arbitrarily chosen element in the bag. We might as
+ well return the one at the root of the underlying AVL tree. */
+ AvlNode* nd = bag->fm->root;
+ tl_assert(nd); /* if this fails, 'bag' is empty - caller is in error. */
+ tl_assert(nd->val >= 1);
+ return nd->key;
+}
+
+void HG_(initIterBag)( WordBag* bag )
+{
+ HG_(initIterFM)(bag->fm);
+}
+
+Bool HG_(nextIterBag)( WordBag* bag, /*OUT*/Word* pVal, /*OUT*/Word* pCount )
+{
+ return HG_(nextIterFM)( bag->fm, pVal, pCount );
+}
+
+void HG_(doneIterBag)( WordBag* bag )
+{
+ HG_(doneIterFM)( bag->fm );
+}
+
+//------------------------------------------------------------------//
+//--- end WordBag (unboxed words only) ---//
+//--- Implementation ---//
+//------------------------------------------------------------------//
+
+/*--------------------------------------------------------------------*/
+/*--- end hg_wordfm.c ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/hg_wordfm.h b/helgrind/hg_wordfm.h
new file mode 100644
index 0000000..cd8f542
--- /dev/null
+++ b/helgrind/hg_wordfm.h
@@ -0,0 +1,162 @@
+
+/*--------------------------------------------------------------------*/
+/*--- An AVL tree based finite map for word keys and word values. ---*/
+/*--- Inspired by Haskell's "FiniteMap" library. ---*/
+/*--- hg_wordfm.h ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+ This file is part of Helgrind, a Valgrind tool for detecting errors
+ in threaded programs.
+
+ Copyright (C) 2007-2007 Julian Seward
+ jseward@acm.org
+
+ This code is based on previous work by Nicholas Nethercote
+ (coregrind/m_oset.c) which is
+
+ Copyright (C) 2005-2007 Nicholas Nethercote
+ njn@valgrind.org
+
+ which in turn was derived partially from:
+
+ AVL C library
+ Copyright (C) 2000,2002 Daniel Nagy
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+ [...]
+
+ (taken from libavl-0.4/debian/copyright)
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307, USA.
+
+ The GNU General Public License is contained in the file COPYING.
+*/
+
+#ifndef __HG_WORDFM_H
+#define __HG_WORDFM_H
+
+//------------------------------------------------------------------//
+//--- WordFM ---//
+//--- Public interface ---//
+//------------------------------------------------------------------//
+
+typedef struct _WordFM WordFM; /* opaque */
+
+/* Allocate and initialise a WordFM */
+WordFM* HG_(newFM) ( void* (*alloc_nofail)( SizeT ),
+ void (*dealloc)(void*),
+ Word (*kCmp)(Word,Word) );
+
+/* Free up the FM. If kFin is non-NULL, it is applied to keys
+ before the FM is deleted; ditto with vFin for vals. */
+void HG_(deleteFM) ( WordFM*, void(*kFin)(Word), void(*vFin)(Word) );
+
+/* Add (k,v) to fm. If a binding for k already exists, it is updated
+ to map to this new v. In that case we should really return the
+ previous v so that caller can finalise it. Oh well. */
+void HG_(addToFM) ( WordFM* fm, Word k, Word v );
+
+// Delete key from fm, returning associated key and val if found
+Bool HG_(delFromFM) ( WordFM* fm,
+ /*OUT*/Word* oldK, /*OUT*/Word* oldV, Word key );
+
+// Look up in fm, assigning found key & val at spec'd addresses
+Bool HG_(lookupFM) ( WordFM* fm,
+ /*OUT*/Word* keyP, /*OUT*/Word* valP, Word key );
+
+// How many elements are there in fm?
+Word HG_(sizeFM) ( WordFM* fm );
+
+// set up FM for iteration
+void HG_(initIterFM) ( WordFM* fm );
+
+// get next key/val pair. Will assert if fm has been modified
+// or looked up in since initIterFM was called.
+Bool HG_(nextIterFM) ( WordFM* fm,
+ /*OUT*/Word* pKey, /*OUT*/Word* pVal );
+
+// clear the I'm iterating flag
+void HG_(doneIterFM) ( WordFM* fm );
+
+// Deep copy a FM. If dopyK is NULL, keys are copied verbatim.
+// If non-null, dopyK is applied to each key to generate the
+// version in the new copy. In that case, if the argument to dopyK
+// is non-NULL but the result is NULL, it is assumed that dopyK
+// could not allocate memory, in which case the copy is abandoned
+// and NULL is returned. Ditto with dopyV for values.
+WordFM* HG_(dopyFM) ( WordFM* fm,
+ Word(*dopyK)(Word), Word(*dopyV)(Word) );
+
+//------------------------------------------------------------------//
+//--- end WordFM ---//
+//--- Public interface ---//
+//------------------------------------------------------------------//
+
+//------------------------------------------------------------------//
+//--- WordBag (unboxed words only) ---//
+//--- Public interface ---//
+//------------------------------------------------------------------//
+
+typedef struct _WordBag WordBag; /* opaque */
+
+/* Allocate and initialise a WordBag */
+WordBag* HG_(newBag) ( void* (*alloc_nofail)( SizeT ),
+ void (*dealloc)(void*) );
+
+/* Free up the Bag. */
+void HG_(deleteBag) ( WordBag* );
+
+/* Add a word. */
+void HG_(addToBag)( WordBag*, Word );
+
+/* Find out how many times the given word exists in the bag. */
+Word HG_(elemBag) ( WordBag*, Word );
+
+/* Delete a word from the bag. */
+Bool HG_(delFromBag)( WordBag*, Word );
+
+/* Is the bag empty? */
+Bool HG_(isEmptyBag)( WordBag* );
+
+/* Does the bag have exactly one element? */
+Bool HG_(isSingletonTotalBag)( WordBag* );
+
+/* Return an arbitrary element from the bag. */
+Word HG_(anyElementOfBag)( WordBag* );
+
+/* How many different / total elements are in the bag? */
+Word HG_(sizeUniqueBag)( WordBag* ); /* fast */
+Word HG_(sizeTotalBag)( WordBag* ); /* warning: slow */
+
+/* Iterating over the elements of a bag. */
+void HG_(initIterBag)( WordBag* );
+Bool HG_(nextIterBag)( WordBag*, /*OUT*/Word* pVal, /*OUT*/Word* pCount );
+void HG_(doneIterBag)( WordBag* );
+
+//------------------------------------------------------------------//
+//--- end WordBag (unboxed words only) ---//
+//--- Public interface ---//
+//------------------------------------------------------------------//
+
+#endif /* ! __HG_WORDFM_H */
+
+/*--------------------------------------------------------------------*/
+/*--- end hg_wordfm.h ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/hg_wordset.c b/helgrind/hg_wordset.c
new file mode 100644
index 0000000..ed9a5b8
--- /dev/null
+++ b/helgrind/hg_wordset.c
@@ -0,0 +1,854 @@
+
+/*--------------------------------------------------------------------*/
+/*--- Sets of words, with unique set identifiers. ---*/
+/*--- hg_wordset.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+ This file is part of Helgrind, a Valgrind tool for detecting errors
+ in threaded programs.
+
+ Copyright (C) 2007-2007 OpenWorks LLP
+ info@open-works.co.uk
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307, USA.
+
+ The GNU General Public License is contained in the file COPYING.
+
+ Neither the names of the U.S. Department of Energy nor the
+ University of California nor the names of its contributors may be
+ used to endorse or promote products derived from this software
+ without prior written permission.
+*/
+
+#include "pub_tool_basics.h"
+#include "pub_tool_libcassert.h"
+#include "pub_tool_libcbase.h"
+#include "pub_tool_libcprint.h"
+
+#define HG_(str) VGAPPEND(vgHelgrind_,str)
+#include "hg_wordfm.h"
+#include "hg_wordset.h"
+
+//------------------------------------------------------------------//
+//--- Word Cache ---//
+//------------------------------------------------------------------//
+
+typedef
+ struct { UWord arg1; UWord arg2; UWord res; }
+ WCacheEnt;
+
+/* Each cache is a fixed sized array of N_WCACHE_STAT_MAX entries.
+ However only the first .dynMax are used. This is because at some
+ point, expanding the cache further overall gives a slowdown because
+ searching more entries more than negates any performance advantage
+ from caching those entries in the first place. Hence use .dynMax
+ to allow the size of the cache(s) to be set differently for each
+ different WordSetU. */
+#define N_WCACHE_STAT_MAX 32
+typedef
+ struct {
+ WCacheEnt ent[N_WCACHE_STAT_MAX];
+ Word dynMax; /* 1 .. N_WCACHE_STAT_MAX inclusive */
+ Word inUse; /* 0 .. dynMax inclusive */
+ }
+ WCache;
+
+#define WCache_INIT(_zzcache,_zzdynmax) \
+ do { \
+ tl_assert((_zzdynmax) >= 1); \
+ tl_assert((_zzdynmax) <= N_WCACHE_STAT_MAX); \
+ (_zzcache).dynMax = (_zzdynmax); \
+ (_zzcache).inUse = 0; \
+ } while (0)
+
+#define WCache_LOOKUP_AND_RETURN(_retty,_zzcache,_zzarg1,_zzarg2) \
+ do { \
+ Word _i; \
+ UWord _arg1 = (UWord)(_zzarg1); \
+ UWord _arg2 = (UWord)(_zzarg2); \
+ WCache* _cache = &(_zzcache); \
+ tl_assert(_cache->dynMax >= 1); \
+ tl_assert(_cache->dynMax <= N_WCACHE_STAT_MAX); \
+ tl_assert(_cache->inUse >= 0); \
+ tl_assert(_cache->inUse <= _cache->dynMax); \
+ if (_cache->inUse > 0) { \
+ if (_cache->ent[0].arg1 == _arg1 \
+ && _cache->ent[0].arg2 == _arg2) \
+ return (_retty)_cache->ent[0].res; \
+ for (_i = 1; _i < _cache->inUse; _i++) { \
+ if (_cache->ent[_i].arg1 == _arg1 \
+ && _cache->ent[_i].arg2 == _arg2) { \
+ WCacheEnt tmp = _cache->ent[_i-1]; \
+ _cache->ent[_i-1] = _cache->ent[_i]; \
+ _cache->ent[_i] = tmp; \
+ return (_retty)_cache->ent[_i-1].res; \
+ } \
+ } \
+ } \
+ } while (0)
+
+#define WCache_UPDATE(_zzcache,_zzarg1,_zzarg2,_zzresult) \
+ do { \
+ Word _i; \
+ UWord _arg1 = (UWord)(_zzarg1); \
+ UWord _arg2 = (UWord)(_zzarg2); \
+ UWord _res = (UWord)(_zzresult); \
+ WCache* _cache = &(_zzcache); \
+ tl_assert(_cache->dynMax >= 1); \
+ tl_assert(_cache->dynMax <= N_WCACHE_STAT_MAX); \
+ tl_assert(_cache->inUse >= 0); \
+ tl_assert(_cache->inUse <= _cache->dynMax); \
+ if (_cache->inUse < _cache->dynMax) \
+ _cache->inUse++; \
+ for (_i = _cache->inUse-1; _i >= 1; _i--) \
+ _cache->ent[_i] = _cache->ent[_i-1]; \
+ _cache->ent[0].arg1 = _arg1; \
+ _cache->ent[0].arg2 = _arg2; \
+ _cache->ent[0].res = _res; \
+ } while (0)
+
+
+//------------------------------------------------------------------//
+//--- WordSet ---//
+//--- Implementation ---//
+//------------------------------------------------------------------//
+
+typedef
+ struct {
+ WordSetU* owner; /* for sanity checking */
+ Word* words;
+ Int size; /* Really this should be SizeT */
+ }
+ WordVec;
+
+/* ix2vec[0 .. ix2vec_used-1] are pointers to the lock sets (WordVecs)
+ really. vec2ix is the inverse mapping, mapping WordVec* to the
+ corresponding ix2vec entry number. The two mappings are mutually
+ redundant. */
+struct _WordSetU {
+ void* (*alloc)(SizeT);
+ void (*dealloc)(void*);
+ WordFM* vec2ix; /* WordVec-to-WordSet mapping tree */
+ WordVec** ix2vec; /* WordSet-to-WordVec mapping array */
+ UInt ix2vec_size;
+ UInt ix2vec_used;
+ WordSet empty; /* cached, for speed */
+ /* Caches for some operations */
+ WCache cache_addTo;
+ WCache cache_delFrom;
+ WCache cache_intersect;
+ WCache cache_minus;
+ /* Stats */
+ UWord n_add;
+ UWord n_add_uncached;
+ UWord n_del;
+ UWord n_del_uncached;
+ UWord n_union;
+ UWord n_intersect;
+ UWord n_intersect_uncached;
+ UWord n_minus;
+ UWord n_minus_uncached;
+ UWord n_elem;
+ UWord n_doubleton;
+ UWord n_isEmpty;
+ UWord n_isSingleton;
+ UWord n_anyElementOf;
+ UWord n_isSubsetOf;
+ };
+
+/* Create a new WordVec of the given size. */
+
+static WordVec* new_WV_of_size ( WordSetU* wsu, Int sz )
+{
+ WordVec* wv;
+ tl_assert(sz >= 0);
+ wv = wsu->alloc( sizeof(WordVec) );
+ wv->owner = wsu;
+ wv->words = NULL;
+ wv->size = sz;
+ if (sz > 0) {
+ wv->words = wsu->alloc( (SizeT)sz * sizeof(Word) );
+ }
+ return wv;
+}
+
+static void delete_WV ( WordVec* wv )
+{
+ void (*dealloc)(void*) = wv->owner->dealloc;
+ if (wv->words) {
+ dealloc(wv->words);
+ }
+ dealloc(wv);
+}
+static void delete_WV_for_FM ( Word wv ) {
+ delete_WV( (WordVec*)wv );
+}
+
+static Word cmp_WordVecs_for_FM ( Word wv1W, Word wv2W )
+{
+ Int i;
+ WordVec* wv1 = (WordVec*)wv1W;
+ WordVec* wv2 = (WordVec*)wv2W;
+ Int common = wv1->size < wv2->size ? wv1->size : wv2->size;
+ for (i = 0; i < common; i++) {
+ if (wv1->words[i] == wv2->words[i])
+ continue;
+ if (wv1->words[i] < wv2->words[i])
+ return -1;
+ if (wv1->words[i] > wv2->words[i])
+ return 1;
+ tl_assert(0);
+ }
+ /* Ok, the common sections are identical. So now consider the
+ tails. Both sets are considered to finish in an implied
+ sequence of -infinity. */
+ if (wv1->size < wv2->size) {
+ tl_assert(common == wv1->size);
+ return -1; /* impliedly, wv1 contains some -infinitys in places
+ where wv2 doesn't. */
+ }
+ if (wv1->size > wv2->size) {
+ tl_assert(common == wv2->size);
+ return 1;
+ }
+ tl_assert(common == wv1->size);
+ return 0; /* identical */
+}
+
+static void ensure_ix2vec_space ( WordSetU* wsu )
+{
+ UInt i, new_sz;
+ WordVec** new_vec;
+ tl_assert(wsu->ix2vec_used <= wsu->ix2vec_size);
+ if (wsu->ix2vec_used < wsu->ix2vec_size)
+ return;
+ new_sz = 2 * wsu->ix2vec_size;
+ if (new_sz == 0) new_sz = 2;
+ new_vec = wsu->alloc( new_sz * sizeof(WordVec*) );
+ tl_assert(new_vec);
+ for (i = 0; i < wsu->ix2vec_size; i++)
+ new_vec[i] = wsu->ix2vec[i];
+ if (wsu->ix2vec)
+ wsu->dealloc(wsu->ix2vec);
+ wsu->ix2vec = new_vec;
+ wsu->ix2vec_size = new_sz;
+}
+
+/* Index into a WordSetU, doing the obvious range check. Failure of
+ the assertions marked XXX and YYY is an indication of passing the
+ wrong WordSetU* in the public API of this module. */
+static WordVec* do_ix2vec ( WordSetU* wsu, WordSet ws )
+{
+ WordVec* wv;
+ tl_assert(wsu->ix2vec_used <= wsu->ix2vec_size);
+ if (wsu->ix2vec_used > 0)
+ tl_assert(wsu->ix2vec);
+ /* If this assertion fails, it may mean you supplied a 'ws'
+ that does not come from the 'wsu' universe. */
+ tl_assert(ws < wsu->ix2vec_used); /* XXX */
+ wv = wsu->ix2vec[ws];
+ /* Make absolutely sure that 'ws' is a member of 'wsu'. */
+ tl_assert(wv);
+ tl_assert(wv->owner == wsu); /* YYY */
+ return wv;
+}
+
+/* See if wv is contained within wsu. If so, deallocate wv and return
+ the index of the already-present copy. If not, add wv to both the
+ vec2ix and ix2vec mappings and return its index.
+*/
+static WordSet add_or_dealloc_WordVec( WordSetU* wsu, WordVec* wv_new )
+{
+ Bool have;
+ WordVec* wv_old;
+ Word/*Set*/ ix_old = -1;
+ /* Really WordSet, but need something that can safely be casted to
+ a Word* in the lookupFM. Making it WordSet (which is 32 bits)
+ causes failures on a 64-bit platform. */
+ tl_assert(wv_new->owner == wsu);
+ have = HG_(lookupFM)( wsu->vec2ix,
+ (Word*)(void*)&wv_old, (Word*)&ix_old,
+ (Word)wv_new );
+ if (have) {
+ tl_assert(wv_old != wv_new);
+ tl_assert(wv_old);
+ tl_assert(wv_old->owner == wsu);
+ tl_assert(ix_old < wsu->ix2vec_used);
+ tl_assert(wsu->ix2vec[ix_old] == wv_old);
+ delete_WV( wv_new );
+ return (WordSet)ix_old;
+ } else {
+ ensure_ix2vec_space( wsu );
+ tl_assert(wsu->ix2vec);
+ tl_assert(wsu->ix2vec_used < wsu->ix2vec_size);
+ wsu->ix2vec[wsu->ix2vec_used] = wv_new;
+ HG_(addToFM)( wsu->vec2ix, (Word)wv_new, (Word)wsu->ix2vec_used );
+ if (0) VG_(printf)("aodW %d\n", (Int)wsu->ix2vec_used );
+ wsu->ix2vec_used++;
+ tl_assert(wsu->ix2vec_used <= wsu->ix2vec_size);
+ return (WordSet)(wsu->ix2vec_used - 1);
+ }
+}
+
+
+WordSetU* HG_(newWordSetU) ( void* (*alloc_nofail)( SizeT ),
+ void (*dealloc)(void*),
+ Word cacheSize )
+{
+ WordSetU* wsu;
+ WordVec* empty;
+
+ wsu = alloc_nofail( sizeof(WordSetU) );
+ VG_(memset)( wsu, 0, sizeof(WordSetU) );
+ wsu->alloc = alloc_nofail;
+ wsu->dealloc = dealloc;
+ wsu->vec2ix = HG_(newFM)( alloc_nofail, dealloc, cmp_WordVecs_for_FM );
+ wsu->ix2vec_used = 0;
+ wsu->ix2vec_size = 0;
+ wsu->ix2vec = NULL;
+ WCache_INIT(wsu->cache_addTo, cacheSize);
+ WCache_INIT(wsu->cache_delFrom, cacheSize);
+ WCache_INIT(wsu->cache_intersect, cacheSize);
+ WCache_INIT(wsu->cache_minus, cacheSize);
+ empty = new_WV_of_size( wsu, 0 );
+ wsu->empty = add_or_dealloc_WordVec( wsu, empty );
+
+ return wsu;
+}
+
+void HG_(deleteWordSetU) ( WordSetU* wsu )
+{
+ void (*dealloc)(void*) = wsu->dealloc;
+ tl_assert(wsu->vec2ix);
+ HG_(deleteFM)( wsu->vec2ix, delete_WV_for_FM, NULL/*val-finalizer*/ );
+ if (wsu->ix2vec)
+ dealloc(wsu->ix2vec);
+ dealloc(wsu);
+}
+
+WordSet HG_(emptyWS) ( WordSetU* wsu )
+{
+ return wsu->empty;
+}
+
+Bool HG_(isEmptyWS) ( WordSetU* wsu, WordSet ws )
+{
+ WordVec* wv = do_ix2vec( wsu, ws );
+ wsu->n_isEmpty++;
+ if (wv->size == 0) {
+ tl_assert(ws == wsu->empty);
+ return True;
+ } else {
+ tl_assert(ws != wsu->empty);
+ return False;
+ }
+}
+
+Bool HG_(isSingletonWS) ( WordSetU* wsu, WordSet ws, Word w )
+{
+ WordVec* wv;
+ tl_assert(wsu);
+ wsu->n_isSingleton++;
+ wv = do_ix2vec( wsu, ws );
+ return (Bool)(wv->size == 1 && wv->words[0] == w);
+}
+
+Int HG_(cardinalityWS) ( WordSetU* wsu, WordSet ws )
+{
+ WordVec* wv;
+ tl_assert(wsu);
+ wv = do_ix2vec( wsu, ws );
+ tl_assert(wv->size >= 0);
+ return wv->size;
+}
+
+Word HG_(anyElementOfWS) ( WordSetU* wsu, WordSet ws )
+{
+ WordVec* wv;
+ tl_assert(wsu);
+ wsu->n_anyElementOf++;
+ wv = do_ix2vec( wsu, ws );
+ tl_assert(wv->size >= 1);
+ return wv->words[0];
+}
+
+Int HG_(cardinalityWSU) ( WordSetU* wsu )
+{
+ tl_assert(wsu);
+ return (Int)wsu->ix2vec_used;
+}
+
+void HG_(getPayloadWS) ( /*OUT*/Word** words, /*OUT*/Word* nWords,
+ WordSetU* wsu, WordSet ws )
+{
+ WordVec* wv;
+ tl_assert(wsu);
+ wv = do_ix2vec( wsu, ws );
+ tl_assert(wv->size >= 0);
+ *nWords = wv->size;
+ *words = wv->words;
+}
+
+Bool HG_(plausibleWS) ( WordSetU* wsu, WordSet ws )
+{
+ if (wsu == NULL) return False;
+ if (ws < 0 || ws >= wsu->ix2vec_used)
+ return False;
+ return True;
+}
+
+Bool HG_(saneWS_SLOW) ( WordSetU* wsu, WordSet ws )
+{
+ WordVec* wv;
+ Int i;
+ if (wsu == NULL) return False;
+ if (ws < 0 || ws >= wsu->ix2vec_used)
+ return False;
+ wv = do_ix2vec( wsu, ws );
+ /* can never happen .. do_ix2vec will assert instead. Oh well. */
+ if (wv->owner != wsu) return False;
+ if (wv->size < 0) return False;
+ if (wv->size > 0) {
+ for (i = 0; i < wv->size-1; i++) {
+ if (wv->words[i] >= wv->words[i+1])
+ return False;
+ }
+ }
+ return True;
+}
+
+Bool HG_(elemWS) ( WordSetU* wsu, WordSet ws, Word w )
+{
+ Int i;
+ WordVec* wv = do_ix2vec( wsu, ws );
+ wsu->n_elem++;
+ for (i = 0; i < wv->size; i++) {
+ if (wv->words[i] == w)
+ return True;
+ }
+ return False;
+}
+
+WordSet HG_(doubletonWS) ( WordSetU* wsu, Word w1, Word w2 )
+{
+ WordVec* wv;
+ wsu->n_doubleton++;
+ if (w1 == w2) {
+ wv = new_WV_of_size(wsu, 1);
+ wv->words[0] = w1;
+ }
+ else if (w1 < w2) {
+ wv = new_WV_of_size(wsu, 2);
+ wv->words[0] = w1;
+ wv->words[1] = w2;
+ }
+ else {
+ tl_assert(w1 > w2);
+ wv = new_WV_of_size(wsu, 2);
+ wv->words[0] = w2;
+ wv->words[1] = w1;
+ }
+ return add_or_dealloc_WordVec( wsu, wv );
+}
+
+WordSet HG_(singletonWS) ( WordSetU* wsu, Word w )
+{
+ return HG_(doubletonWS)( wsu, w, w );
+}
+
+WordSet HG_(isSubsetOf) ( WordSetU* wsu, WordSet small, WordSet big )
+{
+ wsu->n_isSubsetOf++;
+ return small == HG_(intersectWS)( wsu, small, big );
+}
+
+void HG_(ppWS) ( WordSetU* wsu, WordSet ws )
+{
+ Int i;
+ WordVec* wv;
+ tl_assert(wsu);
+ wv = do_ix2vec( wsu, ws );
+ VG_(printf)("{");
+ for (i = 0; i < wv->size; i++) {
+ VG_(printf)("%p", (void*)wv->words[i]);
+ if (i < wv->size-1)
+ VG_(printf)(",");
+ }
+ VG_(printf)("}");
+}
+
+void HG_(ppWSUstats) ( WordSetU* wsu, HChar* name )
+{
+ VG_(printf)(" WordSet \"%s\":\n", name);
+ VG_(printf)(" addTo %10u (%u uncached)\n",
+ wsu->n_add, wsu->n_add_uncached);
+ VG_(printf)(" delFrom %10u (%u uncached)\n",
+ wsu->n_del, wsu->n_del_uncached);
+ VG_(printf)(" union %10u\n", wsu->n_union);
+ VG_(printf)(" intersect %10u (%u uncached) [nb. incl isSubsetOf]\n",
+ wsu->n_intersect, wsu->n_intersect_uncached);
+ VG_(printf)(" minus %10u (%u uncached)\n",
+ wsu->n_minus, wsu->n_minus_uncached);
+ VG_(printf)(" elem %10u\n", wsu->n_elem);
+ VG_(printf)(" doubleton %10u\n", wsu->n_doubleton);
+ VG_(printf)(" isEmpty %10u\n", wsu->n_isEmpty);
+ VG_(printf)(" isSingleton %10u\n", wsu->n_isSingleton);
+ VG_(printf)(" anyElementOf %10u\n", wsu->n_anyElementOf);
+ VG_(printf)(" isSubsetOf %10u\n", wsu->n_isSubsetOf);
+}
+
+WordSet HG_(addToWS) ( WordSetU* wsu, WordSet ws, Word w )
+{
+ Int k, j;
+ WordVec* wv_new;
+ WordVec* wv;
+ WordSet result = (WordSet)(-1); /* bogus */
+
+ wsu->n_add++;
+ WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_addTo, ws, w);
+ wsu->n_add_uncached++;
+
+ /* If already present, this is a no-op. */
+ wv = do_ix2vec( wsu, ws );
+ for (k = 0; k < wv->size; k++) {
+ if (wv->words[k] == w) {
+ result = ws;
+ goto out;
+ }
+ }
+ /* Ok, not present. Build a new one ... */
+ wv_new = new_WV_of_size( wsu, wv->size + 1 );
+ k = j = 0;
+ for (; k < wv->size && wv->words[k] < w; k++) {
+ wv_new->words[j++] = wv->words[k];
+ }
+ wv_new->words[j++] = w;
+ for (; k < wv->size; k++) {
+ tl_assert(wv->words[k] > w);
+ wv_new->words[j++] = wv->words[k];
+ }
+ tl_assert(j == wv_new->size);
+
+ /* Find any existing copy, or add the new one. */
+ result = add_or_dealloc_WordVec( wsu, wv_new );
+ tl_assert(result != (WordSet)(-1));
+
+ out:
+ WCache_UPDATE(wsu->cache_addTo, ws, w, result);
+ return result;
+}
+
+WordSet HG_(delFromWS) ( WordSetU* wsu, WordSet ws, Word w )
+{
+ Int i, j, k;
+ WordVec* wv_new;
+ WordSet result = (WordSet)(-1); /* bogus */
+ WordVec* wv = do_ix2vec( wsu, ws );
+
+ wsu->n_del++;
+
+ /* special case empty set */
+ if (wv->size == 0) {
+ tl_assert(ws == wsu->empty);
+ return ws;
+ }
+
+ WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_delFrom, ws, w);
+ wsu->n_del_uncached++;
+
+ /* If not already present, this is a no-op. */
+ for (i = 0; i < wv->size; i++) {
+ if (wv->words[i] == w)
+ break;
+ }
+ if (i == wv->size) {
+ result = ws;
+ goto out;
+ }
+ /* So w is present in ws, and the new set will be one element
+ smaller. */
+ tl_assert(i >= 0 && i < wv->size);
+ tl_assert(wv->size > 0);
+
+ wv_new = new_WV_of_size( wsu, wv->size - 1 );
+ j = k = 0;
+ for (; j < wv->size; j++) {
+ if (j == i)
+ continue;
+ wv_new->words[k++] = wv->words[j];
+ }
+ tl_assert(k == wv_new->size);
+
+ result = add_or_dealloc_WordVec( wsu, wv_new );
+ if (wv->size == 1) {
+ tl_assert(result == wsu->empty);
+ }
+
+ out:
+ WCache_UPDATE(wsu->cache_delFrom, ws, w, result);
+ return result;
+}
+
+WordSet HG_(unionWS) ( WordSetU* wsu, WordSet ws1, WordSet ws2 )
+{
+ Int i1, i2, k, sz;
+ WordVec* wv_new;
+ WordVec* wv1 = do_ix2vec( wsu, ws1 );
+ WordVec* wv2 = do_ix2vec( wsu, ws2 );
+ wsu->n_union++;
+ sz = 0;
+ i1 = i2 = 0;
+ while (1) {
+ if (i1 >= wv1->size || i2 >= wv2->size)
+ break;
+ sz++;
+ if (wv1->words[i1] < wv2->words[i2]) {
+ i1++;
+ } else
+ if (wv1->words[i1] > wv2->words[i2]) {
+ i2++;
+ } else {
+ i1++;
+ i2++;
+ }
+ }
+ tl_assert(i1 <= wv1->size);
+ tl_assert(i2 <= wv2->size);
+ tl_assert(i1 == wv1->size || i2 == wv2->size);
+ if (i1 == wv1->size && i2 < wv2->size) {
+ sz += (wv2->size - i2);
+ }
+ if (i2 == wv2->size && i1 < wv1->size) {
+ sz += (wv1->size - i1);
+ }
+
+ wv_new = new_WV_of_size( wsu, sz );
+ k = 0;
+
+ i1 = i2 = 0;
+ while (1) {
+ if (i1 >= wv1->size || i2 >= wv2->size)
+ break;
+ if (wv1->words[i1] < wv2->words[i2]) {
+ wv_new->words[k++] = wv1->words[i1];
+ i1++;
+ } else
+ if (wv1->words[i1] > wv2->words[i2]) {
+ wv_new->words[k++] = wv2->words[i2];
+ i2++;
+ } else {
+ wv_new->words[k++] = wv1->words[i1];
+ i1++;
+ i2++;
+ }
+ }
+ tl_assert(i1 <= wv1->size);
+ tl_assert(i2 <= wv2->size);
+ tl_assert(i1 == wv1->size || i2 == wv2->size);
+ if (i1 == wv1->size && i2 < wv2->size) {
+ while (i2 < wv2->size)
+ wv_new->words[k++] = wv2->words[i2++];
+ }
+ if (i2 == wv2->size && i1 < wv1->size) {
+ while (i1 < wv1->size)
+ wv_new->words[k++] = wv1->words[i1++];
+ }
+
+ tl_assert(k == sz);
+
+ return add_or_dealloc_WordVec( wsu, wv_new );
+}
+
+WordSet HG_(intersectWS) ( WordSetU* wsu, WordSet ws1, WordSet ws2 )
+{
+ Int i1, i2, k, sz;
+ WordSet ws_new = (WordSet)(-1); /* bogus */
+ WordVec* wv_new;
+ WordVec* wv1;
+ WordVec* wv2;
+
+ wsu->n_intersect++;
+
+ /* Deal with an obvious case fast. */
+ if (ws1 == ws2)
+ return ws1;
+
+ /* Since intersect(x,y) == intersect(y,x), convert both variants to
+ the same query. This reduces the number of variants the cache
+ has to deal with. */
+ if (ws1 > ws2) {
+ WordSet wst = ws1; ws1 = ws2; ws2 = wst;
+ }
+
+ WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_intersect, ws1, ws2);
+ wsu->n_intersect_uncached++;
+
+ wv1 = do_ix2vec( wsu, ws1 );
+ wv2 = do_ix2vec( wsu, ws2 );
+ sz = 0;
+ i1 = i2 = 0;
+ while (1) {
+ if (i1 >= wv1->size || i2 >= wv2->size)
+ break;
+ if (wv1->words[i1] < wv2->words[i2]) {
+ i1++;
+ } else
+ if (wv1->words[i1] > wv2->words[i2]) {
+ i2++;
+ } else {
+ sz++;
+ i1++;
+ i2++;
+ }
+ }
+ tl_assert(i1 <= wv1->size);
+ tl_assert(i2 <= wv2->size);
+ tl_assert(i1 == wv1->size || i2 == wv2->size);
+
+ wv_new = new_WV_of_size( wsu, sz );
+ k = 0;
+
+ i1 = i2 = 0;
+ while (1) {
+ if (i1 >= wv1->size || i2 >= wv2->size)
+ break;
+ if (wv1->words[i1] < wv2->words[i2]) {
+ i1++;
+ } else
+ if (wv1->words[i1] > wv2->words[i2]) {
+ i2++;
+ } else {
+ wv_new->words[k++] = wv1->words[i1];
+ i1++;
+ i2++;
+ }
+ }
+ tl_assert(i1 <= wv1->size);
+ tl_assert(i2 <= wv2->size);
+ tl_assert(i1 == wv1->size || i2 == wv2->size);
+
+ tl_assert(k == sz);
+
+ ws_new = add_or_dealloc_WordVec( wsu, wv_new );
+ if (sz == 0) {
+ tl_assert(ws_new == wsu->empty);
+ }
+
+ tl_assert(ws_new != (WordSet)(-1));
+ WCache_UPDATE(wsu->cache_intersect, ws1, ws2, ws_new);
+
+ return ws_new;
+}
+
+WordSet HG_(minusWS) ( WordSetU* wsu, WordSet ws1, WordSet ws2 )
+{
+ Int i1, i2, k, sz;
+ WordSet ws_new = (WordSet)(-1); /* bogus */
+ WordVec* wv_new;
+ WordVec* wv1;
+ WordVec* wv2;
+
+ wsu->n_minus++;
+ WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_minus, ws1, ws2);
+ wsu->n_minus_uncached++;
+
+ wv1 = do_ix2vec( wsu, ws1 );
+ wv2 = do_ix2vec( wsu, ws2 );
+ sz = 0;
+ i1 = i2 = 0;
+ while (1) {
+ if (i1 >= wv1->size || i2 >= wv2->size)
+ break;
+ if (wv1->words[i1] < wv2->words[i2]) {
+ sz++;
+ i1++;
+ } else
+ if (wv1->words[i1] > wv2->words[i2]) {
+ i2++;
+ } else {
+ i1++;
+ i2++;
+ }
+ }
+ tl_assert(i1 <= wv1->size);
+ tl_assert(i2 <= wv2->size);
+ tl_assert(i1 == wv1->size || i2 == wv2->size);
+ if (i2 == wv2->size && i1 < wv1->size) {
+ sz += (wv1->size - i1);
+ }
+
+ wv_new = new_WV_of_size( wsu, sz );
+ k = 0;
+
+ i1 = i2 = 0;
+ while (1) {
+ if (i1 >= wv1->size || i2 >= wv2->size)
+ break;
+ if (wv1->words[i1] < wv2->words[i2]) {
+ wv_new->words[k++] = wv1->words[i1];
+ i1++;
+ } else
+ if (wv1->words[i1] > wv2->words[i2]) {
+ i2++;
+ } else {
+ i1++;
+ i2++;
+ }
+ }
+ tl_assert(i1 <= wv1->size);
+ tl_assert(i2 <= wv2->size);
+ tl_assert(i1 == wv1->size || i2 == wv2->size);
+ if (i2 == wv2->size && i1 < wv1->size) {
+ while (i1 < wv1->size)
+ wv_new->words[k++] = wv1->words[i1++];
+ }
+
+ tl_assert(k == sz);
+
+ ws_new = add_or_dealloc_WordVec( wsu, wv_new );
+ if (sz == 0) {
+ tl_assert(ws_new == wsu->empty);
+ }
+
+ tl_assert(ws_new != (WordSet)(-1));
+ WCache_UPDATE(wsu->cache_minus, ws1, ws2, ws_new);
+
+ return ws_new;
+}
+
+static __attribute__((unused))
+void show_WS ( WordSetU* wsu, WordSet ws )
+{
+ Int i;
+ WordVec* wv = do_ix2vec( wsu, ws );
+ VG_(printf)("#%u{", ws);
+ for (i = 0; i < wv->size; i++) {
+ VG_(printf)("%lu", wv->words[i]);
+ if (i < wv->size-1)
+ VG_(printf)(",");
+ }
+ VG_(printf)("}\n");
+}
+
+//------------------------------------------------------------------//
+//--- end WordSet ---//
+//--- Implementation ---//
+//------------------------------------------------------------------//
+
+/*--------------------------------------------------------------------*/
+/*--- end hg_wordset.c ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/hg_wordset.h b/helgrind/hg_wordset.h
new file mode 100644
index 0000000..5c40ef4
--- /dev/null
+++ b/helgrind/hg_wordset.h
@@ -0,0 +1,100 @@
+
+/*--------------------------------------------------------------------*/
+/*--- Sets of words, with unique set identifiers. ---*/
+/*--- hg_wordset.h ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+ This file is part of Helgrind, a Valgrind tool for detecting errors
+ in threaded programs.
+
+ Copyright (C) 2007-2007 OpenWorks LLP
+ info@open-works.co.uk
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307, USA.
+
+ The GNU General Public License is contained in the file COPYING.
+
+ Neither the names of the U.S. Department of Energy nor the
+ University of California nor the names of its contributors may be
+ used to endorse or promote products derived from this software
+ without prior written permission.
+*/
+
+#ifndef __HG_WORDSET_H
+#define __HG_WORDSET_H
+
+//------------------------------------------------------------------//
+//--- WordSet ---//
+//--- Public Interface ---//
+//------------------------------------------------------------------//
+
+typedef struct _WordSetU WordSetU; /* opaque */
+
+typedef UInt WordSet; /* opaque, small int index */
+
+/* Allocate and initialise a WordSetU */
+WordSetU* HG_(newWordSetU) ( void* (*alloc_nofail)( SizeT ),
+ void (*dealloc)(void*),
+ Word cacheSize );
+
+/* Free up the WordSetU. */
+void HG_(deleteWordSetU) ( WordSetU* );
+
+/* Get the number of elements in this WordSetU. */
+Int HG_(cardinalityWSU) ( WordSetU* );
+
+/* Show performance stats for this WordSetU. */
+void HG_(ppWSUstats) ( WordSetU* wsu, HChar* name );
+
+
+/* Element-level operations on WordSets. Note that the WordSet
+ numbers given out are 0, 1, 2, 3, etc, and as it happens 0 always
+ represents the empty set. */
+
+WordSet HG_(emptyWS) ( WordSetU* );
+WordSet HG_(addToWS) ( WordSetU*, WordSet, Word );
+WordSet HG_(delFromWS) ( WordSetU*, WordSet, Word );
+WordSet HG_(unionWS) ( WordSetU*, WordSet, WordSet );
+WordSet HG_(intersectWS) ( WordSetU*, WordSet, WordSet );
+WordSet HG_(minusWS) ( WordSetU*, WordSet, WordSet );
+Bool HG_(isEmptyWS) ( WordSetU*, WordSet );
+Bool HG_(isSingletonWS) ( WordSetU*, WordSet, Word );
+Word HG_(anyElementOfWS) ( WordSetU*, WordSet );
+Int HG_(cardinalityWS) ( WordSetU*, WordSet );
+Bool HG_(elemWS) ( WordSetU*, WordSet, Word );
+WordSet HG_(doubletonWS) ( WordSetU*, Word, Word );
+WordSet HG_(singletonWS) ( WordSetU*, Word );
+WordSet HG_(isSubsetOf) ( WordSetU*, WordSet, WordSet );
+
+Bool HG_(plausibleWS) ( WordSetU*, WordSet );
+Bool HG_(saneWS_SLOW) ( WordSetU*, WordSet );
+
+void HG_(ppWS) ( WordSetU*, WordSet );
+void HG_(getPayloadWS) ( /*OUT*/Word** words, /*OUT*/Word* nWords,
+ WordSetU*, WordSet );
+
+
+//------------------------------------------------------------------//
+//--- end WordSet ---//
+//--- Public Interface ---//
+//------------------------------------------------------------------//
+
+#endif /* ! __HG_WORDSET_H */
+
+/*--------------------------------------------------------------------*/
+/*--- end hg_wordset.h ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/tests/Makefile.am b/helgrind/tests/Makefile.am
new file mode 100644
index 0000000..ac84a96
--- /dev/null
+++ b/helgrind/tests/Makefile.am
@@ -0,0 +1,124 @@
+
+# For AM_FLAG_M3264_PRI
+include $(top_srcdir)/Makefile.flags.am
+
+noinst_SCRIPTS = filter_stderr
+
+EXTRA_DIST = $(noinst_SCRIPTS) \
+ hg01_all_ok.vgtest hg01_all_ok.stdout.exp \
+ hg01_all_ok.stderr.exp-glibc25-amd64 \
+ hg02_deadlock.vgtest hg02_deadlock.stdout.exp \
+ hg02_deadlock.stderr.exp-glibc25-amd64 \
+ hg02_deadlock.stderr.exp-glibc25-x86 \
+ hg03_inherit.vgtest hg03_inherit.stdout.exp \
+ hg03_inherit.stderr.exp-glibc25-amd64 \
+ hg03_inherit.stderr.exp-glibc25-x86 \
+ hg04_race.vgtest hg04_race.stdout.exp \
+ hg04_race.stderr.exp-glibc25-amd64 \
+ hg04_race.stderr.exp-glibc25-x86 \
+ hg05_race2.vgtest hg05_race2.stdout.exp \
+ hg05_race2.stderr.exp-glibc25-amd64 \
+ hg05_race2.stderr.exp-glibc25-x86 \
+ hg06_readshared.vgtest hg06_readshared.stdout.exp \
+ hg06_readshared.stderr.exp-glibc25-amd64 \
+ tc01_simple_race.vgtest tc01_simple_race.stdout.exp \
+ tc01_simple_race.stderr.exp-glibc25-amd64 \
+ tc01_simple_race.stderr.exp-glibc25-x86 \
+ tc02_simple_tls.vgtest tc02_simple_tls.stdout.exp \
+ tc02_simple_tls.stderr.exp-glibc25-amd64 \
+ tc03_re_excl.vgtest tc03_re_excl.stdout.exp \
+ tc03_re_excl.stderr.exp-glibc25-amd64 \
+ tc04_free_lock.vgtest tc04_free_lock.stdout.exp \
+ tc04_free_lock.stderr.exp-glibc25-amd64 \
+ tc05_simple_race.vgtest tc05_simple_race.stdout.exp \
+ tc05_simple_race.stderr.exp-glibc25-amd64 \
+ tc05_simple_race.stderr.exp-glibc25-x86 \
+ tc06_two_races.vgtest tc06_two_races.stdout.exp \
+ tc06_two_races.stderr.exp-glibc25-amd64 \
+ tc06_two_races.stderr.exp-glibc25-x86 \
+ tc07_hbl1.vgtest tc07_hbl1.stdout.exp \
+ tc07_hbl1.stderr.exp-glibc25-amd64 \
+ tc08_hbl2.vgtest tc08_hbl2.stdout.exp \
+ tc08_hbl2.stderr.exp-glibc25-amd64 \
+ tc09_bad_unlock.vgtest tc09_bad_unlock.stdout.exp \
+ tc09_bad_unlock.stderr.exp-glibc23-amd64 \
+ tc09_bad_unlock.stderr.exp-glibc25-amd64 \
+ tc09_bad_unlock.stderr.exp-glibc25-x86 \
+ tc10_rec_lock.vgtest tc10_rec_lock.stdout.exp \
+ tc10_rec_lock.stderr.exp-glibc25-amd64 \
+ tc11_XCHG.vgtest tc11_XCHG.stdout.exp \
+ tc11_XCHG.stderr.exp-glibc25-amd64 \
+ tc12_rwl_trivial.vgtest tc12_rwl_trivial.stdout.exp \
+ tc12_rwl_trivial.stderr.exp-glibc25-amd64 \
+ tc13_laog1.vgtest tc13_laog1.stdout.exp \
+ tc13_laog1.stderr.exp-glibc25-amd64 \
+ tc14_laog_dinphils.vgtest tc14_laog_dinphils.stdout.exp \
+ tc14_laog_dinphils.stderr.exp-glibc25-amd64 \
+ tc14_laog_dinphils.stderr.exp-glibc25-x86 \
+ tc15_laog_lockdel.vgtest tc15_laog_lockdel.stdout.exp \
+ tc15_laog_lockdel.stderr.exp-glibc25-amd64 \
+ tc16_byterace.vgtest tc16_byterace.stdout.exp \
+ tc16_byterace.stderr.exp-glibc25-amd64 \
+ tc16_byterace.stderr.exp-glibc25-x86 \
+ tc17_sembar.vgtest tc17_sembar.stdout.exp \
+ tc17_sembar.stderr.exp-glibc25-amd64 \
+ tc17_sembar.stderr.exp-glibc25-x86 \
+ tc18_semabuse.vgtest tc18_semabuse.stdout.exp \
+ tc18_semabuse.stderr.exp-glibc25-amd64 \
+ tc18_semabuse.stderr.exp-glibc25-x86 \
+ tc19_shadowmem.vgtest tc19_shadowmem.stdout.exp \
+ tc19_shadowmem.stderr.exp-glibc25-amd64 \
+ tc19_shadowmem.stderr.exp-glibc25-x86 \
+ tc20_verifywrap.vgtest tc20_verifywrap.stdout.exp \
+ tc20_verifywrap.stderr.exp-glibc23-amd64 \
+ tc20_verifywrap.stderr.exp-glibc25-amd64 \
+ tc20_verifywrap.stderr.exp-glibc25-x86 \
+ tc21_pthonce.vgtest tc21_pthonce.stdout.exp \
+ tc21_pthonce.stderr.exp-glibc25-amd64 \
+ tc21_pthonce.stderr.exp-glibc25-x86 \
+ tc22_exit_w_lock.vgtest tc22_exit_w_lock.stdout.exp \
+ tc22_exit_w_lock.stderr.exp-glibc25-amd64 \
+ tc22_exit_w_lock.stderr.exp-glibc25-x86 \
+ tc23_bogus_condwait.vgtest tc23_bogus_condwait.stdout.exp \
+ tc23_bogus_condwait.stderr.exp-glibc25-amd64 \
+ tc23_bogus_condwait.stderr.exp-glibc25-x86
+
+check_PROGRAMS = \
+ hg01_all_ok \
+ hg02_deadlock \
+ hg03_inherit \
+ hg04_race \
+ hg05_race2 \
+ hg06_readshared \
+ tc01_simple_race \
+ tc02_simple_tls \
+ tc03_re_excl \
+ tc04_free_lock \
+ tc05_simple_race \
+ tc06_two_races \
+ tc07_hbl1 \
+ tc08_hbl2 \
+ tc09_bad_unlock \
+ tc10_rec_lock \
+ tc11_XCHG \
+ tc12_rwl_trivial \
+ tc13_laog1 \
+ tc14_laog_dinphils \
+ tc15_laog_lockdel \
+ tc16_byterace \
+ tc17_sembar \
+ tc18_semabuse \
+ tc19_shadowmem \
+ tc20_verifywrap \
+ tc21_pthonce \
+ tc22_exit_w_lock \
+ tc23_bogus_condwait
+
+AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/include \
+ -I$(top_srcdir)/coregrind -I$(top_builddir)/include \
+ -I@VEX_DIR@/pub
+
+# are these necessary?
+AM_CFLAGS = $(WERROR) -Winline -Wall -Wshadow -g $(AM_FLAG_M3264_PRI)
+
+LDADD = -lpthread
diff --git a/helgrind/tests/filter_stderr b/helgrind/tests/filter_stderr
new file mode 100755
index 0000000..f2b45d7
--- /dev/null
+++ b/helgrind/tests/filter_stderr
@@ -0,0 +1,30 @@
+#! /bin/sh
+
+dir=`dirname $0`
+
+$dir/../../tests/filter_stderr_basic |
+
+# Anonymise addresses
+$dir/../../tests/filter_addresses |
+
+# Remove "Helgrind, ..." line and the following copyright line.
+sed "/^Helgrind, a thread error detector/ , /./ d" |
+
+# Anonymise line numbers in hg_intercepts.c
+sed "s/hg_intercepts.c:[0-9]*/hg_intercepts.c:.../g" |
+
+# Change (eg) "/lib64/libpthread-2.5.so" into "/lib/libpthread..."
+sed "s/lib64/lib/g" |
+sed "s/libpthread.*so/libpthread\.\.\./g" |
+
+# Change (eg) "pthread_create@@GLIBC_2.2.5" into "pthread_create@GLIBC"
+# and (eg) "pthread_create@GLIBC_2.1" into "pthread_create@GLIBC"
+sed "s/@@*GLIBC_2[0123456789\.]*/@GLIBC_/g" |
+
+# Tidy up in cases where glibc (+ libdl + libpthread + ld) have
+# been built with debugging information, hence source locs are present
+sed "s/(createthread.c:[0-9]*)/(in \/lib\/libpthread...)/g" |
+sed "s/(clone.S:[0-9]*)/(in \/...libc...)/g" |
+sed "s/start_thread (pthread_create.c:[0-9]*)$/start_thread (in \/lib\/libpthread...)/g" |
+
+$dir/../../tests/filter_test_paths
diff --git a/helgrind/tests/hg01_all_ok.c b/helgrind/tests/hg01_all_ok.c
new file mode 100644
index 0000000..144ce60
--- /dev/null
+++ b/helgrind/tests/hg01_all_ok.c
@@ -0,0 +1,32 @@
+/* All OK */
+
+#include <pthread.h>
+
+static pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
+
+static int shared;
+
+static void *th(void *v)
+{
+ pthread_mutex_lock(&mx);
+ shared++;
+ pthread_mutex_unlock(&mx);
+
+ return 0;
+}
+
+int main()
+{
+ pthread_t a, b;
+
+ pthread_mutex_lock(&mx);
+ pthread_mutex_unlock(&mx);
+
+ pthread_create(&a, NULL, th, NULL);
+ pthread_create(&b, NULL, th, NULL);
+
+ pthread_join(a, NULL);
+ pthread_join(b, NULL);
+
+ return 0;
+}
diff --git a/helgrind/tests/hg01_all_ok.stderr.exp-glibc25-amd64 b/helgrind/tests/hg01_all_ok.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/hg01_all_ok.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg01_all_ok.stdout.exp b/helgrind/tests/hg01_all_ok.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg01_all_ok.stdout.exp
diff --git a/helgrind/tests/hg01_all_ok.vgtest b/helgrind/tests/hg01_all_ok.vgtest
new file mode 100644
index 0000000..9524976
--- /dev/null
+++ b/helgrind/tests/hg01_all_ok.vgtest
@@ -0,0 +1 @@
+prog: hg01_all_ok
diff --git a/helgrind/tests/hg02_deadlock.c b/helgrind/tests/hg02_deadlock.c
new file mode 100644
index 0000000..1142f5c
--- /dev/null
+++ b/helgrind/tests/hg02_deadlock.c
@@ -0,0 +1,43 @@
+/* Simple possible deadlock */
+#include <pthread.h>
+
+static pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
+
+static void *t1(void *v)
+{
+ pthread_mutex_lock(&m1);
+ pthread_mutex_lock(&m2);
+ pthread_mutex_unlock(&m1);
+ pthread_mutex_unlock(&m2);
+
+ return 0;
+}
+
+static void *t2(void *v)
+{
+ pthread_mutex_lock(&m2);
+ pthread_mutex_lock(&m1);
+ pthread_mutex_unlock(&m1);
+ pthread_mutex_unlock(&m2);
+
+ return 0;
+}
+
+int main()
+{
+ pthread_t a, b;
+
+ /* prevent spurious messages from the dynamic linker */
+ pthread_mutex_lock(&m1);
+ pthread_mutex_unlock(&m1);
+
+ pthread_create(&a, NULL, t1, NULL);
+ pthread_create(&b, NULL, t2, NULL);
+
+ pthread_join(a, NULL);
+ pthread_join(b, NULL);
+
+ return 0;
+}
+
diff --git a/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-amd64 b/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..8fe4ea4
--- /dev/null
+++ b/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-amd64
@@ -0,0 +1,28 @@
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg02_deadlock.c:36)
+
+Thread #3: lock order "0x........ before 0x........" violated
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: t2 (hg02_deadlock.c:20)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Required order was established by acquisition of lock at 0x........
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: t1 (hg02_deadlock.c:9)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ followed by a later acquisition of lock at 0x........
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: t1 (hg02_deadlock.c:10)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-x86 b/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..6f7fa48
--- /dev/null
+++ b/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-x86
@@ -0,0 +1,27 @@
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg02_deadlock.c:36)
+
+Thread #3: lock order "0x........ before 0x........" violated
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: t2 (hg02_deadlock.c:20)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Required order was established by acquisition of lock at 0x........
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: t1 (hg02_deadlock.c:9)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ followed by a later acquisition of lock at 0x........
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: t1 (hg02_deadlock.c:10)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg02_deadlock.stdout.exp b/helgrind/tests/hg02_deadlock.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg02_deadlock.stdout.exp
diff --git a/helgrind/tests/hg02_deadlock.vgtest b/helgrind/tests/hg02_deadlock.vgtest
new file mode 100644
index 0000000..ff0deb7
--- /dev/null
+++ b/helgrind/tests/hg02_deadlock.vgtest
@@ -0,0 +1 @@
+prog: hg02_deadlock
diff --git a/helgrind/tests/hg03_inherit.c b/helgrind/tests/hg03_inherit.c
new file mode 100644
index 0000000..7c429f8
--- /dev/null
+++ b/helgrind/tests/hg03_inherit.c
@@ -0,0 +1,67 @@
+
+/* I don't think this is a very good test .. all this
+ sleepery is highly confusing. */
+
+/* test child thread inheriting data */
+
+#include <stdio.h>
+#include <pthread.h>
+#include <unistd.h>
+
+static volatile int shared[2];
+
+static void *t1(void *v)
+{
+ volatile int *ip = (int *)v;
+ if (0) printf("ta W\n");
+ *ip += 44;
+ *ip *= 2;
+ sleep(1);
+ return 0;
+}
+
+static void *t2(void *v)
+{
+ volatile int *ip = (int *)v;
+ sleep(2);
+ if (0) printf("tb W\n");
+ *ip += 88;
+ *ip *= 3;
+ sleep(1);
+ return 0;
+}
+
+int main(void)
+{
+ pthread_t a, b;
+ volatile int ret = 0;
+
+ sleep(0);
+
+ shared[0] = 22;
+ shared[1] = 77;
+
+ pthread_create(&a, NULL, t1, (void *)&shared[0]);
+ // a steals shared[0] from root thread, so is excl(a)
+ pthread_create(&b, NULL, t2, (void *)&shared[1]);
+ // b steals shared[1] from root thread, so is excl(b)
+
+ pthread_join(a, NULL);
+ // b's stuff (shared[1]) still belongs to b, so is excl(b)
+
+ // ret is excl(root), and shared[0] is re-acquired as excl(root)
+ // since a joined to root
+ if (0) printf("r R1\n");
+ ret += shared[0]; /* no error - a is finished */
+
+ // but shared[1] is excl(b); hence we're reading excl(b)
+ // without a lock and without a dependency edge
+ if (0) printf("r R2\n");
+ ret += shared[1]; /* expect error - b has not finished,
+ so we can't touch shared[1] yet */
+
+ pthread_join(b, NULL);
+
+
+ return ret;
+}
diff --git a/helgrind/tests/hg03_inherit.stderr.exp-glibc25-amd64 b/helgrind/tests/hg03_inherit.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..3cf4b5e
--- /dev/null
+++ b/helgrind/tests/hg03_inherit.stderr.exp-glibc25-amd64
@@ -0,0 +1,21 @@
+
+Thread #1 is the program's root thread
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg03_inherit.c:46)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: t2 (hg03_inherit.c:28)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: shared-readonly by threads #1, #3
+ New state: shared-modified by threads #1, #3
+ Reason: this thread, #3, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg03_inherit.stderr.exp-glibc25-x86 b/helgrind/tests/hg03_inherit.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..a7e4407
--- /dev/null
+++ b/helgrind/tests/hg03_inherit.stderr.exp-glibc25-x86
@@ -0,0 +1,20 @@
+
+Thread #1 is the program's root thread
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg03_inherit.c:46)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: t2 (hg03_inherit.c:28)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: shared-readonly by threads #1, #3
+ New state: shared-modified by threads #1, #3
+ Reason: this thread, #3, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg03_inherit.stdout.exp b/helgrind/tests/hg03_inherit.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg03_inherit.stdout.exp
diff --git a/helgrind/tests/hg03_inherit.vgtest b/helgrind/tests/hg03_inherit.vgtest
new file mode 100644
index 0000000..b3ac039
--- /dev/null
+++ b/helgrind/tests/hg03_inherit.vgtest
@@ -0,0 +1 @@
+prog: hg03_inherit
diff --git a/helgrind/tests/hg04_race.c b/helgrind/tests/hg04_race.c
new file mode 100644
index 0000000..111195b
--- /dev/null
+++ b/helgrind/tests/hg04_race.c
@@ -0,0 +1,27 @@
+/* A simple race */
+
+#include <pthread.h>
+#include <unistd.h>
+
+static int shared;
+
+static void *th(void *v)
+{
+ shared++;
+
+ return 0;
+}
+
+int main()
+{
+ pthread_t a, b;
+
+ pthread_create(&a, NULL, th, NULL);
+ sleep(1); /* force ordering */
+ pthread_create(&b, NULL, th, NULL);
+
+ pthread_join(a, NULL);
+ pthread_join(b, NULL);
+
+ return 0;
+}
diff --git a/helgrind/tests/hg04_race.stderr.exp-glibc25-amd64 b/helgrind/tests/hg04_race.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..6ec1ac3
--- /dev/null
+++ b/helgrind/tests/hg04_race.stderr.exp-glibc25-amd64
@@ -0,0 +1,26 @@
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg04_race.c:19)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg04_race.c:21)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: th (hg04_race.c:10)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: shared-readonly by threads #2, #3
+ New state: shared-modified by threads #2, #3
+ Reason: this thread, #3, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg04_race.stderr.exp-glibc25-x86 b/helgrind/tests/hg04_race.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..3d28bd8
--- /dev/null
+++ b/helgrind/tests/hg04_race.stderr.exp-glibc25-x86
@@ -0,0 +1,24 @@
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg04_race.c:19)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg04_race.c:21)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: th (hg04_race.c:10)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: shared-readonly by threads #2, #3
+ New state: shared-modified by threads #2, #3
+ Reason: this thread, #3, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg04_race.stdout.exp b/helgrind/tests/hg04_race.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg04_race.stdout.exp
diff --git a/helgrind/tests/hg04_race.vgtest b/helgrind/tests/hg04_race.vgtest
new file mode 100644
index 0000000..92b7099
--- /dev/null
+++ b/helgrind/tests/hg04_race.vgtest
@@ -0,0 +1 @@
+prog: hg04_race
diff --git a/helgrind/tests/hg05_race2.c b/helgrind/tests/hg05_race2.c
new file mode 100644
index 0000000..de01f2c
--- /dev/null
+++ b/helgrind/tests/hg05_race2.c
@@ -0,0 +1,35 @@
+/* A simple race - test symaddr */
+
+#include <pthread.h>
+#include <unistd.h>
+
+struct foo {
+ struct bar {
+ int plop[22];
+ char biff;
+ } poot[11];
+};
+
+static void *th(void *v)
+{
+ struct foo *f = (struct foo *)v;
+
+ f->poot[5].plop[11]++;
+
+ return 0;
+}
+
+int main()
+{
+ struct foo foo;
+ pthread_t a, b;
+
+ pthread_create(&a, NULL, th, &foo);
+ sleep(1); /* force ordering */
+ pthread_create(&b, NULL, th, &foo);
+
+ pthread_join(a, NULL);
+ pthread_join(b, NULL);
+
+ return 0;
+}
diff --git a/helgrind/tests/hg05_race2.stderr.exp-glibc25-amd64 b/helgrind/tests/hg05_race2.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..b6dc2e9
--- /dev/null
+++ b/helgrind/tests/hg05_race2.stderr.exp-glibc25-amd64
@@ -0,0 +1,26 @@
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg05_race2.c:27)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg05_race2.c:29)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: th (hg05_race2.c:17)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: shared-readonly by threads #2, #3
+ New state: shared-modified by threads #2, #3
+ Reason: this thread, #3, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg05_race2.stderr.exp-glibc25-x86 b/helgrind/tests/hg05_race2.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..285efeb
--- /dev/null
+++ b/helgrind/tests/hg05_race2.stderr.exp-glibc25-x86
@@ -0,0 +1,24 @@
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg05_race2.c:27)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (hg05_race2.c:29)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: th (hg05_race2.c:17)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: shared-readonly by threads #2, #3
+ New state: shared-modified by threads #2, #3
+ Reason: this thread, #3, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg05_race2.stdout.exp b/helgrind/tests/hg05_race2.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg05_race2.stdout.exp
diff --git a/helgrind/tests/hg05_race2.vgtest b/helgrind/tests/hg05_race2.vgtest
new file mode 100644
index 0000000..a93db5e
--- /dev/null
+++ b/helgrind/tests/hg05_race2.vgtest
@@ -0,0 +1 @@
+prog: hg05_race2
diff --git a/helgrind/tests/hg06_readshared.c b/helgrind/tests/hg06_readshared.c
new file mode 100644
index 0000000..3904b44
--- /dev/null
+++ b/helgrind/tests/hg06_readshared.c
@@ -0,0 +1,33 @@
+/* All OK - test allowed read sharing */
+
+#include <pthread.h>
+#include <assert.h>
+
+static int shared;
+
+static void *t1(void *v)
+{
+ return (void *)(long)(shared + 44);
+}
+
+static void *t2(void *v)
+{
+ return (void *)(long)(shared + 55);
+}
+
+int main()
+{
+ pthread_t a, b;
+
+ shared = 22;
+
+ pthread_create(&a, NULL, t1, NULL);
+ pthread_create(&b, NULL, t2, NULL);
+
+ pthread_join(a, NULL);
+ pthread_join(b, NULL);
+
+ assert(shared == 22);
+
+ return 0;
+}
diff --git a/helgrind/tests/hg06_readshared.stderr.exp-glibc25-amd64 b/helgrind/tests/hg06_readshared.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/hg06_readshared.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg06_readshared.stdout.exp b/helgrind/tests/hg06_readshared.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg06_readshared.stdout.exp
diff --git a/helgrind/tests/hg06_readshared.vgtest b/helgrind/tests/hg06_readshared.vgtest
new file mode 100644
index 0000000..c5accee
--- /dev/null
+++ b/helgrind/tests/hg06_readshared.vgtest
@@ -0,0 +1 @@
+prog: hg06_readshared
diff --git a/helgrind/tests/tc01_simple_race.c b/helgrind/tests/tc01_simple_race.c
new file mode 100644
index 0000000..abf37b5
--- /dev/null
+++ b/helgrind/tests/tc01_simple_race.c
@@ -0,0 +1,36 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, has a race. Parent and child both modify x
+ with no locking. */
+
+int x = 0;
+
+void* child_fn ( void* arg )
+{
+ /* Unprotected relative to parent */
+ x++;
+ return NULL;
+}
+
+int main ( void )
+{
+ pthread_t child;
+
+ if (pthread_create(&child, NULL, child_fn, NULL)) {
+ perror("pthread_create");
+ exit(1);
+ }
+
+ /* Unprotected relative to child */
+ x++;
+
+ if (pthread_join(child, NULL)) {
+ perror("pthread join");
+ exit(1);
+ }
+
+ return 0;
+}
diff --git a/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-amd64 b/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..a5b31c3
--- /dev/null
+++ b/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-amd64
@@ -0,0 +1,18 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc01_simple_race.c:22)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: main (tc01_simple_race.c:28)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-x86 b/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..ba37641
--- /dev/null
+++ b/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-x86
@@ -0,0 +1,17 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc01_simple_race.c:22)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: main (tc01_simple_race.c:28)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc01_simple_race.stdout.exp b/helgrind/tests/tc01_simple_race.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc01_simple_race.stdout.exp
diff --git a/helgrind/tests/tc01_simple_race.vgtest b/helgrind/tests/tc01_simple_race.vgtest
new file mode 100644
index 0000000..44f3045
--- /dev/null
+++ b/helgrind/tests/tc01_simple_race.vgtest
@@ -0,0 +1 @@
+prog: tc01_simple_race
diff --git a/helgrind/tests/tc02_simple_tls.c b/helgrind/tests/tc02_simple_tls.c
new file mode 100644
index 0000000..a23b14c
--- /dev/null
+++ b/helgrind/tests/tc02_simple_tls.c
@@ -0,0 +1,39 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, no race: parent only modified x after child
+ has modified it and then joined with the parent. Tests simple
+ thread lifetime segment handling. */
+
+int x = 0;
+
+void* child_fn ( void* arg )
+{
+ /* Unprotected relative to parent, but in child's segment only */
+ x++;
+ return NULL;
+}
+
+int main ( void )
+{
+ pthread_t child;
+
+ x++; /* happens in parent's segment */
+
+ if (pthread_create(&child, NULL, child_fn, NULL)) {
+ perror("pthread_create");
+ exit(1);
+ }
+
+ if (pthread_join(child, NULL)) {
+ perror("pthread join");
+ exit(1);
+ }
+
+ /* Now back in parent's segment */
+ x++;
+
+ return 0;
+}
diff --git a/helgrind/tests/tc02_simple_tls.stderr.exp-glibc25-amd64 b/helgrind/tests/tc02_simple_tls.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/tc02_simple_tls.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc02_simple_tls.stdout.exp b/helgrind/tests/tc02_simple_tls.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc02_simple_tls.stdout.exp
diff --git a/helgrind/tests/tc02_simple_tls.vgtest b/helgrind/tests/tc02_simple_tls.vgtest
new file mode 100644
index 0000000..57db35c
--- /dev/null
+++ b/helgrind/tests/tc02_simple_tls.vgtest
@@ -0,0 +1 @@
+prog: tc02_simple_tls
diff --git a/helgrind/tests/tc03_re_excl.c b/helgrind/tests/tc03_re_excl.c
new file mode 100644
index 0000000..4f3ce51
--- /dev/null
+++ b/helgrind/tests/tc03_re_excl.c
@@ -0,0 +1,44 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, no race: parent only modifies x after child
+ has modified it and then joined with the parent. Tests simple
+ thread lifetime segment handling. */
+
+/* A simple function to "use" a value, so that gcc can't
+ possibly optimise it into nothing. */
+static void use ( int x ) {
+ __asm__ __volatile__( "nop" : : "r"(x) : "cc","memory" );
+}
+
+static void* worker_thread ( void* argV )
+{
+ int* arg = (int*)argV;
+ use(arg[5]); /* read access */
+ return NULL;
+}
+
+int main ( void )
+{
+ pthread_t thread_id;
+ volatile int* x = malloc(10 * sizeof(int));
+ x[5] = 1;
+ /* x[5] is Excl(parent) */
+
+ pthread_create(&thread_id, 0, worker_thread, (void*)x);
+
+ use(x[5]); /* read access */
+
+ /* Just before the threads join, x[5] is ShR (read by both parent
+ and child) */
+ pthread_join(thread_id, 0);
+ /* x[5] is Excl(parent), because only parent and child accessed it
+ and child has merged to parent. So now it's ok for parent to
+ access it without locking. */
+
+ x[5] = 0; /* write access */
+
+ return x[5];
+}
diff --git a/helgrind/tests/tc03_re_excl.stderr.exp-glibc25-amd64 b/helgrind/tests/tc03_re_excl.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/tc03_re_excl.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc03_re_excl.stdout.exp b/helgrind/tests/tc03_re_excl.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc03_re_excl.stdout.exp
diff --git a/helgrind/tests/tc03_re_excl.vgtest b/helgrind/tests/tc03_re_excl.vgtest
new file mode 100644
index 0000000..e12924a
--- /dev/null
+++ b/helgrind/tests/tc03_re_excl.vgtest
@@ -0,0 +1 @@
+prog: tc03_re_excl
diff --git a/helgrind/tests/tc04_free_lock.c b/helgrind/tests/tc04_free_lock.c
new file mode 100644
index 0000000..c1ffa25
--- /dev/null
+++ b/helgrind/tests/tc04_free_lock.c
@@ -0,0 +1,50 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/* Delete memory that has a held lock and see what happens. */
+
+typedef struct { int stuff[2000];
+ pthread_mutex_t lock; int morestuff[2000]; } XX;
+
+void bar ( void );
+void foo ( void );
+
+int main ( void )
+{
+ XX* xx = malloc(sizeof(XX));
+ assert(xx);
+
+ pthread_mutex_init( &xx->lock, NULL );
+
+ pthread_mutex_lock( &xx->lock );
+
+ free(xx);
+
+ bar();
+ foo();
+ bar();
+
+ return 0;
+}
+
+/* Try the same, on the stack */
+void bar ( void )
+{
+ pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
+ // pthread_mutex_init( &mx, NULL );
+ pthread_mutex_lock( &mx );
+ /* now just abandon mx */
+}
+
+/* and again ... */
+void foo ( void )
+{
+ pthread_mutex_t mx;
+ pthread_mutex_init( &mx, NULL );
+ pthread_mutex_lock( &mx );
+ /* now just abandon mx */
+}
+
diff --git a/helgrind/tests/tc04_free_lock.stderr.exp-glibc25-amd64 b/helgrind/tests/tc04_free_lock.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..b14e3b6
--- /dev/null
+++ b/helgrind/tests/tc04_free_lock.stderr.exp-glibc25-amd64
@@ -0,0 +1,35 @@
+
+Thread #1 is the program's root thread
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: free (vg_replace_malloc.c:...)
+ by 0x........: main (tc04_free_lock.c:24)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: main (tc04_free_lock.c:20)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: bar (tc04_free_lock.c:40)
+ by 0x........: main (tc04_free_lock.c:26)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: bar (tc04_free_lock.c:38)
+ by 0x........: main (tc04_free_lock.c:26)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: foo (tc04_free_lock.c:49)
+ by 0x........: main (tc04_free_lock.c:27)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: foo (tc04_free_lock.c:46)
+ by 0x........: main (tc04_free_lock.c:27)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: bar (tc04_free_lock.c:40)
+ by 0x........: main (tc04_free_lock.c:28)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: bar (tc04_free_lock.c:38)
+ by 0x........: main (tc04_free_lock.c:28)
+
+ERROR SUMMARY: 4 errors from 4 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc04_free_lock.stdout.exp b/helgrind/tests/tc04_free_lock.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc04_free_lock.stdout.exp
diff --git a/helgrind/tests/tc04_free_lock.vgtest b/helgrind/tests/tc04_free_lock.vgtest
new file mode 100644
index 0000000..27d28bf
--- /dev/null
+++ b/helgrind/tests/tc04_free_lock.vgtest
@@ -0,0 +1 @@
+prog: tc04_free_lock
diff --git a/helgrind/tests/tc05_simple_race.c b/helgrind/tests/tc05_simple_race.c
new file mode 100644
index 0000000..287c12c
--- /dev/null
+++ b/helgrind/tests/tc05_simple_race.c
@@ -0,0 +1,44 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, has a race. Parent and child both modify y
+ with no locking. This is the program shown in Fig 2 of the
+ original Eraser paper by Savage et al. */
+
+int y = 0, v = 0;
+pthread_mutex_t mu = PTHREAD_MUTEX_INITIALIZER;
+
+void* child_fn ( void* arg )
+{
+ /* "Thread 2" in the paper */
+ pthread_mutex_lock( &mu );
+ v = v + 1;
+ pthread_mutex_unlock( &mu );
+ y = y + 1;
+ return NULL;
+}
+
+int main ( void )
+{
+ pthread_t child;
+
+ if (pthread_create(&child, NULL, child_fn, NULL)) {
+ perror("pthread_create");
+ exit(1);
+ }
+
+ /* "Thread 1" in the paper */
+ y = y + 1;
+ pthread_mutex_lock( &mu );
+ v = v + 1;
+ pthread_mutex_unlock( &mu );
+
+ if (pthread_join(child, NULL)) {
+ perror("pthread join");
+ exit(1);
+ }
+
+ return 0;
+}
diff --git a/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-amd64 b/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..8c15d1a
--- /dev/null
+++ b/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-amd64
@@ -0,0 +1,18 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc05_simple_race.c:27)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: main (tc05_simple_race.c:33)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-x86 b/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..fb6dccf
--- /dev/null
+++ b/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-x86
@@ -0,0 +1,17 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc05_simple_race.c:27)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: main (tc05_simple_race.c:33)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc05_simple_race.stdout.exp b/helgrind/tests/tc05_simple_race.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc05_simple_race.stdout.exp
diff --git a/helgrind/tests/tc05_simple_race.vgtest b/helgrind/tests/tc05_simple_race.vgtest
new file mode 100644
index 0000000..27f3881
--- /dev/null
+++ b/helgrind/tests/tc05_simple_race.vgtest
@@ -0,0 +1 @@
+prog: tc05_simple_race
diff --git a/helgrind/tests/tc06_two_races.c b/helgrind/tests/tc06_two_races.c
new file mode 100644
index 0000000..65c83ef
--- /dev/null
+++ b/helgrind/tests/tc06_two_races.c
@@ -0,0 +1,43 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, has two races. A happens-before detector can only
+ ever detect one of them, though. */
+
+int unprot1 = 0, unprot2 = 0, prot = 0;
+pthread_mutex_t mu = PTHREAD_MUTEX_INITIALIZER;
+
+void* child_fn ( void* arg )
+{
+ unprot1 ++;
+ pthread_mutex_lock( &mu );
+ prot ++;
+ pthread_mutex_unlock( &mu );
+ unprot2 ++;
+ return NULL;
+}
+
+int main ( void )
+{
+ pthread_t child;
+
+ if (pthread_create(&child, NULL, child_fn, NULL)) {
+ perror("pthread_create");
+ exit(1);
+ }
+
+ unprot1 ++;
+ pthread_mutex_lock( &mu );
+ prot ++;
+ pthread_mutex_unlock( &mu );
+ unprot2 ++;
+
+ if (pthread_join(child, NULL)) {
+ perror("pthread join");
+ exit(1);
+ }
+
+ return 0;
+}
diff --git a/helgrind/tests/tc06_two_races.stderr.exp-glibc25-amd64 b/helgrind/tests/tc06_two_races.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..db74a70
--- /dev/null
+++ b/helgrind/tests/tc06_two_races.stderr.exp-glibc25-amd64
@@ -0,0 +1,25 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc06_two_races.c:26)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: main (tc06_two_races.c:31)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: main (tc06_two_races.c:35)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc06_two_races.stderr.exp-glibc25-x86 b/helgrind/tests/tc06_two_races.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..34874fc
--- /dev/null
+++ b/helgrind/tests/tc06_two_races.stderr.exp-glibc25-x86
@@ -0,0 +1,24 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc06_two_races.c:26)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: main (tc06_two_races.c:31)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: main (tc06_two_races.c:35)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc06_two_races.stdout.exp b/helgrind/tests/tc06_two_races.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc06_two_races.stdout.exp
diff --git a/helgrind/tests/tc06_two_races.vgtest b/helgrind/tests/tc06_two_races.vgtest
new file mode 100644
index 0000000..f6f5247
--- /dev/null
+++ b/helgrind/tests/tc06_two_races.vgtest
@@ -0,0 +1 @@
+prog: tc06_two_races
diff --git a/helgrind/tests/tc07_hbl1.c b/helgrind/tests/tc07_hbl1.c
new file mode 100644
index 0000000..58e6564
--- /dev/null
+++ b/helgrind/tests/tc07_hbl1.c
@@ -0,0 +1,77 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, no race. Parent and child both modify x and
+ use the hardware bus lock. */
+
+#undef PLAT_x86_linux
+#undef PLAT_amd64_linux
+#undef PLAT_ppc32_linux
+#undef PLAT_ppc64_linux
+#undef PLAT_ppc32_aix5
+#undef PLAT_ppc64_aix5
+
+#if !defined(_AIX) && defined(__i386__)
+# define PLAT_x86_linux 1
+#elif !defined(_AIX) && defined(__x86_64__)
+# define PLAT_amd64_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && !defined(__powerpc64__)
+# define PLAT_ppc32_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && defined(__powerpc64__)
+# define PLAT_ppc64_linux 1
+#elif defined(_AIX) && defined(__64BIT__)
+# define PLAT_ppc64_aix5 1
+#elif defined(_AIX) && !defined(__64BIT__)
+# define PLAT_ppc32_aix5 1
+#endif
+
+
+#if defined(PLAT_amd64_linux) || defined(PLAT_x86_linux)
+# define INC(_lval) \
+ __asm__ __volatile__ ( \
+ "lock ; incl (%0)" : /*out*/ : /*in*/"r"(&(_lval)) : "memory", "cc" )
+#elif defined(PLAT_ppc32_linux) || defined(PLAT_ppc64_linux)
+# define INC(_lval) \
+ __asm__ __volatile__( \
+ "1:\n" \
+ " lwarx 15,0,%0\n" \
+ " addi 15,15,1\n" \
+ " stwcx. 15,0,%0\n" \
+ " bne- 1b" \
+ : /*out*/ : /*in*/ "b"(&(_lval)) \
+ : /*trash*/ "r15", "cr0", "memory" \
+ )
+#else
+# error "Fix Me for this platform"
+#endif
+
+
+int x = 0;
+
+void* child_fn ( void* arg )
+{
+ INC(x);
+ return NULL;
+}
+
+int main ( void )
+{
+ pthread_t child;
+
+ if (pthread_create(&child, NULL, child_fn, NULL)) {
+ perror("pthread_create");
+ exit(1);
+ }
+
+ INC(x);
+
+ if (pthread_join(child, NULL)) {
+ perror("pthread join");
+ exit(1);
+ }
+
+ printf("x = %d\n", x);
+ return 0;
+}
diff --git a/helgrind/tests/tc07_hbl1.stderr.exp-glibc25-amd64 b/helgrind/tests/tc07_hbl1.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/tc07_hbl1.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc07_hbl1.stdout.exp b/helgrind/tests/tc07_hbl1.stdout.exp
new file mode 100644
index 0000000..407de30
--- /dev/null
+++ b/helgrind/tests/tc07_hbl1.stdout.exp
@@ -0,0 +1 @@
+x = 2
diff --git a/helgrind/tests/tc07_hbl1.vgtest b/helgrind/tests/tc07_hbl1.vgtest
new file mode 100644
index 0000000..71c463f
--- /dev/null
+++ b/helgrind/tests/tc07_hbl1.vgtest
@@ -0,0 +1 @@
+prog: tc07_hbl1
diff --git a/helgrind/tests/tc08_hbl2.c b/helgrind/tests/tc08_hbl2.c
new file mode 100644
index 0000000..5362faa
--- /dev/null
+++ b/helgrind/tests/tc08_hbl2.c
@@ -0,0 +1,117 @@
+
+/* FIXME: this is basically a bad test as it is scheduling-
+ sensitive. Sometimes the output is:
+
+ child: new value 6
+ child: new value 10
+ done, x = 10
+
+ and sometimes
+
+ child: new value 10
+ done, x = 10
+*/
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+/* Simple test program, no race. Parent writes atomically to a counter
+ whilst child reads it. When counter reaches a prearranged value,
+ child joins back to parent. Parent (writer) uses hardware bus lock;
+ child is only reading and so does not need to use a bus lock. */
+
+
+#undef PLAT_x86_linux
+#undef PLAT_amd64_linux
+#undef PLAT_ppc32_linux
+#undef PLAT_ppc64_linux
+#undef PLAT_ppc32_aix5
+#undef PLAT_ppc64_aix5
+
+#if !defined(_AIX) && defined(__i386__)
+# define PLAT_x86_linux 1
+#elif !defined(_AIX) && defined(__x86_64__)
+# define PLAT_amd64_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && !defined(__powerpc64__)
+# define PLAT_ppc32_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && defined(__powerpc64__)
+# define PLAT_ppc64_linux 1
+#elif defined(_AIX) && defined(__64BIT__)
+# define PLAT_ppc64_aix5 1
+#elif defined(_AIX) && !defined(__64BIT__)
+# define PLAT_ppc32_aix5 1
+#endif
+
+
+#if defined(PLAT_amd64_linux) || defined(PLAT_x86_linux)
+# define INC(_lval) \
+ __asm__ __volatile__ ( \
+ "lock ; incl (%0)" : /*out*/ : /*in*/"r"(&(_lval)) : "memory", "cc" )
+#elif defined(PLAT_ppc32_linux) || defined(PLAT_ppc64_linux)
+# define INC(_lval) \
+ __asm__ __volatile__( \
+ "1:\n" \
+ " lwarx 15,0,%0\n" \
+ " addi 15,15,1\n" \
+ " stwcx. 15,0,%0\n" \
+ " bne- 1b" \
+ : /*out*/ : /*in*/ "b"(&(_lval)) \
+ : /*trash*/ "r15", "cr0", "memory" \
+ )
+#else
+# error "Fix Me for this platform"
+#endif
+
+
+
+#define LIMIT 10
+
+volatile int x = 0;
+
+void* child_fn ( void* arg )
+{
+ int q = 0;
+ int oldx = 0;
+ int ctr = 0;
+ while (1) {
+ q = (x >= LIMIT);
+ if (x != oldx) {
+ oldx = x;
+ printf("child: new value %d\n", oldx);
+ fflush(stdout);
+ }
+ if (q) break;
+ /* Make sure the parent doesn't starve. Seems to be a problem
+ on very slow machines. */
+ ctr++;
+ if (ctr == 2000000) sleep(1);
+ }
+ return NULL;
+}
+
+int main ( void )
+{
+ pthread_t child;
+ int i;
+
+ if (pthread_create(&child, NULL, child_fn, NULL)) {
+ perror("pthread_create");
+ exit(1);
+ }
+
+ for (i = 0; i < LIMIT; i++) {
+ INC(x);
+ if (i == 5) sleep(1); /* make sure child doesn't starve */
+ }
+
+ if (pthread_join(child, NULL)) {
+ perror("pthread join");
+ exit(1);
+ }
+
+ printf("done, x = %d\n", x);
+
+ return 0;
+}
diff --git a/helgrind/tests/tc08_hbl2.stderr.exp-glibc25-amd64 b/helgrind/tests/tc08_hbl2.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/tc08_hbl2.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc08_hbl2.stdout.exp b/helgrind/tests/tc08_hbl2.stdout.exp
new file mode 100644
index 0000000..ce39ad5
--- /dev/null
+++ b/helgrind/tests/tc08_hbl2.stdout.exp
@@ -0,0 +1,3 @@
+child: new value 6
+child: new value 10
+done, x = 10
diff --git a/helgrind/tests/tc08_hbl2.vgtest b/helgrind/tests/tc08_hbl2.vgtest
new file mode 100644
index 0000000..6d0a2cb
--- /dev/null
+++ b/helgrind/tests/tc08_hbl2.vgtest
@@ -0,0 +1 @@
+prog: tc08_hbl2
diff --git a/helgrind/tests/tc09_bad_unlock.c b/helgrind/tests/tc09_bad_unlock.c
new file mode 100644
index 0000000..bb44eb3
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.c
@@ -0,0 +1,52 @@
+
+/* Check that an error is reported for various kinds of bogus
+ pthread_mutex_unlock calls. */
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void* child_fn ( void* arg )
+{
+ pthread_mutex_unlock( (pthread_mutex_t*)arg ); /* ERROR */
+ return NULL;
+}
+
+void nearly_main ( void )
+{
+ pthread_t child;
+ pthread_mutex_t mx1, mx2;
+ int bogus[100], i;
+ /* fill bogus with values which will cause glibc's pth_mx_unlock to fail */
+ for (i = 0; i < 100; i++) bogus[i] = 0xFFFFFFFF;
+ /* Unlocking a lock that is already unlocked */
+ pthread_mutex_init( &mx1, NULL );
+ pthread_mutex_lock( &mx1 );
+ pthread_mutex_unlock( &mx1 );
+
+ pthread_mutex_unlock( &mx1 ); /* ERROR */
+
+ /* Unlocking a lock that is held by a different thread */
+
+ pthread_mutex_init( &mx2, NULL );
+ pthread_mutex_lock( &mx2 );
+ // start child and get it to unlock this lock
+
+ pthread_create( &child, NULL, child_fn, (void*)&mx2 );
+ /* child runs and attempts to unlock our lock. Error
+ is reported in child_fn. */
+ pthread_join(child, NULL );
+
+ /* Unlocking a totally bogus lock. */
+ pthread_mutex_unlock( (pthread_mutex_t*) &bogus[50] ); /* ERROR */
+
+ /* Now we get a freeing-locked-lock error, since the stack
+ frame is removed whilst mx2 is still locked. */
+}
+
+int main ( void )
+{
+ nearly_main();
+ nearly_main();
+ return 0;
+}
diff --git a/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc23-amd64 b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc23-amd64
new file mode 100644
index 0000000..dc6bf41
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc23-amd64
@@ -0,0 +1,86 @@
+
+Thread #1 is the program's root thread
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:27)
+ by 0x........: main (tc09_bad_unlock.c:49)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:23)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:35)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 unlocked lock at 0x........ currently held by thread #1
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: child_fn (tc09_bad_unlock.c:11)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked an invalid lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:41)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: nearly_main (tc09_bad_unlock.c:45)
+ by 0x........: main (tc09_bad_unlock.c:49)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:27)
+ by 0x........: main (tc09_bad_unlock.c:50)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:23)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:35)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 unlocked lock at 0x........ currently held by thread #1
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: child_fn (tc09_bad_unlock.c:11)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 unlocked an invalid lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:41)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: nearly_main (tc09_bad_unlock.c:45)
+ by 0x........: main (tc09_bad_unlock.c:50)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+ERROR SUMMARY: 8 errors from 8 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-amd64 b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..e851dc2
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-amd64
@@ -0,0 +1,98 @@
+
+Thread #1 is the program's root thread
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:27)
+ by 0x........: main (tc09_bad_unlock.c:49)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:23)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:35)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 unlocked lock at 0x........ currently held by thread #1
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: child_fn (tc09_bad_unlock.c:11)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked an invalid lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:41)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1's call to pthread_mutex_unlock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:41)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: nearly_main (tc09_bad_unlock.c:45)
+ by 0x........: main (tc09_bad_unlock.c:49)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:27)
+ by 0x........: main (tc09_bad_unlock.c:50)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:23)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:35)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 unlocked lock at 0x........ currently held by thread #1
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: child_fn (tc09_bad_unlock.c:11)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 unlocked an invalid lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:41)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1's call to pthread_mutex_unlock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:41)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: nearly_main (tc09_bad_unlock.c:45)
+ by 0x........: main (tc09_bad_unlock.c:50)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+ERROR SUMMARY: 10 errors from 10 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-x86 b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..84601c4
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-x86
@@ -0,0 +1,96 @@
+
+Thread #1 is the program's root thread
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:27)
+ by 0x........: main (tc09_bad_unlock.c:49)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:23)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:35)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 unlocked lock at 0x........ currently held by thread #1
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: child_fn (tc09_bad_unlock.c:11)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked an invalid lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:41)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1's call to pthread_mutex_unlock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:41)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: nearly_main (tc09_bad_unlock.c:45)
+ by 0x........: main (tc09_bad_unlock.c:49)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:27)
+ by 0x........: main (tc09_bad_unlock.c:50)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:23)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:35)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 unlocked lock at 0x........ currently held by thread #1
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: child_fn (tc09_bad_unlock.c:11)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 unlocked an invalid lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:41)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1's call to pthread_mutex_unlock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:41)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: nearly_main (tc09_bad_unlock.c:45)
+ by 0x........: main (tc09_bad_unlock.c:50)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc09_bad_unlock.c:31)
+ by 0x........: main (tc09_bad_unlock.c:50)
+
+ERROR SUMMARY: 10 errors from 10 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc09_bad_unlock.stdout.exp b/helgrind/tests/tc09_bad_unlock.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.stdout.exp
diff --git a/helgrind/tests/tc09_bad_unlock.vgtest b/helgrind/tests/tc09_bad_unlock.vgtest
new file mode 100644
index 0000000..d09a702
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.vgtest
@@ -0,0 +1 @@
+prog: tc09_bad_unlock
diff --git a/helgrind/tests/tc10_rec_lock.c b/helgrind/tests/tc10_rec_lock.c
new file mode 100644
index 0000000..648305c
--- /dev/null
+++ b/helgrind/tests/tc10_rec_lock.c
@@ -0,0 +1,49 @@
+
+/* Do simple things with a recursive mutex. */
+
+/* Needed for older glibcs (2.3 and older, at least) who don't
+ otherwise "know" about pthread_rwlock_anything or about
+ PTHREAD_MUTEX_RECURSIVE (amongst things). */
+#define _GNU_SOURCE 1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+
+void nearly_main ( void )
+{
+ pthread_mutex_t mx1;
+ pthread_mutexattr_t attr;
+ int r;
+
+ r = pthread_mutexattr_init( &attr );
+ assert(r==0);
+ r = pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
+ assert(r==0);
+ r = pthread_mutex_init( &mx1, &attr );
+ assert(r==0);
+
+ fprintf(stderr, "before lock #1\n");
+ r = pthread_mutex_lock( &mx1 ); assert(r == 0);
+ fprintf(stderr, "before lock #2\n");
+ r = pthread_mutex_lock( &mx1 ); assert(r == 0);
+ fprintf(stderr, "before lock #3\n");
+ r = pthread_mutex_lock( &mx1 ); assert(r == 0);
+
+ fprintf(stderr, "before unlock #1\n");
+ r = pthread_mutex_unlock( &mx1 ); assert(r == 0);
+ fprintf(stderr, "before unlock #2\n");
+ r = pthread_mutex_unlock( &mx1 ); assert(r == 0);
+ fprintf(stderr, "before unlock #3\n");
+ r = pthread_mutex_unlock( &mx1 ); assert(r == 0);
+
+ fprintf(stderr, "before unlock #4\n");
+ r = pthread_mutex_unlock( &mx1 ); /* FAILS: assert(r == 0); */
+}
+
+int main ( void )
+{
+ nearly_main();
+ return 0;
+}
diff --git a/helgrind/tests/tc10_rec_lock.stderr.exp-glibc25-amd64 b/helgrind/tests/tc10_rec_lock.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..a301ee7
--- /dev/null
+++ b/helgrind/tests/tc10_rec_lock.stderr.exp-glibc25-amd64
@@ -0,0 +1,26 @@
+
+before lock #1
+before lock #2
+before lock #3
+before unlock #1
+before unlock #2
+before unlock #3
+before unlock #4
+Thread #1 is the program's root thread
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc10_rec_lock.c:42)
+ by 0x........: main (tc10_rec_lock.c:47)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc10_rec_lock.c:24)
+ by 0x........: main (tc10_rec_lock.c:47)
+
+Thread #1's call to pthread_mutex_unlock failed
+ with error code 1 (EPERM: Operation not permitted)
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: nearly_main (tc10_rec_lock.c:42)
+ by 0x........: main (tc10_rec_lock.c:47)
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc10_rec_lock.stdout.exp b/helgrind/tests/tc10_rec_lock.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc10_rec_lock.stdout.exp
diff --git a/helgrind/tests/tc10_rec_lock.vgtest b/helgrind/tests/tc10_rec_lock.vgtest
new file mode 100644
index 0000000..bfd0f89
--- /dev/null
+++ b/helgrind/tests/tc10_rec_lock.vgtest
@@ -0,0 +1 @@
+prog: tc10_rec_lock
diff --git a/helgrind/tests/tc11_XCHG.c b/helgrind/tests/tc11_XCHG.c
new file mode 100644
index 0000000..5b46c7e
--- /dev/null
+++ b/helgrind/tests/tc11_XCHG.c
@@ -0,0 +1,92 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/* Simple test program, no race. Parent and child both modify x and
+ use the hardware bus lock (implicitly, since XCHG r,m on x86/amd64
+ does not require an explicit LOCK prefix.). */
+
+#undef PLAT_x86_linux
+#undef PLAT_amd64_linux
+#undef PLAT_ppc32_linux
+#undef PLAT_ppc64_linux
+#undef PLAT_ppc32_aix5
+#undef PLAT_ppc64_aix5
+
+#if !defined(_AIX) && defined(__i386__)
+# define PLAT_x86_linux 1
+#elif !defined(_AIX) && defined(__x86_64__)
+# define PLAT_amd64_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && !defined(__powerpc64__)
+# define PLAT_ppc32_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && defined(__powerpc64__)
+# define PLAT_ppc64_linux 1
+#elif defined(_AIX) && defined(__64BIT__)
+# define PLAT_ppc64_aix5 1
+#elif defined(_AIX) && !defined(__64BIT__)
+# define PLAT_ppc32_aix5 1
+#endif
+
+
+#if defined(PLAT_amd64_linux) || defined(PLAT_x86_linux)
+# define XCHG_M_R(_addr,_lval) \
+ __asm__ __volatile__( \
+ "xchgl %0, %1" \
+ : /*out*/ "+r"(_lval) \
+ : /*in*/ "m"(_addr) \
+ : "memory", "cc" \
+ )
+# define XCHG_M_R_with_redundant_LOCK(_addr,_lval) \
+ __asm__ __volatile__( \
+ "lock xchgl %0, %1" \
+ : /*out*/ "+r"(_lval) \
+ : /*in*/ "m"(_addr) \
+ : "memory", "cc" \
+ )
+#else
+# define XCHG_M_R(_addr,_lval) \
+ do { int tmp = *(int*)(& _addr); \
+ *(int*)(& _addr) = (_lval); \
+ _lval = tmp; \
+ } while (0)
+# define XCHG_M_R_with_redundant_LOCK(_addr,_lval) \
+ XCHG_M_R(_addr,_lval)
+#endif
+
+int x = 0;
+
+void* child_fn ( void* arg )
+{
+ int v = 12345;
+ XCHG_M_R_with_redundant_LOCK(x, v);
+ assert(v == 0 || v == 6789);
+ return NULL;
+}
+
+int main ( void )
+{
+ int v = 6789;
+ pthread_t child;
+
+ if (pthread_create(&child, NULL, child_fn, NULL)) {
+ perror("pthread_create");
+ exit(1);
+ }
+
+ XCHG_M_R(x, v);
+ assert(v == 0 || v == 12345);
+
+ if (pthread_join(child, NULL)) {
+ perror("pthread join");
+ exit(1);
+ }
+
+ if (v == 0 || v == 12345)
+ printf("success\n");
+ else
+ printf("failure\n");
+
+ return v;
+}
diff --git a/helgrind/tests/tc11_XCHG.stderr.exp-glibc25-amd64 b/helgrind/tests/tc11_XCHG.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/tc11_XCHG.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc11_XCHG.stdout.exp b/helgrind/tests/tc11_XCHG.stdout.exp
new file mode 100644
index 0000000..2e9ba47
--- /dev/null
+++ b/helgrind/tests/tc11_XCHG.stdout.exp
@@ -0,0 +1 @@
+success
diff --git a/helgrind/tests/tc11_XCHG.vgtest b/helgrind/tests/tc11_XCHG.vgtest
new file mode 100644
index 0000000..342199b
--- /dev/null
+++ b/helgrind/tests/tc11_XCHG.vgtest
@@ -0,0 +1 @@
+prog: tc11_XCHG
diff --git a/helgrind/tests/tc12_rwl_trivial.c b/helgrind/tests/tc12_rwl_trivial.c
new file mode 100644
index 0000000..9dc8e84
--- /dev/null
+++ b/helgrind/tests/tc12_rwl_trivial.c
@@ -0,0 +1,34 @@
+
+/* Needed for older glibcs (2.3 and older, at least) who don't
+ otherwise "know" about pthread_rwlock_anything or about
+ PTHREAD_MUTEX_RECURSIVE (amongst things). */
+#define _GNU_SOURCE 1
+
+#include <stdio.h>
+#include <pthread.h>
+#include <assert.h>
+
+/* Do trivial stuff with a reader-writer lock. */
+
+int main ( void )
+{
+ int r;
+ pthread_rwlock_t rwl;
+
+ r = pthread_rwlock_init( &rwl, NULL ); assert(r == 0);
+
+ r = pthread_rwlock_wrlock( &rwl ); assert(r == 0);
+ r = pthread_rwlock_unlock( &rwl ); assert(r == 0);
+
+ r = pthread_rwlock_rdlock( &rwl ); assert(r == 0);
+ r = pthread_rwlock_rdlock( &rwl ); assert(r == 0);
+ r = pthread_rwlock_unlock( &rwl ); assert(r == 0);
+ r = pthread_rwlock_unlock( &rwl ); assert(r == 0);
+
+ /* this should fail - lock is unowned now */
+ r = pthread_rwlock_unlock( &rwl ); assert(r == 0);
+
+ r = pthread_rwlock_destroy( &rwl ); assert(r == 0);
+
+ return 0;
+}
diff --git a/helgrind/tests/tc12_rwl_trivial.stderr.exp-glibc25-amd64 b/helgrind/tests/tc12_rwl_trivial.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..cbc403e
--- /dev/null
+++ b/helgrind/tests/tc12_rwl_trivial.stderr.exp-glibc25-amd64
@@ -0,0 +1,11 @@
+
+Thread #1 is the program's root thread
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc12_rwl_trivial.c:29)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc12_rwl_trivial.c:18)
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc12_rwl_trivial.stdout.exp b/helgrind/tests/tc12_rwl_trivial.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc12_rwl_trivial.stdout.exp
diff --git a/helgrind/tests/tc12_rwl_trivial.vgtest b/helgrind/tests/tc12_rwl_trivial.vgtest
new file mode 100644
index 0000000..fdcd644
--- /dev/null
+++ b/helgrind/tests/tc12_rwl_trivial.vgtest
@@ -0,0 +1 @@
+prog: tc12_rwl_trivial
diff --git a/helgrind/tests/tc13_laog1.c b/helgrind/tests/tc13_laog1.c
new file mode 100644
index 0000000..e42ca98
--- /dev/null
+++ b/helgrind/tests/tc13_laog1.c
@@ -0,0 +1,33 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/* The simplest possible test that triggers a lock order acquisition
+ error. */
+
+int main ( void )
+{
+ int r;
+ pthread_mutex_t mx1, mx2;
+ r = pthread_mutex_init( &mx1, NULL ); assert(r==0);
+ r = pthread_mutex_init( &mx2, NULL ); assert(r==0);
+
+ r = pthread_mutex_lock( &mx1 ); assert(r==0);
+ r = pthread_mutex_lock( &mx2 ); assert(r==0);
+
+ r = pthread_mutex_unlock( &mx1 ); assert(r==0);
+ r = pthread_mutex_unlock( &mx2 ); assert(r==0);
+
+ r = pthread_mutex_lock( &mx2 ); assert(r==0); /* error */
+ r = pthread_mutex_lock( &mx1 ); assert(r==0);
+
+ r = pthread_mutex_unlock( &mx1 ); assert(r==0);
+ r = pthread_mutex_unlock( &mx2 ); assert(r==0);
+
+ r = pthread_mutex_destroy( &mx1 );
+ r = pthread_mutex_destroy( &mx2 );
+
+ return 0;
+}
diff --git a/helgrind/tests/tc13_laog1.stderr.exp-glibc25-amd64 b/helgrind/tests/tc13_laog1.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..74aa263
--- /dev/null
+++ b/helgrind/tests/tc13_laog1.stderr.exp-glibc25-amd64
@@ -0,0 +1,14 @@
+
+Thread #1 is the program's root thread
+
+Thread #1: lock order "0x........ before 0x........" violated
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: main (tc13_laog1.c:24)
+ Required order was established by acquisition of lock at 0x........
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: main (tc13_laog1.c:17)
+ followed by a later acquisition of lock at 0x........
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: main (tc13_laog1.c:18)
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc13_laog1.stdout.exp b/helgrind/tests/tc13_laog1.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc13_laog1.stdout.exp
diff --git a/helgrind/tests/tc13_laog1.vgtest b/helgrind/tests/tc13_laog1.vgtest
new file mode 100644
index 0000000..9fa71cd
--- /dev/null
+++ b/helgrind/tests/tc13_laog1.vgtest
@@ -0,0 +1 @@
+prog: tc13_laog1
diff --git a/helgrind/tests/tc14_laog_dinphils.c b/helgrind/tests/tc14_laog_dinphils.c
new file mode 100644
index 0000000..c5af8c1
--- /dev/null
+++ b/helgrind/tests/tc14_laog_dinphils.c
@@ -0,0 +1,42 @@
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+/* Naive dining philosophers with inconsistent lock acquisition
+ ordering. */
+
+static pthread_t phil[5];
+static pthread_mutex_t chop[5];
+
+void* dine ( void* arg )
+{
+ int i;
+ long left = (long)arg;
+ long right = (left + 1) % 5;
+ for (i = 0; i < 1000/*arbitrary*/; i++) {
+ pthread_mutex_lock(&chop[left]);
+ pthread_mutex_lock(&chop[right]);
+ /* eating */
+ pthread_mutex_unlock(&chop[left]);
+ pthread_mutex_unlock(&chop[right]);
+ }
+ return NULL;
+}
+
+int main ( void )
+{
+ long i;
+ for (i = 0; i < 5; i++)
+ pthread_mutex_init( &chop[i], NULL);
+
+ for (i = 0; i < 5; i++)
+ pthread_create(&phil[i], NULL, dine, (void*)i );
+
+ sleep(1);
+
+ for (i = 0; i < 5; i++)
+ pthread_join(phil[i], NULL);
+
+ return 0;
+}
diff --git a/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-amd64 b/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..5cedeb8
--- /dev/null
+++ b/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-amd64
@@ -0,0 +1,16 @@
+
+Thread #6 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc14_laog_dinphils.c:34)
+
+Thread #6: lock order "0x........ before 0x........" violated
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: dine (tc14_laog_dinphils.c:19)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+
+ERROR SUMMARY: 1000 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-x86 b/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..c4db6cf
--- /dev/null
+++ b/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-x86
@@ -0,0 +1,15 @@
+
+Thread #6 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc14_laog_dinphils.c:34)
+
+Thread #6: lock order "0x........ before 0x........" violated
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: dine (tc14_laog_dinphils.c:19)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+
+ERROR SUMMARY: 1000 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc14_laog_dinphils.stdout.exp b/helgrind/tests/tc14_laog_dinphils.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc14_laog_dinphils.stdout.exp
diff --git a/helgrind/tests/tc14_laog_dinphils.vgtest b/helgrind/tests/tc14_laog_dinphils.vgtest
new file mode 100644
index 0000000..5871b73
--- /dev/null
+++ b/helgrind/tests/tc14_laog_dinphils.vgtest
@@ -0,0 +1 @@
+prog: tc14_laog_dinphils
diff --git a/helgrind/tests/tc15_laog_lockdel.c b/helgrind/tests/tc15_laog_lockdel.c
new file mode 100644
index 0000000..ff01605
--- /dev/null
+++ b/helgrind/tests/tc15_laog_lockdel.c
@@ -0,0 +1,68 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/* Test that locks, having entered the lock acquisition tracking
+ machinery, are forgotten by it when the memory they reside in
+ becomes inaccessible. */
+
+int main ( void )
+{
+ int r;
+ pthread_mutex_t *mx1, *mx2;
+
+ mx1 = malloc(sizeof(pthread_mutex_t));
+ mx2 = malloc(sizeof(pthread_mutex_t));
+
+ assert(mx1);
+ assert(mx2);
+
+ r = pthread_mutex_init( mx1, NULL ); assert(r==0);
+ r = pthread_mutex_init( mx2, NULL ); assert(r==0);
+
+ /* Establish order 1 -> 2 */
+ fprintf(stderr, "Establish order 1 -> 2\n");
+ r = pthread_mutex_lock( mx1 ); assert(r==0);
+ r = pthread_mutex_lock( mx2 ); assert(r==0);
+
+ r = pthread_mutex_unlock( mx1 ); assert(r==0);
+ r = pthread_mutex_unlock( mx2 ); assert(r==0);
+
+ /* Try order 2 -> 1. This gives an error. */
+ fprintf(stderr, "Try order 2 -> 1. This gives an error.\n");
+ r = pthread_mutex_lock( mx2 ); assert(r==0); /* error */
+ r = pthread_mutex_lock( mx1 ); assert(r==0);
+
+ r = pthread_mutex_unlock( mx1 ); assert(r==0);
+ r = pthread_mutex_unlock( mx2 ); assert(r==0);
+
+ /* Free 2 and re-allocate it. This gives it a new identity,
+ so a second locking sequence 2 -> 1 should now be OK. */
+ fprintf(stderr,
+ "Free 2 and re-allocate it. This gives it a new identity,\n");
+ fprintf(stderr, "so a second locking sequence 2 -> 1 should now be OK.\n");
+ pthread_mutex_destroy( mx2 );
+ free(mx2);
+ mx2 = malloc(sizeof(pthread_mutex_t));
+ assert(mx2);
+ r = pthread_mutex_init( mx2, NULL ); assert(r==0);
+
+ r = pthread_mutex_lock( mx2 ); assert(r==0); /* error */
+ r = pthread_mutex_lock( mx1 ); assert(r==0);
+
+ r = pthread_mutex_unlock( mx1 ); assert(r==0);
+ r = pthread_mutex_unlock( mx2 ); assert(r==0);
+
+ /* done */
+
+ fprintf(stderr, "done\n");
+ r = pthread_mutex_destroy( mx1 );
+ r = pthread_mutex_destroy( mx2 );
+
+ free( mx1 );
+ free( mx2 );
+
+ return 0;
+}
diff --git a/helgrind/tests/tc15_laog_lockdel.stderr.exp-glibc25-amd64 b/helgrind/tests/tc15_laog_lockdel.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..4bab304
--- /dev/null
+++ b/helgrind/tests/tc15_laog_lockdel.stderr.exp-glibc25-amd64
@@ -0,0 +1,19 @@
+
+Establish order 1 -> 2
+Try order 2 -> 1. This gives an error.
+Thread #1 is the program's root thread
+
+Thread #1: lock order "0x........ before 0x........" violated
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: main (tc15_laog_lockdel.c:36)
+ Required order was established by acquisition of lock at 0x........
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: main (tc15_laog_lockdel.c:27)
+ followed by a later acquisition of lock at 0x........
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: main (tc15_laog_lockdel.c:28)
+Free 2 and re-allocate it. This gives it a new identity,
+so a second locking sequence 2 -> 1 should now be OK.
+done
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc15_laog_lockdel.stdout.exp b/helgrind/tests/tc15_laog_lockdel.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc15_laog_lockdel.stdout.exp
diff --git a/helgrind/tests/tc15_laog_lockdel.vgtest b/helgrind/tests/tc15_laog_lockdel.vgtest
new file mode 100644
index 0000000..bd7a2ec
--- /dev/null
+++ b/helgrind/tests/tc15_laog_lockdel.vgtest
@@ -0,0 +1 @@
+prog: tc15_laog_lockdel
diff --git a/helgrind/tests/tc16_byterace.c b/helgrind/tests/tc16_byterace.c
new file mode 100644
index 0000000..1916c37
--- /dev/null
+++ b/helgrind/tests/tc16_byterace.c
@@ -0,0 +1,42 @@
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple demonstration of lockset tracking at byte granularity. */
+
+char bytes[10];
+
+void* child_fn ( void* arg )
+{
+ int i;
+ for (i = 0; i < 5; i++)
+ bytes[2*i + 0] ++;
+ return NULL;
+}
+
+int main ( void )
+{
+ int i;
+ pthread_t child;
+
+ if (pthread_create(&child, NULL, child_fn, NULL)) {
+ perror("pthread_create");
+ exit(1);
+ }
+
+ /* Unprotected relative to child, but harmless, since different
+ bytes accessed */
+ for (i = 0; i < 5; i++)
+ bytes[2*i + 1] ++;
+
+ /* Unprotected relative to child, but harmful; same bytes */
+ for (i = 0; i < 3; i++)
+ bytes[3*i + 1] ++;
+
+ if (pthread_join(child, NULL)) {
+ perror("pthread join");
+ exit(1);
+ }
+
+ return 0;
+}
diff --git a/helgrind/tests/tc16_byterace.stderr.exp-glibc25-amd64 b/helgrind/tests/tc16_byterace.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..e4286bc
--- /dev/null
+++ b/helgrind/tests/tc16_byterace.stderr.exp-glibc25-amd64
@@ -0,0 +1,18 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc16_byterace.c:22)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: main (tc16_byterace.c:34)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc16_byterace.stderr.exp-glibc25-x86 b/helgrind/tests/tc16_byterace.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..d7ffb0a
--- /dev/null
+++ b/helgrind/tests/tc16_byterace.stderr.exp-glibc25-x86
@@ -0,0 +1,17 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc16_byterace.c:22)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: main (tc16_byterace.c:34)
+ Old state: shared-readonly by threads #1, #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc16_byterace.stdout.exp b/helgrind/tests/tc16_byterace.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc16_byterace.stdout.exp
diff --git a/helgrind/tests/tc16_byterace.vgtest b/helgrind/tests/tc16_byterace.vgtest
new file mode 100644
index 0000000..a8bf0f1
--- /dev/null
+++ b/helgrind/tests/tc16_byterace.vgtest
@@ -0,0 +1 @@
+prog: tc16_byterace
diff --git a/helgrind/tests/tc17_sembar.c b/helgrind/tests/tc17_sembar.c
new file mode 100644
index 0000000..01af962
--- /dev/null
+++ b/helgrind/tests/tc17_sembar.c
@@ -0,0 +1,212 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+/* This is really a test of semaphore handling
+ (sem_{init,destroy,post,wait}). Using semaphores a barrier
+ function is created. Thrcheck does understand the barrier
+ semantics implied by the barrier, as pieced together from
+ happens-before relationships obtained from the component
+ semaphores. However, it does falsely report one race. Ah well. */
+
+/* This code is derived from
+ gcc-4.3-20071012/libgomp/config/posix/bar.c, which is
+
+ Copyright (C) 2005 Free Software Foundation, Inc.
+ Contributed by Richard Henderson <rth@redhat.com>.
+
+ and available under version 2.1 or later of the GNU Lesser General
+ Public License.
+
+ Relative to the libgomp sources, the gomp_barrier_t type here has
+ an extra semaphore field, xxx. This is not functionally useful,
+ but it is used to create enough extra inter-thread dependencies
+ that the barrier-like behaviour of gomp_barrier_t is evident to
+ Thrcheck. There is no other purpose for the .xxx field. */
+
+typedef struct
+{
+ pthread_mutex_t mutex1;
+ pthread_mutex_t mutex2;
+ sem_t sem1;
+ sem_t sem2;
+ unsigned total;
+ unsigned arrived;
+ sem_t xxx;
+} gomp_barrier_t;
+
+typedef long bool;
+
+void
+gomp_barrier_init (gomp_barrier_t *bar, unsigned count)
+{
+ pthread_mutex_init (&bar->mutex1, NULL);
+ pthread_mutex_init (&bar->mutex2, NULL);
+ sem_init (&bar->sem1, 0, 0);
+ sem_init (&bar->sem2, 0, 0);
+ sem_init (&bar->xxx, 0, 0);
+ bar->total = count;
+ bar->arrived = 0;
+}
+
+void
+gomp_barrier_destroy (gomp_barrier_t *bar)
+{
+ /* Before destroying, make sure all threads have left the barrier. */
+ pthread_mutex_lock (&bar->mutex1);
+ pthread_mutex_unlock (&bar->mutex1);
+
+ pthread_mutex_destroy (&bar->mutex1);
+ pthread_mutex_destroy (&bar->mutex2);
+ sem_destroy (&bar->sem1);
+ sem_destroy (&bar->sem2);
+ sem_destroy(&bar->xxx);
+}
+
+void
+gomp_barrier_reinit (gomp_barrier_t *bar, unsigned count)
+{
+ pthread_mutex_lock (&bar->mutex1);
+ bar->total = count;
+ pthread_mutex_unlock (&bar->mutex1);
+}
+
+void
+gomp_barrier_wait (gomp_barrier_t *bar)
+{
+ unsigned int n;
+ pthread_mutex_lock (&bar->mutex1);
+
+ ++bar->arrived;
+
+ if (bar->arrived == bar->total)
+ {
+ bar->arrived--;
+ n = bar->arrived;
+ if (n > 0)
+ {
+ { unsigned int i;
+ for (i = 0; i < n; i++)
+ sem_wait(&bar->xxx); // acquire an obvious dependency from
+ // all other threads arriving at the barrier
+ }
+ // 1 up n times, 2 down once
+ // now let all the other threads past the barrier, giving them
+ // an obvious dependency with this thread.
+ do
+ sem_post (&bar->sem1); // 1 up
+ while (--n != 0);
+ // and wait till the last thread has left
+ sem_wait (&bar->sem2); // 2 down
+ }
+ pthread_mutex_unlock (&bar->mutex1);
+ /* «Résultats professionnels!» First we made this thread have an
+ obvious (Thrcheck-visible) dependency on all other threads
+ calling gomp_barrier_wait. Then, we released them all again,
+ so they all have a (visible) dependency on this thread.
+ Transitively, the result is that all threads leaving the
+ barrier have a a Thrcheck-visible dependency on all threads
+ arriving at the barrier. As required. */
+ }
+ else
+ {
+ pthread_mutex_unlock (&bar->mutex1);
+ sem_post(&bar->xxx);
+ // first N-1 threads wind up waiting here
+ sem_wait (&bar->sem1); // 1 down
+
+ pthread_mutex_lock (&bar->mutex2);
+ n = --bar->arrived; /* XXX see below */
+ pthread_mutex_unlock (&bar->mutex2);
+
+ if (n == 0)
+ sem_post (&bar->sem2); // 2 up
+ }
+}
+
+
+/* re XXX, thrcheck reports a race at this point. It doesn't
+ understand that bar->arrived is protected by mutex1 whilst threads
+ are arriving at the barrier and by mutex2 whilst they are leaving,
+ but not consistently by either of them. Oh well. */
+
+static gomp_barrier_t bar;
+
+/* What's with the volatile here? It stops gcc compiling
+ "if (myid == 4) { unprotected = 99; }" and
+ "if (myid == 3) { unprotected = 88; }" into a conditional
+ load followed by a store. The cmov/store sequence reads and
+ writes memory in all threads and cause Thrcheck to (correctly)
+ report a race, the underlying cause of which is that gcc is
+ generating non threadsafe code.
+
+ (The lack of) thread safe code generation by gcc is currently a
+ hot topic. See the following discussions:
+ http://gcc.gnu.org/ml/gcc/2007-10/msg00266.html
+ http://lkml.org/lkml/2007/10/24/673
+ and this is interesting background:
+ www.hpl.hp.com/techreports/2004/HPL-2004-209.pdf
+*/
+volatile static long unprotected = 0;
+
+void* child ( void* argV )
+{
+ long myid = (long)argV;
+ // assert(myid >= 2 && myid <= 5);
+
+ /* First, we all wait to get to this point. */
+ gomp_barrier_wait( &bar );
+
+ /* Now, thread #4 writes to 'unprotected' and so becomes its
+ owner. */
+ if (myid == 4) {
+ unprotected = 99;
+ }
+
+ /* Now we all wait again. */
+ gomp_barrier_wait( &bar );
+
+ /* This time, thread #3 writes to 'unprotected'. If all goes well,
+ Thrcheck sees the dependency through the barrier back to thread
+ #4 before it, and so thread #3 becomes the exclusive owner of
+ 'unprotected'. */
+ if (myid == 3) {
+ unprotected = 88;
+ }
+
+ /* And just to be on the safe side ... */
+ gomp_barrier_wait( &bar );
+ return NULL;
+}
+
+
+int main (int argc, char *argv[])
+{
+ long i; int res;
+ pthread_t thr[4];
+ fprintf(stderr, "starting\n");
+
+ gomp_barrier_init( &bar, 4 );
+
+ for (i = 0; i < 4; i++) {
+ res = pthread_create( &thr[i], NULL, child, (void*)(i+2) );
+ assert(!res);
+ }
+
+ for (i = 0; i < 4; i++) {
+ res = pthread_join( thr[i], NULL );
+ assert(!res);
+ }
+
+ gomp_barrier_destroy( &bar );
+
+ /* And finally here, the root thread can get exclusive ownership
+ back from thread #4, because #4 has exited by this point and so
+ we have a dependency edge back to the write it did. */
+ fprintf(stderr, "done, result is %ld, should be 88\n", unprotected);
+
+ return 0;
+}
diff --git a/helgrind/tests/tc17_sembar.stderr.exp-glibc25-amd64 b/helgrind/tests/tc17_sembar.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..3600221
--- /dev/null
+++ b/helgrind/tests/tc17_sembar.stderr.exp-glibc25-amd64
@@ -0,0 +1,46 @@
+
+starting
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc17_sembar.c:195)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc17_sembar.c:195)
+
+Thread #4 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc17_sembar.c:195)
+
+Thread #5 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc17_sembar.c:195)
+
+Possible data race during read of size 4 at 0x........
+ at 0x........: gomp_barrier_wait (tc17_sembar.c:122)
+ by 0x........: child (tc17_sembar.c:161)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: shared-modified by threads #2, #3, #4, #5
+ New state: shared-modified by threads #2, #3, #4, #5
+ Reason: this thread, #2, holds no consistent locks
+ Last consistently used lock for 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: gomp_barrier_init (tc17_sembar.c:46)
+ by 0x........: main (tc17_sembar.c:192)
+done, result is 88, should be 88
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc17_sembar.stderr.exp-glibc25-x86 b/helgrind/tests/tc17_sembar.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..7675dbb
--- /dev/null
+++ b/helgrind/tests/tc17_sembar.stderr.exp-glibc25-x86
@@ -0,0 +1,42 @@
+
+starting
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc17_sembar.c:195)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc17_sembar.c:195)
+
+Thread #4 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc17_sembar.c:195)
+
+Thread #5 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc17_sembar.c:195)
+
+Possible data race during read of size 4 at 0x........
+ at 0x........: gomp_barrier_wait (tc17_sembar.c:122)
+ by 0x........: child (tc17_sembar.c:161)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: shared-modified by threads #2, #3, #4, #5
+ New state: shared-modified by threads #2, #3, #4, #5
+ Reason: this thread, #2, holds no consistent locks
+ Last consistently used lock for 0x........ was first observed
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: gomp_barrier_init (tc17_sembar.c:46)
+ by 0x........: main (tc17_sembar.c:192)
+done, result is 88, should be 88
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc17_sembar.stdout.exp b/helgrind/tests/tc17_sembar.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc17_sembar.stdout.exp
diff --git a/helgrind/tests/tc17_sembar.vgtest b/helgrind/tests/tc17_sembar.vgtest
new file mode 100644
index 0000000..643ed8a
--- /dev/null
+++ b/helgrind/tests/tc17_sembar.vgtest
@@ -0,0 +1 @@
+prog: tc17_sembar
diff --git a/helgrind/tests/tc18_semabuse.c b/helgrind/tests/tc18_semabuse.c
new file mode 100644
index 0000000..6e26ce4
--- /dev/null
+++ b/helgrind/tests/tc18_semabuse.c
@@ -0,0 +1,42 @@
+
+/* Do stupid things with semaphores, and check that Thrcheck doesn't
+ fall over and does report errors appropriately. If nothing else
+ this just checks that the relevant functions are getting
+ intercepted. */
+
+/* This is pretty lame, because making the sem_ functions fail is
+ difficult. Not sure it's really worth having. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <string.h>
+
+int main ( void )
+{
+ int r;
+ sem_t s1;
+
+ /* Do sem_init with huge initial count */
+ r= sem_init(&s1, 0, ~0);
+
+ /* initialise properly */
+ r= sem_init(&s1, 0, 0);
+
+ /* in glibc, sem_destroy is a no-op; making it fail is
+ impossible. */
+
+ /* Do 'wait' on a bogus semaphore. This should fail, but on glibc
+ it succeeds. */
+ memset(&s1, 0x55, sizeof(s1));
+ r= sem_wait(&s1); /* assert(r != 0); */
+
+ /* this really ought to fail, but it doesn't. */
+ r= sem_post(&s1); assert(!r);
+
+ sem_destroy(&s1);
+
+ return 0;
+}
diff --git a/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-amd64 b/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..f0519c0
--- /dev/null
+++ b/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-amd64
@@ -0,0 +1,14 @@
+
+Thread #1 is the program's root thread
+
+Thread #1's call to sem_init failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: sem_init@* (hg_intercepts.c:...)
+ by 0x........: main (tc18_semabuse.c:23)
+
+Thread #1: Bug in libpthread: sem_wait succeeded on semaphore without prior sem_post
+ at 0x........: sem_wait_WRK (hg_intercepts.c:...)
+ by 0x........: sem_wait (hg_intercepts.c:...)
+ by 0x........: main (tc18_semabuse.c:34)
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-x86 b/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..82f30d4
--- /dev/null
+++ b/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-x86
@@ -0,0 +1,14 @@
+
+Thread #1 is the program's root thread
+
+Thread #1's call to sem_init failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: sem_init@* (hg_intercepts.c:...)
+ by 0x........: main (tc18_semabuse.c:23)
+
+Thread #1: Bug in libpthread: sem_wait succeeded on semaphore without prior sem_post
+ at 0x........: sem_wait_WRK (hg_intercepts.c:...)
+ by 0x........: sem_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc18_semabuse.c:34)
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc18_semabuse.stdout.exp b/helgrind/tests/tc18_semabuse.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc18_semabuse.stdout.exp
diff --git a/helgrind/tests/tc18_semabuse.vgtest b/helgrind/tests/tc18_semabuse.vgtest
new file mode 100644
index 0000000..fe4d22b
--- /dev/null
+++ b/helgrind/tests/tc18_semabuse.vgtest
@@ -0,0 +1 @@
+prog: tc18_semabuse
diff --git a/helgrind/tests/tc19_shadowmem.c b/helgrind/tests/tc19_shadowmem.c
new file mode 100644
index 0000000..d652fa9
--- /dev/null
+++ b/helgrind/tests/tc19_shadowmem.c
@@ -0,0 +1,2291 @@
+
+#include <pthread.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "helgrind/helgrind.h"
+
+typedef
+ struct {
+ void* (*child)(void*);
+ char* arr;
+ int firstoff;
+ int lastoff;
+ int skipoff;
+ }
+ Info;
+
+pthread_mutex_t mx;
+
+void* child8 ( void* infoV )
+{
+ int r, i, firstoff, lastoff, skipoff;
+ char* arr;
+ Info* info = (Info*)infoV;
+ firstoff = info->firstoff;
+ lastoff = info->lastoff;
+ skipoff = info->skipoff;
+ arr = info->arr;
+ assert( sizeof(char) == 1 );
+ assert( info->child == &child8 );
+ for (i = firstoff; i <= lastoff; i += 1) {
+ char* ptr = (char*)&arr[i];
+ if (i == skipoff) {
+ *ptr = 0;
+ } else {
+ r= pthread_mutex_lock( &mx ); assert(!r);
+ *ptr = 0;
+ r= pthread_mutex_unlock( &mx ); assert(!r);
+ }
+ }
+ return NULL;
+}
+
+void* child16 ( void* infoV )
+{
+ int r, i, firstoff, lastoff, skipoff;
+ char* arr;
+ Info* info = (Info*)infoV;
+ firstoff = info->firstoff;
+ lastoff = info->lastoff;
+ skipoff = info->skipoff;
+ arr = info->arr;
+ assert( sizeof(short) == 2 );
+ assert( info->child == &child16 );
+ for (i = firstoff; i <= lastoff; i += 2) {
+ short* ptr = (short*)&arr[i];
+ if (i == skipoff) {
+ *ptr = 0;
+ } else {
+ r= pthread_mutex_lock( &mx ); assert(!r);
+ *ptr = 0;
+ r= pthread_mutex_unlock( &mx ); assert(!r);
+ }
+ }
+ return NULL;
+}
+
+void* child32 ( void* infoV )
+{
+ int r, i, firstoff, lastoff, skipoff;
+ char* arr;
+ Info* info = (Info*)infoV;
+ firstoff = info->firstoff;
+ lastoff = info->lastoff;
+ skipoff = info->skipoff;
+ arr = info->arr;
+ assert( sizeof(int) == 4 );
+ assert( info->child == &child32 );
+ for (i = firstoff; i <= lastoff; i += 4) {
+ int* ptr = (int*)&arr[i];
+ if (i == skipoff) {
+ *ptr = 0;
+ } else {
+ r= pthread_mutex_lock( &mx ); assert(!r);
+ *ptr = 0;
+ r= pthread_mutex_unlock( &mx ); assert(!r);
+ }
+ }
+ return NULL;
+}
+
+void* child64 ( void* infoV )
+{
+ int r, i, firstoff, lastoff, skipoff;
+ char* arr;
+ Info* info = (Info*)infoV;
+ firstoff = info->firstoff;
+ lastoff = info->lastoff;
+ skipoff = info->skipoff;
+ arr = info->arr;
+ assert( sizeof(double) == 8 );
+ assert( info->child == &child64 );
+ for (i = firstoff; i <= lastoff; i += 8) {
+ double* ptr = (double*)&arr[i];
+ if (i == skipoff) {
+ *ptr = 0;
+ } else {
+ r= pthread_mutex_lock( &mx ); assert(!r);
+ *ptr = 0;
+ r= pthread_mutex_unlock( &mx ); assert(!r);
+ }
+ }
+ return NULL;
+}
+
+
+void* steer ( void* infoV );
+
+#define MAXXX 100 /* re 100: should cover at least 2 cycles
+of length 1 << N_LINE_BITS */
+/* This is all a bit subtle. First, after every inner loop over the
+ data, we have to VALGRIND_TC_CLEAN_MEMORY it to get it back to a
+ decent starting state. Because info.arr is 8-aligned (is asserted
+ for), the address range painter will paint at top level granularity
+ (8-byte), which means we are guaranteed to see any errors from the
+ next iteration at the maximum granularity that their alignment
+ allows.
+
+ Also, the pthread_joins cause the shadow mem cache to be flushed
+ each iteration. Given that all trees are pulled up to 64-bit by
+ the abovementioned VALGRIND_TC_CLEAN_MEMORY, I think this
+ irrelevant.
+*/
+
+int main ( void )
+{
+ pthread_t t1, t2;
+ Info info;
+ int off;
+
+ pthread_mutex_init( &mx, NULL );
+
+ info.arr = malloc(MAXXX);
+ assert(info.arr);
+
+ /* ensure array is 8-aligned. this is important, as per comment
+ above. */
+ assert(0 == (7 & (unsigned long)info.arr));
+
+#if 1
+ /* Test 8 bit granularity */
+
+ fprintf(stderr, "\n");
+ fprintf(stderr,
+ "===========================================================\n");
+ fprintf(stderr,
+ "=== 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 ===\n");
+ fprintf(stderr,
+ "===========================================================\n");
+ fprintf(stderr, "\n");
+ for (off = 0; off < MAXXX-1; off++) {
+
+ info.firstoff = off & 0;
+ info.lastoff = MAXXX - 1;
+ info.skipoff = off;
+ info.child = child8;
+
+ fprintf(stderr, "---------- char gran, %d .. %d, skip %d ----------\n",
+ info.firstoff, info.lastoff, info.skipoff );
+
+ pthread_create( &t1, NULL, steer, (void*)&info );
+ pthread_create( &t2, NULL, steer, (void*)&info );
+
+ pthread_join( t1, NULL );
+ pthread_join( t2, NULL );
+
+ VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
+
+ }
+#endif
+#if 1
+ /* Test 16 bit granularity */
+
+ fprintf(stderr, "\n");
+ fprintf(stderr,
+ "==========================================================\n");
+ fprintf(stderr,
+ "=== 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 ===\n");
+ fprintf(stderr,
+ "==========================================================\n");
+ fprintf(stderr, "\n");
+ for (off = 0; off < MAXXX-2; off++) {
+
+ info.firstoff = off & 1;
+ info.lastoff = MAXXX - 2;
+ info.skipoff = off;
+ info.child = child16;
+
+ fprintf(stderr, "---------- short gran, %d .. %d, skip %d ----------\n",
+ info.firstoff, info.lastoff, info.skipoff );
+
+ pthread_create( &t1, NULL, steer, (void*)&info );
+ pthread_create( &t2, NULL, steer, (void*)&info );
+
+ pthread_join( t1, NULL );
+ pthread_join( t2, NULL );
+
+ VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
+
+ }
+#endif
+#if 1
+ /* Test 32 bit granularity */
+
+ fprintf(stderr, "\n");
+ fprintf(stderr,
+ "==========================================================\n");
+ fprintf(stderr,
+ "=== 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 ===\n");
+ fprintf(stderr,
+ "==========================================================\n");
+ fprintf(stderr, "\n");
+ for (off = 0; off < MAXXX-4; off++) {
+
+ info.firstoff = off & 3;
+ info.lastoff = MAXXX - 4;
+ info.skipoff = off;
+ info.child = child32;
+
+ fprintf(stderr, "---------- int gran, %d .. %d, skip %d ----------\n",
+ info.firstoff, info.lastoff, info.skipoff );
+
+ pthread_create( &t1, NULL, steer, (void*)&info );
+ pthread_create( &t2, NULL, steer, (void*)&info );
+
+ pthread_join( t1, NULL );
+ pthread_join( t2, NULL );
+
+ VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
+
+ }
+#endif
+#if 1
+ /* Test 64 bit granularity */
+
+ fprintf(stderr, "\n");
+ fprintf(stderr,
+ "==========================================================\n");
+ fprintf(stderr,
+ "=== 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 ===\n");
+ fprintf(stderr,
+ "==========================================================\n");
+ fprintf(stderr, "\n");
+ for (off = 0; off < MAXXX-8; off++) {
+
+ info.firstoff = off & 7;
+ info.lastoff = MAXXX - 8;
+ info.skipoff = off;
+ info.child = child64;
+
+ fprintf(stderr, "---------- double gran, %d .. %d, skip %d ----------\n",
+ info.firstoff, info.lastoff, info.skipoff );
+
+ pthread_create( &t1, NULL, steer, (void*)&info );
+ pthread_create( &t2, NULL, steer, (void*)&info );
+
+ pthread_join( t1, NULL );
+ pthread_join( t2, NULL );
+
+ VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
+
+ }
+#endif
+ free(info.arr);
+
+ return 0;
+}
+
+void* steer ( void* infoV )
+{
+ Info* info = (Info*)infoV;
+ int wot = info->skipoff;
+ void*(*fn)(void*) = info->child;
+ if (wot >= 500) goto halfway;
+
+ __asm__ __volatile__("");
+ if (wot == 0) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 1) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 2) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 3) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 4) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 5) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 6) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 7) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 8) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 9) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 10) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 11) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 12) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 13) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 14) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 15) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 16) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 17) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 18) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 19) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 20) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 21) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 22) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 23) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 24) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 25) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 26) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 27) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 28) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 29) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 30) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 31) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 32) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 33) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 34) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 35) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 36) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 37) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 38) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 39) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 40) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 41) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 42) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 43) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 44) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 45) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 46) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 47) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 48) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 49) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 50) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 51) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 52) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 53) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 54) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 55) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 56) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 57) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 58) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 59) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 60) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 61) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 62) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 63) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 64) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 65) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 66) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 67) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 68) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 69) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 70) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 71) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 72) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 73) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 74) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 75) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 76) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 77) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 78) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 79) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 80) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 81) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 82) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 83) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 84) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 85) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 86) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 87) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 88) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 89) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 90) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 91) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 92) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 93) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 94) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 95) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 96) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 97) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 98) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 99) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 100) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 101) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 102) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 103) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 104) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 105) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 106) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 107) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 108) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 109) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 110) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 111) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 112) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 113) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 114) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 115) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 116) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 117) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 118) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 119) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 120) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 121) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 122) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 123) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 124) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 125) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 126) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 127) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 128) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 129) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 130) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 131) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 132) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 133) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 134) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 135) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 136) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 137) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 138) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 139) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 140) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 141) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 142) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 143) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 144) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 145) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 146) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 147) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 148) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 149) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 150) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 151) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 152) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 153) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 154) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 155) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 156) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 157) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 158) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 159) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 160) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 161) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 162) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 163) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 164) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 165) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 166) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 167) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 168) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 169) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 170) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 171) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 172) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 173) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 174) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 175) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 176) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 177) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 178) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 179) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 180) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 181) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 182) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 183) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 184) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 185) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 186) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 187) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 188) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 189) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 190) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 191) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 192) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 193) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 194) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 195) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 196) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 197) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 198) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 199) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 200) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 201) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 202) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 203) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 204) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 205) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 206) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 207) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 208) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 209) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 210) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 211) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 212) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 213) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 214) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 215) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 216) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 217) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 218) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 219) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 220) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 221) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 222) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 223) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 224) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 225) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 226) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 227) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 228) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 229) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 230) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 231) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 232) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 233) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 234) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 235) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 236) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 237) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 238) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 239) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 240) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 241) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 242) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 243) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 244) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 245) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 246) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 247) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 248) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 249) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 250) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 251) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 252) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 253) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 254) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 255) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 256) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 257) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 258) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 259) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 260) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 261) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 262) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 263) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 264) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 265) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 266) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 267) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 268) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 269) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 270) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 271) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 272) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 273) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 274) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 275) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 276) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 277) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 278) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 279) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 280) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 281) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 282) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 283) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 284) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 285) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 286) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 287) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 288) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 289) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 290) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 291) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 292) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 293) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 294) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 295) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 296) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 297) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 298) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 299) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 300) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 301) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 302) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 303) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 304) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 305) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 306) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 307) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 308) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 309) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 310) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 311) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 312) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 313) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 314) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 315) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 316) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 317) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 318) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 319) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 320) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 321) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 322) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 323) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 324) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 325) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 326) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 327) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 328) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 329) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 330) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 331) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 332) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 333) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 334) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 335) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 336) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 337) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 338) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 339) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 340) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 341) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 342) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 343) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 344) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 345) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 346) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 347) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 348) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 349) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 350) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 351) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 352) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 353) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 354) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 355) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 356) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 357) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 358) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 359) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 360) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 361) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 362) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 363) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 364) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 365) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 366) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 367) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 368) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 369) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 370) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 371) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 372) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 373) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 374) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 375) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 376) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 377) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 378) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 379) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 380) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 381) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 382) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 383) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 384) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 385) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 386) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 387) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 388) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 389) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 390) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 391) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 392) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 393) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 394) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 395) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 396) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 397) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 398) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 399) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 400) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 401) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 402) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 403) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 404) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 405) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 406) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 407) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 408) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 409) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 410) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 411) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 412) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 413) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 414) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 415) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 416) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 417) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 418) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 419) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 420) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 421) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 422) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 423) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 424) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 425) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 426) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 427) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 428) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 429) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 430) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 431) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 432) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 433) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 434) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 435) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 436) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 437) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 438) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 439) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 440) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 441) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 442) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 443) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 444) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 445) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 446) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 447) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 448) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 449) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 450) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 451) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 452) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 453) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 454) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 455) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 456) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 457) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 458) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 459) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 460) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 461) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 462) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 463) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 464) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 465) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 466) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 467) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 468) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 469) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 470) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 471) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 472) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 473) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 474) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 475) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 476) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 477) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 478) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 479) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 480) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 481) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 482) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 483) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 484) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 485) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 486) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 487) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 488) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 489) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 490) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 491) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 492) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 493) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 494) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 495) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 496) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 497) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 498) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 499) return fn(info);
+ __asm__ __volatile__("");
+ halfway:
+ if (wot == 500) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 501) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 502) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 503) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 504) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 505) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 506) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 507) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 508) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 509) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 510) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 511) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 512) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 513) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 514) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 515) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 516) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 517) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 518) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 519) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 520) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 521) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 522) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 523) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 524) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 525) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 526) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 527) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 528) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 529) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 530) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 531) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 532) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 533) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 534) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 535) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 536) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 537) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 538) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 539) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 540) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 541) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 542) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 543) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 544) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 545) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 546) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 547) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 548) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 549) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 550) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 551) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 552) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 553) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 554) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 555) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 556) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 557) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 558) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 559) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 560) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 561) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 562) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 563) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 564) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 565) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 566) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 567) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 568) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 569) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 570) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 571) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 572) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 573) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 574) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 575) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 576) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 577) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 578) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 579) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 580) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 581) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 582) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 583) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 584) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 585) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 586) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 587) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 588) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 589) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 590) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 591) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 592) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 593) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 594) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 595) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 596) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 597) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 598) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 599) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 600) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 601) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 602) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 603) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 604) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 605) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 606) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 607) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 608) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 609) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 610) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 611) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 612) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 613) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 614) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 615) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 616) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 617) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 618) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 619) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 620) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 621) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 622) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 623) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 624) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 625) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 626) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 627) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 628) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 629) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 630) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 631) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 632) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 633) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 634) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 635) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 636) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 637) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 638) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 639) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 640) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 641) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 642) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 643) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 644) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 645) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 646) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 647) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 648) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 649) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 650) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 651) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 652) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 653) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 654) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 655) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 656) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 657) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 658) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 659) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 660) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 661) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 662) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 663) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 664) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 665) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 666) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 667) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 668) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 669) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 670) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 671) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 672) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 673) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 674) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 675) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 676) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 677) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 678) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 679) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 680) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 681) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 682) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 683) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 684) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 685) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 686) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 687) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 688) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 689) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 690) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 691) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 692) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 693) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 694) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 695) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 696) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 697) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 698) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 699) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 700) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 701) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 702) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 703) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 704) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 705) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 706) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 707) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 708) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 709) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 710) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 711) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 712) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 713) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 714) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 715) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 716) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 717) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 718) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 719) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 720) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 721) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 722) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 723) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 724) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 725) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 726) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 727) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 728) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 729) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 730) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 731) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 732) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 733) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 734) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 735) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 736) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 737) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 738) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 739) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 740) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 741) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 742) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 743) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 744) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 745) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 746) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 747) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 748) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 749) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 750) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 751) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 752) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 753) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 754) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 755) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 756) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 757) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 758) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 759) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 760) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 761) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 762) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 763) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 764) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 765) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 766) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 767) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 768) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 769) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 770) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 771) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 772) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 773) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 774) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 775) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 776) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 777) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 778) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 779) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 780) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 781) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 782) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 783) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 784) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 785) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 786) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 787) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 788) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 789) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 790) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 791) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 792) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 793) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 794) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 795) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 796) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 797) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 798) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 799) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 800) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 801) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 802) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 803) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 804) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 805) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 806) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 807) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 808) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 809) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 810) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 811) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 812) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 813) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 814) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 815) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 816) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 817) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 818) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 819) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 820) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 821) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 822) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 823) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 824) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 825) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 826) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 827) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 828) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 829) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 830) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 831) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 832) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 833) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 834) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 835) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 836) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 837) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 838) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 839) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 840) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 841) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 842) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 843) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 844) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 845) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 846) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 847) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 848) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 849) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 850) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 851) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 852) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 853) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 854) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 855) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 856) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 857) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 858) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 859) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 860) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 861) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 862) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 863) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 864) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 865) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 866) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 867) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 868) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 869) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 870) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 871) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 872) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 873) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 874) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 875) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 876) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 877) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 878) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 879) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 880) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 881) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 882) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 883) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 884) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 885) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 886) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 887) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 888) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 889) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 890) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 891) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 892) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 893) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 894) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 895) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 896) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 897) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 898) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 899) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 900) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 901) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 902) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 903) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 904) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 905) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 906) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 907) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 908) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 909) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 910) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 911) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 912) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 913) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 914) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 915) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 916) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 917) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 918) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 919) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 920) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 921) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 922) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 923) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 924) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 925) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 926) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 927) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 928) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 929) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 930) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 931) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 932) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 933) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 934) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 935) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 936) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 937) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 938) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 939) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 940) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 941) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 942) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 943) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 944) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 945) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 946) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 947) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 948) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 949) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 950) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 951) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 952) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 953) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 954) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 955) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 956) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 957) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 958) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 959) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 960) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 961) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 962) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 963) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 964) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 965) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 966) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 967) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 968) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 969) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 970) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 971) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 972) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 973) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 974) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 975) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 976) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 977) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 978) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 979) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 980) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 981) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 982) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 983) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 984) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 985) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 986) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 987) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 988) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 989) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 990) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 991) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 992) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 993) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 994) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 995) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 996) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 997) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 998) return fn(info);
+ __asm__ __volatile__("");
+ if (wot == 999) return fn(info);
+ __asm__ __volatile__("");
+
+ assert(0);
+}
diff --git a/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-amd64 b/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..8f83732
--- /dev/null
+++ b/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-amd64
@@ -0,0 +1,15840 @@
+
+
+===========================================================
+=== 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 ===
+===========================================================
+
+---------- char gran, 0 .. 99, skip 0 ----------
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:288)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #2
+ New state: shared-modified by threads #2, #3
+ Reason: this thread, #3, holds no locks at all
+---------- char gran, 0 .. 99, skip 1 ----------
+
+Thread #4 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #5 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #4
+ New state: shared-modified by threads #4, #5
+ Reason: this thread, #5, holds no locks at all
+---------- char gran, 0 .. 99, skip 2 ----------
+
+Thread #6 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #7 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #6
+ New state: shared-modified by threads #6, #7
+ Reason: this thread, #7, holds no locks at all
+---------- char gran, 0 .. 99, skip 3 ----------
+
+Thread #8 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #9 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #8
+ New state: shared-modified by threads #8, #9
+ Reason: this thread, #9, holds no locks at all
+---------- char gran, 0 .. 99, skip 4 ----------
+
+Thread #10 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #11 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:296)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #10
+ New state: shared-modified by threads #10, #11
+ Reason: this thread, #11, holds no locks at all
+---------- char gran, 0 .. 99, skip 5 ----------
+
+Thread #12 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #13 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #12
+ New state: shared-modified by threads #12, #13
+ Reason: this thread, #13, holds no locks at all
+---------- char gran, 0 .. 99, skip 6 ----------
+
+Thread #14 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #15 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #14
+ New state: shared-modified by threads #14, #15
+ Reason: this thread, #15, holds no locks at all
+---------- char gran, 0 .. 99, skip 7 ----------
+
+Thread #16 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #17 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #16
+ New state: shared-modified by threads #16, #17
+ Reason: this thread, #17, holds no locks at all
+---------- char gran, 0 .. 99, skip 8 ----------
+
+Thread #18 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #19 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:304)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #18
+ New state: shared-modified by threads #18, #19
+ Reason: this thread, #19, holds no locks at all
+---------- char gran, 0 .. 99, skip 9 ----------
+
+Thread #20 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #21 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #20
+ New state: shared-modified by threads #20, #21
+ Reason: this thread, #21, holds no locks at all
+---------- char gran, 0 .. 99, skip 10 ----------
+
+Thread #22 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #23 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #22
+ New state: shared-modified by threads #22, #23
+ Reason: this thread, #23, holds no locks at all
+---------- char gran, 0 .. 99, skip 11 ----------
+
+Thread #24 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #25 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #24
+ New state: shared-modified by threads #24, #25
+ Reason: this thread, #25, holds no locks at all
+---------- char gran, 0 .. 99, skip 12 ----------
+
+Thread #26 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #27 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:312)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #26
+ New state: shared-modified by threads #26, #27
+ Reason: this thread, #27, holds no locks at all
+---------- char gran, 0 .. 99, skip 13 ----------
+
+Thread #28 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #29 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #28
+ New state: shared-modified by threads #28, #29
+ Reason: this thread, #29, holds no locks at all
+---------- char gran, 0 .. 99, skip 14 ----------
+
+Thread #30 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #31 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #30
+ New state: shared-modified by threads #30, #31
+ Reason: this thread, #31, holds no locks at all
+---------- char gran, 0 .. 99, skip 15 ----------
+
+Thread #32 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #33 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #32
+ New state: shared-modified by threads #32, #33
+ Reason: this thread, #33, holds no locks at all
+---------- char gran, 0 .. 99, skip 16 ----------
+
+Thread #34 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #35 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:320)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #34
+ New state: shared-modified by threads #34, #35
+ Reason: this thread, #35, holds no locks at all
+---------- char gran, 0 .. 99, skip 17 ----------
+
+Thread #36 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #37 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #36
+ New state: shared-modified by threads #36, #37
+ Reason: this thread, #37, holds no locks at all
+---------- char gran, 0 .. 99, skip 18 ----------
+
+Thread #38 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #39 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #38
+ New state: shared-modified by threads #38, #39
+ Reason: this thread, #39, holds no locks at all
+---------- char gran, 0 .. 99, skip 19 ----------
+
+Thread #40 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #41 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #40
+ New state: shared-modified by threads #40, #41
+ Reason: this thread, #41, holds no locks at all
+---------- char gran, 0 .. 99, skip 20 ----------
+
+Thread #42 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #43 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:328)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #42
+ New state: shared-modified by threads #42, #43
+ Reason: this thread, #43, holds no locks at all
+---------- char gran, 0 .. 99, skip 21 ----------
+
+Thread #44 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #45 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #44
+ New state: shared-modified by threads #44, #45
+ Reason: this thread, #45, holds no locks at all
+---------- char gran, 0 .. 99, skip 22 ----------
+
+Thread #46 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #47 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #46
+ New state: shared-modified by threads #46, #47
+ Reason: this thread, #47, holds no locks at all
+---------- char gran, 0 .. 99, skip 23 ----------
+
+Thread #48 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #49 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #48
+ New state: shared-modified by threads #48, #49
+ Reason: this thread, #49, holds no locks at all
+---------- char gran, 0 .. 99, skip 24 ----------
+
+Thread #50 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #51 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:336)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #50
+ New state: shared-modified by threads #50, #51
+ Reason: this thread, #51, holds no locks at all
+---------- char gran, 0 .. 99, skip 25 ----------
+
+Thread #52 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #53 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #52
+ New state: shared-modified by threads #52, #53
+ Reason: this thread, #53, holds no locks at all
+---------- char gran, 0 .. 99, skip 26 ----------
+
+Thread #54 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #55 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #54
+ New state: shared-modified by threads #54, #55
+ Reason: this thread, #55, holds no locks at all
+---------- char gran, 0 .. 99, skip 27 ----------
+
+Thread #56 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #57 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #56
+ New state: shared-modified by threads #56, #57
+ Reason: this thread, #57, holds no locks at all
+---------- char gran, 0 .. 99, skip 28 ----------
+
+Thread #58 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #59 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:344)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #58
+ New state: shared-modified by threads #58, #59
+ Reason: this thread, #59, holds no locks at all
+---------- char gran, 0 .. 99, skip 29 ----------
+
+Thread #60 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #61 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #60
+ New state: shared-modified by threads #60, #61
+ Reason: this thread, #61, holds no locks at all
+---------- char gran, 0 .. 99, skip 30 ----------
+
+Thread #62 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #63 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #62
+ New state: shared-modified by threads #62, #63
+ Reason: this thread, #63, holds no locks at all
+---------- char gran, 0 .. 99, skip 31 ----------
+
+Thread #64 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #65 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #64
+ New state: shared-modified by threads #64, #65
+ Reason: this thread, #65, holds no locks at all
+---------- char gran, 0 .. 99, skip 32 ----------
+
+Thread #66 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #67 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:352)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #66
+ New state: shared-modified by threads #66, #67
+ Reason: this thread, #67, holds no locks at all
+---------- char gran, 0 .. 99, skip 33 ----------
+
+Thread #68 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #69 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #68
+ New state: shared-modified by threads #68, #69
+ Reason: this thread, #69, holds no locks at all
+---------- char gran, 0 .. 99, skip 34 ----------
+
+Thread #70 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #71 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #70
+ New state: shared-modified by threads #70, #71
+ Reason: this thread, #71, holds no locks at all
+---------- char gran, 0 .. 99, skip 35 ----------
+
+Thread #72 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #73 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #72
+ New state: shared-modified by threads #72, #73
+ Reason: this thread, #73, holds no locks at all
+---------- char gran, 0 .. 99, skip 36 ----------
+
+Thread #74 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #75 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:360)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #74
+ New state: shared-modified by threads #74, #75
+ Reason: this thread, #75, holds no locks at all
+---------- char gran, 0 .. 99, skip 37 ----------
+
+Thread #76 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #77 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #76
+ New state: shared-modified by threads #76, #77
+ Reason: this thread, #77, holds no locks at all
+---------- char gran, 0 .. 99, skip 38 ----------
+
+Thread #78 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #79 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #78
+ New state: shared-modified by threads #78, #79
+ Reason: this thread, #79, holds no locks at all
+---------- char gran, 0 .. 99, skip 39 ----------
+
+Thread #80 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #81 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #80
+ New state: shared-modified by threads #80, #81
+ Reason: this thread, #81, holds no locks at all
+---------- char gran, 0 .. 99, skip 40 ----------
+
+Thread #82 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #83 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:368)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #82
+ New state: shared-modified by threads #82, #83
+ Reason: this thread, #83, holds no locks at all
+---------- char gran, 0 .. 99, skip 41 ----------
+
+Thread #84 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #85 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #84
+ New state: shared-modified by threads #84, #85
+ Reason: this thread, #85, holds no locks at all
+---------- char gran, 0 .. 99, skip 42 ----------
+
+Thread #86 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #87 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #86
+ New state: shared-modified by threads #86, #87
+ Reason: this thread, #87, holds no locks at all
+---------- char gran, 0 .. 99, skip 43 ----------
+
+Thread #88 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #89 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #88
+ New state: shared-modified by threads #88, #89
+ Reason: this thread, #89, holds no locks at all
+---------- char gran, 0 .. 99, skip 44 ----------
+
+Thread #90 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #91 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:376)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #90
+ New state: shared-modified by threads #90, #91
+ Reason: this thread, #91, holds no locks at all
+---------- char gran, 0 .. 99, skip 45 ----------
+
+Thread #92 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #93 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #92
+ New state: shared-modified by threads #92, #93
+ Reason: this thread, #93, holds no locks at all
+---------- char gran, 0 .. 99, skip 46 ----------
+
+Thread #94 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #95 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #94
+ New state: shared-modified by threads #94, #95
+ Reason: this thread, #95, holds no locks at all
+---------- char gran, 0 .. 99, skip 47 ----------
+
+Thread #96 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #97 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #96
+ New state: shared-modified by threads #96, #97
+ Reason: this thread, #97, holds no locks at all
+---------- char gran, 0 .. 99, skip 48 ----------
+
+Thread #98 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #99 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:384)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #98
+ New state: shared-modified by threads #98, #99
+ Reason: this thread, #99, holds no locks at all
+---------- char gran, 0 .. 99, skip 49 ----------
+
+Thread #100 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #101 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #100
+ New state: shared-modified by threads #100, #101
+ Reason: this thread, #101, holds no locks at all
+---------- char gran, 0 .. 99, skip 50 ----------
+
+Thread #102 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #103 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #102
+ New state: shared-modified by threads #102, #103
+ Reason: this thread, #103, holds no locks at all
+---------- char gran, 0 .. 99, skip 51 ----------
+
+Thread #104 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #105 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #104
+ New state: shared-modified by threads #104, #105
+ Reason: this thread, #105, holds no locks at all
+---------- char gran, 0 .. 99, skip 52 ----------
+
+Thread #106 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #107 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:392)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #106
+ New state: shared-modified by threads #106, #107
+ Reason: this thread, #107, holds no locks at all
+---------- char gran, 0 .. 99, skip 53 ----------
+
+Thread #108 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #109 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #108
+ New state: shared-modified by threads #108, #109
+ Reason: this thread, #109, holds no locks at all
+---------- char gran, 0 .. 99, skip 54 ----------
+
+Thread #110 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #111 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #110
+ New state: shared-modified by threads #110, #111
+ Reason: this thread, #111, holds no locks at all
+---------- char gran, 0 .. 99, skip 55 ----------
+
+Thread #112 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #113 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #112
+ New state: shared-modified by threads #112, #113
+ Reason: this thread, #113, holds no locks at all
+---------- char gran, 0 .. 99, skip 56 ----------
+
+Thread #114 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #115 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:400)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #114
+ New state: shared-modified by threads #114, #115
+ Reason: this thread, #115, holds no locks at all
+---------- char gran, 0 .. 99, skip 57 ----------
+
+Thread #116 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #117 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #116
+ New state: shared-modified by threads #116, #117
+ Reason: this thread, #117, holds no locks at all
+---------- char gran, 0 .. 99, skip 58 ----------
+
+Thread #118 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #119 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #118
+ New state: shared-modified by threads #118, #119
+ Reason: this thread, #119, holds no locks at all
+---------- char gran, 0 .. 99, skip 59 ----------
+
+Thread #120 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #121 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #120
+ New state: shared-modified by threads #120, #121
+ Reason: this thread, #121, holds no locks at all
+---------- char gran, 0 .. 99, skip 60 ----------
+
+Thread #122 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #123 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:408)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #122
+ New state: shared-modified by threads #122, #123
+ Reason: this thread, #123, holds no locks at all
+---------- char gran, 0 .. 99, skip 61 ----------
+
+Thread #124 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #125 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #124
+ New state: shared-modified by threads #124, #125
+ Reason: this thread, #125, holds no locks at all
+---------- char gran, 0 .. 99, skip 62 ----------
+
+Thread #126 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #127 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #126
+ New state: shared-modified by threads #126, #127
+ Reason: this thread, #127, holds no locks at all
+---------- char gran, 0 .. 99, skip 63 ----------
+
+Thread #128 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #129 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #128
+ New state: shared-modified by threads #128, #129
+ Reason: this thread, #129, holds no locks at all
+---------- char gran, 0 .. 99, skip 64 ----------
+
+Thread #130 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #131 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:416)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #130
+ New state: shared-modified by threads #130, #131
+ Reason: this thread, #131, holds no locks at all
+---------- char gran, 0 .. 99, skip 65 ----------
+
+Thread #132 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #133 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #132
+ New state: shared-modified by threads #132, #133
+ Reason: this thread, #133, holds no locks at all
+---------- char gran, 0 .. 99, skip 66 ----------
+
+Thread #134 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #135 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #134
+ New state: shared-modified by threads #134, #135
+ Reason: this thread, #135, holds no locks at all
+---------- char gran, 0 .. 99, skip 67 ----------
+
+Thread #136 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #137 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #136
+ New state: shared-modified by threads #136, #137
+ Reason: this thread, #137, holds no locks at all
+---------- char gran, 0 .. 99, skip 68 ----------
+
+Thread #138 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #139 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:424)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #138
+ New state: shared-modified by threads #138, #139
+ Reason: this thread, #139, holds no locks at all
+---------- char gran, 0 .. 99, skip 69 ----------
+
+Thread #140 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #141 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #140
+ New state: shared-modified by threads #140, #141
+ Reason: this thread, #141, holds no locks at all
+---------- char gran, 0 .. 99, skip 70 ----------
+
+Thread #142 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #143 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #142
+ New state: shared-modified by threads #142, #143
+ Reason: this thread, #143, holds no locks at all
+---------- char gran, 0 .. 99, skip 71 ----------
+
+Thread #144 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #145 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #144
+ New state: shared-modified by threads #144, #145
+ Reason: this thread, #145, holds no locks at all
+---------- char gran, 0 .. 99, skip 72 ----------
+
+Thread #146 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #147 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:432)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #146
+ New state: shared-modified by threads #146, #147
+ Reason: this thread, #147, holds no locks at all
+---------- char gran, 0 .. 99, skip 73 ----------
+
+Thread #148 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #149 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #148
+ New state: shared-modified by threads #148, #149
+ Reason: this thread, #149, holds no locks at all
+---------- char gran, 0 .. 99, skip 74 ----------
+
+Thread #150 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #151 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #150
+ New state: shared-modified by threads #150, #151
+ Reason: this thread, #151, holds no locks at all
+---------- char gran, 0 .. 99, skip 75 ----------
+
+Thread #152 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #153 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #152
+ New state: shared-modified by threads #152, #153
+ Reason: this thread, #153, holds no locks at all
+---------- char gran, 0 .. 99, skip 76 ----------
+
+Thread #154 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #155 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:440)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #154
+ New state: shared-modified by threads #154, #155
+ Reason: this thread, #155, holds no locks at all
+---------- char gran, 0 .. 99, skip 77 ----------
+
+Thread #156 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #157 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #156
+ New state: shared-modified by threads #156, #157
+ Reason: this thread, #157, holds no locks at all
+---------- char gran, 0 .. 99, skip 78 ----------
+
+Thread #158 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #159 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #158
+ New state: shared-modified by threads #158, #159
+ Reason: this thread, #159, holds no locks at all
+---------- char gran, 0 .. 99, skip 79 ----------
+
+Thread #160 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #161 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #160
+ New state: shared-modified by threads #160, #161
+ Reason: this thread, #161, holds no locks at all
+---------- char gran, 0 .. 99, skip 80 ----------
+
+Thread #162 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #163 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:448)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #162
+ New state: shared-modified by threads #162, #163
+ Reason: this thread, #163, holds no locks at all
+---------- char gran, 0 .. 99, skip 81 ----------
+
+Thread #164 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #165 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #164
+ New state: shared-modified by threads #164, #165
+ Reason: this thread, #165, holds no locks at all
+---------- char gran, 0 .. 99, skip 82 ----------
+
+Thread #166 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #167 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #166
+ New state: shared-modified by threads #166, #167
+ Reason: this thread, #167, holds no locks at all
+---------- char gran, 0 .. 99, skip 83 ----------
+
+Thread #168 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #169 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #168
+ New state: shared-modified by threads #168, #169
+ Reason: this thread, #169, holds no locks at all
+---------- char gran, 0 .. 99, skip 84 ----------
+
+Thread #170 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #171 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:456)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #170
+ New state: shared-modified by threads #170, #171
+ Reason: this thread, #171, holds no locks at all
+---------- char gran, 0 .. 99, skip 85 ----------
+
+Thread #172 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #173 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #172
+ New state: shared-modified by threads #172, #173
+ Reason: this thread, #173, holds no locks at all
+---------- char gran, 0 .. 99, skip 86 ----------
+
+Thread #174 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #175 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #174
+ New state: shared-modified by threads #174, #175
+ Reason: this thread, #175, holds no locks at all
+---------- char gran, 0 .. 99, skip 87 ----------
+
+Thread #176 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #177 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #176
+ New state: shared-modified by threads #176, #177
+ Reason: this thread, #177, holds no locks at all
+---------- char gran, 0 .. 99, skip 88 ----------
+
+Thread #178 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #179 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:464)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #178
+ New state: shared-modified by threads #178, #179
+ Reason: this thread, #179, holds no locks at all
+---------- char gran, 0 .. 99, skip 89 ----------
+
+Thread #180 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #181 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #180
+ New state: shared-modified by threads #180, #181
+ Reason: this thread, #181, holds no locks at all
+---------- char gran, 0 .. 99, skip 90 ----------
+
+Thread #182 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #183 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #182
+ New state: shared-modified by threads #182, #183
+ Reason: this thread, #183, holds no locks at all
+---------- char gran, 0 .. 99, skip 91 ----------
+
+Thread #184 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #185 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #184
+ New state: shared-modified by threads #184, #185
+ Reason: this thread, #185, holds no locks at all
+---------- char gran, 0 .. 99, skip 92 ----------
+
+Thread #186 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #187 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:472)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #186
+ New state: shared-modified by threads #186, #187
+ Reason: this thread, #187, holds no locks at all
+---------- char gran, 0 .. 99, skip 93 ----------
+
+Thread #188 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #189 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #188
+ New state: shared-modified by threads #188, #189
+ Reason: this thread, #189, holds no locks at all
+---------- char gran, 0 .. 99, skip 94 ----------
+
+Thread #190 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #191 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:476)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #190
+ New state: shared-modified by threads #190, #191
+ Reason: this thread, #191, holds no locks at all
+---------- char gran, 0 .. 99, skip 95 ----------
+
+Thread #192 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #193 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #192
+ New state: shared-modified by threads #192, #193
+ Reason: this thread, #193, holds no locks at all
+---------- char gran, 0 .. 99, skip 96 ----------
+
+Thread #194 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #195 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:480)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #194
+ New state: shared-modified by threads #194, #195
+ Reason: this thread, #195, holds no locks at all
+---------- char gran, 0 .. 99, skip 97 ----------
+
+Thread #196 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #197 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:482)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #196
+ New state: shared-modified by threads #196, #197
+ Reason: this thread, #197, holds no locks at all
+---------- char gran, 0 .. 99, skip 98 ----------
+
+Thread #198 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #199 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:484)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #198
+ New state: shared-modified by threads #198, #199
+ Reason: this thread, #199, holds no locks at all
+
+==========================================================
+=== 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 ===
+==========================================================
+
+---------- short gran, 0 .. 98, skip 0 ----------
+
+Thread #200 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #201 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:288)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #200
+ New state: shared-modified by threads #200, #201
+ Reason: this thread, #201, holds no locks at all
+
+More than 100 errors detected. Subsequent errors
+will still be recorded, but in less detail than before.
+---------- short gran, 1 .. 98, skip 1 ----------
+
+Thread #202 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #203 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #202
+ New state: shared-modified by threads #202, #203
+ Reason: this thread, #203, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #202
+ New state: shared-modified by threads #202, #203
+ Reason: this thread, #203, holds no locks at all
+---------- short gran, 0 .. 98, skip 2 ----------
+
+Thread #204 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #205 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #204
+ New state: shared-modified by threads #204, #205
+ Reason: this thread, #205, holds no locks at all
+---------- short gran, 1 .. 98, skip 3 ----------
+
+Thread #206 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #207 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #206
+ New state: shared-modified by threads #206, #207
+ Reason: this thread, #207, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #206
+ New state: shared-modified by threads #206, #207
+ Reason: this thread, #207, holds no locks at all
+---------- short gran, 0 .. 98, skip 4 ----------
+
+Thread #208 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #209 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:296)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #208
+ New state: shared-modified by threads #208, #209
+ Reason: this thread, #209, holds no locks at all
+---------- short gran, 1 .. 98, skip 5 ----------
+
+Thread #210 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #211 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #210
+ New state: shared-modified by threads #210, #211
+ Reason: this thread, #211, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #210
+ New state: shared-modified by threads #210, #211
+ Reason: this thread, #211, holds no locks at all
+---------- short gran, 0 .. 98, skip 6 ----------
+
+Thread #212 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #213 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #212
+ New state: shared-modified by threads #212, #213
+ Reason: this thread, #213, holds no locks at all
+---------- short gran, 1 .. 98, skip 7 ----------
+
+Thread #214 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #215 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #214
+ New state: shared-modified by threads #214, #215
+ Reason: this thread, #215, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #214
+ New state: shared-modified by threads #214, #215
+ Reason: this thread, #215, holds no locks at all
+---------- short gran, 0 .. 98, skip 8 ----------
+
+Thread #216 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #217 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:304)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #216
+ New state: shared-modified by threads #216, #217
+ Reason: this thread, #217, holds no locks at all
+---------- short gran, 1 .. 98, skip 9 ----------
+
+Thread #218 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #219 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #218
+ New state: shared-modified by threads #218, #219
+ Reason: this thread, #219, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #218
+ New state: shared-modified by threads #218, #219
+ Reason: this thread, #219, holds no locks at all
+---------- short gran, 0 .. 98, skip 10 ----------
+
+Thread #220 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #221 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #220
+ New state: shared-modified by threads #220, #221
+ Reason: this thread, #221, holds no locks at all
+---------- short gran, 1 .. 98, skip 11 ----------
+
+Thread #222 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #223 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #222
+ New state: shared-modified by threads #222, #223
+ Reason: this thread, #223, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #222
+ New state: shared-modified by threads #222, #223
+ Reason: this thread, #223, holds no locks at all
+---------- short gran, 0 .. 98, skip 12 ----------
+
+Thread #224 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #225 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:312)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #224
+ New state: shared-modified by threads #224, #225
+ Reason: this thread, #225, holds no locks at all
+---------- short gran, 1 .. 98, skip 13 ----------
+
+Thread #226 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #227 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #226
+ New state: shared-modified by threads #226, #227
+ Reason: this thread, #227, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #226
+ New state: shared-modified by threads #226, #227
+ Reason: this thread, #227, holds no locks at all
+---------- short gran, 0 .. 98, skip 14 ----------
+
+Thread #228 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #229 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #228
+ New state: shared-modified by threads #228, #229
+ Reason: this thread, #229, holds no locks at all
+---------- short gran, 1 .. 98, skip 15 ----------
+
+Thread #230 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #231 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #230
+ New state: shared-modified by threads #230, #231
+ Reason: this thread, #231, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #230
+ New state: shared-modified by threads #230, #231
+ Reason: this thread, #231, holds no locks at all
+---------- short gran, 0 .. 98, skip 16 ----------
+
+Thread #232 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #233 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:320)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #232
+ New state: shared-modified by threads #232, #233
+ Reason: this thread, #233, holds no locks at all
+---------- short gran, 1 .. 98, skip 17 ----------
+
+Thread #234 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #235 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #234
+ New state: shared-modified by threads #234, #235
+ Reason: this thread, #235, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #234
+ New state: shared-modified by threads #234, #235
+ Reason: this thread, #235, holds no locks at all
+---------- short gran, 0 .. 98, skip 18 ----------
+
+Thread #236 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #237 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #236
+ New state: shared-modified by threads #236, #237
+ Reason: this thread, #237, holds no locks at all
+---------- short gran, 1 .. 98, skip 19 ----------
+
+Thread #238 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #239 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #238
+ New state: shared-modified by threads #238, #239
+ Reason: this thread, #239, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #238
+ New state: shared-modified by threads #238, #239
+ Reason: this thread, #239, holds no locks at all
+---------- short gran, 0 .. 98, skip 20 ----------
+
+Thread #240 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #241 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:328)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #240
+ New state: shared-modified by threads #240, #241
+ Reason: this thread, #241, holds no locks at all
+---------- short gran, 1 .. 98, skip 21 ----------
+
+Thread #242 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #243 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #242
+ New state: shared-modified by threads #242, #243
+ Reason: this thread, #243, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #242
+ New state: shared-modified by threads #242, #243
+ Reason: this thread, #243, holds no locks at all
+---------- short gran, 0 .. 98, skip 22 ----------
+
+Thread #244 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #245 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #244
+ New state: shared-modified by threads #244, #245
+ Reason: this thread, #245, holds no locks at all
+---------- short gran, 1 .. 98, skip 23 ----------
+
+Thread #246 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #247 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #246
+ New state: shared-modified by threads #246, #247
+ Reason: this thread, #247, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #246
+ New state: shared-modified by threads #246, #247
+ Reason: this thread, #247, holds no locks at all
+---------- short gran, 0 .. 98, skip 24 ----------
+
+Thread #248 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #249 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:336)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #248
+ New state: shared-modified by threads #248, #249
+ Reason: this thread, #249, holds no locks at all
+---------- short gran, 1 .. 98, skip 25 ----------
+
+Thread #250 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #251 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #250
+ New state: shared-modified by threads #250, #251
+ Reason: this thread, #251, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #250
+ New state: shared-modified by threads #250, #251
+ Reason: this thread, #251, holds no locks at all
+---------- short gran, 0 .. 98, skip 26 ----------
+
+Thread #252 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #253 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #252
+ New state: shared-modified by threads #252, #253
+ Reason: this thread, #253, holds no locks at all
+---------- short gran, 1 .. 98, skip 27 ----------
+
+Thread #254 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #255 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #254
+ New state: shared-modified by threads #254, #255
+ Reason: this thread, #255, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #254
+ New state: shared-modified by threads #254, #255
+ Reason: this thread, #255, holds no locks at all
+---------- short gran, 0 .. 98, skip 28 ----------
+
+Thread #256 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #257 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:344)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #256
+ New state: shared-modified by threads #256, #257
+ Reason: this thread, #257, holds no locks at all
+---------- short gran, 1 .. 98, skip 29 ----------
+
+Thread #258 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #259 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #258
+ New state: shared-modified by threads #258, #259
+ Reason: this thread, #259, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #258
+ New state: shared-modified by threads #258, #259
+ Reason: this thread, #259, holds no locks at all
+---------- short gran, 0 .. 98, skip 30 ----------
+
+Thread #260 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #261 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #260
+ New state: shared-modified by threads #260, #261
+ Reason: this thread, #261, holds no locks at all
+---------- short gran, 1 .. 98, skip 31 ----------
+
+Thread #262 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #263 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #262
+ New state: shared-modified by threads #262, #263
+ Reason: this thread, #263, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #262
+ New state: shared-modified by threads #262, #263
+ Reason: this thread, #263, holds no locks at all
+---------- short gran, 0 .. 98, skip 32 ----------
+
+Thread #264 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #265 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:352)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #264
+ New state: shared-modified by threads #264, #265
+ Reason: this thread, #265, holds no locks at all
+---------- short gran, 1 .. 98, skip 33 ----------
+
+Thread #266 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #267 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #266
+ New state: shared-modified by threads #266, #267
+ Reason: this thread, #267, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #266
+ New state: shared-modified by threads #266, #267
+ Reason: this thread, #267, holds no locks at all
+---------- short gran, 0 .. 98, skip 34 ----------
+
+Thread #268 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #269 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #268
+ New state: shared-modified by threads #268, #269
+ Reason: this thread, #269, holds no locks at all
+---------- short gran, 1 .. 98, skip 35 ----------
+
+Thread #270 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #271 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #270
+ New state: shared-modified by threads #270, #271
+ Reason: this thread, #271, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #270
+ New state: shared-modified by threads #270, #271
+ Reason: this thread, #271, holds no locks at all
+---------- short gran, 0 .. 98, skip 36 ----------
+
+Thread #272 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #273 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:360)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #272
+ New state: shared-modified by threads #272, #273
+ Reason: this thread, #273, holds no locks at all
+---------- short gran, 1 .. 98, skip 37 ----------
+
+Thread #274 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #275 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #274
+ New state: shared-modified by threads #274, #275
+ Reason: this thread, #275, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #274
+ New state: shared-modified by threads #274, #275
+ Reason: this thread, #275, holds no locks at all
+---------- short gran, 0 .. 98, skip 38 ----------
+
+Thread #276 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #277 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #276
+ New state: shared-modified by threads #276, #277
+ Reason: this thread, #277, holds no locks at all
+---------- short gran, 1 .. 98, skip 39 ----------
+
+Thread #278 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #279 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #278
+ New state: shared-modified by threads #278, #279
+ Reason: this thread, #279, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #278
+ New state: shared-modified by threads #278, #279
+ Reason: this thread, #279, holds no locks at all
+---------- short gran, 0 .. 98, skip 40 ----------
+
+Thread #280 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #281 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:368)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #280
+ New state: shared-modified by threads #280, #281
+ Reason: this thread, #281, holds no locks at all
+---------- short gran, 1 .. 98, skip 41 ----------
+
+Thread #282 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #283 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #282
+ New state: shared-modified by threads #282, #283
+ Reason: this thread, #283, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #282
+ New state: shared-modified by threads #282, #283
+ Reason: this thread, #283, holds no locks at all
+---------- short gran, 0 .. 98, skip 42 ----------
+
+Thread #284 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #285 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #284
+ New state: shared-modified by threads #284, #285
+ Reason: this thread, #285, holds no locks at all
+---------- short gran, 1 .. 98, skip 43 ----------
+
+Thread #286 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #287 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #286
+ New state: shared-modified by threads #286, #287
+ Reason: this thread, #287, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #286
+ New state: shared-modified by threads #286, #287
+ Reason: this thread, #287, holds no locks at all
+---------- short gran, 0 .. 98, skip 44 ----------
+
+Thread #288 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #289 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:376)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #288
+ New state: shared-modified by threads #288, #289
+ Reason: this thread, #289, holds no locks at all
+---------- short gran, 1 .. 98, skip 45 ----------
+
+Thread #290 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #291 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #290
+ New state: shared-modified by threads #290, #291
+ Reason: this thread, #291, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #290
+ New state: shared-modified by threads #290, #291
+ Reason: this thread, #291, holds no locks at all
+---------- short gran, 0 .. 98, skip 46 ----------
+
+Thread #292 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #293 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #292
+ New state: shared-modified by threads #292, #293
+ Reason: this thread, #293, holds no locks at all
+---------- short gran, 1 .. 98, skip 47 ----------
+
+Thread #294 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #295 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #294
+ New state: shared-modified by threads #294, #295
+ Reason: this thread, #295, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #294
+ New state: shared-modified by threads #294, #295
+ Reason: this thread, #295, holds no locks at all
+---------- short gran, 0 .. 98, skip 48 ----------
+
+Thread #296 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #297 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:384)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #296
+ New state: shared-modified by threads #296, #297
+ Reason: this thread, #297, holds no locks at all
+---------- short gran, 1 .. 98, skip 49 ----------
+
+Thread #298 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #299 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #298
+ New state: shared-modified by threads #298, #299
+ Reason: this thread, #299, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #298
+ New state: shared-modified by threads #298, #299
+ Reason: this thread, #299, holds no locks at all
+---------- short gran, 0 .. 98, skip 50 ----------
+
+Thread #300 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #301 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #300
+ New state: shared-modified by threads #300, #301
+ Reason: this thread, #301, holds no locks at all
+---------- short gran, 1 .. 98, skip 51 ----------
+
+Thread #302 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #303 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #302
+ New state: shared-modified by threads #302, #303
+ Reason: this thread, #303, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #302
+ New state: shared-modified by threads #302, #303
+ Reason: this thread, #303, holds no locks at all
+---------- short gran, 0 .. 98, skip 52 ----------
+
+Thread #304 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #305 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:392)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #304
+ New state: shared-modified by threads #304, #305
+ Reason: this thread, #305, holds no locks at all
+---------- short gran, 1 .. 98, skip 53 ----------
+
+Thread #306 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #307 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #306
+ New state: shared-modified by threads #306, #307
+ Reason: this thread, #307, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #306
+ New state: shared-modified by threads #306, #307
+ Reason: this thread, #307, holds no locks at all
+---------- short gran, 0 .. 98, skip 54 ----------
+
+Thread #308 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #309 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #308
+ New state: shared-modified by threads #308, #309
+ Reason: this thread, #309, holds no locks at all
+---------- short gran, 1 .. 98, skip 55 ----------
+
+Thread #310 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #311 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #310
+ New state: shared-modified by threads #310, #311
+ Reason: this thread, #311, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #310
+ New state: shared-modified by threads #310, #311
+ Reason: this thread, #311, holds no locks at all
+---------- short gran, 0 .. 98, skip 56 ----------
+
+Thread #312 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #313 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:400)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #312
+ New state: shared-modified by threads #312, #313
+ Reason: this thread, #313, holds no locks at all
+---------- short gran, 1 .. 98, skip 57 ----------
+
+Thread #314 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #315 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #314
+ New state: shared-modified by threads #314, #315
+ Reason: this thread, #315, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #314
+ New state: shared-modified by threads #314, #315
+ Reason: this thread, #315, holds no locks at all
+---------- short gran, 0 .. 98, skip 58 ----------
+
+Thread #316 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #317 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #316
+ New state: shared-modified by threads #316, #317
+ Reason: this thread, #317, holds no locks at all
+---------- short gran, 1 .. 98, skip 59 ----------
+
+Thread #318 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #319 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #318
+ New state: shared-modified by threads #318, #319
+ Reason: this thread, #319, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #318
+ New state: shared-modified by threads #318, #319
+ Reason: this thread, #319, holds no locks at all
+---------- short gran, 0 .. 98, skip 60 ----------
+
+Thread #320 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #321 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:408)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #320
+ New state: shared-modified by threads #320, #321
+ Reason: this thread, #321, holds no locks at all
+---------- short gran, 1 .. 98, skip 61 ----------
+
+Thread #322 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #323 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #322
+ New state: shared-modified by threads #322, #323
+ Reason: this thread, #323, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #322
+ New state: shared-modified by threads #322, #323
+ Reason: this thread, #323, holds no locks at all
+---------- short gran, 0 .. 98, skip 62 ----------
+
+Thread #324 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #325 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #324
+ New state: shared-modified by threads #324, #325
+ Reason: this thread, #325, holds no locks at all
+---------- short gran, 1 .. 98, skip 63 ----------
+
+Thread #326 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #327 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #326
+ New state: shared-modified by threads #326, #327
+ Reason: this thread, #327, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #326
+ New state: shared-modified by threads #326, #327
+ Reason: this thread, #327, holds no locks at all
+---------- short gran, 0 .. 98, skip 64 ----------
+
+Thread #328 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #329 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:416)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #328
+ New state: shared-modified by threads #328, #329
+ Reason: this thread, #329, holds no locks at all
+---------- short gran, 1 .. 98, skip 65 ----------
+
+Thread #330 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #331 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #330
+ New state: shared-modified by threads #330, #331
+ Reason: this thread, #331, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #330
+ New state: shared-modified by threads #330, #331
+ Reason: this thread, #331, holds no locks at all
+---------- short gran, 0 .. 98, skip 66 ----------
+
+Thread #332 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #333 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #332
+ New state: shared-modified by threads #332, #333
+ Reason: this thread, #333, holds no locks at all
+---------- short gran, 1 .. 98, skip 67 ----------
+
+Thread #334 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #335 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #334
+ New state: shared-modified by threads #334, #335
+ Reason: this thread, #335, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #334
+ New state: shared-modified by threads #334, #335
+ Reason: this thread, #335, holds no locks at all
+---------- short gran, 0 .. 98, skip 68 ----------
+
+Thread #336 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #337 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:424)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #336
+ New state: shared-modified by threads #336, #337
+ Reason: this thread, #337, holds no locks at all
+---------- short gran, 1 .. 98, skip 69 ----------
+
+Thread #338 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #339 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #338
+ New state: shared-modified by threads #338, #339
+ Reason: this thread, #339, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #338
+ New state: shared-modified by threads #338, #339
+ Reason: this thread, #339, holds no locks at all
+---------- short gran, 0 .. 98, skip 70 ----------
+
+Thread #340 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #341 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #340
+ New state: shared-modified by threads #340, #341
+ Reason: this thread, #341, holds no locks at all
+---------- short gran, 1 .. 98, skip 71 ----------
+
+Thread #342 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #343 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #342
+ New state: shared-modified by threads #342, #343
+ Reason: this thread, #343, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #342
+ New state: shared-modified by threads #342, #343
+ Reason: this thread, #343, holds no locks at all
+---------- short gran, 0 .. 98, skip 72 ----------
+
+Thread #344 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #345 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:432)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #344
+ New state: shared-modified by threads #344, #345
+ Reason: this thread, #345, holds no locks at all
+---------- short gran, 1 .. 98, skip 73 ----------
+
+Thread #346 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #347 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #346
+ New state: shared-modified by threads #346, #347
+ Reason: this thread, #347, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #346
+ New state: shared-modified by threads #346, #347
+ Reason: this thread, #347, holds no locks at all
+---------- short gran, 0 .. 98, skip 74 ----------
+
+Thread #348 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #349 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #348
+ New state: shared-modified by threads #348, #349
+ Reason: this thread, #349, holds no locks at all
+---------- short gran, 1 .. 98, skip 75 ----------
+
+Thread #350 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #351 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #350
+ New state: shared-modified by threads #350, #351
+ Reason: this thread, #351, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #350
+ New state: shared-modified by threads #350, #351
+ Reason: this thread, #351, holds no locks at all
+---------- short gran, 0 .. 98, skip 76 ----------
+
+Thread #352 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #353 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:440)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #352
+ New state: shared-modified by threads #352, #353
+ Reason: this thread, #353, holds no locks at all
+---------- short gran, 1 .. 98, skip 77 ----------
+
+Thread #354 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #355 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #354
+ New state: shared-modified by threads #354, #355
+ Reason: this thread, #355, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #354
+ New state: shared-modified by threads #354, #355
+ Reason: this thread, #355, holds no locks at all
+---------- short gran, 0 .. 98, skip 78 ----------
+
+Thread #356 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #357 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #356
+ New state: shared-modified by threads #356, #357
+ Reason: this thread, #357, holds no locks at all
+---------- short gran, 1 .. 98, skip 79 ----------
+
+Thread #358 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #359 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #358
+ New state: shared-modified by threads #358, #359
+ Reason: this thread, #359, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #358
+ New state: shared-modified by threads #358, #359
+ Reason: this thread, #359, holds no locks at all
+---------- short gran, 0 .. 98, skip 80 ----------
+
+Thread #360 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #361 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:448)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #360
+ New state: shared-modified by threads #360, #361
+ Reason: this thread, #361, holds no locks at all
+---------- short gran, 1 .. 98, skip 81 ----------
+
+Thread #362 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #363 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #362
+ New state: shared-modified by threads #362, #363
+ Reason: this thread, #363, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #362
+ New state: shared-modified by threads #362, #363
+ Reason: this thread, #363, holds no locks at all
+---------- short gran, 0 .. 98, skip 82 ----------
+
+Thread #364 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #365 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #364
+ New state: shared-modified by threads #364, #365
+ Reason: this thread, #365, holds no locks at all
+---------- short gran, 1 .. 98, skip 83 ----------
+
+Thread #366 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #367 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #366
+ New state: shared-modified by threads #366, #367
+ Reason: this thread, #367, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #366
+ New state: shared-modified by threads #366, #367
+ Reason: this thread, #367, holds no locks at all
+---------- short gran, 0 .. 98, skip 84 ----------
+
+Thread #368 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #369 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:456)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #368
+ New state: shared-modified by threads #368, #369
+ Reason: this thread, #369, holds no locks at all
+---------- short gran, 1 .. 98, skip 85 ----------
+
+Thread #370 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #371 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #370
+ New state: shared-modified by threads #370, #371
+ Reason: this thread, #371, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #370
+ New state: shared-modified by threads #370, #371
+ Reason: this thread, #371, holds no locks at all
+---------- short gran, 0 .. 98, skip 86 ----------
+
+Thread #372 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #373 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #372
+ New state: shared-modified by threads #372, #373
+ Reason: this thread, #373, holds no locks at all
+---------- short gran, 1 .. 98, skip 87 ----------
+
+Thread #374 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #375 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #374
+ New state: shared-modified by threads #374, #375
+ Reason: this thread, #375, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #374
+ New state: shared-modified by threads #374, #375
+ Reason: this thread, #375, holds no locks at all
+---------- short gran, 0 .. 98, skip 88 ----------
+
+Thread #376 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #377 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:464)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #376
+ New state: shared-modified by threads #376, #377
+ Reason: this thread, #377, holds no locks at all
+---------- short gran, 1 .. 98, skip 89 ----------
+
+Thread #378 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #379 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #378
+ New state: shared-modified by threads #378, #379
+ Reason: this thread, #379, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #378
+ New state: shared-modified by threads #378, #379
+ Reason: this thread, #379, holds no locks at all
+---------- short gran, 0 .. 98, skip 90 ----------
+
+Thread #380 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #381 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #380
+ New state: shared-modified by threads #380, #381
+ Reason: this thread, #381, holds no locks at all
+---------- short gran, 1 .. 98, skip 91 ----------
+
+Thread #382 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #383 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #382
+ New state: shared-modified by threads #382, #383
+ Reason: this thread, #383, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #382
+ New state: shared-modified by threads #382, #383
+ Reason: this thread, #383, holds no locks at all
+---------- short gran, 0 .. 98, skip 92 ----------
+
+Thread #384 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #385 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:472)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #384
+ New state: shared-modified by threads #384, #385
+ Reason: this thread, #385, holds no locks at all
+---------- short gran, 1 .. 98, skip 93 ----------
+
+Thread #386 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #387 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #386
+ New state: shared-modified by threads #386, #387
+ Reason: this thread, #387, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #386
+ New state: shared-modified by threads #386, #387
+ Reason: this thread, #387, holds no locks at all
+---------- short gran, 0 .. 98, skip 94 ----------
+
+Thread #388 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #389 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:476)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #388
+ New state: shared-modified by threads #388, #389
+ Reason: this thread, #389, holds no locks at all
+---------- short gran, 1 .. 98, skip 95 ----------
+
+Thread #390 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #391 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #390
+ New state: shared-modified by threads #390, #391
+ Reason: this thread, #391, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #390
+ New state: shared-modified by threads #390, #391
+ Reason: this thread, #391, holds no locks at all
+---------- short gran, 0 .. 98, skip 96 ----------
+
+Thread #392 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #393 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:480)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #392
+ New state: shared-modified by threads #392, #393
+ Reason: this thread, #393, holds no locks at all
+---------- short gran, 1 .. 98, skip 97 ----------
+
+Thread #394 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #395 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:482)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #394
+ New state: shared-modified by threads #394, #395
+ Reason: this thread, #395, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:482)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #394
+ New state: shared-modified by threads #394, #395
+ Reason: this thread, #395, holds no locks at all
+
+==========================================================
+=== 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 ===
+==========================================================
+
+---------- int gran, 0 .. 96, skip 0 ----------
+
+Thread #396 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #397 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:288)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #396
+ New state: shared-modified by threads #396, #397
+ Reason: this thread, #397, holds no locks at all
+---------- int gran, 1 .. 96, skip 1 ----------
+
+Thread #398 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #399 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #398
+ New state: shared-modified by threads #398, #399
+ Reason: this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #398
+ New state: shared-modified by threads #398, #399
+ Reason: this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #398
+ New state: shared-modified by threads #398, #399
+ Reason: this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #398
+ New state: shared-modified by threads #398, #399
+ Reason: this thread, #399, holds no locks at all
+---------- int gran, 2 .. 96, skip 2 ----------
+
+Thread #400 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #401 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #400
+ New state: shared-modified by threads #400, #401
+ Reason: this thread, #401, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #400
+ New state: shared-modified by threads #400, #401
+ Reason: this thread, #401, holds no locks at all
+---------- int gran, 3 .. 96, skip 3 ----------
+
+Thread #402 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #403 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #402
+ New state: shared-modified by threads #402, #403
+ Reason: this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #402
+ New state: shared-modified by threads #402, #403
+ Reason: this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #402
+ New state: shared-modified by threads #402, #403
+ Reason: this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #402
+ New state: shared-modified by threads #402, #403
+ Reason: this thread, #403, holds no locks at all
+---------- int gran, 0 .. 96, skip 4 ----------
+
+Thread #404 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #405 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:296)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #404
+ New state: shared-modified by threads #404, #405
+ Reason: this thread, #405, holds no locks at all
+---------- int gran, 1 .. 96, skip 5 ----------
+
+Thread #406 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #407 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #406
+ New state: shared-modified by threads #406, #407
+ Reason: this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #406
+ New state: shared-modified by threads #406, #407
+ Reason: this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #406
+ New state: shared-modified by threads #406, #407
+ Reason: this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #406
+ New state: shared-modified by threads #406, #407
+ Reason: this thread, #407, holds no locks at all
+---------- int gran, 2 .. 96, skip 6 ----------
+
+Thread #408 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #409 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #408
+ New state: shared-modified by threads #408, #409
+ Reason: this thread, #409, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #408
+ New state: shared-modified by threads #408, #409
+ Reason: this thread, #409, holds no locks at all
+---------- int gran, 3 .. 96, skip 7 ----------
+
+Thread #410 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #411 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #410
+ New state: shared-modified by threads #410, #411
+ Reason: this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #410
+ New state: shared-modified by threads #410, #411
+ Reason: this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #410
+ New state: shared-modified by threads #410, #411
+ Reason: this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #410
+ New state: shared-modified by threads #410, #411
+ Reason: this thread, #411, holds no locks at all
+---------- int gran, 0 .. 96, skip 8 ----------
+
+Thread #412 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #413 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:304)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #412
+ New state: shared-modified by threads #412, #413
+ Reason: this thread, #413, holds no locks at all
+---------- int gran, 1 .. 96, skip 9 ----------
+
+Thread #414 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #415 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #414
+ New state: shared-modified by threads #414, #415
+ Reason: this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #414
+ New state: shared-modified by threads #414, #415
+ Reason: this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #414
+ New state: shared-modified by threads #414, #415
+ Reason: this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #414
+ New state: shared-modified by threads #414, #415
+ Reason: this thread, #415, holds no locks at all
+---------- int gran, 2 .. 96, skip 10 ----------
+
+Thread #416 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #417 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #416
+ New state: shared-modified by threads #416, #417
+ Reason: this thread, #417, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #416
+ New state: shared-modified by threads #416, #417
+ Reason: this thread, #417, holds no locks at all
+---------- int gran, 3 .. 96, skip 11 ----------
+
+Thread #418 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #419 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #418
+ New state: shared-modified by threads #418, #419
+ Reason: this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #418
+ New state: shared-modified by threads #418, #419
+ Reason: this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #418
+ New state: shared-modified by threads #418, #419
+ Reason: this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #418
+ New state: shared-modified by threads #418, #419
+ Reason: this thread, #419, holds no locks at all
+---------- int gran, 0 .. 96, skip 12 ----------
+
+Thread #420 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #421 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:312)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #420
+ New state: shared-modified by threads #420, #421
+ Reason: this thread, #421, holds no locks at all
+---------- int gran, 1 .. 96, skip 13 ----------
+
+Thread #422 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #423 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #422
+ New state: shared-modified by threads #422, #423
+ Reason: this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #422
+ New state: shared-modified by threads #422, #423
+ Reason: this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #422
+ New state: shared-modified by threads #422, #423
+ Reason: this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #422
+ New state: shared-modified by threads #422, #423
+ Reason: this thread, #423, holds no locks at all
+---------- int gran, 2 .. 96, skip 14 ----------
+
+Thread #424 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #425 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #424
+ New state: shared-modified by threads #424, #425
+ Reason: this thread, #425, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #424
+ New state: shared-modified by threads #424, #425
+ Reason: this thread, #425, holds no locks at all
+---------- int gran, 3 .. 96, skip 15 ----------
+
+Thread #426 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #427 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #426
+ New state: shared-modified by threads #426, #427
+ Reason: this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #426
+ New state: shared-modified by threads #426, #427
+ Reason: this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #426
+ New state: shared-modified by threads #426, #427
+ Reason: this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #426
+ New state: shared-modified by threads #426, #427
+ Reason: this thread, #427, holds no locks at all
+---------- int gran, 0 .. 96, skip 16 ----------
+
+Thread #428 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #429 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:320)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #428
+ New state: shared-modified by threads #428, #429
+ Reason: this thread, #429, holds no locks at all
+---------- int gran, 1 .. 96, skip 17 ----------
+
+Thread #430 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #431 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #430
+ New state: shared-modified by threads #430, #431
+ Reason: this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #430
+ New state: shared-modified by threads #430, #431
+ Reason: this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #430
+ New state: shared-modified by threads #430, #431
+ Reason: this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #430
+ New state: shared-modified by threads #430, #431
+ Reason: this thread, #431, holds no locks at all
+---------- int gran, 2 .. 96, skip 18 ----------
+
+Thread #432 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #433 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #432
+ New state: shared-modified by threads #432, #433
+ Reason: this thread, #433, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #432
+ New state: shared-modified by threads #432, #433
+ Reason: this thread, #433, holds no locks at all
+---------- int gran, 3 .. 96, skip 19 ----------
+
+Thread #434 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #435 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #434
+ New state: shared-modified by threads #434, #435
+ Reason: this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #434
+ New state: shared-modified by threads #434, #435
+ Reason: this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #434
+ New state: shared-modified by threads #434, #435
+ Reason: this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #434
+ New state: shared-modified by threads #434, #435
+ Reason: this thread, #435, holds no locks at all
+---------- int gran, 0 .. 96, skip 20 ----------
+
+Thread #436 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #437 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:328)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #436
+ New state: shared-modified by threads #436, #437
+ Reason: this thread, #437, holds no locks at all
+---------- int gran, 1 .. 96, skip 21 ----------
+
+Thread #438 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #439 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #438
+ New state: shared-modified by threads #438, #439
+ Reason: this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #438
+ New state: shared-modified by threads #438, #439
+ Reason: this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #438
+ New state: shared-modified by threads #438, #439
+ Reason: this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #438
+ New state: shared-modified by threads #438, #439
+ Reason: this thread, #439, holds no locks at all
+---------- int gran, 2 .. 96, skip 22 ----------
+
+Thread #440 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #441 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #440
+ New state: shared-modified by threads #440, #441
+ Reason: this thread, #441, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #440
+ New state: shared-modified by threads #440, #441
+ Reason: this thread, #441, holds no locks at all
+---------- int gran, 3 .. 96, skip 23 ----------
+
+Thread #442 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #443 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #442
+ New state: shared-modified by threads #442, #443
+ Reason: this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #442
+ New state: shared-modified by threads #442, #443
+ Reason: this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #442
+ New state: shared-modified by threads #442, #443
+ Reason: this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #442
+ New state: shared-modified by threads #442, #443
+ Reason: this thread, #443, holds no locks at all
+---------- int gran, 0 .. 96, skip 24 ----------
+
+Thread #444 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #445 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:336)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #444
+ New state: shared-modified by threads #444, #445
+ Reason: this thread, #445, holds no locks at all
+---------- int gran, 1 .. 96, skip 25 ----------
+
+Thread #446 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #447 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #446
+ New state: shared-modified by threads #446, #447
+ Reason: this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #446
+ New state: shared-modified by threads #446, #447
+ Reason: this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #446
+ New state: shared-modified by threads #446, #447
+ Reason: this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #446
+ New state: shared-modified by threads #446, #447
+ Reason: this thread, #447, holds no locks at all
+---------- int gran, 2 .. 96, skip 26 ----------
+
+Thread #448 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #449 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #448
+ New state: shared-modified by threads #448, #449
+ Reason: this thread, #449, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #448
+ New state: shared-modified by threads #448, #449
+ Reason: this thread, #449, holds no locks at all
+---------- int gran, 3 .. 96, skip 27 ----------
+
+Thread #450 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #451 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #450
+ New state: shared-modified by threads #450, #451
+ Reason: this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #450
+ New state: shared-modified by threads #450, #451
+ Reason: this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #450
+ New state: shared-modified by threads #450, #451
+ Reason: this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #450
+ New state: shared-modified by threads #450, #451
+ Reason: this thread, #451, holds no locks at all
+---------- int gran, 0 .. 96, skip 28 ----------
+
+Thread #452 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #453 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:344)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #452
+ New state: shared-modified by threads #452, #453
+ Reason: this thread, #453, holds no locks at all
+---------- int gran, 1 .. 96, skip 29 ----------
+
+Thread #454 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #455 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #454
+ New state: shared-modified by threads #454, #455
+ Reason: this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #454
+ New state: shared-modified by threads #454, #455
+ Reason: this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #454
+ New state: shared-modified by threads #454, #455
+ Reason: this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #454
+ New state: shared-modified by threads #454, #455
+ Reason: this thread, #455, holds no locks at all
+---------- int gran, 2 .. 96, skip 30 ----------
+
+Thread #456 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #457 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #456
+ New state: shared-modified by threads #456, #457
+ Reason: this thread, #457, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #456
+ New state: shared-modified by threads #456, #457
+ Reason: this thread, #457, holds no locks at all
+---------- int gran, 3 .. 96, skip 31 ----------
+
+Thread #458 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #459 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #458
+ New state: shared-modified by threads #458, #459
+ Reason: this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #458
+ New state: shared-modified by threads #458, #459
+ Reason: this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #458
+ New state: shared-modified by threads #458, #459
+ Reason: this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #458
+ New state: shared-modified by threads #458, #459
+ Reason: this thread, #459, holds no locks at all
+---------- int gran, 0 .. 96, skip 32 ----------
+
+Thread #460 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #461 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:352)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #460
+ New state: shared-modified by threads #460, #461
+ Reason: this thread, #461, holds no locks at all
+---------- int gran, 1 .. 96, skip 33 ----------
+
+Thread #462 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #463 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #462
+ New state: shared-modified by threads #462, #463
+ Reason: this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #462
+ New state: shared-modified by threads #462, #463
+ Reason: this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #462
+ New state: shared-modified by threads #462, #463
+ Reason: this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #462
+ New state: shared-modified by threads #462, #463
+ Reason: this thread, #463, holds no locks at all
+---------- int gran, 2 .. 96, skip 34 ----------
+
+Thread #464 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #465 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #464
+ New state: shared-modified by threads #464, #465
+ Reason: this thread, #465, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #464
+ New state: shared-modified by threads #464, #465
+ Reason: this thread, #465, holds no locks at all
+---------- int gran, 3 .. 96, skip 35 ----------
+
+Thread #466 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #467 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #466
+ New state: shared-modified by threads #466, #467
+ Reason: this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #466
+ New state: shared-modified by threads #466, #467
+ Reason: this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #466
+ New state: shared-modified by threads #466, #467
+ Reason: this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #466
+ New state: shared-modified by threads #466, #467
+ Reason: this thread, #467, holds no locks at all
+---------- int gran, 0 .. 96, skip 36 ----------
+
+Thread #468 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #469 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:360)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #468
+ New state: shared-modified by threads #468, #469
+ Reason: this thread, #469, holds no locks at all
+---------- int gran, 1 .. 96, skip 37 ----------
+
+Thread #470 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #471 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #470
+ New state: shared-modified by threads #470, #471
+ Reason: this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #470
+ New state: shared-modified by threads #470, #471
+ Reason: this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #470
+ New state: shared-modified by threads #470, #471
+ Reason: this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #470
+ New state: shared-modified by threads #470, #471
+ Reason: this thread, #471, holds no locks at all
+---------- int gran, 2 .. 96, skip 38 ----------
+
+Thread #472 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #473 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #472
+ New state: shared-modified by threads #472, #473
+ Reason: this thread, #473, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #472
+ New state: shared-modified by threads #472, #473
+ Reason: this thread, #473, holds no locks at all
+---------- int gran, 3 .. 96, skip 39 ----------
+
+Thread #474 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #475 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #474
+ New state: shared-modified by threads #474, #475
+ Reason: this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #474
+ New state: shared-modified by threads #474, #475
+ Reason: this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #474
+ New state: shared-modified by threads #474, #475
+ Reason: this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #474
+ New state: shared-modified by threads #474, #475
+ Reason: this thread, #475, holds no locks at all
+---------- int gran, 0 .. 96, skip 40 ----------
+
+Thread #476 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #477 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:368)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #476
+ New state: shared-modified by threads #476, #477
+ Reason: this thread, #477, holds no locks at all
+---------- int gran, 1 .. 96, skip 41 ----------
+
+Thread #478 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #479 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #478
+ New state: shared-modified by threads #478, #479
+ Reason: this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #478
+ New state: shared-modified by threads #478, #479
+ Reason: this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #478
+ New state: shared-modified by threads #478, #479
+ Reason: this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #478
+ New state: shared-modified by threads #478, #479
+ Reason: this thread, #479, holds no locks at all
+---------- int gran, 2 .. 96, skip 42 ----------
+
+Thread #480 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #481 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #480
+ New state: shared-modified by threads #480, #481
+ Reason: this thread, #481, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #480
+ New state: shared-modified by threads #480, #481
+ Reason: this thread, #481, holds no locks at all
+---------- int gran, 3 .. 96, skip 43 ----------
+
+Thread #482 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #483 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #482
+ New state: shared-modified by threads #482, #483
+ Reason: this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #482
+ New state: shared-modified by threads #482, #483
+ Reason: this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #482
+ New state: shared-modified by threads #482, #483
+ Reason: this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #482
+ New state: shared-modified by threads #482, #483
+ Reason: this thread, #483, holds no locks at all
+---------- int gran, 0 .. 96, skip 44 ----------
+
+Thread #484 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #485 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:376)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #484
+ New state: shared-modified by threads #484, #485
+ Reason: this thread, #485, holds no locks at all
+---------- int gran, 1 .. 96, skip 45 ----------
+
+Thread #486 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #487 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #486
+ New state: shared-modified by threads #486, #487
+ Reason: this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #486
+ New state: shared-modified by threads #486, #487
+ Reason: this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #486
+ New state: shared-modified by threads #486, #487
+ Reason: this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #486
+ New state: shared-modified by threads #486, #487
+ Reason: this thread, #487, holds no locks at all
+---------- int gran, 2 .. 96, skip 46 ----------
+
+Thread #488 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #489 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #488
+ New state: shared-modified by threads #488, #489
+ Reason: this thread, #489, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #488
+ New state: shared-modified by threads #488, #489
+ Reason: this thread, #489, holds no locks at all
+---------- int gran, 3 .. 96, skip 47 ----------
+
+Thread #490 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #491 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #490
+ New state: shared-modified by threads #490, #491
+ Reason: this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #490
+ New state: shared-modified by threads #490, #491
+ Reason: this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #490
+ New state: shared-modified by threads #490, #491
+ Reason: this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #490
+ New state: shared-modified by threads #490, #491
+ Reason: this thread, #491, holds no locks at all
+---------- int gran, 0 .. 96, skip 48 ----------
+
+Thread #492 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #493 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:384)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #492
+ New state: shared-modified by threads #492, #493
+ Reason: this thread, #493, holds no locks at all
+---------- int gran, 1 .. 96, skip 49 ----------
+
+Thread #494 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #495 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #494
+ New state: shared-modified by threads #494, #495
+ Reason: this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #494
+ New state: shared-modified by threads #494, #495
+ Reason: this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #494
+ New state: shared-modified by threads #494, #495
+ Reason: this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #494
+ New state: shared-modified by threads #494, #495
+ Reason: this thread, #495, holds no locks at all
+---------- int gran, 2 .. 96, skip 50 ----------
+
+Thread #496 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #497 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #496
+ New state: shared-modified by threads #496, #497
+ Reason: this thread, #497, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #496
+ New state: shared-modified by threads #496, #497
+ Reason: this thread, #497, holds no locks at all
+---------- int gran, 3 .. 96, skip 51 ----------
+
+Thread #498 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #499 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #498
+ New state: shared-modified by threads #498, #499
+ Reason: this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #498
+ New state: shared-modified by threads #498, #499
+ Reason: this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #498
+ New state: shared-modified by threads #498, #499
+ Reason: this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #498
+ New state: shared-modified by threads #498, #499
+ Reason: this thread, #499, holds no locks at all
+---------- int gran, 0 .. 96, skip 52 ----------
+
+Thread #500 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #501 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:392)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #500
+ New state: shared-modified by threads #500, #501
+ Reason: this thread, #501, holds no locks at all
+---------- int gran, 1 .. 96, skip 53 ----------
+
+Thread #502 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #503 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #502
+ New state: shared-modified by threads #502, #503
+ Reason: this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #502
+ New state: shared-modified by threads #502, #503
+ Reason: this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #502
+ New state: shared-modified by threads #502, #503
+ Reason: this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #502
+ New state: shared-modified by threads #502, #503
+ Reason: this thread, #503, holds no locks at all
+---------- int gran, 2 .. 96, skip 54 ----------
+
+Thread #504 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #505 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #504
+ New state: shared-modified by threads #504, #505
+ Reason: this thread, #505, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #504
+ New state: shared-modified by threads #504, #505
+ Reason: this thread, #505, holds no locks at all
+---------- int gran, 3 .. 96, skip 55 ----------
+
+Thread #506 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #507 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #506
+ New state: shared-modified by threads #506, #507
+ Reason: this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #506
+ New state: shared-modified by threads #506, #507
+ Reason: this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #506
+ New state: shared-modified by threads #506, #507
+ Reason: this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #506
+ New state: shared-modified by threads #506, #507
+ Reason: this thread, #507, holds no locks at all
+---------- int gran, 0 .. 96, skip 56 ----------
+
+Thread #508 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #509 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:400)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #508
+ New state: shared-modified by threads #508, #509
+ Reason: this thread, #509, holds no locks at all
+---------- int gran, 1 .. 96, skip 57 ----------
+
+Thread #510 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #511 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #510
+ New state: shared-modified by threads #510, #511
+ Reason: this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #510
+ New state: shared-modified by threads #510, #511
+ Reason: this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #510
+ New state: shared-modified by threads #510, #511
+ Reason: this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #510
+ New state: shared-modified by threads #510, #511
+ Reason: this thread, #511, holds no locks at all
+---------- int gran, 2 .. 96, skip 58 ----------
+
+Thread #512 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #513 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #512
+ New state: shared-modified by threads #512, #513
+ Reason: this thread, #513, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #512
+ New state: shared-modified by threads #512, #513
+ Reason: this thread, #513, holds no locks at all
+---------- int gran, 3 .. 96, skip 59 ----------
+
+Thread #514 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #515 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #514
+ New state: shared-modified by threads #514, #515
+ Reason: this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #514
+ New state: shared-modified by threads #514, #515
+ Reason: this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #514
+ New state: shared-modified by threads #514, #515
+ Reason: this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #514
+ New state: shared-modified by threads #514, #515
+ Reason: this thread, #515, holds no locks at all
+---------- int gran, 0 .. 96, skip 60 ----------
+
+Thread #516 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #517 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:408)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #516
+ New state: shared-modified by threads #516, #517
+ Reason: this thread, #517, holds no locks at all
+---------- int gran, 1 .. 96, skip 61 ----------
+
+Thread #518 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #519 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #518
+ New state: shared-modified by threads #518, #519
+ Reason: this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #518
+ New state: shared-modified by threads #518, #519
+ Reason: this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #518
+ New state: shared-modified by threads #518, #519
+ Reason: this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #518
+ New state: shared-modified by threads #518, #519
+ Reason: this thread, #519, holds no locks at all
+---------- int gran, 2 .. 96, skip 62 ----------
+
+Thread #520 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #521 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #520
+ New state: shared-modified by threads #520, #521
+ Reason: this thread, #521, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #520
+ New state: shared-modified by threads #520, #521
+ Reason: this thread, #521, holds no locks at all
+---------- int gran, 3 .. 96, skip 63 ----------
+
+Thread #522 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #523 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #522
+ New state: shared-modified by threads #522, #523
+ Reason: this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #522
+ New state: shared-modified by threads #522, #523
+ Reason: this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #522
+ New state: shared-modified by threads #522, #523
+ Reason: this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #522
+ New state: shared-modified by threads #522, #523
+ Reason: this thread, #523, holds no locks at all
+---------- int gran, 0 .. 96, skip 64 ----------
+
+Thread #524 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #525 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:416)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #524
+ New state: shared-modified by threads #524, #525
+ Reason: this thread, #525, holds no locks at all
+---------- int gran, 1 .. 96, skip 65 ----------
+
+Thread #526 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #527 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #526
+ New state: shared-modified by threads #526, #527
+ Reason: this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #526
+ New state: shared-modified by threads #526, #527
+ Reason: this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #526
+ New state: shared-modified by threads #526, #527
+ Reason: this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #526
+ New state: shared-modified by threads #526, #527
+ Reason: this thread, #527, holds no locks at all
+---------- int gran, 2 .. 96, skip 66 ----------
+
+Thread #528 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #529 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #528
+ New state: shared-modified by threads #528, #529
+ Reason: this thread, #529, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #528
+ New state: shared-modified by threads #528, #529
+ Reason: this thread, #529, holds no locks at all
+---------- int gran, 3 .. 96, skip 67 ----------
+
+Thread #530 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #531 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #530
+ New state: shared-modified by threads #530, #531
+ Reason: this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #530
+ New state: shared-modified by threads #530, #531
+ Reason: this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #530
+ New state: shared-modified by threads #530, #531
+ Reason: this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #530
+ New state: shared-modified by threads #530, #531
+ Reason: this thread, #531, holds no locks at all
+---------- int gran, 0 .. 96, skip 68 ----------
+
+Thread #532 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #533 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:424)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #532
+ New state: shared-modified by threads #532, #533
+ Reason: this thread, #533, holds no locks at all
+---------- int gran, 1 .. 96, skip 69 ----------
+
+Thread #534 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #535 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #534
+ New state: shared-modified by threads #534, #535
+ Reason: this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #534
+ New state: shared-modified by threads #534, #535
+ Reason: this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #534
+ New state: shared-modified by threads #534, #535
+ Reason: this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #534
+ New state: shared-modified by threads #534, #535
+ Reason: this thread, #535, holds no locks at all
+---------- int gran, 2 .. 96, skip 70 ----------
+
+Thread #536 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #537 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #536
+ New state: shared-modified by threads #536, #537
+ Reason: this thread, #537, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #536
+ New state: shared-modified by threads #536, #537
+ Reason: this thread, #537, holds no locks at all
+---------- int gran, 3 .. 96, skip 71 ----------
+
+Thread #538 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #539 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #538
+ New state: shared-modified by threads #538, #539
+ Reason: this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #538
+ New state: shared-modified by threads #538, #539
+ Reason: this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #538
+ New state: shared-modified by threads #538, #539
+ Reason: this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #538
+ New state: shared-modified by threads #538, #539
+ Reason: this thread, #539, holds no locks at all
+---------- int gran, 0 .. 96, skip 72 ----------
+
+Thread #540 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #541 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:432)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #540
+ New state: shared-modified by threads #540, #541
+ Reason: this thread, #541, holds no locks at all
+---------- int gran, 1 .. 96, skip 73 ----------
+
+Thread #542 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #543 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #542
+ New state: shared-modified by threads #542, #543
+ Reason: this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #542
+ New state: shared-modified by threads #542, #543
+ Reason: this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #542
+ New state: shared-modified by threads #542, #543
+ Reason: this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #542
+ New state: shared-modified by threads #542, #543
+ Reason: this thread, #543, holds no locks at all
+---------- int gran, 2 .. 96, skip 74 ----------
+
+Thread #544 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #545 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #544
+ New state: shared-modified by threads #544, #545
+ Reason: this thread, #545, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #544
+ New state: shared-modified by threads #544, #545
+ Reason: this thread, #545, holds no locks at all
+---------- int gran, 3 .. 96, skip 75 ----------
+
+Thread #546 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #547 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #546
+ New state: shared-modified by threads #546, #547
+ Reason: this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #546
+ New state: shared-modified by threads #546, #547
+ Reason: this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #546
+ New state: shared-modified by threads #546, #547
+ Reason: this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #546
+ New state: shared-modified by threads #546, #547
+ Reason: this thread, #547, holds no locks at all
+---------- int gran, 0 .. 96, skip 76 ----------
+
+Thread #548 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #549 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:440)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #548
+ New state: shared-modified by threads #548, #549
+ Reason: this thread, #549, holds no locks at all
+---------- int gran, 1 .. 96, skip 77 ----------
+
+Thread #550 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #551 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #550
+ New state: shared-modified by threads #550, #551
+ Reason: this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #550
+ New state: shared-modified by threads #550, #551
+ Reason: this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #550
+ New state: shared-modified by threads #550, #551
+ Reason: this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #550
+ New state: shared-modified by threads #550, #551
+ Reason: this thread, #551, holds no locks at all
+---------- int gran, 2 .. 96, skip 78 ----------
+
+Thread #552 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #553 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #552
+ New state: shared-modified by threads #552, #553
+ Reason: this thread, #553, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #552
+ New state: shared-modified by threads #552, #553
+ Reason: this thread, #553, holds no locks at all
+---------- int gran, 3 .. 96, skip 79 ----------
+
+Thread #554 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #555 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #554
+ New state: shared-modified by threads #554, #555
+ Reason: this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #554
+ New state: shared-modified by threads #554, #555
+ Reason: this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #554
+ New state: shared-modified by threads #554, #555
+ Reason: this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #554
+ New state: shared-modified by threads #554, #555
+ Reason: this thread, #555, holds no locks at all
+---------- int gran, 0 .. 96, skip 80 ----------
+
+Thread #556 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #557 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:448)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #556
+ New state: shared-modified by threads #556, #557
+ Reason: this thread, #557, holds no locks at all
+---------- int gran, 1 .. 96, skip 81 ----------
+
+Thread #558 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #559 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #558
+ New state: shared-modified by threads #558, #559
+ Reason: this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #558
+ New state: shared-modified by threads #558, #559
+ Reason: this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #558
+ New state: shared-modified by threads #558, #559
+ Reason: this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #558
+ New state: shared-modified by threads #558, #559
+ Reason: this thread, #559, holds no locks at all
+---------- int gran, 2 .. 96, skip 82 ----------
+
+Thread #560 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #561 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #560
+ New state: shared-modified by threads #560, #561
+ Reason: this thread, #561, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #560
+ New state: shared-modified by threads #560, #561
+ Reason: this thread, #561, holds no locks at all
+---------- int gran, 3 .. 96, skip 83 ----------
+
+Thread #562 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #563 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #562
+ New state: shared-modified by threads #562, #563
+ Reason: this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #562
+ New state: shared-modified by threads #562, #563
+ Reason: this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #562
+ New state: shared-modified by threads #562, #563
+ Reason: this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #562
+ New state: shared-modified by threads #562, #563
+ Reason: this thread, #563, holds no locks at all
+---------- int gran, 0 .. 96, skip 84 ----------
+
+Thread #564 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #565 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:456)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #564
+ New state: shared-modified by threads #564, #565
+ Reason: this thread, #565, holds no locks at all
+---------- int gran, 1 .. 96, skip 85 ----------
+
+Thread #566 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #567 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #566
+ New state: shared-modified by threads #566, #567
+ Reason: this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #566
+ New state: shared-modified by threads #566, #567
+ Reason: this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #566
+ New state: shared-modified by threads #566, #567
+ Reason: this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #566
+ New state: shared-modified by threads #566, #567
+ Reason: this thread, #567, holds no locks at all
+---------- int gran, 2 .. 96, skip 86 ----------
+
+Thread #568 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #569 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #568
+ New state: shared-modified by threads #568, #569
+ Reason: this thread, #569, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #568
+ New state: shared-modified by threads #568, #569
+ Reason: this thread, #569, holds no locks at all
+---------- int gran, 3 .. 96, skip 87 ----------
+
+Thread #570 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #571 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #570
+ New state: shared-modified by threads #570, #571
+ Reason: this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #570
+ New state: shared-modified by threads #570, #571
+ Reason: this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #570
+ New state: shared-modified by threads #570, #571
+ Reason: this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #570
+ New state: shared-modified by threads #570, #571
+ Reason: this thread, #571, holds no locks at all
+---------- int gran, 0 .. 96, skip 88 ----------
+
+Thread #572 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #573 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:464)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #572
+ New state: shared-modified by threads #572, #573
+ Reason: this thread, #573, holds no locks at all
+---------- int gran, 1 .. 96, skip 89 ----------
+
+Thread #574 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #575 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #574
+ New state: shared-modified by threads #574, #575
+ Reason: this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #574
+ New state: shared-modified by threads #574, #575
+ Reason: this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #574
+ New state: shared-modified by threads #574, #575
+ Reason: this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #574
+ New state: shared-modified by threads #574, #575
+ Reason: this thread, #575, holds no locks at all
+---------- int gran, 2 .. 96, skip 90 ----------
+
+Thread #576 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #577 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #576
+ New state: shared-modified by threads #576, #577
+ Reason: this thread, #577, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #576
+ New state: shared-modified by threads #576, #577
+ Reason: this thread, #577, holds no locks at all
+---------- int gran, 3 .. 96, skip 91 ----------
+
+Thread #578 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #579 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #578
+ New state: shared-modified by threads #578, #579
+ Reason: this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #578
+ New state: shared-modified by threads #578, #579
+ Reason: this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #578
+ New state: shared-modified by threads #578, #579
+ Reason: this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #578
+ New state: shared-modified by threads #578, #579
+ Reason: this thread, #579, holds no locks at all
+---------- int gran, 0 .. 96, skip 92 ----------
+
+Thread #580 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #581 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:472)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #580
+ New state: shared-modified by threads #580, #581
+ Reason: this thread, #581, holds no locks at all
+---------- int gran, 1 .. 96, skip 93 ----------
+
+Thread #582 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #583 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #582
+ New state: shared-modified by threads #582, #583
+ Reason: this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #582
+ New state: shared-modified by threads #582, #583
+ Reason: this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #582
+ New state: shared-modified by threads #582, #583
+ Reason: this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #582
+ New state: shared-modified by threads #582, #583
+ Reason: this thread, #583, holds no locks at all
+---------- int gran, 2 .. 96, skip 94 ----------
+
+Thread #584 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #585 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:476)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #584
+ New state: shared-modified by threads #584, #585
+ Reason: this thread, #585, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:476)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #584
+ New state: shared-modified by threads #584, #585
+ Reason: this thread, #585, holds no locks at all
+---------- int gran, 3 .. 96, skip 95 ----------
+
+Thread #586 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #587 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #586
+ New state: shared-modified by threads #586, #587
+ Reason: this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #586
+ New state: shared-modified by threads #586, #587
+ Reason: this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #586
+ New state: shared-modified by threads #586, #587
+ Reason: this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #586
+ New state: shared-modified by threads #586, #587
+ Reason: this thread, #587, holds no locks at all
+
+==========================================================
+=== 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 ===
+==========================================================
+
+---------- double gran, 0 .. 92, skip 0 ----------
+
+Thread #588 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #589 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:288)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #588
+ New state: shared-modified by threads #588, #589
+ Reason: this thread, #589, holds no locks at all
+---------- double gran, 1 .. 92, skip 1 ----------
+
+Thread #590 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #591 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+---------- double gran, 2 .. 92, skip 2 ----------
+
+Thread #592 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #593 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #592
+ New state: shared-modified by threads #592, #593
+ Reason: this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #592
+ New state: shared-modified by threads #592, #593
+ Reason: this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #592
+ New state: shared-modified by threads #592, #593
+ Reason: this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #592
+ New state: shared-modified by threads #592, #593
+ Reason: this thread, #593, holds no locks at all
+---------- double gran, 3 .. 92, skip 3 ----------
+
+Thread #594 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #595 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+---------- double gran, 4 .. 92, skip 4 ----------
+
+Thread #596 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #597 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:296)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #596
+ New state: shared-modified by threads #596, #597
+ Reason: this thread, #597, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:296)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #596
+ New state: shared-modified by threads #596, #597
+ Reason: this thread, #597, holds no locks at all
+---------- double gran, 5 .. 92, skip 5 ----------
+
+Thread #598 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #599 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+---------- double gran, 6 .. 92, skip 6 ----------
+
+Thread #600 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #601 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #600
+ New state: shared-modified by threads #600, #601
+ Reason: this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #600
+ New state: shared-modified by threads #600, #601
+ Reason: this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #600
+ New state: shared-modified by threads #600, #601
+ Reason: this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #600
+ New state: shared-modified by threads #600, #601
+ Reason: this thread, #601, holds no locks at all
+---------- double gran, 7 .. 92, skip 7 ----------
+
+Thread #602 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #603 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+---------- double gran, 0 .. 92, skip 8 ----------
+
+Thread #604 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #605 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:304)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #604
+ New state: shared-modified by threads #604, #605
+ Reason: this thread, #605, holds no locks at all
+---------- double gran, 1 .. 92, skip 9 ----------
+
+Thread #606 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #607 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+---------- double gran, 2 .. 92, skip 10 ----------
+
+Thread #608 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #609 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #608
+ New state: shared-modified by threads #608, #609
+ Reason: this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #608
+ New state: shared-modified by threads #608, #609
+ Reason: this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #608
+ New state: shared-modified by threads #608, #609
+ Reason: this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #608
+ New state: shared-modified by threads #608, #609
+ Reason: this thread, #609, holds no locks at all
+---------- double gran, 3 .. 92, skip 11 ----------
+
+Thread #610 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #611 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+---------- double gran, 4 .. 92, skip 12 ----------
+
+Thread #612 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #613 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:312)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #612
+ New state: shared-modified by threads #612, #613
+ Reason: this thread, #613, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:312)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #612
+ New state: shared-modified by threads #612, #613
+ Reason: this thread, #613, holds no locks at all
+---------- double gran, 5 .. 92, skip 13 ----------
+
+Thread #614 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #615 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+---------- double gran, 6 .. 92, skip 14 ----------
+
+Thread #616 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #617 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #616
+ New state: shared-modified by threads #616, #617
+ Reason: this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #616
+ New state: shared-modified by threads #616, #617
+ Reason: this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #616
+ New state: shared-modified by threads #616, #617
+ Reason: this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #616
+ New state: shared-modified by threads #616, #617
+ Reason: this thread, #617, holds no locks at all
+---------- double gran, 7 .. 92, skip 15 ----------
+
+Thread #618 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #619 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+---------- double gran, 0 .. 92, skip 16 ----------
+
+Thread #620 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #621 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:320)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #620
+ New state: shared-modified by threads #620, #621
+ Reason: this thread, #621, holds no locks at all
+---------- double gran, 1 .. 92, skip 17 ----------
+
+Thread #622 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #623 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+---------- double gran, 2 .. 92, skip 18 ----------
+
+Thread #624 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #625 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #624
+ New state: shared-modified by threads #624, #625
+ Reason: this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #624
+ New state: shared-modified by threads #624, #625
+ Reason: this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #624
+ New state: shared-modified by threads #624, #625
+ Reason: this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #624
+ New state: shared-modified by threads #624, #625
+ Reason: this thread, #625, holds no locks at all
+---------- double gran, 3 .. 92, skip 19 ----------
+
+Thread #626 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #627 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+---------- double gran, 4 .. 92, skip 20 ----------
+
+Thread #628 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #629 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:328)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #628
+ New state: shared-modified by threads #628, #629
+ Reason: this thread, #629, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:328)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #628
+ New state: shared-modified by threads #628, #629
+ Reason: this thread, #629, holds no locks at all
+---------- double gran, 5 .. 92, skip 21 ----------
+
+Thread #630 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #631 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+---------- double gran, 6 .. 92, skip 22 ----------
+
+Thread #632 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #633 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #632
+ New state: shared-modified by threads #632, #633
+ Reason: this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #632
+ New state: shared-modified by threads #632, #633
+ Reason: this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #632
+ New state: shared-modified by threads #632, #633
+ Reason: this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #632
+ New state: shared-modified by threads #632, #633
+ Reason: this thread, #633, holds no locks at all
+---------- double gran, 7 .. 92, skip 23 ----------
+
+Thread #634 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #635 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+---------- double gran, 0 .. 92, skip 24 ----------
+
+Thread #636 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #637 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:336)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #636
+ New state: shared-modified by threads #636, #637
+ Reason: this thread, #637, holds no locks at all
+---------- double gran, 1 .. 92, skip 25 ----------
+
+Thread #638 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #639 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+---------- double gran, 2 .. 92, skip 26 ----------
+
+Thread #640 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #641 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #640
+ New state: shared-modified by threads #640, #641
+ Reason: this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #640
+ New state: shared-modified by threads #640, #641
+ Reason: this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #640
+ New state: shared-modified by threads #640, #641
+ Reason: this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #640
+ New state: shared-modified by threads #640, #641
+ Reason: this thread, #641, holds no locks at all
+---------- double gran, 3 .. 92, skip 27 ----------
+
+Thread #642 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #643 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+---------- double gran, 4 .. 92, skip 28 ----------
+
+Thread #644 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #645 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:344)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #644
+ New state: shared-modified by threads #644, #645
+ Reason: this thread, #645, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:344)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #644
+ New state: shared-modified by threads #644, #645
+ Reason: this thread, #645, holds no locks at all
+---------- double gran, 5 .. 92, skip 29 ----------
+
+Thread #646 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #647 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+---------- double gran, 6 .. 92, skip 30 ----------
+
+Thread #648 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #649 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #648
+ New state: shared-modified by threads #648, #649
+ Reason: this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #648
+ New state: shared-modified by threads #648, #649
+ Reason: this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #648
+ New state: shared-modified by threads #648, #649
+ Reason: this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #648
+ New state: shared-modified by threads #648, #649
+ Reason: this thread, #649, holds no locks at all
+---------- double gran, 7 .. 92, skip 31 ----------
+
+Thread #650 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #651 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+---------- double gran, 0 .. 92, skip 32 ----------
+
+Thread #652 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #653 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:352)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #652
+ New state: shared-modified by threads #652, #653
+ Reason: this thread, #653, holds no locks at all
+---------- double gran, 1 .. 92, skip 33 ----------
+
+Thread #654 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #655 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+---------- double gran, 2 .. 92, skip 34 ----------
+
+Thread #656 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #657 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #656
+ New state: shared-modified by threads #656, #657
+ Reason: this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #656
+ New state: shared-modified by threads #656, #657
+ Reason: this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #656
+ New state: shared-modified by threads #656, #657
+ Reason: this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #656
+ New state: shared-modified by threads #656, #657
+ Reason: this thread, #657, holds no locks at all
+---------- double gran, 3 .. 92, skip 35 ----------
+
+Thread #658 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #659 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+---------- double gran, 4 .. 92, skip 36 ----------
+
+Thread #660 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #661 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:360)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #660
+ New state: shared-modified by threads #660, #661
+ Reason: this thread, #661, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:360)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #660
+ New state: shared-modified by threads #660, #661
+ Reason: this thread, #661, holds no locks at all
+---------- double gran, 5 .. 92, skip 37 ----------
+
+Thread #662 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #663 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+---------- double gran, 6 .. 92, skip 38 ----------
+
+Thread #664 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #665 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #664
+ New state: shared-modified by threads #664, #665
+ Reason: this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #664
+ New state: shared-modified by threads #664, #665
+ Reason: this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #664
+ New state: shared-modified by threads #664, #665
+ Reason: this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #664
+ New state: shared-modified by threads #664, #665
+ Reason: this thread, #665, holds no locks at all
+---------- double gran, 7 .. 92, skip 39 ----------
+
+Thread #666 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #667 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+---------- double gran, 0 .. 92, skip 40 ----------
+
+Thread #668 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #669 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:368)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #668
+ New state: shared-modified by threads #668, #669
+ Reason: this thread, #669, holds no locks at all
+---------- double gran, 1 .. 92, skip 41 ----------
+
+Thread #670 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #671 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+---------- double gran, 2 .. 92, skip 42 ----------
+
+Thread #672 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #673 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #672
+ New state: shared-modified by threads #672, #673
+ Reason: this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #672
+ New state: shared-modified by threads #672, #673
+ Reason: this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #672
+ New state: shared-modified by threads #672, #673
+ Reason: this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #672
+ New state: shared-modified by threads #672, #673
+ Reason: this thread, #673, holds no locks at all
+---------- double gran, 3 .. 92, skip 43 ----------
+
+Thread #674 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #675 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+---------- double gran, 4 .. 92, skip 44 ----------
+
+Thread #676 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #677 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:376)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #676
+ New state: shared-modified by threads #676, #677
+ Reason: this thread, #677, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:376)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #676
+ New state: shared-modified by threads #676, #677
+ Reason: this thread, #677, holds no locks at all
+---------- double gran, 5 .. 92, skip 45 ----------
+
+Thread #678 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #679 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+---------- double gran, 6 .. 92, skip 46 ----------
+
+Thread #680 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #681 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #680
+ New state: shared-modified by threads #680, #681
+ Reason: this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #680
+ New state: shared-modified by threads #680, #681
+ Reason: this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #680
+ New state: shared-modified by threads #680, #681
+ Reason: this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #680
+ New state: shared-modified by threads #680, #681
+ Reason: this thread, #681, holds no locks at all
+---------- double gran, 7 .. 92, skip 47 ----------
+
+Thread #682 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #683 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+---------- double gran, 0 .. 92, skip 48 ----------
+
+Thread #684 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #685 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:384)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #684
+ New state: shared-modified by threads #684, #685
+ Reason: this thread, #685, holds no locks at all
+---------- double gran, 1 .. 92, skip 49 ----------
+
+Thread #686 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #687 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+---------- double gran, 2 .. 92, skip 50 ----------
+
+Thread #688 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #689 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #688
+ New state: shared-modified by threads #688, #689
+ Reason: this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #688
+ New state: shared-modified by threads #688, #689
+ Reason: this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #688
+ New state: shared-modified by threads #688, #689
+ Reason: this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #688
+ New state: shared-modified by threads #688, #689
+ Reason: this thread, #689, holds no locks at all
+---------- double gran, 3 .. 92, skip 51 ----------
+
+Thread #690 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #691 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+---------- double gran, 4 .. 92, skip 52 ----------
+
+Thread #692 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #693 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:392)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #692
+ New state: shared-modified by threads #692, #693
+ Reason: this thread, #693, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:392)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #692
+ New state: shared-modified by threads #692, #693
+ Reason: this thread, #693, holds no locks at all
+---------- double gran, 5 .. 92, skip 53 ----------
+
+Thread #694 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #695 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+---------- double gran, 6 .. 92, skip 54 ----------
+
+Thread #696 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #697 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #696
+ New state: shared-modified by threads #696, #697
+ Reason: this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #696
+ New state: shared-modified by threads #696, #697
+ Reason: this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #696
+ New state: shared-modified by threads #696, #697
+ Reason: this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #696
+ New state: shared-modified by threads #696, #697
+ Reason: this thread, #697, holds no locks at all
+---------- double gran, 7 .. 92, skip 55 ----------
+
+Thread #698 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #699 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+---------- double gran, 0 .. 92, skip 56 ----------
+
+Thread #700 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #701 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:400)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #700
+ New state: shared-modified by threads #700, #701
+ Reason: this thread, #701, holds no locks at all
+---------- double gran, 1 .. 92, skip 57 ----------
+
+Thread #702 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #703 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+---------- double gran, 2 .. 92, skip 58 ----------
+
+Thread #704 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #705 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #704
+ New state: shared-modified by threads #704, #705
+ Reason: this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #704
+ New state: shared-modified by threads #704, #705
+ Reason: this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #704
+ New state: shared-modified by threads #704, #705
+ Reason: this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #704
+ New state: shared-modified by threads #704, #705
+ Reason: this thread, #705, holds no locks at all
+---------- double gran, 3 .. 92, skip 59 ----------
+
+Thread #706 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #707 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+---------- double gran, 4 .. 92, skip 60 ----------
+
+Thread #708 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #709 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:408)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #708
+ New state: shared-modified by threads #708, #709
+ Reason: this thread, #709, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:408)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #708
+ New state: shared-modified by threads #708, #709
+ Reason: this thread, #709, holds no locks at all
+---------- double gran, 5 .. 92, skip 61 ----------
+
+Thread #710 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #711 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+---------- double gran, 6 .. 92, skip 62 ----------
+
+Thread #712 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #713 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #712
+ New state: shared-modified by threads #712, #713
+ Reason: this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #712
+ New state: shared-modified by threads #712, #713
+ Reason: this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #712
+ New state: shared-modified by threads #712, #713
+ Reason: this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #712
+ New state: shared-modified by threads #712, #713
+ Reason: this thread, #713, holds no locks at all
+---------- double gran, 7 .. 92, skip 63 ----------
+
+Thread #714 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #715 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+---------- double gran, 0 .. 92, skip 64 ----------
+
+Thread #716 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #717 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:416)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #716
+ New state: shared-modified by threads #716, #717
+ Reason: this thread, #717, holds no locks at all
+---------- double gran, 1 .. 92, skip 65 ----------
+
+Thread #718 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #719 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+---------- double gran, 2 .. 92, skip 66 ----------
+
+Thread #720 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #721 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #720
+ New state: shared-modified by threads #720, #721
+ Reason: this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #720
+ New state: shared-modified by threads #720, #721
+ Reason: this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #720
+ New state: shared-modified by threads #720, #721
+ Reason: this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #720
+ New state: shared-modified by threads #720, #721
+ Reason: this thread, #721, holds no locks at all
+---------- double gran, 3 .. 92, skip 67 ----------
+
+Thread #722 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #723 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+---------- double gran, 4 .. 92, skip 68 ----------
+
+Thread #724 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #725 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:424)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #724
+ New state: shared-modified by threads #724, #725
+ Reason: this thread, #725, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:424)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #724
+ New state: shared-modified by threads #724, #725
+ Reason: this thread, #725, holds no locks at all
+---------- double gran, 5 .. 92, skip 69 ----------
+
+Thread #726 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #727 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+---------- double gran, 6 .. 92, skip 70 ----------
+
+Thread #728 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #729 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #728
+ New state: shared-modified by threads #728, #729
+ Reason: this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #728
+ New state: shared-modified by threads #728, #729
+ Reason: this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #728
+ New state: shared-modified by threads #728, #729
+ Reason: this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #728
+ New state: shared-modified by threads #728, #729
+ Reason: this thread, #729, holds no locks at all
+---------- double gran, 7 .. 92, skip 71 ----------
+
+Thread #730 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #731 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+---------- double gran, 0 .. 92, skip 72 ----------
+
+Thread #732 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #733 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:432)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #732
+ New state: shared-modified by threads #732, #733
+ Reason: this thread, #733, holds no locks at all
+---------- double gran, 1 .. 92, skip 73 ----------
+
+Thread #734 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #735 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+---------- double gran, 2 .. 92, skip 74 ----------
+
+Thread #736 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #737 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #736
+ New state: shared-modified by threads #736, #737
+ Reason: this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #736
+ New state: shared-modified by threads #736, #737
+ Reason: this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #736
+ New state: shared-modified by threads #736, #737
+ Reason: this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #736
+ New state: shared-modified by threads #736, #737
+ Reason: this thread, #737, holds no locks at all
+---------- double gran, 3 .. 92, skip 75 ----------
+
+Thread #738 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #739 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+---------- double gran, 4 .. 92, skip 76 ----------
+
+Thread #740 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #741 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:440)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #740
+ New state: shared-modified by threads #740, #741
+ Reason: this thread, #741, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:440)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #740
+ New state: shared-modified by threads #740, #741
+ Reason: this thread, #741, holds no locks at all
+---------- double gran, 5 .. 92, skip 77 ----------
+
+Thread #742 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #743 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+---------- double gran, 6 .. 92, skip 78 ----------
+
+Thread #744 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #745 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #744
+ New state: shared-modified by threads #744, #745
+ Reason: this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #744
+ New state: shared-modified by threads #744, #745
+ Reason: this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #744
+ New state: shared-modified by threads #744, #745
+ Reason: this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #744
+ New state: shared-modified by threads #744, #745
+ Reason: this thread, #745, holds no locks at all
+---------- double gran, 7 .. 92, skip 79 ----------
+
+Thread #746 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #747 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+---------- double gran, 0 .. 92, skip 80 ----------
+
+Thread #748 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #749 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:448)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #748
+ New state: shared-modified by threads #748, #749
+ Reason: this thread, #749, holds no locks at all
+---------- double gran, 1 .. 92, skip 81 ----------
+
+Thread #750 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #751 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+---------- double gran, 2 .. 92, skip 82 ----------
+
+Thread #752 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #753 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #752
+ New state: shared-modified by threads #752, #753
+ Reason: this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #752
+ New state: shared-modified by threads #752, #753
+ Reason: this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #752
+ New state: shared-modified by threads #752, #753
+ Reason: this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #752
+ New state: shared-modified by threads #752, #753
+ Reason: this thread, #753, holds no locks at all
+---------- double gran, 3 .. 92, skip 83 ----------
+
+Thread #754 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #755 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+---------- double gran, 4 .. 92, skip 84 ----------
+
+Thread #756 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #757 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:456)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #756
+ New state: shared-modified by threads #756, #757
+ Reason: this thread, #757, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:456)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #756
+ New state: shared-modified by threads #756, #757
+ Reason: this thread, #757, holds no locks at all
+---------- double gran, 5 .. 92, skip 85 ----------
+
+Thread #758 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #759 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+---------- double gran, 6 .. 92, skip 86 ----------
+
+Thread #760 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #761 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #760
+ New state: shared-modified by threads #760, #761
+ Reason: this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #760
+ New state: shared-modified by threads #760, #761
+ Reason: this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #760
+ New state: shared-modified by threads #760, #761
+ Reason: this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #760
+ New state: shared-modified by threads #760, #761
+ Reason: this thread, #761, holds no locks at all
+---------- double gran, 7 .. 92, skip 87 ----------
+
+Thread #762 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #763 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+---------- double gran, 0 .. 92, skip 88 ----------
+
+Thread #764 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #765 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:464)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #764
+ New state: shared-modified by threads #764, #765
+ Reason: this thread, #765, holds no locks at all
+---------- double gran, 1 .. 92, skip 89 ----------
+
+Thread #766 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #767 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+---------- double gran, 2 .. 92, skip 90 ----------
+
+Thread #768 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #769 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #768
+ New state: shared-modified by threads #768, #769
+ Reason: this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #768
+ New state: shared-modified by threads #768, #769
+ Reason: this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #768
+ New state: shared-modified by threads #768, #769
+ Reason: this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #768
+ New state: shared-modified by threads #768, #769
+ Reason: this thread, #769, holds no locks at all
+---------- double gran, 3 .. 92, skip 91 ----------
+
+Thread #770 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #771 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+ERROR SUMMARY: 1004 errors from 1004 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-x86 b/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..efa6730
--- /dev/null
+++ b/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-x86
@@ -0,0 +1,15070 @@
+
+
+===========================================================
+=== 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 ===
+===========================================================
+
+---------- char gran, 0 .. 99, skip 0 ----------
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:288)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #2
+ New state: shared-modified by threads #2, #3
+ Reason: this thread, #3, holds no locks at all
+---------- char gran, 0 .. 99, skip 1 ----------
+
+Thread #4 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #5 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #4
+ New state: shared-modified by threads #4, #5
+ Reason: this thread, #5, holds no locks at all
+---------- char gran, 0 .. 99, skip 2 ----------
+
+Thread #6 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #7 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #6
+ New state: shared-modified by threads #6, #7
+ Reason: this thread, #7, holds no locks at all
+---------- char gran, 0 .. 99, skip 3 ----------
+
+Thread #8 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #9 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #8
+ New state: shared-modified by threads #8, #9
+ Reason: this thread, #9, holds no locks at all
+---------- char gran, 0 .. 99, skip 4 ----------
+
+Thread #10 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #11 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:296)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #10
+ New state: shared-modified by threads #10, #11
+ Reason: this thread, #11, holds no locks at all
+---------- char gran, 0 .. 99, skip 5 ----------
+
+Thread #12 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #13 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #12
+ New state: shared-modified by threads #12, #13
+ Reason: this thread, #13, holds no locks at all
+---------- char gran, 0 .. 99, skip 6 ----------
+
+Thread #14 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #15 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #14
+ New state: shared-modified by threads #14, #15
+ Reason: this thread, #15, holds no locks at all
+---------- char gran, 0 .. 99, skip 7 ----------
+
+Thread #16 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #17 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #16
+ New state: shared-modified by threads #16, #17
+ Reason: this thread, #17, holds no locks at all
+---------- char gran, 0 .. 99, skip 8 ----------
+
+Thread #18 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #19 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:304)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #18
+ New state: shared-modified by threads #18, #19
+ Reason: this thread, #19, holds no locks at all
+---------- char gran, 0 .. 99, skip 9 ----------
+
+Thread #20 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #21 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #20
+ New state: shared-modified by threads #20, #21
+ Reason: this thread, #21, holds no locks at all
+---------- char gran, 0 .. 99, skip 10 ----------
+
+Thread #22 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #23 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #22
+ New state: shared-modified by threads #22, #23
+ Reason: this thread, #23, holds no locks at all
+---------- char gran, 0 .. 99, skip 11 ----------
+
+Thread #24 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #25 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #24
+ New state: shared-modified by threads #24, #25
+ Reason: this thread, #25, holds no locks at all
+---------- char gran, 0 .. 99, skip 12 ----------
+
+Thread #26 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #27 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:312)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #26
+ New state: shared-modified by threads #26, #27
+ Reason: this thread, #27, holds no locks at all
+---------- char gran, 0 .. 99, skip 13 ----------
+
+Thread #28 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #29 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #28
+ New state: shared-modified by threads #28, #29
+ Reason: this thread, #29, holds no locks at all
+---------- char gran, 0 .. 99, skip 14 ----------
+
+Thread #30 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #31 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #30
+ New state: shared-modified by threads #30, #31
+ Reason: this thread, #31, holds no locks at all
+---------- char gran, 0 .. 99, skip 15 ----------
+
+Thread #32 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #33 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #32
+ New state: shared-modified by threads #32, #33
+ Reason: this thread, #33, holds no locks at all
+---------- char gran, 0 .. 99, skip 16 ----------
+
+Thread #34 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #35 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:320)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #34
+ New state: shared-modified by threads #34, #35
+ Reason: this thread, #35, holds no locks at all
+---------- char gran, 0 .. 99, skip 17 ----------
+
+Thread #36 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #37 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #36
+ New state: shared-modified by threads #36, #37
+ Reason: this thread, #37, holds no locks at all
+---------- char gran, 0 .. 99, skip 18 ----------
+
+Thread #38 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #39 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #38
+ New state: shared-modified by threads #38, #39
+ Reason: this thread, #39, holds no locks at all
+---------- char gran, 0 .. 99, skip 19 ----------
+
+Thread #40 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #41 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #40
+ New state: shared-modified by threads #40, #41
+ Reason: this thread, #41, holds no locks at all
+---------- char gran, 0 .. 99, skip 20 ----------
+
+Thread #42 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #43 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:328)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #42
+ New state: shared-modified by threads #42, #43
+ Reason: this thread, #43, holds no locks at all
+---------- char gran, 0 .. 99, skip 21 ----------
+
+Thread #44 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #45 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #44
+ New state: shared-modified by threads #44, #45
+ Reason: this thread, #45, holds no locks at all
+---------- char gran, 0 .. 99, skip 22 ----------
+
+Thread #46 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #47 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #46
+ New state: shared-modified by threads #46, #47
+ Reason: this thread, #47, holds no locks at all
+---------- char gran, 0 .. 99, skip 23 ----------
+
+Thread #48 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #49 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #48
+ New state: shared-modified by threads #48, #49
+ Reason: this thread, #49, holds no locks at all
+---------- char gran, 0 .. 99, skip 24 ----------
+
+Thread #50 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #51 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:336)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #50
+ New state: shared-modified by threads #50, #51
+ Reason: this thread, #51, holds no locks at all
+---------- char gran, 0 .. 99, skip 25 ----------
+
+Thread #52 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #53 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #52
+ New state: shared-modified by threads #52, #53
+ Reason: this thread, #53, holds no locks at all
+---------- char gran, 0 .. 99, skip 26 ----------
+
+Thread #54 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #55 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #54
+ New state: shared-modified by threads #54, #55
+ Reason: this thread, #55, holds no locks at all
+---------- char gran, 0 .. 99, skip 27 ----------
+
+Thread #56 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #57 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #56
+ New state: shared-modified by threads #56, #57
+ Reason: this thread, #57, holds no locks at all
+---------- char gran, 0 .. 99, skip 28 ----------
+
+Thread #58 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #59 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:344)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #58
+ New state: shared-modified by threads #58, #59
+ Reason: this thread, #59, holds no locks at all
+---------- char gran, 0 .. 99, skip 29 ----------
+
+Thread #60 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #61 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #60
+ New state: shared-modified by threads #60, #61
+ Reason: this thread, #61, holds no locks at all
+---------- char gran, 0 .. 99, skip 30 ----------
+
+Thread #62 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #63 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #62
+ New state: shared-modified by threads #62, #63
+ Reason: this thread, #63, holds no locks at all
+---------- char gran, 0 .. 99, skip 31 ----------
+
+Thread #64 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #65 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #64
+ New state: shared-modified by threads #64, #65
+ Reason: this thread, #65, holds no locks at all
+---------- char gran, 0 .. 99, skip 32 ----------
+
+Thread #66 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #67 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:352)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #66
+ New state: shared-modified by threads #66, #67
+ Reason: this thread, #67, holds no locks at all
+---------- char gran, 0 .. 99, skip 33 ----------
+
+Thread #68 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #69 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #68
+ New state: shared-modified by threads #68, #69
+ Reason: this thread, #69, holds no locks at all
+---------- char gran, 0 .. 99, skip 34 ----------
+
+Thread #70 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #71 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #70
+ New state: shared-modified by threads #70, #71
+ Reason: this thread, #71, holds no locks at all
+---------- char gran, 0 .. 99, skip 35 ----------
+
+Thread #72 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #73 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #72
+ New state: shared-modified by threads #72, #73
+ Reason: this thread, #73, holds no locks at all
+---------- char gran, 0 .. 99, skip 36 ----------
+
+Thread #74 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #75 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:360)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #74
+ New state: shared-modified by threads #74, #75
+ Reason: this thread, #75, holds no locks at all
+---------- char gran, 0 .. 99, skip 37 ----------
+
+Thread #76 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #77 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #76
+ New state: shared-modified by threads #76, #77
+ Reason: this thread, #77, holds no locks at all
+---------- char gran, 0 .. 99, skip 38 ----------
+
+Thread #78 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #79 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #78
+ New state: shared-modified by threads #78, #79
+ Reason: this thread, #79, holds no locks at all
+---------- char gran, 0 .. 99, skip 39 ----------
+
+Thread #80 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #81 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #80
+ New state: shared-modified by threads #80, #81
+ Reason: this thread, #81, holds no locks at all
+---------- char gran, 0 .. 99, skip 40 ----------
+
+Thread #82 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #83 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:368)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #82
+ New state: shared-modified by threads #82, #83
+ Reason: this thread, #83, holds no locks at all
+---------- char gran, 0 .. 99, skip 41 ----------
+
+Thread #84 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #85 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #84
+ New state: shared-modified by threads #84, #85
+ Reason: this thread, #85, holds no locks at all
+---------- char gran, 0 .. 99, skip 42 ----------
+
+Thread #86 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #87 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #86
+ New state: shared-modified by threads #86, #87
+ Reason: this thread, #87, holds no locks at all
+---------- char gran, 0 .. 99, skip 43 ----------
+
+Thread #88 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #89 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #88
+ New state: shared-modified by threads #88, #89
+ Reason: this thread, #89, holds no locks at all
+---------- char gran, 0 .. 99, skip 44 ----------
+
+Thread #90 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #91 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:376)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #90
+ New state: shared-modified by threads #90, #91
+ Reason: this thread, #91, holds no locks at all
+---------- char gran, 0 .. 99, skip 45 ----------
+
+Thread #92 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #93 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #92
+ New state: shared-modified by threads #92, #93
+ Reason: this thread, #93, holds no locks at all
+---------- char gran, 0 .. 99, skip 46 ----------
+
+Thread #94 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #95 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #94
+ New state: shared-modified by threads #94, #95
+ Reason: this thread, #95, holds no locks at all
+---------- char gran, 0 .. 99, skip 47 ----------
+
+Thread #96 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #97 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #96
+ New state: shared-modified by threads #96, #97
+ Reason: this thread, #97, holds no locks at all
+---------- char gran, 0 .. 99, skip 48 ----------
+
+Thread #98 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #99 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:384)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #98
+ New state: shared-modified by threads #98, #99
+ Reason: this thread, #99, holds no locks at all
+---------- char gran, 0 .. 99, skip 49 ----------
+
+Thread #100 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #101 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #100
+ New state: shared-modified by threads #100, #101
+ Reason: this thread, #101, holds no locks at all
+---------- char gran, 0 .. 99, skip 50 ----------
+
+Thread #102 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #103 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #102
+ New state: shared-modified by threads #102, #103
+ Reason: this thread, #103, holds no locks at all
+---------- char gran, 0 .. 99, skip 51 ----------
+
+Thread #104 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #105 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #104
+ New state: shared-modified by threads #104, #105
+ Reason: this thread, #105, holds no locks at all
+---------- char gran, 0 .. 99, skip 52 ----------
+
+Thread #106 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #107 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:392)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #106
+ New state: shared-modified by threads #106, #107
+ Reason: this thread, #107, holds no locks at all
+---------- char gran, 0 .. 99, skip 53 ----------
+
+Thread #108 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #109 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #108
+ New state: shared-modified by threads #108, #109
+ Reason: this thread, #109, holds no locks at all
+---------- char gran, 0 .. 99, skip 54 ----------
+
+Thread #110 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #111 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #110
+ New state: shared-modified by threads #110, #111
+ Reason: this thread, #111, holds no locks at all
+---------- char gran, 0 .. 99, skip 55 ----------
+
+Thread #112 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #113 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #112
+ New state: shared-modified by threads #112, #113
+ Reason: this thread, #113, holds no locks at all
+---------- char gran, 0 .. 99, skip 56 ----------
+
+Thread #114 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #115 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:400)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #114
+ New state: shared-modified by threads #114, #115
+ Reason: this thread, #115, holds no locks at all
+---------- char gran, 0 .. 99, skip 57 ----------
+
+Thread #116 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #117 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #116
+ New state: shared-modified by threads #116, #117
+ Reason: this thread, #117, holds no locks at all
+---------- char gran, 0 .. 99, skip 58 ----------
+
+Thread #118 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #119 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #118
+ New state: shared-modified by threads #118, #119
+ Reason: this thread, #119, holds no locks at all
+---------- char gran, 0 .. 99, skip 59 ----------
+
+Thread #120 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #121 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #120
+ New state: shared-modified by threads #120, #121
+ Reason: this thread, #121, holds no locks at all
+---------- char gran, 0 .. 99, skip 60 ----------
+
+Thread #122 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #123 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:408)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #122
+ New state: shared-modified by threads #122, #123
+ Reason: this thread, #123, holds no locks at all
+---------- char gran, 0 .. 99, skip 61 ----------
+
+Thread #124 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #125 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #124
+ New state: shared-modified by threads #124, #125
+ Reason: this thread, #125, holds no locks at all
+---------- char gran, 0 .. 99, skip 62 ----------
+
+Thread #126 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #127 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #126
+ New state: shared-modified by threads #126, #127
+ Reason: this thread, #127, holds no locks at all
+---------- char gran, 0 .. 99, skip 63 ----------
+
+Thread #128 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #129 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #128
+ New state: shared-modified by threads #128, #129
+ Reason: this thread, #129, holds no locks at all
+---------- char gran, 0 .. 99, skip 64 ----------
+
+Thread #130 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #131 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:416)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #130
+ New state: shared-modified by threads #130, #131
+ Reason: this thread, #131, holds no locks at all
+---------- char gran, 0 .. 99, skip 65 ----------
+
+Thread #132 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #133 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #132
+ New state: shared-modified by threads #132, #133
+ Reason: this thread, #133, holds no locks at all
+---------- char gran, 0 .. 99, skip 66 ----------
+
+Thread #134 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #135 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #134
+ New state: shared-modified by threads #134, #135
+ Reason: this thread, #135, holds no locks at all
+---------- char gran, 0 .. 99, skip 67 ----------
+
+Thread #136 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #137 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #136
+ New state: shared-modified by threads #136, #137
+ Reason: this thread, #137, holds no locks at all
+---------- char gran, 0 .. 99, skip 68 ----------
+
+Thread #138 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #139 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:424)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #138
+ New state: shared-modified by threads #138, #139
+ Reason: this thread, #139, holds no locks at all
+---------- char gran, 0 .. 99, skip 69 ----------
+
+Thread #140 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #141 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #140
+ New state: shared-modified by threads #140, #141
+ Reason: this thread, #141, holds no locks at all
+---------- char gran, 0 .. 99, skip 70 ----------
+
+Thread #142 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #143 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #142
+ New state: shared-modified by threads #142, #143
+ Reason: this thread, #143, holds no locks at all
+---------- char gran, 0 .. 99, skip 71 ----------
+
+Thread #144 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #145 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #144
+ New state: shared-modified by threads #144, #145
+ Reason: this thread, #145, holds no locks at all
+---------- char gran, 0 .. 99, skip 72 ----------
+
+Thread #146 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #147 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:432)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #146
+ New state: shared-modified by threads #146, #147
+ Reason: this thread, #147, holds no locks at all
+---------- char gran, 0 .. 99, skip 73 ----------
+
+Thread #148 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #149 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #148
+ New state: shared-modified by threads #148, #149
+ Reason: this thread, #149, holds no locks at all
+---------- char gran, 0 .. 99, skip 74 ----------
+
+Thread #150 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #151 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #150
+ New state: shared-modified by threads #150, #151
+ Reason: this thread, #151, holds no locks at all
+---------- char gran, 0 .. 99, skip 75 ----------
+
+Thread #152 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #153 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #152
+ New state: shared-modified by threads #152, #153
+ Reason: this thread, #153, holds no locks at all
+---------- char gran, 0 .. 99, skip 76 ----------
+
+Thread #154 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #155 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:440)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #154
+ New state: shared-modified by threads #154, #155
+ Reason: this thread, #155, holds no locks at all
+---------- char gran, 0 .. 99, skip 77 ----------
+
+Thread #156 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #157 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #156
+ New state: shared-modified by threads #156, #157
+ Reason: this thread, #157, holds no locks at all
+---------- char gran, 0 .. 99, skip 78 ----------
+
+Thread #158 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #159 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #158
+ New state: shared-modified by threads #158, #159
+ Reason: this thread, #159, holds no locks at all
+---------- char gran, 0 .. 99, skip 79 ----------
+
+Thread #160 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #161 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #160
+ New state: shared-modified by threads #160, #161
+ Reason: this thread, #161, holds no locks at all
+---------- char gran, 0 .. 99, skip 80 ----------
+
+Thread #162 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #163 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:448)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #162
+ New state: shared-modified by threads #162, #163
+ Reason: this thread, #163, holds no locks at all
+---------- char gran, 0 .. 99, skip 81 ----------
+
+Thread #164 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #165 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #164
+ New state: shared-modified by threads #164, #165
+ Reason: this thread, #165, holds no locks at all
+---------- char gran, 0 .. 99, skip 82 ----------
+
+Thread #166 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #167 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #166
+ New state: shared-modified by threads #166, #167
+ Reason: this thread, #167, holds no locks at all
+---------- char gran, 0 .. 99, skip 83 ----------
+
+Thread #168 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #169 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #168
+ New state: shared-modified by threads #168, #169
+ Reason: this thread, #169, holds no locks at all
+---------- char gran, 0 .. 99, skip 84 ----------
+
+Thread #170 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #171 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:456)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #170
+ New state: shared-modified by threads #170, #171
+ Reason: this thread, #171, holds no locks at all
+---------- char gran, 0 .. 99, skip 85 ----------
+
+Thread #172 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #173 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #172
+ New state: shared-modified by threads #172, #173
+ Reason: this thread, #173, holds no locks at all
+---------- char gran, 0 .. 99, skip 86 ----------
+
+Thread #174 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #175 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #174
+ New state: shared-modified by threads #174, #175
+ Reason: this thread, #175, holds no locks at all
+---------- char gran, 0 .. 99, skip 87 ----------
+
+Thread #176 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #177 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #176
+ New state: shared-modified by threads #176, #177
+ Reason: this thread, #177, holds no locks at all
+---------- char gran, 0 .. 99, skip 88 ----------
+
+Thread #178 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #179 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:464)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #178
+ New state: shared-modified by threads #178, #179
+ Reason: this thread, #179, holds no locks at all
+---------- char gran, 0 .. 99, skip 89 ----------
+
+Thread #180 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #181 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #180
+ New state: shared-modified by threads #180, #181
+ Reason: this thread, #181, holds no locks at all
+---------- char gran, 0 .. 99, skip 90 ----------
+
+Thread #182 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #183 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #182
+ New state: shared-modified by threads #182, #183
+ Reason: this thread, #183, holds no locks at all
+---------- char gran, 0 .. 99, skip 91 ----------
+
+Thread #184 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #185 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #184
+ New state: shared-modified by threads #184, #185
+ Reason: this thread, #185, holds no locks at all
+---------- char gran, 0 .. 99, skip 92 ----------
+
+Thread #186 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #187 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:472)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #186
+ New state: shared-modified by threads #186, #187
+ Reason: this thread, #187, holds no locks at all
+---------- char gran, 0 .. 99, skip 93 ----------
+
+Thread #188 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #189 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #188
+ New state: shared-modified by threads #188, #189
+ Reason: this thread, #189, holds no locks at all
+---------- char gran, 0 .. 99, skip 94 ----------
+
+Thread #190 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #191 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:476)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #190
+ New state: shared-modified by threads #190, #191
+ Reason: this thread, #191, holds no locks at all
+---------- char gran, 0 .. 99, skip 95 ----------
+
+Thread #192 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #193 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #192
+ New state: shared-modified by threads #192, #193
+ Reason: this thread, #193, holds no locks at all
+---------- char gran, 0 .. 99, skip 96 ----------
+
+Thread #194 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #195 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:480)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #194
+ New state: shared-modified by threads #194, #195
+ Reason: this thread, #195, holds no locks at all
+---------- char gran, 0 .. 99, skip 97 ----------
+
+Thread #196 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #197 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:482)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #196
+ New state: shared-modified by threads #196, #197
+ Reason: this thread, #197, holds no locks at all
+---------- char gran, 0 .. 99, skip 98 ----------
+
+Thread #198 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #199 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child8 (tc19_shadowmem.c:35)
+ by 0x........: steer (tc19_shadowmem.c:484)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #198
+ New state: shared-modified by threads #198, #199
+ Reason: this thread, #199, holds no locks at all
+
+==========================================================
+=== 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 ===
+==========================================================
+
+---------- short gran, 0 .. 98, skip 0 ----------
+
+Thread #200 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #201 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:288)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #200
+ New state: shared-modified by threads #200, #201
+ Reason: this thread, #201, holds no locks at all
+
+More than 100 errors detected. Subsequent errors
+will still be recorded, but in less detail than before.
+---------- short gran, 1 .. 98, skip 1 ----------
+
+Thread #202 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #203 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #202
+ New state: shared-modified by threads #202, #203
+ Reason: this thread, #203, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #202
+ New state: shared-modified by threads #202, #203
+ Reason: this thread, #203, holds no locks at all
+---------- short gran, 0 .. 98, skip 2 ----------
+
+Thread #204 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #205 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #204
+ New state: shared-modified by threads #204, #205
+ Reason: this thread, #205, holds no locks at all
+---------- short gran, 1 .. 98, skip 3 ----------
+
+Thread #206 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #207 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #206
+ New state: shared-modified by threads #206, #207
+ Reason: this thread, #207, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #206
+ New state: shared-modified by threads #206, #207
+ Reason: this thread, #207, holds no locks at all
+---------- short gran, 0 .. 98, skip 4 ----------
+
+Thread #208 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #209 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:296)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #208
+ New state: shared-modified by threads #208, #209
+ Reason: this thread, #209, holds no locks at all
+---------- short gran, 1 .. 98, skip 5 ----------
+
+Thread #210 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #211 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #210
+ New state: shared-modified by threads #210, #211
+ Reason: this thread, #211, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #210
+ New state: shared-modified by threads #210, #211
+ Reason: this thread, #211, holds no locks at all
+---------- short gran, 0 .. 98, skip 6 ----------
+
+Thread #212 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #213 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #212
+ New state: shared-modified by threads #212, #213
+ Reason: this thread, #213, holds no locks at all
+---------- short gran, 1 .. 98, skip 7 ----------
+
+Thread #214 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #215 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #214
+ New state: shared-modified by threads #214, #215
+ Reason: this thread, #215, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #214
+ New state: shared-modified by threads #214, #215
+ Reason: this thread, #215, holds no locks at all
+---------- short gran, 0 .. 98, skip 8 ----------
+
+Thread #216 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #217 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:304)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #216
+ New state: shared-modified by threads #216, #217
+ Reason: this thread, #217, holds no locks at all
+---------- short gran, 1 .. 98, skip 9 ----------
+
+Thread #218 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #219 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #218
+ New state: shared-modified by threads #218, #219
+ Reason: this thread, #219, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #218
+ New state: shared-modified by threads #218, #219
+ Reason: this thread, #219, holds no locks at all
+---------- short gran, 0 .. 98, skip 10 ----------
+
+Thread #220 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #221 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #220
+ New state: shared-modified by threads #220, #221
+ Reason: this thread, #221, holds no locks at all
+---------- short gran, 1 .. 98, skip 11 ----------
+
+Thread #222 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #223 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #222
+ New state: shared-modified by threads #222, #223
+ Reason: this thread, #223, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #222
+ New state: shared-modified by threads #222, #223
+ Reason: this thread, #223, holds no locks at all
+---------- short gran, 0 .. 98, skip 12 ----------
+
+Thread #224 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #225 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:312)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #224
+ New state: shared-modified by threads #224, #225
+ Reason: this thread, #225, holds no locks at all
+---------- short gran, 1 .. 98, skip 13 ----------
+
+Thread #226 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #227 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #226
+ New state: shared-modified by threads #226, #227
+ Reason: this thread, #227, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #226
+ New state: shared-modified by threads #226, #227
+ Reason: this thread, #227, holds no locks at all
+---------- short gran, 0 .. 98, skip 14 ----------
+
+Thread #228 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #229 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #228
+ New state: shared-modified by threads #228, #229
+ Reason: this thread, #229, holds no locks at all
+---------- short gran, 1 .. 98, skip 15 ----------
+
+Thread #230 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #231 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #230
+ New state: shared-modified by threads #230, #231
+ Reason: this thread, #231, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #230
+ New state: shared-modified by threads #230, #231
+ Reason: this thread, #231, holds no locks at all
+---------- short gran, 0 .. 98, skip 16 ----------
+
+Thread #232 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #233 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:320)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #232
+ New state: shared-modified by threads #232, #233
+ Reason: this thread, #233, holds no locks at all
+---------- short gran, 1 .. 98, skip 17 ----------
+
+Thread #234 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #235 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #234
+ New state: shared-modified by threads #234, #235
+ Reason: this thread, #235, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #234
+ New state: shared-modified by threads #234, #235
+ Reason: this thread, #235, holds no locks at all
+---------- short gran, 0 .. 98, skip 18 ----------
+
+Thread #236 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #237 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #236
+ New state: shared-modified by threads #236, #237
+ Reason: this thread, #237, holds no locks at all
+---------- short gran, 1 .. 98, skip 19 ----------
+
+Thread #238 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #239 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #238
+ New state: shared-modified by threads #238, #239
+ Reason: this thread, #239, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #238
+ New state: shared-modified by threads #238, #239
+ Reason: this thread, #239, holds no locks at all
+---------- short gran, 0 .. 98, skip 20 ----------
+
+Thread #240 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #241 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:328)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #240
+ New state: shared-modified by threads #240, #241
+ Reason: this thread, #241, holds no locks at all
+---------- short gran, 1 .. 98, skip 21 ----------
+
+Thread #242 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #243 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #242
+ New state: shared-modified by threads #242, #243
+ Reason: this thread, #243, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #242
+ New state: shared-modified by threads #242, #243
+ Reason: this thread, #243, holds no locks at all
+---------- short gran, 0 .. 98, skip 22 ----------
+
+Thread #244 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #245 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #244
+ New state: shared-modified by threads #244, #245
+ Reason: this thread, #245, holds no locks at all
+---------- short gran, 1 .. 98, skip 23 ----------
+
+Thread #246 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #247 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #246
+ New state: shared-modified by threads #246, #247
+ Reason: this thread, #247, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #246
+ New state: shared-modified by threads #246, #247
+ Reason: this thread, #247, holds no locks at all
+---------- short gran, 0 .. 98, skip 24 ----------
+
+Thread #248 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #249 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:336)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #248
+ New state: shared-modified by threads #248, #249
+ Reason: this thread, #249, holds no locks at all
+---------- short gran, 1 .. 98, skip 25 ----------
+
+Thread #250 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #251 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #250
+ New state: shared-modified by threads #250, #251
+ Reason: this thread, #251, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #250
+ New state: shared-modified by threads #250, #251
+ Reason: this thread, #251, holds no locks at all
+---------- short gran, 0 .. 98, skip 26 ----------
+
+Thread #252 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #253 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #252
+ New state: shared-modified by threads #252, #253
+ Reason: this thread, #253, holds no locks at all
+---------- short gran, 1 .. 98, skip 27 ----------
+
+Thread #254 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #255 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #254
+ New state: shared-modified by threads #254, #255
+ Reason: this thread, #255, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #254
+ New state: shared-modified by threads #254, #255
+ Reason: this thread, #255, holds no locks at all
+---------- short gran, 0 .. 98, skip 28 ----------
+
+Thread #256 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #257 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:344)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #256
+ New state: shared-modified by threads #256, #257
+ Reason: this thread, #257, holds no locks at all
+---------- short gran, 1 .. 98, skip 29 ----------
+
+Thread #258 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #259 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #258
+ New state: shared-modified by threads #258, #259
+ Reason: this thread, #259, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #258
+ New state: shared-modified by threads #258, #259
+ Reason: this thread, #259, holds no locks at all
+---------- short gran, 0 .. 98, skip 30 ----------
+
+Thread #260 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #261 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #260
+ New state: shared-modified by threads #260, #261
+ Reason: this thread, #261, holds no locks at all
+---------- short gran, 1 .. 98, skip 31 ----------
+
+Thread #262 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #263 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #262
+ New state: shared-modified by threads #262, #263
+ Reason: this thread, #263, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #262
+ New state: shared-modified by threads #262, #263
+ Reason: this thread, #263, holds no locks at all
+---------- short gran, 0 .. 98, skip 32 ----------
+
+Thread #264 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #265 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:352)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #264
+ New state: shared-modified by threads #264, #265
+ Reason: this thread, #265, holds no locks at all
+---------- short gran, 1 .. 98, skip 33 ----------
+
+Thread #266 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #267 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #266
+ New state: shared-modified by threads #266, #267
+ Reason: this thread, #267, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #266
+ New state: shared-modified by threads #266, #267
+ Reason: this thread, #267, holds no locks at all
+---------- short gran, 0 .. 98, skip 34 ----------
+
+Thread #268 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #269 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #268
+ New state: shared-modified by threads #268, #269
+ Reason: this thread, #269, holds no locks at all
+---------- short gran, 1 .. 98, skip 35 ----------
+
+Thread #270 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #271 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #270
+ New state: shared-modified by threads #270, #271
+ Reason: this thread, #271, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #270
+ New state: shared-modified by threads #270, #271
+ Reason: this thread, #271, holds no locks at all
+---------- short gran, 0 .. 98, skip 36 ----------
+
+Thread #272 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #273 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:360)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #272
+ New state: shared-modified by threads #272, #273
+ Reason: this thread, #273, holds no locks at all
+---------- short gran, 1 .. 98, skip 37 ----------
+
+Thread #274 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #275 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #274
+ New state: shared-modified by threads #274, #275
+ Reason: this thread, #275, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #274
+ New state: shared-modified by threads #274, #275
+ Reason: this thread, #275, holds no locks at all
+---------- short gran, 0 .. 98, skip 38 ----------
+
+Thread #276 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #277 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #276
+ New state: shared-modified by threads #276, #277
+ Reason: this thread, #277, holds no locks at all
+---------- short gran, 1 .. 98, skip 39 ----------
+
+Thread #278 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #279 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #278
+ New state: shared-modified by threads #278, #279
+ Reason: this thread, #279, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #278
+ New state: shared-modified by threads #278, #279
+ Reason: this thread, #279, holds no locks at all
+---------- short gran, 0 .. 98, skip 40 ----------
+
+Thread #280 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #281 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:368)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #280
+ New state: shared-modified by threads #280, #281
+ Reason: this thread, #281, holds no locks at all
+---------- short gran, 1 .. 98, skip 41 ----------
+
+Thread #282 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #283 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #282
+ New state: shared-modified by threads #282, #283
+ Reason: this thread, #283, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #282
+ New state: shared-modified by threads #282, #283
+ Reason: this thread, #283, holds no locks at all
+---------- short gran, 0 .. 98, skip 42 ----------
+
+Thread #284 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #285 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #284
+ New state: shared-modified by threads #284, #285
+ Reason: this thread, #285, holds no locks at all
+---------- short gran, 1 .. 98, skip 43 ----------
+
+Thread #286 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #287 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #286
+ New state: shared-modified by threads #286, #287
+ Reason: this thread, #287, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #286
+ New state: shared-modified by threads #286, #287
+ Reason: this thread, #287, holds no locks at all
+---------- short gran, 0 .. 98, skip 44 ----------
+
+Thread #288 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #289 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:376)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #288
+ New state: shared-modified by threads #288, #289
+ Reason: this thread, #289, holds no locks at all
+---------- short gran, 1 .. 98, skip 45 ----------
+
+Thread #290 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #291 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #290
+ New state: shared-modified by threads #290, #291
+ Reason: this thread, #291, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #290
+ New state: shared-modified by threads #290, #291
+ Reason: this thread, #291, holds no locks at all
+---------- short gran, 0 .. 98, skip 46 ----------
+
+Thread #292 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #293 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #292
+ New state: shared-modified by threads #292, #293
+ Reason: this thread, #293, holds no locks at all
+---------- short gran, 1 .. 98, skip 47 ----------
+
+Thread #294 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #295 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #294
+ New state: shared-modified by threads #294, #295
+ Reason: this thread, #295, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #294
+ New state: shared-modified by threads #294, #295
+ Reason: this thread, #295, holds no locks at all
+---------- short gran, 0 .. 98, skip 48 ----------
+
+Thread #296 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #297 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:384)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #296
+ New state: shared-modified by threads #296, #297
+ Reason: this thread, #297, holds no locks at all
+---------- short gran, 1 .. 98, skip 49 ----------
+
+Thread #298 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #299 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #298
+ New state: shared-modified by threads #298, #299
+ Reason: this thread, #299, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #298
+ New state: shared-modified by threads #298, #299
+ Reason: this thread, #299, holds no locks at all
+---------- short gran, 0 .. 98, skip 50 ----------
+
+Thread #300 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #301 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #300
+ New state: shared-modified by threads #300, #301
+ Reason: this thread, #301, holds no locks at all
+---------- short gran, 1 .. 98, skip 51 ----------
+
+Thread #302 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #303 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #302
+ New state: shared-modified by threads #302, #303
+ Reason: this thread, #303, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #302
+ New state: shared-modified by threads #302, #303
+ Reason: this thread, #303, holds no locks at all
+---------- short gran, 0 .. 98, skip 52 ----------
+
+Thread #304 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #305 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:392)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #304
+ New state: shared-modified by threads #304, #305
+ Reason: this thread, #305, holds no locks at all
+---------- short gran, 1 .. 98, skip 53 ----------
+
+Thread #306 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #307 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #306
+ New state: shared-modified by threads #306, #307
+ Reason: this thread, #307, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #306
+ New state: shared-modified by threads #306, #307
+ Reason: this thread, #307, holds no locks at all
+---------- short gran, 0 .. 98, skip 54 ----------
+
+Thread #308 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #309 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #308
+ New state: shared-modified by threads #308, #309
+ Reason: this thread, #309, holds no locks at all
+---------- short gran, 1 .. 98, skip 55 ----------
+
+Thread #310 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #311 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #310
+ New state: shared-modified by threads #310, #311
+ Reason: this thread, #311, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #310
+ New state: shared-modified by threads #310, #311
+ Reason: this thread, #311, holds no locks at all
+---------- short gran, 0 .. 98, skip 56 ----------
+
+Thread #312 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #313 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:400)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #312
+ New state: shared-modified by threads #312, #313
+ Reason: this thread, #313, holds no locks at all
+---------- short gran, 1 .. 98, skip 57 ----------
+
+Thread #314 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #315 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #314
+ New state: shared-modified by threads #314, #315
+ Reason: this thread, #315, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #314
+ New state: shared-modified by threads #314, #315
+ Reason: this thread, #315, holds no locks at all
+---------- short gran, 0 .. 98, skip 58 ----------
+
+Thread #316 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #317 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #316
+ New state: shared-modified by threads #316, #317
+ Reason: this thread, #317, holds no locks at all
+---------- short gran, 1 .. 98, skip 59 ----------
+
+Thread #318 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #319 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #318
+ New state: shared-modified by threads #318, #319
+ Reason: this thread, #319, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #318
+ New state: shared-modified by threads #318, #319
+ Reason: this thread, #319, holds no locks at all
+---------- short gran, 0 .. 98, skip 60 ----------
+
+Thread #320 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #321 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:408)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #320
+ New state: shared-modified by threads #320, #321
+ Reason: this thread, #321, holds no locks at all
+---------- short gran, 1 .. 98, skip 61 ----------
+
+Thread #322 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #323 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #322
+ New state: shared-modified by threads #322, #323
+ Reason: this thread, #323, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #322
+ New state: shared-modified by threads #322, #323
+ Reason: this thread, #323, holds no locks at all
+---------- short gran, 0 .. 98, skip 62 ----------
+
+Thread #324 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #325 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #324
+ New state: shared-modified by threads #324, #325
+ Reason: this thread, #325, holds no locks at all
+---------- short gran, 1 .. 98, skip 63 ----------
+
+Thread #326 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #327 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #326
+ New state: shared-modified by threads #326, #327
+ Reason: this thread, #327, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #326
+ New state: shared-modified by threads #326, #327
+ Reason: this thread, #327, holds no locks at all
+---------- short gran, 0 .. 98, skip 64 ----------
+
+Thread #328 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #329 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:416)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #328
+ New state: shared-modified by threads #328, #329
+ Reason: this thread, #329, holds no locks at all
+---------- short gran, 1 .. 98, skip 65 ----------
+
+Thread #330 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #331 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #330
+ New state: shared-modified by threads #330, #331
+ Reason: this thread, #331, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #330
+ New state: shared-modified by threads #330, #331
+ Reason: this thread, #331, holds no locks at all
+---------- short gran, 0 .. 98, skip 66 ----------
+
+Thread #332 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #333 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #332
+ New state: shared-modified by threads #332, #333
+ Reason: this thread, #333, holds no locks at all
+---------- short gran, 1 .. 98, skip 67 ----------
+
+Thread #334 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #335 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #334
+ New state: shared-modified by threads #334, #335
+ Reason: this thread, #335, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #334
+ New state: shared-modified by threads #334, #335
+ Reason: this thread, #335, holds no locks at all
+---------- short gran, 0 .. 98, skip 68 ----------
+
+Thread #336 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #337 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:424)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #336
+ New state: shared-modified by threads #336, #337
+ Reason: this thread, #337, holds no locks at all
+---------- short gran, 1 .. 98, skip 69 ----------
+
+Thread #338 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #339 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #338
+ New state: shared-modified by threads #338, #339
+ Reason: this thread, #339, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #338
+ New state: shared-modified by threads #338, #339
+ Reason: this thread, #339, holds no locks at all
+---------- short gran, 0 .. 98, skip 70 ----------
+
+Thread #340 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #341 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #340
+ New state: shared-modified by threads #340, #341
+ Reason: this thread, #341, holds no locks at all
+---------- short gran, 1 .. 98, skip 71 ----------
+
+Thread #342 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #343 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #342
+ New state: shared-modified by threads #342, #343
+ Reason: this thread, #343, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #342
+ New state: shared-modified by threads #342, #343
+ Reason: this thread, #343, holds no locks at all
+---------- short gran, 0 .. 98, skip 72 ----------
+
+Thread #344 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #345 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:432)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #344
+ New state: shared-modified by threads #344, #345
+ Reason: this thread, #345, holds no locks at all
+---------- short gran, 1 .. 98, skip 73 ----------
+
+Thread #346 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #347 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #346
+ New state: shared-modified by threads #346, #347
+ Reason: this thread, #347, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #346
+ New state: shared-modified by threads #346, #347
+ Reason: this thread, #347, holds no locks at all
+---------- short gran, 0 .. 98, skip 74 ----------
+
+Thread #348 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #349 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #348
+ New state: shared-modified by threads #348, #349
+ Reason: this thread, #349, holds no locks at all
+---------- short gran, 1 .. 98, skip 75 ----------
+
+Thread #350 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #351 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #350
+ New state: shared-modified by threads #350, #351
+ Reason: this thread, #351, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #350
+ New state: shared-modified by threads #350, #351
+ Reason: this thread, #351, holds no locks at all
+---------- short gran, 0 .. 98, skip 76 ----------
+
+Thread #352 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #353 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:440)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #352
+ New state: shared-modified by threads #352, #353
+ Reason: this thread, #353, holds no locks at all
+---------- short gran, 1 .. 98, skip 77 ----------
+
+Thread #354 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #355 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #354
+ New state: shared-modified by threads #354, #355
+ Reason: this thread, #355, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #354
+ New state: shared-modified by threads #354, #355
+ Reason: this thread, #355, holds no locks at all
+---------- short gran, 0 .. 98, skip 78 ----------
+
+Thread #356 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #357 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #356
+ New state: shared-modified by threads #356, #357
+ Reason: this thread, #357, holds no locks at all
+---------- short gran, 1 .. 98, skip 79 ----------
+
+Thread #358 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #359 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #358
+ New state: shared-modified by threads #358, #359
+ Reason: this thread, #359, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #358
+ New state: shared-modified by threads #358, #359
+ Reason: this thread, #359, holds no locks at all
+---------- short gran, 0 .. 98, skip 80 ----------
+
+Thread #360 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #361 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:448)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #360
+ New state: shared-modified by threads #360, #361
+ Reason: this thread, #361, holds no locks at all
+---------- short gran, 1 .. 98, skip 81 ----------
+
+Thread #362 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #363 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #362
+ New state: shared-modified by threads #362, #363
+ Reason: this thread, #363, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #362
+ New state: shared-modified by threads #362, #363
+ Reason: this thread, #363, holds no locks at all
+---------- short gran, 0 .. 98, skip 82 ----------
+
+Thread #364 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #365 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #364
+ New state: shared-modified by threads #364, #365
+ Reason: this thread, #365, holds no locks at all
+---------- short gran, 1 .. 98, skip 83 ----------
+
+Thread #366 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #367 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #366
+ New state: shared-modified by threads #366, #367
+ Reason: this thread, #367, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #366
+ New state: shared-modified by threads #366, #367
+ Reason: this thread, #367, holds no locks at all
+---------- short gran, 0 .. 98, skip 84 ----------
+
+Thread #368 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #369 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:456)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #368
+ New state: shared-modified by threads #368, #369
+ Reason: this thread, #369, holds no locks at all
+---------- short gran, 1 .. 98, skip 85 ----------
+
+Thread #370 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #371 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #370
+ New state: shared-modified by threads #370, #371
+ Reason: this thread, #371, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #370
+ New state: shared-modified by threads #370, #371
+ Reason: this thread, #371, holds no locks at all
+---------- short gran, 0 .. 98, skip 86 ----------
+
+Thread #372 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #373 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #372
+ New state: shared-modified by threads #372, #373
+ Reason: this thread, #373, holds no locks at all
+---------- short gran, 1 .. 98, skip 87 ----------
+
+Thread #374 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #375 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #374
+ New state: shared-modified by threads #374, #375
+ Reason: this thread, #375, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #374
+ New state: shared-modified by threads #374, #375
+ Reason: this thread, #375, holds no locks at all
+---------- short gran, 0 .. 98, skip 88 ----------
+
+Thread #376 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #377 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:464)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #376
+ New state: shared-modified by threads #376, #377
+ Reason: this thread, #377, holds no locks at all
+---------- short gran, 1 .. 98, skip 89 ----------
+
+Thread #378 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #379 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #378
+ New state: shared-modified by threads #378, #379
+ Reason: this thread, #379, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #378
+ New state: shared-modified by threads #378, #379
+ Reason: this thread, #379, holds no locks at all
+---------- short gran, 0 .. 98, skip 90 ----------
+
+Thread #380 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #381 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #380
+ New state: shared-modified by threads #380, #381
+ Reason: this thread, #381, holds no locks at all
+---------- short gran, 1 .. 98, skip 91 ----------
+
+Thread #382 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #383 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #382
+ New state: shared-modified by threads #382, #383
+ Reason: this thread, #383, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #382
+ New state: shared-modified by threads #382, #383
+ Reason: this thread, #383, holds no locks at all
+---------- short gran, 0 .. 98, skip 92 ----------
+
+Thread #384 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #385 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:472)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #384
+ New state: shared-modified by threads #384, #385
+ Reason: this thread, #385, holds no locks at all
+---------- short gran, 1 .. 98, skip 93 ----------
+
+Thread #386 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #387 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #386
+ New state: shared-modified by threads #386, #387
+ Reason: this thread, #387, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #386
+ New state: shared-modified by threads #386, #387
+ Reason: this thread, #387, holds no locks at all
+---------- short gran, 0 .. 98, skip 94 ----------
+
+Thread #388 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #389 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:476)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #388
+ New state: shared-modified by threads #388, #389
+ Reason: this thread, #389, holds no locks at all
+---------- short gran, 1 .. 98, skip 95 ----------
+
+Thread #390 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #391 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #390
+ New state: shared-modified by threads #390, #391
+ Reason: this thread, #391, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #390
+ New state: shared-modified by threads #390, #391
+ Reason: this thread, #391, holds no locks at all
+---------- short gran, 0 .. 98, skip 96 ----------
+
+Thread #392 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #393 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:480)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #392
+ New state: shared-modified by threads #392, #393
+ Reason: this thread, #393, holds no locks at all
+---------- short gran, 1 .. 98, skip 97 ----------
+
+Thread #394 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #395 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:482)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #394
+ New state: shared-modified by threads #394, #395
+ Reason: this thread, #395, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child16 (tc19_shadowmem.c:59)
+ by 0x........: steer (tc19_shadowmem.c:482)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #394
+ New state: shared-modified by threads #394, #395
+ Reason: this thread, #395, holds no locks at all
+
+==========================================================
+=== 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 ===
+==========================================================
+
+---------- int gran, 0 .. 96, skip 0 ----------
+
+Thread #396 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #397 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:288)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #396
+ New state: shared-modified by threads #396, #397
+ Reason: this thread, #397, holds no locks at all
+---------- int gran, 1 .. 96, skip 1 ----------
+
+Thread #398 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #399 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #398
+ New state: shared-modified by threads #398, #399
+ Reason: this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #398
+ New state: shared-modified by threads #398, #399
+ Reason: this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #398
+ New state: shared-modified by threads #398, #399
+ Reason: this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #398
+ New state: shared-modified by threads #398, #399
+ Reason: this thread, #399, holds no locks at all
+---------- int gran, 2 .. 96, skip 2 ----------
+
+Thread #400 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #401 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #400
+ New state: shared-modified by threads #400, #401
+ Reason: this thread, #401, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #400
+ New state: shared-modified by threads #400, #401
+ Reason: this thread, #401, holds no locks at all
+---------- int gran, 3 .. 96, skip 3 ----------
+
+Thread #402 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #403 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #402
+ New state: shared-modified by threads #402, #403
+ Reason: this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #402
+ New state: shared-modified by threads #402, #403
+ Reason: this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #402
+ New state: shared-modified by threads #402, #403
+ Reason: this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #402
+ New state: shared-modified by threads #402, #403
+ Reason: this thread, #403, holds no locks at all
+---------- int gran, 0 .. 96, skip 4 ----------
+
+Thread #404 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #405 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:296)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #404
+ New state: shared-modified by threads #404, #405
+ Reason: this thread, #405, holds no locks at all
+---------- int gran, 1 .. 96, skip 5 ----------
+
+Thread #406 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #407 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #406
+ New state: shared-modified by threads #406, #407
+ Reason: this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #406
+ New state: shared-modified by threads #406, #407
+ Reason: this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #406
+ New state: shared-modified by threads #406, #407
+ Reason: this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #406
+ New state: shared-modified by threads #406, #407
+ Reason: this thread, #407, holds no locks at all
+---------- int gran, 2 .. 96, skip 6 ----------
+
+Thread #408 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #409 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #408
+ New state: shared-modified by threads #408, #409
+ Reason: this thread, #409, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #408
+ New state: shared-modified by threads #408, #409
+ Reason: this thread, #409, holds no locks at all
+---------- int gran, 3 .. 96, skip 7 ----------
+
+Thread #410 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #411 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #410
+ New state: shared-modified by threads #410, #411
+ Reason: this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #410
+ New state: shared-modified by threads #410, #411
+ Reason: this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #410
+ New state: shared-modified by threads #410, #411
+ Reason: this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #410
+ New state: shared-modified by threads #410, #411
+ Reason: this thread, #411, holds no locks at all
+---------- int gran, 0 .. 96, skip 8 ----------
+
+Thread #412 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #413 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:304)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #412
+ New state: shared-modified by threads #412, #413
+ Reason: this thread, #413, holds no locks at all
+---------- int gran, 1 .. 96, skip 9 ----------
+
+Thread #414 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #415 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #414
+ New state: shared-modified by threads #414, #415
+ Reason: this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #414
+ New state: shared-modified by threads #414, #415
+ Reason: this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #414
+ New state: shared-modified by threads #414, #415
+ Reason: this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #414
+ New state: shared-modified by threads #414, #415
+ Reason: this thread, #415, holds no locks at all
+---------- int gran, 2 .. 96, skip 10 ----------
+
+Thread #416 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #417 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #416
+ New state: shared-modified by threads #416, #417
+ Reason: this thread, #417, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #416
+ New state: shared-modified by threads #416, #417
+ Reason: this thread, #417, holds no locks at all
+---------- int gran, 3 .. 96, skip 11 ----------
+
+Thread #418 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #419 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #418
+ New state: shared-modified by threads #418, #419
+ Reason: this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #418
+ New state: shared-modified by threads #418, #419
+ Reason: this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #418
+ New state: shared-modified by threads #418, #419
+ Reason: this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #418
+ New state: shared-modified by threads #418, #419
+ Reason: this thread, #419, holds no locks at all
+---------- int gran, 0 .. 96, skip 12 ----------
+
+Thread #420 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #421 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:312)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #420
+ New state: shared-modified by threads #420, #421
+ Reason: this thread, #421, holds no locks at all
+---------- int gran, 1 .. 96, skip 13 ----------
+
+Thread #422 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #423 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #422
+ New state: shared-modified by threads #422, #423
+ Reason: this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #422
+ New state: shared-modified by threads #422, #423
+ Reason: this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #422
+ New state: shared-modified by threads #422, #423
+ Reason: this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #422
+ New state: shared-modified by threads #422, #423
+ Reason: this thread, #423, holds no locks at all
+---------- int gran, 2 .. 96, skip 14 ----------
+
+Thread #424 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #425 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #424
+ New state: shared-modified by threads #424, #425
+ Reason: this thread, #425, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #424
+ New state: shared-modified by threads #424, #425
+ Reason: this thread, #425, holds no locks at all
+---------- int gran, 3 .. 96, skip 15 ----------
+
+Thread #426 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #427 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #426
+ New state: shared-modified by threads #426, #427
+ Reason: this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #426
+ New state: shared-modified by threads #426, #427
+ Reason: this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #426
+ New state: shared-modified by threads #426, #427
+ Reason: this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #426
+ New state: shared-modified by threads #426, #427
+ Reason: this thread, #427, holds no locks at all
+---------- int gran, 0 .. 96, skip 16 ----------
+
+Thread #428 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #429 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:320)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #428
+ New state: shared-modified by threads #428, #429
+ Reason: this thread, #429, holds no locks at all
+---------- int gran, 1 .. 96, skip 17 ----------
+
+Thread #430 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #431 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #430
+ New state: shared-modified by threads #430, #431
+ Reason: this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #430
+ New state: shared-modified by threads #430, #431
+ Reason: this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #430
+ New state: shared-modified by threads #430, #431
+ Reason: this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #430
+ New state: shared-modified by threads #430, #431
+ Reason: this thread, #431, holds no locks at all
+---------- int gran, 2 .. 96, skip 18 ----------
+
+Thread #432 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #433 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #432
+ New state: shared-modified by threads #432, #433
+ Reason: this thread, #433, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #432
+ New state: shared-modified by threads #432, #433
+ Reason: this thread, #433, holds no locks at all
+---------- int gran, 3 .. 96, skip 19 ----------
+
+Thread #434 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #435 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #434
+ New state: shared-modified by threads #434, #435
+ Reason: this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #434
+ New state: shared-modified by threads #434, #435
+ Reason: this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #434
+ New state: shared-modified by threads #434, #435
+ Reason: this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #434
+ New state: shared-modified by threads #434, #435
+ Reason: this thread, #435, holds no locks at all
+---------- int gran, 0 .. 96, skip 20 ----------
+
+Thread #436 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #437 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:328)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #436
+ New state: shared-modified by threads #436, #437
+ Reason: this thread, #437, holds no locks at all
+---------- int gran, 1 .. 96, skip 21 ----------
+
+Thread #438 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #439 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #438
+ New state: shared-modified by threads #438, #439
+ Reason: this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #438
+ New state: shared-modified by threads #438, #439
+ Reason: this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #438
+ New state: shared-modified by threads #438, #439
+ Reason: this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #438
+ New state: shared-modified by threads #438, #439
+ Reason: this thread, #439, holds no locks at all
+---------- int gran, 2 .. 96, skip 22 ----------
+
+Thread #440 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #441 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #440
+ New state: shared-modified by threads #440, #441
+ Reason: this thread, #441, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #440
+ New state: shared-modified by threads #440, #441
+ Reason: this thread, #441, holds no locks at all
+---------- int gran, 3 .. 96, skip 23 ----------
+
+Thread #442 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #443 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #442
+ New state: shared-modified by threads #442, #443
+ Reason: this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #442
+ New state: shared-modified by threads #442, #443
+ Reason: this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #442
+ New state: shared-modified by threads #442, #443
+ Reason: this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #442
+ New state: shared-modified by threads #442, #443
+ Reason: this thread, #443, holds no locks at all
+---------- int gran, 0 .. 96, skip 24 ----------
+
+Thread #444 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #445 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:336)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #444
+ New state: shared-modified by threads #444, #445
+ Reason: this thread, #445, holds no locks at all
+---------- int gran, 1 .. 96, skip 25 ----------
+
+Thread #446 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #447 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #446
+ New state: shared-modified by threads #446, #447
+ Reason: this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #446
+ New state: shared-modified by threads #446, #447
+ Reason: this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #446
+ New state: shared-modified by threads #446, #447
+ Reason: this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #446
+ New state: shared-modified by threads #446, #447
+ Reason: this thread, #447, holds no locks at all
+---------- int gran, 2 .. 96, skip 26 ----------
+
+Thread #448 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #449 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #448
+ New state: shared-modified by threads #448, #449
+ Reason: this thread, #449, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #448
+ New state: shared-modified by threads #448, #449
+ Reason: this thread, #449, holds no locks at all
+---------- int gran, 3 .. 96, skip 27 ----------
+
+Thread #450 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #451 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #450
+ New state: shared-modified by threads #450, #451
+ Reason: this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #450
+ New state: shared-modified by threads #450, #451
+ Reason: this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #450
+ New state: shared-modified by threads #450, #451
+ Reason: this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #450
+ New state: shared-modified by threads #450, #451
+ Reason: this thread, #451, holds no locks at all
+---------- int gran, 0 .. 96, skip 28 ----------
+
+Thread #452 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #453 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:344)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #452
+ New state: shared-modified by threads #452, #453
+ Reason: this thread, #453, holds no locks at all
+---------- int gran, 1 .. 96, skip 29 ----------
+
+Thread #454 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #455 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #454
+ New state: shared-modified by threads #454, #455
+ Reason: this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #454
+ New state: shared-modified by threads #454, #455
+ Reason: this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #454
+ New state: shared-modified by threads #454, #455
+ Reason: this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #454
+ New state: shared-modified by threads #454, #455
+ Reason: this thread, #455, holds no locks at all
+---------- int gran, 2 .. 96, skip 30 ----------
+
+Thread #456 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #457 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #456
+ New state: shared-modified by threads #456, #457
+ Reason: this thread, #457, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #456
+ New state: shared-modified by threads #456, #457
+ Reason: this thread, #457, holds no locks at all
+---------- int gran, 3 .. 96, skip 31 ----------
+
+Thread #458 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #459 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #458
+ New state: shared-modified by threads #458, #459
+ Reason: this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #458
+ New state: shared-modified by threads #458, #459
+ Reason: this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #458
+ New state: shared-modified by threads #458, #459
+ Reason: this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #458
+ New state: shared-modified by threads #458, #459
+ Reason: this thread, #459, holds no locks at all
+---------- int gran, 0 .. 96, skip 32 ----------
+
+Thread #460 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #461 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:352)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #460
+ New state: shared-modified by threads #460, #461
+ Reason: this thread, #461, holds no locks at all
+---------- int gran, 1 .. 96, skip 33 ----------
+
+Thread #462 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #463 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #462
+ New state: shared-modified by threads #462, #463
+ Reason: this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #462
+ New state: shared-modified by threads #462, #463
+ Reason: this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #462
+ New state: shared-modified by threads #462, #463
+ Reason: this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #462
+ New state: shared-modified by threads #462, #463
+ Reason: this thread, #463, holds no locks at all
+---------- int gran, 2 .. 96, skip 34 ----------
+
+Thread #464 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #465 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #464
+ New state: shared-modified by threads #464, #465
+ Reason: this thread, #465, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #464
+ New state: shared-modified by threads #464, #465
+ Reason: this thread, #465, holds no locks at all
+---------- int gran, 3 .. 96, skip 35 ----------
+
+Thread #466 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #467 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #466
+ New state: shared-modified by threads #466, #467
+ Reason: this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #466
+ New state: shared-modified by threads #466, #467
+ Reason: this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #466
+ New state: shared-modified by threads #466, #467
+ Reason: this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #466
+ New state: shared-modified by threads #466, #467
+ Reason: this thread, #467, holds no locks at all
+---------- int gran, 0 .. 96, skip 36 ----------
+
+Thread #468 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #469 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:360)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #468
+ New state: shared-modified by threads #468, #469
+ Reason: this thread, #469, holds no locks at all
+---------- int gran, 1 .. 96, skip 37 ----------
+
+Thread #470 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #471 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #470
+ New state: shared-modified by threads #470, #471
+ Reason: this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #470
+ New state: shared-modified by threads #470, #471
+ Reason: this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #470
+ New state: shared-modified by threads #470, #471
+ Reason: this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #470
+ New state: shared-modified by threads #470, #471
+ Reason: this thread, #471, holds no locks at all
+---------- int gran, 2 .. 96, skip 38 ----------
+
+Thread #472 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #473 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #472
+ New state: shared-modified by threads #472, #473
+ Reason: this thread, #473, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #472
+ New state: shared-modified by threads #472, #473
+ Reason: this thread, #473, holds no locks at all
+---------- int gran, 3 .. 96, skip 39 ----------
+
+Thread #474 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #475 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #474
+ New state: shared-modified by threads #474, #475
+ Reason: this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #474
+ New state: shared-modified by threads #474, #475
+ Reason: this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #474
+ New state: shared-modified by threads #474, #475
+ Reason: this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #474
+ New state: shared-modified by threads #474, #475
+ Reason: this thread, #475, holds no locks at all
+---------- int gran, 0 .. 96, skip 40 ----------
+
+Thread #476 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #477 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:368)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #476
+ New state: shared-modified by threads #476, #477
+ Reason: this thread, #477, holds no locks at all
+---------- int gran, 1 .. 96, skip 41 ----------
+
+Thread #478 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #479 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #478
+ New state: shared-modified by threads #478, #479
+ Reason: this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #478
+ New state: shared-modified by threads #478, #479
+ Reason: this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #478
+ New state: shared-modified by threads #478, #479
+ Reason: this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #478
+ New state: shared-modified by threads #478, #479
+ Reason: this thread, #479, holds no locks at all
+---------- int gran, 2 .. 96, skip 42 ----------
+
+Thread #480 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #481 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #480
+ New state: shared-modified by threads #480, #481
+ Reason: this thread, #481, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #480
+ New state: shared-modified by threads #480, #481
+ Reason: this thread, #481, holds no locks at all
+---------- int gran, 3 .. 96, skip 43 ----------
+
+Thread #482 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #483 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #482
+ New state: shared-modified by threads #482, #483
+ Reason: this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #482
+ New state: shared-modified by threads #482, #483
+ Reason: this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #482
+ New state: shared-modified by threads #482, #483
+ Reason: this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #482
+ New state: shared-modified by threads #482, #483
+ Reason: this thread, #483, holds no locks at all
+---------- int gran, 0 .. 96, skip 44 ----------
+
+Thread #484 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #485 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:376)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #484
+ New state: shared-modified by threads #484, #485
+ Reason: this thread, #485, holds no locks at all
+---------- int gran, 1 .. 96, skip 45 ----------
+
+Thread #486 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #487 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #486
+ New state: shared-modified by threads #486, #487
+ Reason: this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #486
+ New state: shared-modified by threads #486, #487
+ Reason: this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #486
+ New state: shared-modified by threads #486, #487
+ Reason: this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #486
+ New state: shared-modified by threads #486, #487
+ Reason: this thread, #487, holds no locks at all
+---------- int gran, 2 .. 96, skip 46 ----------
+
+Thread #488 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #489 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #488
+ New state: shared-modified by threads #488, #489
+ Reason: this thread, #489, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #488
+ New state: shared-modified by threads #488, #489
+ Reason: this thread, #489, holds no locks at all
+---------- int gran, 3 .. 96, skip 47 ----------
+
+Thread #490 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #491 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #490
+ New state: shared-modified by threads #490, #491
+ Reason: this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #490
+ New state: shared-modified by threads #490, #491
+ Reason: this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #490
+ New state: shared-modified by threads #490, #491
+ Reason: this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #490
+ New state: shared-modified by threads #490, #491
+ Reason: this thread, #491, holds no locks at all
+---------- int gran, 0 .. 96, skip 48 ----------
+
+Thread #492 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #493 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:384)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #492
+ New state: shared-modified by threads #492, #493
+ Reason: this thread, #493, holds no locks at all
+---------- int gran, 1 .. 96, skip 49 ----------
+
+Thread #494 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #495 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #494
+ New state: shared-modified by threads #494, #495
+ Reason: this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #494
+ New state: shared-modified by threads #494, #495
+ Reason: this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #494
+ New state: shared-modified by threads #494, #495
+ Reason: this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #494
+ New state: shared-modified by threads #494, #495
+ Reason: this thread, #495, holds no locks at all
+---------- int gran, 2 .. 96, skip 50 ----------
+
+Thread #496 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #497 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #496
+ New state: shared-modified by threads #496, #497
+ Reason: this thread, #497, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #496
+ New state: shared-modified by threads #496, #497
+ Reason: this thread, #497, holds no locks at all
+---------- int gran, 3 .. 96, skip 51 ----------
+
+Thread #498 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #499 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #498
+ New state: shared-modified by threads #498, #499
+ Reason: this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #498
+ New state: shared-modified by threads #498, #499
+ Reason: this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #498
+ New state: shared-modified by threads #498, #499
+ Reason: this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #498
+ New state: shared-modified by threads #498, #499
+ Reason: this thread, #499, holds no locks at all
+---------- int gran, 0 .. 96, skip 52 ----------
+
+Thread #500 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #501 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:392)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #500
+ New state: shared-modified by threads #500, #501
+ Reason: this thread, #501, holds no locks at all
+---------- int gran, 1 .. 96, skip 53 ----------
+
+Thread #502 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #503 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #502
+ New state: shared-modified by threads #502, #503
+ Reason: this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #502
+ New state: shared-modified by threads #502, #503
+ Reason: this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #502
+ New state: shared-modified by threads #502, #503
+ Reason: this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #502
+ New state: shared-modified by threads #502, #503
+ Reason: this thread, #503, holds no locks at all
+---------- int gran, 2 .. 96, skip 54 ----------
+
+Thread #504 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #505 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #504
+ New state: shared-modified by threads #504, #505
+ Reason: this thread, #505, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #504
+ New state: shared-modified by threads #504, #505
+ Reason: this thread, #505, holds no locks at all
+---------- int gran, 3 .. 96, skip 55 ----------
+
+Thread #506 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #507 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #506
+ New state: shared-modified by threads #506, #507
+ Reason: this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #506
+ New state: shared-modified by threads #506, #507
+ Reason: this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #506
+ New state: shared-modified by threads #506, #507
+ Reason: this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #506
+ New state: shared-modified by threads #506, #507
+ Reason: this thread, #507, holds no locks at all
+---------- int gran, 0 .. 96, skip 56 ----------
+
+Thread #508 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #509 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:400)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #508
+ New state: shared-modified by threads #508, #509
+ Reason: this thread, #509, holds no locks at all
+---------- int gran, 1 .. 96, skip 57 ----------
+
+Thread #510 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #511 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #510
+ New state: shared-modified by threads #510, #511
+ Reason: this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #510
+ New state: shared-modified by threads #510, #511
+ Reason: this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #510
+ New state: shared-modified by threads #510, #511
+ Reason: this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #510
+ New state: shared-modified by threads #510, #511
+ Reason: this thread, #511, holds no locks at all
+---------- int gran, 2 .. 96, skip 58 ----------
+
+Thread #512 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #513 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #512
+ New state: shared-modified by threads #512, #513
+ Reason: this thread, #513, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #512
+ New state: shared-modified by threads #512, #513
+ Reason: this thread, #513, holds no locks at all
+---------- int gran, 3 .. 96, skip 59 ----------
+
+Thread #514 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #515 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #514
+ New state: shared-modified by threads #514, #515
+ Reason: this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #514
+ New state: shared-modified by threads #514, #515
+ Reason: this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #514
+ New state: shared-modified by threads #514, #515
+ Reason: this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #514
+ New state: shared-modified by threads #514, #515
+ Reason: this thread, #515, holds no locks at all
+---------- int gran, 0 .. 96, skip 60 ----------
+
+Thread #516 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #517 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:408)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #516
+ New state: shared-modified by threads #516, #517
+ Reason: this thread, #517, holds no locks at all
+---------- int gran, 1 .. 96, skip 61 ----------
+
+Thread #518 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #519 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #518
+ New state: shared-modified by threads #518, #519
+ Reason: this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #518
+ New state: shared-modified by threads #518, #519
+ Reason: this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #518
+ New state: shared-modified by threads #518, #519
+ Reason: this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #518
+ New state: shared-modified by threads #518, #519
+ Reason: this thread, #519, holds no locks at all
+---------- int gran, 2 .. 96, skip 62 ----------
+
+Thread #520 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #521 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #520
+ New state: shared-modified by threads #520, #521
+ Reason: this thread, #521, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #520
+ New state: shared-modified by threads #520, #521
+ Reason: this thread, #521, holds no locks at all
+---------- int gran, 3 .. 96, skip 63 ----------
+
+Thread #522 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #523 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #522
+ New state: shared-modified by threads #522, #523
+ Reason: this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #522
+ New state: shared-modified by threads #522, #523
+ Reason: this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #522
+ New state: shared-modified by threads #522, #523
+ Reason: this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #522
+ New state: shared-modified by threads #522, #523
+ Reason: this thread, #523, holds no locks at all
+---------- int gran, 0 .. 96, skip 64 ----------
+
+Thread #524 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #525 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:416)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #524
+ New state: shared-modified by threads #524, #525
+ Reason: this thread, #525, holds no locks at all
+---------- int gran, 1 .. 96, skip 65 ----------
+
+Thread #526 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #527 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #526
+ New state: shared-modified by threads #526, #527
+ Reason: this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #526
+ New state: shared-modified by threads #526, #527
+ Reason: this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #526
+ New state: shared-modified by threads #526, #527
+ Reason: this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #526
+ New state: shared-modified by threads #526, #527
+ Reason: this thread, #527, holds no locks at all
+---------- int gran, 2 .. 96, skip 66 ----------
+
+Thread #528 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #529 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #528
+ New state: shared-modified by threads #528, #529
+ Reason: this thread, #529, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #528
+ New state: shared-modified by threads #528, #529
+ Reason: this thread, #529, holds no locks at all
+---------- int gran, 3 .. 96, skip 67 ----------
+
+Thread #530 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #531 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #530
+ New state: shared-modified by threads #530, #531
+ Reason: this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #530
+ New state: shared-modified by threads #530, #531
+ Reason: this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #530
+ New state: shared-modified by threads #530, #531
+ Reason: this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #530
+ New state: shared-modified by threads #530, #531
+ Reason: this thread, #531, holds no locks at all
+---------- int gran, 0 .. 96, skip 68 ----------
+
+Thread #532 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #533 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:424)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #532
+ New state: shared-modified by threads #532, #533
+ Reason: this thread, #533, holds no locks at all
+---------- int gran, 1 .. 96, skip 69 ----------
+
+Thread #534 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #535 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #534
+ New state: shared-modified by threads #534, #535
+ Reason: this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #534
+ New state: shared-modified by threads #534, #535
+ Reason: this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #534
+ New state: shared-modified by threads #534, #535
+ Reason: this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #534
+ New state: shared-modified by threads #534, #535
+ Reason: this thread, #535, holds no locks at all
+---------- int gran, 2 .. 96, skip 70 ----------
+
+Thread #536 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #537 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #536
+ New state: shared-modified by threads #536, #537
+ Reason: this thread, #537, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #536
+ New state: shared-modified by threads #536, #537
+ Reason: this thread, #537, holds no locks at all
+---------- int gran, 3 .. 96, skip 71 ----------
+
+Thread #538 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #539 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #538
+ New state: shared-modified by threads #538, #539
+ Reason: this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #538
+ New state: shared-modified by threads #538, #539
+ Reason: this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #538
+ New state: shared-modified by threads #538, #539
+ Reason: this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #538
+ New state: shared-modified by threads #538, #539
+ Reason: this thread, #539, holds no locks at all
+---------- int gran, 0 .. 96, skip 72 ----------
+
+Thread #540 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #541 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:432)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #540
+ New state: shared-modified by threads #540, #541
+ Reason: this thread, #541, holds no locks at all
+---------- int gran, 1 .. 96, skip 73 ----------
+
+Thread #542 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #543 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #542
+ New state: shared-modified by threads #542, #543
+ Reason: this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #542
+ New state: shared-modified by threads #542, #543
+ Reason: this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #542
+ New state: shared-modified by threads #542, #543
+ Reason: this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #542
+ New state: shared-modified by threads #542, #543
+ Reason: this thread, #543, holds no locks at all
+---------- int gran, 2 .. 96, skip 74 ----------
+
+Thread #544 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #545 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #544
+ New state: shared-modified by threads #544, #545
+ Reason: this thread, #545, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #544
+ New state: shared-modified by threads #544, #545
+ Reason: this thread, #545, holds no locks at all
+---------- int gran, 3 .. 96, skip 75 ----------
+
+Thread #546 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #547 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #546
+ New state: shared-modified by threads #546, #547
+ Reason: this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #546
+ New state: shared-modified by threads #546, #547
+ Reason: this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #546
+ New state: shared-modified by threads #546, #547
+ Reason: this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #546
+ New state: shared-modified by threads #546, #547
+ Reason: this thread, #547, holds no locks at all
+---------- int gran, 0 .. 96, skip 76 ----------
+
+Thread #548 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #549 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:440)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #548
+ New state: shared-modified by threads #548, #549
+ Reason: this thread, #549, holds no locks at all
+---------- int gran, 1 .. 96, skip 77 ----------
+
+Thread #550 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #551 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #550
+ New state: shared-modified by threads #550, #551
+ Reason: this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #550
+ New state: shared-modified by threads #550, #551
+ Reason: this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #550
+ New state: shared-modified by threads #550, #551
+ Reason: this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #550
+ New state: shared-modified by threads #550, #551
+ Reason: this thread, #551, holds no locks at all
+---------- int gran, 2 .. 96, skip 78 ----------
+
+Thread #552 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #553 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #552
+ New state: shared-modified by threads #552, #553
+ Reason: this thread, #553, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #552
+ New state: shared-modified by threads #552, #553
+ Reason: this thread, #553, holds no locks at all
+---------- int gran, 3 .. 96, skip 79 ----------
+
+Thread #554 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #555 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #554
+ New state: shared-modified by threads #554, #555
+ Reason: this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #554
+ New state: shared-modified by threads #554, #555
+ Reason: this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #554
+ New state: shared-modified by threads #554, #555
+ Reason: this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #554
+ New state: shared-modified by threads #554, #555
+ Reason: this thread, #555, holds no locks at all
+---------- int gran, 0 .. 96, skip 80 ----------
+
+Thread #556 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #557 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:448)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #556
+ New state: shared-modified by threads #556, #557
+ Reason: this thread, #557, holds no locks at all
+---------- int gran, 1 .. 96, skip 81 ----------
+
+Thread #558 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #559 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #558
+ New state: shared-modified by threads #558, #559
+ Reason: this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #558
+ New state: shared-modified by threads #558, #559
+ Reason: this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #558
+ New state: shared-modified by threads #558, #559
+ Reason: this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #558
+ New state: shared-modified by threads #558, #559
+ Reason: this thread, #559, holds no locks at all
+---------- int gran, 2 .. 96, skip 82 ----------
+
+Thread #560 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #561 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #560
+ New state: shared-modified by threads #560, #561
+ Reason: this thread, #561, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #560
+ New state: shared-modified by threads #560, #561
+ Reason: this thread, #561, holds no locks at all
+---------- int gran, 3 .. 96, skip 83 ----------
+
+Thread #562 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #563 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #562
+ New state: shared-modified by threads #562, #563
+ Reason: this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #562
+ New state: shared-modified by threads #562, #563
+ Reason: this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #562
+ New state: shared-modified by threads #562, #563
+ Reason: this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #562
+ New state: shared-modified by threads #562, #563
+ Reason: this thread, #563, holds no locks at all
+---------- int gran, 0 .. 96, skip 84 ----------
+
+Thread #564 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #565 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:456)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #564
+ New state: shared-modified by threads #564, #565
+ Reason: this thread, #565, holds no locks at all
+---------- int gran, 1 .. 96, skip 85 ----------
+
+Thread #566 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #567 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #566
+ New state: shared-modified by threads #566, #567
+ Reason: this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #566
+ New state: shared-modified by threads #566, #567
+ Reason: this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #566
+ New state: shared-modified by threads #566, #567
+ Reason: this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #566
+ New state: shared-modified by threads #566, #567
+ Reason: this thread, #567, holds no locks at all
+---------- int gran, 2 .. 96, skip 86 ----------
+
+Thread #568 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #569 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #568
+ New state: shared-modified by threads #568, #569
+ Reason: this thread, #569, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #568
+ New state: shared-modified by threads #568, #569
+ Reason: this thread, #569, holds no locks at all
+---------- int gran, 3 .. 96, skip 87 ----------
+
+Thread #570 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #571 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #570
+ New state: shared-modified by threads #570, #571
+ Reason: this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #570
+ New state: shared-modified by threads #570, #571
+ Reason: this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #570
+ New state: shared-modified by threads #570, #571
+ Reason: this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #570
+ New state: shared-modified by threads #570, #571
+ Reason: this thread, #571, holds no locks at all
+---------- int gran, 0 .. 96, skip 88 ----------
+
+Thread #572 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #573 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:464)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #572
+ New state: shared-modified by threads #572, #573
+ Reason: this thread, #573, holds no locks at all
+---------- int gran, 1 .. 96, skip 89 ----------
+
+Thread #574 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #575 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #574
+ New state: shared-modified by threads #574, #575
+ Reason: this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #574
+ New state: shared-modified by threads #574, #575
+ Reason: this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #574
+ New state: shared-modified by threads #574, #575
+ Reason: this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #574
+ New state: shared-modified by threads #574, #575
+ Reason: this thread, #575, holds no locks at all
+---------- int gran, 2 .. 96, skip 90 ----------
+
+Thread #576 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #577 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #576
+ New state: shared-modified by threads #576, #577
+ Reason: this thread, #577, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #576
+ New state: shared-modified by threads #576, #577
+ Reason: this thread, #577, holds no locks at all
+---------- int gran, 3 .. 96, skip 91 ----------
+
+Thread #578 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #579 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #578
+ New state: shared-modified by threads #578, #579
+ Reason: this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #578
+ New state: shared-modified by threads #578, #579
+ Reason: this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #578
+ New state: shared-modified by threads #578, #579
+ Reason: this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #578
+ New state: shared-modified by threads #578, #579
+ Reason: this thread, #579, holds no locks at all
+---------- int gran, 0 .. 96, skip 92 ----------
+
+Thread #580 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #581 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:472)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #580
+ New state: shared-modified by threads #580, #581
+ Reason: this thread, #581, holds no locks at all
+---------- int gran, 1 .. 96, skip 93 ----------
+
+Thread #582 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #583 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #582
+ New state: shared-modified by threads #582, #583
+ Reason: this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #582
+ New state: shared-modified by threads #582, #583
+ Reason: this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #582
+ New state: shared-modified by threads #582, #583
+ Reason: this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:474)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #582
+ New state: shared-modified by threads #582, #583
+ Reason: this thread, #583, holds no locks at all
+---------- int gran, 2 .. 96, skip 94 ----------
+
+Thread #584 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #585 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:476)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #584
+ New state: shared-modified by threads #584, #585
+ Reason: this thread, #585, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:476)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #584
+ New state: shared-modified by threads #584, #585
+ Reason: this thread, #585, holds no locks at all
+---------- int gran, 3 .. 96, skip 95 ----------
+
+Thread #586 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #587 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #586
+ New state: shared-modified by threads #586, #587
+ Reason: this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #586
+ New state: shared-modified by threads #586, #587
+ Reason: this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #586
+ New state: shared-modified by threads #586, #587
+ Reason: this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child32 (tc19_shadowmem.c:83)
+ by 0x........: steer (tc19_shadowmem.c:478)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #586
+ New state: shared-modified by threads #586, #587
+ Reason: this thread, #587, holds no locks at all
+
+==========================================================
+=== 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 ===
+==========================================================
+
+---------- double gran, 0 .. 92, skip 0 ----------
+
+Thread #588 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #589 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:288)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #588
+ New state: shared-modified by threads #588, #589
+ Reason: this thread, #589, holds no locks at all
+---------- double gran, 1 .. 92, skip 1 ----------
+
+Thread #590 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #591 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:290)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #590
+ New state: shared-modified by threads #590, #591
+ Reason: this thread, #591, holds no locks at all
+---------- double gran, 2 .. 92, skip 2 ----------
+
+Thread #592 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #593 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #592
+ New state: shared-modified by threads #592, #593
+ Reason: this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #592
+ New state: shared-modified by threads #592, #593
+ Reason: this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #592
+ New state: shared-modified by threads #592, #593
+ Reason: this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:292)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #592
+ New state: shared-modified by threads #592, #593
+ Reason: this thread, #593, holds no locks at all
+---------- double gran, 3 .. 92, skip 3 ----------
+
+Thread #594 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #595 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:294)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #594
+ New state: shared-modified by threads #594, #595
+ Reason: this thread, #595, holds no locks at all
+---------- double gran, 4 .. 92, skip 4 ----------
+
+Thread #596 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #597 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:296)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #596
+ New state: shared-modified by threads #596, #597
+ Reason: this thread, #597, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:296)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #596
+ New state: shared-modified by threads #596, #597
+ Reason: this thread, #597, holds no locks at all
+---------- double gran, 5 .. 92, skip 5 ----------
+
+Thread #598 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #599 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:298)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #598
+ New state: shared-modified by threads #598, #599
+ Reason: this thread, #599, holds no locks at all
+---------- double gran, 6 .. 92, skip 6 ----------
+
+Thread #600 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #601 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #600
+ New state: shared-modified by threads #600, #601
+ Reason: this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #600
+ New state: shared-modified by threads #600, #601
+ Reason: this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #600
+ New state: shared-modified by threads #600, #601
+ Reason: this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:300)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #600
+ New state: shared-modified by threads #600, #601
+ Reason: this thread, #601, holds no locks at all
+---------- double gran, 7 .. 92, skip 7 ----------
+
+Thread #602 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #603 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:302)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #602
+ New state: shared-modified by threads #602, #603
+ Reason: this thread, #603, holds no locks at all
+---------- double gran, 0 .. 92, skip 8 ----------
+
+Thread #604 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #605 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:304)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #604
+ New state: shared-modified by threads #604, #605
+ Reason: this thread, #605, holds no locks at all
+---------- double gran, 1 .. 92, skip 9 ----------
+
+Thread #606 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #607 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:306)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #606
+ New state: shared-modified by threads #606, #607
+ Reason: this thread, #607, holds no locks at all
+---------- double gran, 2 .. 92, skip 10 ----------
+
+Thread #608 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #609 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #608
+ New state: shared-modified by threads #608, #609
+ Reason: this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #608
+ New state: shared-modified by threads #608, #609
+ Reason: this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #608
+ New state: shared-modified by threads #608, #609
+ Reason: this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:308)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #608
+ New state: shared-modified by threads #608, #609
+ Reason: this thread, #609, holds no locks at all
+---------- double gran, 3 .. 92, skip 11 ----------
+
+Thread #610 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #611 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:310)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #610
+ New state: shared-modified by threads #610, #611
+ Reason: this thread, #611, holds no locks at all
+---------- double gran, 4 .. 92, skip 12 ----------
+
+Thread #612 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #613 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:312)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #612
+ New state: shared-modified by threads #612, #613
+ Reason: this thread, #613, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:312)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #612
+ New state: shared-modified by threads #612, #613
+ Reason: this thread, #613, holds no locks at all
+---------- double gran, 5 .. 92, skip 13 ----------
+
+Thread #614 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #615 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:314)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #614
+ New state: shared-modified by threads #614, #615
+ Reason: this thread, #615, holds no locks at all
+---------- double gran, 6 .. 92, skip 14 ----------
+
+Thread #616 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #617 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #616
+ New state: shared-modified by threads #616, #617
+ Reason: this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #616
+ New state: shared-modified by threads #616, #617
+ Reason: this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #616
+ New state: shared-modified by threads #616, #617
+ Reason: this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:316)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #616
+ New state: shared-modified by threads #616, #617
+ Reason: this thread, #617, holds no locks at all
+---------- double gran, 7 .. 92, skip 15 ----------
+
+Thread #618 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #619 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:318)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #618
+ New state: shared-modified by threads #618, #619
+ Reason: this thread, #619, holds no locks at all
+---------- double gran, 0 .. 92, skip 16 ----------
+
+Thread #620 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #621 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:320)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #620
+ New state: shared-modified by threads #620, #621
+ Reason: this thread, #621, holds no locks at all
+---------- double gran, 1 .. 92, skip 17 ----------
+
+Thread #622 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #623 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:322)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #622
+ New state: shared-modified by threads #622, #623
+ Reason: this thread, #623, holds no locks at all
+---------- double gran, 2 .. 92, skip 18 ----------
+
+Thread #624 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #625 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #624
+ New state: shared-modified by threads #624, #625
+ Reason: this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #624
+ New state: shared-modified by threads #624, #625
+ Reason: this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #624
+ New state: shared-modified by threads #624, #625
+ Reason: this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:324)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #624
+ New state: shared-modified by threads #624, #625
+ Reason: this thread, #625, holds no locks at all
+---------- double gran, 3 .. 92, skip 19 ----------
+
+Thread #626 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #627 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:326)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #626
+ New state: shared-modified by threads #626, #627
+ Reason: this thread, #627, holds no locks at all
+---------- double gran, 4 .. 92, skip 20 ----------
+
+Thread #628 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #629 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:328)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #628
+ New state: shared-modified by threads #628, #629
+ Reason: this thread, #629, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:328)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #628
+ New state: shared-modified by threads #628, #629
+ Reason: this thread, #629, holds no locks at all
+---------- double gran, 5 .. 92, skip 21 ----------
+
+Thread #630 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #631 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:330)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #630
+ New state: shared-modified by threads #630, #631
+ Reason: this thread, #631, holds no locks at all
+---------- double gran, 6 .. 92, skip 22 ----------
+
+Thread #632 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #633 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #632
+ New state: shared-modified by threads #632, #633
+ Reason: this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #632
+ New state: shared-modified by threads #632, #633
+ Reason: this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #632
+ New state: shared-modified by threads #632, #633
+ Reason: this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:332)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #632
+ New state: shared-modified by threads #632, #633
+ Reason: this thread, #633, holds no locks at all
+---------- double gran, 7 .. 92, skip 23 ----------
+
+Thread #634 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #635 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:334)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #634
+ New state: shared-modified by threads #634, #635
+ Reason: this thread, #635, holds no locks at all
+---------- double gran, 0 .. 92, skip 24 ----------
+
+Thread #636 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #637 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:336)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #636
+ New state: shared-modified by threads #636, #637
+ Reason: this thread, #637, holds no locks at all
+---------- double gran, 1 .. 92, skip 25 ----------
+
+Thread #638 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #639 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:338)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #638
+ New state: shared-modified by threads #638, #639
+ Reason: this thread, #639, holds no locks at all
+---------- double gran, 2 .. 92, skip 26 ----------
+
+Thread #640 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #641 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #640
+ New state: shared-modified by threads #640, #641
+ Reason: this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #640
+ New state: shared-modified by threads #640, #641
+ Reason: this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #640
+ New state: shared-modified by threads #640, #641
+ Reason: this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:340)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #640
+ New state: shared-modified by threads #640, #641
+ Reason: this thread, #641, holds no locks at all
+---------- double gran, 3 .. 92, skip 27 ----------
+
+Thread #642 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #643 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:342)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #642
+ New state: shared-modified by threads #642, #643
+ Reason: this thread, #643, holds no locks at all
+---------- double gran, 4 .. 92, skip 28 ----------
+
+Thread #644 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #645 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:344)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #644
+ New state: shared-modified by threads #644, #645
+ Reason: this thread, #645, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:344)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #644
+ New state: shared-modified by threads #644, #645
+ Reason: this thread, #645, holds no locks at all
+---------- double gran, 5 .. 92, skip 29 ----------
+
+Thread #646 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #647 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:346)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #646
+ New state: shared-modified by threads #646, #647
+ Reason: this thread, #647, holds no locks at all
+---------- double gran, 6 .. 92, skip 30 ----------
+
+Thread #648 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #649 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #648
+ New state: shared-modified by threads #648, #649
+ Reason: this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #648
+ New state: shared-modified by threads #648, #649
+ Reason: this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #648
+ New state: shared-modified by threads #648, #649
+ Reason: this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:348)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #648
+ New state: shared-modified by threads #648, #649
+ Reason: this thread, #649, holds no locks at all
+---------- double gran, 7 .. 92, skip 31 ----------
+
+Thread #650 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #651 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:350)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #650
+ New state: shared-modified by threads #650, #651
+ Reason: this thread, #651, holds no locks at all
+---------- double gran, 0 .. 92, skip 32 ----------
+
+Thread #652 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #653 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:352)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #652
+ New state: shared-modified by threads #652, #653
+ Reason: this thread, #653, holds no locks at all
+---------- double gran, 1 .. 92, skip 33 ----------
+
+Thread #654 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #655 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:354)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #654
+ New state: shared-modified by threads #654, #655
+ Reason: this thread, #655, holds no locks at all
+---------- double gran, 2 .. 92, skip 34 ----------
+
+Thread #656 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #657 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #656
+ New state: shared-modified by threads #656, #657
+ Reason: this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #656
+ New state: shared-modified by threads #656, #657
+ Reason: this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #656
+ New state: shared-modified by threads #656, #657
+ Reason: this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:356)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #656
+ New state: shared-modified by threads #656, #657
+ Reason: this thread, #657, holds no locks at all
+---------- double gran, 3 .. 92, skip 35 ----------
+
+Thread #658 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #659 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:358)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #658
+ New state: shared-modified by threads #658, #659
+ Reason: this thread, #659, holds no locks at all
+---------- double gran, 4 .. 92, skip 36 ----------
+
+Thread #660 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #661 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:360)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #660
+ New state: shared-modified by threads #660, #661
+ Reason: this thread, #661, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:360)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #660
+ New state: shared-modified by threads #660, #661
+ Reason: this thread, #661, holds no locks at all
+---------- double gran, 5 .. 92, skip 37 ----------
+
+Thread #662 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #663 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:362)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #662
+ New state: shared-modified by threads #662, #663
+ Reason: this thread, #663, holds no locks at all
+---------- double gran, 6 .. 92, skip 38 ----------
+
+Thread #664 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #665 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #664
+ New state: shared-modified by threads #664, #665
+ Reason: this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #664
+ New state: shared-modified by threads #664, #665
+ Reason: this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #664
+ New state: shared-modified by threads #664, #665
+ Reason: this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:364)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #664
+ New state: shared-modified by threads #664, #665
+ Reason: this thread, #665, holds no locks at all
+---------- double gran, 7 .. 92, skip 39 ----------
+
+Thread #666 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #667 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:366)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #666
+ New state: shared-modified by threads #666, #667
+ Reason: this thread, #667, holds no locks at all
+---------- double gran, 0 .. 92, skip 40 ----------
+
+Thread #668 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #669 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:368)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #668
+ New state: shared-modified by threads #668, #669
+ Reason: this thread, #669, holds no locks at all
+---------- double gran, 1 .. 92, skip 41 ----------
+
+Thread #670 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #671 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:370)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #670
+ New state: shared-modified by threads #670, #671
+ Reason: this thread, #671, holds no locks at all
+---------- double gran, 2 .. 92, skip 42 ----------
+
+Thread #672 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #673 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #672
+ New state: shared-modified by threads #672, #673
+ Reason: this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #672
+ New state: shared-modified by threads #672, #673
+ Reason: this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #672
+ New state: shared-modified by threads #672, #673
+ Reason: this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:372)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #672
+ New state: shared-modified by threads #672, #673
+ Reason: this thread, #673, holds no locks at all
+---------- double gran, 3 .. 92, skip 43 ----------
+
+Thread #674 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #675 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:374)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #674
+ New state: shared-modified by threads #674, #675
+ Reason: this thread, #675, holds no locks at all
+---------- double gran, 4 .. 92, skip 44 ----------
+
+Thread #676 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #677 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:376)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #676
+ New state: shared-modified by threads #676, #677
+ Reason: this thread, #677, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:376)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #676
+ New state: shared-modified by threads #676, #677
+ Reason: this thread, #677, holds no locks at all
+---------- double gran, 5 .. 92, skip 45 ----------
+
+Thread #678 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #679 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:378)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #678
+ New state: shared-modified by threads #678, #679
+ Reason: this thread, #679, holds no locks at all
+---------- double gran, 6 .. 92, skip 46 ----------
+
+Thread #680 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #681 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #680
+ New state: shared-modified by threads #680, #681
+ Reason: this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #680
+ New state: shared-modified by threads #680, #681
+ Reason: this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #680
+ New state: shared-modified by threads #680, #681
+ Reason: this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:380)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #680
+ New state: shared-modified by threads #680, #681
+ Reason: this thread, #681, holds no locks at all
+---------- double gran, 7 .. 92, skip 47 ----------
+
+Thread #682 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #683 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:382)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #682
+ New state: shared-modified by threads #682, #683
+ Reason: this thread, #683, holds no locks at all
+---------- double gran, 0 .. 92, skip 48 ----------
+
+Thread #684 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #685 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:384)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #684
+ New state: shared-modified by threads #684, #685
+ Reason: this thread, #685, holds no locks at all
+---------- double gran, 1 .. 92, skip 49 ----------
+
+Thread #686 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #687 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:386)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #686
+ New state: shared-modified by threads #686, #687
+ Reason: this thread, #687, holds no locks at all
+---------- double gran, 2 .. 92, skip 50 ----------
+
+Thread #688 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #689 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #688
+ New state: shared-modified by threads #688, #689
+ Reason: this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #688
+ New state: shared-modified by threads #688, #689
+ Reason: this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #688
+ New state: shared-modified by threads #688, #689
+ Reason: this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:388)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #688
+ New state: shared-modified by threads #688, #689
+ Reason: this thread, #689, holds no locks at all
+---------- double gran, 3 .. 92, skip 51 ----------
+
+Thread #690 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #691 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:390)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #690
+ New state: shared-modified by threads #690, #691
+ Reason: this thread, #691, holds no locks at all
+---------- double gran, 4 .. 92, skip 52 ----------
+
+Thread #692 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #693 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:392)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #692
+ New state: shared-modified by threads #692, #693
+ Reason: this thread, #693, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:392)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #692
+ New state: shared-modified by threads #692, #693
+ Reason: this thread, #693, holds no locks at all
+---------- double gran, 5 .. 92, skip 53 ----------
+
+Thread #694 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #695 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:394)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #694
+ New state: shared-modified by threads #694, #695
+ Reason: this thread, #695, holds no locks at all
+---------- double gran, 6 .. 92, skip 54 ----------
+
+Thread #696 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #697 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #696
+ New state: shared-modified by threads #696, #697
+ Reason: this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #696
+ New state: shared-modified by threads #696, #697
+ Reason: this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #696
+ New state: shared-modified by threads #696, #697
+ Reason: this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:396)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #696
+ New state: shared-modified by threads #696, #697
+ Reason: this thread, #697, holds no locks at all
+---------- double gran, 7 .. 92, skip 55 ----------
+
+Thread #698 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #699 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:398)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #698
+ New state: shared-modified by threads #698, #699
+ Reason: this thread, #699, holds no locks at all
+---------- double gran, 0 .. 92, skip 56 ----------
+
+Thread #700 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #701 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:400)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #700
+ New state: shared-modified by threads #700, #701
+ Reason: this thread, #701, holds no locks at all
+---------- double gran, 1 .. 92, skip 57 ----------
+
+Thread #702 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #703 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:402)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #702
+ New state: shared-modified by threads #702, #703
+ Reason: this thread, #703, holds no locks at all
+---------- double gran, 2 .. 92, skip 58 ----------
+
+Thread #704 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #705 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #704
+ New state: shared-modified by threads #704, #705
+ Reason: this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #704
+ New state: shared-modified by threads #704, #705
+ Reason: this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #704
+ New state: shared-modified by threads #704, #705
+ Reason: this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:404)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #704
+ New state: shared-modified by threads #704, #705
+ Reason: this thread, #705, holds no locks at all
+---------- double gran, 3 .. 92, skip 59 ----------
+
+Thread #706 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #707 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:406)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #706
+ New state: shared-modified by threads #706, #707
+ Reason: this thread, #707, holds no locks at all
+---------- double gran, 4 .. 92, skip 60 ----------
+
+Thread #708 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #709 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:408)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #708
+ New state: shared-modified by threads #708, #709
+ Reason: this thread, #709, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:408)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #708
+ New state: shared-modified by threads #708, #709
+ Reason: this thread, #709, holds no locks at all
+---------- double gran, 5 .. 92, skip 61 ----------
+
+Thread #710 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #711 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:410)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #710
+ New state: shared-modified by threads #710, #711
+ Reason: this thread, #711, holds no locks at all
+---------- double gran, 6 .. 92, skip 62 ----------
+
+Thread #712 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #713 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #712
+ New state: shared-modified by threads #712, #713
+ Reason: this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #712
+ New state: shared-modified by threads #712, #713
+ Reason: this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #712
+ New state: shared-modified by threads #712, #713
+ Reason: this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:412)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #712
+ New state: shared-modified by threads #712, #713
+ Reason: this thread, #713, holds no locks at all
+---------- double gran, 7 .. 92, skip 63 ----------
+
+Thread #714 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #715 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:414)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #714
+ New state: shared-modified by threads #714, #715
+ Reason: this thread, #715, holds no locks at all
+---------- double gran, 0 .. 92, skip 64 ----------
+
+Thread #716 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #717 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:416)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #716
+ New state: shared-modified by threads #716, #717
+ Reason: this thread, #717, holds no locks at all
+---------- double gran, 1 .. 92, skip 65 ----------
+
+Thread #718 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #719 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:418)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #718
+ New state: shared-modified by threads #718, #719
+ Reason: this thread, #719, holds no locks at all
+---------- double gran, 2 .. 92, skip 66 ----------
+
+Thread #720 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #721 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #720
+ New state: shared-modified by threads #720, #721
+ Reason: this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #720
+ New state: shared-modified by threads #720, #721
+ Reason: this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #720
+ New state: shared-modified by threads #720, #721
+ Reason: this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:420)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #720
+ New state: shared-modified by threads #720, #721
+ Reason: this thread, #721, holds no locks at all
+---------- double gran, 3 .. 92, skip 67 ----------
+
+Thread #722 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #723 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:422)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #722
+ New state: shared-modified by threads #722, #723
+ Reason: this thread, #723, holds no locks at all
+---------- double gran, 4 .. 92, skip 68 ----------
+
+Thread #724 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #725 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:424)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #724
+ New state: shared-modified by threads #724, #725
+ Reason: this thread, #725, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:424)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #724
+ New state: shared-modified by threads #724, #725
+ Reason: this thread, #725, holds no locks at all
+---------- double gran, 5 .. 92, skip 69 ----------
+
+Thread #726 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #727 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:426)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #726
+ New state: shared-modified by threads #726, #727
+ Reason: this thread, #727, holds no locks at all
+---------- double gran, 6 .. 92, skip 70 ----------
+
+Thread #728 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #729 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #728
+ New state: shared-modified by threads #728, #729
+ Reason: this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #728
+ New state: shared-modified by threads #728, #729
+ Reason: this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #728
+ New state: shared-modified by threads #728, #729
+ Reason: this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:428)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #728
+ New state: shared-modified by threads #728, #729
+ Reason: this thread, #729, holds no locks at all
+---------- double gran, 7 .. 92, skip 71 ----------
+
+Thread #730 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #731 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:430)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #730
+ New state: shared-modified by threads #730, #731
+ Reason: this thread, #731, holds no locks at all
+---------- double gran, 0 .. 92, skip 72 ----------
+
+Thread #732 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #733 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:432)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #732
+ New state: shared-modified by threads #732, #733
+ Reason: this thread, #733, holds no locks at all
+---------- double gran, 1 .. 92, skip 73 ----------
+
+Thread #734 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #735 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:434)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #734
+ New state: shared-modified by threads #734, #735
+ Reason: this thread, #735, holds no locks at all
+---------- double gran, 2 .. 92, skip 74 ----------
+
+Thread #736 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #737 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #736
+ New state: shared-modified by threads #736, #737
+ Reason: this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #736
+ New state: shared-modified by threads #736, #737
+ Reason: this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #736
+ New state: shared-modified by threads #736, #737
+ Reason: this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:436)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #736
+ New state: shared-modified by threads #736, #737
+ Reason: this thread, #737, holds no locks at all
+---------- double gran, 3 .. 92, skip 75 ----------
+
+Thread #738 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #739 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:438)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #738
+ New state: shared-modified by threads #738, #739
+ Reason: this thread, #739, holds no locks at all
+---------- double gran, 4 .. 92, skip 76 ----------
+
+Thread #740 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #741 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:440)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #740
+ New state: shared-modified by threads #740, #741
+ Reason: this thread, #741, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:440)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #740
+ New state: shared-modified by threads #740, #741
+ Reason: this thread, #741, holds no locks at all
+---------- double gran, 5 .. 92, skip 77 ----------
+
+Thread #742 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #743 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:442)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #742
+ New state: shared-modified by threads #742, #743
+ Reason: this thread, #743, holds no locks at all
+---------- double gran, 6 .. 92, skip 78 ----------
+
+Thread #744 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #745 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #744
+ New state: shared-modified by threads #744, #745
+ Reason: this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #744
+ New state: shared-modified by threads #744, #745
+ Reason: this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #744
+ New state: shared-modified by threads #744, #745
+ Reason: this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:444)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #744
+ New state: shared-modified by threads #744, #745
+ Reason: this thread, #745, holds no locks at all
+---------- double gran, 7 .. 92, skip 79 ----------
+
+Thread #746 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #747 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:446)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #746
+ New state: shared-modified by threads #746, #747
+ Reason: this thread, #747, holds no locks at all
+---------- double gran, 0 .. 92, skip 80 ----------
+
+Thread #748 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #749 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:448)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #748
+ New state: shared-modified by threads #748, #749
+ Reason: this thread, #749, holds no locks at all
+---------- double gran, 1 .. 92, skip 81 ----------
+
+Thread #750 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #751 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:450)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #750
+ New state: shared-modified by threads #750, #751
+ Reason: this thread, #751, holds no locks at all
+---------- double gran, 2 .. 92, skip 82 ----------
+
+Thread #752 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #753 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #752
+ New state: shared-modified by threads #752, #753
+ Reason: this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #752
+ New state: shared-modified by threads #752, #753
+ Reason: this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #752
+ New state: shared-modified by threads #752, #753
+ Reason: this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:452)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #752
+ New state: shared-modified by threads #752, #753
+ Reason: this thread, #753, holds no locks at all
+---------- double gran, 3 .. 92, skip 83 ----------
+
+Thread #754 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #755 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:454)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #754
+ New state: shared-modified by threads #754, #755
+ Reason: this thread, #755, holds no locks at all
+---------- double gran, 4 .. 92, skip 84 ----------
+
+Thread #756 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #757 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:456)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #756
+ New state: shared-modified by threads #756, #757
+ Reason: this thread, #757, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:456)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #756
+ New state: shared-modified by threads #756, #757
+ Reason: this thread, #757, holds no locks at all
+---------- double gran, 5 .. 92, skip 85 ----------
+
+Thread #758 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #759 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:458)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #758
+ New state: shared-modified by threads #758, #759
+ Reason: this thread, #759, holds no locks at all
+---------- double gran, 6 .. 92, skip 86 ----------
+
+Thread #760 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #761 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #760
+ New state: shared-modified by threads #760, #761
+ Reason: this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #760
+ New state: shared-modified by threads #760, #761
+ Reason: this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #760
+ New state: shared-modified by threads #760, #761
+ Reason: this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:460)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #760
+ New state: shared-modified by threads #760, #761
+ Reason: this thread, #761, holds no locks at all
+---------- double gran, 7 .. 92, skip 87 ----------
+
+Thread #762 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #763 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:462)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #762
+ New state: shared-modified by threads #762, #763
+ Reason: this thread, #763, holds no locks at all
+---------- double gran, 0 .. 92, skip 88 ----------
+
+Thread #764 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #765 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:464)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #764
+ New state: shared-modified by threads #764, #765
+ Reason: this thread, #765, holds no locks at all
+---------- double gran, 1 .. 92, skip 89 ----------
+
+Thread #766 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #767 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:466)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #766
+ New state: shared-modified by threads #766, #767
+ Reason: this thread, #767, holds no locks at all
+---------- double gran, 2 .. 92, skip 90 ----------
+
+Thread #768 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #769 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #768
+ New state: shared-modified by threads #768, #769
+ Reason: this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #768
+ New state: shared-modified by threads #768, #769
+ Reason: this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #768
+ New state: shared-modified by threads #768, #769
+ Reason: this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:468)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #768
+ New state: shared-modified by threads #768, #769
+ Reason: this thread, #769, holds no locks at all
+---------- double gran, 3 .. 92, skip 91 ----------
+
+Thread #770 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #771 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+ at 0x........: child64 (tc19_shadowmem.c:107)
+ by 0x........: steer (tc19_shadowmem.c:470)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: owned exclusively by thread #770
+ New state: shared-modified by threads #770, #771
+ Reason: this thread, #771, holds no locks at all
+
+ERROR SUMMARY: 1004 errors from 1004 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc19_shadowmem.stdout.exp b/helgrind/tests/tc19_shadowmem.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc19_shadowmem.stdout.exp
diff --git a/helgrind/tests/tc19_shadowmem.vgtest b/helgrind/tests/tc19_shadowmem.vgtest
new file mode 100644
index 0000000..233e8e4
--- /dev/null
+++ b/helgrind/tests/tc19_shadowmem.vgtest
@@ -0,0 +1,2 @@
+prog: tc19_shadowmem
+vgopts: --cmp-race-err-addrs=yes --error-limit=no
diff --git a/helgrind/tests/tc20_verifywrap.c b/helgrind/tests/tc20_verifywrap.c
new file mode 100644
index 0000000..81ea512
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.c
@@ -0,0 +1,262 @@
+
+/* This program attempts to verify that all functions that are
+ supposed to be wrapped by tc_intercepts.c really are wrapped. The
+ main way it does this is to cause failures in those functions, so
+ as to obtain various error messages which imply that the wrapper
+ really did engage.
+
+ Any regressions shown up by this program are potentially serious
+ and should be investigated carefully. */
+
+/* Needed for older glibcs (2.3 and older, at least) who don't
+ otherwise "know" about some more exotic pthread stuff, in this case
+ PTHREAD_MUTEX_ERRORCHECK. */
+#define _GNU_SOURCE 1
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+#if !defined(__GLIBC_PREREQ)
+# error "This program needs __GLIBC_PREREQ (in /usr/include/features.h)"
+#endif
+
+short unprotected = 0;
+
+void* lazy_child ( void* v ) {
+ assert(0); /* does not run */
+}
+
+void* racy_child ( void* v ) {
+ unprotected = 1234;
+ return NULL;
+}
+
+int main ( void )
+{
+ int r;
+ /* pthread_t thr; */
+ /* pthread_attr_t thra; */
+ pthread_mutexattr_t mxa, mxa2;
+ pthread_mutex_t mx, mx2, mx3, mx4;
+ pthread_cond_t cv;
+ struct timespec abstime;
+ pthread_rwlock_t rwl;
+ pthread_rwlock_t rwl2;
+ pthread_rwlock_t rwl3;
+ sem_t s1;
+
+# if __GLIBC_PREREQ(2,4)
+ fprintf(stderr,
+ "\n\n------ This is output for >= glibc 2.4 ------\n");
+# else
+ fprintf(stderr,
+ "\n\n------ This is output for < glibc 2.4 ------\n");
+# endif
+
+ /* --------- pthread_create/join --------- */
+
+ fprintf(stderr,
+ "\n---------------- pthread_create/join ----------------\n\n");
+
+ /* make pthread_create fail */
+ /* It's amazingly difficult to make pthread_create fail
+ without first soaking up all the machine's resources.
+ Instead, in order to demonstrate that it's really wrapped,
+ create a child thread, generate a race error, and join with it
+ again. */
+ /* This just segfaults:
+ memset( &thra, 0xFF, sizeof(thra) );
+ r= pthread_create( &thr, NULL, lazy_child, NULL ); assert(r);
+ */
+ { pthread_t child;
+ r= pthread_create( &child, NULL, racy_child, NULL ); assert(!r);
+ sleep(1); /* just to ensure parent thread reports race, not child */
+ unprotected = 5678;
+ r= pthread_join( child, NULL ); assert(!r);
+ }
+
+ /* make pthread_join fail */
+ r= pthread_join( pthread_self(), NULL ); assert(r);
+
+ /* --------- pthread_mutex_lock et al --------- */
+
+ fprintf(stderr,
+ "\n---------------- pthread_mutex_lock et al ----------------\n\n");
+
+ /* make pthread_mutex_init fail */
+ memset( &mxa, 0xFF, sizeof(mxa) );
+ r= pthread_mutex_init( &mx, &mxa );
+# if __GLIBC_PREREQ(2,4)
+ assert(r); /* glibc >= 2.4: the call should fail */
+# else
+ assert(!r); /* glibc < 2.4: oh well, glibc didn't bounce this */
+# endif
+
+ /* make pthread_mutex_destroy fail */
+ r= pthread_mutex_init( &mx2, NULL ); assert(!r);
+ r= pthread_mutex_lock( &mx2 ); assert(!r);
+ r= pthread_mutex_destroy( &mx2 ); assert(r);
+
+ /* make pthread_mutex_lock fail (skipped on < glibc 2.4 because it
+ doesn't fail, hence hangs the test) */
+# if __GLIBC_PREREQ(2,4)
+ memset( &mx3, 0xFF, sizeof(mx3) );
+ r= pthread_mutex_lock( &mx3 ); assert(r);
+# else
+ fprintf(stderr, "\nmake pthread_mutex_lock fail: "
+ "skipped on glibc < 2.4\n\n");
+# endif
+
+ /* make pthread_mutex_trylock fail */
+ memset( &mx3, 0xFF, sizeof(mx3) );
+ r= pthread_mutex_trylock( &mx3 ); assert(r);
+
+ /* make pthread_mutex_timedlock fail */
+ memset( &abstime, 0, sizeof(abstime) );
+ memset( &mx3, 0xFF, sizeof(mx3) );
+ r= pthread_mutex_timedlock( &mx3, &abstime ); assert(r);
+
+ /* make pthread_mutex_unlock fail */
+ memset( &mx3, 0xFF, sizeof(mx3) );
+ r= pthread_mutex_unlock( &mx3 );
+# if __GLIBC_PREREQ(2,4)
+ assert(r);
+# else
+ assert(!r);
+# endif
+
+ /* --------- pthread_cond_wait et al --------- */
+
+ fprintf(stderr,
+ "\n---------------- pthread_cond_wait et al ----------------\n\n");
+
+ /* make pthread_cond_wait fail. This is difficult. Our cunning
+ plan (tm) is to show up at pthread_cond_wait bearing a
+ not-locked mutex of the ERRORCHECK flavour and hope (as is
+ indeed the case with glibc-2.5) that pthread_cond_wait notices
+ it is not locked, and bounces our request. */
+ r= pthread_mutexattr_init( &mxa2 ); assert(!r);
+ r= pthread_mutexattr_settype( &mxa2, PTHREAD_MUTEX_ERRORCHECK );
+ assert(!r);
+ r= pthread_mutex_init( &mx4, &mxa2 ); assert(!r);
+ r= pthread_cond_init( &cv, NULL ); assert(!r);
+ r= pthread_cond_wait( &cv, &mx4 ); assert(r);
+ r= pthread_mutexattr_destroy( &mxa2 ); assert(!r);
+
+ /* make pthread_cond_signal fail. FIXME: can't figure out how
+ to */
+ r= pthread_cond_signal( &cv ); assert(!r);
+ fprintf(stderr, "\nFIXME: can't figure out how to "
+ "verify wrap of pthread_cond_signal\n\n");
+
+ /* make pthread_cond_broadcast fail. FIXME: can't figure out how
+ to */
+ r= pthread_cond_broadcast( &cv ); assert(!r);
+ fprintf(stderr, "\nFIXME: can't figure out how to "
+ "verify wrap of pthread_broadcast_signal\n\n");
+
+ /* make pthread_cond_timedwait fail. */
+ memset( &abstime, 0, sizeof(abstime) );
+ abstime.tv_nsec = 1000000000 + 1;
+ r= pthread_cond_timedwait( &cv, &mx4, &abstime ); assert(r);
+
+ /* --------- pthread_rwlock_* --------- */
+
+ fprintf(stderr,
+ "\n---------------- pthread_rwlock_* ----------------\n\n");
+
+ /* pthread_rwlock_init, pthread_rwlock_unlock */
+ /* pthread_rwlock_init: can't make glibc's implementation fail.
+ However, can demonstrate interceptedness by initialising but not
+ locking a lock and then unlocking it. Then the unlock call
+ should say "first seen at .. the init call." So this tests
+ wrappedness of both calls. */
+ r= pthread_rwlock_init( &rwl, NULL ); assert(!r);
+ r= pthread_rwlock_unlock( &rwl );
+ /* assert(r); *//* glibc doesn't complain. It really ought to. Oh well. */
+
+ /* We can infer the presence of wrapping for pthread_rwlock_rdlock,
+ pthread_rwlock_wrlock and pthread_rwlock_unlock by making
+ Thrcheck count the lockedness state, and warning when we unlock
+ a not-locked lock. Thusly: */
+ r= pthread_rwlock_init( &rwl2, NULL ); assert(!r);
+
+ /* w-lock it */
+ fprintf(stderr, "(1) no error on next line\n");
+ r= pthread_rwlock_wrlock( &rwl2 ); assert(!r);
+ /* unlock it */
+ fprintf(stderr, "(2) no error on next line\n");
+ r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
+ /* unlock it again, get an error */
+ fprintf(stderr, "(3) ERROR on next line\n");
+ r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
+
+ /* same game with r-locks */
+ r= pthread_rwlock_init( &rwl2, NULL ); assert(!r);
+ /* r-lock it twice */
+ fprintf(stderr, "(4) no error on next line\n");
+ r= pthread_rwlock_rdlock( &rwl2 ); assert(!r);
+ fprintf(stderr, "(5) no error on next line\n");
+ r= pthread_rwlock_rdlock( &rwl2 ); assert(!r);
+ /* unlock it twice */
+ fprintf(stderr, "(6) no error on next line\n");
+ r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
+ fprintf(stderr, "(7) no error on next line\n");
+ r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
+ /* unlock it again, get an error */
+ fprintf(stderr, "(8) ERROR on next line\n");
+ r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
+
+ /* Lock rwl3 so the locked-lock-at-dealloc check can complain about
+ it. */
+ r= pthread_rwlock_init( &rwl3, NULL ); assert(!r);
+ r= pthread_rwlock_rdlock( &rwl3 ); assert(!r);
+
+ /* ------------- sem_* ------------- */
+
+ /* This is pretty lame, and duplicates tc18_semabuse.c. */
+
+ fprintf(stderr,
+ "\n---------------- sem_* ----------------\n\n");
+
+ /* verifies wrap of sem_init */
+ /* Do sem_init with huge initial count - fails */
+ r= sem_init(&s1, 0, ~0); assert(r);
+
+ /* initialise properly */
+ r= sem_init(&s1, 0, 0);
+
+ /* in glibc, sem_destroy is a no-op; making it fail is
+ impossible. */
+ fprintf(stderr, "\nFIXME: can't figure out how to verify wrap of "
+ "sem_destroy\n\n");
+
+ /* verifies wrap of sem_wait */
+ /* Do 'wait' on a bogus semaphore. This should fail, but on glibc
+ it succeeds. */
+ memset(&s1, 0x55, sizeof(s1));
+ r= sem_wait(&s1); /* assert(r != 0); */
+
+ /* this really ought to fail, but it doesn't. */
+ r= sem_post(&s1); assert(!r);
+ fprintf(stderr, "\nFIXME: can't figure out how to verify wrap of "
+ "sem_post\n\n");
+
+ sem_destroy(&s1);
+
+ /* ------------- dealloc of mem holding locks ------------- */
+
+ fprintf(stderr,
+ "\n------------ dealloc of mem holding locks ------------\n\n");
+
+ /* At this point it should complain about deallocation
+ of memory containing locked locks:
+ rwl3
+ */
+
+ return 0;
+}
diff --git a/helgrind/tests/tc20_verifywrap.stderr.exp-glibc23-amd64 b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc23-amd64
new file mode 100644
index 0000000..df85c25
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc23-amd64
@@ -0,0 +1,134 @@
+
+
+
+------ This is output for < glibc 2.4 ------
+
+---------------- pthread_create/join ----------------
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:76)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: main (tc20_verifywrap.c:78)
+ Old state: owned exclusively by thread #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no locks at all
+
+Thread #1's call to pthread_join failed
+ with error code 35 (EDEADLK: Resource deadlock would occur)
+ at 0x........: pthread_join (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:83)
+
+---------------- pthread_mutex_lock et al ----------------
+
+
+Thread #1: pthread_mutex_destroy of a locked mutex
+ at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:102)
+
+Thread #1's call to pthread_mutex_destroy failed
+ with error code 16 (EBUSY: Device or resource busy)
+ at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:102)
+
+make pthread_mutex_lock fail: skipped on glibc < 2.4
+
+
+Thread #1 unlocked an invalid lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:125)
+
+---------------- pthread_cond_wait et al ----------------
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:147)
+
+Thread #1's call to pthread_cond_wait failed
+ with error code 1 (EPERM: Operation not permitted)
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:147)
+
+FIXME: can't figure out how to verify wrap of pthread_cond_signal
+
+
+FIXME: can't figure out how to verify wrap of pthread_broadcast_signal
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+ at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:165)
+
+Thread #1's call to pthread_cond_timedwait failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:165)
+
+---------------- pthread_rwlock_* ----------------
+
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:179)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:178)
+(1) no error on next line
+(2) no error on next line
+(3) ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:196)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:186)
+(4) no error on next line
+(5) no error on next line
+(6) no error on next line
+(7) no error on next line
+(8) ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:212)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:186)
+
+---------------- sem_* ----------------
+
+
+Thread #1's call to sem_init failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: sem_init@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:228)
+
+FIXME: can't figure out how to verify wrap of sem_destroy
+
+
+Thread #1: Bug in libpthread: sem_wait succeeded on semaphore without prior sem_post
+ at 0x........: sem_wait_WRK (hg_intercepts.c:...)
+ by 0x........: sem_wait (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:242)
+
+FIXME: can't figure out how to verify wrap of sem_post
+
+
+------------ dealloc of mem holding locks ------------
+
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: main (tc20_verifywrap.c:262)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:216)
+
+ERROR SUMMARY: 15 errors from 15 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-amd64 b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..0b399de
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-amd64
@@ -0,0 +1,156 @@
+
+
+
+------ This is output for >= glibc 2.4 ------
+
+---------------- pthread_create/join ----------------
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:76)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: main (tc20_verifywrap.c:78)
+ Old state: owned exclusively by thread #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no locks at all
+
+Thread #1's call to pthread_join failed
+ with error code 35 (EDEADLK: Resource deadlock would occur)
+ at 0x........: pthread_join (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:83)
+
+---------------- pthread_mutex_lock et al ----------------
+
+
+Thread #1's call to pthread_mutex_init failed
+ with error code 95 (EOPNOTSUPP: Operation not supported on transport endpoint)
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:92)
+
+Thread #1: pthread_mutex_destroy of a locked mutex
+ at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:102)
+
+Thread #1's call to pthread_mutex_destroy failed
+ with error code 16 (EBUSY: Device or resource busy)
+ at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:102)
+
+Thread #1's call to pthread_mutex_lock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:108)
+
+Thread #1's call to pthread_mutex_trylock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_trylock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:116)
+
+Thread #1's call to pthread_mutex_timedlock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_timedlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:121)
+
+Thread #1 unlocked an invalid lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:125)
+
+Thread #1's call to pthread_mutex_unlock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:125)
+
+---------------- pthread_cond_wait et al ----------------
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:147)
+
+Thread #1's call to pthread_cond_wait failed
+ with error code 1 (EPERM: Operation not permitted)
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:147)
+
+FIXME: can't figure out how to verify wrap of pthread_cond_signal
+
+
+FIXME: can't figure out how to verify wrap of pthread_broadcast_signal
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+ at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:165)
+
+Thread #1's call to pthread_cond_timedwait failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:165)
+
+---------------- pthread_rwlock_* ----------------
+
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:179)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:178)
+(1) no error on next line
+(2) no error on next line
+(3) ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:196)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:186)
+(4) no error on next line
+(5) no error on next line
+(6) no error on next line
+(7) no error on next line
+(8) ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:212)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:186)
+
+---------------- sem_* ----------------
+
+
+Thread #1's call to sem_init failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: sem_init@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:228)
+
+FIXME: can't figure out how to verify wrap of sem_destroy
+
+
+Thread #1: Bug in libpthread: sem_wait succeeded on semaphore without prior sem_post
+ at 0x........: sem_wait_WRK (hg_intercepts.c:...)
+ by 0x........: sem_wait (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:242)
+
+FIXME: can't figure out how to verify wrap of sem_post
+
+
+------------ dealloc of mem holding locks ------------
+
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: main (tc20_verifywrap.c:262)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:216)
+
+ERROR SUMMARY: 20 errors from 20 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-x86 b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..c44e998
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-x86
@@ -0,0 +1,155 @@
+
+
+
+------ This is output for >= glibc 2.4 ------
+
+---------------- pthread_create/join ----------------
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:76)
+
+Possible data race during write of size 2 at 0x........
+ at 0x........: main (tc20_verifywrap.c:78)
+ Old state: owned exclusively by thread #2
+ New state: shared-modified by threads #1, #2
+ Reason: this thread, #1, holds no locks at all
+
+Thread #1's call to pthread_join failed
+ with error code 35 (EDEADLK: Resource deadlock would occur)
+ at 0x........: pthread_join (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:83)
+
+---------------- pthread_mutex_lock et al ----------------
+
+
+Thread #1's call to pthread_mutex_init failed
+ with error code 95 (EOPNOTSUPP: Operation not supported on transport endpoint)
+ at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:92)
+
+Thread #1: pthread_mutex_destroy of a locked mutex
+ at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:102)
+
+Thread #1's call to pthread_mutex_destroy failed
+ with error code 16 (EBUSY: Device or resource busy)
+ at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:102)
+
+Thread #1's call to pthread_mutex_lock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:108)
+
+Thread #1's call to pthread_mutex_trylock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_trylock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:116)
+
+Thread #1's call to pthread_mutex_timedlock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_timedlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:121)
+
+Thread #1 unlocked an invalid lock at 0x........
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:125)
+
+Thread #1's call to pthread_mutex_unlock failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:125)
+
+---------------- pthread_cond_wait et al ----------------
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:147)
+
+Thread #1's call to pthread_cond_wait failed
+ with error code 1 (EPERM: Operation not permitted)
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:147)
+
+FIXME: can't figure out how to verify wrap of pthread_cond_signal
+
+
+FIXME: can't figure out how to verify wrap of pthread_broadcast_signal
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+ at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:165)
+
+Thread #1's call to pthread_cond_timedwait failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:165)
+
+---------------- pthread_rwlock_* ----------------
+
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:179)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:178)
+(1) no error on next line
+(2) no error on next line
+(3) ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:196)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:186)
+(4) no error on next line
+(5) no error on next line
+(6) no error on next line
+(7) no error on next line
+(8) ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........
+ at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:212)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:186)
+
+---------------- sem_* ----------------
+
+
+Thread #1's call to sem_init failed
+ with error code 22 (EINVAL: Invalid argument)
+ at 0x........: sem_init@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:228)
+
+FIXME: can't figure out how to verify wrap of sem_destroy
+
+
+Thread #1: Bug in libpthread: sem_wait succeeded on semaphore without prior sem_post
+ at 0x........: sem_wait_WRK (hg_intercepts.c:...)
+ by 0x........: sem_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:242)
+
+FIXME: can't figure out how to verify wrap of sem_post
+
+
+------------ dealloc of mem holding locks ------------
+
+
+Thread #1 deallocated location 0x........ containing a locked lock
+ at 0x........: main (tc20_verifywrap.c:261)
+ Lock at 0x........ was first observed
+ at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+ by 0x........: main (tc20_verifywrap.c:216)
+
+ERROR SUMMARY: 20 errors from 20 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc20_verifywrap.stdout.exp b/helgrind/tests/tc20_verifywrap.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.stdout.exp
diff --git a/helgrind/tests/tc20_verifywrap.vgtest b/helgrind/tests/tc20_verifywrap.vgtest
new file mode 100644
index 0000000..bc61bd6
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.vgtest
@@ -0,0 +1 @@
+prog: tc20_verifywrap
diff --git a/helgrind/tests/tc21_pthonce.c b/helgrind/tests/tc21_pthonce.c
new file mode 100644
index 0000000..69fac76
--- /dev/null
+++ b/helgrind/tests/tc21_pthonce.c
@@ -0,0 +1,96 @@
+
+/* This really exists to check that Thrcheck behaves plausibly
+ with pthread_once calls. Which it appears to.
+
+ The original source of this program is as shown below, although it
+ has been modified somewhat. See
+ http://www.oreilly.com/pub/a/oreilly/ask_tim/2001/codepolicy.html
+ for OReilly's policy on using bits of their code examples.
+*/
+
+
+/********************************************************
+ * An example source module to accompany...
+ *
+ * "Using POSIX Threads: Programming with Pthreads"
+ * by Brad Nichols, Dick Buttlar, Jackie Farrell
+ * O'Reilly & Associates, Inc.
+ *
+ ********************************************************
+ * once_exam.c
+ *
+ * An example of using the pthreads_once() call to execute an
+ * initialization procedure.
+ *
+ * A program spawns multiple threads and each one tries to
+ * execute the routine welcome() using the once call. Only
+ * the first thread into the once routine will actually
+ * execute welcome().
+ *
+ * The program's main thread synchronizes its exit with the
+ * exit of the threads using the pthread_join() operation.
+ *
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <assert.h>
+
+#include <pthread.h>
+
+/* With more than 2 threads, the precise error reports vary between
+ platforms, in terms of the number of races detected. Make life
+ simple and just have 2 threads and so just 1 race. */
+#define NUM_THREADS 2
+
+static pthread_once_t welcome_once_block = PTHREAD_ONCE_INIT;
+
+static int unprotected1 = 0;
+static int unprotected2 = 0;
+
+/* This is a hack: delay threads except the first enough so as to
+ ensure threads[0] gets to the pthread_once call first. This is so
+ as to ensure that this test produces results which aren't
+ scheduling sensitive. (sigh) */
+void maybe_stall ( int myid )
+{
+ assert(myid >= 0 && myid < NUM_THREADS);
+ if (myid > 0)
+ sleep(1);
+}
+
+void welcome(void) {
+ printf("welcome: Welcome\n");
+ unprotected1++; /* this is harmless */
+}
+
+void* child ( void* argV ) {
+ int r;
+ maybe_stall( *(int*)argV );
+ r= pthread_once(&welcome_once_block, welcome); assert(!r);
+ printf("child: Hi, I'm thread %d\n", *(int*)argV);
+ unprotected2++; /* whereas this is a race */
+ return NULL;
+}
+
+int main ( void ) {
+ int *id_arg, i, r;
+ pthread_t threads[NUM_THREADS];
+
+ id_arg = (int *)malloc(NUM_THREADS*sizeof(int));
+
+ for (i = 0; i < NUM_THREADS; i++) {
+ id_arg[i] = i;
+ r= pthread_create(&threads[i], NULL, child, &id_arg[i]);
+ assert(!r);
+ }
+
+ for (i = 0; i < NUM_THREADS; i++) {
+ pthread_join(threads[i], NULL);
+ /* printf("main: joined to thread %d\n", i); */
+ }
+ printf("main: Goodbye\n");
+ return 0;
+}
diff --git a/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-amd64 b/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..4d0fd44
--- /dev/null
+++ b/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-amd64
@@ -0,0 +1,26 @@
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc21_pthonce.c:86)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc21_pthonce.c:86)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child (tc21_pthonce.c:74)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: shared-readonly by threads #2, #3
+ New state: shared-modified by threads #2, #3
+ Reason: this thread, #3, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-x86 b/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..f0b58a3
--- /dev/null
+++ b/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-x86
@@ -0,0 +1,24 @@
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc21_pthonce.c:86)
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc21_pthonce.c:86)
+
+Possible data race during write of size 4 at 0x........
+ at 0x........: child (tc21_pthonce.c:74)
+ by 0x........: mythread_wrapper (hg_intercepts.c:...)
+ by 0x........: ...
+ by 0x........: ...
+ Old state: shared-readonly by threads #2, #3
+ New state: shared-modified by threads #2, #3
+ Reason: this thread, #3, holds no consistent locks
+ Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc21_pthonce.stdout.exp b/helgrind/tests/tc21_pthonce.stdout.exp
new file mode 100644
index 0000000..e6c2dc2
--- /dev/null
+++ b/helgrind/tests/tc21_pthonce.stdout.exp
@@ -0,0 +1,4 @@
+welcome: Welcome
+child: Hi, I'm thread 0
+child: Hi, I'm thread 1
+main: Goodbye
diff --git a/helgrind/tests/tc21_pthonce.vgtest b/helgrind/tests/tc21_pthonce.vgtest
new file mode 100644
index 0000000..d9b9a81
--- /dev/null
+++ b/helgrind/tests/tc21_pthonce.vgtest
@@ -0,0 +1 @@
+prog: tc21_pthonce
diff --git a/helgrind/tests/tc22_exit_w_lock.c b/helgrind/tests/tc22_exit_w_lock.c
new file mode 100644
index 0000000..d40600e
--- /dev/null
+++ b/helgrind/tests/tc22_exit_w_lock.c
@@ -0,0 +1,50 @@
+
+#include <pthread.h>
+#include <unistd.h>
+#include <assert.h>
+#include <signal.h>
+
+/* Should see 3 threads exiting in different ways, all holding one (or
+ two) locks. */
+
+pthread_mutex_t mxC1 = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mxC2 = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mxC2b = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mxP = PTHREAD_MUTEX_INITIALIZER;
+
+/* This one exits in the normal way, by joining back */
+void* child_fn1 ( void* arg )
+{
+ int r= pthread_mutex_lock( &mxC1 ); assert(!r);
+ return NULL;
+}
+
+/* This one detaches, does its own thing. */
+void* child_fn2 ( void* arg )
+{
+ int r;
+ r= pthread_mutex_lock( &mxC2 ); assert(!r);
+ r= pthread_mutex_lock( &mxC2b ); assert(!r);
+ r= pthread_detach( pthread_self() ); assert(!r);
+ return NULL;
+}
+
+/* Parent creates 2 children, takes a lock, waits, segfaults. Use
+ sleeps to enforce exit ordering, for repeatable regtesting. */
+int main ( void )
+{
+ int r;
+ pthread_t child1, child2;
+
+ r= pthread_create(&child2, NULL, child_fn2, NULL); assert(!r);
+ sleep(1);
+
+ r= pthread_create(&child1, NULL, child_fn1, NULL); assert(!r);
+ r= pthread_join(child1, NULL); assert(!r);
+ sleep(1);
+
+ r= pthread_mutex_lock( &mxP );
+
+ kill( getpid(), SIGABRT );
+ return 0;
+}
diff --git a/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-amd64 b/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..f0eb6b6
--- /dev/null
+++ b/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-amd64
@@ -0,0 +1,30 @@
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc22_exit_w_lock.c:39)
+
+Thread #2: Exiting thread still holds 2 locks
+ at 0x........: start_thread (in /lib/libpthread...)
+ by 0x........: ...
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: ...
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc22_exit_w_lock.c:42)
+
+Thread #3: Exiting thread still holds 1 lock
+ at 0x........: start_thread (in /lib/libpthread...)
+ by 0x........: ...
+
+Thread #1 is the program's root thread
+
+Thread #1: Exiting thread still holds 1 lock
+ at 0x........: kill (in /...libc...)
+ by 0x........: main (tc22_exit_w_lock.c:48)
+
+ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-x86 b/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..bc07725
--- /dev/null
+++ b/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-x86
@@ -0,0 +1,28 @@
+
+Thread #2 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc22_exit_w_lock.c:39)
+
+Thread #2: Exiting thread still holds 2 locks
+ at 0x........: start_thread (in /lib/libpthread...)
+ by 0x........: ...
+
+Thread #3 was created
+ at 0x........: clone (in /...libc...)
+ by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+ by 0x........: pthread_create@* (hg_intercepts.c:...)
+ by 0x........: main (tc22_exit_w_lock.c:42)
+
+Thread #3: Exiting thread still holds 1 lock
+ at 0x........: start_thread (in /lib/libpthread...)
+ by 0x........: ...
+
+Thread #1 is the program's root thread
+
+Thread #1: Exiting thread still holds 1 lock
+ at 0x........: kill (in /...libc...)
+ by 0x........: (below main) (in /...libc...)
+
+ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc22_exit_w_lock.stdout.exp b/helgrind/tests/tc22_exit_w_lock.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc22_exit_w_lock.stdout.exp
diff --git a/helgrind/tests/tc22_exit_w_lock.vgtest b/helgrind/tests/tc22_exit_w_lock.vgtest
new file mode 100644
index 0000000..4f85dd5
--- /dev/null
+++ b/helgrind/tests/tc22_exit_w_lock.vgtest
@@ -0,0 +1 @@
+prog: tc22_exit_w_lock
diff --git a/helgrind/tests/tc23_bogus_condwait.c b/helgrind/tests/tc23_bogus_condwait.c
new file mode 100644
index 0000000..a0fad5d
--- /dev/null
+++ b/helgrind/tests/tc23_bogus_condwait.c
@@ -0,0 +1,86 @@
+
+/* Expect 5 errors total (4 re cvs, 1 re exiting w/lock.).
+ Tests passing bogus mutexes to pthread_cond_wait. */
+#define _GNU_SOURCE 1 /* needed by glibc <= 2.3 for pthread_rwlock_* */
+#include <pthread.h>
+#include <assert.h>
+#include <unistd.h>
+#include <semaphore.h>
+
+pthread_mutex_t mx[4];
+pthread_cond_t cv;
+pthread_rwlock_t rwl;
+
+sem_t quit_now;
+
+void* rescue_me ( void* uu )
+{
+ /* wait for, and unblock, the first wait */
+ sleep(1);
+ pthread_cond_signal( &cv );
+
+ /* wait for, and unblock, the second wait */
+ sleep(1);
+ pthread_cond_signal( &cv );
+
+ /* wait for, and unblock, the third wait */
+ sleep(1);
+ pthread_cond_signal( &cv );
+
+ /* wait for, and unblock, the fourth wait */
+ sleep(1);
+ pthread_cond_signal( &cv );
+
+ sem_wait( &quit_now );
+ return NULL;
+}
+
+void* grab_the_lock ( void* uu )
+{
+ int r= pthread_mutex_lock( &mx[2] ); assert(!r);
+ sem_wait( &quit_now );
+ r= pthread_mutex_unlock( &mx[2] ); assert(!r);
+ return NULL;
+}
+
+int main ( void )
+{
+ int r;
+ pthread_t my_rescuer, grabber;
+
+ r= pthread_mutex_init(&mx[0], NULL); assert(!r);
+ r= pthread_mutex_init(&mx[1], NULL); assert(!r);
+ r= pthread_mutex_init(&mx[2], NULL); assert(!r);
+ r= pthread_mutex_init(&mx[3], NULL); assert(!r);
+
+ r= pthread_cond_init(&cv, NULL); assert(!r);
+ r= pthread_rwlock_init(&rwl, NULL); assert(!r);
+
+ r= sem_init( &quit_now, 0,0 ); assert(!r);
+
+ r= pthread_create( &grabber, NULL, grab_the_lock, NULL ); assert(!r);
+ sleep(1); /* let the grabber get there first */
+
+ r= pthread_create( &my_rescuer, NULL, rescue_me, NULL ); assert(!r);
+ /* Do stupid things and hope that rescue_me gets us out of
+ trouble */
+
+ /* mx is bogus */
+ r= pthread_cond_wait(&cv, (pthread_mutex_t*)(1 + (char*)&mx[0]) );
+
+ /* mx is not locked */
+ r= pthread_cond_wait(&cv, &mx[0]);
+
+ /* wrong flavour of lock */
+ r= pthread_cond_wait(&cv, (pthread_mutex_t*)&rwl );
+
+ /* mx is held by someone else. */
+ r= pthread_cond_wait(&cv, &mx[2] );
+
+ r= sem_post( &quit_now ); assert(!r);
+ r= sem_post( &quit_now ); assert(!r);
+
+ r= pthread_join( my_rescuer, NULL ); assert(!r);
+ r= pthread_join( grabber, NULL ); assert(!r);
+ return 0;
+}
diff --git a/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-amd64 b/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..2bb66de
--- /dev/null
+++ b/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-amd64
@@ -0,0 +1,20 @@
+
+Thread #1 is the program's root thread
+
+Thread #1: pthread_cond_{timed}wait called with invalid mutex
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc23_bogus_condwait.c:69)
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc23_bogus_condwait.c:72)
+
+Thread #1: pthread_cond_{timed}wait called with mutex of type pthread_rwlock_t*
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc23_bogus_condwait.c:75)
+
+Thread #1: pthread_cond_{timed}wait called with mutex held by a different thread
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc23_bogus_condwait.c:78)
+
+ERROR SUMMARY: 4 errors from 4 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-x86 b/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..2bb66de
--- /dev/null
+++ b/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-x86
@@ -0,0 +1,20 @@
+
+Thread #1 is the program's root thread
+
+Thread #1: pthread_cond_{timed}wait called with invalid mutex
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc23_bogus_condwait.c:69)
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc23_bogus_condwait.c:72)
+
+Thread #1: pthread_cond_{timed}wait called with mutex of type pthread_rwlock_t*
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc23_bogus_condwait.c:75)
+
+Thread #1: pthread_cond_{timed}wait called with mutex held by a different thread
+ at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+ by 0x........: main (tc23_bogus_condwait.c:78)
+
+ERROR SUMMARY: 4 errors from 4 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc23_bogus_condwait.stdout.exp b/helgrind/tests/tc23_bogus_condwait.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc23_bogus_condwait.stdout.exp
diff --git a/helgrind/tests/tc23_bogus_condwait.vgtest b/helgrind/tests/tc23_bogus_condwait.vgtest
new file mode 100644
index 0000000..31c3ed8
--- /dev/null
+++ b/helgrind/tests/tc23_bogus_condwait.vgtest
@@ -0,0 +1 @@
+prog: tc23_bogus_condwait