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