abi

type ArrayType ¶

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

ArrayType represents a fixed array type.

NOTE: The type name has to be ArrayType, as expected by dwarf See ${GOROOT}/src/cmd/link/internal/ld/dwarf.go#func:dwarfGenerateDebugInfo

type BitVector ¶

type BitVector struct {
	N        int32 // # of bits
	ByteData *uint8
}

Information from the compiler about the layout of stack frames. Note: this type must agree with reflect.bitVector.

type ChanDir ¶

type ChanDir int

const (
	ChanDirRecv    ChanDir = 1 << iota                 // <-chan
	ChanDirSend                                        // chan<-
	ChanDirBoth            = ChanDirRecv | ChanDirSend // chan
	ChanDirInvalid ChanDir = 0
)

type ChanType ¶

type ChanType struct {
	Type
	Elem *Type
	Dir  ChanDir
}

ChanType represents a channel type

NOTE: The type name has to be ChanType, as expected by dwarf See ${GOROOT}/src/cmd/link/internal/ld/dwarf.go#func:dwarfGenerateDebugInfo

type Func ¶

type Func struct {
	DeferReturn uint32 // offset of start of a deferreturn call instruction from entry, if any.

	PCSP   uint32
	PCFile uint32
	PCLn   uint32

	StartLine int32  // line number of start of function (func keyword/TEXT directive)
	FuncID    FuncID // set for certain special runtime functions
	Flag      FuncFlag
	// contains filtered or unexported fields
}

Layout of in-memory per-function information prepared by linker See https://golang.org/s/go12symtab. Keep in sync with linker (../cmd/link/internal/ld/pcln.go:/pclntab) and with package debug/gosym and with symtab.go in package runtime.

see $GOROOT/src/runtime/runtime2.go#type:_func

func (f *Func) IsInlined() bool

type FuncFlag ¶

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 ¶

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_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 FuncInfo ¶

type FuncInfo struct {
	*Func
	Datap *ModuleData
}

func FindFunc(pc uintptr) FuncInfo

func (f FuncInfo) Entry() uintptr

func (f FuncInfo) Name() string

func (f FuncInfo) Valid() bool

type FuncInl ¶

type FuncInl struct {
	// contains filtered or unexported fields
}

Pseudo-Func that is returned for PCs that occur in inlined code. A *Func can be either a *_func or a *FuncInl, and they are distinguished by the first uintptr.

TODO(austin): Can we merge this with inlinedCall?

type FuncTab ¶

type FuncTab struct {
	Entryoff uint32 // relative to runtime.text
	Funcoff  uint32
}

type FuncType ¶

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
}

NOTE: The type name has to be `FuncType`, as expected by dwarf See ${GOROOT}/src/cmd/link/internal/ld/dwarf.go#func:dwarfGenerateDebugInfo

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

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

func (t *FuncType) IsVariadic() bool

func (t *FuncType) NumIn() int

func (t *FuncType) NumOut() int

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

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

type FuncVal ¶

type FuncVal struct {
	Fn uintptr
}

type GetItabResult ¶

type GetItabResult uint8

const (
	GetItabResult_OK GetItabResult = iota
	GetItabResult_UncommonType
	GetItabResult_
)

type Imethod ¶

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

Imethod represents a method on an interface type

NOTE: The type name has to be `Imethod`, as expected by dwarf See ${GOROOT}/src/cmd/link/internal/ld/dwarf.go#func:dwarfGenerateDebugInfo

type InitTask ¶

type InitTask struct {
	State uint32 // 0 = uninitialized, 1 = in progress, 2 = done
	NFns  uint32
	// contains filtered or unexported fields
}

An InitTask represents the set of initializations that need to be done for a package. Keep in sync with ../../test/noinit.go:InitTask

see $GOROOT/src/runtime/proc.go#type:initTask

func (tsk *InitTask) Nth(i uint32) func()

type IntArgRegBitmap ¶

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

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

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

func (b *IntArgRegBitmap) Set(i int)

