diff --git a/coregrind/amd64-linux/syscalls.c b/coregrind/amd64-linux/syscalls.c
index 67dab790e..c9d39e8cb 100644
--- a/coregrind/amd64-linux/syscalls.c
+++ b/coregrind/amd64-linux/syscalls.c
@@ -364,9 +364,10 @@ static Int do_clone(ThreadId ptid,
       only go down to the start of the mmaped segment. */
    seg = VG_(find_segment)((Addr)rsp);
    if (seg) {
-      ctst->stack_base = seg->addr;
-      ctst->stack_highest_word = (Addr)PGROUNDUP(rsp);
-      ctst->stack_size = ctst->stack_highest_word - ctst->stack_base;
+      ctst->client_stack_base = seg->addr;
+      ctst->client_stack_highest_word = (Addr)PGROUNDUP(rsp);
+      ctst->client_stack_szB  = ctst->client_stack_highest_word 
+                              - ctst->client_stack_base;
 
       if (debug)
 	 VG_(printf)("tid %d: guessed client stack range %p-%p\n",
@@ -374,8 +375,8 @@ static Int do_clone(ThreadId ptid,
    } else {
       VG_(message)(Vg_UserMsg, "!? New thread %d starts with RSP(%p) unmapped\n",
 		   ctid, rsp);
-      ctst->stack_base = 0;
-      ctst->stack_size = 0;
+      ctst->client_stack_base = 0;
+      ctst->client_stack_szB  = 0;
    }
 
    if (flags & VKI_CLONE_SETTLS) {
diff --git a/coregrind/amd64/signals.c b/coregrind/amd64/signals.c
index 8f738e34f..95e2ff5ee 100644
--- a/coregrind/amd64/signals.c
+++ b/coregrind/amd64/signals.c
@@ -377,7 +377,7 @@ static Bool extend ( ThreadState *tst, Addr addr, SizeT size )
    ThreadId tid = tst->tid;
    Segment *stackseg = NULL;
 
-   if (VG_(extend_stack)(addr, tst->stack_size)) {
+   if (VG_(extend_stack)(addr, tst->client_stack_szB)) {
       stackseg = VG_(find_segment)(addr);
       if (0 && stackseg)
 	 VG_(printf)("frame=%p seg=%p-%p\n",
diff --git a/coregrind/core.h b/coregrind/core.h
index fcfd1bf55..ace647785 100644
--- a/coregrind/core.h
+++ b/coregrind/core.h
@@ -596,7 +596,7 @@ struct _ThreadState {
       post-syscall function. */
    void *tool_pre_syscall_value;
 
-   /* Stacks.  When a thread slot is freed, we don't deallocate its
+   /* Client stacks.  When a thread slot is freed, we don't deallocate its
       stack; we just leave it lying around for the next use of the
       slot.  If the next use of the slot requires a larger stack,
       only then is the old one deallocated and a new one
@@ -608,18 +608,13 @@ struct _ThreadState {
 
    /* The allocated size of this thread's stack (permanently zero
       if this is ThreadId == 0, since we didn't allocate its stack) */
-   UInt stack_size;
-
-   /* Address of the lowest word in this thread's stack.  NULL means
-      not allocated yet.
-   */
-   Addr stack_base;
+   SizeT client_stack_szB;
 
    /* Address of the highest legitimate word in this stack.  This is
       used for error messages only -- not critical for execution
       correctness.  Is is set for all stacks, specifically including
       ThreadId == 0 (the main thread). */
-   Addr stack_highest_word;
+   Addr client_stack_highest_word;
 
    /* Alternate signal stack */
    vki_stack_t altstack;
diff --git a/coregrind/stacktrace.c b/coregrind/stacktrace.c
index f8c7c4e14..5821d584d 100644
--- a/coregrind/stacktrace.c
+++ b/coregrind/stacktrace.c
@@ -116,7 +116,7 @@ UInt VG_(get_StackTrace) ( ThreadId tid, StackTrace ips, UInt n_ips )
    Addr ip                 = INSTR_PTR(tst->arch);
    Addr fp                 = FRAME_PTR(tst->arch);
    Addr sp                 = STACK_PTR(tst->arch);
-   Addr stack_highest_word = tst->stack_highest_word;
+   Addr stack_highest_word = tst->client_stack_highest_word;
 
 #ifdef __x86__
    /* Nasty little hack to deal with sysinfo syscalls - if libc is
diff --git a/coregrind/vg_scheduler.c b/coregrind/vg_scheduler.c
index 59f89b546..91ac17305 100644
--- a/coregrind/vg_scheduler.c
+++ b/coregrind/vg_scheduler.c
@@ -144,7 +144,7 @@ ThreadId VG_(first_matching_thread_stack)
       if (VG_(threads)[tid].status == VgTs_Empty) continue;
 
       if ( p ( STACK_PTR(VG_(threads)[tid].arch),
-               VG_(threads)[tid].stack_highest_word, d ) )
+               VG_(threads)[tid].client_stack_highest_word, d ) )
          return tid;
    }
    return VG_INVALID_THREADID;
@@ -350,16 +350,6 @@ void VG_(exit_thread)(ThreadId tid)
    vg_assert(VG_(is_running_thread)(tid));
    vg_assert(VG_(is_exiting)(tid));
 
-   /* It's stack is now off-limits
-
-      XXX Don't do this - the client thread implementation can touch
-      the stack after thread death... */
-   if (0 && VG_(threads)[tid].stack_base) {
-      Segment *seg = VG_(find_segment)( VG_(threads)[tid].stack_base );
-      if (seg)
-	 VG_TRACK( die_mem_stack, seg->addr, seg->len );
-   }
-
    VGA_(cleanup_thread)( &VG_(threads)[tid].arch );
 
    mostly_clear_thread_record(tid);
@@ -627,10 +617,9 @@ void VG_(scheduler_init) ( void )
       VGA_(os_state_init)(&VG_(threads)[i]);
       mostly_clear_thread_record(i);
 
-      VG_(threads)[i].status               = VgTs_Empty;
-      VG_(threads)[i].stack_size           = 0;
-      VG_(threads)[i].stack_base           = (Addr)NULL;
-      VG_(threads)[i].stack_highest_word   = (Addr)NULL;
+      VG_(threads)[i].status                    = VgTs_Empty;
+      VG_(threads)[i].client_stack_szB          = 0;
+      VG_(threads)[i].client_stack_highest_word = (Addr)NULL;
    }
 
    tid_main = VG_(alloc_ThreadState)();
@@ -638,9 +627,9 @@ void VG_(scheduler_init) ( void )
    VG_(master_tid) = tid_main;
 
    /* Initial thread's stack is the original process stack */
-   VG_(threads)[tid_main].stack_highest_word = VG_(clstk_end) - sizeof(UInt);
-   VG_(threads)[tid_main].stack_base = VG_(clstk_base);
-   VG_(threads)[tid_main].stack_size = VG_(client_rlimit_stack).rlim_cur;
+   VG_(threads)[tid_main].client_stack_highest_word 
+                                            = VG_(clstk_end) - sizeof(UInt);
+   VG_(threads)[tid_main].client_stack_szB  = VG_(client_rlimit_stack).rlim_cur;
 
    VG_(atfork)(NULL, NULL, sched_fork_cleanup);
 }
diff --git a/coregrind/vg_signals.c b/coregrind/vg_signals.c
index 86a37e1a1..6eb5f8b84 100644
--- a/coregrind/vg_signals.c
+++ b/coregrind/vg_signals.c
@@ -1842,7 +1842,7 @@ void sync_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext *u
 	    then extend the stack segment. 
 	 */
          Addr base = PGROUNDDN(esp - VGA_STACK_REDZONE_SIZE);
-	 if (VG_(extend_stack)(base, VG_(threads)[tid].stack_size)) {
+	 if (VG_(extend_stack)(base, VG_(threads)[tid].client_stack_szB)) {
 	    if (VG_(clo_trace_signals))
 	       VG_(message)(Vg_DebugMsg, 
 			    "       -> extended stack base to %p", PGROUNDDN(fault));
diff --git a/coregrind/vg_syscalls.c b/coregrind/vg_syscalls.c
index 45d3eb60e..344ee6d61 100644
--- a/coregrind/vg_syscalls.c
+++ b/coregrind/vg_syscalls.c
@@ -5004,7 +5004,7 @@ PRE(sys_setrlimit, 0)
          SET_RESULT( -VKI_EPERM );
       }
       else {
-         VG_(threads)[tid].stack_size = ((struct vki_rlimit *)ARG2)->rlim_cur;
+         VG_(threads)[tid].client_stack_szB  = ((struct vki_rlimit *)ARG2)->rlim_cur;
          VG_(client_rlimit_stack) = *(struct vki_rlimit *)ARG2;
          SET_RESULT( 0 );
       }
diff --git a/coregrind/x86-linux/syscalls.c b/coregrind/x86-linux/syscalls.c
index 2dc52b560..5f046cbe0 100644
--- a/coregrind/x86-linux/syscalls.c
+++ b/coregrind/x86-linux/syscalls.c
@@ -358,9 +358,8 @@ static Int do_clone(ThreadId ptid,
       only go down to the start of the mmaped segment. */
    seg = VG_(find_segment)((Addr)esp);
    if (seg) {
-      ctst->stack_base = seg->addr;
-      ctst->stack_highest_word = (Addr)PGROUNDUP(esp);
-      ctst->stack_size = ctst->stack_highest_word - ctst->stack_base;
+      ctst->client_stack_highest_word = (Addr)PGROUNDUP(esp);
+      ctst->client_stack_szB  = ctst->client_stack_highest_word - seg->addr;
 
       if (debug)
 	 VG_(printf)("tid %d: guessed client stack range %p-%p\n",
@@ -368,8 +367,7 @@ static Int do_clone(ThreadId ptid,
    } else {
       VG_(message)(Vg_UserMsg, "!? New thread %d starts with ESP(%p) unmapped\n",
 		   ctid, esp);
-      ctst->stack_base = 0;
-      ctst->stack_size = 0;
+      ctst->client_stack_szB  = 0;
    }
 
    if (flags & VKI_CLONE_SETTLS) {
diff --git a/coregrind/x86/signals.c b/coregrind/x86/signals.c
index 2f72fe413..88895d468 100644
--- a/coregrind/x86/signals.c
+++ b/coregrind/x86/signals.c
@@ -397,7 +397,7 @@ static Bool extend ( ThreadState *tst, Addr addr, SizeT size )
    ThreadId tid = tst->tid;
    Segment *stackseg = NULL;
 
-   if (VG_(extend_stack)(addr, tst->stack_size)) {
+   if (VG_(extend_stack)(addr, tst->client_stack_szB)) {
       stackseg = VG_(find_segment)(addr);
       if (0 && stackseg)
 	 VG_(printf)("frame=%p seg=%p-%p\n",