mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-08 20:55:01 +00:00
639 lines
16 KiB
Go
639 lines
16 KiB
Go
// 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.
|
|
|
|
// DWARF debug information entry parser.
|
|
// An entry is a sequence of data items of a given format.
|
|
// The first word in the entry is an index into what DWARF
|
|
// calls the ``abbreviation table.'' An abbreviation is really
|
|
// just a type descriptor: it's an array of attribute tag/value format pairs.
|
|
|
|
package dwarf
|
|
|
|
import (
|
|
"errors"
|
|
"strconv"
|
|
)
|
|
|
|
// a single entry's description: a sequence of attributes
|
|
type abbrev struct {
|
|
tag Tag
|
|
children bool
|
|
field []afield
|
|
}
|
|
|
|
type afield struct {
|
|
attr Attr
|
|
fmt format
|
|
class Class
|
|
}
|
|
|
|
// a map from entry format ids to their descriptions
|
|
type abbrevTable map[uint32]abbrev
|
|
|
|
// ParseAbbrev returns the abbreviation table that starts at byte off
|
|
// in the .debug_abbrev section.
|
|
func (d *Data) parseAbbrev(off uint32, vers int) (abbrevTable, error) {
|
|
if m, ok := d.abbrevCache[off]; ok {
|
|
return m, nil
|
|
}
|
|
|
|
data := d.abbrev
|
|
if off > uint32(len(data)) {
|
|
data = nil
|
|
} else {
|
|
data = data[off:]
|
|
}
|
|
b := makeBuf(d, unknownFormat{}, "abbrev", 0, data)
|
|
|
|
// Error handling is simplified by the buf getters
|
|
// returning an endless stream of 0s after an error.
|
|
m := make(abbrevTable)
|
|
for {
|
|
// Table ends with id == 0.
|
|
id := uint32(b.uint())
|
|
if id == 0 {
|
|
break
|
|
}
|
|
|
|
// Walk over attributes, counting.
|
|
n := 0
|
|
b1 := b // Read from copy of b.
|
|
b1.uint()
|
|
b1.uint8()
|
|
for {
|
|
tag := b1.uint()
|
|
fmt := b1.uint()
|
|
if tag == 0 && fmt == 0 {
|
|
break
|
|
}
|
|
n++
|
|
}
|
|
if b1.err != nil {
|
|
return nil, b1.err
|
|
}
|
|
|
|
// Walk over attributes again, this time writing them down.
|
|
var a abbrev
|
|
a.tag = Tag(b.uint())
|
|
a.children = b.uint8() != 0
|
|
a.field = make([]afield, n)
|
|
for i := range a.field {
|
|
a.field[i].attr = Attr(b.uint())
|
|
a.field[i].fmt = format(b.uint())
|
|
a.field[i].class = formToClass(a.field[i].fmt, a.field[i].attr, vers, &b)
|
|
}
|
|
b.uint()
|
|
b.uint()
|
|
|
|
m[id] = a
|
|
}
|
|
if b.err != nil {
|
|
return nil, b.err
|
|
}
|
|
d.abbrevCache[off] = m
|
|
return m, nil
|
|
}
|
|
|
|
// attrIsExprloc indicates attributes that allow exprloc values that
|
|
// are encoded as block values in DWARF 2 and 3. See DWARF 4, Figure
|
|
// 20.
|
|
var attrIsExprloc = map[Attr]bool{
|
|
AttrLocation: true,
|
|
AttrByteSize: true,
|
|
AttrBitOffset: true,
|
|
AttrBitSize: true,
|
|
AttrStringLength: true,
|
|
AttrLowerBound: true,
|
|
AttrReturnAddr: true,
|
|
AttrStrideSize: true,
|
|
AttrUpperBound: true,
|
|
AttrCount: true,
|
|
AttrDataMemberLoc: true,
|
|
AttrFrameBase: true,
|
|
AttrSegment: true,
|
|
AttrStaticLink: true,
|
|
AttrUseLocation: true,
|
|
AttrVtableElemLoc: true,
|
|
AttrAllocated: true,
|
|
AttrAssociated: true,
|
|
AttrDataLocation: true,
|
|
AttrStride: true,
|
|
}
|
|
|
|
// attrPtrClass indicates the *ptr class of attributes that have
|
|
// encoding formSecOffset in DWARF 4 or formData* in DWARF 2 and 3.
|
|
var attrPtrClass = map[Attr]Class{
|
|
AttrLocation: ClassLocListPtr,
|
|
AttrStmtList: ClassLinePtr,
|
|
AttrStringLength: ClassLocListPtr,
|
|
AttrReturnAddr: ClassLocListPtr,
|
|
AttrStartScope: ClassRangeListPtr,
|
|
AttrDataMemberLoc: ClassLocListPtr,
|
|
AttrFrameBase: ClassLocListPtr,
|
|
AttrMacroInfo: ClassMacPtr,
|
|
AttrSegment: ClassLocListPtr,
|
|
AttrStaticLink: ClassLocListPtr,
|
|
AttrUseLocation: ClassLocListPtr,
|
|
AttrVtableElemLoc: ClassLocListPtr,
|
|
AttrRanges: ClassRangeListPtr,
|
|
}
|
|
|
|
// formToClass returns the DWARF 4 Class for the given form. If the
|
|
// DWARF version is less then 4, it will disambiguate some forms
|
|
// depending on the attribute.
|
|
func formToClass(form format, attr Attr, vers int, b *buf) Class {
|
|
switch form {
|
|
default:
|
|
b.error("cannot determine class of unknown attribute form")
|
|
return 0
|
|
|
|
case formAddr:
|
|
return ClassAddress
|
|
|
|
case formDwarfBlock1, formDwarfBlock2, formDwarfBlock4, formDwarfBlock:
|
|
// In DWARF 2 and 3, ClassExprLoc was encoded as a
|
|
// block. DWARF 4 distinguishes ClassBlock and
|
|
// ClassExprLoc, but there are no attributes that can
|
|
// be both, so we also promote ClassBlock values in
|
|
// DWARF 4 that should be ClassExprLoc in case
|
|
// producers get this wrong.
|
|
if attrIsExprloc[attr] {
|
|
return ClassExprLoc
|
|
}
|
|
return ClassBlock
|
|
|
|
case formData1, formData2, formData4, formData8, formSdata, formUdata:
|
|
// In DWARF 2 and 3, ClassPtr was encoded as a
|
|
// constant. Unlike ClassExprLoc/ClassBlock, some
|
|
// DWARF 4 attributes need to distinguish Class*Ptr
|
|
// from ClassConstant, so we only do this promotion
|
|
// for versions 2 and 3.
|
|
if class, ok := attrPtrClass[attr]; vers < 4 && ok {
|
|
return class
|
|
}
|
|
return ClassConstant
|
|
|
|
case formFlag, formFlagPresent:
|
|
return ClassFlag
|
|
|
|
case formRefAddr, formRef1, formRef2, formRef4, formRef8, formRefUdata:
|
|
return ClassReference
|
|
|
|
case formRefSig8:
|
|
return ClassReferenceSig
|
|
|
|
case formString, formStrp:
|
|
return ClassString
|
|
|
|
case formSecOffset:
|
|
// DWARF 4 defines four *ptr classes, but doesn't
|
|
// distinguish them in the encoding. Disambiguate
|
|
// these classes using the attribute.
|
|
if class, ok := attrPtrClass[attr]; ok {
|
|
return class
|
|
}
|
|
return ClassUnknown
|
|
|
|
case formExprloc:
|
|
return ClassExprLoc
|
|
|
|
case formGnuRefAlt:
|
|
return ClassReferenceAlt
|
|
|
|
case formGnuStrpAlt:
|
|
return ClassStringAlt
|
|
}
|
|
}
|
|
|
|
// An entry is a sequence of attribute/value pairs.
|
|
type Entry struct {
|
|
Offset Offset // offset of Entry in DWARF info
|
|
Tag Tag // tag (kind of Entry)
|
|
Children bool // whether Entry is followed by children
|
|
Field []Field
|
|
}
|
|
|
|
// A Field is a single attribute/value pair in an Entry.
|
|
//
|
|
// A value can be one of several "attribute classes" defined by DWARF.
|
|
// The Go types corresponding to each class are:
|
|
//
|
|
// DWARF class Go type Class
|
|
// ----------- ------- -----
|
|
// address uint64 ClassAddress
|
|
// block []byte ClassBlock
|
|
// constant int64 ClassConstant
|
|
// flag bool ClassFlag
|
|
// reference
|
|
// to info dwarf.Offset ClassReference
|
|
// to type unit uint64 ClassReferenceSig
|
|
// string string ClassString
|
|
// exprloc []byte ClassExprLoc
|
|
// lineptr int64 ClassLinePtr
|
|
// loclistptr int64 ClassLocListPtr
|
|
// macptr int64 ClassMacPtr
|
|
// rangelistptr int64 ClassRangeListPtr
|
|
//
|
|
// For unrecognized or vendor-defined attributes, Class may be
|
|
// ClassUnknown.
|
|
type Field struct {
|
|
Attr Attr
|
|
Val interface{}
|
|
Class Class
|
|
}
|
|
|
|
// A Class is the DWARF 4 class of an attibute value.
|
|
//
|
|
// In general, a given attribute's value may take on one of several
|
|
// possible classes defined by DWARF, each of which leads to a
|
|
// slightly different interpretation of the attribute.
|
|
//
|
|
// DWARF version 4 distinguishes attribute value classes more finely
|
|
// than previous versions of DWARF. The reader will disambiguate
|
|
// coarser classes from earlier versions of DWARF into the appropriate
|
|
// DWARF 4 class. For example, DWARF 2 uses "constant" for constants
|
|
// as well as all types of section offsets, but the reader will
|
|
// canonicalize attributes in DWARF 2 files that refer to section
|
|
// offsets to one of the Class*Ptr classes, even though these classes
|
|
// were only defined in DWARF 3.
|
|
type Class int
|
|
|
|
const (
|
|
// ClassUnknown represents values of unknown DWARF class.
|
|
ClassUnknown Class = iota
|
|
|
|
// ClassAddress represents values of type uint64 that are
|
|
// addresses on the target machine.
|
|
ClassAddress
|
|
|
|
// ClassBlock represents values of type []byte whose
|
|
// interpretation depends on the attribute.
|
|
ClassBlock
|
|
|
|
// ClassConstant represents values of type int64 that are
|
|
// constants. The interpretation of this constant depends on
|
|
// the attribute.
|
|
ClassConstant
|
|
|
|
// ClassExprLoc represents values of type []byte that contain
|
|
// an encoded DWARF expression or location description.
|
|
ClassExprLoc
|
|
|
|
// ClassFlag represents values of type bool.
|
|
ClassFlag
|
|
|
|
// ClassLinePtr represents values that are an int64 offset
|
|
// into the "line" section.
|
|
ClassLinePtr
|
|
|
|
// ClassLocListPtr represents values that are an int64 offset
|
|
// into the "loclist" section.
|
|
ClassLocListPtr
|
|
|
|
// ClassMacPtr represents values that are an int64 offset into
|
|
// the "mac" section.
|
|
ClassMacPtr
|
|
|
|
// ClassMacPtr represents values that are an int64 offset into
|
|
// the "rangelist" section.
|
|
ClassRangeListPtr
|
|
|
|
// ClassReference represents values that are an Offset offset
|
|
// of an Entry in the info section (for use with Reader.Seek).
|
|
// The DWARF specification combines ClassReference and
|
|
// ClassReferenceSig into class "reference".
|
|
ClassReference
|
|
|
|
// ClassReferenceSig represents values that are a uint64 type
|
|
// signature referencing a type Entry.
|
|
ClassReferenceSig
|
|
|
|
// ClassString represents values that are strings. If the
|
|
// compilation unit specifies the AttrUseUTF8 flag (strongly
|
|
// recommended), the string value will be encoded in UTF-8.
|
|
// Otherwise, the encoding is unspecified.
|
|
ClassString
|
|
|
|
// ClassReferenceAlt represents values of type int64 that are
|
|
// an offset into the DWARF "info" section of an alternate
|
|
// object file.
|
|
ClassReferenceAlt
|
|
|
|
// ClassStringAlt represents values of type int64 that are an
|
|
// offset into the DWARF string section of an alternate object
|
|
// file.
|
|
ClassStringAlt
|
|
)
|
|
|
|
//go:generate stringer -type=Class
|
|
|
|
func (i Class) GoString() string {
|
|
return "dwarf." + i.String()
|
|
}
|
|
|
|
// Val returns the value associated with attribute Attr in Entry,
|
|
// or nil if there is no such attribute.
|
|
//
|
|
// A common idiom is to merge the check for nil return with
|
|
// the check that the value has the expected dynamic type, as in:
|
|
// v, ok := e.Val(AttrSibling).(int64)
|
|
//
|
|
func (e *Entry) Val(a Attr) interface{} {
|
|
if f := e.AttrField(a); f != nil {
|
|
return f.Val
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// AttrField returns the Field associated with attribute Attr in
|
|
// Entry, or nil if there is no such attribute.
|
|
func (e *Entry) AttrField(a Attr) *Field {
|
|
for i, f := range e.Field {
|
|
if f.Attr == a {
|
|
return &e.Field[i]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// An Offset represents the location of an Entry within the DWARF info.
|
|
// (See Reader.Seek.)
|
|
type Offset uint32
|
|
|
|
// Entry reads a single entry from buf, decoding
|
|
// according to the given abbreviation table.
|
|
func (b *buf) entry(atab abbrevTable, ubase Offset) *Entry {
|
|
off := b.off
|
|
id := uint32(b.uint())
|
|
if id == 0 {
|
|
return &Entry{}
|
|
}
|
|
a, ok := atab[id]
|
|
if !ok {
|
|
b.error("unknown abbreviation table index")
|
|
return nil
|
|
}
|
|
e := &Entry{
|
|
Offset: off,
|
|
Tag: a.tag,
|
|
Children: a.children,
|
|
Field: make([]Field, len(a.field)),
|
|
}
|
|
for i := range e.Field {
|
|
e.Field[i].Attr = a.field[i].attr
|
|
e.Field[i].Class = a.field[i].class
|
|
fmt := a.field[i].fmt
|
|
if fmt == formIndirect {
|
|
fmt = format(b.uint())
|
|
}
|
|
var val interface{}
|
|
switch fmt {
|
|
default:
|
|
b.error("unknown entry attr format 0x" + strconv.FormatInt(int64(fmt), 16))
|
|
|
|
// address
|
|
case formAddr:
|
|
val = b.addr()
|
|
|
|
// block
|
|
case formDwarfBlock1:
|
|
val = b.bytes(int(b.uint8()))
|
|
case formDwarfBlock2:
|
|
val = b.bytes(int(b.uint16()))
|
|
case formDwarfBlock4:
|
|
val = b.bytes(int(b.uint32()))
|
|
case formDwarfBlock:
|
|
val = b.bytes(int(b.uint()))
|
|
|
|
// constant
|
|
case formData1:
|
|
val = int64(b.uint8())
|
|
case formData2:
|
|
val = int64(b.uint16())
|
|
case formData4:
|
|
val = int64(b.uint32())
|
|
case formData8:
|
|
val = int64(b.uint64())
|
|
case formSdata:
|
|
val = int64(b.int())
|
|
case formUdata:
|
|
val = int64(b.uint())
|
|
|
|
// flag
|
|
case formFlag:
|
|
val = b.uint8() == 1
|
|
// New in DWARF 4.
|
|
case formFlagPresent:
|
|
// The attribute is implicitly indicated as present, and no value is
|
|
// encoded in the debugging information entry itself.
|
|
val = true
|
|
|
|
// reference to other entry
|
|
case formRefAddr:
|
|
vers := b.format.version()
|
|
if vers == 0 {
|
|
b.error("unknown version for DW_FORM_ref_addr")
|
|
} else if vers == 2 {
|
|
val = Offset(b.addr())
|
|
} else {
|
|
is64, known := b.format.dwarf64()
|
|
if !known {
|
|
b.error("unknown size for DW_FORM_ref_addr")
|
|
} else if is64 {
|
|
val = Offset(b.uint64())
|
|
} else {
|
|
val = Offset(b.uint32())
|
|
}
|
|
}
|
|
case formRef1:
|
|
val = Offset(b.uint8()) + ubase
|
|
case formRef2:
|
|
val = Offset(b.uint16()) + ubase
|
|
case formRef4:
|
|
val = Offset(b.uint32()) + ubase
|
|
case formRef8:
|
|
val = Offset(b.uint64()) + ubase
|
|
case formRefUdata:
|
|
val = Offset(b.uint()) + ubase
|
|
|
|
// string
|
|
case formString:
|
|
val = b.string()
|
|
case formStrp:
|
|
off := b.uint32() // offset into .debug_str
|
|
if b.err != nil {
|
|
return nil
|
|
}
|
|
b1 := makeBuf(b.dwarf, unknownFormat{}, "str", 0, b.dwarf.str)
|
|
b1.skip(int(off))
|
|
val = b1.string()
|
|
if b1.err != nil {
|
|
b.err = b1.err
|
|
return nil
|
|
}
|
|
|
|
// lineptr, loclistptr, macptr, rangelistptr
|
|
// New in DWARF 4, but clang can generate them with -gdwarf-2.
|
|
// Section reference, replacing use of formData4 and formData8.
|
|
case formSecOffset, formGnuRefAlt, formGnuStrpAlt:
|
|
is64, known := b.format.dwarf64()
|
|
if !known {
|
|
b.error("unknown size for form 0x" + strconv.FormatInt(int64(fmt), 16))
|
|
} else if is64 {
|
|
val = int64(b.uint64())
|
|
} else {
|
|
val = int64(b.uint32())
|
|
}
|
|
|
|
// exprloc
|
|
// New in DWARF 4.
|
|
case formExprloc:
|
|
val = b.bytes(int(b.uint()))
|
|
|
|
// reference
|
|
// New in DWARF 4.
|
|
case formRefSig8:
|
|
// 64-bit type signature.
|
|
val = b.uint64()
|
|
}
|
|
e.Field[i].Val = val
|
|
}
|
|
if b.err != nil {
|
|
return nil
|
|
}
|
|
return e
|
|
}
|
|
|
|
// A Reader allows reading Entry structures from a DWARF ``info'' section.
|
|
// The Entry structures are arranged in a tree. The Reader's Next function
|
|
// return successive entries from a pre-order traversal of the tree.
|
|
// If an entry has children, its Children field will be true, and the children
|
|
// follow, terminated by an Entry with Tag 0.
|
|
type Reader struct {
|
|
b buf
|
|
d *Data
|
|
err error
|
|
unit int
|
|
lastChildren bool // .Children of last entry returned by Next
|
|
lastSibling Offset // .Val(AttrSibling) of last entry returned by Next
|
|
}
|
|
|
|
// Reader returns a new Reader for Data.
|
|
// The reader is positioned at byte offset 0 in the DWARF ``info'' section.
|
|
func (d *Data) Reader() *Reader {
|
|
r := &Reader{d: d}
|
|
r.Seek(0)
|
|
return r
|
|
}
|
|
|
|
// AddressSize returns the size in bytes of addresses in the current compilation
|
|
// unit.
|
|
func (r *Reader) AddressSize() int {
|
|
return r.d.unit[r.unit].asize
|
|
}
|
|
|
|
// Seek positions the Reader at offset off in the encoded entry stream.
|
|
// Offset 0 can be used to denote the first entry.
|
|
func (r *Reader) Seek(off Offset) {
|
|
d := r.d
|
|
r.err = nil
|
|
r.lastChildren = false
|
|
if off == 0 {
|
|
if len(d.unit) == 0 {
|
|
return
|
|
}
|
|
u := &d.unit[0]
|
|
r.unit = 0
|
|
r.b = makeBuf(r.d, u, "info", u.off, u.data)
|
|
return
|
|
}
|
|
|
|
i := d.offsetToUnit(off)
|
|
if i == -1 {
|
|
r.err = errors.New("offset out of range")
|
|
return
|
|
}
|
|
u := &d.unit[i]
|
|
r.unit = i
|
|
r.b = makeBuf(r.d, u, "info", off, u.data[off-u.off:])
|
|
}
|
|
|
|
// maybeNextUnit advances to the next unit if this one is finished.
|
|
func (r *Reader) maybeNextUnit() {
|
|
for len(r.b.data) == 0 && r.unit+1 < len(r.d.unit) {
|
|
r.unit++
|
|
u := &r.d.unit[r.unit]
|
|
r.b = makeBuf(r.d, u, "info", u.off, u.data)
|
|
}
|
|
}
|
|
|
|
// Next reads the next entry from the encoded entry stream.
|
|
// It returns nil, nil when it reaches the end of the section.
|
|
// It returns an error if the current offset is invalid or the data at the
|
|
// offset cannot be decoded as a valid Entry.
|
|
func (r *Reader) Next() (*Entry, error) {
|
|
if r.err != nil {
|
|
return nil, r.err
|
|
}
|
|
r.maybeNextUnit()
|
|
if len(r.b.data) == 0 {
|
|
return nil, nil
|
|
}
|
|
u := &r.d.unit[r.unit]
|
|
e := r.b.entry(u.atable, u.base)
|
|
if r.b.err != nil {
|
|
r.err = r.b.err
|
|
return nil, r.err
|
|
}
|
|
if e != nil {
|
|
r.lastChildren = e.Children
|
|
if r.lastChildren {
|
|
r.lastSibling, _ = e.Val(AttrSibling).(Offset)
|
|
}
|
|
} else {
|
|
r.lastChildren = false
|
|
}
|
|
return e, nil
|
|
}
|
|
|
|
// SkipChildren skips over the child entries associated with
|
|
// the last Entry returned by Next. If that Entry did not have
|
|
// children or Next has not been called, SkipChildren is a no-op.
|
|
func (r *Reader) SkipChildren() {
|
|
if r.err != nil || !r.lastChildren {
|
|
return
|
|
}
|
|
|
|
// If the last entry had a sibling attribute,
|
|
// that attribute gives the offset of the next
|
|
// sibling, so we can avoid decoding the
|
|
// child subtrees.
|
|
if r.lastSibling >= r.b.off {
|
|
r.Seek(r.lastSibling)
|
|
return
|
|
}
|
|
|
|
for {
|
|
e, err := r.Next()
|
|
if err != nil || e == nil || e.Tag == 0 {
|
|
break
|
|
}
|
|
if e.Children {
|
|
r.SkipChildren()
|
|
}
|
|
}
|
|
}
|
|
|
|
// clone returns a copy of the reader. This is used by the typeReader
|
|
// interface.
|
|
func (r *Reader) clone() typeReader {
|
|
return r.d.Reader()
|
|
}
|
|
|
|
// offset returns the current buffer offset. This is used by the
|
|
// typeReader interface.
|
|
func (r *Reader) offset() Offset {
|
|
return r.b.off
|
|
}
|