merge patches from Jeremy Fitzhardinge:

14-hg-tid
  HELGRIND: This fixes a bug in Helgrind in which all memory access by
  syscalls was being treated as if it were happening in thread 1. This
  is because the eraser_mem_read/write functions were using
  get_current_tid_1_if_root() to get the current tid. Unfortunately,
  during syscalls there is no current thread, so it was getting
  1_if_root. This patch fixes this by using what thread ID information
  we're given, and only using get_current_tid() if we're recording a
  memory access performed by code (rather than by a syscall).

... which relies on ...

06-memops
  Implement VG_(memcpy/memset).

git-svn-id: svn://svn.valgrind.org/valgrind/trunk@1247

diff --git a/coregrind/vg_mylibc.c b/coregrind/vg_mylibc.c
index c94224db101596d382c5351a95438f3ee9267001..ebefad6f068f67ff1e122dbd411dbe5753732504 100644 (file)
--- a/coregrind/vg_mylibc.c
+++ b/coregrind/vg_mylibc.c
@@ -895,6 +895,31 @@ Char* VG_(strchr) ( const Char* s, Char c )
 }
 
 
+void* VG_(memcpy) ( void *dest, const void *src, Int sz )
+{
+   const Char *s = (const Char *)src;
+   Char *d = (Char *)dest;
+   vg_assert(sz >= 0);
+
+   while (sz--)
+      *d++ = *s++;
+
+   return dest;
+}
+
+
+void* VG_(memset) ( void *dest, Int c, Int sz )
+{
+   Char *d = (Char *)dest;
+   vg_assert(sz >= 0);
+
+   while (sz--)
+      *d++ = c;
+
+   return dest;
+}
+
+
 Char VG_(toupper) ( Char c )
 {
    if (c >= 'a' && c <= 'z')

diff --git a/coregrind/vg_scheduler.c b/coregrind/vg_scheduler.c
index e023248e462f77419ee2da45cafde831987bb3c3..07834eb8fc1668bba237b34e624357826036b7e9 100644 (file)
--- a/coregrind/vg_scheduler.c
+++ b/coregrind/vg_scheduler.c
@@ -389,6 +389,12 @@ ThreadId VG_(get_current_tid_1_if_root) ( void )
    return vg_tid_currently_in_baseBlock;
 }
 
+ThreadId VG_(get_tid_from_ThreadState) (ThreadState* tst)
+{
+   vg_assert(tst >= &VG_(threads)[1] && tst < &VG_(threads)[VG_N_THREADS]);
+   return tst->tid;
+}
+
 
 /* Copy the saved state of a thread into VG_(baseBlock), ready for it
    to be run. */

diff --git a/helgrind/hg_main.c b/helgrind/hg_main.c
index 8cc000053d693dd7994bad983976f4bc1d08b3b6..178a05190f3aff21453d34581db722a1956bf86c 100644 (file)
--- a/helgrind/hg_main.c
+++ b/helgrind/hg_main.c
@@ -748,28 +748,30 @@ static void copy_address_range_state(Addr src, Addr dst, UInt len)
 }
 
 // SSS: put these somewhere better
-static void eraser_mem_read (Addr a, UInt data_size);
-static void eraser_mem_write(Addr a, UInt data_size);
+static void eraser_mem_read (Addr a, UInt data_size, ThreadId tid);
+static void eraser_mem_write(Addr a, UInt data_size, ThreadId tid);
+static void eraser_mem_read_notid (Addr a, UInt data_size);
+static void eraser_mem_write_notid(Addr a, UInt data_size);
 
 static
 void eraser_pre_mem_read(CorePart part, ThreadState* tst,
                          Char* s, UInt base, UInt size )
 {
-   eraser_mem_read(base, size);
+   eraser_mem_read(base, size, VG_(get_tid_from_ThreadState)(tst));
 }
 
 static
 void eraser_pre_mem_read_asciiz(CorePart part, ThreadState* tst,
                                 Char* s, UInt base )
 {
-   eraser_mem_read(base, VG_(strlen)((Char*)base));
+   eraser_mem_read(base, VG_(strlen)((Char*)base), VG_(get_tid_from_ThreadState)(tst));
 }
 
 static
 void eraser_pre_mem_write(CorePart part, ThreadState* tst,
                           Char* s, UInt base, UInt size )
 {
-   eraser_mem_write(base, size);
+   eraser_mem_write(base, size, VG_(get_tid_from_ThreadState)(tst));
 }
 
 
@@ -889,7 +891,7 @@ UCodeBlock* SK_(instrument) ( UCodeBlock* cb_in, Addr not_used )
                       8 == u_in->size || 10 == u_in->size);
             uInstr2(cb, CCALL, 0, TempReg, u_in->val1, TempReg, t_size);
             // SSS: make regparms(2) eventually...
