# s390 support for -fsplit-stack.
# Copyright (C) 2015-2017 Free Software Foundation, Inc.
# Contributed by Marcin Kościelnicki <koriakin@0x04.net>.

# This file is part of GCC.

# GCC is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free
# Software Foundation; either version 3, or (at your option) any later
# version.

# GCC is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
# for more details.

# Under Section 7 of GPL version 3, you are granted additional
# permissions described in the GCC Runtime Library Exception, version
# 3.1, as published by the Free Software Foundation.

# You should have received a copy of the GNU General Public License and
# a copy of the GCC Runtime Library Exception along with this program;
# see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
# <http://www.gnu.org/licenses/>.

# Excess space needed to call ld.so resolver for lazy plt
# resolution.  Go uses sigaltstack so this doesn't need to
# also cover signal frame size.
#define BACKOFF 0x1000

# The __morestack function.

	.global	__morestack
	.hidden	__morestack

	.type	__morestack,@function

__morestack:
.LFB1:
	.cfi_startproc


#ifndef __s390x__


# The 31-bit __morestack function.

	# We use a cleanup to restore the stack guard if an exception
	# is thrown through this code.
#ifndef __PIC__
	.cfi_personality 0,__gcc_personality_v0
	.cfi_lsda 0,.LLSDA1
#else
	.cfi_personality 0x9b,DW.ref.__gcc_personality_v0
	.cfi_lsda 0x1b,.LLSDA1
#endif

	stm	%r2, %r15, 0x8(%r15)	# Save %r2-%r15.
	.cfi_offset %r6, -0x48
	.cfi_offset %r7, -0x44
	.cfi_offset %r8, -0x40
	.cfi_offset %r9, -0x3c
	.cfi_offset %r10, -0x38
	.cfi_offset %r11, -0x34
	.cfi_offset %r12, -0x30
	.cfi_offset %r13, -0x2c
	.cfi_offset %r14, -0x28
	.cfi_offset %r15, -0x24
	lr	%r11, %r15		# Make frame pointer for vararg.
	.cfi_def_cfa_register %r11
	ahi	%r15, -0x60		# 0x60 for standard frame.
	st	%r11, 0(%r15)		# Save back chain.
	lr	%r8, %r0		# Save %r0 (static chain).
	lr	%r10, %r1		# Save %r1 (address of parameter block).

	l	%r7, 0(%r10)		# Required frame size to %r7
	ear	%r1, %a0		# Extract thread pointer.
	l	%r1, 0x20(%r1)		# Get stack bounduary
	ar	%r1, %r7		# Stack bounduary + frame size
	a	%r1, 4(%r10)		# + stack param size
	clr	%r1, %r15		# Compare with current stack pointer
	jle	.Lnoalloc		# guard > sp - frame-size: need alloc

	brasl	%r14, __morestack_block_signals

	# We abuse one of caller's fpr save slots (which we don't use for fprs)
	# as a local variable.  Not needed here, but done to be consistent with
	# the below use.
	ahi	%r7, BACKOFF		# Bump requested size a bit.
	st	%r7, 0x40(%r11)		# Stuff frame size on stack.
	la	%r2, 0x40(%r11)		# Pass its address as parameter.
	la	%r3, 0x60(%r11)		# Caller's stack parameters.
	l	%r4, 4(%r10)		# Size of stack parameters.
	brasl	%r14, __generic_morestack

	lr	%r15, %r2		# Switch to the new stack.
	ahi	%r15, -0x60		# Make a stack frame on it.
	st	%r11, 0(%r15)		# Save back chain.

	s	%r2, 0x40(%r11)		# The end of stack space.
	ahi	%r2, BACKOFF		# Back off a bit.
	ear	%r1, %a0		# Extract thread pointer.
