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