1 /* Library support for -fsplit-stack. */
2 /* Copyright (C) 2009-2020 Free Software Foundation, Inc.
3 Contributed by Ian Lance Taylor <iant@google.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 <http://www.gnu.org/licenses/>. */
26 #pragma GCC optimize ("no-isolate-erroneous-paths-dereference")
28 /* powerpc 32-bit not supported. */
29 #if !defined __powerpc__ || defined __powerpc64__
33 #include "coretypes.h"
35 #include "libgcc_tm.h"
37 /* If inhibit_libc is defined, we cannot compile this file. The
38 effect is that people will not be able to use -fsplit-stack. That
39 is much better than failing the build particularly since people
40 will want to define inhibit_libc while building a compiler which
54 #include "generic-morestack.h"
56 typedef unsigned uintptr_type
__attribute__ ((mode (pointer
)));
58 /* This file contains subroutines that are used by code compiled with
61 /* Declare functions to avoid warnings--there is no header file for
62 these internal functions. We give most of these functions the
63 flatten attribute in order to minimize their stack usage--here we
64 must minimize stack usage even at the cost of code size, and in
65 general inlining everything will do that. */
68 __generic_morestack_set_initial_sp (void *sp
, size_t len
)
69 __attribute__ ((no_split_stack
, flatten
, visibility ("hidden")));
72 __generic_morestack (size_t *frame_size
, void *old_stack
, size_t param_size
)
73 __attribute__ ((no_split_stack
, flatten
, visibility ("hidden")));
76 __generic_releasestack (size_t *pavailable
)
77 __attribute__ ((no_split_stack
, flatten
, visibility ("hidden")));
80 __morestack_block_signals (void)
81 __attribute__ ((no_split_stack
, flatten
, visibility ("hidden")));
84 __morestack_unblock_signals (void)
85 __attribute__ ((no_split_stack
, flatten
, visibility ("hidden")));
88 __generic_findstack (void *stack
)
89 __attribute__ ((no_split_stack
, flatten
, visibility ("hidden")));
92 __morestack_load_mmap (void)
93 __attribute__ ((no_split_stack
, visibility ("hidden")));
96 __morestack_allocate_stack_space (size_t size
)
97 __attribute__ ((visibility ("hidden")));
99 /* These are functions which -fsplit-stack code can call. These are
100 not called by the compiler, and are not hidden. FIXME: These
101 should be in some header file somewhere, somehow. */
104 __splitstack_find (void *, void *, size_t *, void **, void **, void **)
105 __attribute__ ((visibility ("default")));
108 __splitstack_block_signals (int *, int *)
109 __attribute__ ((visibility ("default")));
112 __splitstack_getcontext (void *context
[10])
113 __attribute__ ((no_split_stack
, visibility ("default")));
116 __splitstack_setcontext (void *context
[10])
117 __attribute__ ((no_split_stack
, visibility ("default")));
120 __splitstack_makecontext (size_t, void *context
[10], size_t *)
121 __attribute__ ((visibility ("default")));
124 __splitstack_resetcontext (void *context
[10], size_t *)
125 __attribute__ ((visibility ("default")));
128 __splitstack_releasecontext (void *context
[10])
129 __attribute__ ((visibility ("default")));
132 __splitstack_block_signals_context (void *context
[10], int *, int *)
133 __attribute__ ((visibility ("default")));
136 __splitstack_find_context (void *context
[10], size_t *, void **, void **,
138 __attribute__ ((visibility ("default")));
140 /* These functions must be defined by the processor specific code. */
142 extern void *__morestack_get_guard (void)
143 __attribute__ ((no_split_stack
, visibility ("hidden")));
145 extern void __morestack_set_guard (void *)
146 __attribute__ ((no_split_stack
, visibility ("hidden")));
148 extern void *__morestack_make_guard (void *, size_t)
149 __attribute__ ((no_split_stack
, visibility ("hidden")));
151 /* When we allocate a stack segment we put this header at the
156 /* The previous stack segment--when a function running on this stack
157 segment returns, it will run on the previous one. */
158 struct stack_segment
*prev
;
159 /* The next stack segment, if it has been allocated--when a function
160 is running on this stack segment, the next one is not being
162 struct stack_segment
*next
;
163 /* The total size of this stack segment. */
165 /* The stack address when this stack was created. This is used when
166 popping the stack. */
168 /* A list of memory blocks allocated by dynamic stack
170 struct dynamic_allocation_blocks
*dynamic_allocation
;
171 /* A list of dynamic memory blocks no longer needed. */
172 struct dynamic_allocation_blocks
*free_dynamic_allocation
;
173 /* An extra pointer in case we need some more information some
178 /* This structure holds the (approximate) initial stack pointer and
179 size for the system supplied stack for a thread. This is set when
180 the thread is created. We also store a sigset_t here to hold the
181 signal mask while splitting the stack, since we don't want to store
182 that on the stack. */
186 /* The initial stack pointer. */
188 /* The stack length. */
190 /* A signal mask, put here so that the thread can use it without
191 needing stack space. */
193 /* Non-zero if we should not block signals. This is a reversed flag
194 so that the default zero value is the safe value. The type is
195 uintptr_type because it replaced one of the void * pointers in
197 uintptr_type dont_block_signals
;
198 /* Some extra space for later extensibility. */
202 /* A list of memory blocks allocated by dynamic stack allocation.
203 This is used for code that calls alloca or uses variably sized
206 struct dynamic_allocation_blocks
208 /* The next block in the list. */
209 struct dynamic_allocation_blocks
*next
;
210 /* The size of the allocated memory. */
212 /* The allocated memory. */
216 /* These thread local global variables must be shared by all split
217 stack code across shared library boundaries. Therefore, they have
218 default visibility. They have extensibility fields if needed for
219 new versions. If more radical changes are needed, new code can be
220 written using new variable names, while still using the existing
221 variables in a backward compatible manner. Symbol versioning is
222 also used, although, since these variables are only referenced by
223 code in this file and generic-morestack-thread.c, it is likely that
224 simply using new names will suffice. */
226 /* The first stack segment allocated for this thread. */
228 __thread
struct stack_segment
*__morestack_segments
229 __attribute__ ((visibility ("default")));
231 /* The stack segment that we think we are currently using. This will
232 be correct in normal usage, but will be incorrect if an exception
233 unwinds into a different stack segment or if longjmp jumps to a
234 different stack segment. */
236 __thread
struct stack_segment
*__morestack_current_segment
237 __attribute__ ((visibility ("default")));
239 /* The initial stack pointer and size for this thread. */
241 __thread
struct initial_sp __morestack_initial_sp
242 __attribute__ ((visibility ("default")));
244 /* A static signal mask, to avoid taking up stack space. */
246 static sigset_t __morestack_fullmask
;
248 /* Page size, as returned from getpagesize(). Set on startup. */
249 static unsigned int static_pagesize
;
251 /* Set on startup to non-zero value if SPLIT_STACK_GUARD env var is set. */
252 static int use_guard_page
;
254 /* Convert an integer to a decimal string without using much stack
255 space. Return a pointer to the part of the buffer to use. We this
256 instead of sprintf because sprintf will require too much stack
260 print_int (int val
, char *buf
, int buflen
, size_t *print_len
)
266 uval
= (unsigned int) val
;
279 buf
[i
] = '0' + (uval
% 10);
282 while (uval
!= 0 && i
> 0);
291 *print_len
= buflen
- i
;
295 /* Print the string MSG/LEN, the errno number ERR, and a newline on
296 stderr. Then crash. */
299 __morestack_fail (const char *, size_t, int) __attribute__ ((noreturn
));
302 __morestack_fail (const char *msg
, size_t len
, int err
)
305 static const char nl
[] = "\n";
307 union { char *p
; const char *cp
; } const_cast;
310 iov
[0].iov_base
= const_cast.p
;
311 iov
[0].iov_len
= len
;
312 /* We can't call strerror, because it may try to translate the error
313 message, and that would use too much stack space. */
314 iov
[1].iov_base
= print_int (err
, buf
, sizeof buf
, &iov
[1].iov_len
);
315 const_cast.cp
= &nl
[0];
316 iov
[2].iov_base
= const_cast.p
;
317 iov
[2].iov_len
= sizeof nl
- 1;
318 /* FIXME: On systems without writev we need to issue three write
319 calls, or punt on printing errno. For now this is irrelevant
320 since stack splitting only works on GNU/Linux anyhow. */
325 /* Allocate a new stack segment. FRAME_SIZE is the required frame
328 static struct stack_segment
*
329 allocate_segment (size_t frame_size
)
331 unsigned int pagesize
;
332 unsigned int overhead
;
333 unsigned int allocate
;
335 struct stack_segment
*pss
;
337 pagesize
= static_pagesize
;
338 overhead
= sizeof (struct stack_segment
);
341 if (allocate
< MINSIGSTKSZ
)
342 allocate
= ((MINSIGSTKSZ
+ overhead
+ pagesize
- 1)
344 if (allocate
< frame_size
)
345 allocate
= ((frame_size
+ overhead
+ pagesize
- 1)
349 allocate
+= pagesize
;
351 /* FIXME: If this binary requires an executable stack, then we need
352 to set PROT_EXEC. Unfortunately figuring that out is complicated
353 and target dependent. We would need to use dl_iterate_phdr to
354 see if there is any object which does not have a PT_GNU_STACK
355 phdr, though only for architectures which use that mechanism. */
356 space
= mmap (NULL
, allocate
, PROT_READ
| PROT_WRITE
,
357 MAP_ANONYMOUS
| MAP_PRIVATE
, -1, 0);
358 if (space
== MAP_FAILED
)
360 static const char msg
[] =
361 "unable to allocate additional stack space: errno ";
362 __morestack_fail (msg
, sizeof msg
- 1, errno
);
369 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
371 space
= (char *) space
+ pagesize
;
373 guard
= space
+ allocate
- pagesize
;
376 mprotect (guard
, pagesize
, PROT_NONE
);
377 allocate
-= pagesize
;
380 pss
= (struct stack_segment
*) space
;
384 pss
->size
= allocate
- overhead
;
385 pss
->dynamic_allocation
= NULL
;
386 pss
->free_dynamic_allocation
= NULL
;
392 /* Free a list of dynamic blocks. */
395 free_dynamic_blocks (struct dynamic_allocation_blocks
*p
)
399 struct dynamic_allocation_blocks
*next
;
408 /* Merge two lists of dynamic blocks. */
410 static struct dynamic_allocation_blocks
*
411 merge_dynamic_blocks (struct dynamic_allocation_blocks
*a
,
412 struct dynamic_allocation_blocks
*b
)
414 struct dynamic_allocation_blocks
**pp
;
420 for (pp
= &a
->next
; *pp
!= NULL
; pp
= &(*pp
)->next
)
426 /* Release stack segments. If FREE_DYNAMIC is non-zero, we also free
427 any dynamic blocks. Otherwise we return them. */
429 struct dynamic_allocation_blocks
*
430 __morestack_release_segments (struct stack_segment
**pp
, int free_dynamic
)
432 struct dynamic_allocation_blocks
*ret
;
433 struct stack_segment
*pss
;
439 struct stack_segment
*next
;
440 unsigned int allocate
;
444 if (pss
->dynamic_allocation
!= NULL
445 || pss
->free_dynamic_allocation
!= NULL
)
449 free_dynamic_blocks (pss
->dynamic_allocation
);
450 free_dynamic_blocks (pss
->free_dynamic_allocation
);
454 ret
= merge_dynamic_blocks (pss
->dynamic_allocation
, ret
);
455 ret
= merge_dynamic_blocks (pss
->free_dynamic_allocation
, ret
);
459 allocate
= pss
->size
+ sizeof (struct stack_segment
);
460 if (munmap (pss
, allocate
) < 0)
462 static const char msg
[] = "munmap of stack space failed: errno ";
463 __morestack_fail (msg
, sizeof msg
- 1, errno
);
473 /* This function is called by a processor specific function to set the
474 initial stack pointer for a thread. The operating system will
475 always create a stack for a thread. Here we record a stack pointer
476 near the base of that stack. The size argument lets the processor
477 specific code estimate how much stack space is available on this
481 __generic_morestack_set_initial_sp (void *sp
, size_t len
)
483 /* The stack pointer most likely starts on a page boundary. Adjust
484 to the nearest 512 byte boundary. It's not essential that we be
485 precise here; getting it wrong will just leave some stack space
487 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
488 sp
= (void *) ((((__UINTPTR_TYPE__
) sp
+ 511U) / 512U) * 512U);
490 sp
= (void *) ((((__UINTPTR_TYPE__
) sp
- 511U) / 512U) * 512U);
493 __morestack_initial_sp
.sp
= sp
;
494 __morestack_initial_sp
.len
= len
;
495 sigemptyset (&__morestack_initial_sp
.mask
);
497 sigfillset (&__morestack_fullmask
);
498 #if defined(__GLIBC__) && defined(__linux__)
499 /* In glibc, the first two real time signals are used by the NPTL
500 threading library. By taking them out of the set of signals, we
501 avoiding copying the signal mask in pthread_sigmask. More
502 importantly, pthread_sigmask uses less stack space on x86_64. */
503 sigdelset (&__morestack_fullmask
, __SIGRTMIN
);
504 sigdelset (&__morestack_fullmask
, __SIGRTMIN
+ 1);
508 /* This function is called by a processor specific function which is
509 run in the prologue when more stack is needed. The processor
510 specific function handles the details of saving registers and
511 frobbing the actual stack pointer. This function is responsible
512 for allocating a new stack segment and for copying a parameter
513 block from the old stack to the new one. On function entry
514 *PFRAME_SIZE is the size of the required stack frame--the returned
515 stack must be at least this large. On function exit *PFRAME_SIZE
516 is the amount of space remaining on the allocated stack. OLD_STACK
517 points at the parameters the old stack (really the current one
518 while this function is running). OLD_STACK is saved so that it can
519 be returned by a later call to __generic_releasestack. PARAM_SIZE
520 is the size in bytes of parameters to copy to the new stack. This
521 function returns a pointer to the new stack segment, pointing to
522 the memory after the parameters have been copied. The returned
523 value minus the returned *PFRAME_SIZE (or plus if the stack grows
524 upward) is the first address on the stack which should not be used.
526 This function is running on the old stack and has only a limited
527 amount of stack space available. */
530 __generic_morestack (size_t *pframe_size
, void *old_stack
, size_t param_size
)
532 size_t frame_size
= *pframe_size
;
533 struct stack_segment
*current
;
534 struct stack_segment
**pp
;
535 struct dynamic_allocation_blocks
*dynamic
;
542 current
= __morestack_current_segment
;
544 pp
= current
!= NULL
? ¤t
->next
: &__morestack_segments
;
545 if (*pp
!= NULL
&& (*pp
)->size
< frame_size
)
546 dynamic
= __morestack_release_segments (pp
, 0);
553 current
= allocate_segment (frame_size
+ param_size
);
554 current
->prev
= __morestack_current_segment
;
558 current
->old_stack
= old_stack
;
560 __morestack_current_segment
= current
;
564 /* Move the free blocks onto our list. We don't want to call
565 free here, as we are short on stack space. */
566 current
->free_dynamic_allocation
=
567 merge_dynamic_blocks (dynamic
, current
->free_dynamic_allocation
);
570 *pframe_size
= current
->size
- param_size
;
572 /* Align the returned stack to a 32-byte boundary. */
573 aligned
= (param_size
+ 31) & ~ (size_t) 31;
575 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
577 char *bottom
= (char *) (current
+ 1) + current
->size
;
578 to
= bottom
- aligned
;
579 ret
= bottom
- aligned
;
583 to
+= aligned
- param_size
;
584 ret
= (char *) (current
+ 1) + aligned
;
587 /* We don't call memcpy to avoid worrying about the dynamic linker
588 trying to resolve it. */
589 from
= (char *) old_stack
;
590 for (i
= 0; i
< param_size
; i
++)
596 /* This function is called by a processor specific function when it is
597 ready to release a stack segment. We don't actually release the
598 stack segment, we just move back to the previous one. The current
599 stack segment will still be available if we need it in
600 __generic_morestack. This returns a pointer to the new stack
601 segment to use, which is the one saved by a previous call to
602 __generic_morestack. The processor specific function is then
603 responsible for actually updating the stack pointer. This sets
604 *PAVAILABLE to the amount of stack space now available. */
607 __generic_releasestack (size_t *pavailable
)
609 struct stack_segment
*current
;
612 current
= __morestack_current_segment
;
613 old_stack
= current
->old_stack
;
614 current
= current
->prev
;
615 __morestack_current_segment
= current
;
619 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
620 *pavailable
= (char *) old_stack
- (char *) (current
+ 1);
622 *pavailable
= (char *) (current
+ 1) + current
->size
- (char *) old_stack
;
629 /* We have popped back to the original stack. */
630 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
631 if ((char *) old_stack
>= (char *) __morestack_initial_sp
.sp
)
634 used
= (char *) __morestack_initial_sp
.sp
- (char *) old_stack
;
636 if ((char *) old_stack
<= (char *) __morestack_initial_sp
.sp
)
639 used
= (char *) old_stack
- (char *) __morestack_initial_sp
.sp
;
642 if (used
> __morestack_initial_sp
.len
)
645 *pavailable
= __morestack_initial_sp
.len
- used
;
651 /* Block signals while splitting the stack. This avoids trouble if we
652 try to invoke a signal handler which itself wants to split the
655 extern int pthread_sigmask (int, const sigset_t
*, sigset_t
*)
656 __attribute__ ((weak
));
659 __morestack_block_signals (void)
661 if (__morestack_initial_sp
.dont_block_signals
)
663 else if (pthread_sigmask
)
664 pthread_sigmask (SIG_BLOCK
, &__morestack_fullmask
,
665 &__morestack_initial_sp
.mask
);
667 sigprocmask (SIG_BLOCK
, &__morestack_fullmask
,
668 &__morestack_initial_sp
.mask
);
671 /* Unblock signals while splitting the stack. */
674 __morestack_unblock_signals (void)
676 if (__morestack_initial_sp
.dont_block_signals
)
678 else if (pthread_sigmask
)
679 pthread_sigmask (SIG_SETMASK
, &__morestack_initial_sp
.mask
, NULL
);
681 sigprocmask (SIG_SETMASK
, &__morestack_initial_sp
.mask
, NULL
);
684 /* This function is called to allocate dynamic stack space, for alloca
685 or a variably sized array. This is a regular function with
686 sufficient stack space, so we just use malloc to allocate the
687 space. We attach the allocated blocks to the current stack
688 segment, so that they will eventually be reused or freed. */
691 __morestack_allocate_stack_space (size_t size
)
693 struct stack_segment
*seg
, *current
;
694 struct dynamic_allocation_blocks
*p
;
696 /* We have to block signals to avoid getting confused if we get
697 interrupted by a signal whose handler itself uses alloca or a
698 variably sized array. */
699 __morestack_block_signals ();
701 /* Since we don't want to call free while we are low on stack space,
702 we may have a list of already allocated blocks waiting to be
703 freed. Release them all, unless we find one that is large
704 enough. We don't look at every block to see if one is large
705 enough, just the first one, because we aren't trying to build a
706 memory allocator here, we're just trying to speed up common
709 current
= __morestack_current_segment
;
711 for (seg
= __morestack_segments
; seg
!= NULL
; seg
= seg
->next
)
713 p
= seg
->free_dynamic_allocation
;
718 seg
->free_dynamic_allocation
= p
->next
;
722 free_dynamic_blocks (p
);
723 seg
->free_dynamic_allocation
= NULL
;
730 /* We need to allocate additional memory. */
731 p
= malloc (sizeof (*p
));
735 p
->block
= malloc (size
);
736 if (p
->block
== NULL
)
740 /* If we are still on the initial stack, then we have a space leak.
744 p
->next
= current
->dynamic_allocation
;
745 current
->dynamic_allocation
= p
;
748 __morestack_unblock_signals ();
753 /* Find the stack segment for STACK and return the amount of space
754 available. This is used when unwinding the stack because of an
755 exception, in order to reset the stack guard correctly. */
758 __generic_findstack (void *stack
)
760 struct stack_segment
*pss
;
763 for (pss
= __morestack_current_segment
; pss
!= NULL
; pss
= pss
->prev
)
765 if ((char *) pss
< (char *) stack
766 && (char *) pss
+ pss
->size
> (char *) stack
)
768 __morestack_current_segment
= pss
;
769 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
770 return (char *) stack
- (char *) (pss
+ 1);
772 return (char *) (pss
+ 1) + pss
->size
- (char *) stack
;
777 /* We have popped back to the original stack. */
779 if (__morestack_initial_sp
.sp
== NULL
)
782 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
783 if ((char *) stack
>= (char *) __morestack_initial_sp
.sp
)
786 used
= (char *) __morestack_initial_sp
.sp
- (char *) stack
;
788 if ((char *) stack
<= (char *) __morestack_initial_sp
.sp
)
791 used
= (char *) stack
- (char *) __morestack_initial_sp
.sp
;
794 if (used
> __morestack_initial_sp
.len
)
797 return __morestack_initial_sp
.len
- used
;
800 /* This function is called at program startup time to make sure that
801 mmap, munmap, and getpagesize are resolved if linking dynamically.
802 We want to resolve them while we have enough stack for them, rather
803 than calling into the dynamic linker while low on stack space.
804 Similarly, invoke getenv here to check for split-stack related control
805 variables, since doing do as part of the __morestack path can result
806 in unwanted use of SSE/AVX registers (see GCC PR 86213). */
809 __morestack_load_mmap (void)
811 /* Call with bogus values to run faster. We don't care if the call
812 fails. Pass __MORESTACK_CURRENT_SEGMENT to make sure that any
813 TLS accessor function is resolved. */
814 mmap (__morestack_current_segment
, 0, PROT_READ
, MAP_ANONYMOUS
, -1, 0);
815 mprotect (NULL
, 0, 0);
816 munmap (0, static_pagesize
);
818 /* Initialize these values here, so as to avoid dynamic linker
819 activity as part of a __morestack call. */
820 static_pagesize
= getpagesize();
821 use_guard_page
= getenv ("SPLIT_STACK_GUARD") != 0;
824 /* This function may be used to iterate over the stack segments.
825 This can be called like this.
826 void *next_segment = NULL;
827 void *next_sp = NULL;
828 void *initial_sp = NULL;
831 while ((stack = __splitstack_find (next_segment, next_sp, &stack_size,
832 &next_segment, &next_sp,
833 &initial_sp)) != NULL)
835 // Stack segment starts at stack and is stack_size bytes long.
838 There is no way to iterate over the stack segments of a different
839 thread. However, what is permitted is for one thread to call this
840 with the first two values NULL, to pass next_segment, next_sp, and
841 initial_sp to a different thread, and then to suspend one way or
842 another. A different thread may run the subsequent
843 __morestack_find iterations. Of course, this will only work if the
844 first thread is suspended during the __morestack_find iterations.
845 If not, the second thread will be looking at the stack while it is
846 changing, and anything could happen.
848 FIXME: This should be declared in some header file, but where? */
851 __splitstack_find (void *segment_arg
, void *sp
, size_t *len
,
852 void **next_segment
, void **next_sp
,
855 struct stack_segment
*segment
;
859 if (segment_arg
== (void *) (uintptr_type
) 1)
861 char *isp
= (char *) *initial_sp
;
866 *next_segment
= (void *) (uintptr_type
) 2;
868 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
869 if ((char *) sp
>= isp
)
871 *len
= (char *) isp
- (char *) sp
;
874 if ((char *) sp
<= (char *) isp
)
876 *len
= (char *) sp
- (char *) isp
;
880 else if (segment_arg
== (void *) (uintptr_type
) 2)
882 else if (segment_arg
!= NULL
)
883 segment
= (struct stack_segment
*) segment_arg
;
886 *initial_sp
= __morestack_initial_sp
.sp
;
887 segment
= __morestack_current_segment
;
888 sp
= (void *) &segment
;
892 return __splitstack_find ((void *) (uintptr_type
) 1, sp
, len
,
893 next_segment
, next_sp
, initial_sp
);
894 if ((char *) sp
>= (char *) (segment
+ 1)
895 && (char *) sp
<= (char *) (segment
+ 1) + segment
->size
)
897 segment
= segment
->prev
;
901 if (segment
->prev
== NULL
)
902 *next_segment
= (void *) (uintptr_type
) 1;
904 *next_segment
= segment
->prev
;
906 /* The old_stack value is the address of the function parameters of
907 the function which called __morestack. So if f1 called f2 which
908 called __morestack, the stack looks like this:
910 parameters <- old_stack
913 registers pushed by __morestack
915 The registers pushed by __morestack may not be visible on any
916 other stack, if we are being called by a signal handler
917 immediately after the call to __morestack_unblock_signals. We
918 want to adjust our return value to include those registers. This
919 is target dependent. */
921 nsp
= (char *) segment
->old_stack
;
925 /* We've reached the top of the stack. */
926 *next_segment
= (void *) (uintptr_type
) 2;
930 #if defined (__x86_64__)
931 nsp
-= 12 * sizeof (void *);
932 #elif defined (__i386__)
933 nsp
-= 6 * sizeof (void *);
934 #elif defined __powerpc64__
935 #elif defined __s390x__
937 #elif defined __s390__
940 #error "unrecognized target"
943 *next_sp
= (void *) nsp
;
946 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
947 *len
= (char *) (segment
+ 1) + segment
->size
- (char *) sp
;
950 *len
= (char *) sp
- (char *) (segment
+ 1);
951 ret
= (void *) (segment
+ 1);
957 /* Tell the split stack code whether it has to block signals while
958 manipulating the stack. This is for programs in which some threads
959 block all signals. If a thread already blocks signals, there is no
960 need for the split stack code to block them as well. If NEW is not
961 NULL, then if *NEW is non-zero signals will be blocked while
962 splitting the stack, otherwise they will not. If OLD is not NULL,
963 *OLD will be set to the old value. */
966 __splitstack_block_signals (int *new, int *old
)
969 *old
= __morestack_initial_sp
.dont_block_signals
? 0 : 1;
971 __morestack_initial_sp
.dont_block_signals
= *new ? 0 : 1;
974 /* The offsets into the arrays used by __splitstack_getcontext and
975 __splitstack_setcontext. */
977 enum __splitstack_context_offsets
979 MORESTACK_SEGMENTS
= 0,
990 /* Get the current split stack context. This may be used for
991 coroutine switching, similar to getcontext. The argument should
992 have at least 10 void *pointers for extensibility, although we
993 don't currently use all of them. This would normally be called
994 immediately before a call to getcontext or swapcontext or
998 __splitstack_getcontext (void *context
[NUMBER_OFFSETS
])
1000 memset (context
, 0, NUMBER_OFFSETS
* sizeof (void *));
1001 context
[MORESTACK_SEGMENTS
] = (void *) __morestack_segments
;
1002 context
[CURRENT_SEGMENT
] = (void *) __morestack_current_segment
;
1003 context
[CURRENT_STACK
] = (void *) &context
;
1004 context
[STACK_GUARD
] = __morestack_get_guard ();
1005 context
[INITIAL_SP
] = (void *) __morestack_initial_sp
.sp
;
1006 context
[INITIAL_SP_LEN
] = (void *) (uintptr_type
) __morestack_initial_sp
.len
;
1007 context
[BLOCK_SIGNALS
] = (void *) __morestack_initial_sp
.dont_block_signals
;
1010 /* Set the current split stack context. The argument should be a
1011 context previously passed to __splitstack_getcontext. This would
1012 normally be called immediately after a call to getcontext or
1013 swapcontext or setjmp if something jumped to it. */
1016 __splitstack_setcontext (void *context
[NUMBER_OFFSETS
])
1018 __morestack_segments
= (struct stack_segment
*) context
[MORESTACK_SEGMENTS
];
1019 __morestack_current_segment
=
1020 (struct stack_segment
*) context
[CURRENT_SEGMENT
];
1021 __morestack_set_guard (context
[STACK_GUARD
]);
1022 __morestack_initial_sp
.sp
= context
[INITIAL_SP
];
1023 __morestack_initial_sp
.len
= (size_t) context
[INITIAL_SP_LEN
];
1024 __morestack_initial_sp
.dont_block_signals
=
1025 (uintptr_type
) context
[BLOCK_SIGNALS
];
1028 /* Create a new split stack context. This will allocate a new stack
1029 segment which may be used by a coroutine. STACK_SIZE is the
1030 minimum size of the new stack. The caller is responsible for
1031 actually setting the stack pointer. This would normally be called
1032 before a call to makecontext, and the returned stack pointer and
1033 size would be used to set the uc_stack field. A function called
1034 via makecontext on a stack created by __splitstack_makecontext may
1035 not return. Note that the returned pointer points to the lowest
1036 address in the stack space, and thus may not be the value to which
1037 to set the stack pointer. */
1040 __splitstack_makecontext (size_t stack_size
, void *context
[NUMBER_OFFSETS
],
1043 struct stack_segment
*segment
;
1046 memset (context
, 0, NUMBER_OFFSETS
* sizeof (void *));
1047 segment
= allocate_segment (stack_size
);
1048 context
[MORESTACK_SEGMENTS
] = segment
;
1049 context
[CURRENT_SEGMENT
] = segment
;
1050 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
1051 initial_sp
= (void *) ((char *) (segment
+ 1) + segment
->size
);
1053 initial_sp
= (void *) (segment
+ 1);
1055 context
[STACK_GUARD
] = __morestack_make_guard (initial_sp
, segment
->size
);
1056 context
[INITIAL_SP
] = NULL
;
1057 context
[INITIAL_SP_LEN
] = 0;
1058 *size
= segment
->size
;
1059 return (void *) (segment
+ 1);
1062 /* Given an existing split stack context, reset it back to the start
1063 of the stack. Return the stack pointer and size, appropriate for
1064 use with makecontext. This may be used if a coroutine exits, in
1065 order to reuse the stack segments for a new coroutine. */
1068 __splitstack_resetcontext (void *context
[10], size_t *size
)
1070 struct stack_segment
*segment
;
1072 size_t initial_size
;
1075 /* Reset the context assuming that MORESTACK_SEGMENTS, INITIAL_SP
1076 and INITIAL_SP_LEN are correct. */
1078 segment
= context
[MORESTACK_SEGMENTS
];
1079 context
[CURRENT_SEGMENT
] = segment
;
1080 context
[CURRENT_STACK
] = NULL
;
1081 if (segment
== NULL
)
1083 initial_sp
= context
[INITIAL_SP
];
1084 initial_size
= (uintptr_type
) context
[INITIAL_SP_LEN
];
1086 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
1087 ret
= (void *) ((char *) ret
- initial_size
);
1092 #ifdef __LIBGCC_STACK_GROWS_DOWNWARD__
1093 initial_sp
= (void *) ((char *) (segment
+ 1) + segment
->size
);
1095 initial_sp
= (void *) (segment
+ 1);
1097 initial_size
= segment
->size
;
1098 ret
= (void *) (segment
+ 1);
1100 context
[STACK_GUARD
] = __morestack_make_guard (initial_sp
, initial_size
);
1101 context
[BLOCK_SIGNALS
] = NULL
;
1102 *size
= initial_size
;
1106 /* Release all the memory associated with a splitstack context. This
1107 may be used if a coroutine exits and the associated stack should be
1111 __splitstack_releasecontext (void *context
[10])
1113 __morestack_release_segments (((struct stack_segment
**)
1114 &context
[MORESTACK_SEGMENTS
]),
1118 /* Like __splitstack_block_signals, but operating on CONTEXT, rather
1119 than on the current state. */
1122 __splitstack_block_signals_context (void *context
[NUMBER_OFFSETS
], int *new,
1126 *old
= ((uintptr_type
) context
[BLOCK_SIGNALS
]) != 0 ? 0 : 1;
1128 context
[BLOCK_SIGNALS
] = (void *) (uintptr_type
) (*new ? 0 : 1);
1131 /* Find the stack segments associated with a split stack context.
1132 This will return the address of the first stack segment and set
1133 *STACK_SIZE to its size. It will set next_segment, next_sp, and
1134 initial_sp which may be passed to __splitstack_find to find the
1135 remaining segments. */
1138 __splitstack_find_context (void *context
[NUMBER_OFFSETS
], size_t *stack_size
,
1139 void **next_segment
, void **next_sp
,
1143 struct stack_segment
*segment
;
1145 *initial_sp
= context
[INITIAL_SP
];
1147 sp
= context
[CURRENT_STACK
];
1150 /* Most likely this context was created but was never used. The
1151 value 2 is a code used by __splitstack_find to mean that we
1152 have reached the end of the list of stacks. */
1153 *next_segment
= (void *) (uintptr_type
) 2;
1159 segment
= context
[CURRENT_SEGMENT
];
1160 if (segment
== NULL
)
1162 /* Most likely this context was saved by a thread which was not
1163 created using __splistack_makecontext and which has never
1164 split the stack. The value 1 is a code used by
1165 __splitstack_find to look at the initial stack. */
1166 segment
= (struct stack_segment
*) (uintptr_type
) 1;
1169 return __splitstack_find (segment
, sp
, stack_size
, next_segment
, next_sp
,
1173 #endif /* !defined (inhibit_libc) */
1174 #endif /* not powerpc 32-bit */