// arm64:`MOVW\tR27, command-line-arguments\.x`, `MOVW\tR27, command-line-arguments\.y`, -`MOVW\tR27, command-line-arguments\.z`
	x, y, z := p1, p2, p3
	addrTaken(&z)
	// x is dead at the call (the value of x is loaded before the CALL), y is not
	// amd64:`MOVL\t\$3735936685, command-line-arguments\.x`, -`MOVL\t\$3735936685, command-line-arguments\.y`

	MOV	0(X9), X10		// arg 1 - addr
	MOV	8(X9), X11		// arg 2 - len
	MOVW	16(X9), X12		// arg 3 - prot
	MOVW	20(X9), X13		// arg 4 - flags
	MOVW	24(X9), X14		// arg 5 - fid
	MOVW	28(X9), X15		// arg 6 - offset
	CALL	libc_mmap(SB)
	MOV	$0, X5
	MOV	$-1, X6
	BNE	X6, X10, noerr
	CALL	libc_errno(SB)
	MOVW	(X10), X5		// errno
	MOV	$0, X10
noerr:
	MOV	X10, 32(X9)
	MOV	X5, 40(X9)
	RET

	MOVW	name+0(FP), R4
	MOVW	mode+4(FP), R5
	MOVW	perm+8(FP), R6
	MOVW	$SYS_open, R2
	SYSCALL
	BEQ	R7, 2(PC)
	MOVW	$-1, R2
	MOVW	R2, ret+12(FP)
	RET

TEXT runtime·closefd(SB),NOSPLIT,$0-8
	MOVW	fd+0(FP), R4
	MOVW	$SYS_close, R2
	SYSCALL
	BEQ	R7, 2(PC)
	MOVW	$-1, R2
	MOVW	R2, ret+4(FP)
	RET

TEXT runtime·write1(SB),NOSPLIT,$0-16
	MOVW	fd+0(FP), R4
	MOVW	p+4(FP), R5
	MOVW	n+8(FP), R6

	MOVW	off+20(FP), R5
	MOVW	$SYS_mmap2, R7
	SWI	$0
	MOVW	$0xfffff001, R6
	CMP		R6, R0
	MOVW	$0, R1
	RSB.HI	$0, R0
	MOVW.HI	R0, R1		// if error, put in R1
	MOVW.HI	$0, R0
	MOVW	R0, p+24(FP)
	MOVW	R1, err+28(FP)
	RET

TEXT runtime·munmap(SB),NOSPLIT,$0
	MOVW	addr+0(FP), R0
	MOVW	n+4(FP), R1
	MOVW	$SYS_munmap, R7
	SWI	$0
	MOVW	$0xfffff001, R6
	CMP 	R6, R0

env GO111MODULE=off

# Issue 27665. Verify that "go vet" analyzes non-Go files.

[!GOARCH:amd64] skip
! go vet -asmdecl a
stderr 'f: invalid MOVW of x'

# -c flag shows context
! go vet -c=2 -asmdecl a
stderr '...invalid MOVW...'
stderr '1	.*TEXT'
stderr '2		MOVW'
stderr '3		RET'
stderr '4'

# -json causes success, even with diagnostics and errors.
go vet -json -asmdecl a
stderr '"a": {'
stderr   '"asmdecl":'

#include "textflag.h"

TEXT cas<>(SB),NOSPLIT,$0
	MOVW	$0xffff0fc0, R15 // R15 is PC

TEXT ·RewindAndSetgid(SB),NOSPLIT|NOFRAME,$0-0
	// Save link register
	MOVW	R14, R4

	// Rewind stack pointer so anything that happens on the stack
	// will clobber the test pattern created by the caller
	ADD	$(1024 * 8), R13

	// Ask signaller to setgid
	MOVW	$·Baton(SB), R2
storeloop:
	MOVW	0(R2), R0
	MOVW	$1, R1
	BL	cas<>(SB)

	MOVW	$0, R1
	MOVW.CS R0, R1	// if error, move to R1
	MOVW.CS $0, R0
	MOVW	R0, p+24(FP)
	MOVW	R1, err+28(FP)
	RET

TEXT runtime·munmap(SB),NOSPLIT,$0
	MOVW addr+0(FP), R0	// arg 1 - addr
	MOVW n+4(FP), R1	// arg 2 - len
	SWI $SYS_munmap
	MOVW.CS $0, R8	// crash on syscall failure
	MOVW.CS R8, (R8)
	RET

TEXT runtime·madvise(SB),NOSPLIT,$0
	MOVW	addr+0(FP), R0	// arg 1 - addr

	NO_LOCAL_POINTERS
	JAL	runtime·entersyscall(SB)
	MOVW	a1+4(FP), R4
	MOVW	a2+8(FP), R5
	MOVW	a3+12(FP), R6
	MOVW	a4+16(FP), R7
	MOVW	a5+20(FP), R8
	MOVW	a6+24(FP), R9
	MOVW	a7+28(FP), R10
	MOVW	a8+32(FP), R11
	MOVW	R8, 16(R29)
	MOVW	R9, 20(R29)
	MOVW	R10, 24(R29)
	MOVW	R11, 28(R29)
	MOVW	trap+0(FP), R2	// syscall entry
	MOVW	R0, R3	// reset R3 to zero as 1-ret SYSCALL keeps it
	SYSCALL
	BEQ	R7, ok9

	MOVW	$0, R11
	MOVW	R11, (g_sched+gobuf_lr)(g)

	// Switch to m->g0 & its stack, call fn.
	MOVW	g, R1
	MOVW	g_m(g), R8
	MOVW	m_g0(R8), R0
	BL	setg<>(SB)
	CMP	g, R1
	B.NE	2(PC)
	B	runtime·badmcall(SB)
	MOVW	fn+0(FP), R0
	MOVW	(g_sched+gobuf_sp)(g), R13
	SUB	$8, R13
	MOVW	R1, 4(R13)
	MOVW	R0, R7
	MOVW	0(R0), R0
	BL	(R0)
	B	runtime·badmcall2(SB)
	RET

	MOVW	R28, 96(R29)
	// R29 is SP.
	// R30 is g.
	// R31 is LR, which was saved by the prologue.

	CALL	runtime·wbBufFlush(SB)

	MOVW	4(R29), R20
	MOVW	8(R29), R21
	MOVW	12(R29), R3
	MOVW	16(R29), R4
	MOVW	20(R29), R5
	MOVW	24(R29), R6
	MOVW	28(R29), R7
	MOVW	32(R29), R8
	MOVW	36(R29), R9
	MOVW	40(R29), R10
	MOVW	44(R29), R11
	MOVW	48(R29), R12
	MOVW	52(R29), R13
	MOVW	56(R29), R14