.LEHB0:
	st	%r2, 0x20(%r1)	# Save the new stack boundary.

	brasl	%r14, __morestack_unblock_signals

	lr	%r0, %r8		# Static chain.
	lm	%r2, %r6, 0x8(%r11)	# Paremeter registers.

	# Third parameter is address of function meat - address of parameter
	# block.
	a	%r10, 0x8(%r10)

	# Leave vararg pointer in %r1, in case function uses it
	la	%r1, 0x60(%r11)

	# State of registers:
	# %r0: Static chain from entry.
	# %r1: Vararg pointer.
	# %r2-%r6: Parameters from entry.
	# %r7-%r10: Indeterminate.
	# %r11: Frame pointer (%r15 from entry).
	# %r12-%r13: Indeterminate.
	# %r14: Return address.
	# %r15: Stack pointer.
	basr	%r14, %r10		# Call our caller.

	stm	%r2, %r3, 0x8(%r11)	# Save return registers.

	brasl	%r14, __morestack_block_signals

	# We need a stack slot now, but have no good way to get it - the frame
	# on new stack had to be exactly 0x60 bytes, or stack parameters would
	# be passed wrong.  Abuse fpr save area in caller's frame (we don't
	# save actual fprs).
	la	%r2, 0x40(%r11)
	brasl	%r14, __generic_releasestack

	s	%r2, 0x40(%r11)		# Subtract available space.
	ahi	%r2, BACKOFF		# Back off a bit.
	ear	%r1, %a0		# Extract thread pointer.
.LEHE0:
	st	%r2, 0x20(%r1)	# Save the new stack boundary.

	# We need to restore the old stack pointer before unblocking signals.
	# We also need 0x60 bytes for a stack frame.  Since we had a stack
	# frame at this place before the stack switch, there's no need to
	# write the back chain again.
	lr	%r15, %r11
	ahi	%r15, -0x60

	brasl	%r14, __morestack_unblock_signals

	lm	%r2, %r15, 0x8(%r11)	# Restore all registers.
	.cfi_remember_state
	.cfi_restore %r15
	.cfi_restore %r14
	.cfi_restore %r13
	.cfi_restore %r12
	.cfi_restore %r11
	.cfi_restore %r10
	.cfi_restore %r9
	.cfi_restore %r8
	.cfi_restore %r7
	.cfi_restore %r6
	.cfi_def_cfa_register %r15
	br	%r14			# Return to caller's caller.

# Executed if no new stack allocation is needed.

.Lnoalloc:
	.cfi_restore_state
	# We may need to copy stack parameters.
	l	%r9, 0x4(%r10)		# Load stack parameter size.
	ltr	%r9, %r9		# And check if it's 0.
	je	.Lnostackparm		# Skip the copy if not needed.
	sr	%r15, %r9		# Make space on the stack.
	la	%r8, 0x60(%r15)		# Destination.
	la	%r12, 0x60(%r11)	# Source.
	lr	%r13, %r9		# Source size.
.Lcopy:
	mvcle	%r8, %r12, 0		# Copy.
	jo	.Lcopy

.Lnostackparm:
	# Third parameter is address of function meat - address of parameter
	# block.
	a	%r10, 0x8(%r10)

	# Leave vararg pointer in %r1, in case function uses it
	la	%r1, 0x60(%r11)

	# OK, no stack allocation needed.  We still follow the protocol and
	# call our caller - it doesn't cost much and makes sure vararg works.
	# No need to set any registers here - %r0 and %r2-%r6 weren't modified.
	basr	%r14, %r10		# Call our caller.

	lm	%r6, %r15, 0x18(%r11)	# Restore all callee-saved registers.
	.cfi_remember_state
	.cfi_restore %r15
	.cfi_restore %r14
	.cfi_restore %r13
	.cfi_restore %r12
	.cfi_restore %r11
	.cfi_restore %r10
	.cfi_restore %r9
	.cfi_restore %r8
	.cfi_restore %r7
	.cfi_restore %r6
	.cfi_def_cfa_register %r15
	br	%r14			# Return to caller's caller.

# This is the cleanup code called by the stack unwinder when unwinding
# through the code between .LEHB0 and .LEHE0 above.

.L1:
	.cfi_restore_state
	lr	%r2, %r11		# Stack pointer after resume.
	brasl	%r14, __generic_findstack
	lr	%r3, %r11		# Get the stack pointer.
	sr	%r3, %r2		# Subtract available space.
	ahi	%r3, BACKOFF		# Back off a bit.
	ear	%r1, %a0		# Extract thread pointer.
	st	%r3, 0x20(%r1)	# Save the new stack boundary.

	# We need GOT pointer in %r12 for PLT entry.
	larl	%r12,_GLOBAL_OFFSET_TABLE_
	lr	%r2, %r6		# Exception header.
#ifdef __PIC__
	brasl	%r14, _Unwind_Resume@PLT
#else
	brasl	%r14, _Unwind_Resume
#endif

#else /* defined(__s390x__) */


