llvm/lib/CodeGen/AsmPrinter/DIE.cpp

   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 {
 177   return Owner.dyn_cast<DIE*>();
 178 }
 179
 180 DIEAbbrev DIE::generateAbbrev() const {
 181   DIEAbbrev Abbrev(Tag, hasChildren());
 182   for (const DIEValue &V : values())
 183     if (V.getForm() == dwarf::DW_FORM_implicit_const)
 184       Abbrev.AddImplicitConstAttribute(V.getAttribute(),
 185                                        V.getDIEInteger().getValue());
 186     else
 187       Abbrev.AddAttribute(V.getAttribute(), V.getForm());
 188   return Abbrev;
 189 }
 190
 191 uint64_t DIE::getDebugSectionOffset() const {
 192   const DIEUnit *Unit = getUnit();
 193   assert(Unit && "DIE must be owned by a DIEUnit to get its absolute offset");
 194   return Unit->getDebugSectionOffset() + getOffset();
 195 }
 196
 197 const DIE *DIE::getUnitDie() const {
 198   const DIE *p = this;
 199   while (p) {
 200     if (p->getTag() == dwarf::DW_TAG_compile_unit ||
 201         p->getTag() == dwarf::DW_TAG_skeleton_unit ||
 202         p->getTag() == dwarf::DW_TAG_type_unit)
 203       return p;
 204     p = p->getParent();
 205   }
 206   return nullptr;
 207 }
 208
 209 DIEUnit *DIE::getUnit() const {
 210   const DIE *UnitDie = getUnitDie();
 211   if (UnitDie)
 212     return UnitDie->Owner.dyn_cast<DIEUnit*>();
 213   return nullptr;
 214 }
 215
 216 DIEValue DIE::findAttribute(dwarf::Attribute Attribute) const {
 217   // Iterate through all the attributes until we find the one we're
 218   // looking for, if we can't find it return NULL.
 219   for (const auto &V : values())
 220     if (V.getAttribute() == Attribute)
 221       return V;
 222   return DIEValue();
 223 }
 224
 225 LLVM_DUMP_METHOD
 226 static void printValues(raw_ostream &O, const DIEValueList &Values,
 227                         StringRef Type, unsigned Size, unsigned IndentCount) {
 228   O << Type << ": Size: " << Size << "\n";
 229
 230   unsigned I = 0;
 231   const std::string Indent(IndentCount, ' ');
 232   for (const auto &V : Values.values()) {
 233     O << Indent;
 234     O << "Blk[" << I++ << "]";
 235     O << "  " << dwarf::FormEncodingString(V.getForm()) << " ";
 236     V.print(O);
 237     O << "\n";
 238   }
 239 }
 240
 241 LLVM_DUMP_METHOD
 242 void DIE::print(raw_ostream &O, unsigned IndentCount) const {
 243   const std::string Indent(IndentCount, ' ');
 244   O << Indent << "Die: " << format("0x%lx", (long)(intptr_t) this)
 245     << ", Offset: " << Offset << ", Size: " << Size << "\n";
 246
 247   O << Indent << dwarf::TagString(getTag()) << " "
 248     << dwarf::ChildrenString(hasChildren()) << "\n";
 249
 250   IndentCount += 2;
 251   for (const auto &V : values()) {
 252     O << Indent;
 253     O << dwarf::AttributeString(V.getAttribute());
 254     O << "  " << dwarf::FormEncodingString(V.getForm()) << " ";
 255     V.print(O);
 256     O << "\n";
 257   }
 258   IndentCount -= 2;
 259
 260   for (const auto &Child : children())
 261     Child.print(O, IndentCount + 4);
 262
 263   O << "\n";
 264 }
 265
 266 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 267 LLVM_DUMP_METHOD void DIE::dump() const {
 268   print(dbgs());
 269 }
 270 #endif
 271
 272 unsigned DIE::computeOffsetsAndAbbrevs(const dwarf::FormParams &FormParams,
 273                                        DIEAbbrevSet &AbbrevSet,
 274                                        unsigned CUOffset) {
 275   // Unique the abbreviation and fill in the abbreviation number so this DIE
 276   // can be emitted.
 277   const DIEAbbrev &Abbrev = AbbrevSet.uniqueAbbreviation(*this);
 278
 279   // Set compile/type unit relative offset of this DIE.
 280   setOffset(CUOffset);
 281
 282   // Add the byte size of the abbreviation code.
 283   CUOffset += getULEB128Size(getAbbrevNumber());
 284
 285   // Add the byte size of all the DIE attribute values.
 286   for (const auto &V : values())
 287     CUOffset += V.sizeOf(FormParams);
 288
 289   // Let the children compute their offsets and abbreviation numbers.
 290   if (hasChildren()) {
 291     (void)Abbrev;
 292     assert(Abbrev.hasChildren() && "Children flag not set");
 293
 294     for (auto &Child : children())
 295       CUOffset =
 296           Child.computeOffsetsAndAbbrevs(FormParams, AbbrevSet, CUOffset);
 297
 298     // Each child chain is terminated with a zero byte, adjust the offset.
 299     CUOffset += sizeof(int8_t);
 300   }
 301
 302   // Compute the byte size of this DIE and all of its children correctly. This
 303   // is needed so that top level DIE can help the compile unit set its length
 304   // correctly.
 305   setSize(CUOffset - getOffset());
 306   return CUOffset;
 307 }
 308
 309 //===----------------------------------------------------------------------===//
 310 // DIEUnit Implementation
 311 //===----------------------------------------------------------------------===//
 312 DIEUnit::DIEUnit(dwarf::Tag UnitTag) : Die(UnitTag) {
 313   Die.Owner = this;
 314   assert((UnitTag == dwarf::DW_TAG_compile_unit ||
 315           UnitTag == dwarf::DW_TAG_skeleton_unit ||
 316           UnitTag == dwarf::DW_TAG_type_unit ||
 317           UnitTag == dwarf::DW_TAG_partial_unit) &&
 318          "expected a unit TAG");
 319 }
 320
 321 void DIEValue::emitValue(const AsmPrinter *AP) const {
 322   switch (Ty) {
 323   case isNone:
 324     llvm_unreachable("Expected valid DIEValue");
 325 #define HANDLE_DIEVALUE(T)                                                     \
 326   case is##T:                                                                  \
 327     getDIE##T().emitValue(AP, Form);                                           \
 328     break;
 329 #include "llvm/CodeGen/DIEValue.def"
 330   }
 331 }
 332
 333 unsigned DIEValue::sizeOf(const dwarf::FormParams &FormParams) const {
 334   switch (Ty) {
 335   case isNone:
 336     llvm_unreachable("Expected valid DIEValue");
 337 #define HANDLE_DIEVALUE(T)                                                     \
 338   case is##T:                                                                  \
 339     return getDIE##T().sizeOf(FormParams, Form);
 340 #include "llvm/CodeGen/DIEValue.def"
 341   }
 342   llvm_unreachable("Unknown DIE kind");
 343 }
 344
 345 LLVM_DUMP_METHOD
 346 void DIEValue::print(raw_ostream &O) const {
 347   switch (Ty) {
 348   case isNone:
 349     llvm_unreachable("Expected valid DIEValue");
 350 #define HANDLE_DIEVALUE(T)                                                     \
 351   case is##T:                                                                  \
 352     getDIE##T().print(O);                                                      \
 353     break;
 354 #include "llvm/CodeGen/DIEValue.def"
 355   }
 356 }
 357
 358 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 359 LLVM_DUMP_METHOD void DIEValue::dump() const {
 360   print(dbgs());
 361 }
 362 #endif
 363
 364 //===----------------------------------------------------------------------===//
 365 // DIEInteger Implementation
 366 //===----------------------------------------------------------------------===//
 367
 368 /// EmitValue - Emit integer of appropriate size.
 369 ///
 370 void DIEInteger::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
 371   switch (Form) {
 372   case dwarf::DW_FORM_implicit_const:
 373   case dwarf::DW_FORM_flag_present:
 374     // Emit something to keep the lines and comments in sync.
 375     // FIXME: Is there a better way to do this?
 376     Asm->OutStreamer->addBlankLine();
 377     return;
 378   case dwarf::DW_FORM_flag:
 379   case dwarf::DW_FORM_ref1:
 380   case dwarf::DW_FORM_data1:
 381   case dwarf::DW_FORM_strx1:
 382   case dwarf::DW_FORM_addrx1:
 383   case dwarf::DW_FORM_ref2:
 384   case dwarf::DW_FORM_data2:
 385   case dwarf::DW_FORM_strx2:
 386   case dwarf::DW_FORM_addrx2:
 387   case dwarf::DW_FORM_strx3:
 388   case dwarf::DW_FORM_strp:
 389   case dwarf::DW_FORM_ref4:
 390   case dwarf::DW_FORM_data4:
 391   case dwarf::DW_FORM_ref_sup4:
 392   case dwarf::DW_FORM_strx4:
 393   case dwarf::DW_FORM_addrx4:
 394   case dwarf::DW_FORM_ref8:
 395   case dwarf::DW_FORM_ref_sig8:
 396   case dwarf::DW_FORM_data8:
 397   case dwarf::DW_FORM_ref_sup8:
 398   case dwarf::DW_FORM_GNU_ref_alt:
 399   case dwarf::DW_FORM_GNU_strp_alt:
 400   case dwarf::DW_FORM_line_strp:
 401   case dwarf::DW_FORM_sec_offset:
 402   case dwarf::DW_FORM_strp_sup:
 403   case dwarf::DW_FORM_addr:
 404   case dwarf::DW_FORM_ref_addr:
 405     Asm->OutStreamer->emitIntValue(Integer,
 406                                    sizeOf(Asm->getDwarfFormParams(), Form));
 407     return;
 408   case dwarf::DW_FORM_GNU_str_index:
 409   case dwarf::DW_FORM_GNU_addr_index:
 410   case dwarf::DW_FORM_ref_udata:
 411   case dwarf::DW_FORM_strx:
 412   case dwarf::DW_FORM_addrx:
 413   case dwarf::DW_FORM_rnglistx:
 414   case dwarf::DW_FORM_udata:
 415     Asm->emitULEB128(Integer);
 416     return;
 417   case dwarf::DW_FORM_sdata:
 418     Asm->emitSLEB128(Integer);
 419     return;
 420   default: llvm_unreachable("DIE Value form not supported yet");
 421   }
 422 }
 423
 424 /// sizeOf - Determine size of integer value in bytes.
 425 ///
 426 unsigned DIEInteger::sizeOf(const dwarf::FormParams &FormParams,
 427                             dwarf::Form Form) const {
 428   if (Optional<uint8_t> FixedSize =
 429           dwarf::getFixedFormByteSize(Form, FormParams))
 430     return *FixedSize;
 431
 432   switch (Form) {
 433   case dwarf::DW_FORM_GNU_str_index:
 434   case dwarf::DW_FORM_GNU_addr_index:
 435   case dwarf::DW_FORM_ref_udata:
 436   case dwarf::DW_FORM_strx:
 437   case dwarf::DW_FORM_addrx:
 438   case dwarf::DW_FORM_rnglistx:
 439   case dwarf::DW_FORM_udata:
 440     return getULEB128Size(Integer);
 441   case dwarf::DW_FORM_sdata:
 442     return getSLEB128Size(Integer);
 443   default: llvm_unreachable("DIE Value form not supported yet");
 444   }
 445 }
 446
 447 LLVM_DUMP_METHOD
 448 void DIEInteger::print(raw_ostream &O) const {
 449   O << "Int: " << (int64_t)Integer << "  0x";
 450   O.write_hex(Integer);
 451 }
 452
 453 //===----------------------------------------------------------------------===//
 454 // DIEExpr Implementation
 455 //===----------------------------------------------------------------------===//
 456
 457 /// EmitValue - Emit expression value.
 458 ///
 459 void DIEExpr::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 460   AP->emitDebugValue(Expr, sizeOf(AP->getDwarfFormParams(), Form));
 461 }
 462
 463 /// SizeOf - Determine size of expression value in bytes.
 464 ///
 465 unsigned DIEExpr::sizeOf(const dwarf::FormParams &FormParams,
 466                          dwarf::Form Form) const {
 467   switch (Form) {
 468   case dwarf::DW_FORM_data4:
 469     return 4;
 470   case dwarf::DW_FORM_data8:
 471     return 8;
 472   case dwarf::DW_FORM_sec_offset:
 473     return FormParams.getDwarfOffsetByteSize();
 474   default:
 475     llvm_unreachable("DIE Value form not supported yet");
 476   }
 477 }
 478
 479 LLVM_DUMP_METHOD
 480 void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; }
 481
 482 //===----------------------------------------------------------------------===//
 483 // DIELabel Implementation
 484 //===----------------------------------------------------------------------===//
 485
 486 /// EmitValue - Emit label value.
 487 ///
 488 void DIELabel::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 489   bool IsSectionRelative = Form != dwarf::DW_FORM_addr;
 490   AP->emitLabelReference(Label, sizeOf(AP->getDwarfFormParams(), Form),
 491                          IsSectionRelative);
 492 }
 493
 494 /// sizeOf - Determine size of label value in bytes.
 495 ///
 496 unsigned DIELabel::sizeOf(const dwarf::FormParams &FormParams,
 497                           dwarf::Form Form) const {
 498   switch (Form) {
 499   case dwarf::DW_FORM_data4:
 500     return 4;
 501   case dwarf::DW_FORM_data8:
 502     return 8;
 503   case dwarf::DW_FORM_sec_offset:
 504   case dwarf::DW_FORM_strp:
 505     return FormParams.getDwarfOffsetByteSize();
 506   case dwarf::DW_FORM_addr:
 507     return FormParams.AddrSize;
 508   default:
 509     llvm_unreachable("DIE Value form not supported yet");
 510   }
 511 }
 512
 513 LLVM_DUMP_METHOD
 514 void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); }
 515
 516 //===----------------------------------------------------------------------===//
 517 // DIEBaseTypeRef Implementation
 518 //===----------------------------------------------------------------------===//
 519
 520 void DIEBaseTypeRef::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 521   uint64_t Offset = CU->ExprRefedBaseTypes[Index].Die->getOffset();
 522   assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
 523   AP->emitULEB128(Offset, nullptr, ULEB128PadSize);
 524 }
 525
 526 unsigned DIEBaseTypeRef::sizeOf(const dwarf::FormParams &, dwarf::Form) const {
 527   return ULEB128PadSize;
 528 }
 529
 530 LLVM_DUMP_METHOD
 531 void DIEBaseTypeRef::print(raw_ostream &O) const { O << "BaseTypeRef: " << Index; }
 532
 533 //===----------------------------------------------------------------------===//
 534 // DIEDelta Implementation
 535 //===----------------------------------------------------------------------===//
 536
 537 /// EmitValue - Emit delta value.
 538 ///
 539 void DIEDelta::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 540   AP->emitLabelDifference(LabelHi, LabelLo,
 541                           sizeOf(AP->getDwarfFormParams(), Form));
 542 }
 543
 544 /// SizeOf - Determine size of delta value in bytes.
 545 ///
 546 unsigned DIEDelta::sizeOf(const dwarf::FormParams &FormParams,
 547                           dwarf::Form Form) const {
 548   switch (Form) {
 549   case dwarf::DW_FORM_data4:
 550     return 4;
 551   case dwarf::DW_FORM_data8:
 552     return 8;
 553   case dwarf::DW_FORM_sec_offset:
 554     return FormParams.getDwarfOffsetByteSize();
 555   default:
 556     llvm_unreachable("DIE Value form not supported yet");
 557   }
 558 }
 559
 560 LLVM_DUMP_METHOD
 561 void DIEDelta::print(raw_ostream &O) const {
 562   O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName();
 563 }
 564
 565 //===----------------------------------------------------------------------===//
 566 // DIEString Implementation
 567 //===----------------------------------------------------------------------===//
 568
 569 /// EmitValue - Emit string value.
 570 ///
 571 void DIEString::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 572   // Index of string in symbol table.
 573   switch (Form) {
 574   case dwarf::DW_FORM_GNU_str_index:
 575   case dwarf::DW_FORM_strx:
 576   case dwarf::DW_FORM_strx1:
 577   case dwarf::DW_FORM_strx2:
 578   case dwarf::DW_FORM_strx3:
 579   case dwarf::DW_FORM_strx4:
 580     DIEInteger(S.getIndex()).emitValue(AP, Form);
 581     return;
 582   case dwarf::DW_FORM_strp:
 583     if (AP->MAI->doesDwarfUseRelocationsAcrossSections())
 584       DIELabel(S.getSymbol()).emitValue(AP, Form);
 585     else
 586       DIEInteger(S.getOffset()).emitValue(AP, Form);
 587     return;
 588   default:
 589     llvm_unreachable("Expected valid string form");
 590   }
 591 }
 592
 593 /// sizeOf - Determine size of delta value in bytes.
 594 ///
 595 unsigned DIEString::sizeOf(const dwarf::FormParams &FormParams,
 596                            dwarf::Form Form) const {
 597   // Index of string in symbol table.
 598   switch (Form) {
 599   case dwarf::DW_FORM_GNU_str_index:
 600   case dwarf::DW_FORM_strx:
 601   case dwarf::DW_FORM_strx1:
 602   case dwarf::DW_FORM_strx2:
 603   case dwarf::DW_FORM_strx3:
 604   case dwarf::DW_FORM_strx4:
 605     return DIEInteger(S.getIndex()).sizeOf(FormParams, Form);
 606   case dwarf::DW_FORM_strp:
 607     if (FormParams.DwarfUsesRelocationsAcrossSections)
 608       return DIELabel(S.getSymbol()).sizeOf(FormParams, Form);
 609     return DIEInteger(S.getOffset()).sizeOf(FormParams, Form);
 610   default:
 611     llvm_unreachable("Expected valid string form");
 612   }
 613 }
 614
 615 LLVM_DUMP_METHOD
 616 void DIEString::print(raw_ostream &O) const {
 617   O << "String: " << S.getString();
 618 }
 619
 620 //===----------------------------------------------------------------------===//
 621 // DIEInlineString Implementation
 622 //===----------------------------------------------------------------------===//
 623 void DIEInlineString::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 624   if (Form == dwarf::DW_FORM_string) {
 625     AP->OutStreamer->emitBytes(S);
 626     AP->emitInt8(0);
 627     return;
 628   }
 629   llvm_unreachable("Expected valid string form");
 630 }
 631
 632 unsigned DIEInlineString::sizeOf(const dwarf::FormParams &, dwarf::Form) const {
 633   // Emit string bytes + NULL byte.
 634   return S.size() + 1;
 635 }
 636
 637 LLVM_DUMP_METHOD
 638 void DIEInlineString::print(raw_ostream &O) const {
 639   O << "InlineString: " << S;
 640 }
 641
 642 //===----------------------------------------------------------------------===//
 643 // DIEEntry Implementation
 644 //===----------------------------------------------------------------------===//
 645
 646 /// EmitValue - Emit debug information entry offset.
 647 ///
 648 void DIEEntry::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 649
 650   switch (Form) {
 651   case dwarf::DW_FORM_ref1:
 652   case dwarf::DW_FORM_ref2:
 653   case dwarf::DW_FORM_ref4:
 654   case dwarf::DW_FORM_ref8:
 655     AP->OutStreamer->emitIntValue(Entry->getOffset(),
 656                                   sizeOf(AP->getDwarfFormParams(), Form));
 657     return;
 658
 659   case dwarf::DW_FORM_ref_udata:
 660     AP->emitULEB128(Entry->getOffset());
 661     return;
 662
 663   case dwarf::DW_FORM_ref_addr: {
 664     // Get the absolute offset for this DIE within the debug info/types section.
 665     uint64_t Addr = Entry->getDebugSectionOffset();
 666     if (const MCSymbol *SectionSym =
 667             Entry->getUnit()->getCrossSectionRelativeBaseAddress()) {
 668       AP->emitLabelPlusOffset(SectionSym, Addr,
 669                               sizeOf(AP->getDwarfFormParams(), Form), true);
 670       return;
 671     }
 672
 673     AP->OutStreamer->emitIntValue(Addr, sizeOf(AP->getDwarfFormParams(), Form));
 674     return;
 675   }
 676   default:
 677     llvm_unreachable("Improper form for DIE reference");
 678   }
 679 }
 680
 681 unsigned DIEEntry::sizeOf(const dwarf::FormParams &FormParams,
 682                           dwarf::Form Form) const {
 683   switch (Form) {
 684   case dwarf::DW_FORM_ref1:
 685     return 1;
 686   case dwarf::DW_FORM_ref2:
 687     return 2;
 688   case dwarf::DW_FORM_ref4:
 689     return 4;
 690   case dwarf::DW_FORM_ref8:
 691     return 8;
 692   case dwarf::DW_FORM_ref_udata:
 693     return getULEB128Size(Entry->getOffset());
 694   case dwarf::DW_FORM_ref_addr:
 695     return FormParams.getRefAddrByteSize();
 696
 697   default:
 698     llvm_unreachable("Improper form for DIE reference");
 699   }
 700 }
 701
 702 LLVM_DUMP_METHOD
 703 void DIEEntry::print(raw_ostream &O) const {
 704   O << format("Die: 0x%lx", (long)(intptr_t)&Entry);
 705 }
 706
 707 //===----------------------------------------------------------------------===//
 708 // DIELoc Implementation
 709 //===----------------------------------------------------------------------===//
 710
 711 unsigned DIELoc::computeSize(const dwarf::FormParams &FormParams) const {
 712   if (!Size) {
 713     for (const auto &V : values())
 714       Size += V.sizeOf(FormParams);
 715   }
 716
 717   return Size;
 718 }
 719
 720 /// EmitValue - Emit location data.
 721 ///
 722 void DIELoc::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
 723   switch (Form) {
 724   default: llvm_unreachable("Improper form for block");
 725   case dwarf::DW_FORM_block1: Asm->emitInt8(Size);    break;
 726   case dwarf::DW_FORM_block2: Asm->emitInt16(Size);   break;
 727   case dwarf::DW_FORM_block4: Asm->emitInt32(Size);   break;
 728   case dwarf::DW_FORM_block:
 729   case dwarf::DW_FORM_exprloc:
 730     Asm->emitULEB128(Size);
 731     break;
 732   }
 733
 734   for (const auto &V : values())
 735     V.emitValue(Asm);
 736 }
 737
 738 /// sizeOf - Determine size of location data in bytes.
 739 ///
 740 unsigned DIELoc::sizeOf(const dwarf::FormParams &, dwarf::Form Form) const {
 741   switch (Form) {
 742   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
 743   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
 744   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
 745   case dwarf::DW_FORM_block:
 746   case dwarf::DW_FORM_exprloc:
 747     return Size + getULEB128Size(Size);
 748   default: llvm_unreachable("Improper form for block");
 749   }
 750 }
 751
 752 LLVM_DUMP_METHOD
 753 void DIELoc::print(raw_ostream &O) const {
 754   printValues(O, *this, "ExprLoc", Size, 5);
 755 }
 756
 757 //===----------------------------------------------------------------------===//
 758 // DIEBlock Implementation
 759 //===----------------------------------------------------------------------===//
 760
 761 unsigned DIEBlock::computeSize(const dwarf::FormParams &FormParams) const {
 762   if (!Size) {
 763     for (const auto &V : values())
 764       Size += V.sizeOf(FormParams);
 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_exprloc:
 779   case dwarf::DW_FORM_block:
 780     Asm->emitULEB128(Size);
 781     break;
 782   case dwarf::DW_FORM_string: break;
 783   case dwarf::DW_FORM_data16: break;
 784   }
 785
 786   for (const auto &V : values())
 787     V.emitValue(Asm);
 788 }
 789
 790 /// sizeOf - Determine size of block data in bytes.
 791 ///
 792 unsigned DIEBlock::sizeOf(const dwarf::FormParams &, dwarf::Form Form) const {
 793   switch (Form) {
 794   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
 795   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
 796   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
 797   case dwarf::DW_FORM_exprloc:
 798   case dwarf::DW_FORM_block:  return Size + getULEB128Size(Size);
 799   case dwarf::DW_FORM_data16: return 16;
 800   default: llvm_unreachable("Improper form for block");
 801   }
 802 }
 803
 804 LLVM_DUMP_METHOD
 805 void DIEBlock::print(raw_ostream &O) const {
 806   printValues(O, *this, "Blk", Size, 5);
 807 }
 808
 809 //===----------------------------------------------------------------------===//
 810 // DIELocList Implementation
 811 //===----------------------------------------------------------------------===//
 812
 813 unsigned DIELocList::sizeOf(const dwarf::FormParams &FormParams,
 814                             dwarf::Form Form) const {
 815   switch (Form) {
 816   case dwarf::DW_FORM_loclistx:
 817     return getULEB128Size(Index);
 818   case dwarf::DW_FORM_data4:
 819     assert(FormParams.Format != dwarf::DWARF64 &&
 820            "DW_FORM_data4 is not suitable to emit a pointer to a location list "
 821            "in the 64-bit DWARF format");
 822     return 4;
 823   case dwarf::DW_FORM_data8:
 824     assert(FormParams.Format == dwarf::DWARF64 &&
 825            "DW_FORM_data8 is not suitable to emit a pointer to a location list "
 826            "in the 32-bit DWARF format");
 827     return 8;
 828   case dwarf::DW_FORM_sec_offset:
 829     return FormParams.getDwarfOffsetByteSize();
 830   default:
 831     llvm_unreachable("DIE Value form not supported yet");
 832   }
 833 }
 834
 835 /// EmitValue - Emit label value.
 836 ///
 837 void DIELocList::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 838   if (Form == dwarf::DW_FORM_loclistx) {
 839     AP->emitULEB128(Index);
 840     return;
 841   }
 842   DwarfDebug *DD = AP->getDwarfDebug();
 843   MCSymbol *Label = DD->getDebugLocs().getList(Index).Label;
 844   AP->emitDwarfSymbolReference(Label, /*ForceOffset*/ DD->useSplitDwarf());
 845 }
 846
 847 LLVM_DUMP_METHOD
 848 void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; }
 849
 850 //===----------------------------------------------------------------------===//
 851 // DIEAddrOffset Implementation
 852 //===----------------------------------------------------------------------===//
 853
 854 unsigned DIEAddrOffset::sizeOf(const dwarf::FormParams &FormParams,
 855                                dwarf::Form) const {
 856   return Addr.sizeOf(FormParams, dwarf::DW_FORM_addrx) +
 857          Offset.sizeOf(FormParams, dwarf::DW_FORM_data4);
 858 }
 859
 860 /// EmitValue - Emit label value.
 861 ///
 862 void DIEAddrOffset::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 863   Addr.emitValue(AP, dwarf::DW_FORM_addrx);
 864   Offset.emitValue(AP, dwarf::DW_FORM_data4);
 865 }
 866
 867 LLVM_DUMP_METHOD
 868 void DIEAddrOffset::print(raw_ostream &O) const {
 869   O << "AddrOffset: ";
 870   Addr.print(O);
 871   O << " + ";
 872   Offset.print(O);
 873 }