godwarf

type AddrType ¶

type AddrType struct {
	BasicType
}

An AddrType represents a machine address type.

type ArrayType ¶

type ArrayType struct {
	CommonType
	Type          Type
	StrideBitSize int64 // if > 0, number of bits to hold each element
	Count         int64 // if == -1, an incomplete array, like char x[].
}

An ArrayType represents a fixed size array type.

func (t *ArrayType) Align() int64

func (t *ArrayType) Size() int64

func (t *ArrayType) String() string

type BasicType ¶

type BasicType struct {
	CommonType
	BitSize   int64
	BitOffset int64
}

A BasicType holds fields common to all basic types.

func (t *BasicType) Align() int64

func (t *BasicType) Basic() *BasicType

func (t *BasicType) String() string

type BoolType ¶

type BoolType struct {
	BasicType
}

A BoolType represents a boolean type.

type ChanType ¶

type ChanType struct {
	TypedefType
	ElemType Type
}

A ChanType represents a Go channel type.

func (t *ChanType) String() string

type CharType ¶

type CharType struct {
	BasicType
}

A CharType represents a signed character type.

type CommonType ¶

type CommonType struct {
	Index       int          // index supplied by caller of ReadType
	ByteSize    int64        // size of value of this type, in bytes
	Name        string       // name that can be used to refer to type
	ReflectKind reflect.Kind // the reflect kind of the type.
	Offset      dwarf.Offset // the offset at which this type was read
}

A CommonType holds fields common to multiple types. If a field is not known or not applicable for a given type, the zero value is used.

func (c *CommonType) Align() int64

func (c *CommonType) Common() *CommonType

func (c *CommonType) Size() int64

type ComplexType ¶

type ComplexType struct {
	BasicType
}

A ComplexType represents a complex floating point type.

type DebugAddr ¶

type DebugAddr struct {
	*DebugAddrSection
	// contains filtered or unexported fields
}

DebugAddr represents a subsection of the debug_addr section with a specific base address

func (addr *DebugAddr) Get(idx uint64) (uint64, error)

type DebugAddrSection ¶

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

DebugAddrSection represents the debug_addr section of DWARFv5. See DWARFv5 section 7.27 page 241 and following.

func ParseAddr(data []byte) *DebugAddrSection

func (addr *DebugAddrSection) GetSubsection(addrBase uint64) *DebugAddr

type DotDotDotType ¶

type DotDotDotType struct {
	CommonType
}

A DotDotDotType represents the variadic ... function parameter.

func (t *DotDotDotType) String() string

type Entry ¶

type Entry interface {
	Val(dwarf.Attr) interface{}
	AttrField(dwarf.Attr) *dwarf.Field
}

Entry represents a debug_info entry. When calling Val, if the entry does not have the specified attribute, the entry specified by DW_AT_abstract_origin will be searched recursively.

func LoadAbstractOriginAndSpecification(entry *dwarf.Entry, aordr *dwarf.Reader) (Entry, dwarf.Offset)

type EnumType ¶

type EnumType struct {
	CommonType
	EnumName string
	Val      []*EnumValue
}

An EnumType represents an enumerated type. The only indication of its native integer type is its ByteSize (inside CommonType).

func (t *EnumType) String() string

type EnumValue ¶

type EnumValue struct {
	Name string
	Val  int64
}

An EnumValue represents a single enumeration value.

type FloatType ¶

type FloatType struct {
	BasicType
}

A FloatType represents a floating point type.

type FuncType ¶

type FuncType struct {
	CommonType
	ReturnType Type
	ParamType  []Type
}

A FuncType represents a function type.

func (t *FuncType) String() string

type IntType ¶

type IntType struct {
	BasicType
}

An IntType represents a signed integer type.

type InterfaceType ¶

type InterfaceType struct {
	TypedefType
}

An InterfaceType represents a Go interface.

func (t *InterfaceType) String() string

type MapType ¶

type MapType struct {
	TypedefType
	KeyType  Type
	ElemType Type
}

