package test

import "testing"

type T1 struct {
	x          float32
	a, b, c, d int16 // memequal64
}
type T2 struct {
	x          float32
	a, b, c, d int32 // memequal128
}

type A2 [2]byte // eq uses a 2-byte load
type A4 [4]byte // eq uses a 4-byte load
type A8 [8]byte // eq uses an 8-byte load

//go:noinline
func cmpT1(p, q *T1) {
	if *p != *q {

	{"runtime.memclrNoHeapPointers", 1},
	{"runtime.memclrHasPointers", 1},
	{"runtime.memequal", 1},
	{"runtime.memequal0", 1},
	{"runtime.memequal8", 1},
	{"runtime.memequal16", 1},
	{"runtime.memequal32", 1},
	{"runtime.memequal64", 1},
	{"runtime.memequal128", 1},
	{"runtime.f32equal", 1},
	{"runtime.f64equal", 1},
	{"runtime.c64equal", 1},
	{"runtime.c128equal", 1},
	{"runtime.strequal", 1},

func memclrHasPointers(ptr unsafe.Pointer, n uintptr)

func memequal(x, y *any, size uintptr) bool
func memequal0(x, y *any) bool
func memequal8(x, y *any) bool
func memequal16(x, y *any) bool
func memequal32(x, y *any) bool
func memequal64(x, y *any) bool
func memequal128(x, y *any) bool
func f32equal(p, q unsafe.Pointer) bool
func f64equal(p, q unsafe.Pointer) bool
func c64equal(p, q unsafe.Pointer) bool

	{"memclrNoHeapPointers", funcTag, 124},
	{"memclrHasPointers", funcTag, 124},
	{"memequal", funcTag, 125},
	{"memequal0", funcTag, 126},
	{"memequal8", funcTag, 126},
	{"memequal16", funcTag, 126},
	{"memequal32", funcTag, 126},
	{"memequal64", funcTag, 126},
	{"memequal128", funcTag, 126},
	{"f32equal", funcTag, 127},
	{"f64equal", funcTag, 127},
	{"c64equal", funcTag, 127},
	{"c128equal", funcTag, 127},

	return true
}
func memequal8(p, q unsafe.Pointer) bool {
	return *(*int8)(p) == *(*int8)(q)
}
func memequal16(p, q unsafe.Pointer) bool {
	return *(*int16)(p) == *(*int16)(q)
}
func memequal32(p, q unsafe.Pointer) bool {
	return *(*int32)(p) == *(*int32)(q)
}
func memequal64(p, q unsafe.Pointer) bool {
	return *(*int64)(p) == *(*int64)(q)
}
func memequal128(p, q unsafe.Pointer) bool {