OSDN Git Service

* config/i386/morestack.S (__morestack_non_split): If there is
[pf3gnuchains/gcc-fork.git] / libgcc / config / i386 / morestack.S
1 # x86/x86_64 support for -fsplit-stack.
2 # Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
3 # Contributed by Ian Lance Taylor <iant@google.com>.
4
5 # This file is part of GCC.
6
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
10 # version.
11
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
15 # for more details.
16
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.
20
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/>.
25
26
27 # Support for allocating more stack space when using -fsplit-stack.
28 # When a function discovers that it needs more stack space, it will
29 # call __morestack with the size of the stack frame and the size of
30 # the parameters to copy from the old stack frame to the new one.
31 # The __morestack function preserves the parameter registers and
32 # calls __generic_morestack to actually allocate the stack space.
33
34 # When this is called stack space is very low, but we ensure that
35 # there is enough space to push the parameter registers and to call
36 # __generic_morestack.
37
38 # When calling __generic_morestack, FRAME_SIZE points to the size of
39 # the desired frame when the function is called, and the function
40 # sets it to the size of the allocated stack.  OLD_STACK points to
41 # the parameters on the old stack and PARAM_SIZE is the number of
42 # bytes of parameters to copy to the new stack.  These are the
43 # parameters of the function that called __morestack.  The
44 # __generic_morestack function returns the new stack pointer,
45 # pointing to the address of the first copied parameter.  The return
46 # value minus the returned *FRAME_SIZE will be the first address on
47 # the stack which we should not use.
48
49 # void *__generic_morestack (size_t *frame_size, void *old_stack,
50 #                            size_t param_size);
51
52 # The __morestack routine has to arrange for the caller to return to a
53 # stub on the new stack.  The stub is responsible for restoring the
54 # old stack pointer and returning to the caller's caller.  This calls
55 # __generic_releasestack to retrieve the old stack pointer and release
56 # the newly allocated stack.
57
58 # void *__generic_releasestack (size_t *available);
59
60 # We do a little dance so that the processor's call/return return
61 # address prediction works out.  The compiler arranges for the caller
62 # to look like this:
63 #   call __generic_morestack
64 #   ret
65 #  L:
66 #   // carry on with function
67 # After we allocate more stack, we call L, which is in our caller.
68 # When that returns (to the predicted instruction), we release the
69 # stack segment and reset the stack pointer.  We then return to the
70 # predicted instruction, namely the ret instruction immediately after
71 # the call to __generic_morestack.  That then returns to the caller of
72 # the original caller.
73
74
75 # The amount of extra space we ask for.  In general this has to be
76 # enough for the dynamic loader to find a symbol and for a signal
77 # handler to run.
78         
79 #ifndef __x86_64__
80 #define BACKOFF (1024)
81 #else
82 #define BACKOFF (1536)
83 #endif
84
85
86 # This entry point is for split-stack code which calls non-split-stack
87 # code.  When the linker sees this case, it converts the call to
88 # __morestack to call __morestack_non_split instead.  We just bump the
89 # requested stack space by 16K.
90
91         .global __morestack_non_split
92         .hidden __morestack_non_split
93
94 #ifdef __ELF__
95        .type    __morestack_non_split,@function
96 #endif
97
98 __morestack_non_split:
99         .cfi_startproc
100
101 #ifndef __x86_64__
102
103         # See below for an extended explanation of the CFI instructions.
104         .cfi_offset 8, 8                # New PC stored at CFA + 8
105         .cfi_escape 0x15, 4, 0x7d       # DW_CFA_val_offset_sf, %esp, 12/-4
106                                         # i.e., next %esp is CFA + 12
107
108         pushl   %eax                    # Save %eax in case it is a parameter.
109
110         .cfi_def_cfa %esp,8             # Account for pushed register.
111
112         movl    %esp,%eax               # Current stack,
113         subl    8(%esp),%eax            # less required stack frame size,
114         subl    $0x4000,%eax            # less space for non-split code.
115         cmpl    %gs:0x30,%eax           # See if we have enough space.
116         jb      2f                      # Get more space if we need it.
117
118         # Here the stack is
119         #       %esp + 20:      stack pointer after two returns
120         #       %esp + 16:      return address of morestack caller's caller
121         #       %esp + 12:      size of parameters
122         #       %esp + 8:       new stack frame size
123         #       %esp + 4:       return address of this function
124         #       %esp:           saved %eax
125         #
126         # Since we aren't doing a full split stack, we don't need to
127         # do anything when our caller returns.  So we return to our
128         # caller rather than calling it, and let it return as usual.
129         # To make that work we adjust the return address.
130
131         # This breaks call/return address prediction for the call to
132         # this function.  I can't figure out a way to make it work
133         # short of copying the parameters down the stack, which will
134         # probably take more clock cycles than we will lose breaking
135         # call/return address prediction.  We will only break
136         # prediction for this call, not for our caller.
137
138         movl    4(%esp),%eax            # Increment the return address
139         cmpb    $0xc3,(%eax)            # to skip the ret instruction;
140         je      1f                      # see above.
141         addl    $2,%eax
142 1:      inc     %eax
143         movl    %eax,4(%esp)            # Update return address.
144
145         popl    %eax                    # Restore %eax and stack.
146
147         .cfi_def_cfa %esp,4             # Account for popped register.
148
149         ret     $8                      # Return to caller, popping args.
150
151 2:
152         .cfi_def_cfa %esp,8             # Back to where we were.
153
154         popl    %eax                    # Restore %eax and stack.
155
156         .cfi_def_cfa %esp,4             # Account for popped register.
157
158         addl    $0x5000+BACKOFF,4(%esp) # Increment space we request.
159
160         # Fall through into morestack.
161
162 #else
163
164         # See below for an extended explanation of the CFI instructions.
165         .cfi_offset 16, 0
166         .cfi_escape 0x15, 7, 0x7f       # DW_CFA_val_offset_sf, %esp, 8/-8
167
168         pushq   %rax                    # Save %rax in case caller is using
169                                         # it to preserve original %r10.
170         .cfi_def_cfa %rsp,16            # Adjust for pushed register.
171
172         movq    %rsp,%rax               # Current stack,
173         subq    %r10,%rax               # less required stack frame size,
174         subq    $0x4000,%rax            # less space for non-split code.
175
176 #ifdef __LP64__
177         cmpq    %fs:0x70,%rax           # See if we have enough space.
178 #else
179         cmpl    %fs:0x40,%eax
180 #endif
181         jb      2f                      # Get more space if we need it.
182
183         # This breaks call/return prediction, as described above.
184         incq    8(%rsp)                 # Increment the return address.
185
186         popq    %rax                    # Restore register.
187
188         .cfi_def_cfa %rsp,8             # Adjust for popped register.
189
190         ret                             # Return to caller.
191
192 2:
193         .cfi_def_cfa %rsp,16            # Back to where we were.
194
195         popq    %rax                    # Restore register.
196
197         .cfi_def_cfa %rsp,8             # Adjust for popped register.
198
199         addq    $0x5000+BACKOFF,%r10    # Increment space we request.
200
201         # Fall throug into morestack.
202
203 #endif
204
205         .cfi_endproc
206 #ifdef __ELF__
207         .size   __morestack_non_split, . - __morestack_non_split
208 #endif
209
210 # __morestack_non_split falls through into __morestack.
211
212
213 # The __morestack function.
214
215         .global __morestack
216         .hidden __morestack
217
218 #ifdef __ELF__
219         .type   __morestack,@function
220 #endif
221
222 __morestack:
223 .LFB1:
224         .cfi_startproc
225
226
227 #ifndef __x86_64__
228
229
230 # The 32-bit __morestack function.
231
232         # We use a cleanup to restore the stack guard if an exception
233         # is thrown through this code.
234 #ifndef __PIC__
235         .cfi_personality 0,__gcc_personality_v0
236         .cfi_lsda 0,.LLSDA1
237 #else
238         .cfi_personality 0x9b,DW.ref.__gcc_personality_v0
239         .cfi_lsda 0x1b,.LLSDA1
240 #endif
241
242         # We return below with a ret $8.  We will return to a single
243         # return instruction, which will return to the caller of our
244         # caller.  We let the unwinder skip that single return
245         # instruction, and just return to the real caller.
246
247         # Here CFA points just past the return address on the stack,
248         # e.g., on function entry it is %esp + 4.  Later we will
249         # change it to %ebp + 8, as set by .cfi_def_cfa_register and
250         # .cfi_def_cfa_offset above.  The stack looks like this:
251         #       CFA + 12:       stack pointer after two returns
252         #       CFA + 8:        return address of morestack caller's caller
253         #       CFA + 4:        size of parameters
254         #       CFA:            new stack frame size
255         #       CFA - 4:        return address of this function
256         #       CFA - 8:        previous value of %ebp; %ebp points here
257         # We want to set %esp to the stack pointer after the double
258         # return, which is CFA + 12.
259         .cfi_offset 8, 8                # New PC stored at CFA + 8
260         .cfi_escape 0x15, 4, 0x7d       # DW_CFA_val_offset_sf, %esp, 12/-4
261                                         # i.e., next %esp is CFA + 12
262
263         # Set up a normal backtrace.
264         pushl   %ebp
265         .cfi_def_cfa_offset 8
266         .cfi_offset %ebp, -8
267         movl    %esp,%ebp
268         .cfi_def_cfa_register %ebp
269
270         # In 32-bit mode the parameters are pushed on the stack.  The
271         # argument size is pushed then the new stack frame size is
272         # pushed.
273
274         # Align stack to 16-byte boundary with enough space for saving
275         # registers and passing parameters to functions we call.
276         subl    $40,%esp
277
278         # Because our cleanup code may need to clobber %ebx, we need
279         # to save it here so the unwinder can restore the value used
280         # by the caller.  Note that we don't have to restore the
281         # register, since we don't change it, we just have to save it
282         # for the unwinder.
283         movl    %ebx,-4(%ebp)
284         .cfi_offset %ebx, -12
285
286         # In 32-bit mode the registers %eax, %edx, and %ecx may be
287         # used for parameters, depending on the regparm and fastcall
288         # attributes.
289
290         movl    %eax,-8(%ebp)
291         movl    %edx,-12(%ebp)
292         movl    %ecx,-16(%ebp)
293
294         call    __morestack_block_signals
295
296         movl    12(%ebp),%eax           # The size of the parameters.
297         movl    %eax,8(%esp)
298         leal    20(%ebp),%eax           # Address of caller's parameters.
299         movl    %eax,4(%esp)
300         addl    $BACKOFF,8(%ebp)        # Ask for backoff bytes.
301         leal    8(%ebp),%eax            # The address of the new frame size.
302         movl    %eax,(%esp)
303
304         call    __generic_morestack
305
306         movl    %eax,%esp               # Switch to the new stack.
307         subl    8(%ebp),%eax            # The end of the stack space.
308         addl    $BACKOFF,%eax           # Back off 512 bytes.
309
310 .LEHB0:
311         # FIXME: The offset must match
312         # TARGET_THREAD_SPLIT_STACK_OFFSET in
313         # gcc/config/i386/linux.h.
314         movl    %eax,%gs:0x30           # Save the new stack boundary.
315
316         call    __morestack_unblock_signals
317
318         movl    -12(%ebp),%edx          # Restore registers.
319         movl    -16(%ebp),%ecx
320
321         movl    4(%ebp),%eax            # Increment the return address
322         cmpb    $0xc3,(%eax)            # to skip the ret instruction;
323         je      1f                      # see above.
324         addl    $2,%eax
325 1:      inc     %eax
326
327         movl    %eax,-12(%ebp)          # Store return address in an
328                                         # unused slot.
329
330         movl    -8(%ebp),%eax           # Restore the last register.
331
332         call    *-12(%ebp)              # Call our caller!
333
334         # The caller will return here, as predicted.
335
336         # Save the registers which may hold a return value.  We
337         # assume that __generic_releasestack does not touch any
338         # floating point or vector registers.
339         pushl   %eax
340         pushl   %edx
341
342         # Push the arguments to __generic_releasestack now so that the
343         # stack is at a 16-byte boundary for
344         # __morestack_block_signals.
345         pushl   $0                      # Where the available space is returned.
346         leal    0(%esp),%eax            # Push its address.
347         push    %eax
348
349         call    __morestack_block_signals
350
351         call    __generic_releasestack
352
353         subl    4(%esp),%eax            # Subtract available space.
354         addl    $BACKOFF,%eax           # Back off 512 bytes.
355 .LEHE0:
356         movl    %eax,%gs:0x30           # Save the new stack boundary.
357
358         addl    $8,%esp                 # Remove values from stack.
359
360         # We need to restore the old stack pointer, which is in %rbp,
361         # before we unblock signals.  We also need to restore %eax and
362         # %edx after we unblock signals but before we return.  Do this
363         # by moving %eax and %edx from the current stack to the old
364         # stack.
365
366         popl    %edx                    # Pop return value from current stack.
367         popl    %eax
368
369         movl    %ebp,%esp               # Restore stack pointer.
370
371         pushl   %eax                    # Push return value on old stack.
372         pushl   %edx
373         subl    $8,%esp                 # Align stack to 16-byte boundary.
374
375         call    __morestack_unblock_signals
376
377         addl    $8,%esp
378         popl    %edx                    # Restore return value.
379         popl    %eax
380
381         .cfi_remember_state
382
383         # We never changed %ebx, so we don't have to actually restore it.
384         .cfi_restore %ebx
385
386         popl    %ebp
387         .cfi_restore %ebp
388         .cfi_def_cfa %esp, 4
389         ret     $8                      # Return to caller, which will
390                                         # immediately return.  Pop
391                                         # arguments as we go.
392
393 # This is the cleanup code called by the stack unwinder when unwinding
394 # through the code between .LEHB0 and .LEHE0 above.
395         
396 .L1:
397         .cfi_restore_state
398         subl    $16,%esp                # Maintain 16 byte alignment.
399         movl    %eax,4(%esp)            # Save exception header.
400         movl    %ebp,(%esp)             # Stack pointer after resume.
401         call    __generic_findstack
402         movl    %ebp,%ecx               # Get the stack pointer.
403         subl    %eax,%ecx               # Subtract available space.
404         addl    $BACKOFF,%ecx           # Back off 512 bytes.
405         movl    %ecx,%gs:0x30           # Save new stack boundary.
406         movl    4(%esp),%eax            # Function argument.
407         movl    %eax,(%esp)
408 #ifdef __PIC__
409         call    __x86.get_pc_thunk.bx   # %ebx may not be set up for us.
410         addl    $_GLOBAL_OFFSET_TABLE_, %ebx
411         call    _Unwind_Resume@PLT      # Resume unwinding.
412 #else
413         call    _Unwind_Resume
414 #endif
415
416 #else /* defined(__x86_64__) */
417
418
419 # The 64-bit __morestack function.
420
421         # We use a cleanup to restore the stack guard if an exception
422         # is thrown through this code.
423 #ifndef __PIC__
424         .cfi_personality 0x3,__gcc_personality_v0
425         .cfi_lsda 0x3,.LLSDA1
426 #else
427         .cfi_personality 0x9b,DW.ref.__gcc_personality_v0
428         .cfi_lsda 0x1b,.LLSDA1
429 #endif
430
431         # We will return a single return instruction, which will
432         # return to the caller of our caller.  Let the unwinder skip
433         # that single return instruction, and just return to the real
434         # caller.
435         .cfi_offset 16, 0
436         .cfi_escape 0x15, 7, 0x7f       # DW_CFA_val_offset_sf, %esp, 8/-8
437
438         # Set up a normal backtrace.
439         pushq   %rbp
440         .cfi_def_cfa_offset 16
441         .cfi_offset %rbp, -16
442         movq    %rsp, %rbp
443         .cfi_def_cfa_register %rbp
444
445         # In 64-bit mode the new stack frame size is passed in r10
446         # and the argument size is passed in r11.
447
448         addq    $BACKOFF,%r10           # Ask for backoff bytes.
449         pushq   %r10                    # Save new frame size.
450
451         # In 64-bit mode the registers %rdi, %rsi, %rdx, %rcx, %r8,
452         # and %r9 may be used for parameters.  We also preserve %rax
453         # which the caller may use to hold %r10.
454
455         pushq   %rax
456         pushq   %rdi
457         pushq   %rsi
458         pushq   %rdx
459         pushq   %rcx
460         pushq   %r8
461         pushq   %r9
462
463         pushq   %r11
464         pushq   $0                      # For alignment.
465
466         call    __morestack_block_signals
467
468         leaq    -8(%rbp),%rdi           # Address of new frame size.
469         leaq    24(%rbp),%rsi           # The caller's parameters.
470         addq    $8,%rsp
471         popq    %rdx                    # The size of the parameters.
472
473         call    __generic_morestack
474
475         movq    -8(%rbp),%r10           # Reload modified frame size
476         movq    %rax,%rsp               # Switch to the new stack.
477         subq    %r10,%rax               # The end of the stack space.
478         addq    $BACKOFF,%rax           # Back off 1024 bytes.
479
480 .LEHB0:
481         # FIXME: The offset must match
482         # TARGET_THREAD_SPLIT_STACK_OFFSET in
483         # gcc/config/i386/linux64.h.
484         # Macro to save the new stack boundary.
485 #ifdef __LP64__
486 #define X86_64_SAVE_NEW_STACK_BOUNDARY(reg)     movq    %r##reg,%fs:0x70
487 #else
488 #define X86_64_SAVE_NEW_STACK_BOUNDARY(reg)     movl    %e##reg,%fs:0x40
489 #endif
490         X86_64_SAVE_NEW_STACK_BOUNDARY (ax)
491
492         call    __morestack_unblock_signals
493
494         movq    -24(%rbp),%rdi          # Restore registers.
495         movq    -32(%rbp),%rsi
496         movq    -40(%rbp),%rdx
497         movq    -48(%rbp),%rcx
498         movq    -56(%rbp),%r8
499         movq    -64(%rbp),%r9
500
501         movq    8(%rbp),%r10            # Increment the return address
502         incq    %r10                    # to skip the ret instruction;
503                                         # see above.
504
505         movq    -16(%rbp),%rax          # Restore caller's %rax.
506
507         call    *%r10                   # Call our caller!
508
509         # The caller will return here, as predicted.
510
511         # Save the registers which may hold a return value.  We
512         # assume that __generic_releasestack does not touch any
513         # floating point or vector registers.
514         pushq   %rax
515         pushq   %rdx
516
517         call    __morestack_block_signals
518
519         pushq   $0                      # For alignment.
520         pushq   $0                      # Where the available space is returned.
521         leaq    0(%rsp),%rdi            # Pass its address.
522
523         call    __generic_releasestack
524
525         subq    0(%rsp),%rax            # Subtract available space.
526         addq    $BACKOFF,%rax           # Back off 1024 bytes.
527 .LEHE0:
528         X86_64_SAVE_NEW_STACK_BOUNDARY (ax)
529
530         addq    $16,%rsp                # Remove values from stack.
531
532         # We need to restore the old stack pointer, which is in %rbp,
533         # before we unblock signals.  We also need to restore %rax and
534         # %rdx after we unblock signals but before we return.  Do this
535         # by moving %rax and %rdx from the current stack to the old
536         # stack.
537
538         popq    %rdx                    # Pop return value from current stack.
539         popq    %rax
540
541         movq    %rbp,%rsp               # Restore stack pointer.
542
543         pushq   %rax                    # Push return value on old stack.
544         pushq   %rdx
545
546         call    __morestack_unblock_signals
547
548         popq    %rdx                    # Restore return value.
549         popq    %rax
550
551         .cfi_remember_state
552         popq    %rbp
553         .cfi_restore %rbp
554         .cfi_def_cfa %rsp, 8
555         ret                             # Return to caller, which will
556                                         # immediately return.
557
558 # This is the cleanup code called by the stack unwinder when unwinding
559 # through the code between .LEHB0 and .LEHE0 above.
560         
561 .L1:
562         .cfi_restore_state
563         subq    $16,%rsp                # Maintain 16 byte alignment.
564         movq    %rax,(%rsp)             # Save exception header.
565         movq    %rbp,%rdi               # Stack pointer after resume.
566         call    __generic_findstack
567         movq    %rbp,%rcx               # Get the stack pointer.
568         subq    %rax,%rcx               # Subtract available space.
569         addq    $BACKOFF,%rcx           # Back off 1024 bytes.
570         X86_64_SAVE_NEW_STACK_BOUNDARY (cx)
571         movq    (%rsp),%rdi             # Restore exception data for call.
572 #ifdef __PIC__
573         call    _Unwind_Resume@PLT      # Resume unwinding.
574 #else
575         call    _Unwind_Resume          # Resume unwinding.
576 #endif
577
578 #endif /* defined(__x86_64__) */
579
580         .cfi_endproc
581 #ifdef __ELF__
582         .size   __morestack, . - __morestack
583 #endif
584
585 #if !defined(__x86_64__) && defined(__PIC__)
586 # Output the thunk to get PC into bx, since we use it above.
587         .section        .text.__x86.get_pc_thunk.bx,"axG",@progbits,__x86.get_pc_thunk.bx,comdat
588         .globl  __x86.get_pc_thunk.bx
589         .hidden __x86.get_pc_thunk.bx
590 #ifdef __ELF__
591         .type   __x86.get_pc_thunk.bx, @function
592 #endif
593 __x86.get_pc_thunk.bx:
594         .cfi_startproc
595         movl    (%esp), %ebx
596         ret
597         .cfi_endproc
598 #ifdef __ELF__
599         .size   __x86.get_pc_thunk.bx, . - __x86.get_pc_thunk.bx
600 #endif
601 #endif
602
603 # The exception table.  This tells the personality routine to execute
604 # the exception handler.
605
606         .section        .gcc_except_table,"a",@progbits
607         .align  4
608 .LLSDA1:
609         .byte   0xff    # @LPStart format (omit)
610         .byte   0xff    # @TType format (omit)
611         .byte   0x1     # call-site format (uleb128)
612         .uleb128 .LLSDACSE1-.LLSDACSB1  # Call-site table length
613 .LLSDACSB1:
614         .uleb128 .LEHB0-.LFB1   # region 0 start
615         .uleb128 .LEHE0-.LEHB0  # length
616         .uleb128 .L1-.LFB1      # landing pad
617         .uleb128 0              # action
618 .LLSDACSE1:
619
620
621         .global __gcc_personality_v0
622 #ifdef __PIC__
623         # Build a position independent reference to the basic
624         # personality function.
625         .hidden DW.ref.__gcc_personality_v0
626         .weak   DW.ref.__gcc_personality_v0
627         .section .data.DW.ref.__gcc_personality_v0,"awG",@progbits,DW.ref.__gcc_personality_v0,comdat
628         .type   DW.ref.__gcc_personality_v0, @object
629 DW.ref.__gcc_personality_v0:
630 #ifndef __LP64__
631         .align 4
632         .size   DW.ref.__gcc_personality_v0, 4
633         .long   __gcc_personality_v0
634 #else
635         .align 8
636         .size   DW.ref.__gcc_personality_v0, 8
637         .quad   __gcc_personality_v0
638 #endif
639 #endif
640
641 #if defined __x86_64__ && defined __LP64__
642
643 # This entry point is used for the large model.  With this entry point
644 # the upper 32 bits of %r10 hold the argument size and the lower 32
645 # bits hold the new stack frame size.  There doesn't seem to be a way
646 # to know in the assembler code that we are assembling for the large
647 # model, and there doesn't seem to be a large model multilib anyhow.
648 # If one is developed, then the non-PIC code is probably OK since we
649 # will probably be close to the morestack code, but the PIC code
650 # almost certainly needs to be changed.  FIXME.
651
652         .text
653         .global __morestack_large_model
654         .hidden __morestack_large_model
655
656 #ifdef __ELF__
657         .type   __morestack_large_model,@function
658 #endif
659
660 __morestack_large_model:
661
662         .cfi_startproc
663
664         movq    %r10, %r11
665         andl    $0xffffffff, %r10d
666         sarq    $32, %r11
667         jmp     __morestack
668
669         .cfi_endproc
670 #ifdef __ELF__
671        .size    __morestack_large_model, . - __morestack_large_model
672 #endif
673
674 #endif /* __x86_64__ && __LP64__ */
675
676 # Initialize the stack test value when the program starts or when a
677 # new thread starts.  We don't know how large the main stack is, so we
678 # guess conservatively.  We might be able to use getrlimit here.
679
680         .text
681         .global __stack_split_initialize
682         .hidden __stack_split_initialize
683
684 #ifdef __ELF__
685         .type   __stack_split_initialize, @function
686 #endif
687
688 __stack_split_initialize:
689
690 #ifndef __x86_64__
691
692         leal    -16000(%esp),%eax       # We should have at least 16K.
693         movl    %eax,%gs:0x30
694         pushl   $16000
695         pushl   %esp
696 #ifdef __PIC__
697         call    __generic_morestack_set_initial_sp@PLT
698 #else
699         call    __generic_morestack_set_initial_sp
700 #endif
701         addl    $8,%esp
702         ret
703
704 #else /* defined(__x86_64__) */
705
706         leaq    -16000(%rsp),%rax       # We should have at least 16K.
707         X86_64_SAVE_NEW_STACK_BOUNDARY (ax)
708         movq    %rsp,%rdi
709         movq    $16000,%rsi
710 #ifdef __PIC__
711         call    __generic_morestack_set_initial_sp@PLT
712 #else
713         call    __generic_morestack_set_initial_sp
714 #endif
715         ret
716
717 #endif /* defined(__x86_64__) */
718
719 #ifdef __ELF__
720         .size   __stack_split_initialize, . - __stack_split_initialize
721 #endif
722
723 # Routines to get and set the guard, for __splitstack_getcontext,
724 # __splitstack_setcontext, and __splitstack_makecontext.
725
726 # void *__morestack_get_guard (void) returns the current stack guard.
727         .text
728         .global __morestack_get_guard
729         .hidden __morestack_get_guard
730
731 #ifdef __ELF__
732         .type   __morestack_get_guard,@function
733 #endif
734
735 __morestack_get_guard:
736
737 #ifndef __x86_64__
738         movl    %gs:0x30,%eax
739 #else
740 #ifdef __LP64__
741         movq    %fs:0x70,%rax
742 #else
743         movl    %fs:0x40,%eax
744 #endif
745 #endif
746         ret
747
748 #ifdef __ELF__
749         .size   __morestack_get_guard, . - __morestack_get_guard
750 #endif
751
752 # void __morestack_set_guard (void *) sets the stack guard.
753         .global __morestack_set_guard
754         .hidden __morestack_set_guard
755
756 #ifdef __ELF__
757         .type   __morestack_set_guard,@function
758 #endif
759
760 __morestack_set_guard:
761
762 #ifndef __x86_64__
763         movl    4(%esp),%eax
764         movl    %eax,%gs:0x30
765 #else
766         X86_64_SAVE_NEW_STACK_BOUNDARY (di)
767 #endif
768         ret
769
770 #ifdef __ELF__
771         .size   __morestack_set_guard, . - __morestack_set_guard
772 #endif
773
774 # void *__morestack_make_guard (void *, size_t) returns the stack
775 # guard value for a stack.
776         .global __morestack_make_guard
777         .hidden __morestack_make_guard
778
779 #ifdef __ELF__
780         .type   __morestack_make_guard,@function
781 #endif
782
783 __morestack_make_guard:
784
785 #ifndef __x86_64__
786         movl    4(%esp),%eax
787         subl    8(%esp),%eax
788         addl    $BACKOFF,%eax
789 #else
790         subq    %rsi,%rdi
791         addq    $BACKOFF,%rdi
792         movq    %rdi,%rax
793 #endif
794         ret
795
796 #ifdef __ELF__
797         .size   __morestack_make_guard, . - __morestack_make_guard
798 #endif
799
800 # Make __stack_split_initialize a high priority constructor.  FIXME:
801 # This is ELF specific.
802
803         .section        .ctors.65535,"aw",@progbits
804
805 #ifndef __LP64__
806         .align  4
807         .long   __stack_split_initialize
808         .long   __morestack_load_mmap
809 #else
810         .align  8
811         .quad   __stack_split_initialize
812         .quad   __morestack_load_mmap
813 #endif
814
815 #ifdef __ELF__
816         .section        .note.GNU-stack,"",@progbits
817         .section        .note.GNU-split-stack,"",@progbits
818         .section        .note.GNU-no-split-stack,"",@progbits
819 #endif