type InterfaceType ¶

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

NOTE: The type name has to be `InterfaceType`, as expected by dwarf See ${GOROOT}/src/cmd/link/internal/ld/dwarf.go#func:dwarfGenerateDebugInfo

func (t *InterfaceType) NumMethod() int

type Itab ¶

type Itab struct {
	Inter *InterfaceType
	Type  *Type
	Hash  uint32 // copy of _type.hash. Used for type switches.

	// actual length of Fun = len(.Inter.Methods)
	// fun[0]==0 means _type does not implement inter.
	Fun [1]uintptr
	// contains filtered or unexported fields
}

layout of Itab known to compilers allocated in non-garbage-collected memory Needs to be in sync with ../cmd/compile/internal/reflectdata/reflect.go:/^func.WriteTabs.

func (m *Itab) FuncPCs() []unsafe.Pointer

func (m *Itab) Init() string

type Kind ¶

type Kind uint

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

const (
	KindInvalid Kind = iota
	KindBool
	KindInt
	KindInt8
	KindInt16
	KindInt32
	KindInt64
	KindUint
	KindUint8
	KindUint16
	KindUint32
	KindUint64
	KindUintptr
	KindFloat32
	KindFloat64
	KindComplex64
	KindComplex128
	KindArray
	KindChan
	KindKindFunc
	KindInterface
	KindMap
	KindPointer
	KindSlice
	KindString
	KindStruct
	KindUnsafePointer
)

type MapType ¶

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
}

NOTE: The type name has to be `MapType`, as expected by dwarf See ${GOROOT}/src/cmd/link/internal/ld/dwarf.go#func:dwarfGenerateDebugInfo

func (mt *MapType) HashMightPanic() bool

func (mt *MapType) IndirectElem() bool

func (mt *MapType) IndirectKey() bool

func (mt *MapType) NeedKeyUpdate() bool

func (mt *MapType) ReflexiveKey() bool

type Method ¶

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 ModuleData ¶

type ModuleData struct {
	PCHeader     *PCHeader
	FuncNameTab  []byte
	CuTab        []uint32
	FileTab      []byte
	PCTab        []byte
	PCLnTable    []byte
	FTab         []FuncTab
	FindFuncTab  uintptr
	MinPC, MaxPC uintptr

	Text, Etext           uintptr
	NOPTRdata, ENOPTRdata uintptr
	Data, Edata           uintptr
	Bss, Ebss             uintptr
	NOPTRbss, ENOPTRbss   uintptr
	CovCtrs, ECovCtrs     uintptr // since go1.20
	End, GCdata, GCbss    uintptr
	Types, ETypes         uintptr
	ROData                uintptr
	GoFunc                uintptr // go.func.*

	TextSectMap []TextSect

	// .Types + .TypeLinks[i] = uintptr(unsafe.Pointer(*Type))
	//
	// The linker will leave a table of all the typelinks for
	// types in the binary, so the runtime can find them.
	//
	// When buildmode=shared, all types are in typelinks so the
	// runtime can deduplicate type pointers.
	//
	// Ref: ${GOROOT}/src/cmd/compile/internal/reflectdata/reflect.go#func:writeType
	TypeLinks []int32 // offsets from types
	ITabLinks []*Itab

	PTab []PTabEntry

	PluginPath string
	PkgHashes  []ModuleHash

	// This slice records the initializing tasks that need to be
	// done to start up the program. It is built by the linker.
	InitTasks []*InitTask // since go1.21

	ModuleName   string
	ModuleHashes []ModuleHash

	HasMain uint8 // 1 if module contains the main function, 0 otherwise

	GCdataMask, GCbssMask BitVector

	TypeMap map[TypeOff]*Type // offset to *_rtype in previous module

	Bad bool // module failed to load and should be ignored

	Next *ModuleData
	// contains filtered or unexported fields
}

