From: Julian Seward Date: Fri, 9 Nov 2007 22:49:28 +0000 (+0000) Subject: Import thrcheck from the THRCHECK branch, and rename it Helgrind (with X-Git-Tag: svn/VALGRIND_3_3_0~173 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6109e89b04a5da3610c8bfa01472bd99d3e0c3af;p=thirdparty%2Fvalgrind.git 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 --- diff --git a/helgrind/Makefile.am b/helgrind/Makefile.am new file mode 100644 index 0000000000..4a9d93d7e4 --- /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 0000000000..84f630f974 --- /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 0000000000..5090cfc2ee --- /dev/null +++ b/helgrind/docs/hg-manual.xml @@ -0,0 +1,1311 @@ + + + + + + Thrcheck: a thread error detector + +To use this tool, you must specify +--tool=thrcheck on the Valgrind +command line. + + + + + +Overview + +Thrcheck is a Valgrind tool for detecting synchronisation errors +in C, C++ and Fortran programs that use the POSIX pthreads +threading primitives. + +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. + +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. + + +Thrcheck can detect three classes of errors, which are discussed +in detail in the next three sections: + + + + + Misuses of the POSIX pthreads API. + + + + Potential deadlocks arising from lock + ordering problems. + + + + Data races -- accessing memory without adequate locking. + + + + +Following those is a section containing + +hints and tips on how to get the best out of Thrcheck. + + +Then there is a +summary of command-line +options. + + +Finally, there is +a brief summary of areas in which Thrcheck +could be improved. + + + + + + + + +Detected errors: Misuses of the POSIX pthreads API + +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: + + + unlocking an invalid mutex + unlocking a not-locked mutex + unlocking a mutex held by a different + thread + destroying an invalid or a locked mutex + recursively locking a non-recursive mutex + deallocation of memory that contains a + locked mutex + passing mutex arguments to functions expecting + reader-writer lock arguments, and vice + versa + when a POSIX pthread function fails with an + error code that must be handled + when a thread exits whilst still holding locked + locks + calling pthread_cond_wait + with a not-locked mutex, or one locked by a different + thread + + +Checks pertaining to the validity of mutexes are generally also +performed for reader-writer locks. + +Various kinds of this-can't-possibly-happen events are also +reported. These usually indicate bugs in the system threading +library. + +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 "was first observed +at" part), so you have a chance of figuring out which +mutex it is referring to. For example: + + + +Thrcheck has a way of summarising thread identities, as +evidenced here by the text "Thread +#1". This is so that it can speak about threads and +sets of threads without overwhelming you with details. See +below +for more information on interpreting error messages. + + + + + + + +Detected errors: Inconsistent Lock Orderings + +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. + +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. + +The simplest example of such a problem is as +follows. + + + 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. + + 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. + + 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. + + + +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. + +In simple situations, where the cycle only contains two locks, +Thrcheck will show where the required order was established: + + + +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 thrcheck/tests/tc14_laog_dinphils.c). +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. + + + + + + + + + +Detected errors: Data Races + +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. + +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. + + + +A Simple Data Race + +About the simplest possible example of a race is as follows. In +this program, it is impossible to know what the value +of var is at the end of the program. +Is it 2 ? Or 1 ? + + + +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; +} +]]> + +The problem is there is nothing to +stop var being updated simultaneously +by both threads. A correct program would +protect var with a lock of type +pthread_mutex_t, which is acquired +before each access and released afterwards. Thrcheck's output for +this program is: + + + +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 var, +happening in function main at line 13 +in the program. + +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 +var without a lock that an error +exists. + +The error message shows some other interesting details. The +sections below explain them. Here we merely note their presence: + + + Thrcheck maintains some kind of state machine for the + memory location in question, hence the "Old + state:" and "New + state:" lines. + + Thrcheck keeps track of which threads have accessed + the location: "threads #1, #2". + 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. + + Thrcheck tries to provide an explaination of why the + race exists: "Location 0x601034 has never been + protected by any lock". + + + +Understanding the memory state machine is central to +understanding Thrcheck's race-detection algorithm. The next three +subsections explain this. + + + + + +Thrcheck's Memory State Machine + +Thrcheck tracks the state of every byte of memory used by your +program. There are a number of states, but only three are +interesting: + + + 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. + + 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. + + 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. + + + +Let's review the simple example above with this in mind. When +the program starts, var is not in any +of these states. Either the parent or child thread gets to its +var++ first, and thereby +thereby gets Exclusive ownership of the location. + +The later-running thread now arrives at +its var++ statement. It first reads +the existing value from memory. +Because var is currently marked as +owned exclusively by the other thread, its state is changed to +shared-readonly by both threads. + +This same thread adds one to the value it has and stores it back +in var. 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 +var 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. + +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. + +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). + +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 +summary of the complete +algorithm used by Thrcheck is presented below. First, however, +it is important to understand details of transitions pertaining to the +Exclusive-ownership state. + + + + + + +Transfers of Exclusive Ownership Between Threads + +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. + +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. + +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: + + + +Although buf 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 buf to happen +after the parent initialises buf, and +before the parent reads the results +from buf. + +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 buf is transferred from parent to +child and back, so the basic algorithm does not report any races +despite the absence of any locking. + +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. + +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: + + + At thread creation: a child can acquire ownership of + memory held exclusively by the parent prior to the child's + creation. + + 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. + + 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. + + 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. + + + + + + + + +Restoration of Exclusive Ownership + +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: + + + +This program is correct, but using only the mechanisms described +so far, Thrcheck would report an error at +var += 4. This is because, by that +point, var is marked as being in the +state "shared-modified and protected by the +lock mx", but is being accessed +without locking. Really, what we want is +for var to return to the parent +thread's exclusive ownership after the child thread has exited. + +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. + +In our example, the result is exactly as we desire: +var is reacquired exclusively by the +parent after the child exits. + +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. + + + + + + +A Summary of the Race Detection Algorithm + +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. + +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: + +The following thread events are intercepted and monitored: + + + thread creation and exiting (pthread_create, + pthread_join, pthread_exit) + + + lock acquisition and release (pthread_mutex_lock, + pthread_mutex_unlock, pthread_rwlock_rdlock, + pthread_rwlock_wrlock, + pthread_rwlock_unlock) + + + inter-thread event notifications (pthread_cond_wait, + pthread_cond_signal, pthread_cond_broadcast, + sem_wait, sem_post) + + + +Memory allocation and deallocation events are intercepted and +monitored: + + + + malloc/new/free/delete and variants + + + stack allocation and deallocation + + + +All memory accesses are intercepted and monitored. + +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: + + + + + A thread may allocate memory, and write initial values into + it, without locking. That thread is regarded as owning the memory + exclusively. + + + A thread may read and write memory which it owns exclusively, + without locking. + + + 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). + + + 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. + + + +Any violation of this discipline will cause an error to be reported. +However, two exemptions apply: + + + + 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: + + X creates thread Y + X joins back to Y + X uses a condition-variable to signal at Y, and Y is + waiting for that event + Y completes a semaphore wait as a result of X signalling + on that same semaphore + + + 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). + + + 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. + + 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. + + + +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. + +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. + +Thrcheck correctly handles POSIX mutexes for which recursive +locking is allowed. + +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. + + + + + + +Interpreting Race Error Messages + +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: + + + +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. + +The main error message begins at the text +"Possible data race during read". +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. + +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. + +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. + +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. + + + +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. + + + +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. + + + +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. + +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. + +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 +above +for a discussion of transfers of exclusive ownership states between +threads. + + + + + + + +Hints and Tips for Effective Use of Thrcheck + +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. + +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. + +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. + + + + + + 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. + + 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. + + 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. + + 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. + + At the time of writing, the following popular Linux packages + are known to implement their own threading primitives: + + + 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. + + 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. + + + + + 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 thrcheck.h). + + 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. + + 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. + + + + 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. + + 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. + + 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. + + 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: + + + + Assume b 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. + + If the signaller arrives + first, b 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 b 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. + + By comparison, Thrcheck's detection of inter-thread + dependencies caused by semaphore operations is believed to be + exactly correct. + + 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. + + + + 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. + + 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. + + + + 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. + + 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 as described + extensively above, which helps Thrcheck produce more + accurate error reports. + + 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. + + + + Perform thread debugging (with Thrcheck) and memory + debugging (with Memcheck) together. + + 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. + + 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. + + 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. + + + + 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. + + 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. + + + + Thrcheck's error checks do not work properly inside the + system threading library itself + (libpthread.so), 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. + + If you see any race errors reported + where libpthread.so or + ld.so is the object associated + with the innermost stack frame, please file a bug report at + http://www.valgrind.org. + + + + + + + + + + +Thrcheck Options + +The following end-user options are available: + + + + + + + + + + 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 above + for a discussion of transfers of exclusive ownership states + between threads. + + With --happens-before=all, the + following events are regarded as sources of synchronisation: + thread creation/joinage, condition variable + signal/broadcast/waits, and semaphore posts/waits. + + With --happens-before=threads, only + thread creation/joinage events are regarded as sources of + synchronisation. + + With --happens-before=none, no events + (apart, of course, from locking) are regarded as sources of + synchronisation. + + Changing this setting from the default will increase your + false-error rate but give little or no gain. The only advantage + is that and + should make Thrcheck + less and less sensitive to the scheduling of threads, and hence + the output more and more repeatable across runs. + + + + + + + and + + + + Requests that Thrcheck produces a log of all state changes + to location 0xXXYYZZ. This can be helpful in tracking down + tricky races. --trace-level 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. + + + + + + + +In addition, the following debugging options are available for +Thrcheck: + + + + + + + + + Show all client malloc (etc) and free (etc) requests. + + + + + + + + + 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: + valgrind --tool=thrcheck + --gen-vcg=yes my_app 2>&1 + | grep xxxxxx | sed "s/xxxxxx//g" + | xvcg - + With --gen-vcg=yes, the basic + happens-before graph is shown. With + --gen-vcg=yes-w-vts, the vector timestamp + for each node is also shown. + + + + + + + + + Controls whether or not race (data) addresses should be + taken into account when removing duplicates of race errors. + With --cmp-race-err-addrs=no, two otherwise + identical race errors will be considered to be the same if + their race addresses differ. With + With --cmp-race-err-addrs=yes they will be + considered different. This is provided to help make certain + regression tests work reliably. + + + + + + + + + Run extensive sanity checks on Thrcheck's internal + data structures at events defined by the bitstring, as + follows: + 10000 after changes to + the lock order acquisition graph + 01000 after every client + memory access (NB: not currently used) + 00100 after every client + memory range permission setting of 256 bytes or greater + 00010 after every client + lock or unlock event + 00001 after every client + thread creation or joinage event + Note these will make Thrcheck run very slowly, often to + the point of being completely unusable. + + + + + + + + + + +A To-Do List for Thrcheck + +The following is a list of loose ends which should be tidied up +some time. + + + Track which mutexes are associated with which + condition variables, and emit a warning if this becomes + inconsistent. + + For lock order errors, print the complete lock + cycle, rather than only doing for size-2 cycles as at + present. + + Document the VALGRIND_HG_CLEAN_MEMORY client + request. + + Possibly a client request to forcibly transfer + ownership of memory from one thread to another. Requires further + consideration. + + 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. + + Document races caused by gcc's thread-unsafe code + generation for speculative stores. In the interim see + http://gcc.gnu.org/ml/gcc/2007-10/msg00266.html + + and http://lkml.org/lkml/2007/10/24/673. + + + 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. + + Performance can be very poor. Slowdowns on the + order of 100:1 are not unusual. There is quite some scope for + performance improvements, though. + + + + + + + + diff --git a/helgrind/helgrind.h b/helgrind/helgrind.h new file mode 100644 index 0000000000..b2f6ed3e25 --- /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 0000000000..10be82b9b0 --- /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 +#include +#include +#include + + +/* 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 + +#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 0000000000..0a97571247 --- /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<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= 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 0000000000..b839a38ede --- /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 0000000000..cd8f5420ca --- /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 0000000000..ed9a5b8b21 --- /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 0000000000..5c40ef44ad --- /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 0000000000..ac84a96721 --- /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 0000000000..f2b45d7d9a --- /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 0000000000..144ce608d1 --- /dev/null +++ b/helgrind/tests/hg01_all_ok.c @@ -0,0 +1,32 @@ +/* All OK */ + +#include + +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 0000000000..d18786f806 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/hg01_all_ok.vgtest b/helgrind/tests/hg01_all_ok.vgtest new file mode 100644 index 0000000000..952497636f --- /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 0000000000..1142f5cfe9 --- /dev/null +++ b/helgrind/tests/hg02_deadlock.c @@ -0,0 +1,43 @@ +/* Simple possible deadlock */ +#include + +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 0000000000..8fe4ea458d --- /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 0000000000..6f7fa48936 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/hg02_deadlock.vgtest b/helgrind/tests/hg02_deadlock.vgtest new file mode 100644 index 0000000000..ff0deb7ca8 --- /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 0000000000..7c429f838f --- /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 +#include +#include + +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 0000000000..3cf4b5e7e4 --- /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 0000000000..a7e4407329 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/hg03_inherit.vgtest b/helgrind/tests/hg03_inherit.vgtest new file mode 100644 index 0000000000..b3ac0395a7 --- /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 0000000000..111195bf90 --- /dev/null +++ b/helgrind/tests/hg04_race.c @@ -0,0 +1,27 @@ +/* A simple race */ + +#include +#include + +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 0000000000..6ec1ac387b --- /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 0000000000..3d28bd8e80 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/hg04_race.vgtest b/helgrind/tests/hg04_race.vgtest new file mode 100644 index 0000000000..92b709963f --- /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 0000000000..de01f2c490 --- /dev/null +++ b/helgrind/tests/hg05_race2.c @@ -0,0 +1,35 @@ +/* A simple race - test symaddr */ + +#include +#include + +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 0000000000..b6dc2e9592 --- /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 0000000000..285efeba23 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/hg05_race2.vgtest b/helgrind/tests/hg05_race2.vgtest new file mode 100644 index 0000000000..a93db5e75d --- /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 0000000000..3904b44bb1 --- /dev/null +++ b/helgrind/tests/hg06_readshared.c @@ -0,0 +1,33 @@ +/* All OK - test allowed read sharing */ + +#include +#include + +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 0000000000..d18786f806 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/hg06_readshared.vgtest b/helgrind/tests/hg06_readshared.vgtest new file mode 100644 index 0000000000..c5acceef5f --- /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 0000000000..abf37b543c --- /dev/null +++ b/helgrind/tests/tc01_simple_race.c @@ -0,0 +1,36 @@ + +#include +#include +#include + +/* 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 0000000000..a5b31c362c --- /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 0000000000..ba37641e30 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc01_simple_race.vgtest b/helgrind/tests/tc01_simple_race.vgtest new file mode 100644 index 0000000000..44f3045cce --- /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 0000000000..a23b14c172 --- /dev/null +++ b/helgrind/tests/tc02_simple_tls.c @@ -0,0 +1,39 @@ + +#include +#include +#include + +/* 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 0000000000..d18786f806 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc02_simple_tls.vgtest b/helgrind/tests/tc02_simple_tls.vgtest new file mode 100644 index 0000000000..57db35c0bc --- /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 0000000000..4f3ce51270 --- /dev/null +++ b/helgrind/tests/tc03_re_excl.c @@ -0,0 +1,44 @@ + +#include +#include +#include + +/* 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 0000000000..d18786f806 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc03_re_excl.vgtest b/helgrind/tests/tc03_re_excl.vgtest new file mode 100644 index 0000000000..e12924a8a1 --- /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 0000000000..c1ffa254a6 --- /dev/null +++ b/helgrind/tests/tc04_free_lock.c @@ -0,0 +1,50 @@ + +#include +#include +#include +#include + +/* 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 0000000000..b14e3b64c4 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc04_free_lock.vgtest b/helgrind/tests/tc04_free_lock.vgtest new file mode 100644 index 0000000000..27d28bf29e --- /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 0000000000..287c12c48d --- /dev/null +++ b/helgrind/tests/tc05_simple_race.c @@ -0,0 +1,44 @@ + +#include +#include +#include + +/* 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 0000000000..8c15d1ace1 --- /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 0000000000..fb6dccf8e1 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc05_simple_race.vgtest b/helgrind/tests/tc05_simple_race.vgtest new file mode 100644 index 0000000000..27f388110a --- /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 0000000000..65c83efcc9 --- /dev/null +++ b/helgrind/tests/tc06_two_races.c @@ -0,0 +1,43 @@ + +#include +#include +#include + +/* 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 0000000000..db74a7001f --- /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 0000000000..34874fcaa8 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc06_two_races.vgtest b/helgrind/tests/tc06_two_races.vgtest new file mode 100644 index 0000000000..f6f5247971 --- /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 0000000000..58e6564cd7 --- /dev/null +++ b/helgrind/tests/tc07_hbl1.c @@ -0,0 +1,77 @@ + +#include +#include +#include + +/* 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 0000000000..d18786f806 --- /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 0000000000..407de3068e --- /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 0000000000..71c463f810 --- /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 0000000000..5362faae41 --- /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 +#include +#include +#include + +/* 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 0000000000..d18786f806 --- /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 0000000000..ce39ad5871 --- /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 0000000000..6d0a2cb773 --- /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 0000000000..bb44eb3562 --- /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 +#include +#include + +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 0000000000..dc6bf41550 --- /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 0000000000..e851dc2937 --- /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 0000000000..84601c4797 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc09_bad_unlock.vgtest b/helgrind/tests/tc09_bad_unlock.vgtest new file mode 100644 index 0000000000..d09a702ecb --- /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 0000000000..648305cd7c --- /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 +#include +#include +#include + +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 0000000000..a301ee7d70 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc10_rec_lock.vgtest b/helgrind/tests/tc10_rec_lock.vgtest new file mode 100644 index 0000000000..bfd0f89601 --- /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 0000000000..5b46c7ed80 --- /dev/null +++ b/helgrind/tests/tc11_XCHG.c @@ -0,0 +1,92 @@ + +#include +#include +#include +#include + +/* 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 0000000000..d18786f806 --- /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 0000000000..2e9ba477f8 --- /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 0000000000..342199b011 --- /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 0000000000..9dc8e84294 --- /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 +#include +#include + +/* 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 0000000000..cbc403eb48 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc12_rwl_trivial.vgtest b/helgrind/tests/tc12_rwl_trivial.vgtest new file mode 100644 index 0000000000..fdcd6446eb --- /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 0000000000..e42ca985f9 --- /dev/null +++ b/helgrind/tests/tc13_laog1.c @@ -0,0 +1,33 @@ + +#include +#include +#include +#include + +/* 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 0000000000..74aa263e20 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc13_laog1.vgtest b/helgrind/tests/tc13_laog1.vgtest new file mode 100644 index 0000000000..9fa71cd895 --- /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 0000000000..c5af8c1078 --- /dev/null +++ b/helgrind/tests/tc14_laog_dinphils.c @@ -0,0 +1,42 @@ + +#include +#include +#include + +/* 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 0000000000..5cedeb8f18 --- /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 0000000000..c4db6cf5e0 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc14_laog_dinphils.vgtest b/helgrind/tests/tc14_laog_dinphils.vgtest new file mode 100644 index 0000000000..5871b73382 --- /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 0000000000..ff0160549e --- /dev/null +++ b/helgrind/tests/tc15_laog_lockdel.c @@ -0,0 +1,68 @@ + +#include +#include +#include +#include + +/* 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 0000000000..4bab3042e8 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc15_laog_lockdel.vgtest b/helgrind/tests/tc15_laog_lockdel.vgtest new file mode 100644 index 0000000000..bd7a2ecd07 --- /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 0000000000..1916c37fbd --- /dev/null +++ b/helgrind/tests/tc16_byterace.c @@ -0,0 +1,42 @@ +#include +#include +#include + +/* 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 0000000000..e4286bcdad --- /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 0000000000..d7ffb0ad9e --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc16_byterace.vgtest b/helgrind/tests/tc16_byterace.vgtest new file mode 100644 index 0000000000..a8bf0f1f30 --- /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 0000000000..01af962f17 --- /dev/null +++ b/helgrind/tests/tc17_sembar.c @@ -0,0 +1,212 @@ + +#include +#include +#include +#include +#include + +/* 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 . + + 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 0000000000..3600221e93 --- /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 0000000000..7675dbb124 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc17_sembar.vgtest b/helgrind/tests/tc17_sembar.vgtest new file mode 100644 index 0000000000..643ed8ab3b --- /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 0000000000..6e26ce411d --- /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 +#include +#include +#include +#include +#include + +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 0000000000..f0519c0323 --- /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 0000000000..82f30d4ac8 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc18_semabuse.vgtest b/helgrind/tests/tc18_semabuse.vgtest new file mode 100644 index 0000000000..fe4d22ba17 --- /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 0000000000..d652fa928e --- /dev/null +++ b/helgrind/tests/tc19_shadowmem.c @@ -0,0 +1,2291 @@ + +#include +#include +#include +#include + +#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 0000000000..8f83732f36 --- /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 0000000000..efa673066b --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc19_shadowmem.vgtest b/helgrind/tests/tc19_shadowmem.vgtest new file mode 100644 index 0000000000..233e8e4d70 --- /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 0000000000..81ea512bcf --- /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 +#include +#include +#include +#include +#include + +#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 0000000000..df85c2588a --- /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 0000000000..0b399dece2 --- /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 0000000000..c44e998fc2 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc20_verifywrap.vgtest b/helgrind/tests/tc20_verifywrap.vgtest new file mode 100644 index 0000000000..bc61bd6528 --- /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 0000000000..69fac769f4 --- /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 +#include +#include +#include +#include + +#include + +/* 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 0000000000..4d0fd4418e --- /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 0000000000..f0b58a351a --- /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 0000000000..e6c2dc2256 --- /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 0000000000..d9b9a81be1 --- /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 0000000000..d40600e7f0 --- /dev/null +++ b/helgrind/tests/tc22_exit_w_lock.c @@ -0,0 +1,50 @@ + +#include +#include +#include +#include + +/* 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 0000000000..f0eb6b675a --- /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 0000000000..bc07725f97 --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc22_exit_w_lock.vgtest b/helgrind/tests/tc22_exit_w_lock.vgtest new file mode 100644 index 0000000000..4f85dd53dd --- /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 0000000000..a0fad5d5d7 --- /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 +#include +#include +#include + +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 0000000000..2bb66de94d --- /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 0000000000..2bb66de94d --- /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 0000000000..e69de29bb2 diff --git a/helgrind/tests/tc23_bogus_condwait.vgtest b/helgrind/tests/tc23_bogus_condwait.vgtest new file mode 100644 index 0000000000..31c3ed8b9a --- /dev/null +++ b/helgrind/tests/tc23_bogus_condwait.vgtest @@ -0,0 +1 @@ +prog: tc23_bogus_condwait