abi

package
v0.9.2202 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 21, 2024 License: BSD-3-Clause Imports: 2 Imported by: 0

Documentation

Index

Constants

View Source 
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
)
View Source 
const (
	MapBucketCountBits = 3 // log2 of number of elements in a bucket.
	MapBucketCount     = 1 << MapBucketCountBits
	MapMaxKeyBytes     = 128 // Must fit in a uint8.
	MapMaxElemBytes    = 128 // Must fit in a uint8.
)

Map constants common to several packages runtime/runtime-gdb.py:MapTypePrinter contains its own copy

View Source 
const (
	// StackNosplitBase is the base maximum number of bytes that a chain of
	// NOSPLIT functions can use.
	//
	// This value must be multiplied by the stack guard multiplier, so do not
	// use it directly. See runtime/stack.go:stackNosplit and
	// cmd/internal/objabi/stack.go:StackNosplit.
	StackNosplitBase = 800

	// After a stack split check the SP is allowed to be StackSmall bytes below
	// the stack guard.
	//
	// Functions that need frames <= StackSmall can perform the stack check
	// using a single comparison directly between the stack guard and the SP
	// because we ensure that StackSmall bytes of stack space are available
	// beyond the stack guard.
	StackSmall = 128

	// Functions that need frames <= StackBig can assume that neither
	// SP-framesize nor stackGuard-StackSmall will underflow, and thus use a
	// more efficient check. In order to ensure this, StackBig must be <= the
	// size of the unmapped space at zero.
	StackBig = 4096
)
View Source 
const (
	PCDATA_UnsafePoint   = 0
	PCDATA_StackMapIndex = 1
	PCDATA_InlTreeIndex  = 2
	PCDATA_ArgLiveIndex  = 3

	FUNCDATA_ArgsPointerMaps    = 0
	FUNCDATA_LocalsPointerMaps  = 1
	FUNCDATA_StackObjects       = 2
	FUNCDATA_InlTree            = 3
	FUNCDATA_OpenCodedDeferInfo = 4
	FUNCDATA_ArgInfo            = 5
	FUNCDATA_ArgLiveInfo        = 6
	FUNCDATA_WrapInfo           = 7
)

IDs for PCDATA and FUNCDATA tables in Go binaries.

These must agree with ../../../runtime/funcdata.h.

View Source 
const (
	UnsafePointSafe   = -1 // Safe for async preemption
	UnsafePointUnsafe = -2 // Unsafe for async preemption

	// UnsafePointRestart1(2) apply on a sequence of instructions, within
	// which if an async preemption happens, we should back off the PC
	// to the start of the sequence when resuming.
	// We need two so we can distinguish the start/end of the sequence
	// in case that two sequences are next to each other.
	UnsafePointRestart1 = -3
	UnsafePointRestart2 = -4

	// Like UnsafePointRestart1, but back to function entry if async preempted.
	UnsafePointRestartAtEntry = -5
)

Special values for the PCDATA_UnsafePoint table.

View Source 
const (
	// TODO (khr, drchase) why aren't these in TFlag?  Investigate, fix if possible.
	KindDirectIface = 1 << 5
	KindGCProg      = 1 << 6 // Type.gc points to GC program
	KindMask        = (1 << 5) - 1
)
View Source 
const ArgsSizeUnknown = -0x80000000

ArgsSizeUnknown is set in Func.argsize to mark all functions whose argument size is unknown (C vararg functions, and assembly code without an explicit specification). This value is generated by the compiler, assembler, or linker.

View Source 
const ZeroValSize = 1024

ZeroValSize is the size in bytes of runtime.zeroVal.

Variables

This section is empty.

Functions

func CommonSize added in v0.7.2202 

func CommonSize(ptrSize int) int

CommonSize returns sizeof(Type) for a compilation target with a given ptrSize

func StructFieldSize added in v0.7.2202 

func StructFieldSize(ptrSize int) int

StructFieldSize returns sizeof(StructField) for a compilation target with a given ptrSize

func TFlagOff added in v0.7.2202 

func TFlagOff(ptrSize int) int

TFlagOff returns the offset of Type.TFlag for a compilation target with a given ptrSize

func UncommonSize added in v0.7.2202 

func UncommonSize() uint64

UncommonSize returns sizeof(UncommonType). This currently does not depend on ptrSize. This exported function is in an internal package, so it may change to depend on ptrSize in the future.

func UseInterfaceSwitchCache added in v0.7.2202 

func UseInterfaceSwitchCache(goarch string) bool

Types