# The 64-bit __morestack function.

	# We use a cleanup to restore the stack guard if an exception
	# is thrown through this code.
#ifndef __PIC__
	.cfi_personality 0x3,__gcc_personality_v0
	.cfi_lsda 0x3,.LLSDA1
#else
	.cfi_personality 0x9b,DW.ref.__gcc_personality_v0
	.cfi_lsda 0x1b,.LLSDA1
#endif

	stmg	%r2, %r15, 0x10(%r15)	# Save %r2-%r15.
	.cfi_offset %r6, -0x70
	.cfi_offset %r7, -0x68
	.cfi_offset %r8, -0x60
	.cfi_offset %r9, -0x58
	.cfi_offset %r10, -0x50
	.cfi_offset %r11, -0x48
	.cfi_offset %r12, -0x40
	.cfi_offset %r13, -0x38
	.cfi_offset %r14, -0x30
	.cfi_offset %r15, -0x28
	lgr	%r11, %r15		# Make frame pointer for vararg.
	.cfi_def_cfa_register %r11
	aghi	%r15, -0xa0		# 0xa0 for standard frame.
	stg	%r11, 0(%r15)		# Save back chain.
	lgr	%r8, %r0		# Save %r0 (static chain).
	lgr	%r10, %r1		# Save %r1 (address of parameter block).

	lg	%r7, 0(%r10)		# Required frame size to %r7
	ear	%r1, %a0
	sllg	%r1, %r1, 32
	ear	%r1, %a1		# Extract thread pointer.
	lg	%r1, 0x38(%r1)		# Get stack bounduary
	agr	%r1, %r7		# Stack bounduary + frame size
	ag	%r1, 8(%r10)		# + stack param size
	clgr	%r1, %r15		# Compare with current stack pointer
	jle	.Lnoalloc		# guard > sp - frame-size: need alloc

	brasl	%r14, __morestack_block_signals

	# We abuse one of caller's fpr save slots (which we don't use for fprs)
	# as a local variable.  Not needed here, but done to be consistent with
	# the below use.
	aghi	%r7, BACKOFF		# Bump requested size a bit.
	stg	%r7, 0x80(%r11)		# Stuff frame size on stack.
	la	%r2, 0x80(%r11)		# Pass its address as parameter.
	la	%r3, 0xa0(%r11)		# Caller's stack parameters.
	lg	%r4, 8(%r10)		# Size of stack parameters.
	brasl	%r14, __generic_morestack

	lgr	%r15, %r2		# Switch to the new stack.
	aghi	%r15, -0xa0		# Make a stack frame on it.
	stg	%r11, 0(%r15)		# Save back chain.

	sg	%r2, 0x80(%r11)		# The end of stack space.
	aghi	%r2, BACKOFF		# Back off a bit.
	ear	%r1, %a0
	sllg	%r1, %r1, 32
	ear	%r1, %a1		# Extract thread pointer.
.LEHB0:
	stg	%r2, 0x38(%r1)	# Save the new stack boundary.

	brasl	%r14, __morestack_unblock_signals

	lgr	%r0, %r8		# Static chain.
	lmg	%r2, %r6, 0x10(%r11)	# Paremeter registers.

	# Third parameter is address of function meat - address of parameter
	# block.
	ag	%r10, 0x10(%r10)

	# Leave vararg pointer in %r1, in case function uses it
	la	%r1, 0xa0(%r11)

	# State of registers:
	# %r0: Static chain from entry.
	# %r1: Vararg pointer.
	# %r2-%r6: Parameters from entry.
	# %r7-%r10: Indeterminate.
	# %r11: Frame pointer (%r15 from entry).
	# %r12-%r13: Indeterminate.
	# %r14: Return address.
	# %r15: Stack pointer.
	basr	%r14, %r10		# Call our caller.

	stg	%r2, 0x10(%r11)		# Save return register.

	brasl	%r14, __morestack_block_signals

	# We need a stack slot now, but have no good way to get it - the frame
	# on new stack had to be exactly 0xa0 bytes, or stack parameters would
	# be passed wrong.  Abuse fpr save area in caller's frame (we don't
	# save actual fprs).
	la	%r2, 0x80(%r11)
	brasl	%r14, __generic_releasestack

	sg	%r2, 0x80(%r11)		# Subtract available space.
	aghi	%r2, BACKOFF		# Back off a bit.
	ear	%r1, %a0
	sllg	%r1, %r1, 32
	ear	%r1, %a1		# Extract thread pointer.
