// 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
}