OSDN Git Service

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