type ArrayType added in v0.7.2202 

type ArrayType struct {
	Type
	Elem  *Type // array element type
	Slice *Type // slice type
	Len   uintptr
}

ArrayType represents a fixed array type.

type ChanDir added in v0.7.2202 

type ChanDir int
const (
	RecvDir    ChanDir = 1 << iota         // <-chan
	SendDir                                // chan<-
	BothDir            = RecvDir | SendDir // chan
	InvalidDir ChanDir = 0
)

type ChanType added in v0.7.2202 

type ChanType struct {
	Type
	Elem *Type
	Dir  ChanDir
}

ChanType represents a channel type

type FuncFlag added in v0.7.2202 

type FuncFlag uint8

A FuncFlag records bits about a function, passed to the runtime. 

const (
	// FuncFlagTopFrame indicates a function that appears at the top of its stack.
	// The traceback routine stop at such a function and consider that a
	// successful, complete traversal of the stack.
	// Examples of TopFrame functions include goexit, which appears
	// at the top of a user goroutine stack, and mstart, which appears
	// at the top of a system goroutine stack.
	FuncFlagTopFrame FuncFlag = 1 << iota

	// FuncFlagSPWrite indicates a function that writes an arbitrary value to SP
	// (any write other than adding or subtracting a constant amount).
	// The traceback routines cannot encode such changes into the
	// pcsp tables, so the function traceback cannot safely unwind past
	// SPWrite functions. Stopping at an SPWrite function is considered
	// to be an incomplete unwinding of the stack. In certain contexts
	// (in particular garbage collector stack scans) that is a fatal error.
	FuncFlagSPWrite

	// FuncFlagAsm indicates that a function was implemented in assembly.
	FuncFlagAsm
)

type FuncID added in v0.7.2202 

type FuncID uint8

A FuncID identifies particular functions that need to be treated specially by the runtime. Note that in some situations involving plugins, there may be multiple copies of a particular special runtime function. 

const (
	FuncIDNormal FuncID = iota // not a special function
	FuncID_abort
	FuncID_asmcgocall
	FuncID_asyncPreempt
	FuncID_cgocallback
	FuncID_corostart
	FuncID_debugCallV2
	FuncID_gcBgMarkWorker
	FuncID_goexit
	FuncID_gogo
	FuncID_gopanic
	FuncID_handleAsyncEvent
	FuncID_mcall
	FuncID_morestack
	FuncID_mstart
	FuncID_panicwrap
	FuncID_rt0_go
	FuncID_runfinq
	FuncID_runtime_main
	FuncID_sigpanic
	FuncID_systemstack
	FuncID_systemstack_switch
	FuncIDWrapper // any autogenerated code (hash/eq algorithms, method wrappers, etc.)
)

type FuncType added in v0.7.2202 

type FuncType struct {
	Type
	InCount  uint16
	OutCount uint16 // top bit is set if last input parameter is ...
}

funcType represents a function type.

A *Type for each in and out parameter is stored in an array that directly follows the funcType (and possibly its uncommonType). So a function type with one method, one input, and one output is: 

struct {
	funcType
	uncommonType
	[2]*rtype    // [0] is in, [1] is out
}

func (*FuncType) In added in v0.7.2202 

func (t *FuncType) In(i int) *Type

func (*FuncType) InSlice added in v0.7.2202 

func (t *FuncType) InSlice() []*Type

func (*FuncType) IsVariadic added in v0.7.2202 

func (t *FuncType) IsVariadic() bool

func (*FuncType) NumIn added in v0.7.2202 

func (t *FuncType) NumIn() int

func (*FuncType) NumOut added in v0.7.2202 

func (t *FuncType) NumOut() int

func (*FuncType) Out added in v0.7.2202 

func (t *FuncType) Out(i int) *Type

func (*FuncType) OutSlice added in v0.7.2202 

func (t *FuncType) OutSlice() []*Type

type Imethod added in v0.7.2202 

type Imethod struct {
	Name NameOff // name of method
	Typ  TypeOff // .(*FuncType) underneath
}

Imethod represents a method on an interface type

type IntArgRegBitmap 

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

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

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 InterfaceSwitch added in v0.7.2202 

type InterfaceSwitch struct {
	Cache  *InterfaceSwitchCache
	NCases int

	// Array of NCases elements.
	// Each case must be a non-empty interface type.
	Cases [1]*InterfaceType
}

type InterfaceSwitchCache added in v0.7.2202 

