TEXT	runtime·doasanread(SB), NOSPLIT, $0-32
	MOV	addr+0(FP), X10
	MOV	sz+8(FP), X11
	MOV	sp+16(FP), X12
	MOV	pc+24(FP), X13
	// void __asan_read_go(void *addr, uintptr_t sz);
	MOV	$__asan_read_go(SB), X14
	JMP	asancall<>(SB)

// func runtime·doasanwrite(addr unsafe.Pointer, sz, sp, pc uintptr)
TEXT	runtime·doasanwrite(SB), NOSPLIT, $0-32
	MOV	addr+0(FP), X10
	MOV	sz+8(FP), X11
	MOV	sp+16(FP), X12
	MOV	pc+24(FP), X13

	MOV	(0*8)(X20), X5
	MOV	(1*8)(X20), X6
	MOV	(2*8)(X20), X7
	MOV	(3*8)(X20), X8
	ADD	X5, X10		// H0 = a + H0
	ADD	X6, X11		// H1 = b + H1
	ADD	X7, X12		// H2 = c + H2
	ADD	X8, X13		// H3 = d + H3
	MOV	X10, (0*8)(X20)
	MOV	X11, (1*8)(X20)
	MOV	X12, (2*8)(X20)
	MOV	X13, (3*8)(X20)
	MOV	(4*8)(X20), X5
	MOV	(5*8)(X20), X6
	MOV	(6*8)(X20), X7
	MOV	(7*8)(X20), X8

finish:
	MOV	8(X2), T0	// sec
	MOV	16(X2), T1	// nsec
	// restore stack
	MOV	S2, X2
	MOV	24(X2), T2
	MOV	T2, m_vdsoPC(S3)

	MOV	32(X2), T2
	MOV	T2, m_vdsoSP(S3)
	// sec is in T0, nsec in T1
	// return nsec in T0
	MOV	$1000000000, T2
	MUL	T2, T0
	ADD	T1, T0
	MOV	T0, ret+0(FP)
	RET

fallback:
	MOV	$8(X2), A1
	MOV	$SYS_clock_gettime, A7
	ECALL
	MOV	8(X2), T0	// sec

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
	JALR	RA, T0

restore:
	// Restore callee-save registers, along with X1 (LR).
	MOV	(8*3)(X2), X1
	MOV	(8*4)(X2), X8
	MOV	(8*5)(X2), X9
	MOV	(8*6)(X2), X18
	MOV	(8*7)(X2), X19
	MOV	(8*8)(X2), X20
	MOV	(8*9)(X2), X21
	MOV	(8*10)(X2), X22
	MOV	(8*11)(X2), X23

TEXT runtime·usleep(SB),NOSPLIT,$24-4
	MOVWU	usec+0(FP), A0
	MOV	$1000, A1
	MUL	A1, A0, A0
	MOV	$1000000000, A1
	DIV	A1, A0, A2
	MOV	A2, 8(X2)
	REM	A1, A0, A3
	MOV	A3, 16(X2)
	ADD	$8, X2, A0
	MOV	ZERO, A1
	MOV	$SYS_nanosleep, T0
	ECALL
	RET

// func thr_self() thread
TEXT runtime·thr_self(SB),NOSPLIT,$8-8
	MOV	$ptr-8(SP), A0	// arg 1 &8(SP)
	MOV	$SYS_thr_self, T0
	ECALL
	MOV	ptr-8(SP), A0

	 * 8(X2).
	 */
	ADD	$(-8*29), X2
	MOV	X10, (8*1)(X2) // fn unsafe.Pointer
	MOV	X11, (8*2)(X2) // a unsafe.Pointer
	MOV	X13, (8*3)(X2) // ctxt uintptr
	MOV	X8, (8*4)(X2)
	MOV	X9, (8*5)(X2)
	MOV	X18, (8*6)(X2)
	MOV	X19, (8*7)(X2)
	MOV	X20, (8*8)(X2)
	MOV	X21, (8*9)(X2)
	MOV	X22, (8*10)(X2)
	MOV	X23, (8*11)(X2)
	MOV	X24, (8*12)(X2)
	MOV	X25, (8*13)(X2)
	MOV	X26, (8*14)(X2)
	MOV	g, (8*15)(X2)
	MOV	X1, (8*16)(X2)

	BLT	X5, X6, compare16
compare32:
	MOV	0(X10), X15
	MOV	0(X12), X16
	MOV	8(X10), X17
	MOV	8(X12), X18
	BNE	X15, X16, cmp8a
	BNE	X17, X18, cmp8b
	MOV	16(X10), X15
	MOV	16(X12), X16
	MOV	24(X10), X17
	MOV	24(X12), X18
	BNE	X15, X16, cmp8a
	BNE	X17, X18, cmp8b
	ADD	$32, X10
	ADD	$32, X12
	SUB	$32, X5
	BGE	X5, X6, compare32
	BEQZ	X5, cmp_len

check16:
	MOV	$16, X6
	BLT	X5, X6, check8_unaligned

	MOV	$64, X9
	BLT	X11, X9, zero32
loop64:
	MOV	ZERO, 0(X10)
	MOV	ZERO, 8(X10)
	MOV	ZERO, 16(X10)
	MOV	ZERO, 24(X10)
	MOV	ZERO, 32(X10)
	MOV	ZERO, 40(X10)
	MOV	ZERO, 48(X10)
	MOV	ZERO, 56(X10)
	ADD	$64, X10
	SUB	$64, X11
	BGE	X11, X9, loop64
	BEQZ	X11, done

check32:
	MOV	$32, X9
	BLT	X11, X9, check16
zero32:
	MOV	ZERO, 0(X10)
	MOV	ZERO, 8(X10)
	MOV	ZERO, 16(X10)
	MOV	ZERO, 24(X10)

[short] skip
cd $GOPATH/src/example.com/cov

env GO111MODULE=on
go test -coverpkg=all ./...

env GO111MODULE=off
go test -coverpkg=all ./...

-- $GOPATH/src/example.com/cov/go.mod --
module example.com/cov

-- $GOPATH/src/example.com/cov/notest/notest.go --
package notest

func Foo() {}

-- $GOPATH/src/example.com/cov/onlytest/onlytest_test.go --
package onlytest_test

import (

	CALL	runtime·spillArgs(SB)
	MOV	CTXT, 32(SP) // save CTXT > args of moveMakeFuncArgPtrs < LOCAL_REGARGS
	MOV	CTXT, 8(SP)
	MOV	X25, 16(SP)
	CALL	·moveMakeFuncArgPtrs(SB)
	MOV	32(SP), CTXT // restore CTXT

	MOV	CTXT, 8(SP)
	MOV	$argframe+0(FP), T0
	MOV	T0, 16(SP)
	MOV	ZERO, LOCAL_RETVALID(SP)
	ADD	$LOCAL_RETVALID, SP, T1
	MOV	T1, 24(SP)
	ADD	$LOCAL_REGARGS, SP, T1
	MOV	T1, 32(SP)
	CALL	·callReflect(SB)