minor cleanup with the stack-related fields in ThreadState:
- removed "stack_base" which wasn't used in any meaningful way
- added "client_" prefix to make it clear they concern the client's stack
- renamed "stack_size" as "client_stack_szB" to make the units clear
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@3516 a5019735-40e9-0310-863c-91ae7b9d1cf9
diff --git a/coregrind/amd64-linux/syscalls.c b/coregrind/amd64-linux/syscalls.c
index 67dab79..c9d39e8 100644
--- a/coregrind/amd64-linux/syscalls.c
+++ b/coregrind/amd64-linux/syscalls.c
@@ -364,9 +364,10 @@
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 @@
} 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 8f738e3..95e2ff5 100644
--- a/coregrind/amd64/signals.c
+++ b/coregrind/amd64/signals.c
@@ -377,7 +377,7 @@
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 fcfd1bf..ace6477 100644
--- a/coregrind/core.h
+++ b/coregrind/core.h
@@ -596,7 +596,7 @@
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 @@
/* 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 f8c7c4e..5821d58 100644
--- a/coregrind/stacktrace.c
+++ b/coregrind/stacktrace.c
@@ -116,7 +116,7 @@
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 59f89b5..91ac173 100644
--- a/coregrind/vg_scheduler.c
+++ b/coregrind/vg_scheduler.c
@@ -144,7 +144,7 @@
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 @@
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 @@
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 @@
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 86a37e1..6eb5f8b 100644
--- a/coregrind/vg_signals.c
+++ b/coregrind/vg_signals.c
@@ -1842,7 +1842,7 @@
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 45d3eb6..344ee6d 100644
--- a/coregrind/vg_syscalls.c
+++ b/coregrind/vg_syscalls.c
@@ -5004,7 +5004,7 @@
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 2dc52b5..5f046cb 100644
--- a/coregrind/x86-linux/syscalls.c
+++ b/coregrind/x86-linux/syscalls.c
@@ -358,9 +358,8 @@
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 @@
} 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 2f72fe4..88895d4 100644
--- a/coregrind/x86/signals.c
+++ b/coregrind/x86/signals.c
@@ -397,7 +397,7 @@
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",