-            uCCall(cb, (Addr) & eraser_mem_read, 2, 0, False);
+            uCCall(cb, (Addr) & eraser_mem_read_notid, 2, 0, False);
             VG_(copy_UInstr)(cb, u_in);
             t_size = INVALID_TEMPREG;
             break;
@@ -903,7 +905,7 @@ UCodeBlock* SK_(instrument) ( UCodeBlock* cb_in, Addr not_used )
             sk_assert(1 == u_in->size || 2 == u_in->size || 4 == u_in->size || 
                       8 == u_in->size || 10 == u_in->size);
             uInstr2(cb, CCALL, 0, TempReg, u_in->val2, TempReg, t_size);
-            uCCall(cb, (Addr) & eraser_mem_write, 2, 0, False);
+            uCCall(cb, (Addr) & eraser_mem_write_notid, 2, 0, False);
             VG_(copy_UInstr)(cb, u_in);
             t_size = INVALID_TEMPREG;
             break;
@@ -1194,10 +1196,9 @@ Int compute_num_words_accessed(Addr a, UInt size)
 #endif
 
 
-static void eraser_mem_read(Addr a, UInt size)
+static void eraser_mem_read(Addr a, UInt size, ThreadId tid)
 {
    shadow_word* sword;
-   ThreadId tid = VG_(get_current_tid_1_if_root)();
    Addr     end = a + 4*compute_num_words_accessed(a, size);
 
    for ( ; a < end; a += 4) {
@@ -1262,10 +1263,9 @@ static void eraser_mem_read(Addr a, UInt size)
 }
 
 
-static void eraser_mem_write(Addr a, UInt size)
+static void eraser_mem_write(Addr a, UInt size, ThreadId tid)
 {
    shadow_word* sword;
-   ThreadId tid = VG_(get_current_tid_1_if_root)();
    Addr     end = a + 4*compute_num_words_accessed(a, size);
 
    for ( ; a < end; a += 4) {
@@ -1325,6 +1325,15 @@ static void eraser_mem_write(Addr a, UInt size)
 
 #undef DEBUG_STATE
 
+static void eraser_mem_read_notid(Addr a, UInt size)
+{
+   eraser_mem_read(a, size, VG_(get_current_tid)());
+}
+
+static void eraser_mem_write_notid(Addr a, UInt size)
+{
+   eraser_mem_write(a, size, VG_(get_current_tid)());
+}
 
 /*--------------------------------------------------------------------*/
 /*--- Setup                                                        ---*/
@@ -1373,8 +1382,8 @@ void SK_(pre_clo_init)(VgDetails* details, VgNeeds* needs, VgTrackEvents* track)
    track->post_mutex_lock       = & eraser_post_mutex_lock;
    track->post_mutex_unlock     = & eraser_post_mutex_unlock;
 
-   VG_(register_compact_helper)((Addr) & eraser_mem_read);
-   VG_(register_compact_helper)((Addr) & eraser_mem_write);
+   VG_(register_compact_helper)((Addr) & eraser_mem_read_notid);
+   VG_(register_compact_helper)((Addr) & eraser_mem_write_notid);
 
    /* Init lock table */
    for (i = 0; i < VG_N_THREADS; i++) 

diff --git a/include/vg_skin.h b/include/vg_skin.h
index 6287aecb715351751862d48e24c88cde72f8e1ac..0494277d5d86081c16e2faab60c383877f1d8058 100644 (file)
--- a/include/vg_skin.h
+++ b/include/vg_skin.h
@@ -253,7 +253,9 @@ typedef
    struct _ThreadState
    ThreadState;
 
+extern ThreadId     VG_(get_current_tid)           ( void );
 extern ThreadId     VG_(get_current_tid_1_if_root) ( void );
+extern ThreadId     VG_(get_tid_from_ThreadState)  ( ThreadState* );
 extern ThreadState* VG_(get_ThreadState)           ( ThreadId tid );
 
 
@@ -338,6 +340,8 @@ extern Int   VG_(strncmp)        ( const Char* s1, const Char* s2, Int nmax );
 extern Char* VG_(strstr)         ( const Char* haystack, Char* needle );
 extern Char* VG_(strchr)         ( const Char* s, Char c );
 extern Char* VG_(strdup)         ( const Char* s);
+extern void* VG_(memcpy)         ( void *d, const void *s, Int sz );
+extern void* VG_(memset)         ( void *s, Int c, Int sz );
 
 /* Like strcmp() and strncmp(), but stop comparing at any whitespace. */
 extern Int   VG_(strcmp_ws)      ( const Char* s1, const Char* s2 );