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 []byte // 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 []byte, 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, 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(nil, &tur.tu.unit)
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