go/src/debug/dwarf/type.go

type Type

type CommonType

func (c *CommonType) Common() *CommonType {}

func (c *CommonType) Size() int64 {}

type BasicType

func (b *BasicType) Basic() *BasicType {}

func (t *BasicType) String() string {}

type CharType

type UcharType

type IntType

type UintType

type FloatType

type ComplexType

type BoolType

type AddrType

type UnspecifiedType

type QualType

func (t *QualType) String() string {}

func (t *QualType) Size() int64 {}

type ArrayType

func (t *ArrayType) String() string {}

func (t *ArrayType) Size() int64 {}

type VoidType

func (t *VoidType) String() string {}

type PtrType

func (t *PtrType) String() string {}

type StructType

type StructField

func (t *StructType) String() string {}

func (f *StructField) bitOffset() int64 {}

func (t *StructType) Defn() string {}

type EnumType

type EnumValue

func (t *EnumType) String() string {}

type FuncType

func (t *FuncType) String() string {}

type DotDotDotType

func (t *DotDotDotType) String() string {}

type TypedefType

func (t *TypedefType) String() string {}

func (t *TypedefType) Size() int64 {}

type UnsupportedType

func (t *UnsupportedType) String() string {}

type typeReader

// Type reads the type at off in the DWARF “info” section.
func (d *Data) Type(off Offset) (Type, error) {}

type typeFixer

func (tf *typeFixer) recordArrayType(t *Type) {}

func (tf *typeFixer) apply() {}

// readType reads a type from r at off of name. It adds types to the
// type cache, appends new typedef types to typedefs, and computes the
// sizes of types. Callers should pass nil for typedefs; this is used
// for internal recursion.
func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Offset]Type, fixups *typeFixer) (Type, error) {}

func zeroArray(t *Type) {}