| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| /* |
| * Runtime type representation. |
| * |
| * The following files know the exact layout of these |
| * data structures and must be kept in sync with this file: |
| * |
| * ../../cmd/gc/reflect.c |
| * ../../cmd/ld/dwarf.c |
| * ../reflect/type.go |
| * type.h |
| */ |
| |
| package runtime |
| |
| import "unsafe" |
| |
| // The compiler can only construct empty interface values at |
| // compile time; non-empty interface values get created |
| // during initialization. Type is an empty interface |
| // so that the compiler can lay out references as data. |
| type Type interface{} |
| |
| // All types begin with a few common fields needed for |
| // the interface runtime. |
| type commonType struct { |
| size uintptr // size in bytes |
| hash uint32 // hash of type; avoids computation in hash tables |
| alg uint8 // algorithm for copy+hash+cmp (../runtime/runtime.h:/AMEM) |
| align uint8 // alignment of variable with this type |
| fieldAlign uint8 // alignment of struct field with this type |
| kind uint8 // enumeration for C |
| string *string // string form; unnecessary but undeniably useful |
| *uncommonType // (relatively) uncommon fields |
| } |
| |
| // Values for commonType.kind. |
| const ( |
| kindBool = 1 + iota |
| kindInt |
| kindInt8 |
| kindInt16 |
| kindInt32 |
| kindInt64 |
| kindUint |
| kindUint8 |
| kindUint16 |
| kindUint32 |
| kindUint64 |
| kindUintptr |
| kindFloat |
| kindFloat32 |
| kindFloat64 |
| kindComplex |
| kindComplex64 |
| kindComplex128 |
| kindArray |
| kindChan |
| kindFunc |
| kindInterface |
| kindMap |
| kindPtr |
| kindSlice |
| kindString |
| kindStruct |
| kindUnsafePointer |
| |
| kindNoPointers = 1 << 7 // OR'ed into kind |
| ) |
| |
| // Method on non-interface type |
| type method struct { |
| name *string // name of method |
| pkgPath *string // nil for exported Names; otherwise import path |
| mtyp *Type // method type (without receiver) |
| typ *Type // .(*FuncType) underneath (with receiver) |
| ifn unsafe.Pointer // fn used in interface call (one-word receiver) |
| tfn unsafe.Pointer // fn used for normal method call |
| } |
| |
| // uncommonType is present only for types with names or methods |
| // (if T is a named type, the uncommonTypes for T and *T have methods). |
| // Using a pointer to this struct reduces the overall size required |
| // to describe an unnamed type with no methods. |
| type uncommonType struct { |
| name *string // name of type |
| pkgPath *string // import path; nil for built-in types like int, string |
| methods []method // methods associated with type |
| } |
| |
| // BoolType represents a boolean type. |
| type BoolType commonType |
| |
| // FloatType represents a float type. |
| type FloatType commonType |
| |
| // ComplexType represents a complex type. |
| type ComplexType commonType |
| |
| // IntType represents an int type. |
| type IntType commonType |
| |
| // UintType represents a uint type. |
| type UintType commonType |
| |
| // StringType represents a string type. |
| type StringType commonType |
| |
| // UintptrType represents a uintptr type. |
| type UintptrType commonType |
| |
| // UnsafePointerType represents an unsafe.Pointer type. |
| type UnsafePointerType commonType |
| |
| // ArrayType represents a fixed array type. |
| type ArrayType struct { |
| commonType |
| elem *Type // array element type |
| len uintptr |
| } |
| |
| // SliceType represents a slice type. |
| type SliceType struct { |
| commonType |
| elem *Type // slice element type |
| } |
| |
| // ChanDir represents a channel type's direction. |
| type ChanDir int |
| |
| const ( |
| RecvDir ChanDir = 1 << iota // <-chan |
| SendDir // chan<- |
| BothDir = RecvDir | SendDir // chan |
| ) |
| |
| // ChanType represents a channel type. |
| type ChanType struct { |
| commonType |
| elem *Type // channel element type |
| dir uintptr // channel direction (ChanDir) |
| } |
| |
| // FuncType represents a function type. |
| type FuncType struct { |
| commonType |
| dotdotdot bool // last input parameter is ... |
| in []*Type // input parameter types |
| out []*Type // output parameter types |
| } |
| |
| // Method on interface type |
| type imethod struct { |
| name *string // name of method |
| pkgPath *string // nil for exported Names; otherwise import path |
| typ *Type // .(*FuncType) underneath |
| } |
| |
| // InterfaceType represents an interface type. |
| type InterfaceType struct { |
| commonType |
| methods []imethod // sorted by hash |
| } |
| |
| // MapType represents a map type. |
| type MapType struct { |
| commonType |
| key *Type // map key type |
| elem *Type // map element (value) type |
| } |
| |
| // PtrType represents a pointer type. |
| type PtrType struct { |
| commonType |
| elem *Type // pointer element (pointed at) type |
| } |
| |
| // Struct field |
| type structField struct { |
| name *string // nil for embedded fields |
| pkgPath *string // nil for exported Names; otherwise import path |
| typ *Type // type of field |
| tag *string // nil if no tag |
| offset uintptr // byte offset of field within struct |
| } |
| |
| // StructType represents a struct type. |
| type StructType struct { |
| commonType |
| fields []structField // sorted by offset |
| } |
| |
| /* |
| * Must match iface.c:/Itab and compilers. |
| * NOTE: this is the version used by the reflection code, there is another |
| * one in iface_defs.go that is closer to the original C version. |
| */ |
| type Itable struct { |
| Itype *Type // (*tab.inter).(*InterfaceType) is the interface type |
| Type *Type |
| link *Itable |
| bad int32 |
| unused int32 |
| Fn [100000]uintptr // bigger than we'll ever see |
| } |