diff options
author | Ian Lance Taylor <iant@google.com> | 2010-09-27 19:48:20 +0000 |
---|---|---|
committer | Ian Lance Taylor <ian@gcc.gnu.org> | 2010-09-27 19:48:20 +0000 |
commit | 7458026b018e6635b9d1bae9ec3b9f4738c3d94a (patch) | |
tree | 69a38455d6a1f5425700674e4dc6483284eed579 /libgcc/generic-morestack.c | |
parent | 177b48f93077a03a72cee7ab5897996e2ea47cdc (diff) | |
download | gcc-7458026b018e6635b9d1bae9ec3b9f4738c3d94a.tar.gz |
common.opt (fsplit-stack): New option.
gcc/:
* common.opt (fsplit-stack): New option.
* opts.c (decode_options): Set flag_split_stack to final value.
* target.def (supports_split_stack): New hook.
* gcc.c (STACK_SPLIT_SPEC): Define.
(LINK_COMMAND_SPEC): Use STACK_SPLIT_SPEC.
* doc/invoke.texi (Option Summary): Mention -fsplit-stack.
(Code Gen Options): Document -fsplit-stack.
* doc/extend.texi (Function Attributes): Mention no_split_stack.
(Function Attributes): Document no_split_stack.
* doc/tm.texi.in (Stack Smashing Protection): Add @hook
TARGET_SUPPORTS_SPLIT_STACK.
* doc/tm.texi: Rebuild.
* function.c (thread_prologue_and_epilogue_insns): If
flag_split_stack, add split stack prologue.
* explow.c (allocate_dynamic_stack_space): Support -fsplit-stack.
* varasm.c (saw_no_split_stack): New static variable.
(assemble_start_function): Set saw_no_split_stack if the function
has the no_split_stack attribute.
(file_end_indicate_split_stack): New function.
* output.h (file_end_indicate_split_stack): Declare.
* libgcc-std.ver (GCC_4.6.0): Add -fsplit-stack support variables
and function.
* doc/libgcc.texi (Miscellaneous routines): Document -fsplit-stack
routines.
* config/i386/i386.c (ix86_option_override_internal): Don't set
expand_builtin_va_start to NULL if -fsplit-stack.
(ix86_function_regparm): Reduce local regparm by 1 for 32-bit
-fsplit-stack.
(ix86_va_start): If -fsplit-stack, get overflow pointer from
scratch register set by prologue.
(ix86_code_end): If -fsplit-stack, call
file_end_indicate_split_stack.
(ix86_supports_split_stack): New static function.
(SPLIT_STACK_AVAILABLE): Define.
(split_stack_prologue_scratch_regno): New static function.
(split_stack_fn): New static variable.
(ix86_expand_split_stack_prologue): New function.
(ix86_live_on_entry): New static function.
(ix86_legitimate_address_p): Handle UNSPEC_STACK_CHECK.
(output_pic_addr_const): Likewise.
(i386_asm_output_addr_const_extra): Likewise.
(ix86_expand_call): Change return type to rtx. Return the new
call instruction.
(TARGET_SUPPORTS_SPLIT_STACK): Define.
(TARGET_EXTRA_LIVE_ON_ENTRY): Define.
* config/i386/i386.md (UNSPEC_STACK_CHECK): Define.
(split_stack_prologue, split_stack_return): New insns.
(split_stack_space_check): New insn.
* config/i386/i386.h (struct machine_function): Add
split_stack_varargs_pointer field.
* config/i386/linux.h (TARGET_CAN_SPLIT_STACK): Define.
(TARGET_THREAD_SPLIT_STACK_OFFSET): Define.
* config/i386/linux64.h (TARGET_CAN_SPLIT_STACK): Define.
(TARGET_THREAD_SPLIT_STACK_OFFSET): Define.
* config/i386/i386-protos.h (ix86_expand_split_stack_prologue):
Declare.
(ix86_expand_call): Update declaration.
gcc/c-family/:
* c-common.c (c_common_attribute_table): Add no_split_stack.
(handle_no_split_stack_attribute): New static function.
gcc/testsuite/:
* lib/target-supports.exp (check_effective_target_split_stack):
New procedure.
* gcc.dg/split-1.c: New test.
* gcc.dg/split-2.c: New test.
* gcc.dg/split-3.c: New test.
* gcc.dg/split-4.c: New test.
libgcc/:
* generic-morestack.h: New file.
* generic-morestack.c: New file.
* generic-morestack-thread.c: New file.
* config/i386/morestack.S: New file.
* config/t-stack: New file.
* config/i386/t-stack-i386: New file.
* config.host (i[34567]86-*-linux* and friends): Add t-stack and
i386/t-stack-i386 to tmake_file.
From-SVN: r164661
Diffstat (limited to 'libgcc/generic-morestack.c')
-rw-r--r-- | libgcc/generic-morestack.c | 876 |
1 files changed, 876 insertions, 0 deletions
diff --git a/libgcc/generic-morestack.c b/libgcc/generic-morestack.c new file mode 100644 index 00000000000..3709d320864 --- /dev/null +++ b/libgcc/generic-morestack.c @@ -0,0 +1,876 @@ +/* Library support for -fsplit-stack. */ +/* Copyright (C) 2009, 2010 Free Software Foundation, Inc. + Contributed by Ian Lance Taylor <iant@google.com>. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +Under Section 7 of GPL version 3, you are granted additional +permissions described in the GCC Runtime Library Exception, version +3.1, as published by the Free Software Foundation. + +You should have received a copy of the GNU General Public License and +a copy of the GCC Runtime Library Exception along with this program; +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +<http://www.gnu.org/licenses/>. */ + +#include "tconfig.h" +#include "tsystem.h" +#include "coretypes.h" +#include "tm.h" + +/* If inhibit_libc is defined, we can not compile this file. The + effect is that people will not be able to use -fsplit-stack. That + is much better than failing the build particularly since people + will want to define inhibit_libc while building a compiler which + can build glibc. */ + +#ifndef inhibit_libc + +#include <assert.h> +#include <errno.h> +#include <signal.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/mman.h> +#include <sys/uio.h> + +#include "generic-morestack.h" + +/* This file contains subroutines that are used by code compiled with + -fsplit-stack. */ + +/* Declare functions to avoid warnings--there is no header file for + these internal functions. We give most of these functions the + flatten attribute in order to minimize their stack usage--here we + must minimize stack usage even at the cost of code size, and in + general inlining everything will do that. */ + +extern void +__generic_morestack_set_initial_sp (void *sp, size_t len) + __attribute__ ((no_split_stack, flatten, visibility ("hidden"))); + +extern void * +__generic_morestack (size_t *frame_size, void *old_stack, size_t param_size) + __attribute__ ((no_split_stack, flatten, visibility ("hidden"))); + +extern void * +__generic_releasestack (size_t *pavailable) + __attribute__ ((no_split_stack, flatten, visibility ("hidden"))); + +extern void +__morestack_block_signals (void) + __attribute__ ((no_split_stack, flatten, visibility ("hidden"))); + +extern void +__morestack_unblock_signals (void) + __attribute__ ((no_split_stack, flatten, visibility ("hidden"))); + +extern size_t +__generic_findstack (void *stack) + __attribute__ ((no_split_stack, flatten, visibility ("hidden"))); + +extern void +__morestack_load_mmap (void) + __attribute__ ((no_split_stack, visibility ("hidden"))); + +extern void * +__morestack_allocate_stack_space (size_t size) + __attribute__ ((visibility ("hidden"))); + +/* This is a function which -fsplit-stack code can call to get a list + of the stacks. Since it is not called only by the compiler, it is + not hidden. */ + +extern void * +__splitstack_find (void *, void *, size_t *, void **, void **, void **) + __attribute__ ((visibility ("default"))); + +/* When we allocate a stack segment we put this header at the + start. */ + +struct stack_segment +{ + /* The previous stack segment--when a function running on this stack + segment returns, it will run on the previous one. */ + struct stack_segment *prev; + /* The next stack segment, if it has been allocated--when a function + is running on this stack segment, the next one is not being + used. */ + struct stack_segment *next; + /* The total size of this stack segment. */ + size_t size; + /* The stack address when this stack was created. This is used when + popping the stack. */ + void *old_stack; + /* A list of memory blocks allocated by dynamic stack + allocation. */ + struct dynamic_allocation_blocks *dynamic_allocation; + /* A list of dynamic memory blocks no longer needed. */ + struct dynamic_allocation_blocks *free_dynamic_allocation; + /* An extra pointer in case we need some more information some + day. */ + void *extra; +}; + +/* This structure holds the (approximate) initial stack pointer and + size for the system supplied stack for a thread. This is set when + the thread is created. We also store a sigset_t here to hold the + signal mask while splitting the stack, since we don't want to store + that on the stack. */ + +struct initial_sp +{ + /* The initial stack pointer. */ + void *sp; + /* The stack length. */ + size_t len; + /* A signal mask, put here so that the thread can use it without + needing stack space. */ + sigset_t mask; + /* Some extra space for later extensibility. */ + void *extra[5]; +}; + +/* A list of memory blocks allocated by dynamic stack allocation. + This is used for code that calls alloca or uses variably sized + arrays. */ + +struct dynamic_allocation_blocks +{ + /* The next block in the list. */ + struct dynamic_allocation_blocks *next; + /* The size of the allocated memory. */ + size_t size; + /* The allocated memory. */ + void *block; +}; + +/* These thread local global variables must be shared by all split + stack code across shared library boundaries. Therefore, they have + default visibility. They have extensibility fields if needed for + new versions. If more radical changes are needed, new code can be + written using new variable names, while still using the existing + variables in a backward compatible manner. Symbol versioning is + also used, although, since these variables are only referenced by + code in this file and generic-morestack-thread.c, it is likely that + simply using new names will suffice. */ + +/* The first stack segment allocated for this thread. */ + +__thread struct stack_segment *__morestack_segments + __attribute__ ((visibility ("default"))); + +/* The stack segment that we think we are currently using. This will + be correct in normal usage, but will be incorrect if an exception + unwinds into a different stack segment or if longjmp jumps to a + different stack segment. */ + +__thread struct stack_segment *__morestack_current_segment + __attribute__ ((visibility ("default"))); + +/* The initial stack pointer and size for this thread. */ + +__thread struct initial_sp __morestack_initial_sp + __attribute__ ((visibility ("default"))); + +/* A static signal mask, to avoid taking up stack space. */ + +static sigset_t __morestack_fullmask; + +/* Convert an integer to a decimal string without using much stack + space. Return a pointer to the part of the buffer to use. We this + instead of sprintf because sprintf will require too much stack + space. */ + +static char * +print_int (int val, char *buf, int buflen, size_t *print_len) +{ + int is_negative; + int i; + unsigned int uval; + + uval = (unsigned int) val; + if (val >= 0) + is_negative = 0; + else + { + is_negative = 1; + uval = - uval; + } + + i = buflen; + do + { + --i; + buf[i] = '0' + (uval % 10); + uval /= 10; + } + while (uval != 0 && i > 0); + + if (is_negative) + { + if (i > 0) + --i; + buf[i] = '-'; + } + + *print_len = buflen - i; + return buf + i; +} + +/* Print the string MSG/LEN, the errno number ERR, and a newline on + stderr. Then crash. */ + +void +__morestack_fail (const char *, size_t, int) __attribute__ ((noreturn)); + +void +__morestack_fail (const char *msg, size_t len, int err) +{ + char buf[24]; + static const char nl[] = "\n"; + struct iovec iov[3]; + union { char *p; const char *cp; } const_cast; + + const_cast.cp = msg; + iov[0].iov_base = const_cast.p; + iov[0].iov_len = len; + /* We can't call strerror, because it may try to translate the error + message, and that would use too much stack space. */ + iov[1].iov_base = print_int (err, buf, sizeof buf, &iov[1].iov_len); + const_cast.cp = &nl[0]; + iov[2].iov_base = const_cast.p; + iov[2].iov_len = sizeof nl - 1; + /* FIXME: On systems without writev we need to issue three write + calls, or punt on printing errno. For now this is irrelevant + since stack splitting only works on GNU/Linux anyhow. */ + writev (2, iov, 3); + abort (); +} + +/* Allocate a new stack segment. FRAME_SIZE is the required frame + size. */ + +static struct stack_segment * +allocate_segment (size_t frame_size) +{ + static unsigned int static_pagesize; + static int use_guard_page; + unsigned int pagesize; + unsigned int overhead; + unsigned int allocate; + void *space; + struct stack_segment *pss; + + pagesize = static_pagesize; + if (pagesize == 0) + { + unsigned int p; + + pagesize = getpagesize (); + +#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 + p = __sync_val_compare_and_swap (&static_pagesize, 0, pagesize); +#else + /* Just hope this assignment is atomic. */ + static_pagesize = pagesize; + p = 0; +#endif + + use_guard_page = getenv ("SPLIT_STACK_GUARD") != 0; + + /* FIXME: I'm not sure this assert should be in the released + code. */ + assert (p == 0 || p == pagesize); + } + + overhead = sizeof (struct stack_segment); + + allocate = pagesize; + if (allocate < MINSIGSTKSZ) + allocate = ((MINSIGSTKSZ + overhead + pagesize - 1) + & ~ (pagesize - 1)); + if (allocate < frame_size) + allocate = ((frame_size + overhead + pagesize - 1) + & ~ (pagesize - 1)); + + if (use_guard_page) + allocate += pagesize; + + /* FIXME: If this binary requires an executable stack, then we need + to set PROT_EXEC. Unfortunately figuring that out is complicated + and target dependent. We would need to use dl_iterate_phdr to + see if there is any object which does not have a PT_GNU_STACK + phdr, though only for architectures which use that mechanism. */ + space = mmap (NULL, allocate, PROT_READ | PROT_WRITE, + MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); + if (space == MAP_FAILED) + { + static const char msg[] = + "unable to allocate additional stack space: errno "; + __morestack_fail (msg, sizeof msg - 1, errno); + } + + if (use_guard_page) + { + void *guard; + +#ifdef STACK_GROWS_DOWNWARD + guard = space; + space = (char *) space + pagesize; +#else + guard = space + allocate - pagesize; +#endif + + mprotect (guard, pagesize, PROT_NONE); + allocate -= pagesize; + } + + pss = (struct stack_segment *) space; + + pss->prev = __morestack_current_segment; + pss->next = NULL; + pss->size = allocate - overhead; + pss->dynamic_allocation = NULL; + pss->free_dynamic_allocation = NULL; + pss->extra = NULL; + + if (__morestack_current_segment != NULL) + __morestack_current_segment->next = pss; + else + __morestack_segments = pss; + + return pss; +} + +/* Free a list of dynamic blocks. */ + +static void +free_dynamic_blocks (struct dynamic_allocation_blocks *p) +{ + while (p != NULL) + { + struct dynamic_allocation_blocks *next; + + next = p->next; + free (p->block); + free (p); + p = next; + } +} + +/* Merge two lists of dynamic blocks. */ + +static struct dynamic_allocation_blocks * +merge_dynamic_blocks (struct dynamic_allocation_blocks *a, + struct dynamic_allocation_blocks *b) +{ + struct dynamic_allocation_blocks **pp; + + if (a == NULL) + return b; + if (b == NULL) + return a; + for (pp = &a->next; *pp != NULL; pp = &(*pp)->next) + ; + *pp = b; + return a; +} + +/* Release stack segments. If FREE_DYNAMIC is non-zero, we also free + any dynamic blocks. Otherwise we return them. */ + +struct dynamic_allocation_blocks * +__morestack_release_segments (struct stack_segment **pp, int free_dynamic) +{ + struct dynamic_allocation_blocks *ret; + struct stack_segment *pss; + + ret = NULL; + pss = *pp; + while (pss != NULL) + { + struct stack_segment *next; + unsigned int allocate; + + next = pss->next; + + if (pss->dynamic_allocation != NULL + || pss->free_dynamic_allocation != NULL) + { + if (free_dynamic) + { + free_dynamic_blocks (pss->dynamic_allocation); + free_dynamic_blocks (pss->free_dynamic_allocation); + } + else + { + ret = merge_dynamic_blocks (pss->dynamic_allocation, ret); + ret = merge_dynamic_blocks (pss->free_dynamic_allocation, ret); + } + } + + allocate = pss->size + sizeof (struct stack_segment); + if (munmap (pss, allocate) < 0) + { + static const char msg[] = "munmap of stack space failed: errno "; + __morestack_fail (msg, sizeof msg - 1, errno); + } + + pss = next; + } + *pp = NULL; + + return ret; +} + +/* This function is called by a processor specific function to set the + initial stack pointer for a thread. The operating system will + always create a stack for a thread. Here we record a stack pointer + near the base of that stack. The size argument lets the processor + specific code estimate how much stack space is available on this + initial stack. */ + +void +__generic_morestack_set_initial_sp (void *sp, size_t len) +{ + /* The stack pointer most likely starts on a page boundary. Adjust + to the nearest 512 byte boundary. It's not essential that we be + precise here; getting it wrong will just leave some stack space + unused. */ +#ifdef STACK_GROWS_DOWNWARD + sp = (void *) ((((__UINTPTR_TYPE__) sp + 511U) / 512U) * 512U); +#else + sp = (void *) ((((__UINTPTR_TYPE__) sp - 511U) / 512U) * 512U); +#endif + + __morestack_initial_sp.sp = sp; + __morestack_initial_sp.len = len; + sigemptyset (&__morestack_initial_sp.mask); + + sigfillset (&__morestack_fullmask); +#ifdef __linux__ + /* On Linux, the first two real time signals are used by the NPTL + threading library. By taking them out of the set of signals, we + avoiding copying the signal mask in pthread_sigmask. More + importantly, pthread_sigmask uses less stack space on x86_64. */ + sigdelset (&__morestack_fullmask, __SIGRTMIN); + sigdelset (&__morestack_fullmask, __SIGRTMIN + 1); +#endif +} + +/* This function is called by a processor specific function which is + run in the prologue when more stack is needed. The processor + specific function handles the details of saving registers and + frobbing the actual stack pointer. This function is responsible + for allocating a new stack segment and for copying a parameter + block from the old stack to the new one. On function entry + *PFRAME_SIZE is the size of the required stack frame--the returned + stack must be at least this large. On function exit *PFRAME_SIZE + is the amount of space remaining on the allocated stack. OLD_STACK + points at the parameters the old stack (really the current one + while this function is running). OLD_STACK is saved so that it can + be returned by a later call to __generic_releasestack. PARAM_SIZE + is the size in bytes of parameters to copy to the new stack. This + function returns a pointer to the new stack segment, pointing to + the memory after the parameters have been copied. The returned + value minus the returned *PFRAME_SIZE (or plus if the stack grows + upward) is the first address on the stack which should not be used. + + This function is running on the old stack and has only a limited + amount of stack space available. */ + +void * +__generic_morestack (size_t *pframe_size, void *old_stack, size_t param_size) +{ + size_t frame_size = *pframe_size; + struct stack_segment *current; + struct stack_segment **pp; + struct dynamic_allocation_blocks *dynamic; + char *from; + char *to; + void *ret; + size_t i; + + current = __morestack_current_segment; + + pp = current != NULL ? ¤t->next : &__morestack_segments; + if (*pp != NULL && (*pp)->size < frame_size) + dynamic = __morestack_release_segments (pp, 0); + else + dynamic = NULL; + current = *pp; + + if (current == NULL) + current = allocate_segment (frame_size); + + current->old_stack = old_stack; + + __morestack_current_segment = current; + + if (dynamic != NULL) + { + /* Move the free blocks onto our list. We don't want to call + free here, as we are short on stack space. */ + current->free_dynamic_allocation = + merge_dynamic_blocks (dynamic, current->free_dynamic_allocation); + } + + *pframe_size = current->size - param_size; + +#ifdef STACK_GROWS_DOWNWARD + { + char *bottom = (char *) (current + 1) + current->size; + to = bottom - param_size; + ret = bottom - param_size; + } +#else + to = current + 1; + ret = (char *) (current + 1) + param_size; +#endif + + /* We don't call memcpy to avoid worrying about the dynamic linker + trying to resolve it. */ + from = (char *) old_stack; + for (i = 0; i < param_size; i++) + *to++ = *from++; + + return ret; +} + +/* This function is called by a processor specific function when it is + ready to release a stack segment. We don't actually release the + stack segment, we just move back to the previous one. The current + stack segment will still be available if we need it in + __generic_morestack. This returns a pointer to the new stack + segment to use, which is the one saved by a previous call to + __generic_morestack. The processor specific function is then + responsible for actually updating the stack pointer. This sets + *PAVAILABLE to the amount of stack space now available. */ + +void * +__generic_releasestack (size_t *pavailable) +{ + struct stack_segment *current; + void *old_stack; + + current = __morestack_current_segment; + old_stack = current->old_stack; + current = current->prev; + __morestack_current_segment = current; + + if (current != NULL) + { +#ifdef STACK_GROWS_DOWNWARD + *pavailable = (char *) old_stack - (char *) (current + 1); +#else + *pavailable = (char *) (current + 1) + current->size - (char *) old_stack; +#endif + } + else + { + size_t used; + + /* We have popped back to the original stack. */ +#ifdef STACK_GROWS_DOWNWARD + if ((char *) old_stack >= (char *) __morestack_initial_sp.sp) + used = 0; + else + used = (char *) __morestack_initial_sp.sp - (char *) old_stack; +#else + if ((char *) old_stack <= (char *) __morestack_initial_sp.sp) + used = 0; + else + used = (char *) old_stack - (char *) __morestack_initial_sp.sp; +#endif + + if (used > __morestack_initial_sp.len) + *pavailable = 0; + else + *pavailable = __morestack_initial_sp.len - used; + } + + return old_stack; +} + +/* Block signals while splitting the stack. This avoids trouble if we + try to invoke a signal handler which itself wants to split the + stack. */ + +extern int pthread_sigmask (int, const sigset_t *, sigset_t *) + __attribute__ ((weak)); + +void +__morestack_block_signals (void) +{ + if (pthread_sigmask) + pthread_sigmask (SIG_BLOCK, &__morestack_fullmask, + &__morestack_initial_sp.mask); + else + sigprocmask (SIG_BLOCK, &__morestack_fullmask, + &__morestack_initial_sp.mask); +} + +/* Unblock signals while splitting the stack. */ + +void +__morestack_unblock_signals (void) +{ + if (pthread_sigmask) + pthread_sigmask (SIG_SETMASK, &__morestack_initial_sp.mask, NULL); + else + sigprocmask (SIG_SETMASK, &__morestack_initial_sp.mask, NULL); +} + +/* This function is called to allocate dynamic stack space, for alloca + or a variably sized array. This is a regular function with + sufficient stack space, so we just use malloc to allocate the + space. We attach the allocated blocks to the current stack + segment, so that they will eventually be reused or freed. */ + +void * +__morestack_allocate_stack_space (size_t size) +{ + struct stack_segment *seg, *current; + struct dynamic_allocation_blocks *p; + + /* We have to block signals to avoid getting confused if we get + interrupted by a signal whose handler itself uses alloca or a + variably sized array. */ + __morestack_block_signals (); + + /* Since we don't want to call free while we are low on stack space, + we may have a list of already allocated blocks waiting to be + freed. Release them all, unless we find one that is large + enough. We don't look at every block to see if one is large + enough, just the first one, because we aren't trying to build a + memory allocator here, we're just trying to speed up common + cases. */ + + current = __morestack_current_segment; + p = NULL; + for (seg = __morestack_segments; seg != NULL; seg = seg->next) + { + p = seg->free_dynamic_allocation; + if (p != NULL) + { + if (p->size >= size) + { + seg->free_dynamic_allocation = p->next; + break; + } + + free_dynamic_blocks (p); + seg->free_dynamic_allocation = NULL; + p = NULL; + } + } + + if (p == NULL) + { + /* We need to allocate additional memory. */ + p = malloc (sizeof (*p)); + if (p == NULL) + abort (); + p->size = size; + p->block = malloc (size); + if (p->block == NULL) + abort (); + } + + /* If we are still on the initial stack, then we have a space leak. + FIXME. */ + if (current != NULL) + { + p->next = current->dynamic_allocation; + current->dynamic_allocation = p; + } + + __morestack_unblock_signals (); + + return p->block; +} + +/* Find the stack segment for STACK and return the amount of space + available. This is used when unwinding the stack because of an + exception, in order to reset the stack guard correctly. */ + +size_t +__generic_findstack (void *stack) +{ + struct stack_segment *pss; + size_t used; + + for (pss = __morestack_current_segment; pss != NULL; pss = pss->prev) + { + if ((char *) pss < (char *) stack + && (char *) pss + pss->size > (char *) stack) + { + __morestack_current_segment = pss; +#ifdef STACK_GROWS_DOWNWARD + return (char *) stack - (char *) (pss + 1); +#else + return (char *) (pss + 1) + pss->size - (char *) stack; +#endif + } + } + + /* We have popped back to the original stack. */ +#ifdef STACK_GROWS_DOWNWARD + if ((char *) stack >= (char *) __morestack_initial_sp.sp) + used = 0; + else + used = (char *) __morestack_initial_sp.sp - (char *) stack; +#else + if ((char *) stack <= (char *) __morestack_initial_sp.sp) + used = 0; + else + used = (char *) stack - (char *) __morestack_initial_sp.sp; +#endif + + if (used > __morestack_initial_sp.len) + return 0; + else + return __morestack_initial_sp.len - used; +} + +/* This function is called at program startup time to make sure that + mmap, munmap, and getpagesize are resolved if linking dynamically. + We want to resolve them while we have enough stack for them, rather + than calling into the dynamic linker while low on stack space. */ + +void +__morestack_load_mmap (void) +{ + /* Call with bogus values to run faster. We don't care if the call + fails. Pass __MORESTACK_CURRENT_SEGMENT to make sure that any + TLS accessor function is resolved. */ + mmap (__morestack_current_segment, 0, PROT_READ, MAP_ANONYMOUS, -1, 0); + mprotect (NULL, 0, 0); + munmap (0, getpagesize ()); +} + +/* This function may be used to iterate over the stack segments. + This can be called like this. + void *next_segment = NULL; + void *next_sp = NULL; + void *initial_sp = NULL; + void *stack; + size_t stack_size; + while ((stack = __splitstack_find (next_segment, next_sp, &stack_size, + &next_segment, &next_sp, + &initial_sp)) != NULL) + { + // Stack segment starts at stack and is stack_size bytes long. + } + + There is no way to iterate over the stack segments of a different + thread. However, what is permitted is for one thread to call this + with the first two values NULL, to pass next_segment, next_sp, and + initial_sp to a different thread, and then to suspend one way or + another. A different thread may run the subsequent + __morestack_find iterations. Of course, this will only work if the + first thread is suspended during the __morestack_find iterations. + If not, the second thread will be looking at the stack while it is + changing, and anything could happen. + + FIXME: This should be declared in some header file, but where? */ + +void * +__splitstack_find (void *segment_arg, void *sp, size_t *len, + void **next_segment, void **next_sp, + void **initial_sp) +{ + struct stack_segment *segment; + void *ret; + char *nsp; + + if (segment_arg == (void *) 1) + { + char *isp = (char *) *initial_sp; + + *next_segment = (void *) 2; + *next_sp = NULL; +#ifdef STACK_GROWS_DOWNWARD + if ((char *) sp >= isp) + return NULL; + *len = (char *) isp - (char *) sp; + return sp; +#else + if ((char *) sp <= (char *) isp) + return NULL; + *len = (char *) sp - (char *) isp; + return (void *) isp; +#endif + } + else if (segment_arg == (void *) 2) + return NULL; + else if (segment_arg != NULL) + segment = (struct stack_segment *) segment_arg; + else + { + *initial_sp = __morestack_initial_sp.sp; + segment = __morestack_current_segment; + sp = (void *) &segment; + while (1) + { + if (segment == NULL) + return __splitstack_find ((void *) 1, sp, len, next_segment, + next_sp, initial_sp); + if ((char *) sp >= (char *) (segment + 1) + && (char *) sp <= (char *) (segment + 1) + segment->size) + break; + segment = segment->prev; + } + } + + if (segment->prev == NULL) + *next_segment = (void *) 1; + else + *next_segment = segment->prev; + + /* The old_stack value is the address of the function parameters of + the function which called __morestack. So if f1 called f2 which + called __morestack, the stack looks like this: + + parameters <- old_stack + return in f1 + return in f2 + data pushed by __morestack + + On x86, the data pushed by __morestack includes the saved value + of the ebp/rbp register. We want our caller to be able to see + that value, which can not be found on any other stack. So we + adjust accordingly. This may need to be tweaked for other + targets. */ + + nsp = (char *) segment->old_stack; +#ifdef STACK_GROWS_DOWNWARD + nsp -= 3 * sizeof (void *); +#else + nsp += 3 * sizeof (void *); +#endif + *next_sp = (void *) nsp; + +#ifdef STACK_GROWS_DOWNWARD + *len = (char *) (segment + 1) + segment->size - (char *) sp; + ret = (void *) sp; +#else + *len = (char *) sp - (char *) (segment + 1); + ret = (void *) (segment + 1); +#endif + + return ret; +} + +#endif /* !defined (inhibit_libc) */ |