OSDN Git Service

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