internal/cabi: TestBuild TestABI

internal/cabi/_testdata/demo/array_float32.go

@@ -0,0 +1,359 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/array_float32.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type array1 struct {
+	x [1]float32
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a array1) array1
+
+func demo1(a array1) array1 {
+	return a
+}
+
+func init() {
+	a := array1{x: [1]float32{1}}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type array2 struct {
+	x [2]float32
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a array2) array2
+
+func demo2(a array2) array2 {
+	return a
+}
+
+func init() {
+	a := array2{x: [2]float32{1, 2}}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type array3 struct {
+	x [3]float32
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a array3) array3
+
+func demo3(a array3) array3 {
+	return a
+}
+
+func init() {
+	a := array3{x: [3]float32{1, 2, 3}}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type array4 struct {
+	x [4]float32
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a array4) array4
+
+func demo4(a array4) array4 {
+	return a
+}
+
+func init() {
+	a := array4{x: [4]float32{1, 2, 3, 4}}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type array5 struct {
+	x [5]float32
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a array5) array5
+
+func demo5(a array5) array5 {
+	return a
+}
+
+func init() {
+	a := array5{x: [5]float32{1, 2, 3, 4, 5}}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type array6 struct {
+	x [6]float32
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a array6) array6
+
+func demo6(a array6) array6 {
+	return a
+}
+
+func init() {
+	a := array6{x: [6]float32{1, 2, 3, 4, 5, 6}}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type array7 struct {
+	x [7]float32
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a array7) array7
+
+func demo7(a array7) array7 {
+	return a
+}
+
+func init() {
+	a := array7{x: [7]float32{1, 2, 3, 4, 5, 6, 7}}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type array8 struct {
+	x [8]float32
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a array8) array8
+
+func demo8(a array8) array8 {
+	return a
+}
+
+func init() {
+	a := array8{x: [8]float32{1, 2, 3, 4, 5, 6, 7, 8}}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type array9 struct {
+	x [9]float32
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a array9) array9
+
+func demo9(a array9) array9 {
+	return a
+}
+
+func init() {
+	a := array9{x: [9]float32{1, 2, 3, 4, 5, 6, 7, 8, 9}}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type array10 struct {
+	x [10]float32
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a array10) array10
+
+func demo10(a array10) array10 {
+	return a
+}
+
+func init() {
+	a := array10{x: [10]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type array11 struct {
+	x [11]float32
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a array11) array11
+
+func demo11(a array11) array11 {
+	return a
+}
+
+func init() {
+	a := array11{x: [11]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type array12 struct {
+	x [12]float32
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a array12) array12
+
+func demo12(a array12) array12 {
+	return a
+}
+
+func init() {
+	a := array12{x: [12]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type array13 struct {
+	x [13]float32
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a array13) array13
+
+func demo13(a array13) array13 {
+	return a
+}
+
+func init() {
+	a := array13{x: [13]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type array14 struct {
+	x [14]float32
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a array14) array14
+
+func demo14(a array14) array14 {
+	return a
+}
+
+func init() {
+	a := array14{x: [14]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type array15 struct {
+	x [15]float32
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a array15) array15
+
+func demo15(a array15) array15 {
+	return a
+}
+
+func init() {
+	a := array15{x: [15]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type array16 struct {
+	x [16]float32
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a array16) array16
+
+func demo16(a array16) array16 {
+	return a
+}
+
+func init() {
+	a := array16{x: [16]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type array17 struct {
+	x [17]float32
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a array17) array17
+
+func demo17(a array17) array17 {
+	return a
+}
+
+func init() {
+	a := array17{x: [17]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type array18 struct {
+	x [18]float32
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a array18) array18
+
+func demo18(a array18) array18 {
+	return a
+}
+
+func init() {
+	a := array18{x: [18]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type array19 struct {
+	x [19]float32
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a array19) array19
+
+func demo19(a array19) array19 {
+	return a
+}
+
+func init() {
+	a := array19{x: [19]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type array20 struct {
+	x [20]float32
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a array20) array20
+
+func demo20(a array20) array20 {
+	return a
+}
+
+func init() {
+	a := array20{x: [20]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/array_float64.go

@@ -0,0 +1,359 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/array_float64.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type array1 struct {
+	x [1]float64
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a array1) array1
+
+func demo1(a array1) array1 {
+	return a
+}
+
+func init() {
+	a := array1{x: [1]float64{1}}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type array2 struct {
+	x [2]float64
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a array2) array2
+
+func demo2(a array2) array2 {
+	return a
+}
+
+func init() {
+	a := array2{x: [2]float64{1, 2}}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type array3 struct {
+	x [3]float64
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a array3) array3
+
+func demo3(a array3) array3 {
+	return a
+}
+
+func init() {
+	a := array3{x: [3]float64{1, 2, 3}}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type array4 struct {
+	x [4]float64
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a array4) array4
+
+func demo4(a array4) array4 {
+	return a
+}
+
+func init() {
+	a := array4{x: [4]float64{1, 2, 3, 4}}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type array5 struct {
+	x [5]float64
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a array5) array5
+
+func demo5(a array5) array5 {
+	return a
+}
+
+func init() {
+	a := array5{x: [5]float64{1, 2, 3, 4, 5}}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type array6 struct {
+	x [6]float64
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a array6) array6
+
+func demo6(a array6) array6 {
+	return a
+}
+
+func init() {
+	a := array6{x: [6]float64{1, 2, 3, 4, 5, 6}}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type array7 struct {
+	x [7]float64
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a array7) array7
+
+func demo7(a array7) array7 {
+	return a
+}
+
+func init() {
+	a := array7{x: [7]float64{1, 2, 3, 4, 5, 6, 7}}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type array8 struct {
+	x [8]float64
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a array8) array8
+
+func demo8(a array8) array8 {
+	return a
+}
+
+func init() {
+	a := array8{x: [8]float64{1, 2, 3, 4, 5, 6, 7, 8}}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type array9 struct {
+	x [9]float64
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a array9) array9
+
+func demo9(a array9) array9 {
+	return a
+}
+
+func init() {
+	a := array9{x: [9]float64{1, 2, 3, 4, 5, 6, 7, 8, 9}}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type array10 struct {
+	x [10]float64
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a array10) array10
+
+func demo10(a array10) array10 {
+	return a
+}
+
+func init() {
+	a := array10{x: [10]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type array11 struct {
+	x [11]float64
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a array11) array11
+
+func demo11(a array11) array11 {
+	return a
+}
+
+func init() {
+	a := array11{x: [11]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type array12 struct {
+	x [12]float64
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a array12) array12
+
+func demo12(a array12) array12 {
+	return a
+}
+
+func init() {
+	a := array12{x: [12]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type array13 struct {
+	x [13]float64
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a array13) array13
+
+func demo13(a array13) array13 {
+	return a
+}
+
+func init() {
+	a := array13{x: [13]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type array14 struct {
+	x [14]float64
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a array14) array14
+
+func demo14(a array14) array14 {
+	return a
+}
+
+func init() {
+	a := array14{x: [14]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type array15 struct {
+	x [15]float64
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a array15) array15
+
+func demo15(a array15) array15 {
+	return a
+}
+
+func init() {
+	a := array15{x: [15]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type array16 struct {
+	x [16]float64
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a array16) array16
+
+func demo16(a array16) array16 {
+	return a
+}
+
+func init() {
+	a := array16{x: [16]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type array17 struct {
+	x [17]float64
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a array17) array17
+
+func demo17(a array17) array17 {
+	return a
+}
+
+func init() {
+	a := array17{x: [17]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type array18 struct {
+	x [18]float64
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a array18) array18
+
+func demo18(a array18) array18 {
+	return a
+}
+
+func init() {
+	a := array18{x: [18]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type array19 struct {
+	x [19]float64
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a array19) array19
+
+func demo19(a array19) array19 {
+	return a
+}
+
+func init() {
+	a := array19{x: [19]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type array20 struct {
+	x [20]float64
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a array20) array20
+
+func demo20(a array20) array20 {
+	return a
+}
+
+func init() {
+	a := array20{x: [20]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/array_int16.go

@@ -0,0 +1,359 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/array_int16.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type array1 struct {
+	x [1]int16
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a array1) array1
+
+func demo1(a array1) array1 {
+	return a
+}
+
+func init() {
+	a := array1{x: [1]int16{1}}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type array2 struct {
+	x [2]int16
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a array2) array2
+
+func demo2(a array2) array2 {
+	return a
+}
+
+func init() {
+	a := array2{x: [2]int16{1, 2}}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type array3 struct {
+	x [3]int16
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a array3) array3
+
+func demo3(a array3) array3 {
+	return a
+}
+
+func init() {
+	a := array3{x: [3]int16{1, 2, 3}}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type array4 struct {
+	x [4]int16
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a array4) array4
+
+func demo4(a array4) array4 {
+	return a
+}
+
+func init() {
+	a := array4{x: [4]int16{1, 2, 3, 4}}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type array5 struct {
+	x [5]int16
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a array5) array5
+
+func demo5(a array5) array5 {
+	return a
+}
+
+func init() {
+	a := array5{x: [5]int16{1, 2, 3, 4, 5}}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type array6 struct {
+	x [6]int16
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a array6) array6
+
+func demo6(a array6) array6 {
+	return a
+}
+
+func init() {
+	a := array6{x: [6]int16{1, 2, 3, 4, 5, 6}}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type array7 struct {
+	x [7]int16
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a array7) array7
+
+func demo7(a array7) array7 {
+	return a
+}
+
+func init() {
+	a := array7{x: [7]int16{1, 2, 3, 4, 5, 6, 7}}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type array8 struct {
+	x [8]int16
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a array8) array8
+
+func demo8(a array8) array8 {
+	return a
+}
+
+func init() {
+	a := array8{x: [8]int16{1, 2, 3, 4, 5, 6, 7, 8}}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type array9 struct {
+	x [9]int16
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a array9) array9
+
+func demo9(a array9) array9 {
+	return a
+}
+
+func init() {
+	a := array9{x: [9]int16{1, 2, 3, 4, 5, 6, 7, 8, 9}}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type array10 struct {
+	x [10]int16
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a array10) array10
+
+func demo10(a array10) array10 {
+	return a
+}
+
+func init() {
+	a := array10{x: [10]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type array11 struct {
+	x [11]int16
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a array11) array11
+
+func demo11(a array11) array11 {
+	return a
+}
+
+func init() {
+	a := array11{x: [11]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type array12 struct {
+	x [12]int16
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a array12) array12
+
+func demo12(a array12) array12 {
+	return a
+}
+
+func init() {
+	a := array12{x: [12]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type array13 struct {
+	x [13]int16
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a array13) array13
+
+func demo13(a array13) array13 {
+	return a
+}
+
+func init() {
+	a := array13{x: [13]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type array14 struct {
+	x [14]int16
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a array14) array14
+
+func demo14(a array14) array14 {
+	return a
+}
+
+func init() {
+	a := array14{x: [14]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type array15 struct {
+	x [15]int16
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a array15) array15
+
+func demo15(a array15) array15 {
+	return a
+}
+
+func init() {
+	a := array15{x: [15]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type array16 struct {
+	x [16]int16
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a array16) array16
+
+func demo16(a array16) array16 {
+	return a
+}
+
+func init() {
+	a := array16{x: [16]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type array17 struct {
+	x [17]int16
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a array17) array17
+
+func demo17(a array17) array17 {
+	return a
+}
+
+func init() {
+	a := array17{x: [17]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type array18 struct {
+	x [18]int16
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a array18) array18
+
+func demo18(a array18) array18 {
+	return a
+}
+
+func init() {
+	a := array18{x: [18]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type array19 struct {
+	x [19]int16
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a array19) array19
+
+func demo19(a array19) array19 {
+	return a
+}
+
+func init() {
+	a := array19{x: [19]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type array20 struct {
+	x [20]int16
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a array20) array20
+
+func demo20(a array20) array20 {
+	return a
+}
+
+func init() {
+	a := array20{x: [20]int16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/array_int32.go

@@ -0,0 +1,359 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/array_int32.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type array1 struct {
+	x [1]int32
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a array1) array1
+
+func demo1(a array1) array1 {
+	return a
+}
+
+func init() {
+	a := array1{x: [1]int32{1}}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type array2 struct {
+	x [2]int32
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a array2) array2
+
+func demo2(a array2) array2 {
+	return a
+}
+
+func init() {
+	a := array2{x: [2]int32{1, 2}}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type array3 struct {
+	x [3]int32
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a array3) array3
+
+func demo3(a array3) array3 {
+	return a
+}
+
+func init() {
+	a := array3{x: [3]int32{1, 2, 3}}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type array4 struct {
+	x [4]int32
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a array4) array4
+
+func demo4(a array4) array4 {
+	return a
+}
+
+func init() {
+	a := array4{x: [4]int32{1, 2, 3, 4}}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type array5 struct {
+	x [5]int32
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a array5) array5
+
+func demo5(a array5) array5 {
+	return a
+}
+
+func init() {
+	a := array5{x: [5]int32{1, 2, 3, 4, 5}}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type array6 struct {
+	x [6]int32
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a array6) array6
+
+func demo6(a array6) array6 {
+	return a
+}
+
+func init() {
+	a := array6{x: [6]int32{1, 2, 3, 4, 5, 6}}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type array7 struct {
+	x [7]int32
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a array7) array7
+
+func demo7(a array7) array7 {
+	return a
+}
+
+func init() {
+	a := array7{x: [7]int32{1, 2, 3, 4, 5, 6, 7}}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type array8 struct {
+	x [8]int32
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a array8) array8
+
+func demo8(a array8) array8 {
+	return a
+}
+
+func init() {
+	a := array8{x: [8]int32{1, 2, 3, 4, 5, 6, 7, 8}}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type array9 struct {
+	x [9]int32
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a array9) array9
+
+func demo9(a array9) array9 {
+	return a
+}
+
+func init() {
+	a := array9{x: [9]int32{1, 2, 3, 4, 5, 6, 7, 8, 9}}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type array10 struct {
+	x [10]int32
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a array10) array10
+
+func demo10(a array10) array10 {
+	return a
+}
+
+func init() {
+	a := array10{x: [10]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type array11 struct {
+	x [11]int32
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a array11) array11
+
+func demo11(a array11) array11 {
+	return a
+}
+
+func init() {
+	a := array11{x: [11]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type array12 struct {
+	x [12]int32
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a array12) array12
+
+func demo12(a array12) array12 {
+	return a
+}
+
+func init() {
+	a := array12{x: [12]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type array13 struct {
+	x [13]int32
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a array13) array13
+
+func demo13(a array13) array13 {
+	return a
+}
+
+func init() {
+	a := array13{x: [13]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type array14 struct {
+	x [14]int32
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a array14) array14
+
+func demo14(a array14) array14 {
+	return a
+}
+
+func init() {
+	a := array14{x: [14]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type array15 struct {
+	x [15]int32
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a array15) array15
+
+func demo15(a array15) array15 {
+	return a
+}
+
+func init() {
+	a := array15{x: [15]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type array16 struct {
+	x [16]int32
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a array16) array16
+
+func demo16(a array16) array16 {
+	return a
+}
+
+func init() {
+	a := array16{x: [16]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type array17 struct {
+	x [17]int32
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a array17) array17
+
+func demo17(a array17) array17 {
+	return a
+}
+
+func init() {
+	a := array17{x: [17]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type array18 struct {
+	x [18]int32
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a array18) array18
+
+func demo18(a array18) array18 {
+	return a
+}
+
+func init() {
+	a := array18{x: [18]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type array19 struct {
+	x [19]int32
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a array19) array19
+
+func demo19(a array19) array19 {
+	return a
+}
+
+func init() {
+	a := array19{x: [19]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type array20 struct {
+	x [20]int32
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a array20) array20
+
+func demo20(a array20) array20 {
+	return a
+}
+
+func init() {
+	a := array20{x: [20]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/array_int64.go

@@ -0,0 +1,359 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/array_int64.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type array1 struct {
+	x [1]int64
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a array1) array1
+
+func demo1(a array1) array1 {
+	return a
+}
+
+func init() {
+	a := array1{x: [1]int64{1}}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type array2 struct {
+	x [2]int64
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a array2) array2
+
+func demo2(a array2) array2 {
+	return a
+}
+
+func init() {
+	a := array2{x: [2]int64{1, 2}}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type array3 struct {
+	x [3]int64
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a array3) array3
+
+func demo3(a array3) array3 {
+	return a
+}
+
+func init() {
+	a := array3{x: [3]int64{1, 2, 3}}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type array4 struct {
+	x [4]int64
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a array4) array4
+
+func demo4(a array4) array4 {
+	return a
+}
+
+func init() {
+	a := array4{x: [4]int64{1, 2, 3, 4}}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type array5 struct {
+	x [5]int64
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a array5) array5
+
+func demo5(a array5) array5 {
+	return a
+}
+
+func init() {
+	a := array5{x: [5]int64{1, 2, 3, 4, 5}}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type array6 struct {
+	x [6]int64
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a array6) array6
+
+func demo6(a array6) array6 {
+	return a
+}
+
+func init() {
+	a := array6{x: [6]int64{1, 2, 3, 4, 5, 6}}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type array7 struct {
+	x [7]int64
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a array7) array7
+
+func demo7(a array7) array7 {
+	return a
+}
+
+func init() {
+	a := array7{x: [7]int64{1, 2, 3, 4, 5, 6, 7}}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type array8 struct {
+	x [8]int64
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a array8) array8
+
+func demo8(a array8) array8 {
+	return a
+}
+
+func init() {
+	a := array8{x: [8]int64{1, 2, 3, 4, 5, 6, 7, 8}}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type array9 struct {
+	x [9]int64
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a array9) array9
+
+func demo9(a array9) array9 {
+	return a
+}
+
+func init() {
+	a := array9{x: [9]int64{1, 2, 3, 4, 5, 6, 7, 8, 9}}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type array10 struct {
+	x [10]int64
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a array10) array10
+
+func demo10(a array10) array10 {
+	return a
+}
+
+func init() {
+	a := array10{x: [10]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type array11 struct {
+	x [11]int64
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a array11) array11
+
+func demo11(a array11) array11 {
+	return a
+}
+
+func init() {
+	a := array11{x: [11]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type array12 struct {
+	x [12]int64
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a array12) array12
+
+func demo12(a array12) array12 {
+	return a
+}
+
+func init() {
+	a := array12{x: [12]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type array13 struct {
+	x [13]int64
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a array13) array13
+
+func demo13(a array13) array13 {
+	return a
+}
+
+func init() {
+	a := array13{x: [13]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type array14 struct {
+	x [14]int64
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a array14) array14
+
+func demo14(a array14) array14 {
+	return a
+}
+
+func init() {
+	a := array14{x: [14]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type array15 struct {
+	x [15]int64
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a array15) array15
+
+func demo15(a array15) array15 {
+	return a
+}
+
+func init() {
+	a := array15{x: [15]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type array16 struct {
+	x [16]int64
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a array16) array16
+
+func demo16(a array16) array16 {
+	return a
+}
+
+func init() {
+	a := array16{x: [16]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type array17 struct {
+	x [17]int64
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a array17) array17
+
+func demo17(a array17) array17 {
+	return a
+}
+
+func init() {
+	a := array17{x: [17]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type array18 struct {
+	x [18]int64
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a array18) array18
+
+func demo18(a array18) array18 {
+	return a
+}
+
+func init() {
+	a := array18{x: [18]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type array19 struct {
+	x [19]int64
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a array19) array19
+
+func demo19(a array19) array19 {
+	return a
+}
+
+func init() {
+	a := array19{x: [19]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type array20 struct {
+	x [20]int64
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a array20) array20
+
+func demo20(a array20) array20 {
+	return a
+}
+
+func init() {
+	a := array20{x: [20]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/array_int8.go

@@ -0,0 +1,359 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/array_int8.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type array1 struct {
+	x [1]int8
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a array1) array1
+
+func demo1(a array1) array1 {
+	return a
+}
+
+func init() {
+	a := array1{x: [1]int8{1}}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type array2 struct {
+	x [2]int8
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a array2) array2
+
+func demo2(a array2) array2 {
+	return a
+}
+
+func init() {
+	a := array2{x: [2]int8{1, 2}}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type array3 struct {
+	x [3]int8
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a array3) array3
+
+func demo3(a array3) array3 {
+	return a
+}
+
+func init() {
+	a := array3{x: [3]int8{1, 2, 3}}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type array4 struct {
+	x [4]int8
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a array4) array4
+
+func demo4(a array4) array4 {
+	return a
+}
+
+func init() {
+	a := array4{x: [4]int8{1, 2, 3, 4}}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type array5 struct {
+	x [5]int8
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a array5) array5
+
+func demo5(a array5) array5 {
+	return a
+}
+
+func init() {
+	a := array5{x: [5]int8{1, 2, 3, 4, 5}}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type array6 struct {
+	x [6]int8
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a array6) array6
+
+func demo6(a array6) array6 {
+	return a
+}
+
+func init() {
+	a := array6{x: [6]int8{1, 2, 3, 4, 5, 6}}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type array7 struct {
+	x [7]int8
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a array7) array7
+
+func demo7(a array7) array7 {
+	return a
+}
+
+func init() {
+	a := array7{x: [7]int8{1, 2, 3, 4, 5, 6, 7}}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type array8 struct {
+	x [8]int8
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a array8) array8
+
+func demo8(a array8) array8 {
+	return a
+}
+
+func init() {
+	a := array8{x: [8]int8{1, 2, 3, 4, 5, 6, 7, 8}}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type array9 struct {
+	x [9]int8
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a array9) array9
+
+func demo9(a array9) array9 {
+	return a
+}
+
+func init() {
+	a := array9{x: [9]int8{1, 2, 3, 4, 5, 6, 7, 8, 9}}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type array10 struct {
+	x [10]int8
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a array10) array10
+
+func demo10(a array10) array10 {
+	return a
+}
+
+func init() {
+	a := array10{x: [10]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type array11 struct {
+	x [11]int8
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a array11) array11
+
+func demo11(a array11) array11 {
+	return a
+}
+
+func init() {
+	a := array11{x: [11]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type array12 struct {
+	x [12]int8
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a array12) array12
+
+func demo12(a array12) array12 {
+	return a
+}
+
+func init() {
+	a := array12{x: [12]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type array13 struct {
+	x [13]int8
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a array13) array13
+
+func demo13(a array13) array13 {
+	return a
+}
+
+func init() {
+	a := array13{x: [13]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type array14 struct {
+	x [14]int8
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a array14) array14
+
+func demo14(a array14) array14 {
+	return a
+}
+
+func init() {
+	a := array14{x: [14]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type array15 struct {
+	x [15]int8
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a array15) array15
+
+func demo15(a array15) array15 {
+	return a
+}
+
+func init() {
+	a := array15{x: [15]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type array16 struct {
+	x [16]int8
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a array16) array16
+
+func demo16(a array16) array16 {
+	return a
+}
+
+func init() {
+	a := array16{x: [16]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type array17 struct {
+	x [17]int8
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a array17) array17
+
+func demo17(a array17) array17 {
+	return a
+}
+
+func init() {
+	a := array17{x: [17]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type array18 struct {
+	x [18]int8
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a array18) array18
+
+func demo18(a array18) array18 {
+	return a
+}
+
+func init() {
+	a := array18{x: [18]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type array19 struct {
+	x [19]int8
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a array19) array19
+
+func demo19(a array19) array19 {
+	return a
+}
+
+func init() {
+	a := array19{x: [19]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type array20 struct {
+	x [20]int8
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a array20) array20
+
+func demo20(a array20) array20 {
+	return a
+}
+
+func init() {
+	a := array20{x: [20]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/array_uintptr.go

@@ -0,0 +1,359 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/array_uintptr.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type array1 struct {
+	x [1]uintptr
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a array1) array1
+
+func demo1(a array1) array1 {
+	return a
+}
+
+func init() {
+	a := array1{x: [1]uintptr{1}}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type array2 struct {
+	x [2]uintptr
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a array2) array2
+
+func demo2(a array2) array2 {
+	return a
+}
+
+func init() {
+	a := array2{x: [2]uintptr{1, 2}}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type array3 struct {
+	x [3]uintptr
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a array3) array3
+
+func demo3(a array3) array3 {
+	return a
+}
+
+func init() {
+	a := array3{x: [3]uintptr{1, 2, 3}}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type array4 struct {
+	x [4]uintptr
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a array4) array4
+
+func demo4(a array4) array4 {
+	return a
+}
+
+func init() {
+	a := array4{x: [4]uintptr{1, 2, 3, 4}}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type array5 struct {
+	x [5]uintptr
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a array5) array5
+
+func demo5(a array5) array5 {
+	return a
+}
+
+func init() {
+	a := array5{x: [5]uintptr{1, 2, 3, 4, 5}}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type array6 struct {
+	x [6]uintptr
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a array6) array6
+
+func demo6(a array6) array6 {
+	return a
+}
+
+func init() {
+	a := array6{x: [6]uintptr{1, 2, 3, 4, 5, 6}}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type array7 struct {
+	x [7]uintptr
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a array7) array7
+
+func demo7(a array7) array7 {
+	return a
+}
+
+func init() {
+	a := array7{x: [7]uintptr{1, 2, 3, 4, 5, 6, 7}}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type array8 struct {
+	x [8]uintptr
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a array8) array8
+
+func demo8(a array8) array8 {
+	return a
+}
+
+func init() {
+	a := array8{x: [8]uintptr{1, 2, 3, 4, 5, 6, 7, 8}}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type array9 struct {
+	x [9]uintptr
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a array9) array9
+
+func demo9(a array9) array9 {
+	return a
+}
+
+func init() {
+	a := array9{x: [9]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9}}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type array10 struct {
+	x [10]uintptr
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a array10) array10
+
+func demo10(a array10) array10 {
+	return a
+}
+
+func init() {
+	a := array10{x: [10]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type array11 struct {
+	x [11]uintptr
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a array11) array11
+
+func demo11(a array11) array11 {
+	return a
+}
+
+func init() {
+	a := array11{x: [11]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type array12 struct {
+	x [12]uintptr
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a array12) array12
+
+func demo12(a array12) array12 {
+	return a
+}
+
+func init() {
+	a := array12{x: [12]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type array13 struct {
+	x [13]uintptr
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a array13) array13
+
+func demo13(a array13) array13 {
+	return a
+}
+
+func init() {
+	a := array13{x: [13]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type array14 struct {
+	x [14]uintptr
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a array14) array14
+
+func demo14(a array14) array14 {
+	return a
+}
+
+func init() {
+	a := array14{x: [14]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type array15 struct {
+	x [15]uintptr
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a array15) array15
+
+func demo15(a array15) array15 {
+	return a
+}
+
+func init() {
+	a := array15{x: [15]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type array16 struct {
+	x [16]uintptr
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a array16) array16
+
+func demo16(a array16) array16 {
+	return a
+}
+
+func init() {
+	a := array16{x: [16]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type array17 struct {
+	x [17]uintptr
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a array17) array17
+
+func demo17(a array17) array17 {
+	return a
+}
+
+func init() {
+	a := array17{x: [17]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type array18 struct {
+	x [18]uintptr
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a array18) array18
+
+func demo18(a array18) array18 {
+	return a
+}
+
+func init() {
+	a := array18{x: [18]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type array19 struct {
+	x [19]uintptr
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a array19) array19
+
+func demo19(a array19) array19 {
+	return a
+}
+
+func init() {
+	a := array19{x: [19]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type array20 struct {
+	x [20]uintptr
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a array20) array20
+
+func demo20(a array20) array20 {
+	return a
+}
+
+func init() {
+	a := array20{x: [20]uintptr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/basic.go

@@ -0,0 +1,103 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/basic.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+//go:linkname cbasic_int8 C.basic_int8
+func cbasic_int8(a int8) int8
+
+func basic_int8(a int8) int8 {
+	return a
+}
+
+func init() {
+	assert("cbasic_int8\000", cbasic_int8(100) == 100)
+	assert("basic_int8\000", basic_int8(100) == 100)
+}
+
+//go:linkname cbasic_int16 C.basic_int16
+func cbasic_int16(a int16) int16
+
+func basic_int16(a int16) int16 {
+	return a
+}
+
+func init() {
+	assert("cbasic_int16\000", cbasic_int16(100) == 100)
+	assert("basic_int16\000", basic_int16(100) == 100)
+}
+
+//go:linkname cbasic_int32 C.basic_int32
+func cbasic_int32(a int32) int32
+
+func basic_int32(a int32) int32 {
+	return a
+}
+
+func init() {
+	assert("cbasic_int32\000", cbasic_int32(100) == 100)
+	assert("basic_int32\000", basic_int32(100) == 100)
+}
+
+//go:linkname cbasic_int64 C.basic_int64
+func cbasic_int64(a int64) int64
+
+func basic_int64(a int64) int64 {
+	return a
+}
+
+func init() {
+	assert("cbasic_int64\000", cbasic_int64(100) == 100)
+	assert("basic_int64\000", basic_int64(100) == 100)
+}
+
+//go:linkname cbasic_float32 C.basic_float32
+func cbasic_float32(a float32) float32
+
+func basic_float32(a float32) float32 {
+	return a
+}
+
+func init() {
+	assert("cbasic_float32\000", cbasic_float32(100) == 100)
+	assert("basic_float32\000", basic_float32(100) == 100)
+}
+
+//go:linkname cbasic_float64 C.basic_float64
+func cbasic_float64(a float64) float64
+
+func basic_float64(a float64) float64 {
+	return a
+}
+
+func init() {
+	assert("cbasic_float64\000", cbasic_float64(100) == 100)
+	assert("basic_float64\000", basic_float64(100) == 100)
+}
+
+//go:linkname cbasic_uintptr C.basic_uintptr
+func cbasic_uintptr(a uintptr) uintptr
+
+func basic_uintptr(a uintptr) uintptr {
+	return a
+}
+
+func init() {
+	assert("cbasic_uintptr\000", cbasic_uintptr(100) == 100)
+	assert("basic_uintptr\000", basic_uintptr(100) == 100)
+}

internal/cabi/_testdata/demo/demo.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	_ "unsafe"
+)
+
+const (
+	LLGoFiles = "../wrap/demo.c"
+)
+
+type st1 struct {
+	x int32
+	y int32
+}
+
+//go:linkname cfn1 C.fn1
+func cfn1(v st1) st1
+
+func fn1(v st1) st1 {
+	return v
+}
+
+func main() {
+	cfn1(st1{})
+}

internal/cabi/_testdata/demo/struct_float32.go

@@ -0,0 +1,549 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/struct_float32.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type point1 struct {
+	x0 float32
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a point1) point1
+
+func demo1(a point1) point1 {
+	return a
+}
+
+func init() {
+	a := point1{1}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type point2 struct {
+	x0 float32
+	x1 float32
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a point2) point2
+
+func demo2(a point2) point2 {
+	return a
+}
+
+func init() {
+	a := point2{1, 2}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type point3 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a point3) point3
+
+func demo3(a point3) point3 {
+	return a
+}
+
+func init() {
+	a := point3{1, 2, 3}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type point4 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a point4) point4
+
+func demo4(a point4) point4 {
+	return a
+}
+
+func init() {
+	a := point4{1, 2, 3, 4}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type point5 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a point5) point5
+
+func demo5(a point5) point5 {
+	return a
+}
+
+func init() {
+	a := point5{1, 2, 3, 4, 5}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type point6 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a point6) point6
+
+func demo6(a point6) point6 {
+	return a
+}
+
+func init() {
+	a := point6{1, 2, 3, 4, 5, 6}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type point7 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a point7) point7
+
+func demo7(a point7) point7 {
+	return a
+}
+
+func init() {
+	a := point7{1, 2, 3, 4, 5, 6, 7}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type point8 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a point8) point8
+
+func demo8(a point8) point8 {
+	return a
+}
+
+func init() {
+	a := point8{1, 2, 3, 4, 5, 6, 7, 8}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type point9 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a point9) point9
+
+func demo9(a point9) point9 {
+	return a
+}
+
+func init() {
+	a := point9{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type point10 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a point10) point10
+
+func demo10(a point10) point10 {
+	return a
+}
+
+func init() {
+	a := point10{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type point11 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+	x10 float32
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a point11) point11
+
+func demo11(a point11) point11 {
+	return a
+}
+
+func init() {
+	a := point11{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type point12 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+	x10 float32
+	x11 float32
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a point12) point12
+
+func demo12(a point12) point12 {
+	return a
+}
+
+func init() {
+	a := point12{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type point13 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+	x10 float32
+	x11 float32
+	x12 float32
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a point13) point13
+
+func demo13(a point13) point13 {
+	return a
+}
+
+func init() {
+	a := point13{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type point14 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+	x10 float32
+	x11 float32
+	x12 float32
+	x13 float32
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a point14) point14
+
+func demo14(a point14) point14 {
+	return a
+}
+
+func init() {
+	a := point14{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type point15 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+	x10 float32
+	x11 float32
+	x12 float32
+	x13 float32
+	x14 float32
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a point15) point15
+
+func demo15(a point15) point15 {
+	return a
+}
+
+func init() {
+	a := point15{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type point16 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+	x10 float32
+	x11 float32
+	x12 float32
+	x13 float32
+	x14 float32
+	x15 float32
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a point16) point16
+
+func demo16(a point16) point16 {
+	return a
+}
+
+func init() {
+	a := point16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type point17 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+	x10 float32
+	x11 float32
+	x12 float32
+	x13 float32
+	x14 float32
+	x15 float32
+	x16 float32
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a point17) point17
+
+func demo17(a point17) point17 {
+	return a
+}
+
+func init() {
+	a := point17{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type point18 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+	x10 float32
+	x11 float32
+	x12 float32
+	x13 float32
+	x14 float32
+	x15 float32
+	x16 float32
+	x17 float32
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a point18) point18
+
+func demo18(a point18) point18 {
+	return a
+}
+
+func init() {
+	a := point18{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type point19 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+	x10 float32
+	x11 float32
+	x12 float32
+	x13 float32
+	x14 float32
+	x15 float32
+	x16 float32
+	x17 float32
+	x18 float32
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a point19) point19
+
+func demo19(a point19) point19 {
+	return a
+}
+
+func init() {
+	a := point19{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type point20 struct {
+	x0 float32
+	x1 float32
+	x2 float32
+	x3 float32
+	x4 float32
+	x5 float32
+	x6 float32
+	x7 float32
+	x8 float32
+	x9 float32
+	x10 float32
+	x11 float32
+	x12 float32
+	x13 float32
+	x14 float32
+	x15 float32
+	x16 float32
+	x17 float32
+	x18 float32
+	x19 float32
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a point20) point20
+
+func demo20(a point20) point20 {
+	return a
+}
+
+func init() {
+	a := point20{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/struct_float64.go

@@ -0,0 +1,549 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/struct_float64.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type point1 struct {
+	x0 float64
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a point1) point1
+
+func demo1(a point1) point1 {
+	return a
+}
+
+func init() {
+	a := point1{1}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type point2 struct {
+	x0 float64
+	x1 float64
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a point2) point2
+
+func demo2(a point2) point2 {
+	return a
+}
+
+func init() {
+	a := point2{1, 2}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type point3 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a point3) point3
+
+func demo3(a point3) point3 {
+	return a
+}
+
+func init() {
+	a := point3{1, 2, 3}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type point4 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a point4) point4
+
+func demo4(a point4) point4 {
+	return a
+}
+
+func init() {
+	a := point4{1, 2, 3, 4}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type point5 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a point5) point5
+
+func demo5(a point5) point5 {
+	return a
+}
+
+func init() {
+	a := point5{1, 2, 3, 4, 5}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type point6 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a point6) point6
+
+func demo6(a point6) point6 {
+	return a
+}
+
+func init() {
+	a := point6{1, 2, 3, 4, 5, 6}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type point7 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a point7) point7
+
+func demo7(a point7) point7 {
+	return a
+}
+
+func init() {
+	a := point7{1, 2, 3, 4, 5, 6, 7}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type point8 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a point8) point8
+
+func demo8(a point8) point8 {
+	return a
+}
+
+func init() {
+	a := point8{1, 2, 3, 4, 5, 6, 7, 8}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type point9 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a point9) point9
+
+func demo9(a point9) point9 {
+	return a
+}
+
+func init() {
+	a := point9{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type point10 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a point10) point10
+
+func demo10(a point10) point10 {
+	return a
+}
+
+func init() {
+	a := point10{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type point11 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+	x10 float64
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a point11) point11
+
+func demo11(a point11) point11 {
+	return a
+}
+
+func init() {
+	a := point11{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type point12 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+	x10 float64
+	x11 float64
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a point12) point12
+
+func demo12(a point12) point12 {
+	return a
+}
+
+func init() {
+	a := point12{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type point13 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+	x10 float64
+	x11 float64
+	x12 float64
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a point13) point13
+
+func demo13(a point13) point13 {
+	return a
+}
+
+func init() {
+	a := point13{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type point14 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+	x10 float64
+	x11 float64
+	x12 float64
+	x13 float64
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a point14) point14
+
+func demo14(a point14) point14 {
+	return a
+}
+
+func init() {
+	a := point14{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type point15 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+	x10 float64
+	x11 float64
+	x12 float64
+	x13 float64
+	x14 float64
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a point15) point15
+
+func demo15(a point15) point15 {
+	return a
+}
+
+func init() {
+	a := point15{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type point16 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+	x10 float64
+	x11 float64
+	x12 float64
+	x13 float64
+	x14 float64
+	x15 float64
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a point16) point16
+
+func demo16(a point16) point16 {
+	return a
+}
+
+func init() {
+	a := point16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type point17 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+	x10 float64
+	x11 float64
+	x12 float64
+	x13 float64
+	x14 float64
+	x15 float64
+	x16 float64
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a point17) point17
+
+func demo17(a point17) point17 {
+	return a
+}
+
+func init() {
+	a := point17{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type point18 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+	x10 float64
+	x11 float64
+	x12 float64
+	x13 float64
+	x14 float64
+	x15 float64
+	x16 float64
+	x17 float64
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a point18) point18
+
+func demo18(a point18) point18 {
+	return a
+}
+
+func init() {
+	a := point18{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type point19 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+	x10 float64
+	x11 float64
+	x12 float64
+	x13 float64
+	x14 float64
+	x15 float64
+	x16 float64
+	x17 float64
+	x18 float64
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a point19) point19
+
+func demo19(a point19) point19 {
+	return a
+}
+
+func init() {
+	a := point19{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type point20 struct {
+	x0 float64
+	x1 float64
+	x2 float64
+	x3 float64
+	x4 float64
+	x5 float64
+	x6 float64
+	x7 float64
+	x8 float64
+	x9 float64
+	x10 float64
+	x11 float64
+	x12 float64
+	x13 float64
+	x14 float64
+	x15 float64
+	x16 float64
+	x17 float64
+	x18 float64
+	x19 float64
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a point20) point20
+
+func demo20(a point20) point20 {
+	return a
+}
+
+func init() {
+	a := point20{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/struct_int16.go

@@ -0,0 +1,549 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/struct_int16.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type point1 struct {
+	x0 int16
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a point1) point1
+
+func demo1(a point1) point1 {
+	return a
+}
+
+func init() {
+	a := point1{1}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type point2 struct {
+	x0 int16
+	x1 int16
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a point2) point2
+
+func demo2(a point2) point2 {
+	return a
+}
+
+func init() {
+	a := point2{1, 2}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type point3 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a point3) point3
+
+func demo3(a point3) point3 {
+	return a
+}
+
+func init() {
+	a := point3{1, 2, 3}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type point4 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a point4) point4
+
+func demo4(a point4) point4 {
+	return a
+}
+
+func init() {
+	a := point4{1, 2, 3, 4}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type point5 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a point5) point5
+
+func demo5(a point5) point5 {
+	return a
+}
+
+func init() {
+	a := point5{1, 2, 3, 4, 5}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type point6 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a point6) point6
+
+func demo6(a point6) point6 {
+	return a
+}
+
+func init() {
+	a := point6{1, 2, 3, 4, 5, 6}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type point7 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a point7) point7
+
+func demo7(a point7) point7 {
+	return a
+}
+
+func init() {
+	a := point7{1, 2, 3, 4, 5, 6, 7}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type point8 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a point8) point8
+
+func demo8(a point8) point8 {
+	return a
+}
+
+func init() {
+	a := point8{1, 2, 3, 4, 5, 6, 7, 8}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type point9 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a point9) point9
+
+func demo9(a point9) point9 {
+	return a
+}
+
+func init() {
+	a := point9{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type point10 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a point10) point10
+
+func demo10(a point10) point10 {
+	return a
+}
+
+func init() {
+	a := point10{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type point11 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+	x10 int16
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a point11) point11
+
+func demo11(a point11) point11 {
+	return a
+}
+
+func init() {
+	a := point11{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type point12 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+	x10 int16
+	x11 int16
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a point12) point12
+
+func demo12(a point12) point12 {
+	return a
+}
+
+func init() {
+	a := point12{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type point13 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+	x10 int16
+	x11 int16
+	x12 int16
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a point13) point13
+
+func demo13(a point13) point13 {
+	return a
+}
+
+func init() {
+	a := point13{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type point14 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+	x10 int16
+	x11 int16
+	x12 int16
+	x13 int16
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a point14) point14
+
+func demo14(a point14) point14 {
+	return a
+}
+
+func init() {
+	a := point14{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type point15 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+	x10 int16
+	x11 int16
+	x12 int16
+	x13 int16
+	x14 int16
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a point15) point15
+
+func demo15(a point15) point15 {
+	return a
+}
+
+func init() {
+	a := point15{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type point16 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+	x10 int16
+	x11 int16
+	x12 int16
+	x13 int16
+	x14 int16
+	x15 int16
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a point16) point16
+
+func demo16(a point16) point16 {
+	return a
+}
+
+func init() {
+	a := point16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type point17 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+	x10 int16
+	x11 int16
+	x12 int16
+	x13 int16
+	x14 int16
+	x15 int16
+	x16 int16
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a point17) point17
+
+func demo17(a point17) point17 {
+	return a
+}
+
+func init() {
+	a := point17{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type point18 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+	x10 int16
+	x11 int16
+	x12 int16
+	x13 int16
+	x14 int16
+	x15 int16
+	x16 int16
+	x17 int16
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a point18) point18
+
+func demo18(a point18) point18 {
+	return a
+}
+
+func init() {
+	a := point18{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type point19 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+	x10 int16
+	x11 int16
+	x12 int16
+	x13 int16
+	x14 int16
+	x15 int16
+	x16 int16
+	x17 int16
+	x18 int16
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a point19) point19
+
+func demo19(a point19) point19 {
+	return a
+}
+
+func init() {
+	a := point19{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type point20 struct {
+	x0 int16
+	x1 int16
+	x2 int16
+	x3 int16
+	x4 int16
+	x5 int16
+	x6 int16
+	x7 int16
+	x8 int16
+	x9 int16
+	x10 int16
+	x11 int16
+	x12 int16
+	x13 int16
+	x14 int16
+	x15 int16
+	x16 int16
+	x17 int16
+	x18 int16
+	x19 int16
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a point20) point20
+
+func demo20(a point20) point20 {
+	return a
+}
+
+func init() {
+	a := point20{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/struct_int32.go

@@ -0,0 +1,549 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/struct_int32.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type point1 struct {
+	x0 int32
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a point1) point1
+
+func demo1(a point1) point1 {
+	return a
+}
+
+func init() {
+	a := point1{1}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type point2 struct {
+	x0 int32
+	x1 int32
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a point2) point2
+
+func demo2(a point2) point2 {
+	return a
+}
+
+func init() {
+	a := point2{1, 2}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type point3 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a point3) point3
+
+func demo3(a point3) point3 {
+	return a
+}
+
+func init() {
+	a := point3{1, 2, 3}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type point4 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a point4) point4
+
+func demo4(a point4) point4 {
+	return a
+}
+
+func init() {
+	a := point4{1, 2, 3, 4}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type point5 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a point5) point5
+
+func demo5(a point5) point5 {
+	return a
+}
+
+func init() {
+	a := point5{1, 2, 3, 4, 5}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type point6 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a point6) point6
+
+func demo6(a point6) point6 {
+	return a
+}
+
+func init() {
+	a := point6{1, 2, 3, 4, 5, 6}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type point7 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a point7) point7
+
+func demo7(a point7) point7 {
+	return a
+}
+
+func init() {
+	a := point7{1, 2, 3, 4, 5, 6, 7}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type point8 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a point8) point8
+
+func demo8(a point8) point8 {
+	return a
+}
+
+func init() {
+	a := point8{1, 2, 3, 4, 5, 6, 7, 8}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type point9 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a point9) point9
+
+func demo9(a point9) point9 {
+	return a
+}
+
+func init() {
+	a := point9{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type point10 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a point10) point10
+
+func demo10(a point10) point10 {
+	return a
+}
+
+func init() {
+	a := point10{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type point11 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+	x10 int32
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a point11) point11
+
+func demo11(a point11) point11 {
+	return a
+}
+
+func init() {
+	a := point11{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type point12 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+	x10 int32
+	x11 int32
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a point12) point12
+
+func demo12(a point12) point12 {
+	return a
+}
+
+func init() {
+	a := point12{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type point13 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+	x10 int32
+	x11 int32
+	x12 int32
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a point13) point13
+
+func demo13(a point13) point13 {
+	return a
+}
+
+func init() {
+	a := point13{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type point14 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+	x10 int32
+	x11 int32
+	x12 int32
+	x13 int32
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a point14) point14
+
+func demo14(a point14) point14 {
+	return a
+}
+
+func init() {
+	a := point14{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type point15 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+	x10 int32
+	x11 int32
+	x12 int32
+	x13 int32
+	x14 int32
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a point15) point15
+
+func demo15(a point15) point15 {
+	return a
+}
+
+func init() {
+	a := point15{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type point16 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+	x10 int32
+	x11 int32
+	x12 int32
+	x13 int32
+	x14 int32
+	x15 int32
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a point16) point16
+
+func demo16(a point16) point16 {
+	return a
+}
+
+func init() {
+	a := point16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type point17 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+	x10 int32
+	x11 int32
+	x12 int32
+	x13 int32
+	x14 int32
+	x15 int32
+	x16 int32
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a point17) point17
+
+func demo17(a point17) point17 {
+	return a
+}
+
+func init() {
+	a := point17{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type point18 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+	x10 int32
+	x11 int32
+	x12 int32
+	x13 int32
+	x14 int32
+	x15 int32
+	x16 int32
+	x17 int32
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a point18) point18
+
+func demo18(a point18) point18 {
+	return a
+}
+
+func init() {
+	a := point18{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type point19 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+	x10 int32
+	x11 int32
+	x12 int32
+	x13 int32
+	x14 int32
+	x15 int32
+	x16 int32
+	x17 int32
+	x18 int32
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a point19) point19
+
+func demo19(a point19) point19 {
+	return a
+}
+
+func init() {
+	a := point19{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type point20 struct {
+	x0 int32
+	x1 int32
+	x2 int32
+	x3 int32
+	x4 int32
+	x5 int32
+	x6 int32
+	x7 int32
+	x8 int32
+	x9 int32
+	x10 int32
+	x11 int32
+	x12 int32
+	x13 int32
+	x14 int32
+	x15 int32
+	x16 int32
+	x17 int32
+	x18 int32
+	x19 int32
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a point20) point20
+
+func demo20(a point20) point20 {
+	return a
+}
+
+func init() {
+	a := point20{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/struct_int64.go

@@ -0,0 +1,549 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/struct_int64.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type point1 struct {
+	x0 int64
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a point1) point1
+
+func demo1(a point1) point1 {
+	return a
+}
+
+func init() {
+	a := point1{1}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type point2 struct {
+	x0 int64
+	x1 int64
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a point2) point2
+
+func demo2(a point2) point2 {
+	return a
+}
+
+func init() {
+	a := point2{1, 2}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type point3 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a point3) point3
+
+func demo3(a point3) point3 {
+	return a
+}
+
+func init() {
+	a := point3{1, 2, 3}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type point4 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a point4) point4
+
+func demo4(a point4) point4 {
+	return a
+}
+
+func init() {
+	a := point4{1, 2, 3, 4}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type point5 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a point5) point5
+
+func demo5(a point5) point5 {
+	return a
+}
+
+func init() {
+	a := point5{1, 2, 3, 4, 5}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type point6 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a point6) point6
+
+func demo6(a point6) point6 {
+	return a
+}
+
+func init() {
+	a := point6{1, 2, 3, 4, 5, 6}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type point7 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a point7) point7
+
+func demo7(a point7) point7 {
+	return a
+}
+
+func init() {
+	a := point7{1, 2, 3, 4, 5, 6, 7}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type point8 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a point8) point8
+
+func demo8(a point8) point8 {
+	return a
+}
+
+func init() {
+	a := point8{1, 2, 3, 4, 5, 6, 7, 8}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type point9 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a point9) point9
+
+func demo9(a point9) point9 {
+	return a
+}
+
+func init() {
+	a := point9{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type point10 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a point10) point10
+
+func demo10(a point10) point10 {
+	return a
+}
+
+func init() {
+	a := point10{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type point11 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+	x10 int64
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a point11) point11
+
+func demo11(a point11) point11 {
+	return a
+}
+
+func init() {
+	a := point11{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type point12 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+	x10 int64
+	x11 int64
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a point12) point12
+
+func demo12(a point12) point12 {
+	return a
+}
+
+func init() {
+	a := point12{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type point13 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+	x10 int64
+	x11 int64
+	x12 int64
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a point13) point13
+
+func demo13(a point13) point13 {
+	return a
+}
+
+func init() {
+	a := point13{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type point14 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+	x10 int64
+	x11 int64
+	x12 int64
+	x13 int64
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a point14) point14
+
+func demo14(a point14) point14 {
+	return a
+}
+
+func init() {
+	a := point14{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type point15 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+	x10 int64
+	x11 int64
+	x12 int64
+	x13 int64
+	x14 int64
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a point15) point15
+
+func demo15(a point15) point15 {
+	return a
+}
+
+func init() {
+	a := point15{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type point16 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+	x10 int64
+	x11 int64
+	x12 int64
+	x13 int64
+	x14 int64
+	x15 int64
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a point16) point16
+
+func demo16(a point16) point16 {
+	return a
+}
+
+func init() {
+	a := point16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type point17 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+	x10 int64
+	x11 int64
+	x12 int64
+	x13 int64
+	x14 int64
+	x15 int64
+	x16 int64
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a point17) point17
+
+func demo17(a point17) point17 {
+	return a
+}
+
+func init() {
+	a := point17{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type point18 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+	x10 int64
+	x11 int64
+	x12 int64
+	x13 int64
+	x14 int64
+	x15 int64
+	x16 int64
+	x17 int64
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a point18) point18
+
+func demo18(a point18) point18 {
+	return a
+}
+
+func init() {
+	a := point18{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type point19 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+	x10 int64
+	x11 int64
+	x12 int64
+	x13 int64
+	x14 int64
+	x15 int64
+	x16 int64
+	x17 int64
+	x18 int64
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a point19) point19
+
+func demo19(a point19) point19 {
+	return a
+}
+
+func init() {
+	a := point19{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type point20 struct {
+	x0 int64
+	x1 int64
+	x2 int64
+	x3 int64
+	x4 int64
+	x5 int64
+	x6 int64
+	x7 int64
+	x8 int64
+	x9 int64
+	x10 int64
+	x11 int64
+	x12 int64
+	x13 int64
+	x14 int64
+	x15 int64
+	x16 int64
+	x17 int64
+	x18 int64
+	x19 int64
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a point20) point20
+
+func demo20(a point20) point20 {
+	return a
+}
+
+func init() {
+	a := point20{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/struct_int8.go

@@ -0,0 +1,549 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/struct_int8.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type point1 struct {
+	x0 int8
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a point1) point1
+
+func demo1(a point1) point1 {
+	return a
+}
+
+func init() {
+	a := point1{1}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type point2 struct {
+	x0 int8
+	x1 int8
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a point2) point2
+
+func demo2(a point2) point2 {
+	return a
+}
+
+func init() {
+	a := point2{1, 2}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type point3 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a point3) point3
+
+func demo3(a point3) point3 {
+	return a
+}
+
+func init() {
+	a := point3{1, 2, 3}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type point4 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a point4) point4
+
+func demo4(a point4) point4 {
+	return a
+}
+
+func init() {
+	a := point4{1, 2, 3, 4}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type point5 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a point5) point5
+
+func demo5(a point5) point5 {
+	return a
+}
+
+func init() {
+	a := point5{1, 2, 3, 4, 5}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type point6 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a point6) point6
+
+func demo6(a point6) point6 {
+	return a
+}
+
+func init() {
+	a := point6{1, 2, 3, 4, 5, 6}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type point7 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a point7) point7
+
+func demo7(a point7) point7 {
+	return a
+}
+
+func init() {
+	a := point7{1, 2, 3, 4, 5, 6, 7}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type point8 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a point8) point8
+
+func demo8(a point8) point8 {
+	return a
+}
+
+func init() {
+	a := point8{1, 2, 3, 4, 5, 6, 7, 8}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type point9 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a point9) point9
+
+func demo9(a point9) point9 {
+	return a
+}
+
+func init() {
+	a := point9{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type point10 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a point10) point10
+
+func demo10(a point10) point10 {
+	return a
+}
+
+func init() {
+	a := point10{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type point11 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+	x10 int8
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a point11) point11
+
+func demo11(a point11) point11 {
+	return a
+}
+
+func init() {
+	a := point11{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type point12 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+	x10 int8
+	x11 int8
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a point12) point12
+
+func demo12(a point12) point12 {
+	return a
+}
+
+func init() {
+	a := point12{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type point13 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+	x10 int8
+	x11 int8
+	x12 int8
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a point13) point13
+
+func demo13(a point13) point13 {
+	return a
+}
+
+func init() {
+	a := point13{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type point14 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+	x10 int8
+	x11 int8
+	x12 int8
+	x13 int8
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a point14) point14
+
+func demo14(a point14) point14 {
+	return a
+}
+
+func init() {
+	a := point14{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type point15 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+	x10 int8
+	x11 int8
+	x12 int8
+	x13 int8
+	x14 int8
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a point15) point15
+
+func demo15(a point15) point15 {
+	return a
+}
+
+func init() {
+	a := point15{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type point16 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+	x10 int8
+	x11 int8
+	x12 int8
+	x13 int8
+	x14 int8
+	x15 int8
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a point16) point16
+
+func demo16(a point16) point16 {
+	return a
+}
+
+func init() {
+	a := point16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type point17 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+	x10 int8
+	x11 int8
+	x12 int8
+	x13 int8
+	x14 int8
+	x15 int8
+	x16 int8
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a point17) point17
+
+func demo17(a point17) point17 {
+	return a
+}
+
+func init() {
+	a := point17{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type point18 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+	x10 int8
+	x11 int8
+	x12 int8
+	x13 int8
+	x14 int8
+	x15 int8
+	x16 int8
+	x17 int8
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a point18) point18
+
+func demo18(a point18) point18 {
+	return a
+}
+
+func init() {
+	a := point18{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type point19 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+	x10 int8
+	x11 int8
+	x12 int8
+	x13 int8
+	x14 int8
+	x15 int8
+	x16 int8
+	x17 int8
+	x18 int8
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a point19) point19
+
+func demo19(a point19) point19 {
+	return a
+}
+
+func init() {
+	a := point19{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type point20 struct {
+	x0 int8
+	x1 int8
+	x2 int8
+	x3 int8
+	x4 int8
+	x5 int8
+	x6 int8
+	x7 int8
+	x8 int8
+	x9 int8
+	x10 int8
+	x11 int8
+	x12 int8
+	x13 int8
+	x14 int8
+	x15 int8
+	x16 int8
+	x17 int8
+	x18 int8
+	x19 int8
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a point20) point20
+
+func demo20(a point20) point20 {
+	return a
+}
+
+func init() {
+	a := point20{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}

internal/cabi/_testdata/demo/struct_uintptr.go

@@ -0,0 +1,549 @@
+package main
+
+import "unsafe"
+
+const (
+	LLGoFiles = "../wrap/struct_uintptr.c"
+)
+
+//go:linkname printf C.printf
+func printf(format *byte, __llgo_va_list ...any) int32
+
+func assert(info string, b bool) {
+	if !b {
+		printf(unsafe.StringData("Assertion failed: %s\n\000"), unsafe.StringData(info))
+	}
+}
+
+func main() {
+}
+
+type point1 struct {
+	x0 uintptr
+}
+
+//go:linkname cdemo1 C.demo1
+func cdemo1(a point1) point1
+
+func demo1(a point1) point1 {
+	return a
+}
+
+func init() {
+	a := point1{1}
+	assert("cdemo1\000", cdemo1(a) == a)
+	assert("demo1\000", demo1(a) == a)
+}
+
+type point2 struct {
+	x0 uintptr
+	x1 uintptr
+}
+
+//go:linkname cdemo2 C.demo2
+func cdemo2(a point2) point2
+
+func demo2(a point2) point2 {
+	return a
+}
+
+func init() {
+	a := point2{1, 2}
+	assert("cdemo2\000", cdemo2(a) == a)
+	assert("demo2\000", demo2(a) == a)
+}
+
+type point3 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+}
+
+//go:linkname cdemo3 C.demo3
+func cdemo3(a point3) point3
+
+func demo3(a point3) point3 {
+	return a
+}
+
+func init() {
+	a := point3{1, 2, 3}
+	assert("cdemo3\000", cdemo3(a) == a)
+	assert("demo3\000", demo3(a) == a)
+}
+
+type point4 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+}
+
+//go:linkname cdemo4 C.demo4
+func cdemo4(a point4) point4
+
+func demo4(a point4) point4 {
+	return a
+}
+
+func init() {
+	a := point4{1, 2, 3, 4}
+	assert("cdemo4\000", cdemo4(a) == a)
+	assert("demo4\000", demo4(a) == a)
+}
+
+type point5 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+}
+
+//go:linkname cdemo5 C.demo5
+func cdemo5(a point5) point5
+
+func demo5(a point5) point5 {
+	return a
+}
+
+func init() {
+	a := point5{1, 2, 3, 4, 5}
+	assert("cdemo5\000", cdemo5(a) == a)
+	assert("demo5\000", demo5(a) == a)
+}
+
+type point6 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+}
+
+//go:linkname cdemo6 C.demo6
+func cdemo6(a point6) point6
+
+func demo6(a point6) point6 {
+	return a
+}
+
+func init() {
+	a := point6{1, 2, 3, 4, 5, 6}
+	assert("cdemo6\000", cdemo6(a) == a)
+	assert("demo6\000", demo6(a) == a)
+}
+
+type point7 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+}
+
+//go:linkname cdemo7 C.demo7
+func cdemo7(a point7) point7
+
+func demo7(a point7) point7 {
+	return a
+}
+
+func init() {
+	a := point7{1, 2, 3, 4, 5, 6, 7}
+	assert("cdemo7\000", cdemo7(a) == a)
+	assert("demo7\000", demo7(a) == a)
+}
+
+type point8 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+}
+
+//go:linkname cdemo8 C.demo8
+func cdemo8(a point8) point8
+
+func demo8(a point8) point8 {
+	return a
+}
+
+func init() {
+	a := point8{1, 2, 3, 4, 5, 6, 7, 8}
+	assert("cdemo8\000", cdemo8(a) == a)
+	assert("demo8\000", demo8(a) == a)
+}
+
+type point9 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+}
+
+//go:linkname cdemo9 C.demo9
+func cdemo9(a point9) point9
+
+func demo9(a point9) point9 {
+	return a
+}
+
+func init() {
+	a := point9{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	assert("cdemo9\000", cdemo9(a) == a)
+	assert("demo9\000", demo9(a) == a)
+}
+
+type point10 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+}
+
+//go:linkname cdemo10 C.demo10
+func cdemo10(a point10) point10
+
+func demo10(a point10) point10 {
+	return a
+}
+
+func init() {
+	a := point10{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	assert("cdemo10\000", cdemo10(a) == a)
+	assert("demo10\000", demo10(a) == a)
+}
+
+type point11 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+	x10 uintptr
+}
+
+//go:linkname cdemo11 C.demo11
+func cdemo11(a point11) point11
+
+func demo11(a point11) point11 {
+	return a
+}
+
+func init() {
+	a := point11{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+	assert("cdemo11\000", cdemo11(a) == a)
+	assert("demo11\000", demo11(a) == a)
+}
+
+type point12 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+	x10 uintptr
+	x11 uintptr
+}
+
+//go:linkname cdemo12 C.demo12
+func cdemo12(a point12) point12
+
+func demo12(a point12) point12 {
+	return a
+}
+
+func init() {
+	a := point12{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
+	assert("cdemo12\000", cdemo12(a) == a)
+	assert("demo12\000", demo12(a) == a)
+}
+
+type point13 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+	x10 uintptr
+	x11 uintptr
+	x12 uintptr
+}
+
+//go:linkname cdemo13 C.demo13
+func cdemo13(a point13) point13
+
+func demo13(a point13) point13 {
+	return a
+}
+
+func init() {
+	a := point13{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
+	assert("cdemo13\000", cdemo13(a) == a)
+	assert("demo13\000", demo13(a) == a)
+}
+
+type point14 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+	x10 uintptr
+	x11 uintptr
+	x12 uintptr
+	x13 uintptr
+}
+
+//go:linkname cdemo14 C.demo14
+func cdemo14(a point14) point14
+
+func demo14(a point14) point14 {
+	return a
+}
+
+func init() {
+	a := point14{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
+	assert("cdemo14\000", cdemo14(a) == a)
+	assert("demo14\000", demo14(a) == a)
+}
+
+type point15 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+	x10 uintptr
+	x11 uintptr
+	x12 uintptr
+	x13 uintptr
+	x14 uintptr
+}
+
+//go:linkname cdemo15 C.demo15
+func cdemo15(a point15) point15
+
+func demo15(a point15) point15 {
+	return a
+}
+
+func init() {
+	a := point15{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+	assert("cdemo15\000", cdemo15(a) == a)
+	assert("demo15\000", demo15(a) == a)
+}
+
+type point16 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+	x10 uintptr
+	x11 uintptr
+	x12 uintptr
+	x13 uintptr
+	x14 uintptr
+	x15 uintptr
+}
+
+//go:linkname cdemo16 C.demo16
+func cdemo16(a point16) point16
+
+func demo16(a point16) point16 {
+	return a
+}
+
+func init() {
+	a := point16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
+	assert("cdemo16\000", cdemo16(a) == a)
+	assert("demo16\000", demo16(a) == a)
+}
+
+type point17 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+	x10 uintptr
+	x11 uintptr
+	x12 uintptr
+	x13 uintptr
+	x14 uintptr
+	x15 uintptr
+	x16 uintptr
+}
+
+//go:linkname cdemo17 C.demo17
+func cdemo17(a point17) point17
+
+func demo17(a point17) point17 {
+	return a
+}
+
+func init() {
+	a := point17{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}
+	assert("cdemo17\000", cdemo17(a) == a)
+	assert("demo17\000", demo17(a) == a)
+}
+
+type point18 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+	x10 uintptr
+	x11 uintptr
+	x12 uintptr
+	x13 uintptr
+	x14 uintptr
+	x15 uintptr
+	x16 uintptr
+	x17 uintptr
+}
+
+//go:linkname cdemo18 C.demo18
+func cdemo18(a point18) point18
+
+func demo18(a point18) point18 {
+	return a
+}
+
+func init() {
+	a := point18{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
+	assert("cdemo18\000", cdemo18(a) == a)
+	assert("demo18\000", demo18(a) == a)
+}
+
+type point19 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+	x10 uintptr
+	x11 uintptr
+	x12 uintptr
+	x13 uintptr
+	x14 uintptr
+	x15 uintptr
+	x16 uintptr
+	x17 uintptr
+	x18 uintptr
+}
+
+//go:linkname cdemo19 C.demo19
+func cdemo19(a point19) point19
+
+func demo19(a point19) point19 {
+	return a
+}
+
+func init() {
+	a := point19{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	assert("cdemo19\000", cdemo19(a) == a)
+	assert("demo19\000", demo19(a) == a)
+}
+
+type point20 struct {
+	x0 uintptr
+	x1 uintptr
+	x2 uintptr
+	x3 uintptr
+	x4 uintptr
+	x5 uintptr
+	x6 uintptr
+	x7 uintptr
+	x8 uintptr
+	x9 uintptr
+	x10 uintptr
+	x11 uintptr
+	x12 uintptr
+	x13 uintptr
+	x14 uintptr
+	x15 uintptr
+	x16 uintptr
+	x17 uintptr
+	x18 uintptr
+	x19 uintptr
+}
+
+//go:linkname cdemo20 C.demo20
+func cdemo20(a point20) point20
+
+func demo20(a point20) point20 {
+	return a
+}
+
+func init() {
+	a := point20{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+	assert("cdemo20\000", cdemo20(a) == a)
+	assert("demo20\000", demo20(a) == a)
+}