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.
//

	BL	(R4)

	// Create a new thread to do the runtime initialization and return.
	MOVD	_cgo_sys_thread_create(SB), R4
	CBZ	R4, nocgo
	MOVD	$_rt0_arm64_netbsd_lib_go(SB), R0
	MOVD	$0, R1
	SUB	$16, RSP		// reserve 16 bytes for sp-8 where fp may be saved.
	BL	(R4)
	ADD	$16, RSP
	B	restore

nocgo:
	MOVD	$0x800000, R0                     // stacksize = 8192KB
	MOVD	$_rt0_arm64_netbsd_lib_go(SB), R1
	MOVD	R0, 8(RSP)

//
// NOTE: setg_gcc<> assume this clobbers only R10 and R11.
TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0-0
	MOVB	runtime·iscgo(SB),  R10
	CMPBEQ	R10, $0, nocgo
	MOVW	AR0, R11
	SLD	$32, R11
	MOVW	AR1, R11
	MOVD	runtime·tls_g(SB), R10
	MOVD	g, 0(R10)(R11*1)
nocgo:
	RET

// load_g loads the g register from pthread-provided
// thread-local memory, for use after calling externally compiled

	BL	(R4)

	// Create a new thread to do the runtime initialization and return.
	MOVD	_cgo_sys_thread_create(SB), R4
	CBZ	R4, nocgo
	MOVD	$_rt0_arm64_openbsd_lib_go(SB), R0
	MOVD	$0, R1
	SUB	$16, RSP		// reserve 16 bytes for sp-8 where fp may be saved.
	BL	(R4)
	ADD	$16, RSP
	B	restore

nocgo:
	MOVD	$0x800000, R0                     // stacksize = 8192KB
	MOVD	$_rt0_arm64_openbsd_lib_go(SB), R1
	MOVD	R0, 8(RSP)

	MOVV	$runtime·libpreinit(SB), R19
	JAL	(R19)

	// Create a new thread to do the runtime initialization and return.
	MOVV	_cgo_sys_thread_create(SB), R19
	BEQ	R19, nocgo
	MOVV	$_rt0_loong64_linux_lib_go(SB), R4
	MOVV	$0, R5
	JAL	(R19)
	JMP	restore

nocgo:
	MOVV	$0x800000, R4                     // stacksize = 8192KB
	MOVV	$_rt0_loong64_linux_lib_go(SB), R5
	MOVV	R4, 8(R3)
	MOVV	R5, 16(R3)
	MOVV	$runtime·newosproc0(SB), R19

	MOVW	_cgo_init(SB), R4
	CMP	$0, R4
	B.EQ	nocgo
	MRC     15, 0, R0, C13, C0, 3 	// load TLS base pointer
	MOVW 	R0, R3 			// arg 3: TLS base pointer
#ifdef TLSG_IS_VARIABLE
	MOVW 	$runtime·tls_g(SB), R2 	// arg 2: &tls_g
#else
	MOVW	$0, R2			// arg 2: not used when using platform tls
#endif
	MOVW	$setg_gcc<>(SB), R1 	// arg 1: setg
	MOVW	g, R0 			// arg 0: G
	BL	(R4) // will clobber R0-R3
nocgo:
	RET

	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)

	MOV	$runtime·libpreinit(SB), T0
	JALR	RA, T0

	// Create a new thread to do the runtime initialization and return.
	MOV	_cgo_sys_thread_create(SB), T0
	BEQZ	T0, nocgo
	MOV	$_rt0_riscv64_linux_lib_go(SB), A0
	MOV	$0, A1
	JALR	RA, T0
	JMP	restore

nocgo:
	MOV	$0x800000, A0                     // stacksize = 8192KB
	MOV	$_rt0_riscv64_linux_lib_go(SB), A1
	MOV	A0, 8(X2)
	MOV	A1, 16(X2)
	MOV	$runtime·newosproc0(SB), T0

	MOV	$runtime·libpreinit(SB), T0
	JALR	RA, T0

	// Create a new thread to do the runtime initialization and return.
	MOV	_cgo_sys_thread_create(SB), T0
	BEQZ	T0, nocgo
	MOV	$_rt0_riscv64_freebsd_lib_go(SB), A0
	MOV	$0, A1
	JALR	RA, T0
	JMP	restore

nocgo:
	MOV	$0x800000, A0                     // stacksize = 8192KB
	MOV	$_rt0_riscv64_freebsd_lib_go(SB), A1
	MOV	A0, 8(X2)
	MOV	A1, 16(X2)
	MOV	$runtime·newosproc0(SB), T0

package signal

import (
	"os"
	"syscall"
	"testing"
	"time"
)

const prSetKeepCaps = 8

// This test validates that syscall.AllThreadsSyscall() can reliably
// reach all 'm' (threads) of the nocgo runtime even when one thread
// is blocked waiting to receive signals from the kernel. This monitors
// for a regression vs. the fix for #43149.
func TestAllThreadsSyscallSignals(t *testing.T) {