163d1a8abSmrg#ifdef __powerpc64__ 263d1a8abSmrg# PowerPC64 support for -fsplit-stack. 3*ec02198aSmrg# Copyright (C) 2009-2020 Free Software Foundation, Inc. 463d1a8abSmrg# Contributed by Alan Modra <amodra@gmail.com>. 563d1a8abSmrg 663d1a8abSmrg# This file is part of GCC. 763d1a8abSmrg 863d1a8abSmrg# GCC is free software; you can redistribute it and/or modify it under 963d1a8abSmrg# the terms of the GNU General Public License as published by the Free 1063d1a8abSmrg# Software Foundation; either version 3, or (at your option) any later 1163d1a8abSmrg# version. 1263d1a8abSmrg 1363d1a8abSmrg# GCC is distributed in the hope that it will be useful, but WITHOUT ANY 1463d1a8abSmrg# WARRANTY; without even the implied warranty of MERCHANTABILITY or 1563d1a8abSmrg# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1663d1a8abSmrg# for more details. 1763d1a8abSmrg 1863d1a8abSmrg# Under Section 7 of GPL version 3, you are granted additional 1963d1a8abSmrg# permissions described in the GCC Runtime Library Exception, version 2063d1a8abSmrg# 3.1, as published by the Free Software Foundation. 2163d1a8abSmrg 2263d1a8abSmrg# You should have received a copy of the GNU General Public License and 2363d1a8abSmrg# a copy of the GCC Runtime Library Exception along with this program; 2463d1a8abSmrg# see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 2563d1a8abSmrg# <http://www.gnu.org/licenses/>. 2663d1a8abSmrg 2763d1a8abSmrg#if _CALL_ELF == 2 2863d1a8abSmrg .abiversion 2 2963d1a8abSmrg#define PARAMS 32 3063d1a8abSmrg#else 3163d1a8abSmrg#define PARAMS 48 3263d1a8abSmrg#endif 3363d1a8abSmrg#define MORESTACK_FRAMESIZE (PARAMS+96) 34*ec02198aSmrg#define R2_SAVE -MORESTACK_FRAMESIZE+PARAMS-8 3563d1a8abSmrg#define PARAMREG_SAVE -MORESTACK_FRAMESIZE+PARAMS+0 3663d1a8abSmrg#define STATIC_CHAIN_SAVE -MORESTACK_FRAMESIZE+PARAMS+64 3763d1a8abSmrg#define R29_SAVE -MORESTACK_FRAMESIZE+PARAMS+72 3863d1a8abSmrg#define LINKREG_SAVE -MORESTACK_FRAMESIZE+PARAMS+80 3963d1a8abSmrg#define NEWSTACKSIZE_SAVE -MORESTACK_FRAMESIZE+PARAMS+88 4063d1a8abSmrg 4163d1a8abSmrg# Excess space needed to call ld.so resolver for lazy plt 4263d1a8abSmrg# resolution. Go uses sigaltstack so this doesn't need to 4363d1a8abSmrg# also cover signal frame size. 4463d1a8abSmrg#define BACKOFF 4096 4563d1a8abSmrg# Large excess allocated when calling non-split-stack code. 4663d1a8abSmrg#define NON_SPLIT_STACK 0x100000 4763d1a8abSmrg 4863d1a8abSmrg 4963d1a8abSmrg#if _CALL_ELF == 2 5063d1a8abSmrg 5163d1a8abSmrg#define BODY_LABEL(name) name 5263d1a8abSmrg 5363d1a8abSmrg#define ENTRY0(name) \ 5463d1a8abSmrg .global name; \ 5563d1a8abSmrg .hidden name; \ 5663d1a8abSmrg .type name,@function; \ 5763d1a8abSmrgname##: 5863d1a8abSmrg 59*ec02198aSmrg#ifdef __PCREL__ 60*ec02198aSmrg#define ENTRY(name) \ 61*ec02198aSmrg ENTRY0(name); \ 62*ec02198aSmrg .localentry name, 1 63*ec02198aSmrg#define JUMP_TARGET(name) name##@notoc 64*ec02198aSmrg#else 6563d1a8abSmrg#define ENTRY(name) \ 6663d1a8abSmrg ENTRY0(name); \ 6763d1a8abSmrg0: addis %r2,%r12,.TOC.-0b@ha; \ 6863d1a8abSmrg addi %r2,%r2,.TOC.-0b@l; \ 6963d1a8abSmrg .localentry name, .-name 70*ec02198aSmrg#endif 7163d1a8abSmrg 7263d1a8abSmrg#else 7363d1a8abSmrg 7463d1a8abSmrg#define BODY_LABEL(name) .L.##name 7563d1a8abSmrg 7663d1a8abSmrg#define ENTRY0(name) \ 7763d1a8abSmrg .global name; \ 7863d1a8abSmrg .hidden name; \ 7963d1a8abSmrg .type name,@function; \ 8063d1a8abSmrg .pushsection ".opd","aw"; \ 8163d1a8abSmrg .p2align 3; \ 8263d1a8abSmrgname##: .quad BODY_LABEL (name), .TOC.@tocbase, 0; \ 8363d1a8abSmrg .popsection; \ 8463d1a8abSmrgBODY_LABEL(name)##: 8563d1a8abSmrg 8663d1a8abSmrg#define ENTRY(name) ENTRY0(name) 8763d1a8abSmrg 8863d1a8abSmrg#endif 8963d1a8abSmrg 9063d1a8abSmrg#define SIZE(name) .size name, .-BODY_LABEL(name) 9163d1a8abSmrg 92*ec02198aSmrg#ifndef JUMP_TARGET 93*ec02198aSmrg#define JUMP_TARGET(name) name 94*ec02198aSmrg#endif 9563d1a8abSmrg 9663d1a8abSmrg .text 9763d1a8abSmrg# Just like __morestack, but with larger excess allocation 9863d1a8abSmrgENTRY0(__morestack_non_split) 9963d1a8abSmrg.LFB1: 10063d1a8abSmrg .cfi_startproc 10163d1a8abSmrg# We use a cleanup to restore the tcbhead_t.__private_ss if 10263d1a8abSmrg# an exception is thrown through this code. 10363d1a8abSmrg#ifdef __PIC__ 10463d1a8abSmrg .cfi_personality 0x9b,DW.ref.__gcc_personality_v0 10563d1a8abSmrg .cfi_lsda 0x1b,.LLSDA1 10663d1a8abSmrg#else 10763d1a8abSmrg .cfi_personality 0x3,__gcc_personality_v0 10863d1a8abSmrg .cfi_lsda 0x3,.LLSDA1 10963d1a8abSmrg#endif 11063d1a8abSmrg# LR is already saved by the split-stack prologue code. 11163d1a8abSmrg# We may as well have the unwinder skip over the call in the 11263d1a8abSmrg# prologue too. 11363d1a8abSmrg .cfi_offset %lr,16 11463d1a8abSmrg 11563d1a8abSmrg addis %r12,%r12,-NON_SPLIT_STACK@h 11663d1a8abSmrg SIZE (__morestack_non_split) 11763d1a8abSmrg# Fall through into __morestack 11863d1a8abSmrg 11963d1a8abSmrg 12063d1a8abSmrg# This function is called with non-standard calling conventions. 12163d1a8abSmrg# On entry, r12 is the requested stack pointer. One version of the 12263d1a8abSmrg# split-stack prologue that calls __morestack looks like 12363d1a8abSmrg# ld %r0,-0x7000-64(%r13) 12463d1a8abSmrg# addis %r12,%r1,-allocate@ha 12563d1a8abSmrg# addi %r12,%r12,-allocate@l 12663d1a8abSmrg# cmpld %r12,%r0 12763d1a8abSmrg# bge+ enough 12863d1a8abSmrg# mflr %r0 12963d1a8abSmrg# std %r0,16(%r1) 13063d1a8abSmrg# bl __morestack 13163d1a8abSmrg# ld %r0,16(%r1) 13263d1a8abSmrg# mtlr %r0 13363d1a8abSmrg# blr 13463d1a8abSmrg# enough: 13563d1a8abSmrg# The normal function prologue follows here, with a small addition at 13663d1a8abSmrg# the end to set up the arg pointer. The arg pointer is set up with: 13763d1a8abSmrg# addi %r12,%r1,offset 13863d1a8abSmrg# bge %cr7,.+8 13963d1a8abSmrg# mr %r12,%r29 14063d1a8abSmrg# 14163d1a8abSmrg# Note that the lr save slot 16(%r1) has already been used. 14263d1a8abSmrg# r3 thru r11 possibly contain arguments and a static chain 14363d1a8abSmrg# pointer for the function we're calling, so must be preserved. 14463d1a8abSmrg# cr7 must also be preserved. 14563d1a8abSmrg 14663d1a8abSmrgENTRY0(__morestack) 147*ec02198aSmrg 148*ec02198aSmrg#if _CALL_ELF == 2 149*ec02198aSmrg# Functions with localentry bits of zero cannot make calls if those 150*ec02198aSmrg# calls might change r2. This is true generally, and also true for 151*ec02198aSmrg# __morestack with its special calling convention. When __morestack's 152*ec02198aSmrg# caller is non-pcrel but libgcc is pcrel, the functions called here 153*ec02198aSmrg# might modify r2. r2 must be preserved on exit, and also restored 154*ec02198aSmrg# for the call back to our caller. 155*ec02198aSmrg std %r2,R2_SAVE(%r1) 156*ec02198aSmrg#endif 157*ec02198aSmrg 15863d1a8abSmrg# Save parameter passing registers, our arguments, lr, r29 15963d1a8abSmrg# and use r29 as a frame pointer. 16063d1a8abSmrg std %r3,PARAMREG_SAVE+0(%r1) 16163d1a8abSmrg sub %r3,%r1,%r12 # calculate requested stack size 16263d1a8abSmrg mflr %r12 16363d1a8abSmrg std %r4,PARAMREG_SAVE+8(%r1) 16463d1a8abSmrg std %r5,PARAMREG_SAVE+16(%r1) 16563d1a8abSmrg std %r6,PARAMREG_SAVE+24(%r1) 16663d1a8abSmrg std %r7,PARAMREG_SAVE+32(%r1) 16763d1a8abSmrg addi %r3,%r3,BACKOFF 16863d1a8abSmrg std %r8,PARAMREG_SAVE+40(%r1) 16963d1a8abSmrg std %r9,PARAMREG_SAVE+48(%r1) 17063d1a8abSmrg std %r10,PARAMREG_SAVE+56(%r1) 17163d1a8abSmrg std %r11,STATIC_CHAIN_SAVE(%r1) 17263d1a8abSmrg std %r29,R29_SAVE(%r1) 17363d1a8abSmrg std %r12,LINKREG_SAVE(%r1) 17463d1a8abSmrg std %r3,NEWSTACKSIZE_SAVE(%r1) # new stack size 17563d1a8abSmrg mr %r29,%r1 176*ec02198aSmrg#if _CALL_ELF == 2 177*ec02198aSmrg .cfi_offset %r2,R2_SAVE 178*ec02198aSmrg#endif 17963d1a8abSmrg .cfi_offset %r29,R29_SAVE 18063d1a8abSmrg .cfi_def_cfa_register %r29 18163d1a8abSmrg stdu %r1,-MORESTACK_FRAMESIZE(%r1) 18263d1a8abSmrg 183*ec02198aSmrg#if _CALL_ELF == 2 && !defined __PCREL__ 184*ec02198aSmrg# If this isn't a pcrel libgcc then the functions we call here will 185*ec02198aSmrg# require r2 to be valid. If __morestack is called from pcrel code r2 186*ec02198aSmrg# won't be valid. Set it up. 187*ec02198aSmrg bcl 20,31,1f 188*ec02198aSmrg1: 189*ec02198aSmrg mflr %r12 190*ec02198aSmrg addis %r2,%r12,.TOC.-1b@ha 191*ec02198aSmrg addi %r2,%r2,.TOC.-1b@l 192*ec02198aSmrg#endif 193*ec02198aSmrg 19463d1a8abSmrg # void __morestack_block_signals (void) 195*ec02198aSmrg bl JUMP_TARGET(__morestack_block_signals) 19663d1a8abSmrg 19763d1a8abSmrg # void *__generic_morestack (size_t *pframe_size, 19863d1a8abSmrg # void *old_stack, 19963d1a8abSmrg # size_t param_size) 20063d1a8abSmrg addi %r3,%r29,NEWSTACKSIZE_SAVE 20163d1a8abSmrg mr %r4,%r29 20263d1a8abSmrg li %r5,0 # no copying from old stack 203*ec02198aSmrg bl JUMP_TARGET(__generic_morestack) 20463d1a8abSmrg 20563d1a8abSmrg# Start using new stack 20663d1a8abSmrg stdu %r29,-32(%r3) # back-chain 20763d1a8abSmrg mr %r1,%r3 20863d1a8abSmrg 20963d1a8abSmrg# Set __private_ss stack guard for the new stack. 21063d1a8abSmrg ld %r12,NEWSTACKSIZE_SAVE(%r29) # modified size 21163d1a8abSmrg addi %r3,%r3,BACKOFF-32 21263d1a8abSmrg sub %r3,%r3,%r12 21363d1a8abSmrg# Note that a signal frame has $pc pointing at the instruction 21463d1a8abSmrg# where the signal occurred. For something like a timer 21563d1a8abSmrg# interrupt this means the instruction has already executed, 21663d1a8abSmrg# thus the region starts at the instruction modifying 21763d1a8abSmrg# __private_ss, not one instruction after. 21863d1a8abSmrg.LEHB0: 21963d1a8abSmrg std %r3,-0x7000-64(%r13) # tcbhead_t.__private_ss 22063d1a8abSmrg 22163d1a8abSmrg # void __morestack_unblock_signals (void) 222*ec02198aSmrg bl JUMP_TARGET(__morestack_unblock_signals) 22363d1a8abSmrg 22463d1a8abSmrg# Set up for a call to the target function, located 3 22563d1a8abSmrg# instructions after __morestack's return address. 22663d1a8abSmrg# 22763d1a8abSmrg ld %r12,LINKREG_SAVE(%r29) 228*ec02198aSmrg#if _CALL_ELF == 2 229*ec02198aSmrg ld %r2,R2_SAVE(%r29) 230*ec02198aSmrg#endif 23163d1a8abSmrg ld %r3,PARAMREG_SAVE+0(%r29) # restore arg regs 23263d1a8abSmrg ld %r4,PARAMREG_SAVE+8(%r29) 23363d1a8abSmrg ld %r5,PARAMREG_SAVE+16(%r29) 23463d1a8abSmrg ld %r6,PARAMREG_SAVE+24(%r29) 23563d1a8abSmrg ld %r7,PARAMREG_SAVE+32(%r29) 23663d1a8abSmrg ld %r8,PARAMREG_SAVE+40(%r29) 23763d1a8abSmrg ld %r9,PARAMREG_SAVE+48(%r29) 23863d1a8abSmrg addi %r0,%r12,12 # add 3 instructions 23963d1a8abSmrg ld %r10,PARAMREG_SAVE+56(%r29) 24063d1a8abSmrg ld %r11,STATIC_CHAIN_SAVE(%r29) 24163d1a8abSmrg cmpld %cr7,%r12,%r0 # indicate we were called 24263d1a8abSmrg mtctr %r0 24363d1a8abSmrg bctrl # call caller! 24463d1a8abSmrg 24563d1a8abSmrg# On return, save regs possibly used to return a value, and 24663d1a8abSmrg# possibly trashed by calls to __morestack_block_signals, 24763d1a8abSmrg# __generic_releasestack and __morestack_unblock_signals. 24863d1a8abSmrg# Assume those calls don't use vector or floating point regs. 24963d1a8abSmrg std %r3,PARAMREG_SAVE+0(%r29) 25063d1a8abSmrg std %r4,PARAMREG_SAVE+8(%r29) 25163d1a8abSmrg std %r5,PARAMREG_SAVE+16(%r29) 25263d1a8abSmrg std %r6,PARAMREG_SAVE+24(%r29) 25363d1a8abSmrg#if _CALL_ELF == 2 25463d1a8abSmrg std %r7,PARAMREG_SAVE+32(%r29) 25563d1a8abSmrg std %r8,PARAMREG_SAVE+40(%r29) 25663d1a8abSmrg std %r9,PARAMREG_SAVE+48(%r29) 25763d1a8abSmrg std %r10,PARAMREG_SAVE+56(%r29) 25863d1a8abSmrg#endif 25963d1a8abSmrg 260*ec02198aSmrg#if _CALL_ELF == 2 && !defined __PCREL__ 261*ec02198aSmrg# r2 was restored for calling back into our caller. Set it up again. 262*ec02198aSmrg bcl 20,31,1f 263*ec02198aSmrg1: 264*ec02198aSmrg mflr %r12 265*ec02198aSmrg addis %r2,%r12,.TOC.-1b@ha 266*ec02198aSmrg addi %r2,%r2,.TOC.-1b@l 267*ec02198aSmrg#endif 268*ec02198aSmrg 269*ec02198aSmrg bl JUMP_TARGET(__morestack_block_signals) 27063d1a8abSmrg 27163d1a8abSmrg # void *__generic_releasestack (size_t *pavailable) 27263d1a8abSmrg addi %r3,%r29,NEWSTACKSIZE_SAVE 273*ec02198aSmrg bl JUMP_TARGET(__generic_releasestack) 27463d1a8abSmrg 27563d1a8abSmrg# Reset __private_ss stack guard to value for old stack 27663d1a8abSmrg ld %r12,NEWSTACKSIZE_SAVE(%r29) 27763d1a8abSmrg addi %r3,%r3,BACKOFF 27863d1a8abSmrg sub %r3,%r3,%r12 27963d1a8abSmrg.LEHE0: 28063d1a8abSmrg std %r3,-0x7000-64(%r13) # tcbhead_t.__private_ss 28163d1a8abSmrg 282*ec02198aSmrg bl JUMP_TARGET(__morestack_unblock_signals) 28363d1a8abSmrg 28463d1a8abSmrg# Use old stack again. 28563d1a8abSmrg mr %r1,%r29 28663d1a8abSmrg 28763d1a8abSmrg# Restore return value regs, and return. 28863d1a8abSmrg ld %r0,LINKREG_SAVE(%r29) 28963d1a8abSmrg mtlr %r0 290*ec02198aSmrg#if _CALL_ELF == 2 291*ec02198aSmrg ld %r2,R2_SAVE(%r29) 292*ec02198aSmrg#endif 29363d1a8abSmrg ld %r3,PARAMREG_SAVE+0(%r29) 29463d1a8abSmrg ld %r4,PARAMREG_SAVE+8(%r29) 29563d1a8abSmrg ld %r5,PARAMREG_SAVE+16(%r29) 29663d1a8abSmrg ld %r6,PARAMREG_SAVE+24(%r29) 29763d1a8abSmrg#if _CALL_ELF == 2 29863d1a8abSmrg ld %r7,PARAMREG_SAVE+32(%r29) 29963d1a8abSmrg ld %r8,PARAMREG_SAVE+40(%r29) 30063d1a8abSmrg ld %r9,PARAMREG_SAVE+48(%r29) 30163d1a8abSmrg ld %r10,PARAMREG_SAVE+56(%r29) 30263d1a8abSmrg#endif 30363d1a8abSmrg ld %r29,R29_SAVE(%r29) 30463d1a8abSmrg .cfi_def_cfa_register %r1 30563d1a8abSmrg blr 30663d1a8abSmrg 30763d1a8abSmrg# This is the cleanup code called by the stack unwinder when 30863d1a8abSmrg# unwinding through code between .LEHB0 and .LEHE0 above. 30963d1a8abSmrgcleanup: 31063d1a8abSmrg .cfi_def_cfa_register %r29 31163d1a8abSmrg std %r3,PARAMREG_SAVE(%r29) # Save exception header 31263d1a8abSmrg # size_t __generic_findstack (void *stack) 31363d1a8abSmrg mr %r3,%r29 314*ec02198aSmrg bl JUMP_TARGET(__generic_findstack) 31563d1a8abSmrg sub %r3,%r29,%r3 31663d1a8abSmrg addi %r3,%r3,BACKOFF 31763d1a8abSmrg std %r3,-0x7000-64(%r13) # tcbhead_t.__private_ss 31863d1a8abSmrg ld %r3,PARAMREG_SAVE(%r29) 319*ec02198aSmrg bl JUMP_TARGET(_Unwind_Resume) 320*ec02198aSmrg#ifndef __PCREL__ 32163d1a8abSmrg nop 322*ec02198aSmrg#endif 32363d1a8abSmrg .cfi_endproc 32463d1a8abSmrg SIZE (__morestack) 32563d1a8abSmrg 32663d1a8abSmrg 32763d1a8abSmrg .section .gcc_except_table,"a",@progbits 32863d1a8abSmrg .p2align 2 32963d1a8abSmrg.LLSDA1: 33063d1a8abSmrg .byte 0xff # @LPStart format (omit) 33163d1a8abSmrg .byte 0xff # @TType format (omit) 33263d1a8abSmrg .byte 0x1 # call-site format (uleb128) 33363d1a8abSmrg .uleb128 .LLSDACSE1-.LLSDACSB1 # Call-site table length 33463d1a8abSmrg.LLSDACSB1: 33563d1a8abSmrg .uleb128 .LEHB0-.LFB1 # region 0 start 33663d1a8abSmrg .uleb128 .LEHE0-.LEHB0 # length 33763d1a8abSmrg .uleb128 cleanup-.LFB1 # landing pad 33863d1a8abSmrg .uleb128 0 # no action, ie. a cleanup 33963d1a8abSmrg.LLSDACSE1: 34063d1a8abSmrg 34163d1a8abSmrg 34263d1a8abSmrg#ifdef __PIC__ 34363d1a8abSmrg# Build a position independent reference to the personality function. 34463d1a8abSmrg .hidden DW.ref.__gcc_personality_v0 34563d1a8abSmrg .weak DW.ref.__gcc_personality_v0 34663d1a8abSmrg .section .data.DW.ref.__gcc_personality_v0,"awG",@progbits,DW.ref.__gcc_personality_v0,comdat 34763d1a8abSmrg .p2align 3 34863d1a8abSmrgDW.ref.__gcc_personality_v0: 34963d1a8abSmrg .quad __gcc_personality_v0 35063d1a8abSmrg .type DW.ref.__gcc_personality_v0, @object 35163d1a8abSmrg .size DW.ref.__gcc_personality_v0, 8 35263d1a8abSmrg#endif 35363d1a8abSmrg 35463d1a8abSmrg 35563d1a8abSmrg .text 35663d1a8abSmrg# Initialize the stack guard when the program starts or when a 35763d1a8abSmrg# new thread starts. This is called from a constructor. 35863d1a8abSmrg# void __stack_split_initialize (void) 35963d1a8abSmrgENTRY(__stack_split_initialize) 3600fc04c29Smrg .cfi_startproc 36163d1a8abSmrg addi %r3,%r1,-0x4000 # We should have at least 16K. 36263d1a8abSmrg std %r3,-0x7000-64(%r13) # tcbhead_t.__private_ss 36363d1a8abSmrg # void __generic_morestack_set_initial_sp (void *sp, size_t len) 36463d1a8abSmrg mr %r3,%r1 36563d1a8abSmrg li %r4, 0x4000 366*ec02198aSmrg b JUMP_TARGET(__generic_morestack_set_initial_sp) 3670fc04c29Smrg# The lack of .cfi_endproc here is deliberate. This function and the 3680fc04c29Smrg# following ones can all use the default FDE. 36963d1a8abSmrg SIZE (__stack_split_initialize) 37063d1a8abSmrg 37163d1a8abSmrg 37263d1a8abSmrg# Return current __private_ss 37363d1a8abSmrg# void *__morestack_get_guard (void) 37463d1a8abSmrgENTRY0(__morestack_get_guard) 37563d1a8abSmrg ld %r3,-0x7000-64(%r13) # tcbhead_t.__private_ss 37663d1a8abSmrg blr 37763d1a8abSmrg SIZE (__morestack_get_guard) 37863d1a8abSmrg 37963d1a8abSmrg 38063d1a8abSmrg# Set __private_ss 38163d1a8abSmrg# void __morestack_set_guard (void *ptr) 38263d1a8abSmrgENTRY0(__morestack_set_guard) 38363d1a8abSmrg std %r3,-0x7000-64(%r13) # tcbhead_t.__private_ss 38463d1a8abSmrg blr 38563d1a8abSmrg SIZE (__morestack_set_guard) 38663d1a8abSmrg 38763d1a8abSmrg 38863d1a8abSmrg# Return the stack guard value for given stack 38963d1a8abSmrg# void *__morestack_make_guard (void *stack, size_t size) 39063d1a8abSmrgENTRY0(__morestack_make_guard) 39163d1a8abSmrg sub %r3,%r3,%r4 39263d1a8abSmrg addi %r3,%r3,BACKOFF 39363d1a8abSmrg blr 3940fc04c29Smrg .cfi_endproc 39563d1a8abSmrg SIZE (__morestack_make_guard) 39663d1a8abSmrg 39763d1a8abSmrg 39863d1a8abSmrg# Make __stack_split_initialize a high priority constructor. 39963d1a8abSmrg .section .ctors.65535,"aw",@progbits 40063d1a8abSmrg .p2align 3 40163d1a8abSmrg .quad __stack_split_initialize 40263d1a8abSmrg .quad __morestack_load_mmap 40363d1a8abSmrg 40463d1a8abSmrg .section .note.GNU-stack,"",@progbits 40563d1a8abSmrg .section .note.GNU-split-stack,"",@progbits 40663d1a8abSmrg .section .note.GNU-no-split-stack,"",@progbits 40763d1a8abSmrg#endif /* __powerpc64__ */ 408