CALL	(R18)

	// fn should never return.
	MOVV	$2, R8			// crash if reached
	MOVV	R8, (R8)
	RET

TEXT runtime·sigaltstack(SB),NOSPLIT,$0
	MOVV	new+0(FP), R4		// arg 1 - new sigaltstack
	MOVV	old+8(FP), R5		// arg 2 - old sigaltstack
	MOVV	$288, R2		// sys_sigaltstack
	SYSCALL
	BEQ	R7, 3(PC)
	MOVV	$0, R8			// crash on syscall failure
	MOVV	R8, (R8)
	RET

TEXT runtime·osyield(SB),NOSPLIT,$0

TEXT ·Syscall6(SB),NOSPLIT,$0-80
	JMP	syscall·Syscall6(SB)

TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
	JAL	runtime·entersyscall(SB)
	MOVV	a1+8(FP), R4
	MOVV	a2+16(FP), R5
	MOVV	a3+24(FP), R6
	MOVV	R0, R7
	MOVV	R0, R8
	MOVV	R0, R9
	MOVV	trap+0(FP), R11	// syscall entry
	SYSCALL
	MOVV	R4, r1+32(FP)
	MOVV	R0, r2+40(FP)	// r2 is not used. Always set to 0
	JAL	runtime·exitsyscall(SB)
	RET

TEXT ·RawSyscall(SB),NOSPLIT,$0-56

	ADR	ret_sled, R30
	// Clear the lowest 2 bits of fakePC. All ARM64 instructions are four
	// bytes long, so we cannot get better return address granularity than
	// multiples of 4.
	AND	$-4, R8, R8
	// Add the offset of the fake_pc-th ret.
	ADD	R8, R30, R30
	// Call the function by jumping to it and reusing all registers except
	// for the modified return address register R30.
	JMP	(R9)

func (c *sigctxt) r5() uint32  { return c.regs().r5 }
func (c *sigctxt) r6() uint32  { return c.regs().r6 }
func (c *sigctxt) r7() uint32  { return c.regs().r7 }
func (c *sigctxt) r8() uint32  { return c.regs().r8 }
func (c *sigctxt) r9() uint32  { return c.regs().r9 }
func (c *sigctxt) r10() uint32 { return c.regs().r10 }
func (c *sigctxt) fp() uint32  { return c.regs().fp }

	FMOVD	F16, R0
	AND	$FracMask, R0, R2	// fraction
	LSR	$52, R0, R5	// exponent
	ADD	R1, R5		// R1 = int(k)
	CMP	$1, R5
	BGE	normal
	ADD	$52, R5		// denormal
	MOVD	$C1, R8
	FMOVD	R8, F1		// m = 2**-52
normal:
	ORR	R5<<52, R2, R0
	FMOVD	R0, F0
	FMULD	F1, F0		// return m * x
	FMOVD	F0, ret+8(FP)
	RET
nearzero:
	FADDD	F1, F0
isNaN:
	FMOVD	F0, ret+8(FP)
	RET
underflow:

	MOVQ	m_curg(AX), CX
	TESTQ	CX, CX
	JZ	sigtramp        // g.m.curg == nil
	MOVQ	g_syscallsp(CX), CX
	TESTQ	CX, CX
	JZ	sigtramp        // g.m.curg.syscallsp == 0
	MOVQ	m_cgoCallers(AX), R8
	TESTQ	R8, R8
	JZ	sigtramp        // g.m.cgoCallers == nil
	MOVL	m_cgoCallersUse(AX), CX
	TESTL	CX, CX
	JNZ	sigtramp	// g.m.cgoCallersUse != 0

	// Jump to a function in runtime/cgo.

	VEXP2PD (R14), K2, Z17                             // 62c2fd4ac80e
	VEXP2PD -7(DI)(R8*8), K2, Z17                      // 62a2fd4ac88cc7f9ffffff
	VEXP2PD Z31, K2, Z23                               // 6282fd4ac8ff
	VEXP2PD Z0, K2, Z23                                // 62e2fd4ac8f8
	VEXP2PD (R14), K2, Z23                             // 62c2fd4ac83e
	VEXP2PD -7(DI)(R8*8), K2, Z23                      // 62a2fd4ac8bcc7f9ffffff

	MOVQ	m_curg(AX), CX
	TESTQ	CX, CX
	JZ	sigtramp        // g.m.curg == nil
	MOVQ	g_syscallsp(CX), CX
	TESTQ	CX, CX
	JZ	sigtramp        // g.m.curg.syscallsp == 0
	MOVQ	m_cgoCallers(AX), R8
	TESTQ	R8, R8
	JZ	sigtramp        // g.m.cgoCallers == nil
	MOVL	m_cgoCallersUse(AX), CX
	TESTL	CX, CX
	JNZ	sigtramp	// g.m.cgoCallersUse != 0

	// Jump to a function in runtime/cgo.

	MOVL	b, R9; \
	XORL	c, R9; \
	XORL	d, R9

#define FUNC3(a, b, c, d, e) \
	MOVL	b, R8; \
	ORL	c, R8; \
	ANDL	d, R8; \
	MOVL	b, R9; \
	ANDL	c, R9; \
	ORL	R8, R9

#define FUNC4 FUNC2

#define MIX(a, b, c, d, e, const) \
	ROLL	$30, b; \
	ADDL	R9, e; \
	MOVL	a, R8; \
	ROLL	$5, R8; \
	LEAL	const(e)(R10*1), e; \
	ADDL	R8, e

#define ROUND1(a, b, c, d, e, index) \
	LOAD(index); \
	FUNC1(a, b, c, d, e); \

//

// func rawVforkSyscall(trap, a1, a2, a3 uintptr) (r1, err uintptr)
TEXT ·rawVforkSyscall(SB),NOSPLIT,$0-48
	MOVV	a1+8(FP), R4
	MOVV	a2+16(FP), R5
	MOVV	a3+24(FP), R6
	MOVV	$0, R7
	MOVV	$0, R8
	MOVV	$0, R9
	MOVV	trap+0(FP), R11	// syscall entry
	SYSCALL
	MOVW	$-4096, R12
	BGEU	R12, R4, ok
	MOVV	$-1, R12
	MOVV	R12, r1+32(FP)	// r1
	SUBVU	R4, R0, R4
	MOVV	R4, err+40(FP)	// errno
	RET
ok: