open.go

Documentation: debug/dwarf

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  // Package dwarf provides access to DWARF debugging information loaded from
		 6  // executable files, as defined in the DWARF 2.0 Standard at
		 7  // http://dwarfstd.org/doc/dwarf-2.0.0.pdf
		 8  package dwarf
		 9  
		10  import (
		11  	"encoding/binary"
		12  	"errors"
		13  )
		14  
		15  // Data represents the DWARF debugging information
		16  // loaded from an executable file (for example, an ELF or Mach-O executable).
		17  type Data struct {
		18  	// raw data
		19  	abbrev	 []byte
		20  	aranges	[]byte
		21  	frame		[]byte
		22  	info		 []byte
		23  	line		 []byte
		24  	pubnames []byte
		25  	ranges	 []byte
		26  	str			[]byte
		27  
		28  	// New sections added in DWARF 5.
		29  	addr			 []byte
		30  	lineStr		[]byte
		31  	strOffsets []byte
		32  	rngLists	 []byte
		33  
		34  	// parsed data
		35  	abbrevCache map[uint64]abbrevTable
		36  	bigEndian	 bool
		37  	order			 binary.ByteOrder
		38  	typeCache	 map[Offset]Type
		39  	typeSigs		map[uint64]*typeUnit
		40  	unit				[]unit
		41  }
		42  
		43  var errSegmentSelector = errors.New("non-zero segment_selector size not supported")
		44  
		45  // New returns a new Data object initialized from the given parameters.
		46  // Rather than calling this function directly, clients should typically use
		47  // the DWARF method of the File type of the appropriate package debug/elf,
		48  // debug/macho, or debug/pe.
		49  //
		50  // The []byte arguments are the data from the corresponding debug section
		51  // in the object file; for example, for an ELF object, abbrev is the contents of
		52  // the ".debug_abbrev" section.
		53  func New(abbrev, aranges, frame, info, line, pubnames, ranges, str []byte) (*Data, error) {
		54  	d := &Data{
		55  		abbrev:			abbrev,
		56  		aranges:		 aranges,
		57  		frame:			 frame,
		58  		info:				info,
		59  		line:				line,
		60  		pubnames:		pubnames,
		61  		ranges:			ranges,
		62  		str:				 str,
		63  		abbrevCache: make(map[uint64]abbrevTable),
		64  		typeCache:	 make(map[Offset]Type),
		65  		typeSigs:		make(map[uint64]*typeUnit),
		66  	}
		67  
		68  	// Sniff .debug_info to figure out byte order.
		69  	// 32-bit DWARF: 4 byte length, 2 byte version.
		70  	// 64-bit DWARf: 4 bytes of 0xff, 8 byte length, 2 byte version.
		71  	if len(d.info) < 6 {
		72  		return nil, DecodeError{"info", Offset(len(d.info)), "too short"}
		73  	}
		74  	offset := 4
		75  	if d.info[0] == 0xff && d.info[1] == 0xff && d.info[2] == 0xff && d.info[3] == 0xff {
		76  		if len(d.info) < 14 {
		77  			return nil, DecodeError{"info", Offset(len(d.info)), "too short"}
		78  		}
		79  		offset = 12
		80  	}
		81  	// Fetch the version, a tiny 16-bit number (1, 2, 3, 4, 5).
		82  	x, y := d.info[offset], d.info[offset+1]
		83  	switch {
		84  	case x == 0 && y == 0:
		85  		return nil, DecodeError{"info", 4, "unsupported version 0"}
		86  	case x == 0:
		87  		d.bigEndian = true
		88  		d.order = binary.BigEndian
		89  	case y == 0:
		90  		d.bigEndian = false
		91  		d.order = binary.LittleEndian
		92  	default:
		93  		return nil, DecodeError{"info", 4, "cannot determine byte order"}
		94  	}
		95  
		96  	u, err := d.parseUnits()
		97  	if err != nil {
		98  		return nil, err
		99  	}
	 100  	d.unit = u
	 101  	return d, nil
	 102  }
	 103  
	 104  // AddTypes will add one .debug_types section to the DWARF data. A
	 105  // typical object with DWARF version 4 debug info will have multiple
	 106  // .debug_types sections. The name is used for error reporting only,
	 107  // and serves to distinguish one .debug_types section from another.
	 108  func (d *Data) AddTypes(name string, types []byte) error {
	 109  	return d.parseTypes(name, types)
	 110  }
	 111  
	 112  // AddSection adds another DWARF section by name. The name should be a
	 113  // DWARF section name such as ".debug_addr", ".debug_str_offsets", and
	 114  // so forth. This approach is used for new DWARF sections added in
	 115  // DWARF 5 and later.
	 116  func (d *Data) AddSection(name string, contents []byte) error {
	 117  	var err error
	 118  	switch name {
	 119  	case ".debug_addr":
	 120  		d.addr = contents
	 121  	case ".debug_line_str":
	 122  		d.lineStr = contents
	 123  	case ".debug_str_offsets":
	 124  		d.strOffsets = contents
	 125  	case ".debug_rnglists":
	 126  		d.rngLists = contents
	 127  	}
	 128  	// Just ignore names that we don't yet support.
	 129  	return err
	 130  }
	 131
View as plain text