A MapType represents a Go map type. It looks like a TypedefType, describing the runtime-internal structure, with extra fields.

func (t *MapType) String() string

type ParametricType ¶

type ParametricType struct {
	TypedefType
	DictIndex int64
}

type PtrType ¶

type PtrType struct {
	CommonType
	Type Type
}

A PtrType represents a pointer type.

func (t *PtrType) String() string

type QualType ¶

type QualType struct {
	CommonType
	Qual string
	Type Type
}

A QualType represents a type that has the C/C++ "const", "restrict", or "volatile" qualifier.

func (t *QualType) Align() int64

func (t *QualType) Size() int64

func (t *QualType) String() string

type SliceType ¶

type SliceType struct {
	StructType
	ElemType Type
}

A SliceType represents a Go slice type. It looks like a StructType, describing the runtime-internal structure, with extra fields.

func (t *SliceType) String() string

type StringType ¶

type StringType struct {
	StructType
}

A StringType represents a Go string type. It looks like a StructType, describing the runtime-internal structure, but we wrap it for neatness.

func (t *StringType) String() string

type StructField ¶

type StructField struct {
	Name       string
	Type       Type
	ByteOffset int64
	ByteSize   int64
	BitOffset  int64 // within the ByteSize bytes at ByteOffset
	BitSize    int64 // zero if not a bit field
	Embedded   bool
}

A StructField represents a field in a struct, union, or C++ class type.

type StructType ¶

type StructType struct {
	CommonType
	StructName string
	Kind       string // "struct", "union", or "class".
	Field      []*StructField
	Incomplete bool // if true, struct, union, class is declared but not defined
}

A StructType represents a struct, union, or C++ class type.

func (t *StructType) Align() int64

func (t *StructType) Defn(recCheck recCheck) string

func (t *StructType) Size() int64

func (t *StructType) String() string

type Tree ¶

type Tree struct {
	Entry

	Tag      dwarf.Tag
	Offset   dwarf.Offset
	Ranges   [][2]uint64
	Children []*Tree
	// contains filtered or unexported fields
}

Tree represents a tree of dwarf objects.

func EntryToTree(entry *dwarf.Entry) *Tree

func LoadTree(off dwarf.Offset, dw *dwarf.Data, staticBase uint64) (*Tree, error)

func (n *Tree) ContainsPC(pc uint64) bool

func (n *Tree) Type(dw *dwarf.Data, index int, typeCache map[dwarf.Offset]Type) (Type, error)

type Type ¶

type Type interface {
	Common() *CommonType
	String() string
	Size() int64
	Align() int64
	// contains filtered or unexported methods
}

A Type conventionally represents a pointer to any of the specific Type structures (CharType, StructType, etc.).

func FakeBasicType(name string, bitSize int) Type

func FakeSliceType(fieldType Type) Type

func ReadType(d *dwarf.Data, index int, off dwarf.Offset, typeCache map[dwarf.Offset]Type) (Type, error)

type TypedefType ¶

type TypedefType struct {
	CommonType
	Type Type
}

A TypedefType represents a named type.

func (t *TypedefType) Align() int64

func (t *TypedefType) Size() int64

func (t *TypedefType) String() string

type UcharType ¶

type UcharType struct {
	BasicType
}

A UcharType represents an unsigned character type.

type UintType ¶

type UintType struct {
	BasicType
}

A UintType represents an unsigned integer type.

type UnspecifiedType ¶

type UnspecifiedType struct {
	BasicType
}

An UnspecifiedType represents an implicit, unknown, ambiguous or nonexistent type.

type UnsupportedType ¶

type UnsupportedType struct {
	CommonType
	Tag dwarf.Tag
}

An UnsupportedType is a placeholder returned in situations where we encounter a type that isn't supported.

func (t *UnsupportedType) String() string

type VoidType ¶

type VoidType struct {
	CommonType
}

A VoidType represents the C void type.

func (t *VoidType) String() string