ModuleData records information about the layout of the executable image. It is written by the linker. Any changes here must be matched changes to the code in cmd/link/internal/ld/symtab.go:symtab. moduledata is stored in statically allocated non-pointer memory; none of the pointers here are visible to the garbage collector.

See $GOROOT/src/runtime/symtab.go#type:moduledata

type ModuleHash ¶

type ModuleHash struct {
	ModuleName   string
	LinktimeHash string
	RuntimeHash  *string
}

A ModuleHash is used to compare the ABI of a new module or a package in a new module with the loaded program.

For each shared library a module links against, the linker creates an entry in the moduledata.modulehashes slice containing the name of the module, the abi hash seen at link time and a pointer to the runtime abi hash. These are checked in moduledataverify1 below.

For each loaded plugin, the pkghashes slice has a ModuleHash of the newly loaded package that can be used to check the plugin's version of a package against any previously loaded version of the package. This is done in plugin.lastmoduleinit.

type ModuleIter ¶

type ModuleIter uintptr

ModuleIter is an iterator for active modules.

func (iter *ModuleIter) Nth(i int) (md *ModuleData, ok bool)

type Name ¶

type Name struct {
	Bytes *byte
}

Name is an encoded type Name with optional extra data.

The first byte is a bit field containing:

1<<0 the name is exported
1<<1 tag data follows the name
1<<2 pkgPath nameOff follows the name and tag
1<<3 the name is of an embedded (a.k.a. anonymous) field

Following that, there is a varint-encoded length of the name, followed by the name itself.

If tag data is present, it also has a varint-encoded length followed by the tag itself.

If the import path follows, then 4 bytes at the end of the data form a nameOff. The import path is only set for concrete methods that are defined in a different package than their type.

If a name starts with "*", then the exported bit represents whether the pointed to type is exported.

Note: this encoding must match here and in:

cmd/compile/internal/reflectdata/reflect.go
cmd/link/internal/ld/decodesym.go

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

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

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

func (n Name) HasTag() bool

func (n Name) IsBlank() bool

func (n Name) IsEmbedded() bool

func (n Name) IsExported() bool

func (n Name) Name() string

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

func (n Name) Tag() string

type NameOff ¶

type NameOff int32

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

type Offset ¶

type Offset struct {
	// contains filtered or unexported fields
}

Offset is for computing offsets of type data structures at compile/link time; the target platform may not be the host platform. Its state includes the current offset, necessary alignment for the sequence of types, and the size of pointers and alignment of slices, interfaces, and strings (this is for tearing- resistant access to these types, if/when that is supported).

func CommonOffset(ptrSize int, twoWordAlignSlices bool) Offset

func InitializedOffset(off int, align uint8, ptrSize uint8, twoWordAlignSlices bool) Offset

func NewOffset(ptrSize uint8, twoWordAlignSlices bool) Offset

func (o Offset) Align(a uint8) Offset

func (o Offset) D8() Offset

func (o Offset) D16() Offset

func (o Offset) D32() Offset

func (o Offset) D64() Offset

func (o Offset) Interface() Offset

func (o Offset) Offset() uint64

func (o Offset) P() Offset

func (o Offset) PlusUncommon() Offset

func (o Offset) Slice() Offset

func (o Offset) String() Offset

type PCHeader ¶

type PCHeader struct {
	// 0xfffffff1 (go1.20), 0xfffffff0 (go1.18) 0xfffffffa (go1.16) 0xfffffffb (go1.2)
	Magic uint32

	MinLC          uint8   // min instruction size
	PtrSize        uint8   // size of a ptr in bytes
	NFunc          int     // number of functions in the module
	NFiles         uint    // number of entries in the file tab
	TextStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
	FuncNameOffset uintptr // offset to the funcnametab variable from pcHeader
	CuOffset       uintptr // offset to the cutab variable from pcHeader
	FileTabOffset  uintptr // offset to the filetab variable from pcHeader
	PCTabOffset    uintptr // offset to the pctab variable from pcHeader
	PCLnOffset     uintptr // offset to the pclntab variable from pcHeader
	// contains filtered or unexported fields
}

