LSL	$3, R4
	ADD	$(8*8), R12, R5
	MOVD	$0, R6
	MOVD	RSP, R8
stackargs:
	MOVD	(R6)(R5), R7
	MOVD	R7, (R6)(R8)
	ADD	$8, R6
	CMP	R6, R4
	BNE	stackargs

_8args:
	MOVD	(7*8)(R12), R7
_7args:
	MOVD	(6*8)(R12), R6
_6args:
	MOVD	(5*8)(R12), R5
_5args:
	MOVD	(4*8)(R12), R4
_4args:
	MOVD	(3*8)(R12), R3
_3args:
	MOVD	(2*8)(R12), R2
_2args:
	MOVD	(1*8)(R12), R1
_1args:
	MOVD	(0*8)(R12), R0

	MOVD	R2, addr-48(SP)
	MOVD	R3, n-40(SP)
	MOVD	R4, prot-32(SP)
	MOVD	R5, flags-24(SP)
	MOVD	R6, fd-16(SP)
	MOVD	R7, off-8(SP)

	MOVD	$addr-48(SP), R2
	MOVW	$SYS_mmap, R1
	SYSCALL
	MOVD	$-4095, R3
	CMPUBLT	R2, R3, ok
	NEG	R2
	MOVD	$0, p+32(FP)
	MOVD	R2, err+40(FP)
	RET
ok:
	MOVD	R2, p+32(FP)
	MOVD	$0, err+40(FP)
	RET

	MOVW	off+28(FP), R5
	MOVD	$SYS_mmap, R8
	SVC
	BCS	fail
	MOVD	R0, p+32(FP)
	MOVD	$0, err+40(FP)
	RET
fail:
	MOVD	$0, p+32(FP)
	MOVD	R0, err+40(FP)
	RET

// func munmap(addr uintptr, n uintptr) (err error)
TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0
	MOVD	addr+0(FP), R0
	MOVD	n+8(FP), R1
	MOVD	$SYS_munmap, R8
	SVC
	BCS	fail
	RET
fail:
	MOVD	$0, R0
	MOVD	R0, (R0)	// crash

	MOVD	R27, (offset+8*13)(R1) \
	MOVD	R28, (offset+8*14)(R1) \
	MOVD	R29, (offset+8*15)(R1) \
	MOVD	g,   (offset+8*16)(R1) \
	MOVD	R31, (offset+8*17)(R1)

#define RESTORE_GPR(offset)            \
	MOVD	(offset+8*0)(R1), R14  \
	MOVD	(offset+8*1)(R1), R15  \
	MOVD	(offset+8*2)(R1), R16  \
	MOVD	(offset+8*3)(R1), R17  \
	MOVD	(offset+8*4)(R1), R18  \
	MOVD	(offset+8*5)(R1), R19  \
	MOVD	(offset+8*6)(R1), R20  \

	CMP $0, R0
	BNE nofp
	MOVW FPCR, R0
	MOVW R0, 56(R13)
	MOVD F0, 60(R13)
	MOVD F1, 68(R13)
	MOVD F2, 76(R13)
	MOVD F3, 84(R13)
	MOVD F4, 92(R13)
	MOVD F5, 100(R13)
	MOVD F6, 108(R13)
	MOVD F7, 116(R13)
	MOVD F8, 124(R13)
	MOVD F9, 132(R13)
	MOVD F10, 140(R13)
	MOVD F11, 148(R13)
	MOVD F12, 156(R13)
	MOVD F13, 164(R13)
	MOVD F14, 172(R13)
	MOVD F15, 180(R13)
nofp:
	CALL ·asyncPreempt2(SB)

	MOVD	$__asan_register_globals_go(SB), FARG
	JMP	asancall<>(SB)

// Switches SP to g0 stack and calls (FARG). Arguments already set.
TEXT	asancall<>(SB), NOSPLIT, $0-0
	MOVD	RSP, R19                  // callee-saved
	CBZ	g, g0stack                // no g, still on a system stack
	MOVD	g_m(g), R10
	MOVD	m_g0(R10), R11
	CMP	R11, g
	BEQ	g0stack

	MOVD	(g_sched+gobuf_sp)(R11), R5
	MOVD	R5, RSP

g0stack:
	BL	(FARG)

	// a crash.
	MOVD	R1, R6				// Save target function.
	MOVD	R14, R7				// Save PC.
	MOVD	$__tsan_go_ignore_sync_begin(SB), R1
	MOVD	g_racectx(g), R2		// ThreadState *.
	BL	racecall<>(SB)
	MOVD	R6, R1				// Restore target function.
	MOVD	g_racectx(g), R2		// ThreadState *.
	MOVD	8(R15), R3			// Caller PC.
	MOVD	R7, R4				// PC.
	ADD	$24, R15, R5			// Arguments.
	BL	racecall<>(SB)

	MOVD	ZR, g

	MOVD	R0, _rt0_arm64_linux_lib_argc<>(SB)
	MOVD	R1, _rt0_arm64_linux_lib_argv<>(SB)

	// Synchronous initialization.
	MOVD	$runtime·libpreinit(SB), R4
	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_linux_lib_go(SB), R0
	MOVD	$0, R1

	MOVD $0, R7 // i = 0
	MOVD $0, R0 // make sure it's zero
	MOVD $0, R4 // c = 0

	MOVD   R5, R12
	AND    $-2, R12
	CMPBGE R5, $2, A6
	BR     E6

A6:
	MOVD   (R8)(R1*1), R6
	MULHDU R9, R6
	MOVD   (R2)(R1*1), R10
	ADDC   R10, R11        // add to low order bits
	ADDE   R0, R6
	ADDC   R4, R11
	ADDE   R0, R6
	MOVD   R6, R4
	MOVD   R11, (R2)(R1*1)

	MOVD   (8)(R8)(R1*1), R6
	MULHDU R9, R6

	MOVW PSALAA, R8
	MOVD LCA64(R8), R8
	MOVD SAVSTACK_ASYNC(R8), R9
	MOVD R15, 0(R9)

	MOVD argv+8(FP), R1   // Move function arguments into registers
	MOVD dsa+16(FP), g
	MOVD fnptr+0(FP), R15

	BYTE $0x0D // Branch to function
	BYTE $0xEF

	BL   runtime·load_g(SB)     // Restore g and stack pointer
	MOVW PSALAA, R8
	MOVD LCA64(R8), R8
	MOVD SAVSTACK_ASYNC(R8), R9
	MOVD 0(R9), R15