MOVD	(g), F3                                   // 003b9aed
	MOVF	0x20(R3), F9       // MOVF 32(R3), F9     // 089a93ed
	MOVD.EQ	0x20(R4), F9       // MOVD.EQ 32(R4), F9  // 089b940d
	MOVF.NE	-0x20(g), F3       // MOVF.NE -32(g), F3  // 083a1a1d
	MOVD	-0x20(g), F3       // MOVD -32(g), F3     // 083b1aed
	MOVF	F9, (R4)                                  // 009a84ed
	MOVD.EQ	F9, (R4)                                  // 009b840d

/*
 * void crosscall1(void (*fn)(void), void (*setg_gcc)(void *g), void *g)
 *
 * Calling into the gc tool chain, where all registers are caller save.
 * Called from standard RISCV ELF psABI, where x8-x9, x18-x27, f8-f9 and
 * f18-f27 are callee-save, so they must be saved explicitly, along with
 * x1 (LR).
 */
.globl crosscall1
crosscall1:
	sd	x1, -200(sp)
	addi	sp, sp, -200
	sd	x8, 8(sp)
	sd	x9, 16(sp)
	sd	x18, 24(sp)

}

func f8() {
	s := S3{1, 2, 3, 4}
	var i I2 = &s
	i.Put(5)
	check(i.Get() == 4, "f8 i")
	check(s.l == 4, "f8 s")
}

func f9() {
	s := &S3{1, 2, 3, 4}
	var i I2 = s
	i.Put(5)
	check(i.Get() == 4, "f9 i")
	check(s.l == 4, "f9 s")
}

type S4 struct { i, j, k, l int64 }
func (p *S4) Get() int64 { return p.l }
func (p *S4) Put(i int64) { p.l = i }

	func F1() (*T1, *T2)

	// F10 should not be associated with T1. 
	func F10() (T1, T2, error)

	// F4 should not be associated with a type (same as F1) 
	func F4() (a T1, b T2)

	// F9 should not be associated with T1. 
	func F9() (int, T1, T2)


TYPES
	// 
	type T1 struct{}

	// F2 should be associated with T1 
	func F2() (a, b, c T1)

	// F3 should be associated with T1 because b.T3 is from a ...

	FMULD	F3, F5		// F5 = lo = float64(int(k)) * Ln2Lo
	FSUBD	F5, F4, F6	// F6 = r = hi - lo
	FMULD	F6, F6, F7	// F7 = t = r * r
	// compute y
	FMOVD	$P5, F8		// F8 = P5
	FMOVD	$P4, F9		// F9 = P4
	FMADDD	F7, F9, F8, F13	// P4+t*P5
	FMOVD	$P3, F10	// F10 = P3
	FMADDD	F7, F10, F13, F13	// P3+t*(P4+t*P5)
	FMOVD	$P2, F11	// F11 = P2
	FMADDD	F7, F11, F13, F13	// P2+t*(P3+t*(P4+t*P5))
	FMOVD	$P1, F12	// F12 = P1

	var f8 float32 = 8.0
	var f9 float32 = 9.0
	var f10 float32 = 10.0
	var f11 float32 = 11.0
	var f12 float32 = 12.0
	var f13 float32 = 13.0
	var f14 float32 = 14.0
	var f15 float32 = 15.0
	var f16 float32 = 16.0
	i0 = int(f0)
	i1 = int(f1)
	i2 = int(f2)
	i3 = int(f3)
	i4 = int(f4)
	i5 = int(f5)
	i6 = int(f6)
	i7 = int(f7)
	i8 = int(f8)
	i9 = int(f9)
	i10 = int(f10)
	i11 = int(f11)

	func F1() (*T1, *T2)

	// F10 should not be associated with T1. 
	func F10() (T1, T2, error)

	// F4 should not be associated with a type (same as F1) 
	func F4() (a T1, b T2)

	// F9 should not be associated with T1. 
	func F9() (int, T1, T2)


TYPES
	// 
	type T1 struct{}

	// F2 should be associated with T1 
	func F2() (a, b, c T1)

	// F3 should be associated with T1 because b.T3 is from a ...

	FMOVD F7, 176(R15)
	FMOVD F8, 184(R15)
	FMOVD F9, 192(R15)
	FMOVD F10, 200(R15)
	FMOVD F11, 208(R15)
	FMOVD F12, 216(R15)
	FMOVD F13, 224(R15)
	FMOVD F14, 232(R15)
	FMOVD F15, 240(R15)
	CALL ·asyncPreempt2(SB)
	FMOVD 240(R15), F15
	FMOVD 232(R15), F14
	FMOVD 224(R15), F13
	FMOVD 216(R15), F12
	FMOVD 208(R15), F11
	FMOVD 200(R15), F10
	FMOVD 192(R15), F9
	FMOVD 184(R15), F8
	FMOVD 176(R15), F7

}


func f8(a int) (x int, y float32) {
	return 8, 8.0
}

type T struct {
	x, y int
}

func (t *T) m10(a int, b float32) int {
	return (t.x + a) * (t.y + int(b))
}


func f9(a int) (i int, f float32) {
	i = 9
	f = 9.0
	return
}


func main() {
	f1()
	f2(1)
	r3 := f3(1, 2)
	assertequal(r3, 3, "3")
	r4 := f4(0, 2, 3.0)
	assertequal(r4, 4, "4")
	r5 := f5(1)

00000370  73 68 00 5b c3 83 17 60  51 b1 03 8d c3 f9 e1 e8  |sh.[...`Q.......|
00000380  f7 e7 a8 f4 94 b7 4f c1  bf aa 50 49 61 b1 11 0a  |......O...PIa...|
00000390  78 24 cc 16 3b e5 10 72  95 df e4 a3 5d 2c ff ad  |x$..;..r....],..|
000003a0  bd 50 04 93 3c 3c 48 28  0b e3 d9 d3 db 4d 4a 8f  |.P..<<H(.....MJ.|
000003b0  62 17 03 03 00 35 b2 f4  32 f5 f9 b9 f3 cc 15 d5  |b....5..2.......|