PCHeader holds data used by the pclntab lookups.

type PTabEntry ¶

type PTabEntry struct {
	Name NameOff
	Type TypeOff
}

A PTabEntry is generated by the compiler for each exported function and global variable in the main package of a plugin. It is used to initialize the plugin module's symbol map.

type PointerType ¶ added in v0.2.1

type PointerType = PtrType

type PtrType ¶

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

NOTE: The type name has to be `PtrType`, as expected by dwarf See ${GOROOT}/src/cmd/link/internal/ld/dwarf.go#func:dwarfGenerateDebugInfo

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 (r *RegArgs) Dump()

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

type SliceType ¶

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

NOTE: The type name has to be `SliceType`, as expected by dwarf See ${GOROOT}/src/cmd/link/internal/ld/dwarf.go#func:dwarfGenerateDebugInfo

type StructField ¶

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

func (f *StructField) Embedded() bool

type StructType ¶

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

NOTE: The type name has to be `StructType`, as expected by dwarf See ${GOROOT}/src/cmd/link/internal/ld/dwarf.go#func:dwarfGenerateDebugInfo

type TFlag ¶

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
)

type TextOff ¶

type TextOff int32

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

type TextSect ¶

type TextSect struct {
	VAddr    uintptr // prelinked section vaddr
	End      uintptr // vaddr + section length
	BaseAddr uintptr // relocated section address
}

Mapping information for secondary text sections

type Type ¶

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.

Type is also referenced implicitly (in the form of expressions involving constants and arch.PtrSize) in cmd/compile/internal/reflectdata/reflect.go and cmd/link/internal/ld/decodesym.go (e.g. data[2*arch.PtrSize+4] references the TFlag field) unsafe.OffsetOf(Type{}.TFlag) cannot be used directly in those places because it varies with cross compilation and experiments.

NOTE: The type name has to be Type, as expected by dwarf See ${GOROOT}/src/cmd/link/internal/ld/dwarf.go#func:dwarfGenerateDebugInfo

func (t *Type) Align() int

func (t *Type) ArrayType() *ArrayType

func (t *Type) ArrayTypeUnsafe() *ArrayType

func (t *Type) ChanDir() ChanDir

func (t *Type) ChanType() *ChanType

func (t *Type) ChanTypeUnsafe() *ChanType

func (t *Type) Common() *Type

func (t *Type) Elem() *Type

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

func (t *Type) FieldAlign() int

func (t *Type) FuncType() *FuncType

func (t *Type) FuncTypeUnsafe() *FuncType

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

func (t *Type) HasName() bool

func (t *Type) IfaceIndir() bool

func (t *Type) InterfaceType() *InterfaceType

func (t *Type) InterfaceTypeUnsafe() *InterfaceType

func (t *Type) IsDirectIface() bool

func (t *Type) Key() *Type

func (t *Type) Kind() Kind

func (t *Type) Len() int

func (t *Type) MapType() *MapType

func (t *Type) MapTypeUnsafe() *MapType

func (t *Type) Name() string

func (t *Type) NameOff(off NameOff) Name

func (t *Type) NumMethod() int

func (t *Type) PkgPath() string

func (t *Type) PointerType() *PointerType

func (t *Type) PointerTypeUnsafe() *PointerType

func (t *Type) Pointers() bool

func (t *Type) Size() uintptr

func (t *Type) SliceType() *SliceType

func (t *Type) SliceTypeUnsafe() *SliceType

func (t *Type) String() string

func (t *Type) StructType() *StructType

func (t *Type) StructTypeUnsafe() *StructType

func (t *Type) TextOff(off TextOff) unsafe.Pointer

func (t *Type) TypeOff(off TypeOff) *Type

func (t *Type) Uncommon() *UncommonType

type TypeOff ¶

type TypeOff int32

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

type UncommonType ¶

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 (t *UncommonType) ExportedMethods() []Method

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