contrib/llvm/lib/CodeGen/AsmPrinter/DIE.cpp

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