Package abi

Constants

const (

    // RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11.
    IntArgRegs = 9

    // X0 -> X14.
    FloatArgRegs = 15

    // We use SSE2 registers which support 64-bit float operations.
    EffectiveFloatRegSize = 8
)

func FuncPCABI0 ¶

func FuncPCABI0(f interface{}) uintptr

FuncPCABI0 returns the entry PC of the function f, which must be a direct reference of a function defined as ABI0. Otherwise it is a compile-time error.

Implemented as a compile intrinsic.

func FuncPCABIInternal ¶

func FuncPCABIInternal(f interface{}) uintptr

FuncPCABIInternal returns the entry PC of the function f. If f is a direct reference of a function, it must be defined as ABIInternal. Otherwise it is a compile-time error. If f is not a direct reference of a defined function, it assumes that f is a func value. Otherwise the behavior is undefined.

Implemented as a compile intrinsic.

type IntArgRegBitmap ¶

IntArgRegBitmap is a bitmap large enough to hold one bit per integer argument/return register.

type IntArgRegBitmap [(IntArgRegs + 7) / 8]uint8

func (*IntArgRegBitmap) Get ¶

func (b *IntArgRegBitmap) Get(i int) bool

Get returns whether the i'th bit of the bitmap is set.

nosplit because it's called in extremely sensitive contexts, like on the reflectcall return path.

func (*IntArgRegBitmap) Set ¶

func (b *IntArgRegBitmap) Set(i int)

Set sets the i'th bit of the bitmap to 1.

type RegArgs ¶

RegArgs is a struct that has space for each argument and return value register on the current architecture.

Assembly code knows the layout of the first two fields of RegArgs.

RegArgs also contains additional space to hold pointers when it may not be safe to keep them only in the integer register space otherwise.

type RegArgs struct {
    Ints   [IntArgRegs]uintptr  // untyped integer registers
    Floats [FloatArgRegs]uint64 // untyped float registers

    // Ptrs is a space that duplicates Ints but with pointer type,
    // used to make pointers passed or returned  in registers
    // visible to the GC by making the type unsafe.Pointer.
    Ptrs [IntArgRegs]unsafe.Pointer

    // ReturnIsPtr is a bitmap that indicates which registers
    // contain or will contain pointers on the return path from
    // a reflectcall. The i'th bit indicates whether the i'th
    // register contains or will contain a valid Go pointer.
    ReturnIsPtr IntArgRegBitmap
}