type InterfaceSwitchCache struct {
	Mask    uintptr                      // mask for index. Must be a power of 2 minus 1
	Entries [1]InterfaceSwitchCacheEntry // Mask+1 entries total
}

type InterfaceSwitchCacheEntry added in v0.7.2202 

type InterfaceSwitchCacheEntry struct {
	// type of source value (a *Type)
	Typ uintptr
	// case # to dispatch to
	Case int
	// itab to use for resulting case variable (a *runtime.itab)
	Itab uintptr
}

type InterfaceType added in v0.7.2202 

type InterfaceType struct {
	Type
	PkgPath Name      // import path
	Methods []Imethod // sorted by hash
}

func (*InterfaceType) NumMethod added in v0.7.2202 

func (t *InterfaceType) NumMethod() int

NumMethod returns the number of interface methods in the type's method set.

type Kind added in v0.7.2202 

type Kind uint

A Kind represents the specific kind of type that a Type represents. The zero Kind is not a valid kind. 

const (
	Invalid Kind = iota
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	Array
	Chan
	Func
	Interface
	Map
	Pointer
	Slice
	String
	Struct
	UnsafePointer
)

func (Kind) String added in v0.7.2202 

func (k Kind) String() string

String returns the name of k.

type MapType added in v0.7.2202 

type MapType struct {
	Type
	Key    *Type
	Elem   *Type
	Bucket *Type // internal type representing a hash bucket
	// function for hashing keys (ptr to key, seed) -> hash
	Hasher     func(unsafe.Pointer, uintptr) uintptr
	KeySize    uint8  // size of key slot
	ValueSize  uint8  // size of elem slot
	BucketSize uint16 // size of bucket
	Flags      uint32
}

func (*MapType) HashMightPanic added in v0.7.2202 

func (mt *MapType) HashMightPanic() bool

func (*MapType) IndirectElem added in v0.7.2202 

func (mt *MapType) IndirectElem() bool

func (*MapType) IndirectKey added in v0.7.2202 

func (mt *MapType) IndirectKey() bool

Note: flag values must match those used in the TMAP case in ../cmd/compile/internal/reflectdata/reflect.go:writeType.

func (*MapType) NeedKeyUpdate added in v0.7.2202 

func (mt *MapType) NeedKeyUpdate() bool

func (*MapType) ReflexiveKey added in v0.7.2202 

func (mt *MapType) ReflexiveKey() bool

type Method added in v0.7.2202 

type Method struct {
	Name NameOff // name of method
	Mtyp TypeOff // method type (without receiver)
	Ifn  TextOff // fn used in interface call (one-word receiver)
	Tfn  TextOff // fn used for normal method call
}

Method on non-interface type

type Name added in v0.7.2202 

type Name struct {
	Bytes *byte
}

func NewName added in v0.7.2202 

func NewName(n, tag string, exported, embedded bool) Name

func (Name) Data added in v0.7.2202 

func (n Name) Data(off int) *byte

Data does pointer arithmetic on n's Bytes, and that arithmetic is asserted to be safe because the runtime made the call (other packages use DataChecked)

func (Name) DataChecked added in v0.7.2202 

func (n Name) DataChecked(off int, whySafe string) *byte

DataChecked does pointer arithmetic on n's Bytes, and that arithmetic is asserted to be safe for the reason in whySafe (which can appear in a backtrace, etc.)

func (Name) HasTag added in v0.7.2202 

func (n Name) HasTag() bool

HasTag returns true iff there is tag data following this name

func (Name) IsBlank added in v0.7.2202 

func (n Name) IsBlank() bool

IsBlank indicates whether n is "_".

func (Name) IsEmbedded added in v0.7.2202 

func (n Name) IsEmbedded() bool

IsEmbedded returns true iff n is embedded (an anonymous field).

func (Name) IsExported added in v0.7.2202 

func (n Name) IsExported() bool

IsExported returns "is n exported?"

func (Name) Name added in v0.7.2202 

func (n Name) Name() string

Name returns the tag string for n, or empty if there is none.

func (Name) ReadVarint added in v0.7.2202 

func (n Name) ReadVarint(off int) (int, int)

ReadVarint parses a varint as encoded by encoding/binary. It returns the number of encoded bytes and the encoded value.

func (Name) Tag added in v0.7.2202 

func (n Name) Tag() string

Tag returns the tag string for n, or empty if there is none.

type NameOff added in v0.7.2202 

type NameOff int32

NameOff is the offset to a name from moduledata.types. See resolveNameOff in runtime.

type PtrType added in v0.7.2202 

