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