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 ///
43 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 ///
58 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 ///
69 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
110 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)
133 LLVM_DUMP_METHOD void DIEAbbrev::dump() const {
134   print(dbgs());
135 }
136 #endif
137 
138 //===----------------------------------------------------------------------===//
139 // DIEAbbrevSet Implementation
140 //===----------------------------------------------------------------------===//
141 
142 DIEAbbrevSet::~DIEAbbrevSet() {
143   for (DIEAbbrev *Abbrev : Abbreviations)
144     Abbrev->~DIEAbbrev();
145 }
146 
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 
171 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 
183 DIE *DIE::getParent() const {
184   return Owner.dyn_cast<DIE*>();
185 }
186 
187 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 
198 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 
204 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 
215 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 
222 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
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
248 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)
273 LLVM_DUMP_METHOD void DIE::dump() const {
274   print(dbgs());
275 }
276 #endif
277 
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 //===----------------------------------------------------------------------===//
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 
327 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 
339 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
352 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)
365 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 ///
376 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_addrx:
418   case dwarf::DW_FORM_rnglistx:
419   case dwarf::DW_FORM_udata:
420     Asm->EmitULEB128(Integer);
421     return;
422   case dwarf::DW_FORM_sdata:
423     Asm->EmitSLEB128(Integer);
424     return;
425   default: llvm_unreachable("DIE Value form not supported yet");
426   }
427 }
428 
429 /// SizeOf - Determine size of integer value in bytes.
430 ///
431 unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
432   dwarf::FormParams Params = {0, 0, dwarf::DWARF32};
433   if (AP)
434     Params = {AP->getDwarfVersion(), uint8_t(AP->getPointerSize()),
435               AP->OutStreamer->getContext().getDwarfFormat()};
436 
437   if (Optional<uint8_t> FixedSize = dwarf::getFixedFormByteSize(Form, Params))
438     return *FixedSize;
439 
440   switch (Form) {
441   case dwarf::DW_FORM_GNU_str_index:
442   case dwarf::DW_FORM_GNU_addr_index:
443   case dwarf::DW_FORM_ref_udata:
444   case dwarf::DW_FORM_strx:
445   case dwarf::DW_FORM_addrx:
446   case dwarf::DW_FORM_rnglistx:
447   case dwarf::DW_FORM_udata:
448     return getULEB128Size(Integer);
449   case dwarf::DW_FORM_sdata:
450     return getSLEB128Size(Integer);
451   default: llvm_unreachable("DIE Value form not supported yet");
452   }
453 }
454 
455 LLVM_DUMP_METHOD
456 void DIEInteger::print(raw_ostream &O) const {
457   O << "Int: " << (int64_t)Integer << "  0x";
458   O.write_hex(Integer);
459 }
460 
461 //===----------------------------------------------------------------------===//
462 // DIEExpr Implementation
463 //===----------------------------------------------------------------------===//
464 
465 /// EmitValue - Emit expression value.
466 ///
467 void DIEExpr::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
468   AP->EmitDebugValue(Expr, SizeOf(AP, Form));
469 }
470 
471 /// SizeOf - Determine size of expression value in bytes.
472 ///
473 unsigned DIEExpr::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
474   if (Form == dwarf::DW_FORM_data4) return 4;
475   if (Form == dwarf::DW_FORM_sec_offset) return 4;
476   if (Form == dwarf::DW_FORM_strp) return 4;
477   return AP->getPointerSize();
478 }
479 
480 LLVM_DUMP_METHOD
481 void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; }
482 
483 //===----------------------------------------------------------------------===//
484 // DIELabel Implementation
485 //===----------------------------------------------------------------------===//
486 
487 /// EmitValue - Emit label value.
488 ///
489 void DIELabel::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
490   AP->EmitLabelReference(Label, SizeOf(AP, Form),
491                          Form == dwarf::DW_FORM_strp ||
492                              Form == dwarf::DW_FORM_sec_offset ||
493                              Form == dwarf::DW_FORM_ref_addr ||
494                              Form == dwarf::DW_FORM_data4);
495 }
496 
497 /// SizeOf - Determine size of label value in bytes.
498 ///
499 unsigned DIELabel::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
500   if (Form == dwarf::DW_FORM_data4) return 4;
501   if (Form == dwarf::DW_FORM_sec_offset) return 4;
502   if (Form == dwarf::DW_FORM_strp) return 4;
503   return AP->MAI->getCodePointerSize();
504 }
505 
506 LLVM_DUMP_METHOD
507 void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); }
508 
509 //===----------------------------------------------------------------------===//
510 // DIEDelta Implementation
511 //===----------------------------------------------------------------------===//
512 
513 /// EmitValue - Emit delta value.
514 ///
515 void DIEDelta::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
516   AP->EmitLabelDifference(LabelHi, LabelLo, SizeOf(AP, Form));
517 }
518 
519 /// SizeOf - Determine size of delta value in bytes.
520 ///
521 unsigned DIEDelta::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
522   if (Form == dwarf::DW_FORM_data4) return 4;
523   if (Form == dwarf::DW_FORM_sec_offset) return 4;
524   if (Form == dwarf::DW_FORM_strp) return 4;
525   return AP->MAI->getCodePointerSize();
526 }
527 
528 LLVM_DUMP_METHOD
529 void DIEDelta::print(raw_ostream &O) const {
530   O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName();
531 }
532 
533 //===----------------------------------------------------------------------===//
534 // DIEString Implementation
535 //===----------------------------------------------------------------------===//
536 
537 /// EmitValue - Emit string value.
538 ///
539 void DIEString::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
540   // Index of string in symbol table.
541   switch (Form) {
542   case dwarf::DW_FORM_GNU_str_index:
543   case dwarf::DW_FORM_strx:
544   case dwarf::DW_FORM_strx1:
545   case dwarf::DW_FORM_strx2:
546   case dwarf::DW_FORM_strx3:
547   case dwarf::DW_FORM_strx4:
548     DIEInteger(S.getIndex()).EmitValue(AP, Form);
549     return;
550   case dwarf::DW_FORM_strp:
551     if (AP->MAI->doesDwarfUseRelocationsAcrossSections())
552       DIELabel(S.getSymbol()).EmitValue(AP, Form);
553     else
554       DIEInteger(S.getOffset()).EmitValue(AP, Form);
555     return;
556   default:
557     llvm_unreachable("Expected valid string form");
558   }
559 }
560 
561 /// SizeOf - Determine size of delta value in bytes.
562 ///
563 unsigned DIEString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
564   // Index of string in symbol table.
565   switch (Form) {
566   case dwarf::DW_FORM_GNU_str_index:
567   case dwarf::DW_FORM_strx:
568   case dwarf::DW_FORM_strx1:
569   case dwarf::DW_FORM_strx2:
570   case dwarf::DW_FORM_strx3:
571   case dwarf::DW_FORM_strx4:
572     return DIEInteger(S.getIndex()).SizeOf(AP, Form);
573   case dwarf::DW_FORM_strp:
574     if (AP->MAI->doesDwarfUseRelocationsAcrossSections())
575       return DIELabel(S.getSymbol()).SizeOf(AP, Form);
576     return DIEInteger(S.getOffset()).SizeOf(AP, Form);
577   default:
578     llvm_unreachable("Expected valid string form");
579   }
580 }
581 
582 LLVM_DUMP_METHOD
583 void DIEString::print(raw_ostream &O) const {
584   O << "String: " << S.getString();
585 }
586 
587 //===----------------------------------------------------------------------===//
588 // DIEInlineString Implementation
589 //===----------------------------------------------------------------------===//
590 void DIEInlineString::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
591   if (Form == dwarf::DW_FORM_string) {
592     AP->OutStreamer->EmitBytes(S);
593     AP->emitInt8(0);
594     return;
595   }
596   llvm_unreachable("Expected valid string form");
597 }
598 
599 unsigned DIEInlineString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
600   // Emit string bytes + NULL byte.
601   return S.size() + 1;
602 }
603 
604 LLVM_DUMP_METHOD
605 void DIEInlineString::print(raw_ostream &O) const {
606   O << "InlineString: " << S;
607 }
608 
609 //===----------------------------------------------------------------------===//
610 // DIEEntry Implementation
611 //===----------------------------------------------------------------------===//
612 
613 /// EmitValue - Emit debug information entry offset.
614 ///
615 void DIEEntry::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
616 
617   switch (Form) {
618   case dwarf::DW_FORM_ref1:
619   case dwarf::DW_FORM_ref2:
620   case dwarf::DW_FORM_ref4:
621   case dwarf::DW_FORM_ref8:
622     AP->OutStreamer->EmitIntValue(Entry->getOffset(), SizeOf(AP, Form));
623     return;
624 
625   case dwarf::DW_FORM_ref_udata:
626     AP->EmitULEB128(Entry->getOffset());
627     return;
628 
629   case dwarf::DW_FORM_ref_addr: {
630     // Get the absolute offset for this DIE within the debug info/types section.
631     unsigned Addr = Entry->getDebugSectionOffset();
632     if (const MCSymbol *SectionSym =
633             Entry->getUnit()->getCrossSectionRelativeBaseAddress()) {
634       AP->EmitLabelPlusOffset(SectionSym, Addr, SizeOf(AP, Form), true);
635       return;
636     }
637 
638     AP->OutStreamer->EmitIntValue(Addr, SizeOf(AP, Form));
639     return;
640   }
641   default:
642     llvm_unreachable("Improper form for DIE reference");
643   }
644 }
645 
646 unsigned DIEEntry::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
647   switch (Form) {
648   case dwarf::DW_FORM_ref1:
649     return 1;
650   case dwarf::DW_FORM_ref2:
651     return 2;
652   case dwarf::DW_FORM_ref4:
653     return 4;
654   case dwarf::DW_FORM_ref8:
655     return 8;
656   case dwarf::DW_FORM_ref_udata:
657     return getULEB128Size(Entry->getOffset());
658   case dwarf::DW_FORM_ref_addr:
659     if (AP->getDwarfVersion() == 2)
660       return AP->MAI->getCodePointerSize();
661     switch (AP->OutStreamer->getContext().getDwarfFormat()) {
662     case dwarf::DWARF32:
663       return 4;
664     case dwarf::DWARF64:
665       return 8;
666     }
667     llvm_unreachable("Invalid DWARF format");
668 
669   default:
670     llvm_unreachable("Improper form for DIE reference");
671   }
672 }
673 
674 LLVM_DUMP_METHOD
675 void DIEEntry::print(raw_ostream &O) const {
676   O << format("Die: 0x%lx", (long)(intptr_t)&Entry);
677 }
678 
679 //===----------------------------------------------------------------------===//
680 // DIELoc Implementation
681 //===----------------------------------------------------------------------===//
682 
683 /// ComputeSize - calculate the size of the location expression.
684 ///
685 unsigned DIELoc::ComputeSize(const AsmPrinter *AP) const {
686   if (!Size) {
687     for (const auto &V : values())
688       Size += V.SizeOf(AP);
689   }
690 
691   return Size;
692 }
693 
694 /// EmitValue - Emit location data.
695 ///
696 void DIELoc::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
697   switch (Form) {
698   default: llvm_unreachable("Improper form for block");
699   case dwarf::DW_FORM_block1: Asm->emitInt8(Size);    break;
700   case dwarf::DW_FORM_block2: Asm->emitInt16(Size);   break;
701   case dwarf::DW_FORM_block4: Asm->emitInt32(Size);   break;
702   case dwarf::DW_FORM_block:
703   case dwarf::DW_FORM_exprloc:
704     Asm->EmitULEB128(Size); break;
705   }
706 
707   for (const auto &V : values())
708     V.EmitValue(Asm);
709 }
710 
711 /// SizeOf - Determine size of location data in bytes.
712 ///
713 unsigned DIELoc::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
714   switch (Form) {
715   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
716   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
717   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
718   case dwarf::DW_FORM_block:
719   case dwarf::DW_FORM_exprloc:
720     return Size + getULEB128Size(Size);
721   default: llvm_unreachable("Improper form for block");
722   }
723 }
724 
725 LLVM_DUMP_METHOD
726 void DIELoc::print(raw_ostream &O) const {
727   printValues(O, *this, "ExprLoc", Size, 5);
728 }
729 
730 //===----------------------------------------------------------------------===//
731 // DIEBlock Implementation
732 //===----------------------------------------------------------------------===//
733 
734 /// ComputeSize - calculate the size of the block.
735 ///
736 unsigned DIEBlock::ComputeSize(const AsmPrinter *AP) const {
737   if (!Size) {
738     for (const auto &V : values())
739       Size += V.SizeOf(AP);
740   }
741 
742   return Size;
743 }
744 
745 /// EmitValue - Emit block data.
746 ///
747 void DIEBlock::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
748   switch (Form) {
749   default: llvm_unreachable("Improper form for block");
750   case dwarf::DW_FORM_block1: Asm->emitInt8(Size);    break;
751   case dwarf::DW_FORM_block2: Asm->emitInt16(Size);   break;
752   case dwarf::DW_FORM_block4: Asm->emitInt32(Size);   break;
753   case dwarf::DW_FORM_block:  Asm->EmitULEB128(Size); break;
754   case dwarf::DW_FORM_string: break;
755   case dwarf::DW_FORM_data16: break;
756   }
757 
758   for (const auto &V : values())
759     V.EmitValue(Asm);
760 }
761 
762 /// SizeOf - Determine size of block data in bytes.
763 ///
764 unsigned DIEBlock::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
765   switch (Form) {
766   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
767   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
768   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
769   case dwarf::DW_FORM_block:  return Size + getULEB128Size(Size);
770   case dwarf::DW_FORM_data16: return 16;
771   default: llvm_unreachable("Improper form for block");
772   }
773 }
774 
775 LLVM_DUMP_METHOD
776 void DIEBlock::print(raw_ostream &O) const {
777   printValues(O, *this, "Blk", Size, 5);
778 }
779 
780 //===----------------------------------------------------------------------===//
781 // DIELocList Implementation
782 //===----------------------------------------------------------------------===//
783 
784 unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
785   if (Form == dwarf::DW_FORM_data4)
786     return 4;
787   if (Form == dwarf::DW_FORM_sec_offset)
788     return 4;
789   return AP->MAI->getCodePointerSize();
790 }
791 
792 /// EmitValue - Emit label value.
793 ///
794 void DIELocList::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
795   DwarfDebug *DD = AP->getDwarfDebug();
796   MCSymbol *Label = DD->getDebugLocs().getList(Index).Label;
797   AP->emitDwarfSymbolReference(Label, /*ForceOffset*/ DD->useSplitDwarf());
798 }
799 
800 LLVM_DUMP_METHOD
801 void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; }
802