type PtrType struct {
	Type
	Elem *Type // pointer element (pointed at) type
}

type RegArgs 

type RegArgs struct {
	// Values in these slots should be precisely the bit-by-bit
	// representation of how they would appear in a register.
	//
	// This means that on big endian arches, integer values should
	// be in the top bits of the slot. Floats are usually just
	// directly represented, but some architectures treat narrow
	// width floating point values specially (e.g. they're promoted
	// first, or they need to be NaN-boxed).
	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
}

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.

func (*RegArgs) Dump 

func (r *RegArgs) Dump()

func (*RegArgs) IntRegArgAddr 

func (r *RegArgs) IntRegArgAddr(reg int, argSize uintptr) unsafe.Pointer

IntRegArgAddr returns a pointer inside of r.Ints[reg] that is appropriately offset for an argument of size argSize.

argSize must be non-zero, fit in a register, and a power-of-two.

This method is a helper for dealing with the endianness of different CPU architectures, since sub-word-sized arguments in big endian architectures need to be "aligned" to the upper edge of the register to be interpreted by the CPU correctly.

type SliceType added in v0.7.2202 

type SliceType struct {
	Type
	Elem *Type // slice element type
}

type StructField added in v0.7.2202 

type StructField struct {
	Name   Name    // name is always non-empty
	Typ    *Type   // type of field
	Offset uintptr // byte offset of field
}

func (*StructField) Embedded added in v0.7.2202 

func (f *StructField) Embedded() bool

type StructType added in v0.7.2202 

type StructType struct {
	Type
	PkgPath Name
	Fields  []StructField
}

type TFlag added in v0.7.2202 

type TFlag uint8

TFlag is used by a Type to signal what extra type information is available in the memory directly following the Type value. 

const (
	// TFlagUncommon means that there is a data with a type, UncommonType,
	// just beyond the shared-per-type common data.  That is, the data
	// for struct types will store their UncommonType at one offset, the
	// data for interface types will store their UncommonType at a different
	// offset.  UncommonType is always accessed via a pointer that is computed
	// using trust-us-we-are-the-implementors pointer arithmetic.
	//
	// For example, if t.Kind() == Struct and t.tflag&TFlagUncommon != 0,
	// then t has UncommonType data and it can be accessed as:
	//
	//	type structTypeUncommon struct {
	//		structType
	//		u UncommonType
	//	}
	//	u := &(*structTypeUncommon)(unsafe.Pointer(t)).u
	TFlagUncommon TFlag = 1 << 0

	// TFlagExtraStar means the name in the str field has an
	// extraneous '*' prefix. This is because for most types T in
	// a program, the type *T also exists and reusing the str data
	// saves binary size.
	TFlagExtraStar TFlag = 1 << 1

	// TFlagNamed means the type has a name.
	TFlagNamed TFlag = 1 << 2

	// TFlagRegularMemory means that equal and hash functions can treat
	// this type as a single region of t.size bytes.
	TFlagRegularMemory TFlag = 1 << 3

	// TFlagUnrolledBitmap marks special types that are unrolled-bitmap
	// versions of types with GC programs.
	// These types need to be deallocated when the underlying object
	// is freed.
	TFlagUnrolledBitmap TFlag = 1 << 4
)

type TextOff added in v0.7.2202 

type TextOff int32

TextOff is an offset from the top of a text section. See (rtype).textOff in runtime.

type Type added in v0.7.2202 

type Type struct {
	Size_       uintptr
	PtrBytes    uintptr // number of (prefix) bytes in the type that can contain pointers
	Hash        uint32  // hash of type; avoids computation in hash tables
	TFlag       TFlag   // extra type information flags
	Align_      uint8   // alignment of variable with this type
	FieldAlign_ uint8   // alignment of struct field with this type
	Kind_       uint8   // enumeration for C
	// function for comparing objects of this type
	// (ptr to object A, ptr to object B) -> ==?
	Equal func(unsafe.Pointer, unsafe.Pointer) bool
	// GCData stores the GC type data for the garbage collector.
	// If the KindGCProg bit is set in kind, GCData is a GC program.
	// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
	GCData    *byte
	Str       NameOff // string form
	PtrToThis TypeOff // type for pointer to this type, may be zero
}

Type is the runtime representation of a Go type.

Be careful about accessing this type at build time, as the version of this type in the compiler/linker may not have the same layout as the version in the target binary, due to pointer width differences and any experiments. Use cmd/compile/internal/rttype or the functions in compiletype.go to access this type instead. (TODO: this admonition applies to every type in this package. Put it in some shared location?)