.LEHE0:
	stg	%r2, 0x38(%r1)	# Save the new stack boundary.

	# We need to restore the old stack pointer before unblocking signals.
	# We also need 0xa0 bytes for a stack frame.  Since we had a stack
	# frame at this place before the stack switch, there's no need to
	# write the back chain again.
	lgr	%r15, %r11
	aghi	%r15, -0xa0

	brasl	%r14, __morestack_unblock_signals

	lmg	%r2, %r15, 0x10(%r11)	# Restore all registers.
	.cfi_remember_state
	.cfi_restore %r15
	.cfi_restore %r14
	.cfi_restore %r13
	.cfi_restore %r12
	.cfi_restore %r11
	.cfi_restore %r10
	.cfi_restore %r9
	.cfi_restore %r8
	.cfi_restore %r7
	.cfi_restore %r6
	.cfi_def_cfa_register %r15
	br	%r14			# Return to caller's caller.

# Executed if no new stack allocation is needed.

.Lnoalloc:
	.cfi_restore_state
	# We may need to copy stack parameters.
	lg	%r9, 0x8(%r10)		# Load stack parameter size.
	ltgr	%r9, %r9		# Check if it's 0.
	je	.Lnostackparm		# Skip the copy if not needed.
	sgr	%r15, %r9		# Make space on the stack.
	la	%r8, 0xa0(%r15)		# Destination.
	la	%r12, 0xa0(%r11)	# Source.
	lgr	%r13, %r9		# Source size.
.Lcopy:
	mvcle	%r8, %r12, 0		# Copy.
	jo	.Lcopy

.Lnostackparm:
	# Third parameter is address of function meat - address of parameter
	# block.
	ag	%r10, 0x10(%r10)

	# Leave vararg pointer in %r1, in case function uses it
	la	%r1, 0xa0(%r11)

	# OK, no stack allocation needed.  We still follow the protocol and
	# call our caller - it doesn't cost much and makes sure vararg works.
	# No need to set any registers here - %r0 and %r2-%r6 weren't modified.
	basr	%r14, %r10		# Call our caller.

	lmg	%r6, %r15, 0x30(%r11)	# Restore all callee-saved registers.
	.cfi_remember_state
	.cfi_restore %r15
	.cfi_restore %r14
	.cfi_restore %r13
	.cfi_restore %r12
	.cfi_restore %r11
	.cfi_restore %r10
	.cfi_restore %r9
	.cfi_restore %r8
	.cfi_restore %r7
	.cfi_restore %r6
	.cfi_def_cfa_register %r15
	br	%r14			# Return to caller's caller.

# This is the cleanup code called by the stack unwinder when unwinding
# through the code between .LEHB0 and .LEHE0 above.

.L1:
	.cfi_restore_state
	lgr	%r2, %r11		# Stack pointer after resume.
	brasl	%r14, __generic_findstack
	lgr	%r3, %r11		# Get the stack pointer.
	sgr	%r3, %r2		# Subtract available space.
	aghi	%r3, BACKOFF		# Back off a bit.
	ear	%r1, %a0
	sllg	%r1, %r1, 32
	ear	%r1, %a1		# Extract thread pointer.
	stg	%r3, 0x38(%r1)	# Save the new stack boundary.

	lgr	%r2, %r6		# Exception header.
#ifdef __PIC__
	brasl	%r14, _Unwind_Resume@PLT
#else
	brasl	%r14, _Unwind_Resume
#endif

#endif /* defined(__s390x__) */

	.cfi_endproc
	.size	__morestack, . - __morestack


# The exception table.  This tells the personality routine to execute
# the exception handler.

	.section	.gcc_except_table,"a",@progbits
	.align	4
.LLSDA1:
	.byte	0xff	# @LPStart format (omit)
	.byte	0xff	# @TType format (omit)
	.byte	0x1	# call-site format (uleb128)
	.uleb128 .LLSDACSE1-.LLSDACSB1	# Call-site table length
.LLSDACSB1:
	.uleb128 .LEHB0-.LFB1	# region 0 start
	.uleb128 .LEHE0-.LEHB0	# length
	.uleb128 .L1-.LFB1	# landing pad
	.uleb128 0		# action
.LLSDACSE1:


	.global __gcc_personality_v0
