// If !iscgo, this is a no-op.
//
// NOTE: mcall() assumes this clobbers only X31 (REG_TMP).
TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0-0
#ifndef GOOS_openbsd
	MOVB	runtime·iscgo(SB), X31
	BEQZ	X31, nocgo
#endif
	MOV	g, runtime·tls_g(SB)
nocgo:
	RET

TEXT runtime·load_g(SB),NOSPLIT|NOFRAME,$0-0
	MOV	runtime·tls_g(SB), g
	RET

TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0-0
#ifndef GOOS_aix
#ifndef GOOS_openbsd
	MOVBZ	runtime·iscgo(SB), R31
	CMP	R31, $0
	BEQ	nocgo
#endif
#endif
	MOVD	runtime·tls_g(SB), R31
	MOVD	g, 0(R31)

nocgo:
	RET

// load_g loads the g register from pthread-provided
// thread-local memory, for use after calling externally compiled
// ppc64 code that overwrote those registers.
//

	MOVD	R12, CTR
	BL	(CTR)

	// Create a new thread to do the runtime initialization and return.
	MOVD	_cgo_sys_thread_create(SB), R12
	CMP	$0, R12
	BEQ	nocgo
	MOVD	$_rt0_ppc64le_linux_lib_go(SB), R3
	MOVD	$0, R4
	MOVD	R12, CTR
	BL	(CTR)
	BR	done

nocgo:
	MOVD	$0x800000, R12                     // stacksize = 8192KB
	MOVD	R12, 8+FIXED_FRAME(R1)
	MOVD	$_rt0_ppc64le_linux_lib_go(SB), R12
	MOVD	R12, 16+FIXED_FRAME(R1)

	MOVD	$runtime·libpreinit(SB), R1
	BL	R1

	// Create a new thread to finish Go runtime initialization.
	MOVD	_cgo_sys_thread_create(SB), R1
	CMP	R1, $0
	BEQ	nocgo
	MOVD	$_rt0_s390x_lib_go(SB), R2
	MOVD	$0, R3
	BL	R1
	BR	restore

nocgo:
	MOVD	$0x800000, R1              // stacksize
	MOVD	R1, 0(R15)
	MOVD	$_rt0_s390x_lib_go(SB), R1
	MOVD	R1, 8(R15)                 // fn
	MOVD	$runtime·newosproc(SB), R1

	MOVV	R29, (g_stack+stack_hi)(g)

	// if there is a _cgo_init, call it using the gcc ABI.
	MOVV	_cgo_init(SB), R25
	BEQ	R25, nocgo

	MOVV	R0, R7	// arg 3: not used
	MOVV	R0, R6	// arg 2: not used
	MOVV	$setg_gcc<>(SB), R5	// arg 1: setg
	MOVV	g, R4	// arg 0: G
	JAL	(R25)

nocgo:
	// update stackguard after _cgo_init
	MOVV	(g_stack+stack_lo)(g), R1
	ADDV	$const_stackGuard, R1
	MOVV	R1, g_stackguard0(g)

	MOV	X2, (g_stack+stack_hi)(g)

	// if there is a _cgo_init, call it using the gcc ABI.
	MOV	_cgo_init(SB), T0
	BEQ	T0, ZERO, nocgo

	MOV	ZERO, A3		// arg 3: not used
	MOV	ZERO, A2		// arg 2: not used
	MOV	$setg_gcc<>(SB), A1	// arg 1: setg
	MOV	g, A0			// arg 0: G
	JALR	RA, T0

nocgo:
	// update stackguard after _cgo_init
	MOV	(g_stack+stack_lo)(g), T0
	ADD	$const_stackGuard, T0
	MOV	T0, g_stackguard0(g)

	MOVV	R3, (g_stack+stack_hi)(g)

	// if there is a _cgo_init, call it using the gcc ABI.
	MOVV	_cgo_init(SB), R25
	BEQ	R25, nocgo

	MOVV	R0, R7	// arg 3: not used
	MOVV	R0, R6	// arg 2: not used
	MOVV	$setg_gcc<>(SB), R5	// arg 1: setg
	MOVV	g, R4	// arg 0: G
	JAL	(R25)

nocgo:
	// update stackguard after _cgo_init
	MOVV	(g_stack+stack_lo)(g), R19
	ADDV	$const_stackGuard, R19
	MOVV	R19, g_stackguard0(g)

	// if there is a _cgo_init, call it using the gcc ABI.
	MOVW	_cgo_init(SB), R25
	BEQ	R25, nocgo
	ADDU	$-16, R29
	MOVW	R0, R7	// arg 3: not used
	MOVW	R0, R6	// arg 2: not used
	MOVW	$setg_gcc<>(SB), R5	// arg 1: setg
	MOVW	g, R4	// arg 0: G
	JAL	(R25)
	ADDU	$16, R29

nocgo:
	// update stackguard after _cgo_init
	MOVW	(g_stack+stack_lo)(g), R1
	ADD	$const_stackGuard, R1

	MOVD	frame+8(FP), g
	BR	dropm

loadg:
	// Load m and g from thread-local storage.
#ifndef GOOS_openbsd
	MOVBZ	runtime·iscgo(SB), R3
	CMP	R3, $0
	BEQ	nocgo
#endif
	BL	runtime·load_g(SB)
nocgo:

	// If g is nil, Go did not create the current thread,
	// or if this thread never called into Go on pthread platforms.
	// Call needm to obtain one for temporary use.

	// Synchronous initialization.
	CALL	runtime·libpreinit(SB)

	// Create a new thread to do the runtime initialization.
	MOVW	_cgo_sys_thread_create(SB), R2
	CMP	$0, R2
	BEQ	nocgo
	MOVW	$_rt0_arm_lib_go<>(SB), R0
	MOVW	$0, R1
	BL	(R2)
	B	rr
nocgo:
	MOVW	$0x800000, R0                     // stacksize = 8192KB
	MOVW	$_rt0_arm_lib_go<>(SB), R1  // fn
	MOVW	R0, 4(R13)
	MOVW	R1, 8(R13)
	BL	runtime·newosproc0(SB)
rr: