--- /dev/null
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build goexperiment.regabi
+//go:build goexperiment.regabi
+
+package reflect_test
+
+import (
+ "internal/abi"
+ "math/rand"
+ "reflect"
+ "runtime"
+ "testing"
+ "testing/quick"
+)
+
+func TestReflectValueCallABI(t *testing.T) {
+ // Enable register-based reflect.Call and ensure we don't
+ // use potentially incorrect cached versions by clearing
+ // the cache before we start and after we're done.
+ var oldRegs struct {
+ ints, floats int
+ floatSize uintptr
+ }
+ oldRegs.ints = *reflect.IntArgRegs
+ oldRegs.floats = *reflect.FloatArgRegs
+ oldRegs.floatSize = *reflect.FloatRegSize
+ *reflect.IntArgRegs = abi.IntArgRegs
+ *reflect.FloatArgRegs = abi.FloatArgRegs
+ *reflect.FloatRegSize = uintptr(abi.EffectiveFloatRegSize)
+ reflect.ClearLayoutCache()
+ defer func() {
+ *reflect.IntArgRegs = oldRegs.ints
+ *reflect.FloatArgRegs = oldRegs.floats
+ *reflect.FloatRegSize = oldRegs.floatSize
+ reflect.ClearLayoutCache()
+ }()
+
+ // Execute the functions defined below which all have the
+ // same form and perform the same function: pass all arguments
+ // to return values. The purpose is to test the call boundary
+ // and make sure it works.
+ r := rand.New(rand.NewSource(genValueRandSeed))
+ for _, fn := range []interface{}{
+ passNone,
+ passInt,
+ passInt8,
+ passInt16,
+ passInt32,
+ passInt64,
+ passUint,
+ passUint8,
+ passUint16,
+ passUint32,
+ passUint64,
+ passFloat32,
+ passFloat64,
+ passComplex64,
+ passComplex128,
+ passManyInt,
+ passManyFloat64,
+ passArray1,
+ passArray,
+ passArray1Mix,
+ passString,
+ // TODO(mknyszek): Test passing interface values.
+ passSlice,
+ passPointer,
+ passStruct1,
+ passStruct2,
+ passStruct3,
+ passStruct4,
+ passStruct5,
+ passStruct6,
+ passStruct7,
+ passStruct8,
+ passStruct9,
+ passStruct10,
+ // TODO(mknyszek): Test passing unsafe.Pointer values.
+ // TODO(mknyszek): Test passing chan values.
+ passStruct11,
+ passStruct12,
+ passStruct13,
+ pass2Struct1,
+ passEmptyStruct,
+ } {
+ fn := reflect.ValueOf(fn)
+ t.Run(runtime.FuncForPC(fn.Pointer()).Name(), func(t *testing.T) {
+ typ := fn.Type()
+ if typ.Kind() != reflect.Func {
+ t.Fatalf("test case is not a function, has type: %s", typ.String())
+ }
+ if typ.NumIn() != typ.NumOut() {
+ t.Fatalf("test case has different number of inputs and outputs: %d in, %d out", typ.NumIn(), typ.NumOut())
+ }
+ var args []reflect.Value
+ for i := 0; i < typ.NumIn(); i++ {
+ args = append(args, genValue(t, typ.In(i), r))
+ }
+ results := fn.Call(args)
+ for i := range results {
+ x, y := args[i].Interface(), results[i].Interface()
+ if reflect.DeepEqual(x, y) {
+ continue
+ }
+ t.Errorf("arg and result %d differ: got %+v, want %+v", i, x, y)
+ }
+ })
+ }
+}
+
+// Functions for testing reflect.Value.Call.
+
+//go:registerparams
+//go:noinline
+func passNone() {}
+
+//go:registerparams
+//go:noinline
+func passInt(a int) int {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passInt8(a int8) int8 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passInt16(a int16) int16 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passInt32(a int32) int32 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passInt64(a int64) int64 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passUint(a uint) uint {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passUint8(a uint8) uint8 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passUint16(a uint16) uint16 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passUint32(a uint32) uint32 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passUint64(a uint64) uint64 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passFloat32(a float32) float32 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passFloat64(a float64) float64 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passComplex64(a complex64) complex64 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passComplex128(a complex128) complex128 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passArray1(a [1]uint32) [1]uint32 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passArray(a [2]uintptr) [2]uintptr {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passArray1Mix(a int, b [1]uint32, c float64) (int, [1]uint32, float64) {
+ return a, b, c
+}
+
+//go:registerparams
+//go:noinline
+func passString(a string) string {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passSlice(a []byte) []byte {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passPointer(a *byte) *byte {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passManyInt(a, b, c, d, e, f, g, h, i, j int) (int, int, int, int, int, int, int, int, int, int) {
+ return a, b, c, d, e, f, g, h, i, j
+}
+
+//go:registerparams
+//go:noinline
+func passManyFloat64(a, b, c, d, e, f, g, h, i, j, l, m, n, o, p, q, r, s, t float64) (float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64) {
+ return a, b, c, d, e, f, g, h, i, j, l, m, n, o, p, q, r, s, t
+}
+
+//go:registerparams
+//go:noinline
+func passStruct1(a Struct1) Struct1 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct2(a Struct2) Struct2 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct3(a Struct3) Struct3 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct4(a Struct4) Struct4 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct5(a Struct5) Struct5 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct6(a Struct6) Struct6 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct7(a Struct7) Struct7 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct8(a Struct8) Struct8 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct9(a Struct9) Struct9 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct10(a Struct10) Struct10 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct11(a Struct11) Struct11 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct12(a Struct12) Struct12 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct13(a Struct13) Struct13 {
+ return a
+}
+
+//go:registerparams
+//go:noinline
+func pass2Struct1(a, b Struct1) (x, y Struct1) {
+ return a, b
+}
+
+//go:registerparams
+//go:noinline
+func passEmptyStruct(a int, b struct{}, c float64) (int, struct{}, float64) {
+ return a, b, c
+}
+
+// Struct1 is a simple integer-only aggregate struct.
+type Struct1 struct {
+ A, B, C uint
+}
+
+// Struct2 is Struct1 but with an array-typed field that will
+// force it to get passed on the stack.
+type Struct2 struct {
+ A, B, C uint
+ D [2]uint32
+}
+
+// Struct3 is Struct2 but with an anonymous array-typed field.
+// This should act identically to Struct2.
+type Struct3 struct {
+ A, B, C uint
+ D [2]uint32
+}
+
+// Struct4 has byte-length fields that should
+// each use up a whole registers.
+type Struct4 struct {
+ A, B int8
+ C, D uint8
+ E bool
+}
+
+// Struct5 is a relatively large struct
+// with both integer and floating point values.
+type Struct5 struct {
+ A uint16
+ B int16
+ C, D uint32
+ E int32
+ F, G, H, I, J float32
+}
+
+// Struct6 has a nested struct.
+type Struct6 struct {
+ Struct1
+}
+
+// Struct7 is a struct with a nested array-typed field
+// that cannot be passed in registers as a result.
+type Struct7 struct {
+ Struct1
+ Struct2
+}
+
+// Struct8 is large aggregate struct type that may be
+// passed in registers.
+type Struct8 struct {
+ Struct5
+ Struct1
+}
+
+// Struct9 is a type that has an array type nested
+// 2 layers deep, and as a result needs to be passed
+// on the stack.
+type Struct9 struct {
+ Struct1
+ Struct7
+}
+
+// Struct10 is a struct type that is too large to be
+// passed in registers.
+type Struct10 struct {
+ Struct5
+ Struct8
+}
+
+// Struct11 is a struct type that has several reference
+// types in it.
+type Struct11 struct {
+ X map[string]int
+}
+
+// Struct12 has Struct11 embedded into it to test more
+// paths.
+type Struct12 struct {
+ A int
+ Struct11
+}
+
+// Struct13 tests an empty field.
+type Struct13 struct {
+ A int
+ X struct{}
+ B int
+}
+
+const genValueRandSeed = 0
+
+// genValue generates a pseudorandom reflect.Value with type t.
+// The reflect.Value produced by this function is always the same
+// for the same type.
+func genValue(t *testing.T, typ reflect.Type, r *rand.Rand) reflect.Value {
+ // Re-seed and reset the PRNG because we want each value with the
+ // same type to be the same random value.
+ r.Seed(genValueRandSeed)
+ v, ok := quick.Value(typ, r)
+ if !ok {
+ t.Fatal("failed to generate value")
+ }
+ return v
+}