#ifdef __PIC__
	# Build a position independent reference to the basic
	# personality function.
	.hidden DW.ref.__gcc_personality_v0
	.weak   DW.ref.__gcc_personality_v0
	.section .data.DW.ref.__gcc_personality_v0,"awG",@progbits,DW.ref.__gcc_personality_v0,comdat
	.type	DW.ref.__gcc_personality_v0, @object
DW.ref.__gcc_personality_v0:
#ifndef __LP64__
	.align 4
	.size	DW.ref.__gcc_personality_v0, 4
	.long	__gcc_personality_v0
#else
	.align 8
	.size	DW.ref.__gcc_personality_v0, 8
	.quad	__gcc_personality_v0
#endif
#endif



# Initialize the stack test value when the program starts or when a
# new thread starts.  We don't know how large the main stack is, so we
# guess conservatively.  We might be able to use getrlimit here.

	.text
	.global	__stack_split_initialize
	.hidden	__stack_split_initialize

	.type	__stack_split_initialize, @function

__stack_split_initialize:

#ifndef __s390x__

	ear	%r1, %a0
	lr	%r0, %r15
	ahi	%r0, -0x4000	# We should have at least 16K.
	st	%r0, 0x20(%r1)

	lr	%r2, %r15
	lhi	%r3, 0x4000
#ifdef __PIC__
	jg	__generic_morestack_set_initial_sp@PLT	# Tail call
#else
	jg	__generic_morestack_set_initial_sp	# Tail call
#endif

#else /* defined(__s390x__) */

	ear	%r1, %a0
	sllg	%r1, %r1, 32
	ear	%r1, %a1
	lgr	%r0, %r15
	aghi	%r0, -0x4000	# We should have at least 16K.
	stg	%r0, 0x38(%r1)

	lgr	%r2, %r15
	lghi	%r3, 0x4000
#ifdef __PIC__
	jg	__generic_morestack_set_initial_sp@PLT	# Tail call
#else
	jg	__generic_morestack_set_initial_sp	# Tail call
#endif

#endif /* defined(__s390x__) */

	.size	__stack_split_initialize, . - __stack_split_initialize

# Routines to get and set the guard, for __splitstack_getcontext,
# __splitstack_setcontext, and __splitstack_makecontext.

# void *__morestack_get_guard (void) returns the current stack guard.
	.text
	.global	__morestack_get_guard
	.hidden	__morestack_get_guard

	.type	__morestack_get_guard,@function

__morestack_get_guard:

#ifndef __s390x__
	ear	%r1, %a0
	l	%r2, 0x20(%r1)
#else
	ear	%r1, %a0
	sllg	%r1, %r1, 32
	ear	%r1, %a1
	lg	%r2, 0x38(%r1)
#endif
	br %r14

	.size	__morestack_get_guard, . - __morestack_get_guard

# void __morestack_set_guard (void *) sets the stack guard.
	.global	__morestack_set_guard
	.hidden	__morestack_set_guard

	.type	__morestack_set_guard,@function

__morestack_set_guard:

#ifndef __s390x__
	ear	%r1, %a0
	st	%r2, 0x20(%r1)
#else
	ear	%r1, %a0
	sllg	%r1, %r1, 32
	ear	%r1, %a1
	stg	%r2, 0x38(%r1)
#endif
	br	%r14

	.size	__morestack_set_guard, . - __morestack_set_guard

# void *__morestack_make_guard (void *, size_t) returns the stack
# guard value for a stack.
	.global	__morestack_make_guard
	.hidden	__morestack_make_guard

	.type	__morestack_make_guard,@function

__morestack_make_guard:

#ifndef __s390x__
	sr	%r2, %r3
	ahi	%r2, BACKOFF
#else
	sgr	%r2, %r3
	aghi	%r2, BACKOFF
#endif
	br	%r14

	.size	__morestack_make_guard, . - __morestack_make_guard

# Make __stack_split_initialize a high priority constructor.

	.section .ctors.65535,"aw",@progbits

#ifndef __LP64__
	.align	4
	.long	__stack_split_initialize
	.long	__morestack_load_mmap
#else
	.align	8
	.quad	__stack_split_initialize
	.quad	__morestack_load_mmap
#endif

	.section	.note.GNU-stack,"",@progbits
	.section	.note.GNU-split-stack,"",@progbits
	.section	.note.GNU-no-split-stack,"",@progbits