func (*Type) Align added in v0.7.2202 

func (t *Type) Align() int

Align returns the alignment of data with type t.

func (*Type) ArrayType added in v0.7.2202 

func (t *Type) ArrayType() *ArrayType

ArrayType returns t cast to a *ArrayType, or nil if its tag does not match.

func (*Type) ChanDir added in v0.7.2202 

func (t *Type) ChanDir() ChanDir

ChanDir returns the direction of t if t is a channel type, otherwise InvalidDir (0).

func (*Type) Common added in v0.7.2202 

func (t *Type) Common() *Type

func (*Type) Elem added in v0.7.2202 

func (t *Type) Elem() *Type

Elem returns the element type for t if t is an array, channel, map, pointer, or slice, otherwise nil.

func (*Type) ExportedMethods added in v0.7.2202 

func (t *Type) ExportedMethods() []Method

func (*Type) FieldAlign added in v0.7.2202 

func (t *Type) FieldAlign() int

func (*Type) FuncType added in v0.7.2202 

func (t *Type) FuncType() *FuncType

FuncType returns t cast to a *FuncType, or nil if its tag does not match.

func (*Type) GcSlice added in v0.7.2202 

func (t *Type) GcSlice(begin, end uintptr) []byte

func (*Type) HasName added in v0.7.2202 

func (t *Type) HasName() bool

func (*Type) IfaceIndir added in v0.7.2202 

func (t *Type) IfaceIndir() bool

IfaceIndir reports whether t is stored indirectly in an interface value.

func (*Type) InterfaceType added in v0.7.2202 

func (t *Type) InterfaceType() *InterfaceType

InterfaceType returns t cast to a *InterfaceType, or nil if its tag does not match.

func (*Type) IsDirectIface added in v0.7.2202 

func (t *Type) IsDirectIface() bool

isDirectIface reports whether t is stored directly in an interface value.

func (*Type) Key added in v0.7.2202 

func (t *Type) Key() *Type

func (*Type) Kind added in v0.7.2202 

func (t *Type) Kind() Kind

func (*Type) Len added in v0.7.2202 

func (t *Type) Len() int

Len returns the length of t if t is an array type, otherwise 0

func (*Type) MapType added in v0.7.2202 

func (t *Type) MapType() *MapType

MapType returns t cast to a *MapType, or nil if its tag does not match.

func (*Type) NumMethod added in v0.7.2202 

func (t *Type) NumMethod() int

func (*Type) Pointers added in v0.7.2202 

func (t *Type) Pointers() bool

func (*Type) Size added in v0.7.2202 

func (t *Type) Size() uintptr

Size returns the size of data with type t.

func (*Type) StructType added in v0.7.2202 

func (t *Type) StructType() *StructType

StructType returns t cast to a *StructType, or nil if its tag does not match.

func (*Type) Uncommon added in v0.7.2202 

func (t *Type) Uncommon() *UncommonType

Uncommon returns a pointer to T's "uncommon" data if there is any, otherwise nil

type TypeAssert added in v0.7.2202 

type TypeAssert struct {
	Cache   *TypeAssertCache
	Inter   *InterfaceType
	CanFail bool
}

type TypeAssertCache added in v0.7.2202 

type TypeAssertCache struct {
	Mask    uintptr
	Entries [1]TypeAssertCacheEntry
}

type TypeAssertCacheEntry added in v0.7.2202 

type TypeAssertCacheEntry struct {
	// type of source value (a *runtime._type)
	Typ uintptr
	// itab to use for result (a *runtime.itab)
	// nil if CanFail is set and conversion would fail.
	Itab uintptr
}

type TypeOff added in v0.7.2202 

type TypeOff int32

TypeOff is the offset to a type from moduledata.types. See resolveTypeOff in runtime.

type UncommonType added in v0.7.2202 

type UncommonType struct {
	PkgPath NameOff // import path; empty for built-in types like int, string
	Mcount  uint16  // number of methods
	Xcount  uint16  // number of exported methods
	Moff    uint32  // offset from this uncommontype to [mcount]Method
	// contains filtered or unexported fields
}

UncommonType is present only for defined types or types with methods (if T is a defined type, the uncommonTypes for T and *T have methods). Using a pointer to this struct reduces the overall size required to describe a non-defined type with no methods.

func (*UncommonType) ExportedMethods added in v0.7.2202 

func (t *UncommonType) ExportedMethods() []Method

func (*UncommonType) Methods added in v0.7.2202 

func (t *UncommonType) Methods() []Method

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.