abi

package
v0.8.9 Latest Latest
Warning

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

 Go to latest Published: Jun 22, 2024 License: Apache-2.0 Imports: 1 Imported by: 0

Documentation

Index

Constants

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

Variables

This section is empty.

Functions

func IsExported added in v0.8.5 

func IsExported(name string) bool

IsExported reports whether name starts with an upper-case letter.

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
	In  []*Type
	Out []*Type
}

funcType represents a function type.

func (*FuncType) Variadic added in v0.8.5 

func (p *FuncType) Variadic() bool

Variadic reports whether the function type is variadic.

type Imethod 

type Imethod struct {
	Name_ string    // name of method
	Typ_  *FuncType // .(*FuncType) underneath
}

Imethod represents a method on an interface type

func (*Imethod) Exported added in v0.8.7 

func (p *Imethod) Exported() bool

Exported reports whether the imethod is exported.

func (*Imethod) Name 

func (p *Imethod) Name() string

Name returns the tag string for imethod.

func (*Imethod) PkgPath added in v0.8.7 

func (p *Imethod) PkgPath() string

PkgPath returns the pkgpath string for imethod, or empty if there is none.

type InterfaceType 

type InterfaceType struct {
	Type
	PkgPath_ string    // 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
)

func (Kind) String added in v0.8.9 

func (k Kind) String() string

String returns the name of k.

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
}

func (*MapType) HashMightPanic added in v0.8.8 

func (mt *MapType) HashMightPanic() bool

func (*MapType) IndirectElem added in v0.8.8 

func (mt *MapType) IndirectElem() bool

func (*MapType) IndirectKey added in v0.8.8 

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

func (mt *MapType) NeedKeyUpdate() bool

func (*MapType) ReflexiveKey added in v0.8.8 

func (mt *MapType) ReflexiveKey() bool

type Method added in v0.8.5 

type Method struct {
	Name_ string    // name of method
	Mtyp_ *FuncType // method type (without receiver)
	Ifn_  Text      // fn used in interface call (one-word receiver)
	Tfn_  Text      // fn used for normal method call
}

Method on non-interface type

func (*Method) Exported added in v0.8.5 

func (p *Method) Exported() bool

Exported reports whether the method is exported.

func (*Method) Name added in v0.8.7 

func (p *Method) Name() string

Name returns the tag string for method.

func (*Method) PkgPath added in v0.8.7 

func (p *Method) PkgPath() string

PkgPath returns the pkgpath string for method, or empty if there is none.

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_  string  // name is always non-empty
	Typ    *Type   // type of field
	Offset uintptr // byte offset of field

	Tag_      string
	Embedded_ bool
}

func (*StructField) Embedded added in v0.8.5 

func (f *StructField) Embedded() bool

Embedded reports whether the field is embedded.

func (*StructField) Exported added in v0.8.5 

func (f *StructField) Exported() bool

Exported reports whether the field is exported.

type StructType 

type StructType struct {
	Type
	PkgPath_ string
	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

	// TFlagVariadic means a funcType with variadic parameters
	TFlagVariadic TFlag = 1 << 4

	// TFlagUninited means this type is not fully initialized.
	TFlagUninited TFlag = 1 << 7
)

type Text added in v0.8.5 

type Text = unsafe.Pointer // TODO(xsw): to be confirmed

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_       string // string form
	PtrToThis_ *Type  // type for pointer to this type, may be nil
}

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) Align added in v0.8.5 

func (t *Type) Align() int

Align returns the alignment of data with type t.

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) FieldAlign added in v0.8.5 

func (t *Type) FieldAlign() int

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) HasName added in v0.8.9 

func (t *Type) HasName() bool

func (*Type) IfaceIndir added in v0.8.9 

func (t *Type) IfaceIndir() bool

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

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) IsDirectIface added in v0.8.9 

func (t *Type) IsDirectIface() bool

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

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) Pointers added in v0.8.9 

func (t *Type) Pointers() bool

func (*Type) Size added in v0.8.5 

func (t *Type) Size() uintptr

Size returns the size of data with type t.

func (*Type) String added in v0.8.9 

func (t *Type) String() string

String returns string form of type t.

func (*Type) StructType 

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

func (t *Type) Uncommon() *UncommonType

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

type UncommonType added in v0.8.5 

type UncommonType struct {
	PkgPath_ string // 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
}

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

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

func (*UncommonType) Methods added in v0.8.5 

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.