// license that can be found in the LICENSE file.

func booliface() interface{} {
	// amd64:`LEAQ\truntime.staticuint64s\+8\(SB\)`
	return true
}

func smallint8iface() interface{} {
	// amd64:`LEAQ\truntime.staticuint64s\+2024\(SB\)`
	return int8(-3)
}

func smalluint8iface() interface{} {
	// amd64:`LEAQ\truntime.staticuint64s\+24\(SB\)`
	return uint8(3)

	if val < uint16(len(staticuint64s)) {
		x = unsafe.Pointer(&staticuint64s[val])
		if goarch.BigEndian {
			x = add(x, 6)
		}
	} else {
		x = mallocgc(2, uint16Type, false)
		*(*uint16)(x) = val
	}
	return
}

func convT32(val uint32) (x unsafe.Pointer) {
	if val < uint32(len(staticuint64s)) {
		x = unsafe.Pointer(&staticuint64s[val])
		if goarch.BigEndian {
			x = add(x, 4)

	Racereadrange     *obj.LSym
	Racewrite         *obj.LSym
	Racewriterange    *obj.LSym
	TypeAssert        *obj.LSym
	WBZero            *obj.LSym
	WBMove            *obj.LSym
	// Wasm
	SigPanic        *obj.LSym
	Staticuint64s   *obj.LSym
	Typedmemmove    *obj.LSym
	Udiv            *obj.LSym
	WriteBarrier    *obj.LSym
	Zerobase        *obj.LSym
	ARM64HasATOMICS *obj.LSym
	ARMHasVFPv4     *obj.LSym
	X86HasFMA       *obj.LSym

		}
		// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
		// individual bytes.
		staticuint64s := ir.NewLinksymExpr(base.Pos, ir.Syms.Staticuint64s, types.NewArray(types.Types[types.TUINT8], 256*8))
		xe := ir.NewIndexExpr(base.Pos, staticuint64s, index)
		xe.SetBounded(true)
		value = xe
	case n.Op() == ir.ONAME && n.(*ir.Name).Class == ir.PEXTERN && n.(*ir.Name).Readonly():

	}
	if msanenabled {
		msanread(unsafe.Pointer(ptr), uintptr(n))
	}
	if asanenabled {
		asanread(unsafe.Pointer(ptr), uintptr(n))
	}
	if n == 1 {
		p := unsafe.Pointer(&staticuint64s[*ptr])
		if goarch.BigEndian {
			p = add(p, 7)
		}
		return unsafe.String((*byte)(p), 1)
	}

	var p unsafe.Pointer
	if buf != nil && n <= len(buf) {
		p = unsafe.Pointer(buf)
	} else {

	ir.Syms.ARMHasVFPv4 = typecheck.LookupRuntimeVar("armHasVFPv4")         // bool
	ir.Syms.ARM64HasATOMICS = typecheck.LookupRuntimeVar("arm64HasATOMICS") // bool
	ir.Syms.Staticuint64s = typecheck.LookupRuntimeVar("staticuint64s")
	ir.Syms.Typedmemmove = typecheck.LookupRuntimeFunc("typedmemmove")
	ir.Syms.Udiv = typecheck.LookupRuntimeVar("udiv")                 // asm func with special ABI