MOVQ	m_vdsoSP(BX), DX
	MOVQ	CX, 0(SP)
	MOVQ	DX, 8(SP)

	LEAQ	sec+0(FP), DX
	MOVQ	-8(DX), CX	// Sets CX to function return address.
	MOVQ	CX, m_vdsoPC(BX)
	MOVQ	DX, m_vdsoSP(BX)

	CMPQ	R14, m_curg(BX)	// Only switch if on curg.
	JNE	noswitch

	MOVQ	m_g0(BX), DX
	MOVQ	(g_sched+gobuf_sp)(DX), SP	// Set SP to g0 stack

noswitch:
	SUBQ	$32, SP		// Space for two time results
	ANDQ	$~15, SP	// Align for C code

	// save that information (m->curg->sched) so we can restore it.
	// We can restore m->curg->sched.sp easily, because calling
	// runtime.cgocallbackg leaves SP unchanged upon return.
	// To save m->curg->sched.pc, we push it onto the curg stack and
	// open a frame the same size as cgocallback's g0 frame.
	// Once we switch to the curg stack, the pushed PC will appear
	// to be the return PC of cgocallback, so that the traceback

	MOVD	g_m(R9), R6
	CMP	$0, R6
	BEQ	sigtramp    // g.m == nil
	MOVW	m_ncgo(R6), R7
	CMPW	$0, R7
	BEQ	sigtramp    // g.m.ncgo = 0
	MOVD	m_curg(R6), R7
	CMP	$0, R7
	BEQ	sigtramp    // g.m.curg == nil
	MOVD	g_syscallsp(R7), R7
	CMP	$0, R7
	BEQ	sigtramp    // g.m.curg.syscallsp == 0
	MOVD	m_cgoCallers(R6), R7 // R7 is the fifth arg in C calling convention.
	CMP	$0, R7
	BEQ	sigtramp    // g.m.cgoCallers == nil

	// if g == g0
	Get g
	Get R2
	I64Eq
	If
		// no switch:
		MOVD R0, CTXT

		Get CTXT
		I32WrapI64
		I64Load $0
		JMP
	End

	// if g != m.curg
	Get g
	I64Load m_curg(R1)
	I64Ne
	If
		CALLNORESUME runtime·badsystemstack(SB)
		CALLNORESUME runtime·abort(SB)
	End

	// switch:

	// save state in g->sched. Pretend to

	// save that information (m->curg->sched) so we can restore it.
	// We can restore m->curg->sched.sp easily, because calling
	// runtime.cgocallbackg leaves SP unchanged upon return.
	// To save m->curg->sched.pc, we push it onto the curg stack and
	// open a frame the same size as cgocallback's g0 frame.
	// Once we switch to the curg stack, the pushed PC will appear
	// to be the return PC of cgocallback, so that the traceback

	// save that information (m->curg->sched) so we can restore it.
	// We can restore m->curg->sched.sp easily, because calling
	// runtime.cgocallbackg leaves SP unchanged upon return.
	// To save m->curg->sched.pc, we push it onto the curg stack and
	// open a frame the same size as cgocallback's g0 frame.
	// Once we switch to the curg stack, the pushed PC will appear
	// to be the return PC of cgocallback, so that the traceback

	CBZ	g, sigtrampnog // g == nil
	MOVD	g_m(g), R6
	CBZ	R6, sigtramp    // g.m == nil
	MOVW	m_ncgo(R6), R7
	CBZW	R7, sigtramp    // g.m.ncgo = 0
	MOVD	m_curg(R6), R8
	CBZ	R8, sigtramp    // g.m.curg == nil
	MOVD	g_syscallsp(R8), R7
	CBZ	R7,	sigtramp    // g.m.curg.syscallsp == 0
	MOVD	m_cgoCallers(R6), R4 // R4 is the fifth arg in C calling convention.
	CBZ	R4,	sigtramp    // g.m.cgoCallers == nil
	MOVW	m_cgoCallersUse(R6), R8

	// save that information (m->curg->sched) so we can restore it.
	// We can restore m->curg->sched.sp easily, because calling
	// runtime.cgocallbackg leaves SP unchanged upon return.
	// To save m->curg->sched.pc, we push it onto the curg stack and
	// open a frame the same size as cgocallback's g0 frame.
	// Once we switch to the curg stack, the pushed PC will appear
	// to be the return PC of cgocallback, so that the traceback

	MOVV	g_m(g), R4	// R4 = m

	MOVV	m_gsignal(R4), R5	// R5 = gsignal
	BEQ	g, R5, noswitch

	MOVV	m_g0(R4), R5	// R5 = g0
	BEQ	g, R5, noswitch

	MOVV	m_curg(R4), R6
	BEQ	g, R6, switch

	// Bad: g is not gsignal, not g0, not curg. What is it?
	// Hide call from linker nosplit analysis.
	MOVV	$runtime·badsystemstack(SB), R7
	JAL	(R7)
	JAL	runtime·abort(SB)

switch:

	MOVV	m_vdsoPC(R17), R2
	MOVV	m_vdsoSP(R17), R3
	MOVV	R2, 8(R29)
	MOVV	R3, 16(R29)

	MOVV	$ret-8(FP), R2 // caller's SP
	MOVV	R31, m_vdsoPC(R17)
	MOVV	R2, m_vdsoSP(R17)

	MOVV	m_curg(R17), R4
	MOVV	g, R5
	BNE	R4, R5, noswitch

	MOVV	m_g0(R17), R4
	MOVV	(g_sched+gobuf_sp)(R4), R1	// Set SP to g0 stack

noswitch:
	SUBV	$16, R1
	AND	$~15, R1	// Align for C code
	MOVV	R1, R29