//      }
TEXT ·Cas(SB), NOSPLIT, $0-17
	MOV	ptr+0(FP), A0
	MOVW	old+8(FP), A1
	MOVW	new+12(FP), A2
cas_again:
	LRW	(A0), A3
	BNE	A3, A1, cas_fail
	SCW	A2, (A0), A4
	BNE	A4, ZERO, cas_again
	MOV	$1, A0
	MOVB	A0, ret+16(FP)
	RET
cas_fail:
	MOV	$0, A0
	MOV	A0, ret+16(FP)
	RET

// func Cas64(ptr *uint64, old, new uint64) bool
TEXT ·Cas64(SB), NOSPLIT, $0-25
	MOV	ptr+0(FP), A0
	MOV	old+8(FP), A1

	BNE	X19, X20, not_eq
	ADD	$1, X10
	ADD	$1, X11
	BNEZ	X9, align

loop32_check:
	MOV	$32, X9
	BLT	X12, X9, loop16_check
loop32:
	MOV	0(X10), X19
	MOV	0(X11), X20
	MOV	8(X10), X21
	MOV	8(X11), X22
	BNE	X19, X20, not_eq
	BNE	X21, X22, not_eq
	MOV	16(X10), X14
	MOV	16(X11), X15
	MOV	24(X10), X16
	MOV	24(X11), X17
	BNE	X14, X15, not_eq
	BNE	X16, X17, not_eq
	ADD	$32, X10
	ADD	$32, X11

TEXT ·rawVforkSyscall(SB),NOSPLIT|NOFRAME,$0-48
	MOV	a1+8(FP), A0
	MOV	a2+16(FP), A1
	MOV	a3+24(FP), A2
	MOV	ZERO, A3
	MOV	ZERO, A4
	MOV	ZERO, A5
	MOV	trap+0(FP), A7	// syscall entry
	ECALL
	MOV	$-4096, T0
	BLTU	T0, A0, err
	MOV	A0, r1+32(FP)	// r1
	MOV	ZERO, err+40(FP)	// errno
	RET
err:
	MOV	$-1, T0
	MOV	T0, r1+32(FP)	// r1
	SUB	A0, ZERO, A0
	MOV	A0, err+40(FP)	// errno
	RET

// err | A2          | part of A0
TEXT ·Syscall6<ABIInternal>(SB),NOSPLIT,$0-80
	MOV	A0, A7
	MOV	A1, A0
	MOV	A2, A1
	MOV	A3, A2
	MOV	A4, A3
	MOV	A5, A4
	MOV	A6, A5
	ECALL
	MOV	$-4096, T0
	BLTU	T0, A0, err
	// r1 already in A0
	// r2 already in A1
	MOV	ZERO, A2 // errno
	RET
err:
	SUB	A0, ZERO, A2 // errno
	MOV	$-1, A0	     // r1
	MOV	ZERO, A1     // r2

	MOV	a+0(FP), X5
	MOV	b+8(FP), X6
	MOV	$1, X7
	BGEU	X5, X6, b
	MOV	$0, X7
b:
	MOV	X7, r+16(FP)
	RET

// func testBGEZ(a int64) (r bool)
TEXT ·testBGEZ(SB),NOSPLIT,$0-9
	MOV	a+0(FP), X5
	MOV	$1, X6
	BGEZ	X5, b
	MOV	$0, X6
b:
	MOV	X6, r+8(FP)
	RET

// func testBGT(a, b int64) (r bool)
TEXT ·testBGT(SB),NOSPLIT,$0-17
	MOV	a+0(FP), X5
	MOV	b+8(FP), X6
	MOV	$1, X7
	BGT	X5, X6, b
	MOV	$0, X7

TEXT ·asyncPreempt(SB),NOSPLIT|NOFRAME,$0-0
	MOV X1, -464(X2)
	SUB $464, X2
	MOV X5, 8(X2)
	MOV X6, 16(X2)
	MOV X7, 24(X2)
	MOV X8, 32(X2)
	MOV X9, 40(X2)
	MOV X10, 48(X2)
	MOV X11, 56(X2)
	MOV X12, 64(X2)
	MOV X13, 72(X2)
	MOV X14, 80(X2)
	MOV X15, 88(X2)
	MOV X16, 96(X2)
	MOV X17, 104(X2)
	MOV X18, 112(X2)
	MOV X19, 120(X2)
	MOV X20, 128(X2)
	MOV X21, 136(X2)
	MOV X22, 144(X2)
	MOV X23, 152(X2)

	...
	$

4. Convert coverage data to legacy textual format:

	$ go tool covdata textfmt -i=profiledir -o=cov.txt
	$ head cov.txt
	mode: set
	cov-example/p/p.go:12.22,13.2 0 0
	cov-example/p/p.go:15.31,16.2 1 0
	cov-example/p/p.go:16.3,18.3 0 0
	cov-example/p/p.go:19.3,21.3 0 0
	...
	$ go tool cover -html=cov.txt
	$

5. Merge profiles together:

[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/mainonly/mainonly.go --
package main

func main() {}

-- $GOPATH/src/example.com/cov/mainwithtest/mainwithtest.go --
package main

func main() {}

	BEQZ	X30, done
loop:
	MOV	0*8(X5), X10	// z[0]
	MOV	1*8(X5), X13	// z[1]
	MOV	2*8(X5), X16	// z[2]
	MOV	3*8(X5), X19	// z[3]

	MOV	0*8(X7), X8	// x[0]
	MOV	1*8(X7), X11	// x[1]
	MOV	2*8(X7), X14	// x[2]
	MOV	3*8(X7), X17	// x[3]

	MULHU	X8, X6, X9	// z_hi[0] = x[0] * y
	MUL	X8, X6, X8	// z_lo[0] = x[0] * y
	ADD	X8, X10, X21	// z_lo[0] = x[0] * y + z[0]
	SLTU	X8, X21, X22
	ADD	X9, X22, X9	// z_hi[0] = x[0] * y + z[0]

	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)
	ADD	$8, X25
	MOV	ZERO, (X25)