diff --git a/memcheck/mac_leakcheck.c b/memcheck/mac_leakcheck.c
index 6cd7e32..df2a907 100644
--- a/memcheck/mac_leakcheck.c
+++ b/memcheck/mac_leakcheck.c
@@ -375,6 +375,7 @@
    reachable blocks should be shown.
 */
 void MAC_(do_detect_memory_leaks) (
+   ThreadId tid,
    Bool is_valid_64k_chunk ( UInt ),
    Bool is_valid_address ( Addr )
 )
@@ -499,7 +500,7 @@
 
       print_record = ( MAC_(clo_show_reachable) || Proper != p_min->loss_mode );
       is_suppressed = 
-         VG_(unique_error) ( VG_(get_current_tid)(), LeakErr, (UInt)i+1,
+         VG_(unique_error) ( 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 1cc3575..93ca3af 100644
--- a/memcheck/mac_malloc_wrappers.c
+++ b/memcheck/mac_malloc_wrappers.c
@@ -132,7 +132,8 @@
 
 /* Allocate its shadow chunk, put it on the appropriate list. */
 static
-void add_MAC_Chunk ( Addr p, SizeT size, MAC_AllocKind kind, VgHashTable table)
+void add_MAC_Chunk ( ThreadId tid,
+                     Addr p, SizeT size, MAC_AllocKind kind, VgHashTable table)
 {
    MAC_Chunk* mc;
 
@@ -140,7 +141,7 @@
    mc->data      = p;
    mc->size      = size;
    mc->allockind = kind;
-   mc->where     = VG_(get_ExeContext)(VG_(get_current_or_recent_tid)());
+   mc->where     = VG_(get_ExeContext)(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
@@ -148,7 +149,7 @@
       VG_(malloc) should be noaccess as far as the client is
       concerned. */
    if (!MAC_(check_noaccess)( (Addr)mc, sizeof(MAC_Chunk), NULL )) {
-      VG_(tool_panic)("add_MAC_chunk: shadow area is accessible");
+      VG_(tool_panic)("add_MAC_Chunk: shadow area is accessible");
    } 
 
    VG_(HT_add_node)( table, (VgHashNode*)mc );
@@ -182,7 +183,8 @@
 
 /* Allocate memory and note change in memory available */
 __inline__
-void* MAC_(new_block) ( Addr p, SizeT size, SizeT align, UInt rzB,
+void* MAC_(new_block) ( ThreadId tid,
+                        Addr p, SizeT size, SizeT align, UInt rzB,
                         Bool is_zeroed, MAC_AllocKind kind, VgHashTable table)
 {
    VGP_PUSHCC(VgpCliMalloc);
@@ -202,7 +204,7 @@
       if (is_zeroed) VG_(memset)((void*)p, 0, size);
    }
 
-   add_MAC_Chunk( p, size, kind, table );
+   add_MAC_Chunk( tid, p, size, kind, table );
 
    MAC_(ban_mem_heap)( p-rzB, rzB );
    MAC_(new_mem_heap)( p, size, is_zeroed );
@@ -213,63 +215,64 @@
    return (void*)p;
 }
 
-void* TL_(malloc) ( SizeT n )
+void* TL_(malloc) ( ThreadId tid, SizeT n )
 {
    if (complain_about_silly_args(n, "malloc")) {
       return NULL;
    } else {
-      return MAC_(new_block) ( 0, n, VG_(clo_alignment), 
+      return MAC_(new_block) ( tid, 0, n, VG_(clo_alignment), 
          VG_(vg_malloc_redzone_szB), /*is_zeroed*/False, MAC_AllocMalloc,
          MAC_(malloc_list));
    }
 }
 
-void* TL_(__builtin_new) ( SizeT n )
+void* TL_(__builtin_new) ( ThreadId tid, SizeT n )
 {
    if (complain_about_silly_args(n, "__builtin_new")) {
       return NULL;
    } else {
-      return MAC_(new_block) ( 0, n, VG_(clo_alignment), 
+      return MAC_(new_block) ( tid, 0, n, VG_(clo_alignment), 
          VG_(vg_malloc_redzone_szB), /*is_zeroed*/False, MAC_AllocNew,
          MAC_(malloc_list));
    }
 }
 
-void* TL_(__builtin_vec_new) ( SizeT n )
+void* TL_(__builtin_vec_new) ( ThreadId tid, SizeT n )
 {
    if (complain_about_silly_args(n, "__builtin_vec_new")) {
       return NULL;
    } else {
-      return MAC_(new_block) ( 0, n, VG_(clo_alignment), 
+      return MAC_(new_block) ( tid, 0, n, VG_(clo_alignment), 
          VG_(vg_malloc_redzone_szB), /*is_zeroed*/False, MAC_AllocNewVec,
          MAC_(malloc_list));
    }
 }
 
-void* TL_(memalign) ( SizeT align, SizeT n )
+void* TL_(memalign) ( ThreadId tid, SizeT align, SizeT n )
 {
    if (complain_about_silly_args(n, "memalign")) {
       return NULL;
    } else {
-      return MAC_(new_block) ( 0, n, align, 
+      return MAC_(new_block) ( tid, 0, n, align, 
          VG_(vg_malloc_redzone_szB), /*is_zeroed*/False, MAC_AllocMalloc,
          MAC_(malloc_list));
    }
 }
 
-void* TL_(calloc) ( SizeT nmemb, SizeT size1 )
+void* TL_(calloc) ( ThreadId tid, SizeT nmemb, SizeT size1 )
 {
    if (complain_about_silly_args2(nmemb, size1)) {
       return NULL;
    } else {
-      return MAC_(new_block) ( 0, nmemb*size1, VG_(clo_alignment),
+      return MAC_(new_block) ( tid, 0, nmemb*size1, VG_(clo_alignment),
          VG_(vg_malloc_redzone_szB), /*is_zeroed*/True, MAC_AllocMalloc,
          MAC_(malloc_list));
    }
 }
 
 static
-void die_and_free_mem ( MAC_Chunk* mc,
+void die_and_free_mem ( ThreadId tid,
+                        MAC_Chunk* mc,
                         MAC_Chunk** prev_chunks_next_ptr, SizeT rzB )
 {
    /* Note: ban redzones again -- just in case user de-banned them
@@ -287,18 +290,17 @@
    /* Put it out of harm's way for a while, if not from a client request */
    if (MAC_AllocCustom != mc->allockind) {
       /* Record where freed */
-      mc->where = VG_(get_ExeContext) ( VG_(get_current_or_recent_tid)() );
+      mc->where = VG_(get_ExeContext) ( tid );
       add_to_freed_queue ( mc );
    } else
       VG_(free) ( mc );
 }
 
 __inline__
-void MAC_(handle_free) ( Addr p, UInt rzB, MAC_AllocKind kind )
+void MAC_(handle_free) ( ThreadId tid, 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);
 
@@ -317,31 +319,33 @@
       MAC_(record_freemismatch_error) ( tid, p );
    }
 
-   die_and_free_mem ( mc, prev_chunks_next_ptr, rzB );
+   die_and_free_mem ( tid, mc, prev_chunks_next_ptr, rzB );
    VGP_POPCC(VgpCliMalloc);
 }
 
-void TL_(free) ( void* p )
+void TL_(free) ( ThreadId tid, void* p )
 {
-   MAC_(handle_free)((Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocMalloc);
+   MAC_(handle_free)( 
+      tid, (Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocMalloc );
 }
 
-void TL_(__builtin_delete) ( void* p )
+void TL_(__builtin_delete) ( ThreadId tid, void* p )
 {
-   MAC_(handle_free)((Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocNew);
+   MAC_(handle_free)(
+      tid, (Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocNew);
 }
 
-void TL_(__builtin_vec_delete) ( void* p )
+void TL_(__builtin_vec_delete) ( ThreadId tid, void* p )
 {
-   MAC_(handle_free)((Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocNewVec);
+   MAC_(handle_free)(
+      tid, (Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocNewVec);
 }
 
-void* TL_(realloc) ( void* p, SizeT new_size )
+void* TL_(realloc) ( ThreadId tid, void* p, SizeT new_size )
 {
    MAC_Chunk  *mc;
    MAC_Chunk **prev_chunks_next_ptr;
    UInt        i;
-   ThreadId    tid = VG_(get_current_or_recent_tid)();
 
    VGP_PUSHCC(VgpCliMalloc);
 
@@ -404,13 +408,14 @@
          ((UChar*)p_new)[i] = ((UChar*)p)[i];
 
       /* Free old memory */
-      die_and_free_mem ( mc, prev_chunks_next_ptr,
+      die_and_free_mem ( tid, 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 ( p_new, new_size, MAC_AllocMalloc,  MAC_(malloc_list) );
+      add_MAC_Chunk ( tid, p_new, new_size, 
+                           MAC_AllocMalloc, MAC_(malloc_list) );
 
       VGP_POPCC(VgpCliMalloc);
       return (void*)p_new;
@@ -464,7 +469,7 @@
                                          (void*)&prev_next );
 
    if (mp == NULL) {
-      ThreadId      tid = VG_(get_current_or_recent_tid)();
+      ThreadId      tid = VG_(get_current_tid)();
 
       MAC_(record_illegal_mempool_error) ( tid, pool );
       return;
@@ -477,7 +482,7 @@
    VG_(free)(mp);
 }
 
-void MAC_(mempool_alloc)(Addr pool, Addr addr, SizeT size)
+void MAC_(mempool_alloc)(ThreadId tid, Addr pool, Addr addr, SizeT size)
 {
    MAC_Mempool*  mp;
    MAC_Mempool** prev_next;
@@ -486,13 +491,11 @@
                                         (void*)&prev_next );
 
    if (mp == NULL) {
-      ThreadId      tid = VG_(get_current_or_recent_tid)();
-
       MAC_(record_illegal_mempool_error) ( tid, pool );
       return;
    }
 
-   MAC_(new_block)(addr, size, /*ignored*/0, mp->rzB, mp->is_zeroed,
+   MAC_(new_block)(tid, addr, size, /*ignored*/0, mp->rzB, mp->is_zeroed,
                    MAC_AllocCustom, mp->chunks);
 }
 
@@ -502,8 +505,7 @@
    MAC_Mempool** prev_pool;
    MAC_Chunk*    mc;
    MAC_Chunk**   prev_chunk;
-   ThreadId      tid = VG_(get_current_or_recent_tid)();
-
+   ThreadId      tid = VG_(get_current_tid)();
 
    mp = (MAC_Mempool*)VG_(HT_get_node)(MAC_(mempool_list), (UWord)pool,
                                        (void*)&prev_pool);
@@ -521,7 +523,7 @@
       return;
    }
 
-   die_and_free_mem(mc, prev_chunk, mp->rzB);
+   die_and_free_mem ( tid, mc, prev_chunk, mp->rzB );
 }
 
 typedef
diff --git a/memcheck/mac_needs.c b/memcheck/mac_needs.c
index 561bb87..14edf23 100644
--- a/memcheck/mac_needs.c
+++ b/memcheck/mac_needs.c
@@ -430,7 +430,10 @@
    MAC_Error err_extra;
    Bool      just_below_esp;
 
-   just_below_esp = is_just_below_ESP( VG_(get_stack_pointer)(), a );
+   just_below_esp = is_just_below_ESP( 
+                       VG_(get_stack_pointer)(tid),
+                       a 
+                    );
 
    /* If this is caused by an access immediately below %ESP, and the
       user asks nicely, we just ignore it. */
@@ -512,12 +515,11 @@
    VG_(maybe_record_error)( tid, FreeMismatchErr, a, /*s*/NULL, &err_extra );
 }
 
-
-// This one not passed a ThreadId, so it grabs it itself.
-void MAC_(record_overlap_error) ( Char* function, OverlapExtra* ov_extra )
+void MAC_(record_overlap_error) ( ThreadId tid, 
+                                  Char* function, OverlapExtra* ov_extra )
 {
-   VG_(maybe_record_error)( VG_(get_current_or_recent_tid)(), 
-                            OverlapErr, /*addr*/0, /*s*/function, ov_extra );
+   VG_(maybe_record_error)( 
+      tid, OverlapErr, /*addr*/0, /*s*/function, ov_extra );
 }
 
 
@@ -826,7 +828,7 @@
    init_prof_mem();
 }
 
-void MAC_(common_fini)(void (*leak_check)(void))
+void MAC_(common_fini)(void (*leak_check)(ThreadId))
 {
    MAC_(print_malloc_stats)();
 
@@ -838,7 +840,8 @@
       VG_(message)(Vg_UserMsg, 
                    "For counts of detected errors, rerun with: -v");
    }
-   if (MAC_(clo_leak_check)) leak_check();
+   if (MAC_(clo_leak_check)) 
+      leak_check( 1/*bogus ThreadID*/ );
 
    done_prof_mem();
 }
@@ -855,11 +858,6 @@
       "   program to incorporate the updates in the Valgrind header files.\n"
       "   You shouldn't need to change the text of your program at all.\n"
       "   Everything should then work as before.  Sorry for the bother.\n";
-
-   // Not using 'tid' here because MAC_(new_block)() and MAC_(handle_free)()
-   // grab it themselves.  But what they grab should match 'tid', check
-   // this.
-   tl_assert(tid == VG_(get_current_or_recent_tid)());
    
    switch (arg[0]) {
    case VG_USERREQ__COUNT_LEAKS: { /* count leaked bytes */
@@ -883,7 +881,7 @@
       UInt rzB       =       arg[3];
       Bool is_zeroed = (Bool)arg[4];
 
-      MAC_(new_block) ( p, sizeB, /*ignored*/0, rzB, is_zeroed, 
+      MAC_(new_block) ( tid, p, sizeB, /*ignored*/0, rzB, is_zeroed, 
                         MAC_AllocCustom, MAC_(malloc_list) );
       return True;
    }
@@ -891,7 +889,7 @@
       Addr p         = (Addr)arg[1];
       UInt rzB       =       arg[2];
 
-      MAC_(handle_free) ( p, rzB, MAC_AllocCustom );
+      MAC_(handle_free) ( tid, p, rzB, MAC_AllocCustom );
       return True;
    }
 
@@ -920,7 +918,7 @@
       Addr addr      = (Addr)arg[2];
       UInt size      =       arg[3];
 
-      MAC_(mempool_alloc) ( pool, addr, size );
+      MAC_(mempool_alloc) ( tid, pool, addr, size );
       return True;
    }
 
diff --git a/memcheck/mac_shared.h b/memcheck/mac_shared.h
index 2b57a5e..15bc80f 100644
--- a/memcheck/mac_shared.h
+++ b/memcheck/mac_shared.h
@@ -305,14 +305,21 @@
 
 extern Bool MAC_(shared_recognised_suppression) ( Char* name, Supp* su );
 
-extern void* MAC_(new_block) ( Addr p, SizeT size, SizeT align, UInt rzB,
+extern void* MAC_(new_block) ( ThreadId tid,
+                               Addr p, SizeT size, SizeT align, UInt rzB,
                                Bool is_zeroed, MAC_AllocKind kind,
                                VgHashTable table);
-extern void MAC_(handle_free) ( Addr p, UInt rzB, MAC_AllocKind kind );
+
+extern void MAC_(handle_free) ( ThreadId tid,
+                                Addr p, UInt rzB, MAC_AllocKind kind );
 
 extern void MAC_(create_mempool)(Addr pool, UInt rzB, Bool is_zeroed);
+
 extern void MAC_(destroy_mempool)(Addr pool);
-extern void MAC_(mempool_alloc)(Addr pool, Addr addr, SizeT size);
+
+extern void MAC_(mempool_alloc)(ThreadId tid, 
+                                Addr pool, Addr addr, SizeT size);
+
 extern void MAC_(mempool_free)(Addr pool, Addr addr);
 
 extern void MAC_(record_address_error)     ( ThreadId tid, Addr a,
@@ -324,7 +331,8 @@
 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, OverlapExtra* oe );
+extern void MAC_(record_overlap_error)     ( ThreadId tid, 
+                                             Char* function, OverlapExtra* oe );
 extern void MAC_(record_illegal_mempool_error) ( ThreadId tid, Addr pool );
 
 extern void MAC_(pp_shared_Error)          ( Error* err);
@@ -332,7 +340,7 @@
 extern MAC_Chunk* MAC_(first_matching_freed_MAC_Chunk)( Bool (*p)(MAC_Chunk*, void*), void* d );
 
 extern void MAC_(common_pre_clo_init) ( void );
-extern void MAC_(common_fini)         ( void (*leak_check)(void) );
+extern void MAC_(common_fini)         ( void (*leak_check)(ThreadId) );
 
 extern Bool MAC_(handle_common_client_requests) ( ThreadId tid, 
                                                   UWord* arg_block, UWord* ret );
@@ -344,6 +352,7 @@
                                          UInt n_total_records); 
                            
 extern void MAC_(do_detect_memory_leaks) (
+          ThreadId tid,
           Bool is_valid_64k_chunk ( UInt ),
           Bool is_valid_address   ( Addr )
        );
diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c
index 3e51e72..94667c8 100644
--- a/memcheck/mc_main.c
+++ b/memcheck/mc_main.c
@@ -1474,9 +1474,10 @@
 /* Leak detector for this tool.  We don't actually do anything, merely
    run the generic leak detector with suitable parameters for this
    tool. */
-static void mc_detect_memory_leaks ( void )
+static void mc_detect_memory_leaks ( ThreadId tid )
 {
-   MAC_(do_detect_memory_leaks) ( mc_is_valid_64k_chunk, mc_is_valid_address );
+   MAC_(do_detect_memory_leaks) ( 
+      tid, mc_is_valid_64k_chunk, mc_is_valid_address );
 }
 
 
@@ -1815,7 +1816,7 @@
       }
 
       case VG_USERREQ__DO_LEAK_CHECK:
-         mc_detect_memory_leaks();
+         mc_detect_memory_leaks(tid);
 	 *ret = 0; /* return value is meaningless */
 	 break;