/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/lib/CodeGen/AsmPrinter/DIE.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- lib/CodeGen/DIE.cpp - DWARF Info Entries -------------------------===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | // |
10 | | // Data structures for DWARF info entries. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #include "llvm/CodeGen/DIE.h" |
15 | | #include "DwarfCompileUnit.h" |
16 | | #include "DwarfDebug.h" |
17 | | #include "DwarfUnit.h" |
18 | | #include "llvm/ADT/Twine.h" |
19 | | #include "llvm/CodeGen/AsmPrinter.h" |
20 | | #include "llvm/IR/DataLayout.h" |
21 | | #include "llvm/MC/MCAsmInfo.h" |
22 | | #include "llvm/MC/MCContext.h" |
23 | | #include "llvm/MC/MCStreamer.h" |
24 | | #include "llvm/MC/MCSymbol.h" |
25 | | #include "llvm/Support/Debug.h" |
26 | | #include "llvm/Support/ErrorHandling.h" |
27 | | #include "llvm/Support/Format.h" |
28 | | #include "llvm/Support/FormattedStream.h" |
29 | | #include "llvm/Support/LEB128.h" |
30 | | #include "llvm/Support/MD5.h" |
31 | | #include "llvm/Support/raw_ostream.h" |
32 | | using namespace llvm; |
33 | | |
34 | | #define DEBUG_TYPE "dwarfdebug" |
35 | | |
36 | | //===----------------------------------------------------------------------===// |
37 | | // DIEAbbrevData Implementation |
38 | | //===----------------------------------------------------------------------===// |
39 | | |
40 | | /// Profile - Used to gather unique data for the abbreviation folding set. |
41 | | /// |
42 | 443k | void DIEAbbrevData::Profile(FoldingSetNodeID &ID) const { |
43 | 443k | // Explicitly cast to an integer type for which FoldingSetNodeID has |
44 | 443k | // overloads. Otherwise MSVC 2010 thinks this call is ambiguous. |
45 | 443k | ID.AddInteger(unsigned(Attribute)); |
46 | 443k | ID.AddInteger(unsigned(Form)); |
47 | 443k | if (Form == dwarf::DW_FORM_implicit_const) |
48 | 6 | ID.AddInteger(Value); |
49 | 443k | } |
50 | | |
51 | | //===----------------------------------------------------------------------===// |
52 | | // DIEAbbrev Implementation |
53 | | //===----------------------------------------------------------------------===// |
54 | | |
55 | | /// Profile - Used to gather unique data for the abbreviation folding set. |
56 | | /// |
57 | 117k | void DIEAbbrev::Profile(FoldingSetNodeID &ID) const { |
58 | 117k | ID.AddInteger(unsigned(Tag)); |
59 | 117k | ID.AddInteger(unsigned(Children)); |
60 | 117k | |
61 | 117k | // For each attribute description. |
62 | 560k | for (unsigned i = 0, N = Data.size(); i < N560k ; ++i443k ) |
63 | 443k | Data[i].Profile(ID); |
64 | 117k | } |
65 | | |
66 | | /// Emit - Print the abbreviation using the specified asm printer. |
67 | | /// |
68 | 10.0k | void DIEAbbrev::Emit(const AsmPrinter *AP) const { |
69 | 10.0k | // Emit its Dwarf tag type. |
70 | 10.0k | AP->EmitULEB128(Tag, dwarf::TagString(Tag).data()); |
71 | 10.0k | |
72 | 10.0k | // Emit whether it has children DIEs. |
73 | 10.0k | AP->EmitULEB128((unsigned)Children, dwarf::ChildrenString(Children).data()); |
74 | 10.0k | |
75 | 10.0k | // For each attribute description. |
76 | 54.7k | for (unsigned i = 0, N = Data.size(); i < N54.7k ; ++i44.7k ) { |
77 | 44.7k | const DIEAbbrevData &AttrData = Data[i]; |
78 | 44.7k | |
79 | 44.7k | // Emit attribute type. |
80 | 44.7k | AP->EmitULEB128(AttrData.getAttribute(), |
81 | 44.7k | dwarf::AttributeString(AttrData.getAttribute()).data()); |
82 | 44.7k | |
83 | 44.7k | // Emit form type. |
84 | | #ifndef NDEBUG |
85 | | // Could be an assertion, but this way we can see the failing form code |
86 | | // easily, which helps track down where it came from. |
87 | | if (!dwarf::isValidFormForVersion(AttrData.getForm(), |
88 | | AP->getDwarfVersion())) { |
89 | | DEBUG(dbgs() << "Invalid form " << format("0x%x", AttrData.getForm()) |
90 | | << " for DWARF version " << AP->getDwarfVersion() << "\n"); |
91 | | llvm_unreachable("Invalid form for specified DWARF version"); |
92 | | } |
93 | | #endif |
94 | | AP->EmitULEB128(AttrData.getForm(), |
95 | 44.7k | dwarf::FormEncodingString(AttrData.getForm()).data()); |
96 | 44.7k | |
97 | 44.7k | // Emit value for DW_FORM_implicit_const. |
98 | 44.7k | if (AttrData.getForm() == dwarf::DW_FORM_implicit_const) |
99 | 4 | AP->EmitSLEB128(AttrData.getValue()); |
100 | 44.7k | } |
101 | 10.0k | |
102 | 10.0k | // Mark end of abbreviation. |
103 | 10.0k | AP->EmitULEB128(0, "EOM(1)"); |
104 | 10.0k | AP->EmitULEB128(0, "EOM(2)"); |
105 | 10.0k | } |
106 | | |
107 | | LLVM_DUMP_METHOD |
108 | 0 | void DIEAbbrev::print(raw_ostream &O) const { |
109 | 0 | O << "Abbreviation @" |
110 | 0 | << format("0x%lx", (long)(intptr_t)this) |
111 | 0 | << " " |
112 | 0 | << dwarf::TagString(Tag) |
113 | 0 | << " " |
114 | 0 | << dwarf::ChildrenString(Children) |
115 | 0 | << '\n'; |
116 | 0 |
|
117 | 0 | for (unsigned i = 0, N = Data.size(); i < N0 ; ++i0 ) { |
118 | 0 | O << " " |
119 | 0 | << dwarf::AttributeString(Data[i].getAttribute()) |
120 | 0 | << " " |
121 | 0 | << dwarf::FormEncodingString(Data[i].getForm()); |
122 | 0 |
|
123 | 0 | if (Data[i].getForm() == dwarf::DW_FORM_implicit_const) |
124 | 0 | O << " " << Data[i].getValue(); |
125 | 0 |
|
126 | 0 | O << '\n'; |
127 | 0 | } |
128 | 0 | } |
129 | | |
130 | | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
131 | | LLVM_DUMP_METHOD void DIEAbbrev::dump() const { |
132 | | print(dbgs()); |
133 | | } |
134 | | #endif |
135 | | |
136 | | //===----------------------------------------------------------------------===// |
137 | | // DIEAbbrevSet Implementation |
138 | | //===----------------------------------------------------------------------===// |
139 | | |
140 | 65.9k | DIEAbbrevSet::~DIEAbbrevSet() { |
141 | 65.9k | for (DIEAbbrev *Abbrev : Abbreviations) |
142 | 9.52k | Abbrev->~DIEAbbrev(); |
143 | 65.9k | } |
144 | | |
145 | 61.6k | DIEAbbrev &DIEAbbrevSet::uniqueAbbreviation(DIE &Die) { |
146 | 61.6k | |
147 | 61.6k | FoldingSetNodeID ID; |
148 | 61.6k | DIEAbbrev Abbrev = Die.generateAbbrev(); |
149 | 61.6k | Abbrev.Profile(ID); |
150 | 61.6k | |
151 | 61.6k | void *InsertPos; |
152 | 61.6k | if (DIEAbbrev *Existing = |
153 | 52.1k | AbbreviationsSet.FindNodeOrInsertPos(ID, InsertPos)) { |
154 | 52.1k | Die.setAbbrevNumber(Existing->getNumber()); |
155 | 52.1k | return *Existing; |
156 | 52.1k | } |
157 | 9.52k | |
158 | 9.52k | // Move the abbreviation to the heap and assign a number. |
159 | 9.52k | DIEAbbrev *New = new (Alloc) DIEAbbrev(std::move(Abbrev)); |
160 | 9.52k | Abbreviations.push_back(New); |
161 | 9.52k | New->setNumber(Abbreviations.size()); |
162 | 9.52k | Die.setAbbrevNumber(Abbreviations.size()); |
163 | 9.52k | |
164 | 9.52k | // Store it for lookup. |
165 | 9.52k | AbbreviationsSet.InsertNode(New, InsertPos); |
166 | 9.52k | return *New; |
167 | 9.52k | } |
168 | | |
169 | 1.52k | void DIEAbbrevSet::Emit(const AsmPrinter *AP, MCSection *Section) const { |
170 | 1.52k | if (!Abbreviations.empty()1.52k ) { |
171 | 1.19k | // Start the debug abbrev section. |
172 | 1.19k | AP->OutStreamer->SwitchSection(Section); |
173 | 1.19k | AP->emitDwarfAbbrevs(Abbreviations); |
174 | 1.19k | } |
175 | 1.52k | } |
176 | | |
177 | | //===----------------------------------------------------------------------===// |
178 | | // DIE Implementation |
179 | | //===----------------------------------------------------------------------===// |
180 | | |
181 | 204k | DIE *DIE::getParent() const { |
182 | 204k | return Owner.dyn_cast<DIE*>(); |
183 | 204k | } |
184 | | |
185 | 62.5k | DIEAbbrev DIE::generateAbbrev() const { |
186 | 62.5k | DIEAbbrev Abbrev(Tag, hasChildren()); |
187 | 62.5k | for (const DIEValue &V : values()) |
188 | 239k | if (239k V.getForm() == dwarf::DW_FORM_implicit_const239k ) |
189 | 5 | Abbrev.AddImplicitConstAttribute(V.getAttribute(), |
190 | 5 | V.getDIEInteger().getValue()); |
191 | 239k | else |
192 | 239k | Abbrev.AddAttribute(V.getAttribute(), V.getForm()); |
193 | 62.5k | return Abbrev; |
194 | 62.5k | } |
195 | | |
196 | 44.4k | unsigned DIE::getDebugSectionOffset() const { |
197 | 44.4k | const DIEUnit *Unit = getUnit(); |
198 | 44.4k | assert(Unit && "DIE must be owned by a DIEUnit to get its absolute offset"); |
199 | 44.4k | return Unit->getDebugSectionOffset() + getOffset(); |
200 | 44.4k | } |
201 | | |
202 | 159k | const DIE *DIE::getUnitDie() const { |
203 | 159k | const DIE *p = this; |
204 | 364k | while (p364k ) { |
205 | 330k | if (p->getTag() == dwarf::DW_TAG_compile_unit || |
206 | 204k | p->getTag() == dwarf::DW_TAG_type_unit) |
207 | 125k | return p; |
208 | 204k | p = p->getParent(); |
209 | 204k | } |
210 | 34.2k | return nullptr; |
211 | 159k | } |
212 | | |
213 | 158k | const DIEUnit *DIE::getUnit() const { |
214 | 158k | const DIE *UnitDie = getUnitDie(); |
215 | 158k | if (UnitDie) |
216 | 124k | return UnitDie->Owner.dyn_cast<DIEUnit*>(); |
217 | 34.2k | return nullptr; |
218 | 34.2k | } |
219 | | |
220 | 100 | DIEValue DIE::findAttribute(dwarf::Attribute Attribute) const { |
221 | 100 | // Iterate through all the attributes until we find the one we're |
222 | 100 | // looking for, if we can't find it return NULL. |
223 | 100 | for (const auto &V : values()) |
224 | 449 | if (449 V.getAttribute() == Attribute449 ) |
225 | 28 | return V; |
226 | 72 | return DIEValue(); |
227 | 72 | } |
228 | | |
229 | | LLVM_DUMP_METHOD |
230 | | static void printValues(raw_ostream &O, const DIEValueList &Values, |
231 | 0 | StringRef Type, unsigned Size, unsigned IndentCount) { |
232 | 0 | O << Type << ": Size: " << Size << "\n"; |
233 | 0 |
|
234 | 0 | unsigned I = 0; |
235 | 0 | const std::string Indent(IndentCount, ' '); |
236 | 0 | for (const auto &V : Values.values()) { |
237 | 0 | O << Indent; |
238 | 0 | O << "Blk[" << I++ << "]"; |
239 | 0 | O << " " << dwarf::FormEncodingString(V.getForm()) << " "; |
240 | 0 | V.print(O); |
241 | 0 | O << "\n"; |
242 | 0 | } |
243 | 0 | } |
244 | | |
245 | | LLVM_DUMP_METHOD |
246 | 0 | void DIE::print(raw_ostream &O, unsigned IndentCount) const { |
247 | 0 | const std::string Indent(IndentCount, ' '); |
248 | 0 | O << Indent << "Die: " << format("0x%lx", (long)(intptr_t) this) |
249 | 0 | << ", Offset: " << Offset << ", Size: " << Size << "\n"; |
250 | 0 |
|
251 | 0 | O << Indent << dwarf::TagString(getTag()) << " " |
252 | 0 | << dwarf::ChildrenString(hasChildren()) << "\n"; |
253 | 0 |
|
254 | 0 | IndentCount += 2; |
255 | 0 | for (const auto &V : values()) { |
256 | 0 | O << Indent; |
257 | 0 | O << dwarf::AttributeString(V.getAttribute()); |
258 | 0 | O << " " << dwarf::FormEncodingString(V.getForm()) << " "; |
259 | 0 | V.print(O); |
260 | 0 | O << "\n"; |
261 | 0 | } |
262 | 0 | IndentCount -= 2; |
263 | 0 |
|
264 | 0 | for (const auto &Child : children()) |
265 | 0 | Child.print(O, IndentCount + 4); |
266 | 0 |
|
267 | 0 | O << "\n"; |
268 | 0 | } |
269 | | |
270 | | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
271 | | LLVM_DUMP_METHOD void DIE::dump() const { |
272 | | print(dbgs()); |
273 | | } |
274 | | #endif |
275 | | |
276 | | unsigned DIE::computeOffsetsAndAbbrevs(const AsmPrinter *AP, |
277 | | DIEAbbrevSet &AbbrevSet, |
278 | 61.6k | unsigned CUOffset) { |
279 | 61.6k | // Unique the abbreviation and fill in the abbreviation number so this DIE |
280 | 61.6k | // can be emitted. |
281 | 61.6k | const DIEAbbrev &Abbrev = AbbrevSet.uniqueAbbreviation(*this); |
282 | 61.6k | |
283 | 61.6k | // Set compile/type unit relative offset of this DIE. |
284 | 61.6k | setOffset(CUOffset); |
285 | 61.6k | |
286 | 61.6k | // Add the byte size of the abbreviation code. |
287 | 61.6k | CUOffset += getULEB128Size(getAbbrevNumber()); |
288 | 61.6k | |
289 | 61.6k | // Add the byte size of all the DIE attribute values. |
290 | 61.6k | for (const auto &V : values()) |
291 | 234k | CUOffset += V.SizeOf(AP); |
292 | 61.6k | |
293 | 61.6k | // Let the children compute their offsets and abbreviation numbers. |
294 | 61.6k | if (hasChildren()61.6k ) { |
295 | 22.5k | (void)Abbrev; |
296 | 22.5k | assert(Abbrev.hasChildren() && "Children flag not set"); |
297 | 22.5k | |
298 | 22.5k | for (auto &Child : children()) |
299 | 60.3k | CUOffset = Child.computeOffsetsAndAbbrevs(AP, AbbrevSet, CUOffset); |
300 | 22.5k | |
301 | 22.5k | // Each child chain is terminated with a zero byte, adjust the offset. |
302 | 22.5k | CUOffset += sizeof(int8_t); |
303 | 22.5k | } |
304 | 61.6k | |
305 | 61.6k | // Compute the byte size of this DIE and all of its children correctly. This |
306 | 61.6k | // is needed so that top level DIE can help the compile unit set its length |
307 | 61.6k | // correctly. |
308 | 61.6k | setSize(CUOffset - getOffset()); |
309 | 61.6k | return CUOffset; |
310 | 61.6k | } |
311 | | |
312 | | //===----------------------------------------------------------------------===// |
313 | | // DIEUnit Implementation |
314 | | //===----------------------------------------------------------------------===// |
315 | | DIEUnit::DIEUnit(uint16_t V, uint8_t A, dwarf::Tag UnitTag) |
316 | | : Die(UnitTag), Section(nullptr), Offset(0), Length(0), Version(V), |
317 | | AddrSize(A) |
318 | 1.40k | { |
319 | 1.40k | Die.Owner = this; |
320 | 1.40k | assert((UnitTag == dwarf::DW_TAG_compile_unit || |
321 | 1.40k | UnitTag == dwarf::DW_TAG_type_unit || |
322 | 1.40k | UnitTag == dwarf::DW_TAG_partial_unit) && "expected a unit TAG"); |
323 | 1.40k | } |
324 | | |
325 | 243k | void DIEValue::EmitValue(const AsmPrinter *AP) const { |
326 | 243k | switch (Ty) { |
327 | 0 | case isNone: |
328 | 0 | llvm_unreachable("Expected valid DIEValue"); |
329 | 243k | #define HANDLE_DIEVALUE(T) \ |
330 | 243k | case is##T: \ |
331 | 243k | getDIE##T().EmitValue(AP, Form); \ |
332 | 243k | break; |
333 | 91.4k | #include "llvm/CodeGen/DIEValue.def" |
334 | 243k | } |
335 | 243k | } |
336 | | |
337 | 239k | unsigned DIEValue::SizeOf(const AsmPrinter *AP) const { |
338 | 239k | switch (Ty) { |
339 | 0 | case isNone: |
340 | 0 | llvm_unreachable("Expected valid DIEValue"); |
341 | 239k | #define HANDLE_DIEVALUE(T) \ |
342 | 239k | case is##T: \ |
343 | 239k | return getDIE##T().SizeOf(AP, Form); |
344 | 87.8k | #include "llvm/CodeGen/DIEValue.def" |
345 | 239k | } |
346 | 0 | llvm_unreachable0 ("Unknown DIE kind"); |
347 | 0 | } |
348 | | |
349 | | LLVM_DUMP_METHOD |
350 | 0 | void DIEValue::print(raw_ostream &O) const { |
351 | 0 | switch (Ty) { |
352 | 0 | case isNone: |
353 | 0 | llvm_unreachable("Expected valid DIEValue"); |
354 | 0 | #define HANDLE_DIEVALUE(T) \ |
355 | 0 | case is##T: \ |
356 | 0 | getDIE##T().print(O); \ |
357 | 0 | break; |
358 | 0 | #include "llvm/CodeGen/DIEValue.def" |
359 | 0 | } |
360 | 0 | } |
361 | | |
362 | | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
363 | | LLVM_DUMP_METHOD void DIEValue::dump() const { |
364 | | print(dbgs()); |
365 | | } |
366 | | #endif |
367 | | |
368 | | //===----------------------------------------------------------------------===// |
369 | | // DIEInteger Implementation |
370 | | //===----------------------------------------------------------------------===// |
371 | | |
372 | | /// EmitValue - Emit integer of appropriate size. |
373 | | /// |
374 | 115k | void DIEInteger::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const { |
375 | 115k | switch (Form) { |
376 | 2.64k | case dwarf::DW_FORM_implicit_const: |
377 | 2.64k | case dwarf::DW_FORM_flag_present: |
378 | 2.64k | // Emit something to keep the lines and comments in sync. |
379 | 2.64k | // FIXME: Is there a better way to do this? |
380 | 2.64k | Asm->OutStreamer->AddBlankLine(); |
381 | 2.64k | return; |
382 | 111k | case dwarf::DW_FORM_flag: |
383 | 111k | case dwarf::DW_FORM_ref1: |
384 | 111k | case dwarf::DW_FORM_data1: |
385 | 111k | case dwarf::DW_FORM_strx1: |
386 | 111k | case dwarf::DW_FORM_addrx1: |
387 | 111k | case dwarf::DW_FORM_ref2: |
388 | 111k | case dwarf::DW_FORM_data2: |
389 | 111k | case dwarf::DW_FORM_strx2: |
390 | 111k | case dwarf::DW_FORM_addrx2: |
391 | 111k | case dwarf::DW_FORM_strp: |
392 | 111k | case dwarf::DW_FORM_ref4: |
393 | 111k | case dwarf::DW_FORM_data4: |
394 | 111k | case dwarf::DW_FORM_ref_sup4: |
395 | 111k | case dwarf::DW_FORM_strx4: |
396 | 111k | case dwarf::DW_FORM_addrx4: |
397 | 111k | case dwarf::DW_FORM_ref8: |
398 | 111k | case dwarf::DW_FORM_ref_sig8: |
399 | 111k | case dwarf::DW_FORM_data8: |
400 | 111k | case dwarf::DW_FORM_ref_sup8: |
401 | 111k | case dwarf::DW_FORM_GNU_ref_alt: |
402 | 111k | case dwarf::DW_FORM_GNU_strp_alt: |
403 | 111k | case dwarf::DW_FORM_line_strp: |
404 | 111k | case dwarf::DW_FORM_sec_offset: |
405 | 111k | case dwarf::DW_FORM_strp_sup: |
406 | 111k | case dwarf::DW_FORM_addr: |
407 | 111k | case dwarf::DW_FORM_ref_addr: |
408 | 111k | Asm->OutStreamer->EmitIntValue(Integer, SizeOf(Asm, Form)); |
409 | 111k | return; |
410 | 1.03k | case dwarf::DW_FORM_GNU_str_index: |
411 | 1.03k | case dwarf::DW_FORM_GNU_addr_index: |
412 | 1.03k | case dwarf::DW_FORM_ref_udata: |
413 | 1.03k | case dwarf::DW_FORM_udata: |
414 | 1.03k | Asm->EmitULEB128(Integer); |
415 | 1.03k | return; |
416 | 662 | case dwarf::DW_FORM_sdata: |
417 | 662 | Asm->EmitSLEB128(Integer); |
418 | 662 | return; |
419 | 0 | default: 0 llvm_unreachable0 ("DIE Value form not supported yet"); |
420 | 0 | } |
421 | 0 | } |
422 | | |
423 | | /// SizeOf - Determine size of integer value in bytes. |
424 | | /// |
425 | 224k | unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { |
426 | 224k | switch (Form) { |
427 | 2.58k | case dwarf::DW_FORM_implicit_const: |
428 | 2.58k | case dwarf::DW_FORM_flag_present: |
429 | 2.58k | return 0; |
430 | 153k | case dwarf::DW_FORM_flag: |
431 | 153k | case dwarf::DW_FORM_ref1: |
432 | 153k | case dwarf::DW_FORM_data1: |
433 | 153k | case dwarf::DW_FORM_strx1: |
434 | 153k | case dwarf::DW_FORM_addrx1: |
435 | 153k | return sizeof(int8_t); |
436 | 15.7k | case dwarf::DW_FORM_ref2: |
437 | 15.7k | case dwarf::DW_FORM_data2: |
438 | 15.7k | case dwarf::DW_FORM_strx2: |
439 | 15.7k | case dwarf::DW_FORM_addrx2: |
440 | 15.7k | return sizeof(int16_t); |
441 | 196 | case dwarf::DW_FORM_ref4: |
442 | 196 | case dwarf::DW_FORM_data4: |
443 | 196 | case dwarf::DW_FORM_ref_sup4: |
444 | 196 | case dwarf::DW_FORM_strx4: |
445 | 196 | case dwarf::DW_FORM_addrx4: |
446 | 196 | return sizeof(int32_t); |
447 | 294 | case dwarf::DW_FORM_ref8: |
448 | 294 | case dwarf::DW_FORM_ref_sig8: |
449 | 294 | case dwarf::DW_FORM_data8: |
450 | 294 | case dwarf::DW_FORM_ref_sup8: |
451 | 294 | return sizeof(int64_t); |
452 | 178 | case dwarf::DW_FORM_ref_addr: |
453 | 178 | if (AP->getDwarfVersion() == 2) |
454 | 102 | return AP->getPointerSize(); |
455 | 76 | LLVM_FALLTHROUGH76 ; |
456 | 49.7k | case dwarf::DW_FORM_strp: |
457 | 49.7k | case dwarf::DW_FORM_GNU_ref_alt: |
458 | 49.7k | case dwarf::DW_FORM_GNU_strp_alt: |
459 | 49.7k | case dwarf::DW_FORM_line_strp: |
460 | 49.7k | case dwarf::DW_FORM_sec_offset: |
461 | 49.7k | case dwarf::DW_FORM_strp_sup: |
462 | 49.7k | switch (AP->OutStreamer->getContext().getDwarfFormat()) { |
463 | 49.7k | case dwarf::DWARF32: |
464 | 49.7k | return 4; |
465 | 0 | case dwarf::DWARF64: |
466 | 0 | return 8; |
467 | 0 | } |
468 | 0 | llvm_unreachable0 ("Invalid DWARF format"); |
469 | 1.04k | case dwarf::DW_FORM_GNU_str_index: |
470 | 1.04k | case dwarf::DW_FORM_GNU_addr_index: |
471 | 1.04k | case dwarf::DW_FORM_ref_udata: |
472 | 1.04k | case dwarf::DW_FORM_udata: |
473 | 1.04k | return getULEB128Size(Integer); |
474 | 662 | case dwarf::DW_FORM_sdata: |
475 | 662 | return getSLEB128Size(Integer); |
476 | 519 | case dwarf::DW_FORM_addr: |
477 | 519 | return AP->getPointerSize(); |
478 | 0 | default: 0 llvm_unreachable0 ("DIE Value form not supported yet"); |
479 | 0 | } |
480 | 0 | } |
481 | | |
482 | | LLVM_DUMP_METHOD |
483 | 0 | void DIEInteger::print(raw_ostream &O) const { |
484 | 0 | O << "Int: " << (int64_t)Integer << " 0x"; |
485 | 0 | O.write_hex(Integer); |
486 | 0 | } |
487 | | |
488 | | //===----------------------------------------------------------------------===// |
489 | | // DIEExpr Implementation |
490 | | //===----------------------------------------------------------------------===// |
491 | | |
492 | | /// EmitValue - Emit expression value. |
493 | | /// |
494 | 11 | void DIEExpr::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { |
495 | 11 | AP->EmitDebugThreadLocal(Expr, SizeOf(AP, Form)); |
496 | 11 | } |
497 | | |
498 | | /// SizeOf - Determine size of expression value in bytes. |
499 | | /// |
500 | 22 | unsigned DIEExpr::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { |
501 | 22 | if (Form == dwarf::DW_FORM_data422 ) return 40 ; |
502 | 22 | if (22 Form == dwarf::DW_FORM_sec_offset22 ) return 40 ; |
503 | 22 | if (22 Form == dwarf::DW_FORM_strp22 ) return 40 ; |
504 | 22 | return AP->getPointerSize(); |
505 | 22 | } |
506 | | |
507 | | LLVM_DUMP_METHOD |
508 | 0 | void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; } |
509 | | |
510 | | //===----------------------------------------------------------------------===// |
511 | | // DIELabel Implementation |
512 | | //===----------------------------------------------------------------------===// |
513 | | |
514 | | /// EmitValue - Emit label value. |
515 | | /// |
516 | 73.7k | void DIELabel::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { |
517 | 73.7k | AP->EmitLabelReference(Label, SizeOf(AP, Form), |
518 | 73.7k | Form == dwarf::DW_FORM_strp || |
519 | 71.1k | Form == dwarf::DW_FORM_sec_offset || |
520 | 70.8k | Form == dwarf::DW_FORM_ref_addr || |
521 | 70.8k | Form == dwarf::DW_FORM_data4); |
522 | 73.7k | } |
523 | | |
524 | | /// SizeOf - Determine size of label value in bytes. |
525 | | /// |
526 | 147k | unsigned DIELabel::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { |
527 | 147k | if (Form == dwarf::DW_FORM_data4147k ) return 4102 ; |
528 | 147k | if (147k Form == dwarf::DW_FORM_sec_offset147k ) return 4656 ; |
529 | 146k | if (146k Form == dwarf::DW_FORM_strp146k ) return 45.09k ; |
530 | 141k | return AP->MAI->getCodePointerSize(); |
531 | 141k | } |
532 | | |
533 | | LLVM_DUMP_METHOD |
534 | 0 | void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); } |
535 | | |
536 | | //===----------------------------------------------------------------------===// |
537 | | // DIEDelta Implementation |
538 | | //===----------------------------------------------------------------------===// |
539 | | |
540 | | /// EmitValue - Emit delta value. |
541 | | /// |
542 | 10.7k | void DIEDelta::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { |
543 | 10.7k | AP->EmitLabelDifference(LabelHi, LabelLo, SizeOf(AP, Form)); |
544 | 10.7k | } |
545 | | |
546 | | /// SizeOf - Determine size of delta value in bytes. |
547 | | /// |
548 | 21.5k | unsigned DIEDelta::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { |
549 | 21.5k | if (Form == dwarf::DW_FORM_data421.5k ) return 420.9k ; |
550 | 602 | if (602 Form == dwarf::DW_FORM_sec_offset602 ) return 4602 ; |
551 | 0 | if (0 Form == dwarf::DW_FORM_strp0 ) return 40 ; |
552 | 0 | return AP->MAI->getCodePointerSize(); |
553 | 0 | } |
554 | | |
555 | | LLVM_DUMP_METHOD |
556 | 0 | void DIEDelta::print(raw_ostream &O) const { |
557 | 0 | O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName(); |
558 | 0 | } |
559 | | |
560 | | //===----------------------------------------------------------------------===// |
561 | | // DIEString Implementation |
562 | | //===----------------------------------------------------------------------===// |
563 | | |
564 | | /// EmitValue - Emit string value. |
565 | | /// |
566 | 27.1k | void DIEString::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { |
567 | 27.1k | assert( |
568 | 27.1k | (Form == dwarf::DW_FORM_strp || Form == dwarf::DW_FORM_GNU_str_index) && |
569 | 27.1k | "Expected valid string form"); |
570 | 27.1k | |
571 | 27.1k | // Index of string in symbol table. |
572 | 27.1k | if (Form == dwarf::DW_FORM_GNU_str_index27.1k ) { |
573 | 301 | DIEInteger(S.getIndex()).EmitValue(AP, Form); |
574 | 301 | return; |
575 | 301 | } |
576 | 26.8k | |
577 | 26.8k | // Relocatable symbol. |
578 | 27.1k | assert(Form == dwarf::DW_FORM_strp); |
579 | 26.8k | if (AP->MAI->doesDwarfUseRelocationsAcrossSections()26.8k ) { |
580 | 2.54k | DIELabel(S.getSymbol()).EmitValue(AP, Form); |
581 | 2.54k | return; |
582 | 2.54k | } |
583 | 24.2k | |
584 | 24.2k | // Offset into symbol table. |
585 | 24.2k | DIEInteger(S.getOffset()).EmitValue(AP, Form); |
586 | 24.2k | } |
587 | | |
588 | | /// SizeOf - Determine size of delta value in bytes. |
589 | | /// |
590 | 27.1k | unsigned DIEString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { |
591 | 27.1k | assert( |
592 | 27.1k | (Form == dwarf::DW_FORM_strp || Form == dwarf::DW_FORM_GNU_str_index) && |
593 | 27.1k | "Expected valid string form"); |
594 | 27.1k | |
595 | 27.1k | // Index of string in symbol table. |
596 | 27.1k | if (Form == dwarf::DW_FORM_GNU_str_index) |
597 | 301 | return DIEInteger(S.getIndex()).SizeOf(AP, Form); |
598 | 26.8k | |
599 | 26.8k | // Relocatable symbol. |
600 | 26.8k | if (26.8k AP->MAI->doesDwarfUseRelocationsAcrossSections()26.8k ) |
601 | 2.54k | return DIELabel(S.getSymbol()).SizeOf(AP, Form); |
602 | 24.2k | |
603 | 24.2k | // Offset into symbol table. |
604 | 24.2k | return DIEInteger(S.getOffset()).SizeOf(AP, Form); |
605 | 24.2k | } |
606 | | |
607 | | LLVM_DUMP_METHOD |
608 | 0 | void DIEString::print(raw_ostream &O) const { |
609 | 0 | O << "String: " << S.getString(); |
610 | 0 | } |
611 | | |
612 | | //===----------------------------------------------------------------------===// |
613 | | // DIEInlineString Implementation |
614 | | //===----------------------------------------------------------------------===// |
615 | 8 | void DIEInlineString::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { |
616 | 8 | if (Form == dwarf::DW_FORM_string8 ) { |
617 | 8 | for (char ch : S) |
618 | 40 | AP->EmitInt8(ch); |
619 | 8 | AP->EmitInt8(0); |
620 | 8 | return; |
621 | 8 | } |
622 | 0 | llvm_unreachable0 ("Expected valid string form"); |
623 | 0 | } |
624 | | |
625 | 8 | unsigned DIEInlineString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { |
626 | 8 | // Emit string bytes + NULL byte. |
627 | 8 | return S.size() + 1; |
628 | 8 | } |
629 | | |
630 | | LLVM_DUMP_METHOD |
631 | 0 | void DIEInlineString::print(raw_ostream &O) const { |
632 | 0 | O << "InlineString: " << S; |
633 | 0 | } |
634 | | |
635 | | //===----------------------------------------------------------------------===// |
636 | | // DIEEntry Implementation |
637 | | //===----------------------------------------------------------------------===// |
638 | | |
639 | | /// EmitValue - Emit debug information entry offset. |
640 | | /// |
641 | 40.3k | void DIEEntry::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { |
642 | 40.3k | |
643 | 40.3k | switch (Form) { |
644 | 40.2k | case dwarf::DW_FORM_ref1: |
645 | 40.2k | case dwarf::DW_FORM_ref2: |
646 | 40.2k | case dwarf::DW_FORM_ref4: |
647 | 40.2k | case dwarf::DW_FORM_ref8: |
648 | 40.2k | AP->OutStreamer->EmitIntValue(Entry->getOffset(), SizeOf(AP, Form)); |
649 | 40.2k | return; |
650 | 40.2k | |
651 | 0 | case dwarf::DW_FORM_ref_udata: |
652 | 0 | AP->EmitULEB128(Entry->getOffset()); |
653 | 0 | return; |
654 | 40.2k | |
655 | 84 | case dwarf::DW_FORM_ref_addr: { |
656 | 84 | // Get the absolute offset for this DIE within the debug info/types section. |
657 | 84 | unsigned Addr = Entry->getDebugSectionOffset(); |
658 | 84 | if (const MCSymbol *SectionSym = |
659 | 13 | Entry->getUnit()->getCrossSectionRelativeBaseAddress()) { |
660 | 13 | AP->EmitLabelPlusOffset(SectionSym, Addr, SizeOf(AP, Form), true); |
661 | 13 | return; |
662 | 13 | } |
663 | 71 | |
664 | 71 | AP->OutStreamer->EmitIntValue(Addr, SizeOf(AP, Form)); |
665 | 71 | return; |
666 | 71 | } |
667 | 0 | default: |
668 | 0 | llvm_unreachable("Improper form for DIE reference"); |
669 | 0 | } |
670 | 0 | } |
671 | | |
672 | 80.2k | unsigned DIEEntry::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { |
673 | 80.2k | switch (Form) { |
674 | 24 | case dwarf::DW_FORM_ref1: |
675 | 24 | return 1; |
676 | 24 | case dwarf::DW_FORM_ref2: |
677 | 24 | return 2; |
678 | 80.0k | case dwarf::DW_FORM_ref4: |
679 | 80.0k | return 4; |
680 | 24 | case dwarf::DW_FORM_ref8: |
681 | 24 | return 8; |
682 | 0 | case dwarf::DW_FORM_ref_udata: |
683 | 0 | return getULEB128Size(Entry->getOffset()); |
684 | 168 | case dwarf::DW_FORM_ref_addr: |
685 | 168 | if (AP->getDwarfVersion() == 2) |
686 | 62 | return AP->MAI->getCodePointerSize(); |
687 | 106 | switch (AP->OutStreamer->getContext().getDwarfFormat()) { |
688 | 106 | case dwarf::DWARF32: |
689 | 106 | return 4; |
690 | 0 | case dwarf::DWARF64: |
691 | 0 | return 8; |
692 | 0 | } |
693 | 0 | llvm_unreachable0 ("Invalid DWARF format"); |
694 | 0 |
|
695 | 0 | default: |
696 | 0 | llvm_unreachable("Improper form for DIE reference"); |
697 | 0 | } |
698 | 0 | } |
699 | | |
700 | | LLVM_DUMP_METHOD |
701 | 0 | void DIEEntry::print(raw_ostream &O) const { |
702 | 0 | O << format("Die: 0x%lx", (long)(intptr_t)&Entry); |
703 | 0 | } |
704 | | |
705 | | //===----------------------------------------------------------------------===// |
706 | | // DIELoc Implementation |
707 | | //===----------------------------------------------------------------------===// |
708 | | |
709 | | /// ComputeSize - calculate the size of the location expression. |
710 | | /// |
711 | 1.89k | unsigned DIELoc::ComputeSize(const AsmPrinter *AP) const { |
712 | 1.89k | if (!Size1.89k ) { |
713 | 1.85k | for (const auto &V : values()) |
714 | 3.15k | Size += V.SizeOf(AP); |
715 | 1.85k | } |
716 | 1.89k | |
717 | 1.89k | return Size; |
718 | 1.89k | } |
719 | | |
720 | | /// EmitValue - Emit location data. |
721 | | /// |
722 | 1.85k | void DIELoc::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const { |
723 | 1.85k | switch (Form) { |
724 | 0 | default: 0 llvm_unreachable0 ("Improper form for block"); |
725 | 355 | case dwarf::DW_FORM_block1: Asm->EmitInt8(Size); break; |
726 | 0 | case dwarf::DW_FORM_block2: Asm->EmitInt16(Size); break; |
727 | 0 | case dwarf::DW_FORM_block4: Asm->EmitInt32(Size); break; |
728 | 1.49k | case dwarf::DW_FORM_block: |
729 | 1.49k | case dwarf::DW_FORM_exprloc: |
730 | 1.49k | Asm->EmitULEB128(Size); break; |
731 | 1.85k | } |
732 | 1.85k | |
733 | 1.85k | for (const auto &V : values()) |
734 | 3.13k | V.EmitValue(Asm); |
735 | 1.85k | } |
736 | | |
737 | | /// SizeOf - Determine size of location data in bytes. |
738 | | /// |
739 | 1.78k | unsigned DIELoc::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { |
740 | 1.78k | switch (Form) { |
741 | 355 | case dwarf::DW_FORM_block1: return Size + sizeof(int8_t); |
742 | 0 | case dwarf::DW_FORM_block2: return Size + sizeof(int16_t); |
743 | 0 | case dwarf::DW_FORM_block4: return Size + sizeof(int32_t); |
744 | 1.43k | case dwarf::DW_FORM_block: |
745 | 1.43k | case dwarf::DW_FORM_exprloc: |
746 | 1.43k | return Size + getULEB128Size(Size); |
747 | 0 | default: 0 llvm_unreachable0 ("Improper form for block"); |
748 | 0 | } |
749 | 0 | } |
750 | | |
751 | | LLVM_DUMP_METHOD |
752 | 0 | void DIELoc::print(raw_ostream &O) const { |
753 | 0 | printValues(O, *this, "ExprLoc", Size, 5); |
754 | 0 | } |
755 | | |
756 | | //===----------------------------------------------------------------------===// |
757 | | // DIEBlock Implementation |
758 | | //===----------------------------------------------------------------------===// |
759 | | |
760 | | /// ComputeSize - calculate the size of the block. |
761 | | /// |
762 | 322 | unsigned DIEBlock::ComputeSize(const AsmPrinter *AP) const { |
763 | 322 | if (!Size322 ) { |
764 | 322 | for (const auto &V : values()) |
765 | 1.22k | Size += V.SizeOf(AP); |
766 | 322 | } |
767 | 322 | |
768 | 322 | return Size; |
769 | 322 | } |
770 | | |
771 | | /// EmitValue - Emit block data. |
772 | | /// |
773 | 321 | void DIEBlock::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const { |
774 | 321 | switch (Form) { |
775 | 0 | default: 0 llvm_unreachable0 ("Improper form for block"); |
776 | 297 | case dwarf::DW_FORM_block1: Asm->EmitInt8(Size); break; |
777 | 8 | case dwarf::DW_FORM_block2: Asm->EmitInt16(Size); break; |
778 | 8 | case dwarf::DW_FORM_block4: Asm->EmitInt32(Size); break; |
779 | 8 | case dwarf::DW_FORM_block: Asm->EmitULEB128(Size); break; |
780 | 321 | } |
781 | 321 | |
782 | 321 | for (const auto &V : values()) |
783 | 1.22k | V.EmitValue(Asm); |
784 | 321 | } |
785 | | |
786 | | /// SizeOf - Determine size of block data in bytes. |
787 | | /// |
788 | 33 | unsigned DIEBlock::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { |
789 | 33 | switch (Form) { |
790 | 9 | case dwarf::DW_FORM_block1: return Size + sizeof(int8_t); |
791 | 8 | case dwarf::DW_FORM_block2: return Size + sizeof(int16_t); |
792 | 8 | case dwarf::DW_FORM_block4: return Size + sizeof(int32_t); |
793 | 8 | case dwarf::DW_FORM_block: return Size + getULEB128Size(Size); |
794 | 0 | default: 0 llvm_unreachable0 ("Improper form for block"); |
795 | 0 | } |
796 | 0 | } |
797 | | |
798 | | LLVM_DUMP_METHOD |
799 | 0 | void DIEBlock::print(raw_ostream &O) const { |
800 | 0 | printValues(O, *this, "Blk", Size, 5); |
801 | 0 | } |
802 | | |
803 | | //===----------------------------------------------------------------------===// |
804 | | // DIELocList Implementation |
805 | | //===----------------------------------------------------------------------===// |
806 | | |
807 | 322 | unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { |
808 | 322 | if (Form == dwarf::DW_FORM_data4) |
809 | 46 | return 4; |
810 | 276 | if (276 Form == dwarf::DW_FORM_sec_offset276 ) |
811 | 276 | return 4; |
812 | 0 | return AP->MAI->getCodePointerSize(); |
813 | 0 | } |
814 | | |
815 | | /// EmitValue - Emit label value. |
816 | | /// |
817 | 322 | void DIELocList::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { |
818 | 322 | DwarfDebug *DD = AP->getDwarfDebug(); |
819 | 322 | MCSymbol *Label = DD->getDebugLocs().getList(Index).Label; |
820 | 322 | AP->emitDwarfSymbolReference(Label, /*ForceOffset*/ DD->useSplitDwarf()); |
821 | 322 | } |
822 | | |
823 | | LLVM_DUMP_METHOD |
824 | 0 | void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; } |