abi

Documentation

Index

• Constants
• type ArrayType
• type ChanDir
• type ChanType
• type FuncType
• type Imethod
• type InterfaceType
• type Kind
• type MapType
• type Name
• type NameOff
• type PtrType
• type SliceType
• type StructField
• type StructType
• type TFlag
• type Type
  • func (t *Type) ArrayType() *ArrayType
  • func (t *Type) Common() *Type
  • func (t *Type) Elem() *Type
  • func (t *Type) FuncType() *FuncType
  • func (t *Type) InterfaceType() *InterfaceType
  • func (t *Type) Kind() Kind
  • func (t *Type) Len() int
  • func (t *Type) MapType() *MapType
  • func (t *Type) StructType() *StructType
• type TypeOff

Constants

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

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
)

Types

type ArrayType

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

ArrayType represents a fixed array type.

type ChanDir

type ChanDir int

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

type ChanType

type ChanType struct {
	Type
	Elem *Type
	Dir  ChanDir
}

ChanType represents a channel type

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
}

type Imethod

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

Imethod represents a method on an interface type

type InterfaceType

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

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 (
	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
)

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
}

type Name

type Name struct {
	Bytes *byte
}

type NameOff

type NameOff int32

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

type PtrType

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

type SliceType

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

type StructField

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

type StructType

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

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 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.

func (*Type) ArrayType

func (t *Type) ArrayType() *ArrayType

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

func (*Type) Common

func (t *Type) Common() *Type

func (*Type) Elem

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) FuncType

func (t *Type) FuncType() *FuncType

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

func (*Type) InterfaceType

func (t *Type) InterfaceType() *InterfaceType

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

func (*Type) Kind

func (t *Type) Kind() Kind

func (*Type) Len

func (t *Type) Len() int

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

func (*Type) MapType

func (t *Type) MapType() *MapType

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

func (*Type) StructType

func (t *Type) StructType() *StructType

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

type TypeOff

type TypeOff int32

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