...
Run Format

Source file src/debug/dwarf/typeunit.go

Documentation: debug/dwarf

     1  // Copyright 2012 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
     6  
     7  import (
     8  	"fmt"
     9  	"strconv"
    10  )
    11  
    12  // Parse the type units stored in a DWARF4 .debug_types section. Each
    13  // type unit defines a single primary type and an 8-byte signature.
    14  // Other sections may then use formRefSig8 to refer to the type.
    15  
    16  // The typeUnit format is a single type with a signature. It holds
    17  // the same data as a compilation unit.
    18  type typeUnit struct {
    19  	unit
    20  	toff  Offset // Offset to signature type within data.
    21  	name  string // Name of .debug_type section.
    22  	cache Type   // Cache the type, nil to start.
    23  }
    24  
    25  // Parse a .debug_types section.
    26  func (d *Data) parseTypes(name string, types []byte) error {
    27  	b := makeBuf(d, unknownFormat{}, name, 0, types)
    28  	for len(b.data) > 0 {
    29  		base := b.off
    30  		n, dwarf64 := b.unitLength()
    31  		if n != Offset(uint32(n)) {
    32  			b.error("type unit length overflow")
    33  			return b.err
    34  		}
    35  		hdroff := b.off
    36  		vers := int(b.uint16())
    37  		if vers != 4 {
    38  			b.error("unsupported DWARF version " + strconv.Itoa(vers))
    39  			return b.err
    40  		}
    41  		var ao uint64
    42  		if !dwarf64 {
    43  			ao = uint64(b.uint32())
    44  		} else {
    45  			ao = b.uint64()
    46  		}
    47  		atable, err := d.parseAbbrev(ao, vers)
    48  		if err != nil {
    49  			return err
    50  		}
    51  		asize := b.uint8()
    52  		sig := b.uint64()
    53  
    54  		var toff uint32
    55  		if !dwarf64 {
    56  			toff = b.uint32()
    57  		} else {
    58  			to64 := b.uint64()
    59  			if to64 != uint64(uint32(to64)) {
    60  				b.error("type unit type offset overflow")
    61  				return b.err
    62  			}
    63  			toff = uint32(to64)
    64  		}
    65  
    66  		boff := b.off
    67  		d.typeSigs[sig] = &typeUnit{
    68  			unit: unit{
    69  				base:   base,
    70  				off:    boff,
    71  				data:   b.bytes(int(n - (b.off - hdroff))),
    72  				atable: atable,
    73  				asize:  int(asize),
    74  				vers:   vers,
    75  				is64:   dwarf64,
    76  			},
    77  			toff: Offset(toff),
    78  			name: name,
    79  		}
    80  		if b.err != nil {
    81  			return b.err
    82  		}
    83  	}
    84  	return nil
    85  }
    86  
    87  // Return the type for a type signature.
    88  func (d *Data) sigToType(sig uint64) (Type, error) {
    89  	tu := d.typeSigs[sig]
    90  	if tu == nil {
    91  		return nil, fmt.Errorf("no type unit with signature %v", sig)
    92  	}
    93  	if tu.cache != nil {
    94  		return tu.cache, nil
    95  	}
    96  
    97  	b := makeBuf(d, tu, tu.name, tu.off, tu.data)
    98  	r := &typeUnitReader{d: d, tu: tu, b: b}
    99  	t, err := d.readType(tu.name, r, tu.toff, make(map[Offset]Type), nil)
   100  	if err != nil {
   101  		return nil, err
   102  	}
   103  
   104  	tu.cache = t
   105  	return t, nil
   106  }
   107  
   108  // typeUnitReader is a typeReader for a tagTypeUnit.
   109  type typeUnitReader struct {
   110  	d   *Data
   111  	tu  *typeUnit
   112  	b   buf
   113  	err error
   114  }
   115  
   116  // Seek to a new position in the type unit.
   117  func (tur *typeUnitReader) Seek(off Offset) {
   118  	tur.err = nil
   119  	doff := off - tur.tu.off
   120  	if doff < 0 || doff >= Offset(len(tur.tu.data)) {
   121  		tur.err = fmt.Errorf("%s: offset %d out of range; max %d", tur.tu.name, doff, len(tur.tu.data))
   122  		return
   123  	}
   124  	tur.b = makeBuf(tur.d, tur.tu, tur.tu.name, off, tur.tu.data[doff:])
   125  }
   126  
   127  // AddressSize returns the size in bytes of addresses in the current type unit.
   128  func (tur *typeUnitReader) AddressSize() int {
   129  	return tur.tu.unit.asize
   130  }
   131  
   132  // Next reads the next Entry from the type unit.
   133  func (tur *typeUnitReader) Next() (*Entry, error) {
   134  	if tur.err != nil {
   135  		return nil, tur.err
   136  	}
   137  	if len(tur.tu.data) == 0 {
   138  		return nil, nil
   139  	}
   140  	e := tur.b.entry(tur.tu.atable, tur.tu.base)
   141  	if tur.b.err != nil {
   142  		tur.err = tur.b.err
   143  		return nil, tur.err
   144  	}
   145  	return e, nil
   146  }
   147  
   148  // clone returns a new reader for the type unit.
   149  func (tur *typeUnitReader) clone() typeReader {
   150  	return &typeUnitReader{
   151  		d:  tur.d,
   152  		tu: tur.tu,
   153  		b:  makeBuf(tur.d, tur.tu, tur.tu.name, tur.tu.off, tur.tu.data),
   154  	}
   155  }
   156  
   157  // offset returns the current offset.
   158  func (tur *typeUnitReader) offset() Offset {
   159  	return tur.b.off
   160  }
   161  

View as plain text