From: Nicholas Nethercote <njn@valgrind.org>
Date: Thu, 24 Jul 2003 08:45:32 +0000 (+0000)
Subject: A big commit size-wise, but small concept-wise:  removed the ThreadState type
X-Git-Tag: svn/VALGRIND_2_0_0~5
X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=0f871c249cc91d0710558f536e7377be7baaa3a8;p=thirdparty%2Fvalgrind.git

A big commit size-wise, but small concept-wise:  removed the ThreadState type
from skin's view, replacing all instances with ThreadId.  Much cleaner.  Had to
change the way VG_(get_ExeContext)() worked a little.  Changed the core/skin
major interface because this breaks the old version.  Also fixed a few minor
related things here and there.


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

diff --git a/addrcheck/ac_main.c b/addrcheck/ac_main.c
index e4f2a6b3fe..2efaa3a25a 100644
--- a/addrcheck/ac_main.c
+++ b/addrcheck/ac_main.c
@@ -561,7 +561,7 @@ Bool ac_check_readable_asciiz ( Addr a, Addr* bad_addr )
 /*------------------------------------------------------------*/
 
 static __inline__
-void ac_check_is_accessible ( CorePart part, ThreadState* tst,
+void ac_check_is_accessible ( CorePart part, ThreadId tid,
                               Char* s, Addr base, UInt size, Bool isWrite )
 {
    Bool ok;
@@ -573,21 +573,21 @@ void ac_check_is_accessible ( CorePart part, ThreadState* tst,
    if (!ok) {
       switch (part) {
       case Vg_CoreSysCall:
-         MAC_(record_param_error) ( tst, bad_addr, isWrite, s );
+         MAC_(record_param_error) ( tid, bad_addr, isWrite, s );
          break;
 
       case Vg_CoreSignal:
          sk_assert(isWrite);     /* Should only happen with isWrite case */
          /* fall through */
       case Vg_CorePThread:
-         MAC_(record_core_mem_error)( tst, isWrite, s );
+         MAC_(record_core_mem_error)( tid, isWrite, s );
          break;
 
       /* If we're being asked to jump to a silly address, record an error 
          message before potentially crashing the entire system. */
       case Vg_CoreTranslate:
          sk_assert(!isWrite);    /* Should only happen with !isWrite case */
-         MAC_(record_jump_error)( tst, bad_addr );
+         MAC_(record_jump_error)( tid, bad_addr );
          break;
 
       default:
@@ -599,21 +599,21 @@ void ac_check_is_accessible ( CorePart part, ThreadState* tst,
 }
 
 static
-void ac_check_is_writable ( CorePart part, ThreadState* tst,
+void ac_check_is_writable ( CorePart part, ThreadId tid,
                             Char* s, Addr base, UInt size )
 {
-   ac_check_is_accessible ( part, tst, s, base, size, /*isWrite*/True );
+   ac_check_is_accessible ( part, tid, s, base, size, /*isWrite*/True );
 }
 
 static
-void ac_check_is_readable ( CorePart part, ThreadState* tst,
+void ac_check_is_readable ( CorePart part, ThreadId tid,
                             Char* s, Addr base, UInt size )
 {     
-   ac_check_is_accessible ( part, tst, s, base, size, /*isWrite*/False );
+   ac_check_is_accessible ( part, tid, s, base, size, /*isWrite*/False );
 }
 
 static
-void ac_check_is_readable_asciiz ( CorePart part, ThreadState* tst,
+void ac_check_is_readable_asciiz ( CorePart part, ThreadId tid,
                                    Char* s, Addr str )
 {
    Bool ok = True;
@@ -625,7 +625,7 @@ void ac_check_is_readable_asciiz ( CorePart part, ThreadState* tst,
    sk_assert(part == Vg_CoreSysCall);
    ok = ac_check_readable_asciiz ( (Addr)str, &bad_addr );
    if (!ok) {
-      MAC_(record_param_error) ( tst, bad_addr, /*is_writable =*/False, s );
+      MAC_(record_param_error) ( tid, bad_addr, /*is_writable =*/False, s );
    }
 
    VGP_POPCC(VgpCheckMem);
@@ -781,7 +781,7 @@ static void ac_ACCESS4_SLOWLY ( Addr a )
    if (!MAC_(clo_partial_loads_ok) 
        || ((a & 3) != 0)
        || (!a0ok && !a1ok && !a2ok && !a3ok)) {
-      MAC_(record_address_error)( /*tst*/NULL, a, 4, False );
+      MAC_(record_address_error)( VG_(get_current_tid)(), a, 4, False );
       return;
    }
 
@@ -808,7 +808,7 @@ static void ac_ACCESS2_SLOWLY ( Addr a )
 
    /* If an address error has happened, report it. */
    if (aerr) {
-      MAC_(record_address_error)( /*tst*/NULL, a, 2, False );
+      MAC_(record_address_error)( VG_(get_current_tid)(), a, 2, False );
    }
 }
 
@@ -822,7 +822,7 @@ static void ac_ACCESS1_SLOWLY ( Addr a )
 
    /* If an address error has happened, report it. */
    if (aerr) {
-      MAC_(record_address_error)( /*tst*/NULL, a, 1, False );
+      MAC_(record_address_error)( VG_(get_current_tid)(), a, 1, False );
    }
 }
 
@@ -927,7 +927,7 @@ void ac_fpu_ACCESS_check_SLOWLY ( Addr addr, Int size )
    }
 
    if (aerr) {
-      MAC_(record_address_error)( /*tst*/NULL, addr, size, False );
+      MAC_(record_address_error)( VG_(get_current_tid)(), addr, size, False );
    }
 }
 
@@ -1147,7 +1147,7 @@ Bool SK_(expensive_sanity_check) ( void )
 /*--- Client requests                                      ---*/
 /*------------------------------------------------------------*/
 
-Bool SK_(handle_client_request) ( ThreadState* tst, UInt* arg_block, UInt *ret )
+Bool SK_(handle_client_request) ( ThreadId tid, UInt* arg_block, UInt *ret )
 {
 #define IGNORE(what)                                                    \
    do {                                                                 \
@@ -1193,7 +1193,7 @@ Bool SK_(handle_client_request) ( ThreadState* tst, UInt* arg_block, UInt *ret )
          return False;
 
       default:
-         if (MAC_(handle_common_client_requests)(tst, arg_block, ret )) {
+         if (MAC_(handle_common_client_requests)(tid, arg_block, ret )) {
             return True;
          } else {
             VG_(message)(Vg_UserMsg, 
diff --git a/coregrind/vg_default.c b/coregrind/vg_default.c
index 58cb0a0c8e..1bb54085fd 100644
--- a/coregrind/vg_default.c
+++ b/coregrind/vg_default.c
@@ -131,7 +131,7 @@ NON_FUND( void SK_(print_usage)(void) );
 NON_FUND( void SK_(print_debug_usage)(void) );
 
 /* Client request template function */
-NON_FUND( Bool SK_(handle_client_request)(ThreadState* tst, UInt* arg_block,
+NON_FUND( Bool SK_(handle_client_request)(ThreadId tid, UInt* arg_block,
                                           UInt *ret) );
 
 /* UCode extension */
@@ -170,7 +170,7 @@ Bool VG_(sk_malloc_called_by_scheduler) = False;
    malloc()-replacing skin cannot forget to implement SK_(malloc)() or
    SK_(free)().  */
 __attribute__ ((weak))
-void* SK_(malloc)( ThreadState* tst, Int size )
+void* SK_(malloc)( Int size )
 {
    if (VG_(sk_malloc_called_by_scheduler))
       return VG_(cli_malloc)(4, size);
@@ -179,7 +179,7 @@ void* SK_(malloc)( ThreadState* tst, Int size )
 }
 
 __attribute__ ((weak))
-void  SK_(free)( ThreadState* tst, void* p )
+void  SK_(free)( void* p )
 {
    /* see comment for SK_(malloc)() above */
    if (VG_(sk_malloc_called_by_scheduler))
@@ -188,15 +188,14 @@ void  SK_(free)( ThreadState* tst, void* p )
       malloc_panic(__PRETTY_FUNCTION__);
 }
 
-MALLOC( void* SK_(__builtin_new)    ( ThreadState* tst, Int size ) );
-MALLOC( void* SK_(__builtin_vec_new)( ThreadState* tst, Int size ) );
-MALLOC( void* SK_(memalign)         ( ThreadState* tst, Int align, Int size ) );
-MALLOC( void* SK_(calloc)           ( ThreadState* tst, Int nmemb, Int size ) );
+MALLOC( void* SK_(__builtin_new)    ( Int size ) );
+MALLOC( void* SK_(__builtin_vec_new)( Int size ) );
+MALLOC( void* SK_(memalign)         ( Int align, Int size ) );
+MALLOC( void* SK_(calloc)           ( Int nmemb, Int size ) );
 
-MALLOC( void  SK_(__builtin_delete)     ( ThreadState* tst, void* p ) );
-MALLOC( void  SK_(__builtin_vec_delete) ( ThreadState* tst, void* p ) );
-MALLOC( void* SK_(realloc)              ( ThreadState* tst, void* p,
-                                          Int new_size ) );
+MALLOC( void  SK_(__builtin_delete)     ( void* p ) );
+MALLOC( void  SK_(__builtin_vec_delete) ( void* p ) );
+MALLOC( void* SK_(realloc)              ( void* p, Int new_size ) );
 
 /*--------------------------------------------------------------------*/
 /*--- end                                            vg_defaults.c ---*/
diff --git a/coregrind/vg_errcontext.c b/coregrind/vg_errcontext.c
index cabc8ae260..700e4c67a1 100644
--- a/coregrind/vg_errcontext.c
+++ b/coregrind/vg_errcontext.c
@@ -166,32 +166,21 @@ Bool VG_(is_action_requested) ( Char* action, Bool* clo )
      stored thread state, not from VG_(baseBlock).  
 */
 static __inline__
-void construct_error ( Error* err, ThreadState* tst, ErrorKind ekind, Addr a,
-                       Char* s, void* extra, ExeContext* where,
-                       /*out*/Addr* m_eip, /*out*/Addr* m_esp,
-                       /*out*/Addr* m_ebp )
+void construct_error ( Error* err, ThreadId tid, ErrorKind ekind, Addr a,
+                       Char* s, void* extra, ExeContext* where )
 {
+   sk_assert(tid < VG_N_THREADS);
+
    /* Core-only parts */
    err->next     = NULL;
    err->supp     = NULL;
    err->count    = 1;
+   err->tid      = tid;
    if (NULL == where)
-      err->where = VG_(get_ExeContext)( tst );
+      err->where = VG_(get_ExeContext)( tid );
    else
       err->where = where;
 
-   if (NULL == tst) {
-      err->tid   = VG_(get_current_tid)();
-      *m_eip = VG_(baseBlock)[VGOFF_(m_eip)];
-      *m_esp = VG_(baseBlock)[VGOFF_(m_esp)];
-      *m_ebp = VG_(baseBlock)[VGOFF_(m_ebp)];
-   } else {
-      err->tid   = tst->tid;
-      *m_eip = tst->m_eip;
-      *m_esp = tst->m_esp;
-      *m_ebp = tst->m_ebp;
-   }
-
    /* Skin-relevant parts */
    err->ekind  = ekind;
    err->addr   = a;
@@ -199,7 +188,7 @@ void construct_error ( Error* err, ThreadState* tst, ErrorKind ekind, Addr a,
    err->extra  = extra;
 
    /* sanity... */
-   vg_assert(err->tid >= 0 && err->tid < VG_N_THREADS);
+   vg_assert( tid < VG_N_THREADS );
 }
 
 void VG_(gen_suppression)(Error* err)
@@ -251,13 +240,24 @@ void VG_(gen_suppression)(Error* err)
 }
 
 static 
-void do_actions_on_error(Error* err, Bool allow_GDB_attach,
-                         Addr m_eip, Addr m_esp, Addr m_ebp )
+void do_actions_on_error(Error* err, Bool allow_GDB_attach)
 {
    /* Perhaps we want a GDB attach at this point? */
    if (allow_GDB_attach &&
        VG_(is_action_requested)( "Attach to GDB", & VG_(clo_GDB_attach) )) 
    {
+      Addr m_eip, m_esp, m_ebp; 
+      
+      if (VG_(is_running_thread)( err->tid )) {
+         m_eip = VG_(baseBlock)[VGOFF_(m_eip)];
+         m_esp = VG_(baseBlock)[VGOFF_(m_esp)];
+         m_ebp = VG_(baseBlock)[VGOFF_(m_ebp)];
+      } else {
+         ThreadState* tst = & VG_(threads)[ err->tid ];
+         m_eip = tst->m_eip;
+         m_esp = tst->m_esp;
+         m_ebp = tst->m_ebp;
+      }
       VG_(swizzle_esp_then_start_GDB)( m_eip, m_esp, m_ebp );
    }
    /* Or maybe we want to generate the error's suppression? */
@@ -274,10 +274,9 @@ static Bool is_first_shown_context = True;
 /* Top-level entry point to the error management subsystem.
    All detected errors are notified here; this routine decides if/when the
    user should see the error. */
-void VG_(maybe_record_error) ( ThreadState* tst, 
+void VG_(maybe_record_error) ( ThreadId tid, 
                                ErrorKind ekind, Addr a, Char* s, void* extra )
 {
-          Addr   m_eip, m_esp, m_ebp;
           Error  err;
           Error* p;
           Error* p_prev;
@@ -342,8 +341,7 @@ void VG_(maybe_record_error) ( ThreadState* tst,
    }
 
    /* Build ourselves the error */
-   construct_error ( &err, tst, ekind, a, s, extra, NULL,
-                     &m_eip, &m_esp, &m_ebp );
+   construct_error ( &err, tid, ekind, a, s, extra, NULL );
 
    /* First, see if we've got an error record matching this one. */
    p      = vg_errors;
@@ -416,7 +414,7 @@ void VG_(maybe_record_error) ( ThreadState* tst,
       pp_Error(p, False);
       is_first_shown_context = False;
       vg_n_errs_shown++;
-      do_actions_on_error(p, /*allow_GDB_attach*/True, m_eip, m_esp, m_ebp );
+      do_actions_on_error(p, /*allow_GDB_attach*/True);
    } else {
       vg_n_errs_suppressed++;
       p->supp->count++;
@@ -430,16 +428,14 @@ void VG_(maybe_record_error) ( ThreadState* tst,
    suppressed.  Bool `print_error' dictates whether to print the error. 
    Bool `count_error' dictates whether to count the error in VG_(n_errs_found)
 */
-Bool VG_(unique_error) ( ThreadState* tst, ErrorKind ekind, Addr a, Char* s,
+Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind, Addr a, Char* s,
                          void* extra, ExeContext* where, Bool print_error,
                          Bool allow_GDB_attach, Bool count_error )
 {
    Error  err;
-   Addr   m_eip, m_esp, m_ebp;
 
    /* Build ourselves the error */
-   construct_error ( &err, tst, ekind, a, s, extra, where,
-                     &m_eip, &m_esp, &m_ebp );
+   construct_error ( &err, tid, ekind, a, s, extra, where );
 
    /* Unless it's suppressed, we're going to show it.  Don't need to make
       a copy, because it's only temporary anyway.
@@ -459,7 +455,7 @@ Bool VG_(unique_error) ( ThreadState* tst, ErrorKind ekind, Addr a, Char* s,
          pp_Error(&err, False);
          is_first_shown_context = False;
       }
-      do_actions_on_error(&err, allow_GDB_attach, m_eip, m_esp, m_ebp);
+      do_actions_on_error(&err, allow_GDB_attach);
 
       return False;
 
@@ -479,8 +475,7 @@ Bool VG_(unique_error) ( ThreadState* tst, ErrorKind ekind, Addr a, Char* s,
 void VG_(record_pthread_error) ( ThreadId tid, Char* msg )
 {
    if (! VG_(needs).core_errors) return;
-   VG_(maybe_record_error)( &VG_(threads)[tid], PThreadErr, /*addr*/0, msg, 
-                            /*extra*/NULL );
+   VG_(maybe_record_error)( tid, PThreadErr, /*addr*/0, msg, /*extra*/NULL );
 }
 
 /*------------------------------*/
diff --git a/coregrind/vg_execontext.c b/coregrind/vg_execontext.c
index 4fa6b9f30c..380ae5bd5d 100644
--- a/coregrind/vg_execontext.c
+++ b/coregrind/vg_execontext.c
@@ -283,33 +283,33 @@ ExeContext* VG_(get_ExeContext2) ( Addr eip, Addr ebp,
    return new_ec;
 }
 
-ExeContext* VG_(get_ExeContext) ( ThreadState *tst )
+ExeContext* VG_(get_ExeContext) ( ThreadId tid )
 {
    ExeContext *ec;
 
-   if (tst == NULL) {
+   if (VG_(is_running_thread)(tid)) {
       /* thread currently in baseblock */
-      ThreadId tid = VG_(get_current_tid)();
-
       ec = VG_(get_ExeContext2)( VG_(baseBlock)[VGOFF_(m_eip)], 
 				 VG_(baseBlock)[VGOFF_(m_ebp)],
 				 VG_(baseBlock)[VGOFF_(m_esp)],
 				 VG_(threads)[tid].stack_highest_word);
    } else {
+      /* thread in thread table */
+      ThreadState* tst = & VG_(threads)[ tid ];
       ec = VG_(get_ExeContext2)( tst->m_eip, tst->m_ebp, tst->m_esp, 
 				 tst->stack_highest_word );
    }
    return ec;
 }
 
-Addr VG_(get_EIP) ( ThreadState *tst )
+Addr VG_(get_EIP) ( ThreadId tid )
 {
    Addr ret;
 
-   if (tst == NULL)
+   if (VG_(is_running_thread)(tid))
       ret = VG_(baseBlock)[VGOFF_(m_eip)];
    else
-      ret = tst->m_eip;
+      ret = VG_(threads)[ tid ].m_eip;
 
    return ret;
 }
diff --git a/coregrind/vg_include.h b/coregrind/vg_include.h
index bc8ce86452..78a574594b 100644
--- a/coregrind/vg_include.h
+++ b/coregrind/vg_include.h
@@ -344,11 +344,11 @@ typedef
 
       void (*ban_mem_stack)  ( Addr a, UInt len );
 
-      void (*pre_mem_read)   ( CorePart part, ThreadState* tst,
+      void (*pre_mem_read)   ( CorePart part, ThreadId tid,
                                Char* s, Addr a, UInt size );
-      void (*pre_mem_read_asciiz) ( CorePart part, ThreadState* tst,
+      void (*pre_mem_read_asciiz) ( CorePart part, ThreadId tid,
                                     Char* s, Addr a );
-      void (*pre_mem_write)  ( CorePart part, ThreadState* tst,
+      void (*pre_mem_write)  ( CorePart part, ThreadId tid,
                                Char* s, Addr a, UInt size );
       /* Not implemented yet -- have to add in lots of places, which is a
          pain.  Won't bother unless/until there's a need. */
@@ -469,15 +469,6 @@ extern Bool  VG_(is_inside_segment_mmapd_by_low_level_MM)( Addr aa );
 #define VG_USERREQ__MALLOC                  0x2001
 #define VG_USERREQ__FREE                    0x2002
 
-/* 
-In vg_skin.h, so skins can use it.
-Call an arbitrary function with ThreadState as the first arg.
-#define VG_USERREQ__CLIENT_tstCALL0         0x2101
-#define VG_USERREQ__CLIENT_tstCALL1         0x2102
-#define VG_USERREQ__CLIENT_tstCALL2         0x2103
-#define VG_USERREQ__CLIENT_tstCALL3         0x2104
-*/
-
 /* (Fn, Arg): Create a new thread and run Fn applied to Arg in it.  Fn
    MUST NOT return -- ever.  Eventually it will do either __QUIT or
    __WAIT_JOINER.  */
@@ -711,7 +702,8 @@ typedef
    ForkHandlerEntry;
 
 
-struct _ThreadState {
+typedef
+   struct _ThreadState {
    /* ThreadId == 0 (and hence vg_threads[0]) is NEVER USED.
       The thread identity is simply the index in vg_threads[].
       ThreadId == 1 is the root thread and has the special property
@@ -872,7 +864,8 @@ struct _ThreadState {
    UInt sh_ebp;
    UInt sh_esp;
    UInt sh_eflags;
-};
+} 
+ThreadState;
 
 
 /* The thread table. */
@@ -884,6 +877,10 @@ extern Bool VG_(is_valid_tid) ( ThreadId tid );
 /* Check that tid is in range. */
 extern Bool VG_(is_valid_or_empty_tid) ( ThreadId tid );
 
+/* Determine if 'tid' is that of the current running thread (Nb: returns
+   False if no thread is currently running. */
+extern Bool VG_(is_running_thread)(ThreadId tid);
+
 /* Copy the specified thread's state into VG_(baseBlock) in
    preparation for running it. */
 extern void VG_(load_thread_state)( ThreadId );
@@ -1123,7 +1120,7 @@ struct _UCodeBlock {
 
 extern UCodeBlock* VG_(alloc_UCodeBlock) ( void );
 
-extern void  VG_(translate)  ( ThreadState* tst,
+extern void  VG_(translate)  ( ThreadId tid,
                                Addr  orig_addr,
                                UInt* orig_size,
                                Addr* trans_addr,
diff --git a/coregrind/vg_needs.c b/coregrind/vg_needs.c
index 259e15ea58..003d3119f3 100644
--- a/coregrind/vg_needs.c
+++ b/coregrind/vg_needs.c
@@ -247,10 +247,10 @@ TRACK(die_mem_stack,         Addr a, UInt len)
 
 TRACK(ban_mem_stack, Addr a, UInt len)
 
-TRACK(pre_mem_read,        CorePart part, ThreadState* tst, Char* s, Addr a,
+TRACK(pre_mem_read,        CorePart part, ThreadId tid, Char* s, Addr a,
                            UInt size)
-TRACK(pre_mem_read_asciiz, CorePart part, ThreadState* tst, Char* s, Addr a)
-TRACK(pre_mem_write,       CorePart part, ThreadState* tst, Char* s, Addr a,
+TRACK(pre_mem_read_asciiz, CorePart part, ThreadId tid, Char* s, Addr a)
+TRACK(pre_mem_write,       CorePart part, ThreadId tid, Char* s, Addr a,
                            UInt size)
 TRACK(post_mem_write,      Addr a, UInt size)
 
diff --git a/coregrind/vg_replace_malloc.c b/coregrind/vg_replace_malloc.c
index 1d2de8bf73..636e85128e 100644
--- a/coregrind/vg_replace_malloc.c
+++ b/coregrind/vg_replace_malloc.c
@@ -45,7 +45,7 @@
 
 /* Sidestep the normal check which disallows using valgrind.h directly. */
 #define __VALGRIND_SOMESKIN_H
-#include "valgrind.h"            /* for VALGRIND_NON_SIMD_tstCALL[12] */
+#include "valgrind.h"            /* for VALGRIND_NON_SIMD_CALL[12] */
 
 /*------------------------------------------------------------*/
 /*--- Command line options                                 ---*/
@@ -150,7 +150,7 @@ void* malloc ( Int n )
    MAYBE_SLOPPIFY(n);
 
    if (VG_(is_running_on_simd_CPU)()) {
-      v = (void*)VALGRIND_NON_SIMD_tstCALL1( SK_(malloc), n );
+      v = (void*)VALGRIND_NON_SIMD_CALL1( SK_(malloc), n );
    } else if (VG_(clo_alignment) != 4) {
       v = VG_(arena_malloc_aligned)(VG_AR_CLIENT, VG_(clo_alignment), n);
    } else {
@@ -169,7 +169,7 @@ void* __builtin_new ( Int n )
    MAYBE_SLOPPIFY(n);
 
    if (VG_(is_running_on_simd_CPU)()) {
-      v = (void*)VALGRIND_NON_SIMD_tstCALL1( SK_(__builtin_new), n );
+      v = (void*)VALGRIND_NON_SIMD_CALL1( SK_(__builtin_new), n );
    } else if (VG_(clo_alignment) != 4) {
       v = VG_(arena_malloc_aligned)(VG_AR_CLIENT, VG_(clo_alignment), n);
    } else {
@@ -194,7 +194,7 @@ void* __builtin_vec_new ( Int n )
    MAYBE_SLOPPIFY(n);
 
    if (VG_(is_running_on_simd_CPU)()) {
-      v = (void*)VALGRIND_NON_SIMD_tstCALL1( SK_(__builtin_vec_new), n );
+      v = (void*)VALGRIND_NON_SIMD_CALL1( SK_(__builtin_vec_new), n );
    } else if (VG_(clo_alignment) != 4) {
       v = VG_(arena_malloc_aligned)(VG_AR_CLIENT, VG_(clo_alignment), n);
    } else {
@@ -217,7 +217,7 @@ void free ( void* p )
    if (p == NULL) 
       return;
    if (VG_(is_running_on_simd_CPU)()) {
-      (void)VALGRIND_NON_SIMD_tstCALL1( SK_(free), p );
+      (void)VALGRIND_NON_SIMD_CALL1( SK_(free), p );
    } else {
       VG_(arena_free)(VG_AR_CLIENT, p);      
    }
@@ -230,7 +230,7 @@ void __builtin_delete ( void* p )
    if (p == NULL) 
       return;
    if (VG_(is_running_on_simd_CPU)()) {
-      (void)VALGRIND_NON_SIMD_tstCALL1( SK_(__builtin_delete), p );
+      (void)VALGRIND_NON_SIMD_CALL1( SK_(__builtin_delete), p );
    } else {
       VG_(arena_free)(VG_AR_CLIENT, p);
    }
@@ -249,7 +249,7 @@ void __builtin_vec_delete ( void* p )
    if (p == NULL) 
       return;
    if (VG_(is_running_on_simd_CPU)()) {
-      (void)VALGRIND_NON_SIMD_tstCALL1( SK_(__builtin_vec_delete), p );
+      (void)VALGRIND_NON_SIMD_CALL1( SK_(__builtin_vec_delete), p );
    } else {
       VG_(arena_free)(VG_AR_CLIENT, p);
    }
@@ -270,7 +270,7 @@ void* calloc ( UInt nmemb, UInt size )
    MAYBE_SLOPPIFY(size);
 
    if (VG_(is_running_on_simd_CPU)()) {
-      v = (void*)VALGRIND_NON_SIMD_tstCALL2( SK_(calloc), nmemb, size );
+      v = (void*)VALGRIND_NON_SIMD_CALL2( SK_(calloc), nmemb, size );
    } else {
       v = VG_(arena_calloc)(VG_AR_CLIENT, VG_(clo_alignment), nmemb, size);
    }
@@ -296,7 +296,7 @@ void* realloc ( void* ptrV, Int new_size )
       return NULL;
    }   
    if (VG_(is_running_on_simd_CPU)()) {
-      v = (void*)VALGRIND_NON_SIMD_tstCALL2( SK_(realloc), ptrV, new_size );
+      v = (void*)VALGRIND_NON_SIMD_CALL2( SK_(realloc), ptrV, new_size );
    } else {
       v = VG_(arena_realloc)(VG_AR_CLIENT, ptrV, VG_(clo_alignment), new_size);
    }
@@ -314,7 +314,7 @@ void* memalign ( Int alignment, Int n )
    MAYBE_SLOPPIFY(n);
 
    if (VG_(is_running_on_simd_CPU)()) {
-      v = (void*)VALGRIND_NON_SIMD_tstCALL2( SK_(memalign), alignment, n );
+      v = (void*)VALGRIND_NON_SIMD_CALL2( SK_(memalign), alignment, n );
    } else {
       v = VG_(arena_malloc_aligned)(VG_AR_CLIENT, alignment, n);
    }
diff --git a/coregrind/vg_scheduler.c b/coregrind/vg_scheduler.c
index 70bf63f141..ef4d49b77f 100644
--- a/coregrind/vg_scheduler.c
+++ b/coregrind/vg_scheduler.c
@@ -332,8 +332,8 @@ void create_translation_for ( ThreadId tid, Addr orig_addr )
       jumps[i] = (UShort)-1;
 
    /* Make a translation, into temporary storage. */
-   VG_(translate)( &VG_(threads)[tid],
-                   orig_addr, &orig_size, &trans_addr, &trans_size, jumps );
+   VG_(translate)( tid, orig_addr,                                /* in */
+                   &orig_size, &trans_addr, &trans_size, jumps ); /* out */
 
    /* Copy data at trans_addr into the translation cache. */
    /* Since the .orig_size and .trans_size fields are
@@ -363,19 +363,12 @@ ThreadId vg_alloc_ThreadState ( void )
    /*NOTREACHED*/
 }
 
-ThreadState* VG_(get_ThreadState)( ThreadId tid )
+Bool VG_(is_running_thread)(ThreadId tid)
 {
-   vg_assert(tid >= 0 && tid < VG_N_THREADS);
-   return & VG_(threads)[tid];
+   ThreadId curr = VG_(get_current_tid)();
+   return (curr == tid && VG_INVALID_THREADID != tid);
 }
 
-ThreadState* VG_(get_current_thread_state) ( void )
-{
-   vg_assert(VG_(is_valid_tid)(vg_tid_currently_in_baseBlock));
-   return & VG_(threads)[vg_tid_currently_in_baseBlock];
-}
-
-
 ThreadId VG_(get_current_tid) ( void )
 {
    if (!VG_(is_valid_tid)(vg_tid_currently_in_baseBlock))
@@ -392,12 +385,6 @@ ThreadId VG_(get_current_or_recent_tid) ( void )
    return vg_tid_last_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. */
 void VG_(load_thread_state) ( ThreadId tid )
@@ -1626,7 +1613,7 @@ VgSchedReturnCode VG_(scheduler) ( void )
       throwing away the result. */
    VG_(printf)(
       "======vvvvvvvv====== LAST TRANSLATION ======vvvvvvvv======\n");
-   VG_(translate)( &VG_(threads)[tid], 
+   VG_(translate)( tid, 
                    VG_(threads)[tid].m_eip, NULL, NULL, NULL, NULL );
    VG_(printf)("\n");
    VG_(printf)(
@@ -1766,7 +1753,7 @@ void maybe_rendezvous_joiners_and_joinees ( void )
       thread_return = VG_(threads)[jnr].joiner_thread_return;
       if (thread_return != NULL) {
          /* CHECK thread_return writable */
-         VG_TRACK( pre_mem_write, Vg_CorePThread, &VG_(threads)[jnr],
+         VG_TRACK( pre_mem_write, Vg_CorePThread, jnr,
                                   "pthread_join: thread_return",
                                   (Addr)thread_return, sizeof(void*));
 
@@ -1859,7 +1846,7 @@ void do__cleanup_pop ( ThreadId tid, CleanupEntry* cu )
      return;
    }
    sp--;
-   VG_TRACK( pre_mem_write, Vg_CorePThread, & VG_(threads)[tid],
+   VG_TRACK( pre_mem_write, Vg_CorePThread, tid,
                             "cleanup pop", (Addr)cu, sizeof(CleanupEntry) );
    *cu = VG_(threads)[tid].custack[sp];
    VG_TRACK( post_mem_write, (Addr)cu, sizeof(CleanupEntry) );
@@ -2257,8 +2244,7 @@ void do__apply_in_new_thread ( ThreadId parent_tid,
    SET_PTHREQ_ESP(tid, VG_(threads)[tid].m_esp - 8);
 
    VG_TRACK ( new_mem_stack, (Addr)VG_(threads)[tid].m_esp, 2 * 4 );
-   VG_TRACK ( pre_mem_write, Vg_CorePThread, & VG_(threads)[tid], 
-                             "new thread: stack",
+   VG_TRACK ( pre_mem_write, Vg_CorePThread, tid, "new thread: stack",
                              (Addr)VG_(threads)[tid].m_esp, 2 * 4 );
  
    /* push arg and (bogus) return address */
@@ -2918,8 +2904,7 @@ void do_pthread_key_create ( ThreadId tid,
    vg_thread_keys[i].destructor = destructor;
 
    /* check key for addressibility */
-   VG_TRACK( pre_mem_write, Vg_CorePThread, &VG_(threads)[tid], 
-                            "pthread_key_create: key",
+   VG_TRACK( pre_mem_write, Vg_CorePThread, tid, "pthread_key_create: key",
                             (Addr)key, sizeof(pthread_key_t));
    *key = i;
    VG_TRACK( post_mem_write, (Addr)key, sizeof(pthread_key_t) );
@@ -3024,15 +3009,14 @@ void do__get_key_destr_and_spec ( ThreadId tid,
       SET_PTHREQ_RETVAL(tid, -1);
       return;
    }
-   VG_TRACK( pre_mem_write, Vg_CorePThread, & VG_(threads)[tid], 
-                            "get_key_destr_and_spec: cu", (Addr)cu,
-                            sizeof(CleanupEntry) );
+   VG_TRACK( pre_mem_write, Vg_CorePThread, tid, "get_key_destr_and_spec: cu",
+                            (Addr)cu, sizeof(CleanupEntry) );
 
    cu->fn = vg_thread_keys[key].destructor;
    if (VG_(threads)[tid].specifics_ptr == NULL) {
       cu->arg = NULL;
    } else {
-      VG_TRACK( pre_mem_read, Vg_CorePThread, & VG_(threads)[tid],
+      VG_TRACK( pre_mem_read, Vg_CorePThread, tid,
                 "get_key_destr_and_spec: key",
                 (Addr)(&VG_(threads)[tid].specifics_ptr[key]), 
                 sizeof(void*) );
@@ -3071,12 +3055,10 @@ void do_pthread_sigmask ( ThreadId tid,
              && VG_(threads)[tid].status == VgTs_Runnable);
 
    if (newmask)
-      VG_TRACK( pre_mem_read, Vg_CorePThread, &VG_(threads)[tid],
-                              "pthread_sigmask: newmask",
+      VG_TRACK( pre_mem_read, Vg_CorePThread, tid, "pthread_sigmask: newmask",
                               (Addr)newmask, sizeof(vki_ksigset_t));
    if (oldmask)
-      VG_TRACK( pre_mem_write, Vg_CorePThread, &VG_(threads)[tid],
-                               "pthread_sigmask: oldmask",
+      VG_TRACK( pre_mem_write, Vg_CorePThread, tid, "pthread_sigmask: oldmask",
                                (Addr)oldmask, sizeof(vki_ksigset_t));
 
    VG_(do_pthread_sigmask_SCSS_upd) ( tid, vki_how, newmask, oldmask );
@@ -3204,7 +3186,7 @@ void do__set_fhstack_entry ( ThreadId tid, Int n, ForkHandlerEntry* fh )
 
    vg_assert(VG_(is_valid_tid)(tid) 
              && VG_(threads)[tid].status == VgTs_Runnable);
-   VG_TRACK( pre_mem_read, Vg_CorePThread, &VG_(threads)[tid],
+   VG_TRACK( pre_mem_read, Vg_CorePThread, tid,
                            "pthread_atfork: prepare/parent/child",
                            (Addr)fh, sizeof(ForkHandlerEntry));
 
@@ -3230,8 +3212,7 @@ void do__get_fhstack_entry ( ThreadId tid, Int n, /*OUT*/
 
    vg_assert(VG_(is_valid_tid)(tid) 
              && VG_(threads)[tid].status == VgTs_Runnable);
-   VG_TRACK( pre_mem_write, Vg_CorePThread, &VG_(threads)[tid],
-                            "fork: prepare/parent/child",
+   VG_TRACK( pre_mem_write, Vg_CorePThread, tid, "fork: prepare/parent/child",
                             (Addr)fh, sizeof(ForkHandlerEntry));
 
    if (n < 0 || n >= VG_N_FORKHANDLERSTACK) {
@@ -3271,7 +3252,6 @@ UInt VG_(get_exit_status_shadow) ( void )
 static
 void do_client_request ( ThreadId tid )
 {
-   ThreadState* tst    = &VG_(threads)[tid];
    UInt*        arg    = (UInt*)(VG_(threads)[tid].m_eax);
    UInt         req_no = arg[0];
 
@@ -3299,27 +3279,6 @@ void do_client_request ( ThreadId tid )
          break;
       }
 
-      case VG_USERREQ__CLIENT_tstCALL0: {
-         UInt (*f)(ThreadState*) = (void*)arg[1];
-         SET_CLCALL_RETVAL(tid, f ( tst ), (Addr)f );
-         break;
-      }
-      case VG_USERREQ__CLIENT_tstCALL1: {
-         UInt (*f)(ThreadState*, UInt) = (void*)arg[1];
-         SET_CLCALL_RETVAL(tid, f ( tst, arg[2] ), (Addr)f );
-         break;
-      }
-      case VG_USERREQ__CLIENT_tstCALL2: {
-         UInt (*f)(ThreadState*, UInt, UInt) = (void*)arg[1];
-         SET_CLCALL_RETVAL(tid, f ( tst, arg[2], arg[3] ), (Addr)f );
-         break;
-      }
-      case VG_USERREQ__CLIENT_tstCALL3: {
-         UInt (*f)(ThreadState*, UInt, UInt, UInt) = (void*)arg[1];
-         SET_CLCALL_RETVAL(tid, f ( tst, arg[2], arg[3], arg[4] ), (Addr)f );
-         break;
-      }
-
       /* Note:  for skins that replace malloc() et al, we want to call
          the replacement versions.  For those that don't, we want to call
          VG_(cli_malloc)() et al.  We do this by calling SK_(malloc)(), which
@@ -3331,14 +3290,14 @@ void do_client_request ( ThreadId tid )
       case VG_USERREQ__MALLOC:
          VG_(sk_malloc_called_by_scheduler) = True;
          SET_PTHREQ_RETVAL(
-            tid, (UInt)SK_(malloc) ( tst, arg[1] ) 
+            tid, (UInt)SK_(malloc) ( arg[1] ) 
          );
          VG_(sk_malloc_called_by_scheduler) = False;
          break;
 
       case VG_USERREQ__FREE:
          VG_(sk_malloc_called_by_scheduler) = True;
-         SK_(free) ( tst, (void*)arg[1] );
+         SK_(free) ( (void*)arg[1] );
          VG_(sk_malloc_called_by_scheduler) = False;
 	 SET_PTHREQ_RETVAL(tid, 0); /* irrelevant */
          break;
@@ -3561,7 +3520,7 @@ void do_client_request ( ThreadId tid )
                VG_(printf)("client request: code %d,  addr %p,  len %d\n",
                            arg[0], (void*)arg[1], arg[2] );
 
-	    if (SK_(handle_client_request) ( &VG_(threads)[tid], arg, &ret ))
+	    if (SK_(handle_client_request) ( tid, arg, &ret ))
 		SET_CLREQ_RETVAL(tid, ret);
          } else {
 	    static Bool whined = False;
diff --git a/coregrind/vg_signals.c b/coregrind/vg_signals.c
index 3c9ba1ca9d..22ce5399cc 100644
--- a/coregrind/vg_signals.c
+++ b/coregrind/vg_signals.c
@@ -991,7 +991,7 @@ void vg_push_signal_frame ( ThreadId tid, int sigNo )
               == ((Char*)(esp_top_of_frame)) );
 
    /* retaddr, sigNo, psigInfo, puContext fields are to be written */
-   VG_TRACK( pre_mem_write, Vg_CoreSignal, tst, "signal handler frame", 
+   VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame", 
                             (Addr)esp, 16 );
    frame->retaddr    = (UInt)(&VG_(signalreturn_bogusRA));
    frame->sigNo      = sigNo;
diff --git a/coregrind/vg_syscalls.c b/coregrind/vg_syscalls.c
index 291cddf9c2..09b90077c0 100644
--- a/coregrind/vg_syscalls.c
+++ b/coregrind/vg_syscalls.c
@@ -226,26 +226,24 @@ Char *strdupcat ( const Char *s1, const Char *s2, ArenaId aid )
 }
 
 static 
-void pre_mem_read_sendmsg ( ThreadState* tst, 
-                            Char *msg, UInt base, UInt size )
+void pre_mem_read_sendmsg ( ThreadId tid, Char *msg, UInt base, UInt size )
 {
    Char *outmsg = strdupcat ( "socketcall.sendmsg", msg, VG_AR_TRANSIENT );
-   SYSCALL_TRACK( pre_mem_read, tst, outmsg, base, size );
+   SYSCALL_TRACK( pre_mem_read, tid, outmsg, base, size );
 
    VG_(arena_free) ( VG_AR_TRANSIENT, outmsg );
 }
 
 static 
-void pre_mem_write_recvmsg ( ThreadState* tst, 
-                             Char *msg, UInt base, UInt size )
+void pre_mem_write_recvmsg ( ThreadId tid, Char *msg, UInt base, UInt size )
 {
    Char *outmsg = strdupcat ( "socketcall.recvmsg", msg, VG_AR_TRANSIENT );
-   SYSCALL_TRACK( pre_mem_write, tst, outmsg, base, size );
+   SYSCALL_TRACK( pre_mem_write, tid, outmsg, base, size );
    VG_(arena_free) ( VG_AR_TRANSIENT, outmsg );
 }
 
 static
-void post_mem_write_recvmsg ( ThreadState* tst,
+void post_mem_write_recvmsg ( ThreadId tid,
                               Char *fieldName, UInt base, UInt size )
 {
    VG_TRACK( post_mem_write, base, size );
@@ -253,18 +251,18 @@ void post_mem_write_recvmsg ( ThreadState* tst,
  
 static
 void msghdr_foreachfield ( 
-        ThreadState* tst, 
+        ThreadId tid, 
         struct msghdr *msg, 
-        void (*foreach_func)( ThreadState*, Char *, UInt, UInt ) 
+        void (*foreach_func)( ThreadId, Char *, UInt, UInt ) 
      )
 {
    if ( !msg )
       return;
 
-   foreach_func ( tst, "(msg)", (Addr)msg, sizeof( struct msghdr ) );
+   foreach_func ( tid, "(msg)", (Addr)msg, sizeof( struct msghdr ) );
 
    if ( msg->msg_name )
-      foreach_func ( tst, 
+      foreach_func ( tid, 
                      "(msg.msg_name)", 
                      (Addr)msg->msg_name, msg->msg_namelen );
 
@@ -272,26 +270,25 @@ void msghdr_foreachfield (
       struct iovec *iov = msg->msg_iov;
       UInt i;
 
-      foreach_func ( tst, 
+      foreach_func ( tid, 
                      "(msg.msg_iov)", 
                      (Addr)iov, msg->msg_iovlen * sizeof( struct iovec ) );
 
       for ( i = 0; i < msg->msg_iovlen; ++i, ++iov )
-         foreach_func ( tst, 
+         foreach_func ( tid, 
                         "(msg.msg_iov[i]", 
                         (Addr)iov->iov_base, iov->iov_len );
    }
 
    if ( msg->msg_control )
-      foreach_func ( tst, 
+      foreach_func ( tid, 
                      "(msg.msg_control)", 
                      (Addr)msg->msg_control, msg->msg_controllen );
 }
 
 static
-void pre_mem_read_sockaddr ( ThreadState* tst,
-                                 Char *description,
-                                 struct sockaddr *sa, UInt salen )
+void pre_mem_read_sockaddr ( ThreadId tid, Char *description,
+                             struct sockaddr *sa, UInt salen )
 {
    Char *outmsg;
 
@@ -302,44 +299,44 @@ void pre_mem_read_sockaddr ( ThreadState* tst,
                                 strlen( description ) + 30 );
 
    VG_(sprintf) ( outmsg, description, ".sa_family" );
-   SYSCALL_TRACK( pre_mem_read, tst, outmsg, 
+   SYSCALL_TRACK( pre_mem_read, tid, outmsg, 
                   (UInt) &sa->sa_family, sizeof (sa_family_t));
                
    switch (sa->sa_family) {
                   
       case AF_UNIX:
          VG_(sprintf) ( outmsg, description, ".sun_path" );
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, outmsg,
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, outmsg,
             (UInt) ((struct sockaddr_un *) sa)->sun_path);
          break;
                      
       case AF_INET:
          VG_(sprintf) ( outmsg, description, ".sin_port" );
-         SYSCALL_TRACK( pre_mem_read, tst, outmsg,
+         SYSCALL_TRACK( pre_mem_read, tid, outmsg,
             (UInt) &((struct sockaddr_in *) sa)->sin_port,
             sizeof (((struct sockaddr_in *) sa)->sin_port));
          VG_(sprintf) ( outmsg, description, ".sin_addr" );
-         SYSCALL_TRACK( pre_mem_read, tst, outmsg,
+         SYSCALL_TRACK( pre_mem_read, tid, outmsg,
             (UInt) &((struct sockaddr_in *) sa)->sin_addr,
             sizeof (struct in_addr));
          break;
                            
       case AF_INET6:
          VG_(sprintf) ( outmsg, description, ".sin6_port" );
-         SYSCALL_TRACK( pre_mem_read, tst, outmsg,
+         SYSCALL_TRACK( pre_mem_read, tid, outmsg,
             (UInt) &((struct sockaddr_in6 *) sa)->sin6_port,
             sizeof (((struct sockaddr_in6 *) sa)->sin6_port));
          VG_(sprintf) ( outmsg, description, ".sin6_flowinfo" );
-         SYSCALL_TRACK( pre_mem_read, tst, outmsg,
+         SYSCALL_TRACK( pre_mem_read, tid, outmsg,
             (UInt) &((struct sockaddr_in6 *) sa)->sin6_flowinfo,
             sizeof (uint32_t));
          VG_(sprintf) ( outmsg, description, ".sin6_addr" );
-         SYSCALL_TRACK( pre_mem_read, tst, outmsg,
+         SYSCALL_TRACK( pre_mem_read, tid, outmsg,
             (UInt) &((struct sockaddr_in6 *) sa)->sin6_addr,
             sizeof (struct in6_addr));
 #        ifndef GLIBC_2_1
          VG_(sprintf) ( outmsg, description, ".sin6_scope_id" );
-         SYSCALL_TRACK( pre_mem_read, tst, outmsg,
+         SYSCALL_TRACK( pre_mem_read, tid, outmsg,
             (UInt) &((struct sockaddr_in6 *) sa)->sin6_scope_id,
             sizeof (uint32_t));
 #        endif
@@ -347,7 +344,7 @@ void pre_mem_read_sockaddr ( ThreadState* tst,
                
       default:
          VG_(sprintf) ( outmsg, description, "" );
-         SYSCALL_TRACK( pre_mem_read, tst, outmsg, (UInt) sa, salen );
+         SYSCALL_TRACK( pre_mem_read, tid, outmsg, (UInt) sa, salen );
          break;
    }
    
@@ -355,10 +352,10 @@ void pre_mem_read_sockaddr ( ThreadState* tst,
 }
 
 /* Dereference a pointer to a UInt. */
-static UInt deref_UInt ( ThreadState* tst, Addr a, Char* s )
+static UInt deref_UInt ( ThreadId tid, Addr a, Char* s )
 {
    UInt* a_p = (UInt*)a;
-   SYSCALL_TRACK( pre_mem_read, tst, s, (Addr)a_p, sizeof(UInt) );
+   SYSCALL_TRACK( pre_mem_read, tid, s, (Addr)a_p, sizeof(UInt) );
    if (a_p == NULL)
       return 0;
    else
@@ -366,32 +363,32 @@ static UInt deref_UInt ( ThreadState* tst, Addr a, Char* s )
 }
 
 /* Dereference a pointer to a pointer. */
-static Addr deref_Addr ( ThreadState* tst, Addr a, Char* s )
+static Addr deref_Addr ( ThreadId tid, Addr a, Char* s )
 {
    Addr* a_p = (Addr*)a;
-   SYSCALL_TRACK( pre_mem_read, tst, s, (Addr)a_p, sizeof(Addr) );
+   SYSCALL_TRACK( pre_mem_read, tid, s, (Addr)a_p, sizeof(Addr) );
    return *a_p;
 }
 
 static 
-void buf_and_len_pre_check( ThreadState* tst, Addr buf_p, Addr buflen_p,
+void buf_and_len_pre_check( ThreadId tid, Addr buf_p, Addr buflen_p,
                             Char* buf_s, Char* buflen_s )
 {
    if (VG_(track_events).pre_mem_write) {
-      UInt buflen_in = deref_UInt( tst, buflen_p, buflen_s);
+      UInt buflen_in = deref_UInt( tid, buflen_p, buflen_s);
       if (buflen_in > 0) {
          VG_(track_events).pre_mem_write ( Vg_CoreSysCall,
-                                           tst, buf_s, buf_p, buflen_in );
+                                           tid, buf_s, buf_p, buflen_in );
       }
    }
 }
 
 static 
-void buf_and_len_post_check( ThreadState* tst, Int res,
+void buf_and_len_post_check( ThreadId tid, Int res,
                              Addr buf_p, Addr buflen_p, Char* s )
 {
    if (!VG_(is_kerror)(res) && VG_(track_events).post_mem_write) {
-      UInt buflen_out = deref_UInt( tst, buflen_p, s);
+      UInt buflen_out = deref_UInt( tid, buflen_p, s);
       if (buflen_out > 0 && buf_p != (Addr)NULL) {
          VG_(track_events).post_mem_write ( buf_p, buflen_out );
       }
@@ -521,31 +518,31 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          MAYBE_PRINTF("ptrace ( %d, %d, %p, %p )\n", arg1,arg2,arg3,arg4);
          switch (arg1) {
              case 12:   /* PTRACE_GETREGS */
-                 SYSCALL_TRACK( pre_mem_write, tst, "ptrace(getregs)", arg4, 
+                 SYSCALL_TRACK( pre_mem_write, tid, "ptrace(getregs)", arg4, 
                                    sizeof (struct user_regs_struct));
                  break;
              case 14:   /* PTRACE_GETFPREGS */
-                 SYSCALL_TRACK( pre_mem_write, tst, "ptrace(getfpregs)", arg4, 
+                 SYSCALL_TRACK( pre_mem_write, tid, "ptrace(getfpregs)", arg4, 
                                    sizeof (struct user_fpregs_struct));
                  break;
              case 18:   /* PTRACE_GETFPXREGS */
-                 SYSCALL_TRACK( pre_mem_write, tst, "ptrace(getfpxregs)", arg4, 
+                 SYSCALL_TRACK( pre_mem_write, tid, "ptrace(getfpxregs)", arg4, 
                                    sizeof_struct_user_fpxregs_struct);
                  break;
             case 1: case 2: case 3:    /* PTRACE_PEEK{TEXT,DATA,USER} */
-                 SYSCALL_TRACK( pre_mem_write, tst, "ptrace(peek)", arg4, 
+                 SYSCALL_TRACK( pre_mem_write, tid, "ptrace(peek)", arg4, 
                                    sizeof (long));
                  break;
              case 13:   /* PTRACE_SETREGS */
-                 SYSCALL_TRACK( pre_mem_read, tst, "ptrace(setregs)", arg4, 
+                 SYSCALL_TRACK( pre_mem_read, tid, "ptrace(setregs)", arg4, 
                                    sizeof (struct user_regs_struct));
                  break;
              case 15:   /* PTRACE_SETFPREGS */
-                 SYSCALL_TRACK( pre_mem_read, tst, "ptrace(setfpregs)", arg4, 
+                 SYSCALL_TRACK( pre_mem_read, tid, "ptrace(setfpregs)", arg4, 
                                    sizeof (struct user_fpregs_struct));
                  break;
              case 19:   /* PTRACE_SETFPXREGS */
-                 SYSCALL_TRACK( pre_mem_read, tst, "ptrace(setfpxregs)", arg4, 
+                 SYSCALL_TRACK( pre_mem_read, tid, "ptrace(setfpxregs)", arg4, 
                                    sizeof_struct_user_fpxregs_struct);
                  break;
              default:
@@ -583,9 +580,9 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             const char *filesystemtype, unsigned long rwflag,
             const void *data); */
          MAYBE_PRINTF( "mount( %p, %p, %p )\n" ,arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst,"mount(specialfile)",arg1);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst,"mount(dir)",arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst,"mount(filesystemtype)",arg3);
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid,"mount(specialfile)",arg1);
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid,"mount(dir)",arg2);
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid,"mount(filesystemtype)",arg3);
          KERNEL_DO_SYSCALL(tid,res);
          break;
 #     endif
@@ -594,7 +591,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_umount: /* syscall 22 */
          /* int umount(const char *path) */
          MAYBE_PRINTF("umount( %p )\n", arg1);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst,"umount(path)",arg1);
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid,"umount(path)",arg1);
          KERNEL_DO_SYSCALL(tid,res);
          break;
 #     endif
@@ -606,12 +603,12 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          MAYBE_PRINTF("modify_ldt ( %d, %p, %d )\n", arg1,arg2,arg3);
          if (arg1 == 0) {
             /* read the LDT into ptr */
-            SYSCALL_TRACK( pre_mem_write, tst, 
+            SYSCALL_TRACK( pre_mem_write, tid, 
                            "modify_ldt(ptr)(func=0)", arg2, arg3 );
          }
          if (arg1 == 1 || arg1 == 0x11) {
             /* write the LDT with the entry pointed at by ptr */
-            SYSCALL_TRACK( pre_mem_read, tst, 
+            SYSCALL_TRACK( pre_mem_read, tid, 
                            "modify_ldt(ptr)(func=1 or 0x11)", arg2, 
                            sizeof(struct vki_modify_ldt_ldt_s) );
          }
@@ -658,9 +655,9 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          if (VG_(clo_trace_syscalls))
              VG_(printf)("setxattr ( %p, %p, %p, %d, %d )\n",
                          arg1, arg2, arg3, arg4, arg5);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "setxattr(path)", arg1 );
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "setxattr(name)", arg2 );
-         SYSCALL_TRACK( pre_mem_read, tst, "setxattr(value)", arg3, arg4 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "setxattr(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "setxattr(name)", arg2 );
+         SYSCALL_TRACK( pre_mem_read, tid, "setxattr(value)", arg3, arg4 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 #     endif
@@ -672,8 +669,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          if (VG_(clo_trace_syscalls))
              VG_(printf)("fsetxattr ( %d, %p, %p, %d, %d )\n",
                          arg1, arg2, arg3, arg4, arg5);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "fsetxattr(name)", arg2 );
-         SYSCALL_TRACK( pre_mem_read, tst, "fsetxattr(value)", arg3, arg4 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "fsetxattr(name)", arg2 );
+         SYSCALL_TRACK( pre_mem_read, tid, "fsetxattr(value)", arg3, arg4 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 #     endif
@@ -687,9 +684,9 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                                void *value, size_t size); */
          MAYBE_PRINTF("getxattr ( %p, %p, %p, %d )\n", 
                         arg1,arg2,arg3, arg4);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "getxattr(path)", arg1 );
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "getxattr(name)", arg2 );
-         SYSCALL_TRACK( pre_mem_write, tst, "getxattr(value)", arg3, arg4 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "getxattr(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "getxattr(name)", arg2 );
+         SYSCALL_TRACK( pre_mem_write, tid, "getxattr(value)", arg3, arg4 );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res > 0 
                                   && arg3 != (Addr)NULL) {
@@ -705,8 +702,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          if (VG_(clo_trace_syscalls))
              VG_(printf)("fgetxattr ( %d, %p, %p, %d )\n",
                          arg1, arg2, arg3, arg4);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "fgetxattr(name)", arg2 );
-         SYSCALL_TRACK( pre_mem_write, tst, "fgetxattr(value)", arg3, arg4 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "fgetxattr(name)", arg2 );
+         SYSCALL_TRACK( pre_mem_write, tid, "fgetxattr(value)", arg3, arg4 );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res > 0 && arg3 != (Addr)NULL)
              VG_TRACK( post_mem_write, arg3, res );
@@ -720,8 +717,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* ssize_t llistxattr (const char *path, char *list, size_t size); */
          if (VG_(clo_trace_syscalls))
              VG_(printf)("listxattr ( %p, %p, %d )\n", arg1, arg2, arg3);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "listxattr(path)", arg1 );
-         SYSCALL_TRACK( pre_mem_write, tst, "listxattr(list)", arg2, arg3 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "listxattr(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_write, tid, "listxattr(list)", arg2, arg3 );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res > 0 && arg2 != (Addr)NULL)
              VG_TRACK( post_mem_write, arg2, res );
@@ -733,7 +730,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* ssize_t flistxattr (int filedes, char *list, size_t size); */
          if (VG_(clo_trace_syscalls))
              VG_(printf)("flistxattr ( %d, %p, %d )\n", arg1, arg2, arg3);
-         SYSCALL_TRACK( pre_mem_write, tst, "listxattr(list)", arg2, arg3 );
+         SYSCALL_TRACK( pre_mem_write, tid, "listxattr(list)", arg2, arg3 );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res > 0 && arg2 != (Addr)NULL)
              VG_TRACK( post_mem_write, arg2, res );
@@ -747,8 +744,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* int lremovexattr (const char *path, const char *name); */
          if (VG_(clo_trace_syscalls))
              VG_(printf)("removexattr ( %p, %p )\n", arg1, arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "listxattr(path)", arg1 );
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "listxattr(name)", arg2 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "listxattr(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "listxattr(name)", arg2 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 #     endif
@@ -758,7 +755,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* int fremovexattr (int filedes, const char *name); */
          if (VG_(clo_trace_syscalls))
              VG_(printf)("removexattr ( %d, %p )\n", arg1, arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "listxattr(name)", arg2 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "listxattr(name)", arg2 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 #     endif
@@ -768,7 +765,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* int quotactl(int cmd, char *special, int uid, caddr_t addr); */
          MAYBE_PRINTF("quotactl (0x%x, %p, 0x%x, 0x%x )\n", 
                         arg1,arg2,arg3, arg4);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "quotactl(special)", arg2 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "quotactl(special)", arg2 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 #     endif
@@ -778,7 +775,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* int lookup_dcookie (uint64_t cookie, char *buf, size_t sz); */
          MAYBE_PRINTF("lookup_dcookie (0x%llx, %p, %d)\n",
                      arg1 | ((long long) arg2 << 32), arg3, arg4);
-         SYSCALL_TRACK( pre_mem_write, tst, "lookup_dcookie(buf)", arg3, arg4);
+         SYSCALL_TRACK( pre_mem_write, tid, "lookup_dcookie(buf)", arg3, arg4);
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && arg3 != (Addr)NULL)
              VG_TRACK( post_mem_write, arg3, res);
@@ -790,7 +787,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* int truncate64(const char *path, off64_t length); */
          MAYBE_PRINTF("truncate64 ( %p, %lld )\n",
                         arg1, ((ULong)arg2) | (((ULong) arg3) << 32));
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "truncate64(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "truncate64(path)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 #     endif
@@ -807,7 +804,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_msync:
          /* int msync(const void *start, size_t length, int flags); */
          MAYBE_PRINTF("msync ( %p, %d, %d )\n", arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_read, tst, "msync(start)", arg1, arg2 );
+         SYSCALL_TRACK( pre_mem_read, tid, "msync(start)", arg1, arg2 );
          KERNEL_DO_SYSCALL(tid,res);  
          break;
 #     endif
@@ -830,16 +827,16 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       ctrl = (struct strbuf *)arg2;
       data = (struct strbuf *)arg3;
       if (ctrl && ctrl->maxlen > 0)
-          SYSCALL_TRACK( pre_mem_write,tst, "getpmsg(ctrl)", 
+          SYSCALL_TRACK( pre_mem_write, tid, "getpmsg(ctrl)", 
                                 (UInt)ctrl->buf, ctrl->maxlen);
       if (data && data->maxlen > 0)
-          SYSCALL_TRACK( pre_mem_write,tst, "getpmsg(data)", 
+          SYSCALL_TRACK( pre_mem_write, tid, "getpmsg(data)", 
                                  (UInt)data->buf, data->maxlen);
       if (arg4)
-          SYSCALL_TRACK( pre_mem_write,tst, "getpmsg(bandp)", 
+          SYSCALL_TRACK( pre_mem_write, tid, "getpmsg(bandp)", 
                                 (UInt)arg4, sizeof(int));
       if (arg5)
-          SYSCALL_TRACK( pre_mem_write,tst, "getpmsg(flagsp)", 
+          SYSCALL_TRACK( pre_mem_write, tid, "getpmsg(flagsp)", 
                                 (UInt)arg5, sizeof(int));
       KERNEL_DO_SYSCALL(tid,res);
       if (!VG_(is_kerror)(res) && res == 0 && ctrl && ctrl->len > 0) {
@@ -871,10 +868,10 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       ctrl = (struct strbuf *)arg2;
       data = (struct strbuf *)arg3;
       if (ctrl && ctrl->len > 0)
-          SYSCALL_TRACK( pre_mem_read,tst, "putpmsg(ctrl)",
+          SYSCALL_TRACK( pre_mem_read, tid, "putpmsg(ctrl)",
                                 (UInt)ctrl->buf, ctrl->len);
       if (data && data->len > 0)
-          SYSCALL_TRACK( pre_mem_read,tst, "putpmsg(data)",
+          SYSCALL_TRACK( pre_mem_read, tid, "putpmsg(data)",
                                 (UInt)data->buf, data->len);
       KERNEL_DO_SYSCALL(tid,res);
       }
@@ -884,7 +881,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_getitimer: /* syscall 105 */
          /* int getitimer(int which, struct itimerval *value); */
          MAYBE_PRINTF("getitimer ( %d, %p )\n", arg1, arg2);
-         SYSCALL_TRACK( pre_mem_write, tst, "getitimer(timer)", arg2, 
+         SYSCALL_TRACK( pre_mem_write, tid, "getitimer(timer)", arg2, 
                            sizeof(struct itimerval) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && arg2 != (Addr)NULL) {
@@ -898,7 +895,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          MAYBE_PRINTF("syslog (%d, %p, %d)\n",arg1,arg2,arg3);
          switch(arg1) {
             case 2: case 3: case 4:
-               SYSCALL_TRACK( pre_mem_write, tst, "syslog(buf)", arg2, arg3);
+               SYSCALL_TRACK( pre_mem_write, tid, "syslog(buf)", arg2, arg3);
 	       break;
             default: 
                break;
@@ -925,7 +922,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_chroot: /* syscall 61 */
          /* int chroot(const char *path); */
          MAYBE_PRINTF("chroot ( %p )\n", arg1);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "chroot(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "chroot(path)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
@@ -944,7 +941,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                          size_t new_size, unsigned long flags); */
          MAYBE_PRINTF("mremap ( %p, %d, %d, 0x%x )\n", 
                         arg1, arg2, arg3, arg4);
-         SYSCALL_TRACK( pre_mem_write, tst, "mremap(old_address)", arg1, arg2 );
+         SYSCALL_TRACK( pre_mem_write, tid, "mremap(old_address)", arg1, arg2 );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res)) {
             mremap_segment( arg1, arg2, (Addr)res, arg3 );
@@ -980,7 +977,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR__sysctl:
       /* int _sysctl(struct __sysctl_args *args); */
          MAYBE_PRINTF("_sysctl ( %p )\n", arg1 );
-         SYSCALL_TRACK( pre_mem_write, tst, "_sysctl(args)", arg1, 
+         SYSCALL_TRACK( pre_mem_write, tid, "_sysctl(args)", arg1, 
                             sizeof(struct __sysctl_args) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
@@ -1002,7 +999,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                 const struct sched_param *p); */
          MAYBE_PRINTF("sched_setscheduler ( %d, %d, %p )\n",arg1,arg2,arg3);
          if (arg3 != (UInt)NULL)
-            SYSCALL_TRACK( pre_mem_read, tst,
+            SYSCALL_TRACK( pre_mem_read, tid,
                               "sched_setscheduler(struct sched_param *p)", 
                               arg3, sizeof(struct sched_param));
          KERNEL_DO_SYSCALL(tid,res);
@@ -1113,7 +1110,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                              size_t count) */
          MAYBE_PRINTF("sendfile ( %d, %d, %p, %d )\n",arg1,arg2,arg3,arg4);
          if (arg3 != (UInt)NULL)
-            SYSCALL_TRACK( pre_mem_write, tst, "sendfile(offset)",
+            SYSCALL_TRACK( pre_mem_write, tid, "sendfile(offset)",
                            arg3, sizeof(off_t) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && arg3 != (UInt)NULL) {
@@ -1129,7 +1126,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                                 size_t count); */
          MAYBE_PRINTF("sendfile64 ( %d, %d, %p, %d )\n",arg1,arg2,arg3,arg4);
          if (arg3 != (UInt)NULL)
-            SYSCALL_TRACK( pre_mem_write, tst, "sendfile64(offset)",
+            SYSCALL_TRACK( pre_mem_write, tid, "sendfile64(offset)",
                            arg3, sizeof(loff_t) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && arg3 != (UInt)NULL ) {
@@ -1145,7 +1142,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* ssize_t pwrite (int fd, const void *buf, size_t nbytes,
                             off_t offset); */
          MAYBE_PRINTF("pwrite ( %d, %p, %d, %d )\n", arg1, arg2, arg3, arg4);
-         SYSCALL_TRACK( pre_mem_read, tst, "pwrite(buf)", arg2, arg3 );
+         SYSCALL_TRACK( pre_mem_read, tid, "pwrite(buf)", arg2, arg3 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 #     endif
@@ -1161,7 +1158,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_fstatfs: /* syscall 100 */
          /* int fstatfs(int fd, struct statfs *buf); */
          MAYBE_PRINTF("fstatfs ( %d, %p )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_write, tst, "stat(buf)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "stat(buf)", 
                         arg2, sizeof(struct statfs) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
@@ -1186,7 +1183,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_pread: /* syscall 180 */
          /* ssize_t pread(int fd, void *buf, size_t count, off_t offset); */
          MAYBE_PRINTF("pread ( %d, %p, %d, %d ) ...\n",arg1,arg2,arg3,arg4);
-         SYSCALL_TRACK( pre_mem_write, tst, "pread(buf)", arg2, arg3 );
+         SYSCALL_TRACK( pre_mem_write, tid, "pread(buf)", arg2, arg3 );
          KERNEL_DO_SYSCALL(tid,res);
          MAYBE_PRINTF("SYSCALL[%d]       pread ( %d, %p, %d, %d ) --> %d\n",
                         VG_(getpid)(),
@@ -1202,7 +1199,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_mknod: /* syscall 14 */
          /* int mknod(const char *pathname, mode_t mode, dev_t dev); */
          MAYBE_PRINTF("mknod ( %p, 0x%x, 0x%x )\n", arg1, arg2, arg3 );
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "mknod(pathname)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "mknod(pathname)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
@@ -1220,7 +1217,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          MAYBE_PRINTF("sigsuspend ( %p )\n", arg1 );
          if (arg1 != (Addr)NULL) {
             /* above NULL test is paranoia */
-            SYSCALL_TRACK( pre_mem_read, tst, "sigsuspend(mask)", arg1, 
+            SYSCALL_TRACK( pre_mem_read, tid, "sigsuspend(mask)", arg1, 
                               sizeof(vki_ksigset_t) );
          }
          KERNEL_DO_SYSCALL(tid,res);
@@ -1232,7 +1229,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
           /* int sigtimedwait(const  sigset_t  *set,  siginfo_t  *info,
                               const struct timespec timeout); */
          if (arg2 != (UInt)NULL)
-            SYSCALL_TRACK( pre_mem_write, tst, "sigtimedwait(info)", arg2,
+            SYSCALL_TRACK( pre_mem_write, tid, "sigtimedwait(info)", arg2,
                            sizeof(siginfo_t) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && arg2 != (UInt)NULL)
@@ -1243,8 +1240,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_init_module: /* syscall 128 */
          /* int init_module(const char *name, struct module *image); */
          MAYBE_PRINTF("init_module ( %p, %p )\n", arg1, arg2 );
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "init_module(name)", arg1 );
-         SYSCALL_TRACK( pre_mem_read, tst, "init_module(image)", arg2, 
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "init_module(name)", arg1 );
+         SYSCALL_TRACK( pre_mem_read, tid, "init_module(image)", arg2, 
                            VKI_SIZEOF_STRUCT_MODULE );
          KERNEL_DO_SYSCALL(tid,res);
          break;
@@ -1258,9 +1255,9 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_capget: /* syscall 184 */
          /* int capget(cap_user_header_t header, cap_user_data_t data); */
          MAYBE_PRINTF("capget ( %p, %p )\n", arg1, arg2 );
-         SYSCALL_TRACK( pre_mem_read, tst, "capget(header)", arg1, 
+         SYSCALL_TRACK( pre_mem_read, tid, "capget(header)", arg1, 
                                              sizeof(vki_cap_user_header_t) );
-         SYSCALL_TRACK( pre_mem_write, tst, "capget(data)", arg2, 
+         SYSCALL_TRACK( pre_mem_write, tid, "capget(data)", arg2, 
                                            sizeof( vki_cap_user_data_t) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && arg2 != (Addr)NULL)
@@ -1271,9 +1268,9 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
 #     if defined(__NR_capset)
       /* int capset(cap_user_header_t header, const cap_user_data_t data); */
       case __NR_capset: /* syscall 185 */ 
-         SYSCALL_TRACK( pre_mem_read, tst, "capset(header)", 
+         SYSCALL_TRACK( pre_mem_read, tid, "capset(header)", 
                         arg1, sizeof(vki_cap_user_header_t) );
-         SYSCALL_TRACK( pre_mem_read, tst, "capset(data)", 
+         SYSCALL_TRACK( pre_mem_read, tid, "capset(data)", 
                         arg2, sizeof( vki_cap_user_data_t) );
          KERNEL_DO_SYSCALL(tid,res);
          break;
@@ -1320,7 +1317,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_access: /* syscall 33 */
          /* int access(const char *pathname, int mode); */
          MAYBE_PRINTF("access ( %p, %d )\n", arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "access(pathname)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "access(pathname)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
@@ -1364,14 +1361,14 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_chdir: /* syscall 12 */
          /* int chdir(const char *path); */
          MAYBE_PRINTF("chdir ( %p )\n", arg1);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "chdir(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "chdir(path)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
       case __NR_chmod: /* syscall 15 */
          /* int chmod(const char *path, mode_t mode); */
          MAYBE_PRINTF("chmod ( %p, %d )\n", arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "chmod(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "chmod(path)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
@@ -1384,7 +1381,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_chown: /* syscall 16 */
          /* int chown(const char *path, uid_t owner, gid_t group); */
          MAYBE_PRINTF("chown ( %p, 0x%x, 0x%x )\n", arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "chown(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "chown(path)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
@@ -1464,7 +1461,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_fstat: /* syscall 108 */
          /* int fstat(int filedes, struct stat *buf); */
          MAYBE_PRINTF("fstat ( %d, %p )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_write, tst, "fstat", arg2, sizeof(struct stat) );
+         SYSCALL_TRACK( pre_mem_write, tid, "fstat", arg2, sizeof(struct stat) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
             VG_TRACK( post_mem_write, arg2, sizeof(struct stat) );
@@ -1514,7 +1511,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* int getdents(unsigned int fd, struct dirent *dirp, 
                          unsigned int count); */
          MAYBE_PRINTF("getdents ( %d, %p, %d )\n",arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_write, tst, "getdents(dirp)", arg2, arg3 );
+         SYSCALL_TRACK( pre_mem_write, tid, "getdents(dirp)", arg2, arg3 );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res > 0)
             VG_TRACK( post_mem_write, arg2, res );
@@ -1525,7 +1522,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* int getdents(unsigned int fd, struct dirent64 *dirp, 
                          unsigned int count); */
          MAYBE_PRINTF("getdents64 ( %d, %p, %d )\n",arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_write, tst, "getdents64(dirp)", arg2, arg3 );
+         SYSCALL_TRACK( pre_mem_write, tid, "getdents64(dirp)", arg2, arg3 );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res > 0)
             VG_TRACK( post_mem_write, arg2, res );
@@ -1539,7 +1536,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* int getgroups(int size, gid_t list[]); */
          MAYBE_PRINTF("getgroups ( %d, %p )\n", arg1, arg2);
          if (arg1 > 0)
-            SYSCALL_TRACK( pre_mem_write, tst, "getgroups(list)", arg2, 
+            SYSCALL_TRACK( pre_mem_write, tid, "getgroups(list)", arg2, 
                                arg1 * sizeof(gid_t) );
          KERNEL_DO_SYSCALL(tid,res);
          if (arg1 > 0 && !VG_(is_kerror)(res) && res > 0)
@@ -1549,7 +1546,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_getcwd: /* syscall 183 */
          /* char *getcwd(char *buf, size_t size);  (but see comment below) */
          MAYBE_PRINTF("getcwd ( %p, %d )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_write, tst, "getcwd(buf)", arg1, arg2 );
+         SYSCALL_TRACK( pre_mem_write, tid, "getcwd(buf)", arg1, arg2 );
          KERNEL_DO_SYSCALL(tid,res);
 
          /* From linux/fs/dcache.c:
@@ -1631,11 +1628,11 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_getresgid: /* syscall 171 */
          /* int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); */
          MAYBE_PRINTF("getresgid ( %p, %p, %p )\n", arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_write, tst, "getresgid(rgid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresgid(rgid)", 
                                        arg1, sizeof(gid_t) );
-         SYSCALL_TRACK( pre_mem_write, tst, "getresgid(egid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresgid(egid)", 
                                        arg2, sizeof(gid_t) );
-         SYSCALL_TRACK( pre_mem_write, tst, "getresgid(sgid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresgid(sgid)", 
                                        arg3, sizeof(gid_t) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res == 0) {
@@ -1649,11 +1646,11 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_getresgid32: /* syscall 211 */
          /* int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); */
          MAYBE_PRINTF("getresgid32 ( %p, %p, %p )\n", arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_write, tst, "getresgid32(rgid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresgid32(rgid)", 
                                        arg1, sizeof(gid_t) );
-         SYSCALL_TRACK( pre_mem_write, tst, "getresgid32(egid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresgid32(egid)", 
                                        arg2, sizeof(gid_t) );
-         SYSCALL_TRACK( pre_mem_write, tst, "getresgid32(sgid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresgid32(sgid)", 
                                        arg3, sizeof(gid_t) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res == 0) {
@@ -1667,11 +1664,11 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_getresuid: /* syscall 165 */
          /* int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); */
          MAYBE_PRINTF("getresuid ( %p, %p, %p )\n", arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_write, tst, "getresuid(ruid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresuid(ruid)", 
                                        arg1, sizeof(uid_t) );
-         SYSCALL_TRACK( pre_mem_write, tst, "getresuid(euid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresuid(euid)", 
                                        arg2, sizeof(uid_t) );
-         SYSCALL_TRACK( pre_mem_write, tst, "getresuid(suid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresuid(suid)", 
                                        arg3, sizeof(uid_t) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res == 0) {
@@ -1685,11 +1682,11 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_getresuid32: /* syscall 209 */
          /* int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); */
          MAYBE_PRINTF("getresuid32 ( %p, %p, %p )\n", arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_write, tst, "getresuid32(ruid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresuid32(ruid)", 
                                        arg1, sizeof(uid_t) );
-         SYSCALL_TRACK( pre_mem_write, tst, "getresuid32(euid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresuid32(euid)", 
                                        arg2, sizeof(uid_t) );
-         SYSCALL_TRACK( pre_mem_write, tst, "getresuid32(suid)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "getresuid32(suid)", 
                                        arg3, sizeof(uid_t) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res == 0) {
@@ -1706,7 +1703,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_getrlimit: /* syscall 76 */
          /* int getrlimit (int resource, struct rlimit *rlim); */
          MAYBE_PRINTF("getrlimit ( %d, %p )\n", arg1,arg2);
-         SYSCALL_TRACK( pre_mem_write, tst, "getrlimit(rlim)", arg2, 
+         SYSCALL_TRACK( pre_mem_write, tid, "getrlimit(rlim)", arg2, 
                            sizeof(struct rlimit) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res == 0)
@@ -1716,7 +1713,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_getrusage: /* syscall 77 */
          /* int getrusage (int who, struct rusage *usage); */
          MAYBE_PRINTF("getrusage ( %d, %p )\n", arg1,arg2);
-         SYSCALL_TRACK( pre_mem_write, tst, "getrusage(usage)", arg2, 
+         SYSCALL_TRACK( pre_mem_write, tid, "getrusage(usage)", arg2, 
                            sizeof(struct rusage) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res == 0)
@@ -1726,10 +1723,10 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_gettimeofday: /* syscall 78 */
          /* int gettimeofday(struct timeval *tv, struct timezone *tz); */
          MAYBE_PRINTF("gettimeofday ( %p, %p )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_write, tst, "gettimeofday(tv)", arg1, 
+         SYSCALL_TRACK( pre_mem_write, tid, "gettimeofday(tv)", arg1, 
                            sizeof(struct timeval) );
          if (arg2 != 0)
-            SYSCALL_TRACK( pre_mem_write, tst, "gettimeofday(tz)", arg2, 
+            SYSCALL_TRACK( pre_mem_write, tid, "gettimeofday(tz)", arg2, 
                               sizeof(struct timezone) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res == 0) {
@@ -1763,7 +1760,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                         arg1,arg2,arg3,arg4,arg5,arg6);
          switch (arg1 /* call */) {
             case 1: /* IPCOP_semop */
-               SYSCALL_TRACK( pre_mem_read, tst, "semop(sops)", arg5, 
+               SYSCALL_TRACK( pre_mem_read, tid, "semop(sops)", arg5, 
                                   arg3 * sizeof(struct sembuf) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
@@ -1776,9 +1773,9 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                   struct msgbuf *msgp = (struct msgbuf *)arg5;
                   Int msgsz = arg3;
 
-                  SYSCALL_TRACK( pre_mem_read, tst, "msgsnd(msgp->mtype)", 
+                  SYSCALL_TRACK( pre_mem_read, tid, "msgsnd(msgp->mtype)", 
                                      (UInt)&msgp->mtype, sizeof(msgp->mtype) );
-                  SYSCALL_TRACK( pre_mem_read, tst, "msgsnd(msgp->mtext)", 
+                  SYSCALL_TRACK( pre_mem_read, tid, "msgsnd(msgp->mtext)", 
                                      (UInt)msgp->mtext, msgsz );
 
                   KERNEL_DO_SYSCALL(tid,res);
@@ -1789,13 +1786,13 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                   struct msgbuf *msgp;
                   Int msgsz = arg3;
  
-                  msgp = (struct msgbuf *)deref_Addr( tst,
+                  msgp = (struct msgbuf *)deref_Addr( tid,
                             (Addr) (&((struct ipc_kludge *)arg5)->msgp),
                             "msgrcv(msgp)" );
 
-                  SYSCALL_TRACK( pre_mem_write, tst, "msgrcv(msgp->mtype)", 
+                  SYSCALL_TRACK( pre_mem_write, tid, "msgrcv(msgp->mtype)", 
                                      (UInt)&msgp->mtype, sizeof(msgp->mtype) );
-                  SYSCALL_TRACK( pre_mem_write, tst, "msgrcv(msgp->mtext)", 
+                  SYSCALL_TRACK( pre_mem_write, tid, "msgrcv(msgp->mtext)", 
                                      (UInt)msgp->mtext, msgsz );
 
                   KERNEL_DO_SYSCALL(tid,res);
@@ -1814,7 +1811,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                {
                   switch (arg3 /* cmd */) {
                      case IPC_STAT:
-                        SYSCALL_TRACK( pre_mem_write, tst, "msgctl(buf)", arg5, 
+                        SYSCALL_TRACK( pre_mem_write, tid, "msgctl(buf)", arg5, 
                                            sizeof(struct msqid_ds) );
                         KERNEL_DO_SYSCALL(tid,res);
                         if ( !VG_(is_kerror)(res) && res > 0 ) {
@@ -1823,13 +1820,13 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                         }
                         break;
                      case IPC_SET:
-                        SYSCALL_TRACK( pre_mem_read, tst, "msgctl(buf)", arg5, 
+                        SYSCALL_TRACK( pre_mem_read, tid, "msgctl(buf)", arg5, 
                                            sizeof(struct msqid_ds) );
                         KERNEL_DO_SYSCALL(tid,res);
                         break;
 #                    if defined(IPC_64)
                      case IPC_STAT|IPC_64:
-                        SYSCALL_TRACK( pre_mem_write, tst, "msgctl(buf)", arg5, 
+                        SYSCALL_TRACK( pre_mem_write, tid, "msgctl(buf)", arg5, 
                                            sizeof(struct msqid64_ds) );
                         KERNEL_DO_SYSCALL(tid,res);
                         if ( !VG_(is_kerror)(res) && res > 0 ) {
@@ -1840,7 +1837,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
 #                    endif
 #                    if defined(IPC_64)
                      case IPC_SET|IPC_64:
-                        SYSCALL_TRACK( pre_mem_read, tst, "msgctl(buf)", arg5, 
+                        SYSCALL_TRACK( pre_mem_read, tid, "msgctl(buf)", arg5, 
                                            sizeof(struct msqid64_ds) );
                         KERNEL_DO_SYSCALL(tid,res);
                         break;
@@ -1867,7 +1864,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                    * glibc/sysdeps/unix/sysv/linux/shmat.c */
                   VG_TRACK( post_mem_write, arg4, sizeof( ULong ) );
 
-                  addr = deref_Addr ( tst, arg4, "shmat(addr)" );
+                  addr = deref_Addr ( tid, arg4, "shmat(addr)" );
                   if ( addr > 0 ) { 
                      UInt segmentSize = get_shm_size ( shmid );
                      if ( segmentSize > 0 ) {
@@ -1919,11 +1916,11 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
 #                    endif
                      out_arg = cmd == SHM_STAT || cmd == IPC_STAT;
                      if ( out_arg )
-                        SYSCALL_TRACK( pre_mem_write, tst, 
+                        SYSCALL_TRACK( pre_mem_write, tid, 
                            "shmctl(SHM_STAT or IPC_STAT,buf)", 
                            arg5, sizeof(struct shmid_ds) );
                      else
-                        SYSCALL_TRACK( pre_mem_read, tst, 
+                        SYSCALL_TRACK( pre_mem_read, tid, 
                            "shmctl(SHM_XXXX,buf)", 
                            arg5, sizeof(struct shmid_ds) );
                   }
@@ -1959,12 +1956,12 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case TCSETS:
             case TCSETSW:
             case TCSETSF:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(TCSET{S,SW,SF})", arg3, 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TCSET{S,SW,SF})", arg3, 
                                  VKI_SIZEOF_STRUCT_TERMIOS );
                KERNEL_DO_SYSCALL(tid,res);
                break; 
             case TCGETS:
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(TCGETS)", arg3, 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TCGETS)", arg3, 
                                  VKI_SIZEOF_STRUCT_TERMIOS );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -1973,12 +1970,12 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case TCSETA:
             case TCSETAW:
             case TCSETAF:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(TCSET{A,AW,AF})", arg3,
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TCSET{A,AW,AF})", arg3,
                                  VKI_SIZEOF_STRUCT_TERMIO );
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case TCGETA:
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(TCGETA)", arg3,
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TCGETA)", arg3,
                                  VKI_SIZEOF_STRUCT_TERMIO );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -1992,22 +1989,22 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case TIOCGWINSZ:
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(TIOCGWINSZ)", arg3, 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TIOCGWINSZ)", arg3, 
                                  sizeof(struct winsize) );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
                   VG_TRACK( post_mem_write, arg3, sizeof(struct winsize) );
                break;
             case TIOCSWINSZ:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(TIOCSWINSZ)", arg3, 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCSWINSZ)", arg3, 
                                  sizeof(struct winsize) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case TIOCLINUX:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(TIOCLINUX)", arg3, 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCLINUX)", arg3, 
                                  sizeof(char *) );
                if (*(char *)arg3 == 11) {
-                  SYSCALL_TRACK( pre_mem_read, tst, "ioctl(TIOCLINUX, 11)", 
+                  SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCLINUX, 11)", 
                                     arg3, 2 * sizeof(char *) );
                }
                KERNEL_DO_SYSCALL(tid,res);
@@ -2016,7 +2013,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                break;
             case TIOCGPGRP:
                /* Get process group ID for foreground processing group. */
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(TIOCGPGRP)", arg3,
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TIOCGPGRP)", arg3,
                                  sizeof(pid_t) );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -2024,14 +2021,14 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                break;
             case TIOCSPGRP:
                /* Set a process group ID? */
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(TIOCGPGRP)", arg3,
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TIOCGPGRP)", arg3,
                                  sizeof(pid_t) );
                KERNEL_DO_SYSCALL(tid,res); 
                if (!VG_(is_kerror)(res) && res == 0)
                   VG_TRACK( post_mem_write, arg3, sizeof(pid_t) );
                break;
             case TIOCGPTN: /* Get Pty Number (of pty-mux device) */
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(TIOCGPTN)", 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TIOCGPTN)", 
                                              arg3, sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -2042,22 +2039,22 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case TIOCSPTLCK: /* Lock/unlock Pty */
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(TIOCSPTLCK)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCSPTLCK)", 
                                             arg3, sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case FIONBIO:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(FIONBIO)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(FIONBIO)", 
                                             arg3, sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case FIOASYNC:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(FIOASYNC)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(FIOASYNC)", 
                                             arg3, sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case FIONREAD:                /* identical to SIOCINQ */
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(FIONREAD)", 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(FIONREAD)", 
                                              arg3, sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -2069,13 +2066,13 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                vg_unsafe.h. */
 #       if 1
             case SG_SET_COMMAND_Q:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(SG_SET_COMMAND_Q)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SG_SET_COMMAND_Q)", 
                                  arg3, sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
 #           if defined(SG_IO)
             case SG_IO:
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SG_IO)", arg3, 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SG_IO)", arg3, 
                                  sizeof(struct sg_io_hdr) );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -2084,24 +2081,24 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
 #           endif /* SG_IO */
             case SG_GET_SCSI_ID:
                /* Note: sometimes sg_scsi_id is called sg_scsi_id_t */
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SG_GET_SCSI_ID)", arg3, 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SG_GET_SCSI_ID)", arg3, 
                                  sizeof(struct sg_scsi_id) );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
                   VG_TRACK( post_mem_write,arg3, sizeof(struct sg_scsi_id));
                break;
             case SG_SET_RESERVED_SIZE:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(SG_SET_RESERVED_SIZE)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SG_SET_RESERVED_SIZE)", 
                                  arg3, sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case SG_SET_TIMEOUT:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(SG_SET_TIMEOUT)", arg3, 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SG_SET_TIMEOUT)", arg3, 
                                  sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case SG_GET_RESERVED_SIZE:
-               SYSCALL_TRACK( pre_mem_write, tst, 
+               SYSCALL_TRACK( pre_mem_write, tid, 
                                              "ioctl(SG_GET_RESERVED_SIZE)", arg3, 
                                  sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
@@ -2109,14 +2106,14 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                   VG_TRACK( post_mem_write,arg3, sizeof(int));
                break;
             case SG_GET_TIMEOUT:
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SG_GET_TIMEOUT)", arg3, 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SG_GET_TIMEOUT)", arg3, 
                                  sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
                   VG_TRACK( post_mem_write,arg3, sizeof(int));
                break;
             case SG_GET_VERSION_NUM:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(SG_GET_VERSION_NUM)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SG_GET_VERSION_NUM)", 
                                  arg3, sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
@@ -2128,7 +2125,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
 #              ifndef ISDN_MAX_CHANNELS
 #              define ISDN_MAX_CHANNELS 64
 #              endif
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(IIOCGETCPS)", arg3,
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(IIOCGETCPS)", arg3,
                                  ISDN_MAX_CHANNELS 
                                  * 2 * sizeof(unsigned long) );
                KERNEL_DO_SYSCALL(tid,res);
@@ -2137,10 +2134,10 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                                         * 2 * sizeof(unsigned long) );
                break;
             case IIOCNETGPN:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(IIOCNETGPN)",
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(IIOCNETGPN)",
                                  (UInt)&((isdn_net_ioctl_phone *)arg3)->name,
                                  sizeof(((isdn_net_ioctl_phone *)arg3)->name) );
-               SYSCALL_TRACK( pre_mem_write, tst, "ioctl(IIOCNETGPN)", arg3,
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(IIOCNETGPN)", arg3,
                                  sizeof(isdn_net_ioctl_phone) );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -2160,7 +2157,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case SIOCGIFDSTADDR:      /* get remote PA address        */
             case SIOCGIFBRDADDR:      /* get broadcast PA address     */
             case SIOCGIFNAME:         /* get iface name               */
-               SYSCALL_TRACK( pre_mem_write,tst, "ioctl(SIOCGIFINDEX)", arg3, 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFINDEX)", arg3, 
                                 sizeof(struct ifreq));
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -2174,13 +2171,13 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                if (!VG_(is_kerror)(res) && res == 0)
                   VG_TRACK( post_mem_write,arg3, sizeof(struct ifconf));
                */
-               SYSCALL_TRACK( pre_mem_read,tst, "ioctl(SIOCGIFCONF)", arg3, 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCGIFCONF)", arg3, 
                                 sizeof(struct ifconf));
                if ( arg3 ) {
                   // TODO len must be readable and writable
                   // buf pointer only needs to be readable
                   struct ifconf *ifc = (struct ifconf *) arg3;
-                  SYSCALL_TRACK( pre_mem_write,tst, "ioctl(SIOCGIFCONF).ifc_buf",
+                  SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFCONF).ifc_buf",
                                    (Addr)(ifc->ifc_buf), (UInt)(ifc->ifc_len) );
                }
                KERNEL_DO_SYSCALL(tid,res);
@@ -2192,7 +2189,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                }
                break;
             case SIOCGSTAMP:
-               SYSCALL_TRACK( pre_mem_write,tst, "ioctl(SIOCGSTAMP)", arg3, 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGSTAMP)", arg3, 
                                 sizeof(struct timeval));
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -2203,7 +2200,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                It writes this value as an int to the memory location
                indicated by the third argument of ioctl(2). */
             case SIOCOUTQ:
-               SYSCALL_TRACK( pre_mem_write,tst, "ioctl(SIOCOUTQ)", arg3, 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCOUTQ)", arg3, 
                                 sizeof(int));
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -2211,7 +2208,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                break;
             case SIOCGRARP:           /* get RARP table entry         */
             case SIOCGARP:            /* get ARP table entry          */
-               SYSCALL_TRACK( pre_mem_write,tst, "ioctl(SIOCGARP)", arg3, 
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGARP)", arg3, 
                                 sizeof(struct arpreq));
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -2228,14 +2225,14 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case SIOCSIFADDR:         /* set PA address               */
             case SIOCSIFMTU:          /* set MTU size                 */
             case SIOCSIFHWADDR:       /* set hardware address         */
-               SYSCALL_TRACK( pre_mem_read,tst,"ioctl(SIOCSIFFLAGS)", arg3, 
+               SYSCALL_TRACK( pre_mem_read, tid,"ioctl(SIOCSIFFLAGS)", arg3, 
                                 sizeof(struct ifreq));
                KERNEL_DO_SYSCALL(tid,res);
                break;
             /* Routing table calls.  */
             case SIOCADDRT:           /* add routing table entry      */
             case SIOCDELRT:           /* delete routing table entry   */
-               SYSCALL_TRACK( pre_mem_read,tst,"ioctl(SIOCADDRT/DELRT)", arg3, 
+               SYSCALL_TRACK( pre_mem_read, tid,"ioctl(SIOCADDRT/DELRT)", arg3, 
                                 sizeof(struct rtentry));
                KERNEL_DO_SYSCALL(tid,res);
                break;
@@ -2246,13 +2243,13 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             /* ARP cache control calls. */
             case SIOCSARP:            /* set ARP table entry          */
             case SIOCDARP:            /* delete ARP table entry       */
-               SYSCALL_TRACK( pre_mem_read,tst, "ioctl(SIOCSIFFLAGS)", arg3, 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSIFFLAGS)", arg3, 
                                 sizeof(struct ifreq));
                KERNEL_DO_SYSCALL(tid,res);
                break;
 
             case SIOCSPGRP:
-               SYSCALL_TRACK( pre_mem_read, tst, "ioctl(SIOCSPGRP)", arg3, 
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSPGRP)", arg3, 
                                             sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
@@ -2278,7 +2275,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case SOUND_PCM_READ_BITS:
             case (SOUND_PCM_READ_BITS|0x40000000): /* what the fuck ? */
             case SOUND_PCM_READ_FILTER:
-               SYSCALL_TRACK( pre_mem_write,tst,
+               SYSCALL_TRACK( pre_mem_write, tid,
                                  "ioctl(SNDCTL_XXX|SOUND_XXX (SIOR, int))", 
                                 arg3,
                                 sizeof(int));
@@ -2305,17 +2302,17 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case SNDCTL_TMR_SOURCE:
             case SNDCTL_MIDI_PRETIME:
             case SNDCTL_MIDI_MPUMODE:
-               SYSCALL_TRACK( pre_mem_read,tst, "ioctl(SNDCTL_XXX|SOUND_XXX "
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SNDCTL_XXX|SOUND_XXX "
                                      "(SIOWR, int))", 
                                 arg3, sizeof(int));
-               SYSCALL_TRACK( pre_mem_write,tst, "ioctl(SNDCTL_XXX|SOUND_XXX "
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SNDCTL_XXX|SOUND_XXX "
                                      "(SIOWR, int))", 
                                 arg3, sizeof(int));
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case SNDCTL_DSP_GETOSPACE:
             case SNDCTL_DSP_GETISPACE:
-               SYSCALL_TRACK( pre_mem_write,tst, 
+               SYSCALL_TRACK( pre_mem_write, tid, 
                                 "ioctl(SNDCTL_XXX|SOUND_XXX "
                                 "(SIOR, audio_buf_info))", arg3,
                                 sizeof(audio_buf_info));
@@ -2324,7 +2321,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                   VG_TRACK( post_mem_write,arg3, sizeof(audio_buf_info));
                break;
             case SNDCTL_DSP_SETTRIGGER:
-               SYSCALL_TRACK( pre_mem_read,tst, 
+               SYSCALL_TRACK( pre_mem_read, tid, 
                                 "ioctl(SNDCTL_XXX|SOUND_XXX (SIOW, int))", 
                                 arg3, sizeof(int));
                KERNEL_DO_SYSCALL(tid,res);
@@ -2351,19 +2348,19 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                break;
             case RTC_RD_TIME:
             case RTC_ALM_READ:
-               SYSCALL_TRACK( pre_mem_write,tst, "ioctl(RTC_RD_TIME/ALM_READ)", 
-                                arg3, sizeof(struct rtc_time));
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(RTC_RD_TIME/ALM_READ)", 
+                              arg3, sizeof(struct rtc_time));
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror) && res == 0)
                   VG_TRACK( post_mem_write,arg3, sizeof(struct rtc_time));
                break;
             case RTC_ALM_SET:
-               SYSCALL_TRACK( pre_mem_read,tst, "ioctl(RTC_ALM_SET)", arg3,
+               SYSCALL_TRACK( pre_mem_read, tid, "ioctl(RTC_ALM_SET)", arg3,
                                 sizeof(struct rtc_time));
                KERNEL_DO_SYSCALL(tid,res);
                break;
             case RTC_IRQP_READ:
-               SYSCALL_TRACK( pre_mem_write,tst, "ioctl(RTC_IRQP_READ)", arg3,
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(RTC_IRQP_READ)", arg3,
                                 sizeof(unsigned long));
                KERNEL_DO_SYSCALL(tid,res);
                if(!VG_(is_kerror) && res == 0)
@@ -2373,7 +2370,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
 
 #           ifdef BLKGETSIZE
             case BLKGETSIZE:
-               SYSCALL_TRACK( pre_mem_write,tst, "ioctl(BLKGETSIZE)", arg3,
+               SYSCALL_TRACK( pre_mem_write, tid, "ioctl(BLKGETSIZE)", arg3,
                                 sizeof(unsigned long));
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res) && res == 0)
@@ -2383,11 +2380,11 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
 
             /* CD ROM stuff (??)  */
             case CDROMSUBCHNL:
-                SYSCALL_TRACK( pre_mem_read,tst, 
+                SYSCALL_TRACK( pre_mem_read, tid, 
                    "ioctl(CDROMSUBCHNL (cdsc_format, char))",
                    (int) &(((struct cdrom_subchnl *) arg3)->cdsc_format), 
                    sizeof(((struct cdrom_subchnl *) arg3)->cdsc_format));
-                SYSCALL_TRACK( pre_mem_write,tst, 
+                SYSCALL_TRACK( pre_mem_write, tid, 
                    "ioctl(CDROMSUBCHNL)", arg3, 
                    sizeof(struct cdrom_subchnl));
                 KERNEL_DO_SYSCALL(tid,res);
@@ -2395,7 +2392,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                    VG_TRACK( post_mem_write,arg3, sizeof(struct cdrom_subchnl));
                 break;
             case CDROMREADTOCHDR:
-                SYSCALL_TRACK( pre_mem_write,tst, 
+                SYSCALL_TRACK( pre_mem_write, tid, 
                    "ioctl(CDROMREADTOCHDR)", arg3, 
                    sizeof(struct cdrom_tochdr));
                 KERNEL_DO_SYSCALL(tid,res);
@@ -2403,15 +2400,15 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                    VG_TRACK( post_mem_write,arg3, sizeof(struct cdrom_tochdr));
                 break;
             case CDROMREADTOCENTRY:
-                 SYSCALL_TRACK( pre_mem_read,tst, 
+                 SYSCALL_TRACK( pre_mem_read, tid, 
                     "ioctl(CDROMREADTOCENTRY (cdte_format, char))",
                     (int) &(((struct cdrom_tocentry *) arg3)->cdte_format), 
                     sizeof(((struct cdrom_tocentry *) arg3)->cdte_format));
-                 SYSCALL_TRACK( pre_mem_read,tst, 
+                 SYSCALL_TRACK( pre_mem_read, tid, 
                     "ioctl(CDROMREADTOCENTRY (cdte_track, char))",
                     (int) &(((struct cdrom_tocentry *) arg3)->cdte_track), 
                     sizeof(((struct cdrom_tocentry *) arg3)->cdte_track));
-                 SYSCALL_TRACK( pre_mem_write,tst, 
+                 SYSCALL_TRACK( pre_mem_write, tid, 
                     "ioctl(CDROMREADTOCENTRY)", arg3, 
                     sizeof(struct cdrom_tocentry));
                  KERNEL_DO_SYSCALL(tid,res);
@@ -2419,7 +2416,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                     VG_TRACK( post_mem_write,arg3, sizeof(struct cdrom_tochdr));
                  break;
             case CDROMPLAYMSF:
-                 SYSCALL_TRACK( pre_mem_read,tst, "ioctl(CDROMPLAYMSF)", arg3, 
+                 SYSCALL_TRACK( pre_mem_read, tid, "ioctl(CDROMPLAYMSF)", arg3, 
                     sizeof(struct cdrom_msf));
                  KERNEL_DO_SYSCALL(tid,res);
                  break;
@@ -2468,10 +2465,10 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                   }
                } else {
                   if ((dir & _IOC_WRITE) && size > 0)
-                     SYSCALL_TRACK( pre_mem_read,tst, "ioctl(generic)", 
+                     SYSCALL_TRACK( pre_mem_read, tid, "ioctl(generic)", 
                                                       arg3, size);
                   if ((dir & _IOC_READ) && size > 0)
-                     SYSCALL_TRACK( pre_mem_write,tst, "ioctl(generic)", 
+                     SYSCALL_TRACK( pre_mem_write, tid, "ioctl(generic)", 
                                                        arg3, size);
                }
                KERNEL_DO_SYSCALL(tid,res);
@@ -2493,8 +2490,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_link: /* syscall 9 */
          /* int link(const char *oldpath, const char *newpath); */
          MAYBE_PRINTF("link ( %p, %p)\n", arg1, arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "link(oldpath)", arg1);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "link(newpath)", arg2);
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "link(oldpath)", arg1);
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "link(newpath)", arg2);
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
@@ -2510,7 +2507,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                         loff_t * result, unsigned int whence); */
          MAYBE_PRINTF("llseek ( %d, 0x%x, 0x%x, %p, %d )\n",
                         arg1,arg2,arg3,arg4,arg5);
-         SYSCALL_TRACK( pre_mem_write, tst, "llseek(result)", arg4, 
+         SYSCALL_TRACK( pre_mem_write, tid, "llseek(result)", arg4, 
                                        sizeof(loff_t));
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res == 0)
@@ -2520,8 +2517,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_lstat: /* syscall 107 */
          /* int lstat(const char *file_name, struct stat *buf); */
          MAYBE_PRINTF("lstat ( %p, %p )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "lstat(file_name)", arg1 );
-         SYSCALL_TRACK( pre_mem_write, tst, "lstat(buf)", arg2, 
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "lstat(file_name)", arg1 );
+         SYSCALL_TRACK( pre_mem_write, tid, "lstat(buf)", arg2, 
                                        sizeof(struct stat) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res == 0) {
@@ -2533,8 +2530,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_lstat64: /* syscall 196 */
          /* int lstat64(const char *file_name, struct stat64 *buf); */
          MAYBE_PRINTF("lstat64 ( %p, %p )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "lstat64(file_name)", arg1 );
-         SYSCALL_TRACK( pre_mem_write, tst, "lstat64(buf)", arg2, 
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "lstat64(file_name)", arg1 );
+         SYSCALL_TRACK( pre_mem_write, tid, "lstat64(buf)", arg2, 
                                             sizeof(struct stat64) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res == 0) {
@@ -2546,7 +2543,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_mkdir: /* syscall 39 */
          /* int mkdir(const char *pathname, mode_t mode); */
          MAYBE_PRINTF("mkdir ( %p, %d )\n", arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "mkdir(pathname)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "mkdir(pathname)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
@@ -2574,7 +2571,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* void* mmap(void *start, size_t length, int prot, 
                        int flags, int fd, off_t offset); 
          */
-         SYSCALL_TRACK( pre_mem_read, tst, "mmap(args)", arg1, 6*sizeof(UInt) );
+         SYSCALL_TRACK( pre_mem_read, tid, "mmap(args)", arg1, 6*sizeof(UInt) );
          {
             UInt* arg_block = (UInt*)arg1;
             UInt arg6;
@@ -2616,10 +2613,10 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_nanosleep: /* syscall 162 */
          /* int nanosleep(const struct timespec *req, struct timespec *rem); */
          MAYBE_PRINTF("nanosleep ( %p, %p )\n", arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read, tst, "nanosleep(req)", arg1, 
+         SYSCALL_TRACK( pre_mem_read, tid, "nanosleep(req)", arg1, 
                                               sizeof(struct timespec) );
          if (arg2 != (UInt)NULL)
-            SYSCALL_TRACK( pre_mem_write, tst, "nanosleep(rem)", arg2, 
+            SYSCALL_TRACK( pre_mem_write, tid, "nanosleep(rem)", arg2, 
                                sizeof(struct timespec) );
          KERNEL_DO_SYSCALL(tid,res);
          /* Somewhat bogus ... is only written by the kernel if
@@ -2636,16 +2633,16 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          MAYBE_PRINTF("newselect ( %d, %p, %p, %p, %p )\n",
                         arg1,arg2,arg3,arg4,arg5);
          if (arg2 != 0)
-            SYSCALL_TRACK( pre_mem_read, tst, "newselect(readfds)",   
+            SYSCALL_TRACK( pre_mem_read, tid, "newselect(readfds)",   
                               arg2, arg1/8 /* __FD_SETSIZE/8 */ );
          if (arg3 != 0)
-            SYSCALL_TRACK( pre_mem_read, tst, "newselect(writefds)",  
+            SYSCALL_TRACK( pre_mem_read, tid, "newselect(writefds)",  
                               arg3, arg1/8 /* __FD_SETSIZE/8 */ );
          if (arg4 != 0)
-            SYSCALL_TRACK( pre_mem_read, tst, "newselect(exceptfds)", 
+            SYSCALL_TRACK( pre_mem_read, tid, "newselect(exceptfds)", 
                               arg4, arg1/8 /* __FD_SETSIZE/8 */ );
          if (arg5 != 0)
-            SYSCALL_TRACK( pre_mem_read, tst, "newselect(timeout)", arg5, 
+            SYSCALL_TRACK( pre_mem_read, tid, "newselect(timeout)", arg5, 
                               sizeof(struct timeval) );
          KERNEL_DO_SYSCALL(tid,res);
          break;
@@ -2653,7 +2650,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_open: /* syscall 5 */
          /* int open(const char *pathname, int flags); */
          MAYBE_PRINTF("open ( %p(%s), %d ) --> ",arg1,arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "open(pathname)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "open(pathname)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          MAYBE_PRINTF("%d\n",res);
          break;
@@ -2661,7 +2658,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_creat: /* syscall 8 */
          /* int creat(const char *pathname, mode_t mode); */
          MAYBE_PRINTF("creat ( %p(%s), %d ) --> ",arg1,arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "creat(pathname)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "creat(pathname)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          MAYBE_PRINTF("%d\n",res);
          break;
@@ -2669,7 +2666,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_pipe: /* syscall 42 */
          /* int pipe(int filedes[2]); */
          MAYBE_PRINTF("pipe ( %p ) ...\n", arg1);
-         SYSCALL_TRACK( pre_mem_write, tst, "pipe(filedes)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "pipe(filedes)", 
                                             arg1, 2*sizeof(int) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
@@ -2692,7 +2689,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          MAYBE_PRINTF("poll ( %p, %d, %d )\n",arg1,arg2,arg3);
          /* In fact some parts of this struct should be readable too.
             This should be fixed properly. */
-         SYSCALL_TRACK( pre_mem_write, tst, "poll(ufds)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "poll(ufds)", 
                            arg1, arg2 * sizeof(struct pollfd) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res > 0) {
@@ -2726,8 +2723,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_readlink: /* syscall 85 */
          /* int readlink(const char *path, char *buf, size_t bufsiz); */
          MAYBE_PRINTF("readlink ( %p, %p, %d )\n", arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "readlink(path)", arg1 );
-         SYSCALL_TRACK( pre_mem_write, tst, "readlink(buf)", arg2,arg3 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "readlink(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_write, tid, "readlink(buf)", arg2,arg3 );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res > 0) {
             VG_TRACK( post_mem_write, arg2, res );
@@ -2739,12 +2736,12 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          UInt i;
          struct iovec * vec;
          MAYBE_PRINTF("readv ( %d, %p, %d )\n",arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_read, tst, "readv(vector)", 
+         SYSCALL_TRACK( pre_mem_read, tid, "readv(vector)", 
                            arg2, arg3 * sizeof(struct iovec) );
          /* ToDo: don't do any of the following if the vector is invalid */
          vec = (struct iovec *)arg2;
          for (i = 0; i < arg3; i++)
-            SYSCALL_TRACK( pre_mem_write, tst, "readv(vector[...])",
+            SYSCALL_TRACK( pre_mem_write, tid, "readv(vector[...])",
                               (UInt)vec[i].iov_base,vec[i].iov_len );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && res > 0) {
@@ -2763,22 +2760,22 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_rename: /* syscall 38 */
          /* int rename(const char *oldpath, const char *newpath); */
          MAYBE_PRINTF("rename ( %p, %p )\n", arg1, arg2 );
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "rename(oldpath)", arg1 );
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "rename(newpath)", arg2 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "rename(oldpath)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "rename(newpath)", arg2 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
       case __NR_rmdir: /* syscall 40 */
          /* int rmdir(const char *pathname); */
          MAYBE_PRINTF("rmdir ( %p )\n", arg1);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "rmdir(pathname)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "rmdir(pathname)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
       case __NR_sched_setparam: /* syscall 154 */
          /* int sched_setparam(pid_t pid, const struct sched_param *p); */
          MAYBE_PRINTF("sched_setparam ( %d, %p )\n", arg1, arg2 );
-         SYSCALL_TRACK( pre_mem_read, tst, "sched_setparam(ptr)",
+         SYSCALL_TRACK( pre_mem_read, tid, "sched_setparam(ptr)",
                            arg2, sizeof(struct sched_param) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
@@ -2788,7 +2785,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_sched_getparam: /* syscall 155 */
          /* int sched_getparam(pid_t pid, struct sched_param *p); */
          MAYBE_PRINTF("sched_getparam ( %d, %p )\n", arg1, arg2 );
-         SYSCALL_TRACK( pre_mem_write, tst, "sched_getparam(ptr)",
+         SYSCALL_TRACK( pre_mem_write, tid, "sched_getparam(ptr)",
                            arg2, sizeof(struct sched_param) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
@@ -2809,7 +2806,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             };
             int old_select(struct sel_arg_struct *arg);
          */
-         SYSCALL_TRACK( pre_mem_read, tst, "select(args)", arg1, 5*sizeof(UInt) );
+         SYSCALL_TRACK( pre_mem_read, tid, "select(args)", arg1, 5*sizeof(UInt) );
          {
             UInt* arg_struct = (UInt*)arg1;
             arg1 = arg_struct[0];
@@ -2821,16 +2818,16 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             MAYBE_PRINTF("select ( %d, %p, %p, %p, %p )\n", 
                          arg1,arg2,arg3,arg4,arg5);
             if (arg2 != (Addr)NULL)
-               SYSCALL_TRACK( pre_mem_read, tst, "select(readfds)", arg2, 
+               SYSCALL_TRACK( pre_mem_read, tid, "select(readfds)", arg2, 
                                           arg1/8 /* __FD_SETSIZE/8 */ );
             if (arg3 != (Addr)NULL)
-               SYSCALL_TRACK( pre_mem_read, tst, "select(writefds)", arg3, 
+               SYSCALL_TRACK( pre_mem_read, tid, "select(writefds)", arg3, 
                                           arg1/8 /* __FD_SETSIZE/8 */ );
             if (arg4 != (Addr)NULL)
-               SYSCALL_TRACK( pre_mem_read, tst, "select(exceptfds)", arg4, 
+               SYSCALL_TRACK( pre_mem_read, tid, "select(exceptfds)", arg4, 
                                           arg1/8 /* __FD_SETSIZE/8 */ );
             if (arg5 != (Addr)NULL)
-               SYSCALL_TRACK( pre_mem_read, tst, "select(timeout)", arg5, 
+               SYSCALL_TRACK( pre_mem_read, tid, "select(timeout)", arg5, 
                                           sizeof(struct timeval) );
          }
          KERNEL_DO_SYSCALL(tid,res);
@@ -2841,10 +2838,10 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                                  struct itimerval *ovalue); */
          MAYBE_PRINTF("setitimer ( %d, %p, %p )\n", arg1,arg2,arg3);
          if (arg2 != (Addr)NULL)
-            SYSCALL_TRACK( pre_mem_read,tst, "setitimer(value)", 
+            SYSCALL_TRACK( pre_mem_read, tid, "setitimer(value)", 
                              arg2, sizeof(struct itimerval) );
          if (arg3 != (Addr)NULL)
-            SYSCALL_TRACK( pre_mem_write,tst, "setitimer(ovalue)", 
+            SYSCALL_TRACK( pre_mem_write, tid, "setitimer(ovalue)", 
                              arg3, sizeof(struct itimerval));
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && arg3 != (Addr)NULL) {
@@ -2882,7 +2879,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* int setgroups(size_t size, const gid_t *list); */
          MAYBE_PRINTF("setgroups ( %d, %p )\n", arg1, arg2);
          if (arg1 > 0)
-            SYSCALL_TRACK( pre_mem_read, tst, "setgroups(list)", arg2, 
+            SYSCALL_TRACK( pre_mem_read, tid, "setgroups(list)", arg2, 
                                arg1 * sizeof(gid_t) );
          KERNEL_DO_SYSCALL(tid,res);
          break;
@@ -2921,7 +2918,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_setrlimit: /* syscall 75 */
          /* int setrlimit (int resource, const struct rlimit *rlim); */
          MAYBE_PRINTF("setrlimit ( %d, %p )\n", arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read, tst, "setrlimit(rlim)", 
+         SYSCALL_TRACK( pre_mem_read, tid, "setrlimit(rlim)", 
                                       arg2, sizeof(struct rlimit) );
          KERNEL_DO_SYSCALL(tid,res);
          break;
@@ -2942,9 +2939,9 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
 
             case SYS_SOCKETPAIR:
                /* int socketpair(int d, int type, int protocol, int sv[2]); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.socketpair(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.socketpair(args)", 
                                  arg2, 4*sizeof(Addr) );
-               SYSCALL_TRACK( pre_mem_write, tst, "socketcall.socketpair(sv)", 
+               SYSCALL_TRACK( pre_mem_write, tid, "socketcall.socketpair(sv)", 
                                  ((UInt*)arg2)[3], 2*sizeof(int) );
                KERNEL_DO_SYSCALL(tid,res);
                if (!VG_(is_kerror)(res))
@@ -2953,7 +2950,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
 
             case SYS_SOCKET:
                /* int socket(int domain, int type, int protocol); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.socket(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.socket(args)", 
                                  arg2, 3*sizeof(Addr) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
@@ -2961,34 +2958,34 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case SYS_BIND:
                /* int bind(int sockfd, struct sockaddr *my_addr, 
                            int addrlen); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.bind(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.bind(args)", 
                                  arg2, 3*sizeof(Addr) );
-               pre_mem_read_sockaddr( tst, "socketcall.bind(my_addr.%s)",
+               pre_mem_read_sockaddr( tid, "socketcall.bind(my_addr.%s)",
                   (struct sockaddr *) (((UInt*)arg2)[1]), ((UInt*)arg2)[2]);
                KERNEL_DO_SYSCALL(tid,res);
                break;
                
             case SYS_LISTEN:
                /* int listen(int s, int backlog); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.listen(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.listen(args)", 
                                  arg2, 2*sizeof(Addr) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
 
             case SYS_ACCEPT: {
                /* int accept(int s, struct sockaddr *addr, int *addrlen); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.accept(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.accept(args)", 
                                  arg2, 3*sizeof(Addr) );
                {
                Addr addr_p     = ((UInt*)arg2)[1];
                Addr addrlen_p  = ((UInt*)arg2)[2];
                if (addr_p != (Addr)NULL) 
-                  buf_and_len_pre_check ( tst, addr_p, addrlen_p,
+                  buf_and_len_pre_check ( tid, addr_p, addrlen_p,
                                           "socketcall.accept(addr)",
                                           "socketcall.accept(addrlen_in)" );
                KERNEL_DO_SYSCALL(tid,res);
                if (addr_p != (Addr)NULL) 
-                  buf_and_len_post_check ( tst, res, addr_p, addrlen_p,
+                  buf_and_len_post_check ( tid, res, addr_p, addrlen_p,
                                            "socketcall.accept(addrlen_out)" );
                }
                break;
@@ -2998,21 +2995,21 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                /* int sendto(int s, const void *msg, int len, 
                              unsigned int flags, 
                              const struct sockaddr *to, int tolen); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.sendto(args)", arg2, 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.sendto(args)", arg2, 
                                  6*sizeof(Addr) );
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.sendto(msg)",
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.sendto(msg)",
                                  ((UInt*)arg2)[1], /* msg */
                                  ((UInt*)arg2)[2]  /* len */ );
-               pre_mem_read_sockaddr( tst, "socketcall.sendto(to.%s)",
+               pre_mem_read_sockaddr( tid, "socketcall.sendto(to.%s)",
                   (struct sockaddr *) (((UInt*)arg2)[4]), ((UInt*)arg2)[5]);
                KERNEL_DO_SYSCALL(tid,res);
                break;
 
             case SYS_SEND:
                /* int send(int s, const void *msg, size_t len, int flags); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.send(args)", arg2,
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.send(args)", arg2,
                                  4*sizeof(Addr) );
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.send(msg)",
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.send(msg)",
                                  ((UInt*)arg2)[1], /* msg */
                                  ((UInt*)arg2)[2]  /* len */ );
                KERNEL_DO_SYSCALL(tid,res);
@@ -3021,7 +3018,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case SYS_RECVFROM:
                /* int recvfrom(int s, void *buf, int len, unsigned int flags,
                                struct sockaddr *from, int *fromlen); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.recvfrom(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.recvfrom(args)", 
                                  arg2, 6*sizeof(Addr) );
                {
                Addr buf_p      = ((UInt*)arg2)[1];
@@ -3029,15 +3026,15 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                Addr from_p     = ((UInt*)arg2)[4];
                Addr fromlen_p  = ((UInt*)arg2)[5];
 
-               SYSCALL_TRACK( pre_mem_write, tst, "socketcall.recvfrom(buf)", 
+               SYSCALL_TRACK( pre_mem_write, tid, "socketcall.recvfrom(buf)", 
                                              buf_p, len );
                if (from_p != (Addr)NULL) 
-                  buf_and_len_pre_check ( tst, from_p, fromlen_p, 
+                  buf_and_len_pre_check ( tid, from_p, fromlen_p, 
                                           "socketcall.recvfrom(from)",
                                           "socketcall.recvfrom(fromlen_in)" );
                KERNEL_DO_SYSCALL(tid,res);
                if (from_p != (Addr)NULL) 
-                  buf_and_len_post_check ( tst, res, from_p, fromlen_p,
+                  buf_and_len_post_check ( tid, res, from_p, fromlen_p,
                                            "socketcall.recvfrom(fromlen_out)" );
                if (!VG_(is_kerror)(res))
                   VG_TRACK( post_mem_write, buf_p, len );
@@ -3051,9 +3048,9 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                (see connect(2)) and is identical to recvfrom with a  NULL
                from parameter.
                */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.recv(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.recv(args)", 
                                  arg2, 4*sizeof(Addr) );
-               SYSCALL_TRACK( pre_mem_write, tst, "socketcall.recv(buf)", 
+               SYSCALL_TRACK( pre_mem_write, tid, "socketcall.recv(buf)", 
                                  ((UInt*)arg2)[1], /* buf */
                                  ((UInt*)arg2)[2]  /* len */ );
                KERNEL_DO_SYSCALL(tid,res);
@@ -3067,13 +3064,13 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case SYS_CONNECT:
                /* int connect(int sockfd, 
                               struct sockaddr *serv_addr, int addrlen ); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.connect(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.connect(args)", 
                                  arg2, 3*sizeof(Addr) );
-               SYSCALL_TRACK( pre_mem_read, tst, 
+               SYSCALL_TRACK( pre_mem_read, tid, 
                                  "socketcall.connect(serv_addr.sa_family)",
                                  ((UInt*)arg2)[1], /* serv_addr */
                                  sizeof (sa_family_t));
-               pre_mem_read_sockaddr( tst,
+               pre_mem_read_sockaddr( tid,
                   "socketcall.connect(serv_addr.%s)",
                   (struct sockaddr *) (((UInt*)arg2)[1]), ((UInt*)arg2)[2]);
                KERNEL_DO_SYSCALL(tid,res);
@@ -3082,9 +3079,9 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case SYS_SETSOCKOPT:
                /* int setsockopt(int s, int level, int optname, 
                                  const void *optval, int optlen); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.setsockopt(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.setsockopt(args)", 
                                  arg2, 5*sizeof(Addr) );
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.setsockopt(optval)",
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.setsockopt(optval)",
                                  ((UInt*)arg2)[3], /* optval */
                                  ((UInt*)arg2)[4]  /* optlen */ );
                KERNEL_DO_SYSCALL(tid,res);
@@ -3093,62 +3090,62 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
             case SYS_GETSOCKOPT:
                /* int setsockopt(int s, int level, int optname, 
                                  void *optval, socklen_t *optlen); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.getsockopt(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.getsockopt(args)", 
                                  arg2, 5*sizeof(Addr) );
                {
                Addr optval_p  = ((UInt*)arg2)[3];
                Addr optlen_p  = ((UInt*)arg2)[4];
                /* vg_assert(sizeof(socklen_t) == sizeof(UInt)); */
                if (optval_p != (Addr)NULL) 
-                  buf_and_len_pre_check ( tst, optval_p, optlen_p,
+                  buf_and_len_pre_check ( tid, optval_p, optlen_p,
                                           "socketcall.getsockopt(optval)",
                                           "socketcall.getsockopt(optlen)" );
                KERNEL_DO_SYSCALL(tid,res);
                if (optval_p != (Addr)NULL) 
-                  buf_and_len_post_check ( tst, res, optval_p, optlen_p,
+                  buf_and_len_post_check ( tid, res, optval_p, optlen_p,
                                            "socketcall.getsockopt(optlen_out)" );
                }
                break;
 
             case SYS_GETSOCKNAME:
                /* int getsockname(int s, struct sockaddr* name, int* namelen) */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.getsockname(args)",
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.getsockname(args)",
                                             arg2, 3*sizeof(Addr) );
                {
                Addr name_p     = ((UInt*)arg2)[1];
                Addr namelen_p  = ((UInt*)arg2)[2];
 
                /* Nb: name_p cannot be NULL */
-               buf_and_len_pre_check ( tst, name_p, namelen_p,
+               buf_and_len_pre_check ( tid, name_p, namelen_p,
                                        "socketcall.getsockname(name)",
                                        "socketcall.getsockname(namelen_in)" );
                KERNEL_DO_SYSCALL(tid,res);
-               buf_and_len_post_check ( tst, res, name_p, namelen_p,
+               buf_and_len_post_check ( tid, res, name_p, namelen_p,
                                         "socketcall.getsockname(namelen_out)" );
                }
                break;
 
             case SYS_GETPEERNAME:
                /* int getpeername(int s, struct sockaddr* name, int* namelen) */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.getpeername(args)",
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.getpeername(args)",
                                             arg2, 3*sizeof(Addr) );
                {
                Addr name_p     = ((UInt*)arg2)[1];
                Addr namelen_p  = ((UInt*)arg2)[2];
 
                /* Nb: name_p cannot be NULL */
-               buf_and_len_pre_check ( tst, name_p, namelen_p,
+               buf_and_len_pre_check ( tid, name_p, namelen_p,
                                        "socketcall.getpeername(name)",
                                        "socketcall.getpeername(namelen_in)" );
                KERNEL_DO_SYSCALL(tid,res);
-               buf_and_len_post_check ( tst, res, name_p, namelen_p,
+               buf_and_len_post_check ( tid, res, name_p, namelen_p,
                                         "socketcall.getpeername(namelen_out)" );
                }
                break;
 
             case SYS_SHUTDOWN:
                /* int shutdown(int s, int how); */
-               SYSCALL_TRACK( pre_mem_read, tst, "socketcall.shutdown(args)", 
+               SYSCALL_TRACK( pre_mem_read, tid, "socketcall.shutdown(args)", 
                                             arg2, 2*sizeof(Addr) );
                KERNEL_DO_SYSCALL(tid,res);
                break;
@@ -3164,7 +3161,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                   */
 
                   struct msghdr *msg = (struct msghdr *)((UInt *)arg2)[ 1 ];
-                  msghdr_foreachfield ( tst, msg, pre_mem_read_sendmsg );
+                  msghdr_foreachfield ( tid, msg, pre_mem_read_sendmsg );
 
                   KERNEL_DO_SYSCALL(tid,res);
                   break;
@@ -3181,12 +3178,12 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                   */
 
                   struct msghdr *msg = (struct msghdr *)((UInt *)arg2)[ 1 ];
-                  msghdr_foreachfield ( tst, msg, pre_mem_write_recvmsg );
+                  msghdr_foreachfield ( tid, msg, pre_mem_write_recvmsg );
 
                   KERNEL_DO_SYSCALL(tid,res);
 
                   if ( !VG_(is_kerror)( res ) )
-                     msghdr_foreachfield( tst, msg, post_mem_write_recvmsg );
+                     msghdr_foreachfield( tid, msg, post_mem_write_recvmsg );
 
                   break;
                }
@@ -3201,8 +3198,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_stat: /* syscall 106 */
          /* int stat(const char *file_name, struct stat *buf); */
          MAYBE_PRINTF("stat ( %p, %p )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "stat(file_name)", arg1 );
-         SYSCALL_TRACK( pre_mem_write, tst, "stat(buf)", 
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "stat(file_name)", arg1 );
+         SYSCALL_TRACK( pre_mem_write, tid, "stat(buf)", 
                                        arg2, sizeof(struct stat) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
@@ -3212,8 +3209,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_statfs: /* syscall 99 */
          /* int statfs(const char *path, struct statfs *buf); */
          MAYBE_PRINTF("statfs ( %p, %p )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "statfs(path)", arg1 );
-         SYSCALL_TRACK( pre_mem_write, tst, "stat(buf)", 
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "statfs(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_write, tid, "stat(buf)", 
                                        arg2, sizeof(struct statfs) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
@@ -3223,8 +3220,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_symlink: /* syscall 83 */
          /* int symlink(const char *oldpath, const char *newpath); */
          MAYBE_PRINTF("symlink ( %p, %p )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "symlink(oldpath)", arg1 );
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "symlink(newpath)", arg2 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "symlink(oldpath)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "symlink(newpath)", arg2 );
          KERNEL_DO_SYSCALL(tid,res);
          break; 
 
@@ -3232,8 +3229,8 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_stat64: /* syscall 195 */
          /* int stat64(const char *file_name, struct stat64 *buf); */
          MAYBE_PRINTF("stat64 ( %p, %p )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "stat64(file_name)", arg1 );
-         SYSCALL_TRACK( pre_mem_write, tst, "stat64(buf)", 
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "stat64(file_name)", arg1 );
+         SYSCALL_TRACK( pre_mem_write, tid, "stat64(buf)", 
                                        arg2, sizeof(struct stat64) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
@@ -3245,7 +3242,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_fstat64: /* syscall 197 */
          /* int fstat64(int filedes, struct stat64 *buf); */
          MAYBE_PRINTF("fstat64 ( %d, %p )\n",arg1,arg2);
-         SYSCALL_TRACK( pre_mem_write, tst, "fstat64(buf)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "fstat64(buf)", 
                                        arg2, sizeof(struct stat64) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
@@ -3256,7 +3253,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_sysinfo: /* syscall 116 */
          /* int sysinfo(struct sysinfo *info); */
          MAYBE_PRINTF("sysinfo ( %p )\n",arg1);
-         SYSCALL_TRACK( pre_mem_write, tst, "sysinfo(info)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "sysinfo(info)", 
                                        arg1, sizeof(struct sysinfo) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res))
@@ -3267,7 +3264,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* time_t time(time_t *t); */
          MAYBE_PRINTF("time ( %p )\n",arg1);
          if (arg1 != (UInt)NULL) {
-            SYSCALL_TRACK( pre_mem_write, tst, "time", arg1, sizeof(time_t) );
+            SYSCALL_TRACK( pre_mem_write, tid, "time", arg1, sizeof(time_t) );
          }
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && arg1 != (UInt)NULL) {
@@ -3278,7 +3275,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_times: /* syscall 43 */
          /* clock_t times(struct tms *buf); */
          MAYBE_PRINTF("times ( %p )\n",arg1);
-         SYSCALL_TRACK( pre_mem_write, tst, "times(buf)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "times(buf)", 
                                        arg1, sizeof(struct tms) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && arg1 != (UInt)NULL) {
@@ -3289,7 +3286,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_truncate: /* syscall 92 */
          /* int truncate(const char *path, size_t length); */
          MAYBE_PRINTF("truncate ( %p, %d )\n", arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "truncate(path)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "truncate(path)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
@@ -3302,14 +3299,14 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_unlink: /* syscall 10 */
          /* int unlink(const char *pathname) */
          MAYBE_PRINTF("ulink ( %p )\n",arg1);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "unlink(pathname)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "unlink(pathname)", arg1 );
          KERNEL_DO_SYSCALL(tid,res);
          break;
 
       case __NR_uname: /* syscall 122 */
          /* int uname(struct utsname *buf); */
          MAYBE_PRINTF("uname ( %p )\n",arg1);
-         SYSCALL_TRACK( pre_mem_write, tst, "uname(buf)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "uname(buf)", 
                                        arg1, sizeof(struct utsname) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res) && arg1 != (UInt)NULL) {
@@ -3320,9 +3317,9 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
       case __NR_utime: /* syscall 30 */
          /* int utime(const char *filename, struct utimbuf *buf); */
          MAYBE_PRINTF("utime ( %p, %p )\n", arg1,arg2);
-         SYSCALL_TRACK( pre_mem_read_asciiz, tst, "utime(filename)", arg1 );
+         SYSCALL_TRACK( pre_mem_read_asciiz, tid, "utime(filename)", arg1 );
          if (arg2 != (UInt)NULL)
-            SYSCALL_TRACK( pre_mem_read, tst, "utime(buf)", arg2, 
+            SYSCALL_TRACK( pre_mem_read, tid, "utime(buf)", arg2, 
                                                  sizeof(struct utimbuf) );
          KERNEL_DO_SYSCALL(tid,res);
          break;
@@ -3333,10 +3330,10 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          MAYBE_PRINTF("wait4 ( %d, %p, %d, %p )\n",
                       arg1,arg2,arg3,arg4);
          if (arg2 != (Addr)NULL)
-            SYSCALL_TRACK( pre_mem_write, tst, "wait4(status)", 
+            SYSCALL_TRACK( pre_mem_write, tid, "wait4(status)", 
                                           arg2, sizeof(int) );
          if (arg4 != (Addr)NULL)
-            SYSCALL_TRACK( pre_mem_write, tst, "wait4(rusage)", arg4, 
+            SYSCALL_TRACK( pre_mem_write, tid, "wait4(rusage)", arg4, 
                               sizeof(struct rusage) );
          KERNEL_DO_SYSCALL(tid,res);
          if (!VG_(is_kerror)(res)) {
@@ -3352,12 +3349,12 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          UInt i;
          struct iovec * vec;
          MAYBE_PRINTF("writev ( %d, %p, %d )\n",arg1,arg2,arg3);
-         SYSCALL_TRACK( pre_mem_read, tst, "writev(vector)", 
+         SYSCALL_TRACK( pre_mem_read, tid, "writev(vector)", 
                            arg2, arg3 * sizeof(struct iovec) );
          /* ToDo: don't do any of the following if the vector is invalid */
          vec = (struct iovec *)arg2;
          for (i = 0; i < arg3; i++)
-            SYSCALL_TRACK( pre_mem_read, tst, "writev(vector[...])",
+            SYSCALL_TRACK( pre_mem_read, tid, "writev(vector[...])",
                               (UInt)vec[i].iov_base,vec[i].iov_len );
          KERNEL_DO_SYSCALL(tid,res);
          break;
@@ -3384,11 +3381,11 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
          /* int sigaltstack(const stack_t *ss, stack_t *oss); */
          MAYBE_PRINTF("sigaltstack ( %p, %p )\n",arg1,arg2);
          if (arg1 != (UInt)NULL) {
-            SYSCALL_TRACK( pre_mem_read, tst, "sigaltstack(ss)", 
+            SYSCALL_TRACK( pre_mem_read, tid, "sigaltstack(ss)", 
                               arg1, sizeof(vki_kstack_t) );
          }
          if (arg2 != (UInt)NULL) {
-            SYSCALL_TRACK( pre_mem_write, tst, "sigaltstack(ss)", 
+            SYSCALL_TRACK( pre_mem_write, tid, "sigaltstack(ss)", 
                               arg1, sizeof(vki_kstack_t) );
          }
 #        if SIGNAL_SIMULATION
@@ -3407,10 +3404,10 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                                       struct k_sigaction *oldact); */
          MAYBE_PRINTF("sigaction ( %d, %p, %p )\n",arg1,arg2,arg3);
          if (arg2 != (UInt)NULL)
-            SYSCALL_TRACK( pre_mem_read, tst, "sigaction(act)", 
+            SYSCALL_TRACK( pre_mem_read, tid, "sigaction(act)", 
                               arg2, sizeof(vki_ksigaction));
          if (arg3 != (UInt)NULL)
-            SYSCALL_TRACK( pre_mem_write, tst, "sigaction(oldact)", 
+            SYSCALL_TRACK( pre_mem_write, tid, "sigaction(oldact)", 
                               arg3, sizeof(vki_ksigaction));
          /* We do this one ourselves! */
 #        if SIGNAL_SIMULATION
@@ -3430,10 +3427,10 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
                                      k_sigset_t *oldset); */
          MAYBE_PRINTF("sigprocmask ( %d, %p, %p )\n",arg1,arg2,arg3);
          if (arg2 != (UInt)NULL)
-            SYSCALL_TRACK( pre_mem_read, tst, "sigprocmask(set)", 
+            SYSCALL_TRACK( pre_mem_read, tid, "sigprocmask(set)", 
                               arg2, sizeof(vki_ksigset_t));
          if (arg3 != (UInt)NULL)
-            SYSCALL_TRACK( pre_mem_write, tst, "sigprocmask(oldset)", 
+            SYSCALL_TRACK( pre_mem_write, tid, "sigprocmask(oldset)", 
                               arg3, sizeof(vki_ksigset_t));
 #        if SIGNAL_SIMULATION
          VG_(do__NR_sigprocmask) ( tid, 
@@ -3453,7 +3450,7 @@ void VG_(perform_assumed_nonblocking_syscall) ( ThreadId tid )
 #     endif
          /* int sigpending( sigset_t *set ) ; */
          MAYBE_PRINTF( "sigpending ( %p )\n", arg1 );
-         SYSCALL_TRACK( pre_mem_write, tst, "sigpending(set)", 
+         SYSCALL_TRACK( pre_mem_write, tid, "sigpending(set)", 
                            arg1, sizeof(vki_ksigset_t));
 #        if SIGNAL_SIMULATION
          VG_(do_sigpending)( tid, (vki_ksigset_t*)arg1 );
@@ -3531,7 +3528,7 @@ void* VG_(pre_known_blocking_syscall) ( ThreadId tid, Int syscallno )
                "SYSCALL--PRE[%d,%d]       read ( %d, %p, %d )\n", 
                VG_(getpid)(), tid,
                arg1, arg2, arg3);
-         SYSCALL_TRACK( pre_mem_write, tst, "read(buf)", arg2, arg3 );
+         SYSCALL_TRACK( pre_mem_write, tid, "read(buf)", arg2, arg3 );
          break;
 
       case __NR_write: /* syscall 4 */
@@ -3540,7 +3537,7 @@ void* VG_(pre_known_blocking_syscall) ( ThreadId tid, Int syscallno )
                "SYSCALL--PRE[%d,%d]       write ( %d, %p, %d )\n", 
                VG_(getpid)(), tid,
                arg1, arg2, arg3);
-         SYSCALL_TRACK( pre_mem_read, tst, "write(buf)", arg2, arg3 );
+         SYSCALL_TRACK( pre_mem_read, tid, "write(buf)", arg2, arg3 );
          break;
 
       default:
diff --git a/coregrind/vg_translate.c b/coregrind/vg_translate.c
index 5667970daa..51130b9570 100644
--- a/coregrind/vg_translate.c
+++ b/coregrind/vg_translate.c
@@ -2307,7 +2307,7 @@ static void vg_realreg_liveness_analysis ( UCodeBlock* cb )
 
    'tst' is the identity of the thread needing this block.
 */
-void VG_(translate) ( /*IN*/  ThreadState* tst, 
+void VG_(translate) ( /*IN*/  ThreadId tid, 
 		      /*IN*/  Addr  orig_addr,  
                       /*OUT*/ UInt* orig_size,
                       /*OUT*/ Addr* trans_addr, 
@@ -2349,7 +2349,7 @@ void VG_(translate) ( /*IN*/  ThreadState* tst,
       = VG_(overall_in_count) > notrace_until_limit;
 
    if (!debugging_translation)
-      VG_TRACK( pre_mem_read, Vg_CoreTranslate, tst, "", orig_addr, 1 );
+      VG_TRACK( pre_mem_read, Vg_CoreTranslate, tid, "", orig_addr, 1 );
 
    cb = VG_(alloc_UCodeBlock)();
    cb->orig_eip = orig_addr;
diff --git a/helgrind/hg_main.c b/helgrind/hg_main.c
index 456378038d..d95173e414 100644
--- a/helgrind/hg_main.c
+++ b/helgrind/hg_main.c
@@ -1306,8 +1306,7 @@ static void record_lockgraph_error(ThreadId tid, Mutex *mutex,
 				   const LockSet *lockset_holding, 
 				   const LockSet *lockset_prev);
 
-static void set_mutex_state(Mutex *mutex, MutexState state,
-			    ThreadId tid, ThreadState *tst);
+static void set_mutex_state(Mutex *mutex, MutexState state, ThreadId tid);
 
 #define M_MUTEX_HASHSZ	1021
 
@@ -1447,8 +1446,7 @@ static Bool check_cycle(const Mutex *start, const LockSet* lockset)
 /* test to see if a mutex state change would be problematic; this
    makes no changes to the mutex state.  This should be called before
    the locking thread has actually blocked. */
-static void test_mutex_state(Mutex *mutex, MutexState state,
-			     ThreadId tid, ThreadState *tst)
+static void test_mutex_state(Mutex *mutex, MutexState state, ThreadId tid)
 {
    static const Bool debug = False;
 
@@ -1518,8 +1516,7 @@ static void test_mutex_state(Mutex *mutex, MutexState state,
    a result of any thread freeing memory; in this case set_mutex_state
    does all the error reporting as well.
 */
-static void set_mutex_state(Mutex *mutex, MutexState state,
-			    ThreadId tid, ThreadState *tst)
+static void set_mutex_state(Mutex *mutex, MutexState state, ThreadId tid)
 {
    static const Bool debug = False;
 
@@ -1578,7 +1575,7 @@ static void set_mutex_state(Mutex *mutex, MutexState state,
       break;
    }
 
-   mutex->location = VG_(get_ExeContext)(tst);
+   mutex->location = VG_(get_ExeContext)(tid);
    mutex->state = state;
 }
 
@@ -1701,8 +1698,8 @@ 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, ThreadState *tst);
-static void eraser_mem_write(Addr a, UInt data_size, ThreadState *tst);
+static void eraser_mem_read (Addr a, UInt data_size, ThreadId tid);
+static void eraser_mem_write(Addr a, UInt data_size, ThreadId tid);
 
 #define REGPARM(x)	__attribute__((regparm (x)))
 
@@ -1720,24 +1717,25 @@ static void bus_lock(void);
 static void bus_unlock(void);
 
 static
-void eraser_pre_mem_read(CorePart part, ThreadState* tst,
+void eraser_pre_mem_read(CorePart part, ThreadId tid,
                          Char* s, UInt base, UInt size )
 {
-   eraser_mem_read(base, size, tst);
+   if (tid > 50) { VG_(printf)("pid = %d, s = `%s`, part = %d\n", tid, s, part); VG_(skin_panic)("a");}
+   eraser_mem_read(base, size, tid);
 }
 
 static
-void eraser_pre_mem_read_asciiz(CorePart part, ThreadState* tst,
+void eraser_pre_mem_read_asciiz(CorePart part, ThreadId tid,
                                 Char* s, UInt base )
 {
-   eraser_mem_read(base, VG_(strlen)((Char*)base), tst);
+   eraser_mem_read(base, VG_(strlen)((Char*)base), tid);
 }
 
 static
-void eraser_pre_mem_write(CorePart part, ThreadState* tst,
+void eraser_pre_mem_write(CorePart part, ThreadId tid,
                           Char* s, UInt base, UInt size )
 {
-   eraser_mem_write(base, size, tst);
+   eraser_mem_write(base, size, tid);
 }
 
 
@@ -1819,77 +1817,75 @@ UInt VG_(vg_malloc_redzone_szB) = 4;
    shadow chunk on the appropriate list, and set all memory
    protections correctly. */
 
-static void add_HG_Chunk ( ThreadState* tst, Addr p, UInt size )
+static void add_HG_Chunk ( ThreadId tid, Addr p, UInt size )
 {
    HG_Chunk* hc;
 
    hc            = VG_(malloc)(sizeof(HG_Chunk));
    hc->data      = p;
    hc->size      = size;
-   hc->where     = VG_(get_ExeContext)(tst);
-   hc->tid       = VG_(get_tid_from_ThreadState)(tst);
+   hc->where     = VG_(get_ExeContext)(tid);
+   hc->tid       = tid;
 
    VG_(HT_add_node)( hg_malloc_list, (VgHashNode*)hc );
 }
 
 /* Allocate memory and note change in memory available */
 static __inline__
-void* alloc_and_new_mem ( ThreadState* tst, UInt size, UInt alignment,
-                          Bool is_zeroed )
+void* alloc_and_new_mem ( UInt size, UInt alignment, Bool is_zeroed )
 {
    Addr p;
 
    p = (Addr)VG_(cli_malloc)(alignment, size);
-   add_HG_Chunk ( tst, p, size );
+   add_HG_Chunk ( VG_(get_current_or_recent_tid)(), p, size );
    eraser_new_mem_heap( p, size, is_zeroed );
 
    return (void*)p;
 }
 
-void* SK_(malloc) ( ThreadState* tst, Int n )
+void* SK_(malloc) ( Int n )
 {
-   return alloc_and_new_mem ( tst, n, VG_(clo_alignment), /*is_zeroed*/False );
+   return alloc_and_new_mem ( n, VG_(clo_alignment), /*is_zeroed*/False );
 }
 
-void* SK_(__builtin_new) ( ThreadState* tst, Int n )
+void* SK_(__builtin_new) ( Int n )
 {
-   return alloc_and_new_mem ( tst, n, VG_(clo_alignment), /*is_zeroed*/False );
+   return alloc_and_new_mem ( n, VG_(clo_alignment), /*is_zeroed*/False );
 }
 
-void* SK_(__builtin_vec_new) ( ThreadState* tst, Int n )
+void* SK_(__builtin_vec_new) ( Int n )
 {
-   return alloc_and_new_mem ( tst, n, VG_(clo_alignment), /*is_zeroed*/False );
+   return alloc_and_new_mem ( n, VG_(clo_alignment), /*is_zeroed*/False );
 }
 
-void* SK_(memalign) ( ThreadState* tst, Int align, Int n )
+void* SK_(memalign) ( Int align, Int n )
 {
-   return alloc_and_new_mem ( tst, n, align,              /*is_zeroed*/False );
+   return alloc_and_new_mem ( n, align,              /*is_zeroed*/False );
 }
 
-void* SK_(calloc) ( ThreadState* tst, Int nmemb, Int size1 )
+void* SK_(calloc) ( Int nmemb, Int size1 )
 {
    void* p;
    Int  size, i;
 
    size = nmemb * size1;
 
-   p = alloc_and_new_mem ( tst, size, VG_(clo_alignment), /*is_zeroed*/True );
+   p = alloc_and_new_mem ( size, VG_(clo_alignment), /*is_zeroed*/True );
    for (i = 0; i < size; i++)    /* calloc() is zeroed */
       ((UChar*)p)[i] = 0;
    return p;
 }
 
 static
-void die_and_free_mem ( ThreadState* tst, HG_Chunk* hc,
+void die_and_free_mem ( ThreadId tid, HG_Chunk* hc,
                         HG_Chunk** prev_chunks_next_ptr )
 {
-   ThreadId tid   = VG_(get_tid_from_ThreadState)(tst);
-   Addr     start = hc->data;
-   Addr     end   = start + hc->size;
+   Addr start = hc->data;
+   Addr end   = start + hc->size;
 
    Bool deadmx(Mutex *mx) {
       if (mx->state != MxDead)
-         set_mutex_state(mx, MxDead, tid, tst);
+         set_mutex_state(mx, MxDead, tid);
 
       return False;
    }
@@ -1901,7 +1897,7 @@ void die_and_free_mem ( ThreadState* tst, HG_Chunk* hc,
    *prev_chunks_next_ptr = hc->next;
 
    /* Record where freed */
-   hc->where = VG_(get_ExeContext) ( tst );
+   hc->where = VG_(get_ExeContext) ( tid );
 
    /* maintain a small window so that the error reporting machinery
       knows about this memory */
@@ -1923,7 +1919,7 @@ void die_and_free_mem ( ThreadState* tst, HG_Chunk* hc,
 
 
 static __inline__
-void handle_free ( ThreadState* tst, void* p )
+void handle_free ( void* p )
 {
    HG_Chunk*  hc;
    HG_Chunk** prev_chunks_next_ptr;
@@ -1933,29 +1929,31 @@ void handle_free ( ThreadState* tst, void* p )
    if (hc == NULL) {
       return;
    }
-   die_and_free_mem ( tst, hc, prev_chunks_next_ptr );
+   die_and_free_mem ( VG_(get_current_or_recent_tid)(),
+                      hc, prev_chunks_next_ptr );
 }
 
-void SK_(free) ( ThreadState* tst, void* p )
+void SK_(free) ( void* p )
 {
-   handle_free(tst, p);
+   handle_free(p);
 }
 
-void SK_(__builtin_delete) ( ThreadState* tst, void* p )
+void SK_(__builtin_delete) ( void* p )
 {
-   handle_free(tst, p);
+   handle_free(p);
 }
 
-void SK_(__builtin_vec_delete) ( ThreadState* tst, void* p )
+void SK_(__builtin_vec_delete) ( void* p )
 {
-   handle_free(tst, p);
+   handle_free(p);
 }
 
-void* SK_(realloc) ( ThreadState* tst, void* p, Int new_size )
+void* SK_(realloc) ( void* p, Int new_size )
 {
    HG_Chunk  *hc;
    HG_Chunk **prev_chunks_next_ptr;
    Int        i;
+   ThreadId   tid = VG_(get_current_or_recent_tid)();
 
    /* First try and find the block. */
    hc = (HG_Chunk*)VG_(HT_get_node) ( hg_malloc_list, (UInt)p,
@@ -1991,12 +1989,12 @@ void* SK_(realloc) ( ThreadState* tst, void* p, Int new_size )
          ((UChar*)p_new)[i] = ((UChar*)p)[i];
 
       /* Free old memory */
-      die_and_free_mem ( tst, hc, prev_chunks_next_ptr );
+      die_and_free_mem ( tid, hc, prev_chunks_next_ptr );
 
       /* this has to be after die_and_free_mem, otherwise the
          former succeeds in shorting out the new block, not the
          old, in the case when both are on the same list.  */
-      add_HG_Chunk ( tst, p_new, new_size );
+      add_HG_Chunk ( tid, p_new, new_size );
 
       return (void*)p_new;
    }  
@@ -2433,7 +2431,7 @@ UInt SK_(update_extra)(Error* err)
    return sizeof(HelgrindError);
 }
 
-static void record_eraser_error ( ThreadState *tst, Addr a, Bool is_write,
+static void record_eraser_error ( ThreadId tid, Addr a, Bool is_write,
 				  shadow_word prevstate )
 {
    shadow_word *sw;
@@ -2447,7 +2445,7 @@ static void record_eraser_error ( ThreadState *tst, Addr a, Bool is_write,
    err_extra.prevstate = prevstate;
    if (clo_execontext)
       err_extra.lasttouched = getExeContext(a);
-   VG_(maybe_record_error)( tst, EraserErr, a, 
+   VG_(maybe_record_error)( tid, EraserErr, a, 
                             (is_write ? "writing" : "reading"),
                             &err_extra);
 
@@ -2471,7 +2469,7 @@ static void record_mutex_error(ThreadId tid, Mutex *mutex,
    err_extra.lasttouched = EC(ec, virgin_sword, thread_seg[tid]);
    err_extra.lasttid = tid;
 
-   VG_(maybe_record_error)(VG_(get_ThreadState)(tid), MutexErr, 
+   VG_(maybe_record_error)(tid, MutexErr, 
 			   (Addr)mutex->mutexp, str, &err_extra);
 }
 
@@ -2491,8 +2489,7 @@ static void record_lockgraph_error(ThreadId tid, Mutex *mutex,
    err_extra.held_lockset = lockset_holding;
    err_extra.prev_lockset = lockset_prev;
    
-   VG_(maybe_record_error)(VG_(get_ThreadState)(tid), LockGraphErr, 
-			   mutex->mutexp, "", &err_extra);
+   VG_(maybe_record_error)(tid, LockGraphErr, mutex->mutexp, "", &err_extra);
 }
 
 Bool SK_(eq_SkinError) ( VgRes not_used, Error* e1, Error* e2 )
@@ -2771,7 +2768,7 @@ static void eraser_pre_mutex_lock(ThreadId tid, void* void_mutex)
 {
    Mutex *mutex = get_mutex((Addr)void_mutex);
 
-   test_mutex_state(mutex, MxLocked, tid, VG_(get_ThreadState)(tid));
+   test_mutex_state(mutex, MxLocked, tid);
 }
 
 static void eraser_post_mutex_lock(ThreadId tid, void* void_mutex)
@@ -2780,7 +2777,7 @@ static void eraser_post_mutex_lock(ThreadId tid, void* void_mutex)
    Mutex *mutex = get_mutex((Addr)void_mutex);
    const LockSet*  ls;
 
-   set_mutex_state(mutex, MxLocked, tid, VG_(get_ThreadState)(tid));
+   set_mutex_state(mutex, MxLocked, tid);
 
 #  if DEBUG_LOCKS
    VG_(printf)("lock  (%u, %p)\n", tid, mutex->mutexp);
@@ -2815,8 +2812,8 @@ static void eraser_post_mutex_unlock(ThreadId tid, void* void_mutex)
    Mutex *mutex = get_mutex((Addr)void_mutex);
    const LockSet *ls;
 
-   test_mutex_state(mutex, MxUnlocked, tid, VG_(get_ThreadState)(tid));
-   set_mutex_state(mutex, MxUnlocked, tid, VG_(get_ThreadState)(tid));
+   test_mutex_state(mutex, MxUnlocked, tid);
+   set_mutex_state(mutex, MxUnlocked, tid);
 
    if (!ismember(thread_locks[tid], mutex))
        return;
@@ -2883,7 +2880,7 @@ void dump_around_a(Addr a)
    #define DEBUG_STATE(args...)
 #endif
 
-static void eraser_mem_read_word(Addr a, ThreadId tid, ThreadState *tst)
+static void eraser_mem_read_word(Addr a, ThreadId tid)
 {
    shadow_word* sword /* egcs-2.91.66 complains uninit */ = NULL; 
    shadow_word  prevstate;
@@ -2968,7 +2965,7 @@ static void eraser_mem_read_word(Addr a, ThreadId tid, ThreadState *tst)
    statechange = sword->other != prevstate.other;
 
    if (isempty(ls)) {
-      record_eraser_error(tst, a, False /* !is_write */, prevstate);
+      record_eraser_error(tid, a, False /* !is_write */, prevstate);
    }
    goto done;
 
@@ -2977,32 +2974,25 @@ static void eraser_mem_read_word(Addr a, ThreadId tid, ThreadState *tst)
       EC_EIP eceip;
 
       if (clo_execontext == EC_Some)
-	 eceip = EIP(VG_(get_EIP)(tst), prevstate, tls);
+	 eceip = EIP(VG_(get_EIP)(tid), prevstate, tls);
       else
-	 eceip = EC(VG_(get_ExeContext)(tst), prevstate, tls);
+	 eceip = EC(VG_(get_ExeContext)(tid), prevstate, tls);
       setExeContext(a, eceip);
    }
 }
 
-static void eraser_mem_read(Addr a, UInt size, ThreadState *tst)
+static void eraser_mem_read(Addr a, UInt size, ThreadId tid)
 {
-   ThreadId tid;
-   Addr     end;
+   Addr end;
 
    end = ROUNDUP(a+size, 4);
    a = ROUNDDN(a, 4);
 
-   if (tst == NULL)
-      tid = VG_(get_current_tid)();
-   else
-      tid = VG_(get_tid_from_ThreadState)(tst);
-
-
    for ( ; a < end; a += 4)
-      eraser_mem_read_word(a, tid, tst);
+      eraser_mem_read_word(a, tid);
 }
 
-static void eraser_mem_write_word(Addr a, ThreadId tid, ThreadState *tst)
+static void eraser_mem_write_word(Addr a, ThreadId tid)
 {
    ThreadLifeSeg *tls;
    shadow_word* sword /* egcs-2.91.66 complains uninit */ = NULL;
@@ -3080,7 +3070,7 @@ static void eraser_mem_write_word(Addr a, ThreadId tid, ThreadState *tst)
 
   SHARED_MODIFIED:
    if (isempty(unpackLockSet(sword->other))) {
-      record_eraser_error(tst, a, True /* is_write */, prevstate);
+      record_eraser_error(tid, a, True /* is_write */, prevstate);
    }
    goto done;
 
@@ -3089,70 +3079,64 @@ static void eraser_mem_write_word(Addr a, ThreadId tid, ThreadState *tst)
       EC_EIP eceip;
 
       if (clo_execontext == EC_Some)
-	 eceip = EIP(VG_(get_EIP)(tst), prevstate, tls);
+	 eceip = EIP(VG_(get_EIP)(tid), prevstate, tls);
       else
-	 eceip = EC(VG_(get_ExeContext)(tst), prevstate, tls);
+	 eceip = EC(VG_(get_ExeContext)(tid), prevstate, tls);
       setExeContext(a, eceip);
    }
 }
 
-static void eraser_mem_write(Addr a, UInt size, ThreadState *tst)
+static void eraser_mem_write(Addr a, UInt size, ThreadId tid)
 {
-   ThreadId tid;
    Addr     end;
 
    end = ROUNDUP(a+size, 4);
    a = ROUNDDN(a, 4);
 
-   if (tst == NULL)
-      tid = VG_(get_current_tid)();
-   else
-      tid = VG_(get_tid_from_ThreadState)(tst);
-   
    for ( ; a < end; a += 4)
-      eraser_mem_write_word(a, tid, tst);
+      eraser_mem_write_word(a, tid);
 }
 
 #undef DEBUG_STATE
 
 static void eraser_mem_help_read_1(Addr a)
 {
-   eraser_mem_read(a, 1, NULL);
+   eraser_mem_read(a, 1, VG_(get_current_tid)());
 }
 
 static void eraser_mem_help_read_2(Addr a)
 {
-   eraser_mem_read(a, 2, NULL);
+   eraser_mem_read(a, 2, VG_(get_current_tid)());
 }
 
 static void eraser_mem_help_read_4(Addr a)
 {
-   eraser_mem_read(a, 4, NULL);
+   eraser_mem_read(a, 4, VG_(get_current_tid)());
 }
 
 static void eraser_mem_help_read_N(Addr a, UInt size)
 {
-   eraser_mem_read(a, size, NULL);
+   eraser_mem_read(a, size, VG_(get_current_tid)());
 }
 
 static void eraser_mem_help_write_1(Addr a, UInt val)
 {
    if (*(UChar *)a != val)
-      eraser_mem_write(a, 1, NULL);
+      eraser_mem_write(a, 1, VG_(get_current_tid)());
 }
 static void eraser_mem_help_write_2(Addr a, UInt val)
 {
    if (*(UShort *)a != val)
-      eraser_mem_write(a, 2, NULL);
+      eraser_mem_write(a, 2, VG_(get_current_tid)());
 }
 static void eraser_mem_help_write_4(Addr a, UInt val)
 {
    if (*(UInt *)a != val)
-      eraser_mem_write(a, 4, NULL);
+      eraser_mem_write(a, 4, VG_(get_current_tid)());
 }
 static void eraser_mem_help_write_N(Addr a, UInt size)
 {
-   eraser_mem_write(a, size, NULL);
+   eraser_mem_write(a, size, VG_(get_current_tid)());
 }
 
 static void hg_thread_create(ThreadId parent, ThreadId child)
@@ -3196,7 +3180,7 @@ static void bus_unlock(void)
 /*--- Client requests                                              ---*/
 /*--------------------------------------------------------------------*/
 
-Bool SK_(handle_client_request)(ThreadState *tst, UInt *args, UInt *ret)
+Bool SK_(handle_client_request)(ThreadId tid, UInt *args, UInt *ret)
 {
    if (!VG_IS_SKIN_USERREQ('H','G',args[0]))
       return False;
diff --git a/include/vg_skin.h b/include/vg_skin.h
index c478bdcc4a..bce90cb8af 100644
--- a/include/vg_skin.h
+++ b/include/vg_skin.h
@@ -116,7 +116,7 @@ typedef unsigned char          Bool;
    interface;  if the core and skin major versions don't match, Valgrind
    will abort.  The minor version indicates binary-compatible changes.
 */
-#define VG_CORE_INTERFACE_MAJOR_VERSION   2
+#define VG_CORE_INTERFACE_MAJOR_VERSION   3
 #define VG_CORE_INTERFACE_MINOR_VERSION   0
 
 extern const Int VG_(skin_interface_major_version);
@@ -275,29 +275,35 @@ extern Bool VG_(within_m_state_static_OR_threads)(Addr a);
    pthread_mutex_t.__m_owner and pthread_cond_t.__c_waiting. */
 #define VG_INVALID_THREADID ((ThreadId)(0))
 
-/* ThreadIds are simply indices into the vg_threads[] array. */
+/* ThreadIds are simply indices into the VG_(threads)[] array. */
 typedef 
    UInt 
    ThreadId;
 
-/* struct _ThreadState defined elsewhere;  ThreadState is abstract as its
-   definition is not important for skins. */
-typedef
-   struct _ThreadState
-   ThreadState;
-
-/* Use this one from generated code */
-extern ThreadId     VG_(get_current_tid)           ( void );
-
-/* Use this one from non-generated code -- if you use VG_(get_current_tid)(),
-   it will return 0 for the invalid thread, which is not what you want. */
-extern ThreadId     VG_(get_current_or_recent_tid) ( void );
+/* When looking for the current ThreadId, this is the safe option and
+   probably the one you want.
+  
+   Details: Use this one from non-generated code, eg. from functions called
+   on events like 'new_mem_heap'.  In such a case, the "current" thread is
+   temporarily suspended as Valgrind's dispatcher is running.  This function
+   is also suitable to be called from generated code (ie. from UCode, or a C
+   function called directly from UCode).
+   
+   If you use VG_(get_current_tid)() from non-generated code, it will return
+   0 signifying the invalid thread, which is probably not what you want. */
+extern ThreadId VG_(get_current_or_recent_tid) ( void );
 
-extern ThreadId     VG_(get_tid_from_ThreadState)  ( ThreadState* );
-extern ThreadState* VG_(get_ThreadState)           ( ThreadId tid );
+/* When looking for the current ThreadId, only use this one if you know what
+   you are doing.
+  
+   Details: Use this one from generated code, eg. from C functions called
+   from UCode.  (VG_(get_current_or_recent_tid)() is also suitable in that
+   case.)  If you use this function from non-generated code, it will return
+   0 signifying the invalid thread, which is probably not what you want. */
+extern ThreadId VG_(get_current_tid)           ( void );
 
 /* Searches through all thread's stacks to see if any match.  Returns
- * VG_INVALID_THREADID if none match. */
+   VG_INVALID_THREADID if none match. */
 extern ThreadId VG_(first_matching_thread_stack)
                         ( Bool (*p) ( Addr stack_min, Addr stack_max ));
 
@@ -1249,16 +1255,17 @@ extern void VG_(pp_ExeContext) ( ExeContext* );
    ExeContexts to see if we already have it, and if not, allocate a
    new one.  Either way, return a pointer to the context. 
    
-   If called from generated code, `tst' can be NULL and it will use the
-   ThreadState of the current thread.  If called from elsewhere, `tst'
-   should not be NULL.
+   If called from generated code, use VG_(get_current_tid)() to get the
+   current ThreadId.  If called from non-generated code, the current
+   ThreadId should be passed in by the core. 
 */
-extern ExeContext* VG_(get_ExeContext) ( ThreadState *tst );
+extern ExeContext* VG_(get_ExeContext) ( ThreadId tid );
 
 /* Just grab the client's EIP, as a much smaller and cheaper
-   indication of where they are.  ThreadState should be NULL if it's called
-   from within generated code. */
-extern Addr VG_(get_EIP)( ThreadState *tst );
+   indication of where they are.  Use is basically same as for
+   VG_(get_ExeContext)() above. 
+*/
+extern Addr VG_(get_EIP)( ThreadId tid );
 
 
 /*====================================================================*/
@@ -1330,14 +1337,13 @@ void*       VG_(get_error_extra)   ( Error* err );
    seen before.  If it has, the existing error record will have its count
    incremented.  
    
-   If the error occurs in generated code, 'tst' should be NULL.  If the
-   error occurs in non-generated code, 'tst' should be non-NULL.  The
-   `extra' field can be stack-allocated;  it will be copied by the core
-   if needed.  But it won't be copied if it's NULL.
+   'tid' can be found as for VG_(get_ExeContext)().  The `extra' field can
+   be stack-allocated;  it will be copied by the core if needed (but it
+   won't be copied if it's NULL).
 
    If no 'a', 's' or 'extra' of interest needs to be recorded, just use
    NULL for them.  */
-extern void VG_(maybe_record_error) ( ThreadState* tst, ErrorKind ekind, 
+extern void VG_(maybe_record_error) ( ThreadId tid, ErrorKind ekind, 
                                       Addr a, Char* s, void* extra );
 
 /* Similar to VG_(maybe_record_error)(), except this one doesn't record the
@@ -1347,7 +1353,7 @@ extern void VG_(maybe_record_error) ( ThreadState* tst, ErrorKind ekind,
    hack that's useful sometimes if you just want to know if the error would
    be suppressed without possibly printing it.  `count_error' dictates 
    whether to add the error in the error total count (another mild hack). */
-extern Bool VG_(unique_error) ( ThreadState* tst, ErrorKind ekind,
+extern Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind,
                                 Addr a, Char* s, void* extra,
                                 ExeContext* where, Bool print_error,
                                 Bool allow_GDB_attach, Bool count_error );
@@ -1420,55 +1426,6 @@ typedef
 extern VgSectKind VG_(seg_sect_kind)(Addr);
 
 
-/*====================================================================*/
-/*=== Calling functions from the sim'd CPU                         ===*/
-/*====================================================================*/
-
-#define VG_USERREQ__CLIENT_tstCALL0         0x2101
-#define VG_USERREQ__CLIENT_tstCALL1         0x2102
-#define VG_USERREQ__CLIENT_tstCALL2         0x2103
-#define VG_USERREQ__CLIENT_tstCALL3         0x2104
-
-/* These requests are like VALGRIND_NON_SIMD_CALL[0123] in valgrind.h,
-   except they insert the current ThreadState as the first argument to the
-   called function. */
-#define VALGRIND_NON_SIMD_tstCALL0(_qyy_fn)                    \
-   ({unsigned int _qyy_res;                                    \
-    VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */,  \
-                            VG_USERREQ__CLIENT_tstCALL0,       \
-                            _qyy_fn,                           \
-                            0, 0, 0);                          \
-    _qyy_res;                                                  \
-   })
-
-#define VALGRIND_NON_SIMD_tstCALL1(_qyy_fn, _qyy_arg1)         \
-   ({unsigned int _qyy_res;                                    \
-    VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */,  \
-                            VG_USERREQ__CLIENT_tstCALL1,       \
-                            _qyy_fn,                           \
-                            _qyy_arg1, 0, 0);                  \
-    _qyy_res;                                                  \
-   })
-
-#define VALGRIND_NON_SIMD_tstCALL2(_qyy_fn, _qyy_arg1, _qyy_arg2)    \
-   ({unsigned int _qyy_res;                                    \
-    VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */,  \
-                            VG_USERREQ__CLIENT_tstCALL2,       \
-                            _qyy_fn,                           \
-                            _qyy_arg1, _qyy_arg2, 0);          \
-    _qyy_res;                                                  \
-   })
-
-#define VALGRIND_NON_SIMD_tstCALL3(_qyy_fn, _qyy_arg1, _qyy_arg2, _qyy_arg3)  \
-   ({unsigned int _qyy_res;                                             \
-    VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */,           \
-                            VG_USERREQ__CLIENT_tstCALL3,                \
-                            _qyy_fn,                                    \
-                            _qyy_arg1, _qyy_arg2, _qyy_arg3);           \
-    _qyy_res;                                                           \
-   })
-
-
 /*====================================================================*/
 /*=== Generic hash table                                           ===*/
 /*====================================================================*/
@@ -1581,15 +1538,15 @@ extern UInt VG_(vg_malloc_redzone_szB);
 
 /* If a skin links with vg_replace_malloc.c, the following functions will be
    called appropriately when malloc() et al are called. */
-extern void* SK_(malloc)               ( ThreadState* tst, Int n );
-extern void* SK_(__builtin_new)        ( ThreadState* tst, Int n );
-extern void* SK_(__builtin_vec_new)    ( ThreadState* tst, Int n );
-extern void* SK_(memalign)             ( ThreadState* tst, Int align, Int n );
-extern void* SK_(calloc)               ( ThreadState* tst, Int nmemb, Int n );
-extern void  SK_(free)                 ( ThreadState* tst, void* p );
-extern void  SK_(__builtin_delete)     ( ThreadState* tst, void* p );
-extern void  SK_(__builtin_vec_delete) ( ThreadState* tst, void* p );
-extern void* SK_(realloc)              ( ThreadState* tst, void* p, Int size );
+extern void* SK_(malloc)               ( Int n );
+extern void* SK_(__builtin_new)        ( Int n );
+extern void* SK_(__builtin_vec_new)    ( Int n );
+extern void* SK_(memalign)             ( Int align, Int n );
+extern void* SK_(calloc)               ( Int nmemb, Int n );
+extern void  SK_(free)                 ( void* p );
+extern void  SK_(__builtin_delete)     ( void* p );
+extern void  SK_(__builtin_vec_delete) ( void* p );
+extern void* SK_(realloc)              ( void* p, Int size );
 
 /* Can be called from SK_(malloc) et al to do the actual alloc/freeing. */
 extern void* VG_(cli_malloc) ( UInt align, Int nbytes ); 
@@ -1713,7 +1670,14 @@ typedef
 
 /* Events happening in core to track.  To be notified, pass a callback
    function to the appropriate function.  To ignore an event, don't do
-   anything (default is for events to be ignored). */
+   anything (default is for events to be ignored). 
+   
+   Note that most events aren't passed a ThreadId.  To find out the ThreadId
+   of the affected thread, use VG_(get_current_or_recent_tid)().  For the
+   ones passed a ThreadId, use that instead, since
+   VG_(get_current_or_recent_tid)() might not give the right ThreadId in
+   that case.
+*/
 
 
 /* Memory events (Nb: to track heap allocation/freeing, a skin must replace
@@ -1762,15 +1726,15 @@ EV VG_(track_die_mem_stack)    ( void (*f)(Addr a, UInt len) );
 EV VG_(track_ban_mem_stack)   ( void (*f)(Addr a, UInt len) );
 
 /* These ones occur around syscalls, signal handling, etc */
-EV VG_(track_pre_mem_read)    ( void (*f)(CorePart part, ThreadState* tst,
+EV VG_(track_pre_mem_read)    ( void (*f)(CorePart part, ThreadId tid,
                                           Char* s, Addr a, UInt size) );
-EV VG_(track_pre_mem_read_asciiz) ( void (*f)(CorePart part, ThreadState* tst,
+EV VG_(track_pre_mem_read_asciiz) ( void (*f)(CorePart part, ThreadId tid,
                                               Char* s, Addr a) );
-EV VG_(track_pre_mem_write)   ( void (*f)(CorePart part, ThreadState* tst,
+EV VG_(track_pre_mem_write)   ( void (*f)(CorePart part, ThreadId tid,
                                           Char* s, Addr a, UInt size) );
 /* Not implemented yet -- have to add in lots of places, which is a
    pain.  Won't bother unless/until there's a need. */
-/* EV VG_(track_post_mem_read)  ( void (*f)(ThreadState* tst, Char* s, 
+/* EV VG_(track_post_mem_read)  ( void (*f)(ThreadId tid, Char* s, 
                                             Addr a, UInt size) ); */
 EV VG_(track_post_mem_write) ( void (*f)(Addr a, UInt size) );
 
@@ -1988,7 +1952,7 @@ extern void SK_(print_debug_usage)       ( void );
    not recognised.  arg_block[0] holds the request number, any further args
    from the request are in arg_block[1..].  'ret' is for the return value...
    it should probably be filled, if only with 0. */
-extern Bool SK_(handle_client_request) ( ThreadState* tst, UInt* arg_block,
+extern Bool SK_(handle_client_request) ( ThreadId tid, UInt* arg_block,
                                          UInt *ret );
 
 
diff --git a/memcheck/mac_leakcheck.c b/memcheck/mac_leakcheck.c
index 581d649d3a..3dd71ed5f4 100644
--- a/memcheck/mac_leakcheck.c
+++ b/memcheck/mac_leakcheck.c
@@ -482,7 +482,7 @@ void MAC_(do_detect_memory_leaks) (
 
       print_record = ( MAC_(clo_show_reachable) || Proper != p_min->loss_mode );
       is_suppressed = 
-         VG_(unique_error) ( /*tst*/NULL, LeakErr, (UInt)i+1,
+         VG_(unique_error) ( VG_(get_current_tid)(), LeakErr, (UInt)i+1,
                              (Char*)n_lossrecords, (void*) p_min,
                              p_min->allocated_at, print_record,
                              /*allow_GDB_attach*/False, /*count_error*/False );
diff --git a/memcheck/mac_malloc_wrappers.c b/memcheck/mac_malloc_wrappers.c
index 71757d9cc5..879bffd3b1 100644
--- a/memcheck/mac_malloc_wrappers.c
+++ b/memcheck/mac_malloc_wrappers.c
@@ -127,7 +127,7 @@ MAC_Chunk* MAC_(first_matching_freed_MAC_Chunk) ( Bool (*p)(MAC_Chunk*) )
 
 /* Allocate its shadow chunk, put it on the appropriate list. */
 static
-void add_MAC_Chunk ( ThreadState* tst, Addr p, UInt size, MAC_AllocKind kind )
+void add_MAC_Chunk ( Addr p, UInt size, MAC_AllocKind kind )
 {
    MAC_Chunk* mc;
 
@@ -135,7 +135,7 @@ void add_MAC_Chunk ( ThreadState* tst, Addr p, UInt size, MAC_AllocKind kind )
    mc->data      = p;
    mc->size      = size;
    mc->allockind = kind;
-   mc->where     = VG_(get_ExeContext)(tst);
+   mc->where     = VG_(get_ExeContext)(VG_(get_current_or_recent_tid)());
 
    /* Paranoia ... ensure this area is off-limits to the client, so
       the mc->data field isn't visible to the leak checker.  If memory
@@ -155,15 +155,15 @@ void add_MAC_Chunk ( ThreadState* tst, Addr p, UInt size, MAC_AllocKind kind )
 
 /* Allocate memory and note change in memory available */
 __inline__
-void MAC_(new_block) ( ThreadState* tst, Addr p, UInt size,
-                        UInt rzB, Bool is_zeroed, MAC_AllocKind kind )
+void MAC_(new_block) ( Addr p, UInt size,
+                       UInt rzB, Bool is_zeroed, MAC_AllocKind kind )
 {
    VGP_PUSHCC(VgpCliMalloc);
 
    cmalloc_n_mallocs ++;
    cmalloc_bs_mallocd += size;
 
-   add_MAC_Chunk( tst, p, size, kind );
+   add_MAC_Chunk( p, size, kind );
 
    MAC_(ban_mem_heap)( p-rzB, rzB );
    MAC_(new_mem_heap)( p, size, is_zeroed );
@@ -172,33 +172,33 @@ void MAC_(new_block) ( ThreadState* tst, Addr p, UInt size,
    VGP_POPCC(VgpCliMalloc);
 }
 
-void* SK_(malloc) ( ThreadState* tst, Int n )
+void* SK_(malloc) ( Int n )
 {
    if (n < 0) {
       VG_(message)(Vg_UserMsg, "Warning: silly arg (%d) to malloc()", n );
       return NULL;
    } else {
       Addr p = (Addr)VG_(cli_malloc)( VG_(clo_alignment), n );
-      MAC_(new_block) ( tst, p, n, VG_(vg_malloc_redzone_szB),
+      MAC_(new_block) ( p, n, VG_(vg_malloc_redzone_szB),
                         /*is_zeroed*/False, MAC_AllocMalloc );
       return (void*)p;
    }
 }
 
-void* SK_(__builtin_new) ( ThreadState* tst, Int n )
+void* SK_(__builtin_new) ( Int n )
 {
    if (n < 0) {
       VG_(message)(Vg_UserMsg, "Warning: silly arg (%d) to __builtin_new()", n);
       return NULL;
    } else {
       Addr p = (Addr)VG_(cli_malloc)( VG_(clo_alignment), n );
-      MAC_(new_block) ( tst, p, n, VG_(vg_malloc_redzone_szB),
+      MAC_(new_block) ( p, n, VG_(vg_malloc_redzone_szB),
                         /*is_zeroed*/False, MAC_AllocNew );
       return (void*)p;
    }
 }
 
-void* SK_(__builtin_vec_new) ( ThreadState* tst, Int n )
+void* SK_(__builtin_vec_new) ( Int n )
 {
    if (n < 0) {
       VG_(message)(Vg_UserMsg, 
@@ -206,26 +206,26 @@ void* SK_(__builtin_vec_new) ( ThreadState* tst, Int n )
       return NULL;
    } else {
       Addr p = (Addr)VG_(cli_malloc)( VG_(clo_alignment), n );
-      MAC_(new_block) ( tst, p, n, VG_(vg_malloc_redzone_szB),
+      MAC_(new_block) ( p, n, VG_(vg_malloc_redzone_szB),
                         /*is_zeroed*/False, MAC_AllocNewVec );
       return (void*)p;
    }
 }
 
-void* SK_(memalign) ( ThreadState* tst, Int align, Int n )
+void* SK_(memalign) ( Int align, Int n )
 {
    if (n < 0) {
       VG_(message)(Vg_UserMsg, "Warning: silly arg (%d) to memalign()", n);
       return NULL;
    } else {
       Addr p = (Addr)VG_(cli_malloc)( align, n );
-      MAC_(new_block) ( tst, p, n, VG_(vg_malloc_redzone_szB),
+      MAC_(new_block) ( p, n, VG_(vg_malloc_redzone_szB),
                         /*is_zeroed*/False, MAC_AllocMalloc );
       return (void*)p;
    }
 }
 
-void* SK_(calloc) ( ThreadState* tst, Int nmemb, Int size1 )
+void* SK_(calloc) ( Int nmemb, Int size1 )
 {
    Int   n, i;
 
@@ -237,7 +237,7 @@ void* SK_(calloc) ( ThreadState* tst, Int nmemb, Int size1 )
       return NULL;
    } else {
       Addr p = (Addr)VG_(cli_malloc)( VG_(clo_alignment), n );
-      MAC_(new_block) ( tst, p, n, VG_(vg_malloc_redzone_szB),
+      MAC_(new_block) ( p, n, VG_(vg_malloc_redzone_szB),
                         /*is_zeroed*/True, MAC_AllocMalloc );
       for (i = 0; i < n; i++) 
          ((UChar*)p)[i] = 0;
@@ -246,7 +246,7 @@ void* SK_(calloc) ( ThreadState* tst, Int nmemb, Int size1 )
 }
 
 static
-void die_and_free_mem ( ThreadState* tst, MAC_Chunk* mc,
+void die_and_free_mem ( MAC_Chunk* mc,
                         MAC_Chunk** prev_chunks_next_ptr, UInt rzB )
 {
    /* Note: ban redzones again -- just in case user de-banned them
@@ -262,7 +262,7 @@ void die_and_free_mem ( ThreadState* tst, MAC_Chunk* mc,
    *prev_chunks_next_ptr = mc->next;
 
    /* Record where freed */
-   mc->where = VG_(get_ExeContext) ( tst );
+   mc->where = VG_(get_ExeContext) ( VG_(get_current_or_recent_tid)() );
 
    /* Put it out of harm's way for a while, if not from a client request */
    if (MAC_AllocCustom != mc->allockind)
@@ -273,11 +273,11 @@ void die_and_free_mem ( ThreadState* tst, MAC_Chunk* mc,
 
 
 __inline__
-void MAC_(handle_free) ( ThreadState* tst, Addr p, UInt rzB,
-                         MAC_AllocKind kind )
+void MAC_(handle_free) ( Addr p, UInt rzB, MAC_AllocKind kind )
 {
    MAC_Chunk*  mc;
    MAC_Chunk** prev_chunks_next_ptr;
+   ThreadId    tid = VG_(get_current_or_recent_tid)();
 
    VGP_PUSHCC(VgpCliMalloc);
 
@@ -286,40 +286,41 @@ void MAC_(handle_free) ( ThreadState* tst, Addr p, UInt rzB,
    mc = (MAC_Chunk*)VG_(HT_get_node) ( MAC_(malloc_list), (UInt)p,
                                        (VgHashNode***)&prev_chunks_next_ptr );
    if (mc == NULL) {
-      MAC_(record_free_error) ( tst, p );
+      MAC_(record_free_error) ( tid, p );
       VGP_POPCC(VgpCliMalloc);
       return;
    }
 
    /* check if its a matching free() / delete / delete [] */
    if (kind != mc->allockind) {
-      MAC_(record_freemismatch_error) ( tst, p );
+      MAC_(record_freemismatch_error) ( tid, p );
    }
 
-   die_and_free_mem ( tst, mc, prev_chunks_next_ptr, rzB );
+   die_and_free_mem ( mc, prev_chunks_next_ptr, rzB );
    VGP_POPCC(VgpCliMalloc);
 }
 
-void SK_(free) ( ThreadState* tst, void* p )
+void SK_(free) ( void* p )
 {
-   MAC_(handle_free)(tst, (Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocMalloc);
+   MAC_(handle_free)((Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocMalloc);
 }
 
-void SK_(__builtin_delete) ( ThreadState* tst, void* p )
+void SK_(__builtin_delete) ( void* p )
 {
-   MAC_(handle_free)(tst, (Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocNew);
+   MAC_(handle_free)((Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocNew);
 }
 
-void SK_(__builtin_vec_delete) ( ThreadState* tst, void* p )
+void SK_(__builtin_vec_delete) ( void* p )
 {
-   MAC_(handle_free)(tst, (Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocNewVec);
+   MAC_(handle_free)((Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocNewVec);
 }
 
-void* SK_(realloc) ( ThreadState* tst, void* p, Int new_size )
+void* SK_(realloc) ( void* p, Int new_size )
 {
    MAC_Chunk  *mc;
    MAC_Chunk **prev_chunks_next_ptr;
    UInt        i;
+   ThreadId    tid = VG_(get_current_or_recent_tid)();
 
    VGP_PUSHCC(VgpCliMalloc);
 
@@ -338,7 +339,7 @@ void* SK_(realloc) ( ThreadState* tst, void* p, Int new_size )
                                        (VgHashNode***)&prev_chunks_next_ptr );
 
    if (mc == NULL) {
-      MAC_(record_free_error) ( tst, (Addr)p );
+      MAC_(record_free_error) ( tid, (Addr)p );
       /* Perhaps we should return to the program regardless. */
       VGP_POPCC(VgpCliMalloc);
       return NULL;
@@ -347,7 +348,7 @@ void* SK_(realloc) ( ThreadState* tst, void* p, Int new_size )
    /* check if its a matching free() / delete / delete [] */
    if (MAC_AllocMalloc != mc->allockind) {
       /* can not realloc a range that was allocated with new or new [] */
-      MAC_(record_freemismatch_error) ( tst, (Addr)p );
+      MAC_(record_freemismatch_error) ( tid, (Addr)p );
       /* but keep going anyway */
    }
 
@@ -383,13 +384,13 @@ void* SK_(realloc) ( ThreadState* tst, void* p, Int new_size )
          ((UChar*)p_new)[i] = ((UChar*)p)[i];
 
       /* Free old memory */
-      die_and_free_mem ( tst, mc, prev_chunks_next_ptr,
+      die_and_free_mem ( mc, prev_chunks_next_ptr,
                          VG_(vg_malloc_redzone_szB) );
 
       /* this has to be after die_and_free_mem, otherwise the
          former succeeds in shorting out the new block, not the
          old, in the case when both are on the same list.  */
-      add_MAC_Chunk ( tst, p_new, new_size, MAC_AllocMalloc );
+      add_MAC_Chunk ( p_new, new_size, MAC_AllocMalloc );
 
       VGP_POPCC(VgpCliMalloc);
       return (void*)p_new;
diff --git a/memcheck/mac_needs.c b/memcheck/mac_needs.c
index 852edb3861..17ad8a6ba5 100644
--- a/memcheck/mac_needs.c
+++ b/memcheck/mac_needs.c
@@ -391,7 +391,7 @@ static Bool is_just_below_ESP( Addr esp, Addr aa )
 
 /* This one called from generated code and non-generated code. */
 
-void MAC_(record_address_error) ( ThreadState* tst, Addr a, Int size,
+void MAC_(record_address_error) ( ThreadId tid, Addr a, Int size,
                                   Bool isWrite )
 {
    MAC_Error err_extra;
@@ -409,75 +409,74 @@ void MAC_(record_address_error) ( ThreadState* tst, Addr a, Int size,
    err_extra.size    = size;
    err_extra.addrinfo.akind     = Undescribed;
    err_extra.addrinfo.maybe_gcc = just_below_esp;
-   VG_(maybe_record_error)( tst, AddrErr, a, /*s*/NULL, &err_extra );
+   VG_(maybe_record_error)( tid, AddrErr, a, /*s*/NULL, &err_extra );
 }
 
 /* These ones are called from non-generated code */
 
 /* This is for memory errors in pthread functions, as opposed to pthread API
    errors which are found by the core. */
-void MAC_(record_core_mem_error) ( ThreadState* tst, Bool isWrite, Char* msg )
+void MAC_(record_core_mem_error) ( ThreadId tid, Bool isWrite, Char* msg )
 {
    MAC_Error err_extra;
 
    MAC_(clear_MAC_Error)( &err_extra );
    err_extra.isWrite = isWrite;
-   VG_(maybe_record_error)( tst, CoreMemErr, /*addr*/0, msg, &err_extra );
+   VG_(maybe_record_error)( tid, CoreMemErr, /*addr*/0, msg, &err_extra );
 }
 
-void MAC_(record_param_error) ( ThreadState* tst, Addr a, Bool isWrite, 
+void MAC_(record_param_error) ( ThreadId tid, Addr a, Bool isWrite, 
                                Char* msg )
 {
    MAC_Error err_extra;
 
-   sk_assert(NULL != tst);
+   sk_assert(VG_INVALID_THREADID != tid);
    MAC_(clear_MAC_Error)( &err_extra );
    err_extra.addrinfo.akind = Undescribed;
    err_extra.isWrite = isWrite;
-   VG_(maybe_record_error)( tst, ParamErr, a, msg, &err_extra );
+   VG_(maybe_record_error)( tid, ParamErr, a, msg, &err_extra );
 }
 
-void MAC_(record_jump_error) ( ThreadState* tst, Addr a )
+void MAC_(record_jump_error) ( ThreadId tid, Addr a )
 {
    MAC_Error err_extra;
 
-   sk_assert(NULL != tst);
-
+   sk_assert(VG_INVALID_THREADID != tid);
    MAC_(clear_MAC_Error)( &err_extra );
    err_extra.axskind = ExecAxs;
    err_extra.addrinfo.akind = Undescribed;
-   VG_(maybe_record_error)( tst, AddrErr, a, /*s*/NULL, &err_extra );
+   VG_(maybe_record_error)( tid, AddrErr, a, /*s*/NULL, &err_extra );
 }
 
-void MAC_(record_free_error) ( ThreadState* tst, Addr a ) 
+void MAC_(record_free_error) ( ThreadId tid, Addr a ) 
 {
    MAC_Error err_extra;
 
-   sk_assert(NULL != tst);
-
+   sk_assert(VG_INVALID_THREADID != tid);
    MAC_(clear_MAC_Error)( &err_extra );
    err_extra.addrinfo.akind = Undescribed;
-   VG_(maybe_record_error)( tst, FreeErr, a, /*s*/NULL, &err_extra );
+   VG_(maybe_record_error)( tid, FreeErr, a, /*s*/NULL, &err_extra );
 }
 
-void MAC_(record_freemismatch_error) ( ThreadState* tst, Addr a )
+void MAC_(record_freemismatch_error) ( ThreadId tid, Addr a )
 {
    MAC_Error err_extra;
 
-   sk_assert(NULL != tst);
-
+   sk_assert(VG_INVALID_THREADID != tid);
    MAC_(clear_MAC_Error)( &err_extra );
    err_extra.addrinfo.akind = Undescribed;
-   VG_(maybe_record_error)( tst, FreeMismatchErr, a, /*s*/NULL, &err_extra );
+   VG_(maybe_record_error)( tid, FreeMismatchErr, a, /*s*/NULL, &err_extra );
 }
 
 
-void MAC_(record_overlap_error) ( ThreadState* tst, Char* function )
+// This one not passed a ThreadId, so it grabs it itself.
+void MAC_(record_overlap_error) ( Char* function )
 {
    MAC_Error err_extra;
 
    MAC_(clear_MAC_Error)( &err_extra );
-   VG_(maybe_record_error)( tst, OverlapErr, /*addr*/0, function, &err_extra );
+   VG_(maybe_record_error)( VG_(get_current_or_recent_tid)(), 
+                            OverlapErr, /*addr*/0, function, &err_extra );
 }
 
 
@@ -793,10 +792,14 @@ void MAC_(common_fini)(void (*leak_check)(void))
 /*--- Common client request handling                       ---*/
 /*------------------------------------------------------------*/
 
-Bool MAC_(handle_common_client_requests)(ThreadState* tst, UInt* arg,
-                                         UInt* ret )
+Bool MAC_(handle_common_client_requests)(ThreadId tid, UInt* arg, UInt* ret )
 {
    UInt* argv = (UInt*)arg;
+
+   // Not using 'tid' here because MAC_(new_block)() and MAC_(handle_free)()
+   // grab it themselves.  But what they grab should match 'tid', check
+   // this.
+   sk_assert(tid == VG_(get_current_or_recent_tid)());
    
    switch (arg[0]) {
    case VG_USERREQ__COUNT_LEAKS: { /* count leaked bytes */
@@ -816,14 +819,14 @@ Bool MAC_(handle_common_client_requests)(ThreadState* tst, UInt* arg,
       UInt rzB       =       argv[3];
       Bool is_zeroed = (Bool)argv[4];
 
-      MAC_(new_block) ( tst, p, sizeB, rzB, is_zeroed, MAC_AllocCustom );
+      MAC_(new_block) ( p, sizeB, rzB, is_zeroed, MAC_AllocCustom );
       return True;
    }
    case VG_USERREQ__FREELIKE_BLOCK: {
       Addr p         = (Addr)argv[1];
       UInt rzB       =       argv[2];
 
-      MAC_(handle_free) ( tst, p, rzB, MAC_AllocCustom );
+      MAC_(handle_free) ( p, rzB, MAC_AllocCustom );
       return True;
    }
    default:
diff --git a/memcheck/mac_replace_strmem.c b/memcheck/mac_replace_strmem.c
index f40128fae9..da33b1f7c6 100644
--- a/memcheck/mac_replace_strmem.c
+++ b/memcheck/mac_replace_strmem.c
@@ -84,7 +84,7 @@ void complain2 ( Char* s, char* dst, const char* src )
 {
    Char buf[256];
    snprintf(buf, 100, "%s(%p, %p)", s, dst, src );
-   VALGRIND_NON_SIMD_tstCALL1( MAC_(record_overlap_error), buf );
+   VALGRIND_NON_SIMD_CALL1( MAC_(record_overlap_error), buf );
 }
 
 static __inline__
@@ -92,7 +92,7 @@ void complain3 ( Char* s, void* dst, const void* src, int n )
 {
    Char buf[256];
    snprintf(buf, 100, "%s(%p, %p, %d)", s, dst, src, n );
-   VALGRIND_NON_SIMD_tstCALL1( MAC_(record_overlap_error), buf );
+   VALGRIND_NON_SIMD_CALL1( MAC_(record_overlap_error), buf );
 }
 
 char* strrchr ( const char* s, int c )
diff --git a/memcheck/mac_shared.h b/memcheck/mac_shared.h
index d11b7ab234..a8a4d580a3 100644
--- a/memcheck/mac_shared.h
+++ b/memcheck/mac_shared.h
@@ -289,22 +289,20 @@ extern void MAC_(clear_MAC_Error)          ( MAC_Error* err_extra );
 
 extern Bool MAC_(shared_recognised_suppression) ( Char* name, Supp* su );
 
-extern void MAC_(new_block) ( ThreadState* tst, Addr p, UInt size,
-                              UInt rzB, Bool is_zeroed,
-                              MAC_AllocKind kind );
-extern void MAC_(handle_free) ( ThreadState* tst, Addr p, UInt rzB,
-                                MAC_AllocKind kind );
+extern void MAC_(new_block) ( Addr p, UInt size, UInt rzB,
+                              Bool is_zeroed, MAC_AllocKind kind );
+extern void MAC_(handle_free) ( Addr p, UInt rzB, MAC_AllocKind kind );
 
-extern void MAC_(record_address_error)     ( ThreadState* tst, Addr a,
+extern void MAC_(record_address_error)     ( ThreadId tid, Addr a,
                                              Int size, Bool isWrite );
-extern void MAC_(record_core_mem_error)    ( ThreadState* tst, Bool isWrite,
+extern void MAC_(record_core_mem_error)    ( ThreadId tid, Bool isWrite,
                                              Char* s );
-extern void MAC_(record_param_error)       ( ThreadState* tst, Addr a,   
+extern void MAC_(record_param_error)       ( ThreadId tid, Addr a,   
                                              Bool isWriteLack, Char* msg );
-extern void MAC_(record_jump_error)        ( ThreadState* tst, Addr a );
-extern void MAC_(record_free_error)        ( ThreadState* tst, Addr a );
-extern void MAC_(record_freemismatch_error)( ThreadState* tst, Addr a );
-extern void MAC_(record_overlap_error)     ( ThreadState* tst, Char* function );
+extern void MAC_(record_jump_error)        ( ThreadId tid, Addr a );
+extern void MAC_(record_free_error)        ( ThreadId tid, Addr a );
+extern void MAC_(record_freemismatch_error)( ThreadId tid, Addr a );
+extern void MAC_(record_overlap_error)     ( Char* function );
 
 extern void MAC_(pp_shared_SkinError)      ( Error* err);
 
@@ -313,8 +311,8 @@ extern MAC_Chunk* MAC_(first_matching_freed_MAC_Chunk)( Bool (*p)(MAC_Chunk*) );
 extern void MAC_(common_pre_clo_init) ( void );
 extern void MAC_(common_fini)         ( void (*leak_check)(void) );
 
-extern Bool MAC_(handle_common_client_requests) 
-                  ( ThreadState* tst, UInt* arg_block, UInt* ret );
+extern Bool MAC_(handle_common_client_requests) ( ThreadId tid, 
+                                                  UInt* arg_block, UInt* ret );
 
 extern void MAC_(print_malloc_stats) ( void );
 
diff --git a/memcheck/mc_clientreqs.c b/memcheck/mc_clientreqs.c
index bc703a4d3e..53a2b982b0 100644
--- a/memcheck/mc_clientreqs.c
+++ b/memcheck/mc_clientreqs.c
@@ -144,7 +144,7 @@ Bool MC_(client_perm_maybe_describe)( Addr a, AddrInfo* ai )
    return False;
 }
 
-Bool SK_(handle_client_request) ( ThreadState* tst, UInt* arg, UInt* ret )
+Bool SK_(handle_client_request) ( ThreadId tid, UInt* arg, UInt* ret )
 {
    Int   i;
    Bool  ok;
@@ -157,14 +157,14 @@ Bool SK_(handle_client_request) ( ThreadState* tst, UInt* arg, UInt* ret )
       case VG_USERREQ__CHECK_WRITABLE: /* check writable */
          ok = MC_(check_writable) ( arg[1], arg[2], &bad_addr );
          if (!ok)
-            MC_(record_user_error) ( tst, bad_addr, True );
+            MC_(record_user_error) ( tid, bad_addr, True );
          *ret = ok ? (UInt)NULL : bad_addr;
 	 break;
 
       case VG_USERREQ__CHECK_READABLE: /* check readable */
          ok = MC_(check_readable) ( arg[1], arg[2], &bad_addr );
          if (!ok)
-            MC_(record_user_error) ( tst, bad_addr, False );
+            MC_(record_user_error) ( tid, bad_addr, False );
          *ret = ok ? (UInt)NULL : bad_addr;
 	 break;
 
@@ -179,7 +179,7 @@ Bool SK_(handle_client_request) ( ThreadState* tst, UInt* arg, UInt* ret )
          vg_cgbs[i].kind  = CG_NoAccess;
          vg_cgbs[i].start = arg[1];
          vg_cgbs[i].size  = arg[2];
-         vg_cgbs[i].where = VG_(get_ExeContext) ( tst );
+         vg_cgbs[i].where = VG_(get_ExeContext) ( tid );
          MC_(make_noaccess) ( arg[1], arg[2] );
 	 *ret = i;
 	 break;
@@ -189,7 +189,7 @@ Bool SK_(handle_client_request) ( ThreadState* tst, UInt* arg, UInt* ret )
          vg_cgbs[i].kind  = CG_Writable;
          vg_cgbs[i].start = arg[1];
          vg_cgbs[i].size  = arg[2];
-         vg_cgbs[i].where = VG_(get_ExeContext) ( tst );
+         vg_cgbs[i].where = VG_(get_ExeContext) ( tid );
          MC_(make_writable) ( arg[1], arg[2] );
          *ret = i;
 	 break;
@@ -199,7 +199,7 @@ Bool SK_(handle_client_request) ( ThreadState* tst, UInt* arg, UInt* ret )
          vg_cgbs[i].kind  = CG_Readable;
          vg_cgbs[i].start = arg[1];
          vg_cgbs[i].size  = arg[2];
-         vg_cgbs[i].where = VG_(get_ExeContext) ( tst );
+         vg_cgbs[i].where = VG_(get_ExeContext) ( tid );
          MC_(make_readable) ( arg[1], arg[2] );
 	 *ret = i;
          break;
@@ -219,7 +219,7 @@ Bool SK_(handle_client_request) ( ThreadState* tst, UInt* arg, UInt* ret )
             error. */
          /* VG_(printf)("get_vbits %p %p %d\n", arg[1], arg[2], arg[3] ); */
          *ret = MC_(get_or_set_vbits_for_client)
-                   ( tst, arg[1], arg[2], arg[3], False /* get them */ );
+                   ( tid, arg[1], arg[2], arg[3], False /* get them */ );
          break;
 
       case VG_USERREQ__SET_VBITS:
@@ -227,11 +227,11 @@ Bool SK_(handle_client_request) ( ThreadState* tst, UInt* arg, UInt* ret )
             error. */
          /* VG_(printf)("set_vbits %p %p %d\n", arg[1], arg[2], arg[3] ); */
          *ret = MC_(get_or_set_vbits_for_client)
-                   ( tst, arg[1], arg[2], arg[3], True /* set them */ );
+                   ( tid, arg[1], arg[2], arg[3], True /* set them */ );
          break;
 
       default:
-         if (MAC_(handle_common_client_requests)(tst, arg, ret )) {
+         if (MAC_(handle_common_client_requests)(tid, arg, ret )) {
             return True;
          } else {
             VG_(message)(Vg_UserMsg, 
diff --git a/memcheck/mc_errcontext.c b/memcheck/mc_errcontext.c
index 5539b220ee..29f0096fd3 100644
--- a/memcheck/mc_errcontext.c
+++ b/memcheck/mc_errcontext.c
@@ -127,27 +127,26 @@ void SK_(pp_SkinError) ( Error* err )
 /* Creates a copy of the `extra' part, updates the copy with address info if
    necessary, and returns the copy. */
 /* This one called from generated code and non-generated code. */
-void MC_(record_value_error) ( ThreadState* tst, Int size )
+void MC_(record_value_error) ( ThreadId tid, Int size )
 {
    MAC_Error err_extra;
 
    MAC_(clear_MAC_Error)( &err_extra );
    err_extra.size = size;
-   VG_(maybe_record_error)( tst, ValueErr, /*addr*/0, /*s*/NULL, &err_extra );
+   VG_(maybe_record_error)( tid, ValueErr, /*addr*/0, /*s*/NULL, &err_extra );
 }
 
 /* This called from non-generated code */
 
-void MC_(record_user_error) ( ThreadState* tst, Addr a, Bool isWrite )
+void MC_(record_user_error) ( ThreadId tid, Addr a, Bool isWrite )
 {
    MAC_Error err_extra;
 
-   sk_assert(NULL != tst);
-
+   sk_assert(VG_INVALID_THREADID != tid);
    MAC_(clear_MAC_Error)( &err_extra );
    err_extra.addrinfo.akind = Undescribed;
    err_extra.isWrite        = isWrite;
-   VG_(maybe_record_error)( tst, UserErr, a, /*s*/NULL, &err_extra );
+   VG_(maybe_record_error)( tid, UserErr, a, /*s*/NULL, &err_extra );
 }
 
 /*------------------------------------------------------------*/
diff --git a/memcheck/mc_include.h b/memcheck/mc_include.h
index 40458dcc90..01414e24a9 100644
--- a/memcheck/mc_include.h
+++ b/memcheck/mc_include.h
@@ -144,7 +144,7 @@ extern Bool MC_(check_readable) ( Addr a, UInt len, Addr* bad_addr );
 extern void MC_(detect_memory_leaks) ( void );
 
 extern Int  MC_(get_or_set_vbits_for_client) ( 
-               ThreadState* tst,
+               ThreadId tid,
                Addr dataV, 
                Addr vbitsV, 
                UInt size, 
@@ -157,8 +157,8 @@ extern void MC_(show_client_block_stats) ( void );
 
 
 /* Functions defined in mc_errcontext.c */
-extern void MC_(record_value_error)  ( ThreadState* tst, Int size );
-extern void MC_(record_user_error)   ( ThreadState* tst, Addr a, Bool isWrite );
+extern void MC_(record_value_error)  ( ThreadId tid, Int size );
+extern void MC_(record_user_error)   ( ThreadId tid, Addr a, Bool isWrite );
 
 
 #endif
diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c
index 28a971248c..eb78cec2ae 100644
--- a/memcheck/mc_main.c
+++ b/memcheck/mc_main.c
@@ -608,8 +608,8 @@ static Bool mc_check_readable_asciiz ( Addr a, Addr* bad_addr )
 /*------------------------------------------------------------*/
 
 static
-void mc_check_is_writable ( CorePart part, ThreadState* tst,
-                            Char* s, Addr base, UInt size )
+void mc_check_is_writable ( CorePart part, ThreadId tid, Char* s,
+                            Addr base, UInt size )
 {
    Bool ok;
    Addr bad_addr;
@@ -622,12 +622,12 @@ void mc_check_is_writable ( CorePart part, ThreadState* tst,
    if (!ok) {
       switch (part) {
       case Vg_CoreSysCall:
-         MAC_(record_param_error) ( tst, bad_addr, /*isWrite =*/True, s );
+         MAC_(record_param_error) ( tid, bad_addr, /*isWrite =*/True, s );
          break;
 
       case Vg_CorePThread:
       case Vg_CoreSignal:
-         MAC_(record_core_mem_error)( tst, /*isWrite=*/True, s );
+         MAC_(record_core_mem_error)( tid, /*isWrite=*/True, s );
          break;
 
       default:
@@ -639,8 +639,8 @@ void mc_check_is_writable ( CorePart part, ThreadState* tst,
 }
 
 static
-void mc_check_is_readable ( CorePart part, ThreadState* tst,
-                            Char* s, Addr base, UInt size )
+void mc_check_is_readable ( CorePart part, ThreadId tid, Char* s,
+                            Addr base, UInt size )
 {     
    Bool ok;
    Addr bad_addr;
@@ -653,17 +653,17 @@ void mc_check_is_readable ( CorePart part, ThreadState* tst,
    if (!ok) {
       switch (part) {
       case Vg_CoreSysCall:
-         MAC_(record_param_error) ( tst, bad_addr, /*isWrite =*/False, s );
+         MAC_(record_param_error) ( tid, bad_addr, /*isWrite =*/False, s );
          break;
       
       case Vg_CorePThread:
-         MAC_(record_core_mem_error)( tst, /*isWrite=*/False, s );
+         MAC_(record_core_mem_error)( tid, /*isWrite=*/False, s );
          break;
 
       /* If we're being asked to jump to a silly address, record an error 
          message before potentially crashing the entire system. */
       case Vg_CoreTranslate:
-         MAC_(record_jump_error)( tst, bad_addr );
+         MAC_(record_jump_error)( tid, bad_addr );
          break;
 
       default:
@@ -674,7 +674,7 @@ void mc_check_is_readable ( CorePart part, ThreadState* tst,
 }
 
 static
-void mc_check_is_readable_asciiz ( CorePart part, ThreadState* tst,
+void mc_check_is_readable_asciiz ( CorePart part, ThreadId tid,
                                    Char* s, Addr str )
 {
    Bool ok = True;
@@ -686,7 +686,7 @@ void mc_check_is_readable_asciiz ( CorePart part, ThreadState* tst,
    sk_assert(part == Vg_CoreSysCall);
    ok = mc_check_readable_asciiz ( (Addr)str, &bad_addr );
    if (!ok) {
-      MAC_(record_param_error) ( tst, bad_addr, /*is_writable =*/False, s );
+      MAC_(record_param_error) ( tid, bad_addr, /*is_writable =*/False, s );
    }
 
    VGP_POPCC(VgpCheckMem);
@@ -959,7 +959,7 @@ static UInt mc_rd_V4_SLOWLY ( Addr a )
    if (!MAC_(clo_partial_loads_ok) 
        || ((a & 3) != 0)
        || (!a0ok && !a1ok && !a2ok && !a3ok)) {
-      MAC_(record_address_error)( /*tst*/NULL, a, 4, False );
+      MAC_(record_address_error)( VG_(get_current_tid)(), a, 4, False );
       return (VGM_BYTE_VALID << 24) | (VGM_BYTE_VALID << 16) 
              | (VGM_BYTE_VALID << 8) | VGM_BYTE_VALID;
    }
@@ -1002,7 +1002,7 @@ static void mc_wr_V4_SLOWLY ( Addr a, UInt vbytes )
 
    /* If an address error has happened, report it. */
    if (aerr)
-      MAC_(record_address_error)( /*tst*/NULL, a, 4, True );
+      MAC_(record_address_error)( VG_(get_current_tid)(), a, 4, True );
 }
 
 static UInt mc_rd_V2_SLOWLY ( Addr a )
@@ -1021,7 +1021,7 @@ static UInt mc_rd_V2_SLOWLY ( Addr a )
 
    /* If an address error has happened, report it. */
    if (aerr) {
-      MAC_(record_address_error)( /*tst*/NULL, a, 2, False );
+      MAC_(record_address_error)( VG_(get_current_tid)(), a, 2, False );
       vw = (VGM_BYTE_INVALID << 24) | (VGM_BYTE_INVALID << 16) 
            | (VGM_BYTE_VALID << 8) | (VGM_BYTE_VALID);
    }
@@ -1043,7 +1043,7 @@ static void mc_wr_V2_SLOWLY ( Addr a, UInt vbytes )
 
    /* If an address error has happened, report it. */
    if (aerr)
-      MAC_(record_address_error)( /*tst*/NULL, a, 2, True );
+      MAC_(record_address_error)( VG_(get_current_tid)(), a, 2, True );
 }
 
 static UInt mc_rd_V1_SLOWLY ( Addr a )
@@ -1060,7 +1060,7 @@ static UInt mc_rd_V1_SLOWLY ( Addr a )
 
    /* If an address error has happened, report it. */
    if (aerr) {
-      MAC_(record_address_error)( /*tst*/NULL, a, 1, False );
+      MAC_(record_address_error)( VG_(get_current_tid)(), a, 1, False );
       vw = (VGM_BYTE_INVALID << 24) | (VGM_BYTE_INVALID << 16) 
            | (VGM_BYTE_INVALID << 8) | (VGM_BYTE_VALID);
    }
@@ -1079,7 +1079,7 @@ static void mc_wr_V1_SLOWLY ( Addr a, UInt vbytes )
 
    /* If an address error has happened, report it. */
    if (aerr)
-      MAC_(record_address_error)( /*tst*/NULL, a, 1, True );
+      MAC_(record_address_error)( VG_(get_current_tid)(), a, 1, True );
 }
 
 
@@ -1090,22 +1090,22 @@ static void mc_wr_V1_SLOWLY ( Addr a, UInt vbytes )
 
 void MC_(helperc_value_check0_fail) ( void )
 {
-   MC_(record_value_error) ( /*tst*/NULL, 0 );
+   MC_(record_value_error) ( VG_(get_current_tid)(), 0 );
 }
 
 void MC_(helperc_value_check1_fail) ( void )
 {
-   MC_(record_value_error) ( /*tst*/NULL, 1 );
+   MC_(record_value_error) ( VG_(get_current_tid)(), 1 );
 }
 
 void MC_(helperc_value_check2_fail) ( void )
 {
-   MC_(record_value_error) ( /*tst*/NULL, 2 );
+   MC_(record_value_error) ( VG_(get_current_tid)(), 2 );
 }
 
 void MC_(helperc_value_check4_fail) ( void )
 {
-   MC_(record_value_error) ( /*tst*/NULL, 4 );
+   MC_(record_value_error) ( VG_(get_current_tid)(), 4 );
 }
 
 
@@ -1311,10 +1311,10 @@ void mc_fpu_read_check_SLOWLY ( Addr addr, Int size )
    }
 
    if (aerr) {
-      MAC_(record_address_error)( /*tst*/NULL, addr, size, False );
+      MAC_(record_address_error)( VG_(get_current_tid)(), addr, size, False );
    } else {
      if (verr)
-        MC_(record_value_error)( /*tst*/NULL, size );
+        MC_(record_value_error)( VG_(get_current_tid)(), size );
    }
 }
 
@@ -1341,7 +1341,7 @@ void mc_fpu_write_check_SLOWLY ( Addr addr, Int size )
       }
    }
    if (aerr) {
-      MAC_(record_address_error)( /*tst*/NULL, addr, size, True );
+      MAC_(record_address_error)( VG_(get_current_tid)(), addr, size, True );
    }
 }
 
@@ -1353,7 +1353,7 @@ void mc_fpu_write_check_SLOWLY ( Addr addr, Int size )
 /* Copy Vbits for src into vbits. Returns: 1 == OK, 2 == alignment
    error, 3 == addressing error. */
 Int MC_(get_or_set_vbits_for_client) ( 
-   ThreadState* tst,
+   ThreadId tid,
    Addr dataV, 
    Addr vbitsV, 
    UInt size, 
@@ -1389,12 +1389,12 @@ Int MC_(get_or_set_vbits_for_client) (
       }
    }
    if (!addressibleD) {
-      MAC_(record_address_error)( tst, (Addr)dataP, 4, 
+      MAC_(record_address_error)( tid, (Addr)dataP, 4, 
                                   setting ? True : False );
       return 3;
    }
    if (!addressibleV) {
-      MAC_(record_address_error)( tst, (Addr)vbitsP, 4, 
+      MAC_(record_address_error)( tid, (Addr)vbitsP, 4, 
                                   setting ? False : True );
       return 3;
    }
@@ -1404,7 +1404,7 @@ Int MC_(get_or_set_vbits_for_client) (
       /* setting */
       for (i = 0; i < szW; i++) {
          if (get_vbytes4_ALIGNED( (Addr)&vbits[i] ) != VGM_WORD_VALID)
-            MC_(record_value_error)(tst, 4);
+            MC_(record_value_error)(tid, 4);
          set_vbytes4_ALIGNED( (Addr)&data[i], vbits[i] );
       }
    } else {