llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

   1 //===- DWARFContext.cpp ---------------------------------------------------===//
   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 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
  10 #include "llvm/ADT/STLExtras.h"
  11 #include "llvm/ADT/SmallString.h"
  12 #include "llvm/ADT/SmallVector.h"
  13 #include "llvm/ADT/StringRef.h"
  14 #include "llvm/ADT/StringSwitch.h"
  15 #include "llvm/BinaryFormat/Dwarf.h"
  16 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
  17 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
  18 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
  19 #include "llvm/DebugInfo/DWARF/DWARFDebugAddr.h"
  20 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
  21 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
  22 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
  23 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
  24 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
  25 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
  26 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
  27 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
  28 #include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
  29 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
  30 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
  31 #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
  32 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
  33 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
  34 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
  35 #include "llvm/MC/MCRegisterInfo.h"
  36 #include "llvm/Object/Decompressor.h"
  37 #include "llvm/Object/MachO.h"
  38 #include "llvm/Object/ObjectFile.h"
  39 #include "llvm/Object/RelocationResolver.h"
  40 #include "llvm/Support/Casting.h"
  41 #include "llvm/Support/DataExtractor.h"
  42 #include "llvm/Support/Error.h"
  43 #include "llvm/Support/Format.h"
  44 #include "llvm/Support/LEB128.h"
  45 #include "llvm/Support/MemoryBuffer.h"
  46 #include "llvm/Support/Path.h"
  47 #include "llvm/Support/TargetRegistry.h"
  48 #include "llvm/Support/raw_ostream.h"
  49 #include <algorithm>
  50 #include <cstdint>
  51 #include <deque>
  52 #include <map>
  53 #include <string>
  54 #include <utility>
  55 #include <vector>
  56
  57 using namespace llvm;
  58 using namespace dwarf;
  59 using namespace object;
  60
  61 #define DEBUG_TYPE "dwarf"
  62
  63 using DWARFLineTable = DWARFDebugLine::LineTable;
  64 using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind;
  65 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
  66
  67 DWARFContext::DWARFContext(std::unique_ptr<const DWARFObject> DObj,
  68                            std::string DWPName,
  69                            std::function<void(Error)> RecoverableErrorHandler,
  70                            std::function<void(Error)> WarningHandler)
  71     : DIContext(CK_DWARF), DWPName(std::move(DWPName)),
  72       RecoverableErrorHandler(RecoverableErrorHandler),
  73       WarningHandler(WarningHandler), DObj(std::move(DObj)) {}
  74
  75 DWARFContext::~DWARFContext() = default;
  76
  77 /// Dump the UUID load command.
  78 static void dumpUUID(raw_ostream &OS, const ObjectFile &Obj) {
  79   auto *MachO = dyn_cast<MachOObjectFile>(&Obj);
  80   if (!MachO)
  81     return;
  82   for (auto LC : MachO->load_commands()) {
  83     raw_ostream::uuid_t UUID;
  84     if (LC.C.cmd == MachO::LC_UUID) {
  85       if (LC.C.cmdsize < sizeof(UUID) + sizeof(LC.C)) {
  86         OS << "error: UUID load command is too short.\n";
  87         return;
  88       }
  89       OS << "UUID: ";
  90       memcpy(&UUID, LC.Ptr+sizeof(LC.C), sizeof(UUID));
  91       OS.write_uuid(UUID);
  92       Triple T = MachO->getArchTriple();
  93       OS << " (" << T.getArchName() << ')';
  94       OS << ' ' << MachO->getFileName() << '\n';
  95     }
  96   }
  97 }
  98
  99 using ContributionCollection =
 100     std::vector<Optional<StrOffsetsContributionDescriptor>>;
 101
 102 // Collect all the contributions to the string offsets table from all units,
 103 // sort them by their starting offsets and remove duplicates.
 104 static ContributionCollection
 105 collectContributionData(DWARFContext::unit_iterator_range Units) {
 106   ContributionCollection Contributions;
 107   for (const auto &U : Units)
 108     if (const auto &C = U->getStringOffsetsTableContribution())
 109       Contributions.push_back(C);
 110   // Sort the contributions so that any invalid ones are placed at
 111   // the start of the contributions vector. This way they are reported
 112   // first.
 113   llvm::sort(Contributions,
 114              [](const Optional<StrOffsetsContributionDescriptor> &L,
 115                 const Optional<StrOffsetsContributionDescriptor> &R) {
 116                if (L && R)
 117                  return L->Base < R->Base;
 118                return R.hasValue();
 119              });
 120
 121   // Uniquify contributions, as it is possible that units (specifically
 122   // type units in dwo or dwp files) share contributions. We don't want
 123   // to report them more than once.
 124   Contributions.erase(
 125       std::unique(Contributions.begin(), Contributions.end(),
 126                   [](const Optional<StrOffsetsContributionDescriptor> &L,
 127                      const Optional<StrOffsetsContributionDescriptor> &R) {
 128                     if (L && R)
 129                       return L->Base == R->Base && L->Size == R->Size;
 130                     return false;
 131                   }),
 132       Contributions.end());
 133   return Contributions;
 134 }
 135
 136 // Dump a DWARF string offsets section. This may be a DWARF v5 formatted
 137 // string offsets section, where each compile or type unit contributes a
 138 // number of entries (string offsets), with each contribution preceded by
 139 // a header containing size and version number. Alternatively, it may be a
 140 // monolithic series of string offsets, as generated by the pre-DWARF v5
 141 // implementation of split DWARF; however, in that case we still need to
 142 // collect contributions of units because the size of the offsets (4 or 8
 143 // bytes) depends on the format of the referencing unit (DWARF32 or DWARF64).
 144 static void dumpStringOffsetsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
 145                                      StringRef SectionName,
 146                                      const DWARFObject &Obj,
 147                                      const DWARFSection &StringOffsetsSection,
 148                                      StringRef StringSection,
 149                                      DWARFContext::unit_iterator_range Units,
 150                                      bool LittleEndian) {
 151   auto Contributions = collectContributionData(Units);
 152   DWARFDataExtractor StrOffsetExt(Obj, StringOffsetsSection, LittleEndian, 0);
 153   DataExtractor StrData(StringSection, LittleEndian, 0);
 154   uint64_t SectionSize = StringOffsetsSection.Data.size();
 155   uint64_t Offset = 0;
 156   for (auto &Contribution : Contributions) {
 157     // Report an ill-formed contribution.
 158     if (!Contribution) {
 159       OS << "error: invalid contribution to string offsets table in section ."
 160          << SectionName << ".\n";
 161       return;
 162     }
 163
 164     dwarf::DwarfFormat Format = Contribution->getFormat();
 165     int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(Format);
 166     uint16_t Version = Contribution->getVersion();
 167     uint64_t ContributionHeader = Contribution->Base;
 168     // In DWARF v5 there is a contribution header that immediately precedes
 169     // the string offsets base (the location we have previously retrieved from
 170     // the CU DIE's DW_AT_str_offsets attribute). The header is located either
 171     // 8 or 16 bytes before the base, depending on the contribution's format.
 172     if (Version >= 5)
 173       ContributionHeader -= Format == DWARF32 ? 8 : 16;
 174
 175     // Detect overlapping contributions.
 176     if (Offset > ContributionHeader) {
 177       DumpOpts.RecoverableErrorHandler(createStringError(
 178           errc::invalid_argument,
 179           "overlapping contributions to string offsets table in section .%s.",
 180           SectionName.data()));
 181     }
 182     // Report a gap in the table.
 183     if (Offset < ContributionHeader) {
 184       OS << format("0x%8.8" PRIx64 ": Gap, length = ", Offset);
 185       OS << (ContributionHeader - Offset) << "\n";
 186     }
 187     OS << format("0x%8.8" PRIx64 ": ", ContributionHeader);
 188     // In DWARF v5 the contribution size in the descriptor does not equal
 189     // the originally encoded length (it does not contain the length of the
 190     // version field and the padding, a total of 4 bytes). Add them back in
 191     // for reporting.
 192     OS << "Contribution size = " << (Contribution->Size + (Version < 5 ? 0 : 4))
 193        << ", Format = " << dwarf::FormatString(Format)
 194        << ", Version = " << Version << "\n";
 195
 196     Offset = Contribution->Base;
 197     unsigned EntrySize = Contribution->getDwarfOffsetByteSize();
 198     while (Offset - Contribution->Base < Contribution->Size) {
 199       OS << format("0x%8.8" PRIx64 ": ", Offset);
 200       uint64_t StringOffset =
 201           StrOffsetExt.getRelocatedValue(EntrySize, &Offset);
 202       OS << format("%0*" PRIx64 " ", OffsetDumpWidth, StringOffset);
 203       const char *S = StrData.getCStr(&StringOffset);
 204       if (S)
 205         OS << format("\"%s\"", S);
 206       OS << "\n";
 207     }
 208   }
 209   // Report a gap at the end of the table.
 210   if (Offset < SectionSize) {
 211     OS << format("0x%8.8" PRIx64 ": Gap, length = ", Offset);
 212     OS << (SectionSize - Offset) << "\n";
 213   }
 214 }
 215
 216 // Dump the .debug_addr section.
 217 static void dumpAddrSection(raw_ostream &OS, DWARFDataExtractor &AddrData,
 218                             DIDumpOptions DumpOpts, uint16_t Version,
 219                             uint8_t AddrSize) {
 220   uint64_t Offset = 0;
 221   while (AddrData.isValidOffset(Offset)) {
 222     DWARFDebugAddrTable AddrTable;
 223     uint64_t TableOffset = Offset;
 224     if (Error Err = AddrTable.extract(AddrData, &Offset, Version, AddrSize,
 225                                       DumpOpts.WarningHandler)) {
 226       DumpOpts.RecoverableErrorHandler(std::move(Err));
 227       // Keep going after an error, if we can, assuming that the length field
 228       // could be read. If it couldn't, stop reading the section.
 229       if (auto TableLength = AddrTable.getFullLength()) {
 230         Offset = TableOffset + *TableLength;
 231         continue;
 232       }
 233       break;
 234     }
 235     AddrTable.dump(OS, DumpOpts);
 236   }
 237 }
 238
 239 // Dump the .debug_rnglists or .debug_rnglists.dwo section (DWARF v5).
 240 static void dumpRnglistsSection(
 241     raw_ostream &OS, DWARFDataExtractor &rnglistData,
 242     llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
 243         LookupPooledAddress,
 244     DIDumpOptions DumpOpts) {
 245   uint64_t Offset = 0;
 246   while (rnglistData.isValidOffset(Offset)) {
 247     llvm::DWARFDebugRnglistTable Rnglists;
 248     uint64_t TableOffset = Offset;
 249     if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
 250       DumpOpts.RecoverableErrorHandler(std::move(Err));
 251       uint64_t Length = Rnglists.length();
 252       // Keep going after an error, if we can, assuming that the length field
 253       // could be read. If it couldn't, stop reading the section.
 254       if (Length == 0)
 255         break;
 256       Offset = TableOffset + Length;
 257     } else {
 258       Rnglists.dump(rnglistData, OS, LookupPooledAddress, DumpOpts);
 259     }
 260   }
 261 }
 262
 263 std::unique_ptr<DWARFDebugMacro>
 264 DWARFContext::parseMacroOrMacinfo(MacroSecType SectionType) {
 265   auto Macro = std::make_unique<DWARFDebugMacro>();
 266   auto ParseAndDump = [&](DWARFDataExtractor &Data, bool IsMacro) {
 267     if (Error Err = IsMacro ? Macro->parseMacro(SectionType == MacroSection
 268                                                     ? compile_units()
 269                                                     : dwo_compile_units(),
 270                                                 SectionType == MacroSection
 271                                                     ? getStringExtractor()
 272                                                     : getStringDWOExtractor(),
 273                                                 Data)
 274                             : Macro->parseMacinfo(Data)) {
 275       RecoverableErrorHandler(std::move(Err));
 276       Macro = nullptr;
 277     }
 278   };
 279   switch (SectionType) {
 280   case MacinfoSection: {
 281     DWARFDataExtractor Data(DObj->getMacinfoSection(), isLittleEndian(), 0);
 282     ParseAndDump(Data, /*IsMacro=*/false);
 283     break;
 284   }
 285   case MacinfoDwoSection: {
 286     DWARFDataExtractor Data(DObj->getMacinfoDWOSection(), isLittleEndian(), 0);
 287     ParseAndDump(Data, /*IsMacro=*/false);
 288     break;
 289   }
 290   case MacroSection: {
 291     DWARFDataExtractor Data(*DObj, DObj->getMacroSection(), isLittleEndian(),
 292                             0);
 293     ParseAndDump(Data, /*IsMacro=*/true);
 294     break;
 295   }
 296   case MacroDwoSection: {
 297     DWARFDataExtractor Data(DObj->getMacroDWOSection(), isLittleEndian(), 0);
 298     ParseAndDump(Data, /*IsMacro=*/true);
 299     break;
 300   }
 301   }
 302   return Macro;
 303 }
 304
 305 static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
 306                                 DWARFDataExtractor Data,
 307                                 const MCRegisterInfo *MRI,
 308                                 const DWARFObject &Obj,
 309                                 Optional<uint64_t> DumpOffset) {
 310   uint64_t Offset = 0;
 311
 312   while (Data.isValidOffset(Offset)) {
 313     DWARFListTableHeader Header(".debug_loclists", "locations");
 314     if (Error E = Header.extract(Data, &Offset)) {
 315       DumpOpts.RecoverableErrorHandler(std::move(E));
 316       return;
 317     }
 318
 319     Header.dump(Data, OS, DumpOpts);
 320
 321     uint64_t EndOffset = Header.length() + Header.getHeaderOffset();
 322     Data.setAddressSize(Header.getAddrSize());
 323     DWARFDebugLoclists Loc(Data, Header.getVersion());
 324     if (DumpOffset) {
 325       if (DumpOffset >= Offset && DumpOffset < EndOffset) {
 326         Offset = *DumpOffset;
 327         Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/None, MRI, Obj, nullptr,
 328                              DumpOpts, /*Indent=*/0);
 329         OS << "\n";
 330         return;
 331       }
 332     } else {
 333       Loc.dumpRange(Offset, EndOffset - Offset, OS, MRI, Obj, DumpOpts);
 334     }
 335     Offset = EndOffset;
 336   }
 337 }
 338
 339 static void dumpPubTableSection(raw_ostream &OS, DIDumpOptions DumpOpts,
 340                                 DWARFDataExtractor Data, bool GnuStyle) {
 341   DWARFDebugPubTable Table;
 342   Table.extract(Data, GnuStyle, DumpOpts.RecoverableErrorHandler);
 343   Table.dump(OS);
 344 }
 345
 346 void DWARFContext::dump(
 347     raw_ostream &OS, DIDumpOptions DumpOpts,
 348     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
 349   uint64_t DumpType = DumpOpts.DumpType;
 350
 351   StringRef Extension = sys::path::extension(DObj->getFileName());
 352   bool IsDWO = (Extension == ".dwo") || (Extension == ".dwp");
 353
 354   // Print UUID header.
 355   const auto *ObjFile = DObj->getFile();
 356   if (DumpType & DIDT_UUID)
 357     dumpUUID(OS, *ObjFile);
 358
 359   // Print a header for each explicitly-requested section.
 360   // Otherwise just print one for non-empty sections.
 361   // Only print empty .dwo section headers when dumping a .dwo file.
 362   bool Explicit = DumpType != DIDT_All && !IsDWO;
 363   bool ExplicitDWO = Explicit && IsDWO;
 364   auto shouldDump = [&](bool Explicit, const char *Name, unsigned ID,
 365                         StringRef Section) -> Optional<uint64_t> * {
 366     unsigned Mask = 1U << ID;
 367     bool Should = (DumpType & Mask) && (Explicit || !Section.empty());
 368     if (!Should)
 369       return nullptr;
 370     OS << "\n" << Name << " contents:\n";
 371     return &DumpOffsets[ID];
 372   };
 373
 374   // Dump individual sections.
 375   if (shouldDump(Explicit, ".debug_abbrev", DIDT_ID_DebugAbbrev,
 376                  DObj->getAbbrevSection()))
 377     getDebugAbbrev()->dump(OS);
 378   if (shouldDump(ExplicitDWO, ".debug_abbrev.dwo", DIDT_ID_DebugAbbrev,
 379                  DObj->getAbbrevDWOSection()))
 380     getDebugAbbrevDWO()->dump(OS);
 381
 382   auto dumpDebugInfo = [&](const char *Name, unit_iterator_range Units) {
 383     OS << '\n' << Name << " contents:\n";
 384     if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugInfo])
 385       for (const auto &U : Units)
 386         U->getDIEForOffset(DumpOffset.getValue())
 387             .dump(OS, 0, DumpOpts.noImplicitRecursion());
 388     else
 389       for (const auto &U : Units)
 390         U->dump(OS, DumpOpts);
 391   };
 392   if ((DumpType & DIDT_DebugInfo)) {
 393     if (Explicit || getNumCompileUnits())
 394       dumpDebugInfo(".debug_info", info_section_units());
 395     if (ExplicitDWO || getNumDWOCompileUnits())
 396       dumpDebugInfo(".debug_info.dwo", dwo_info_section_units());
 397   }
 398
 399   auto dumpDebugType = [&](const char *Name, unit_iterator_range Units) {
 400     OS << '\n' << Name << " contents:\n";
 401     for (const auto &U : Units)
 402       if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugTypes])
 403         U->getDIEForOffset(*DumpOffset)
 404             .dump(OS, 0, DumpOpts.noImplicitRecursion());
 405       else
 406         U->dump(OS, DumpOpts);
 407   };
 408   if ((DumpType & DIDT_DebugTypes)) {
 409     if (Explicit || getNumTypeUnits())
 410       dumpDebugType(".debug_types", types_section_units());
 411     if (ExplicitDWO || getNumDWOTypeUnits())
 412       dumpDebugType(".debug_types.dwo", dwo_types_section_units());
 413   }
 414
 415   DIDumpOptions LLDumpOpts = DumpOpts;
 416   if (LLDumpOpts.Verbose)
 417     LLDumpOpts.DisplayRawContents = true;
 418
 419   if (const auto *Off = shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
 420                                    DObj->getLocSection().Data)) {
 421     getDebugLoc()->dump(OS, getRegisterInfo(), *DObj, LLDumpOpts, *Off);
 422   }
 423   if (const auto *Off =
 424           shouldDump(Explicit, ".debug_loclists", DIDT_ID_DebugLoclists,
 425                      DObj->getLoclistsSection().Data)) {
 426     DWARFDataExtractor Data(*DObj, DObj->getLoclistsSection(), isLittleEndian(),
 427                             0);
 428     dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off);
 429   }
 430   if (const auto *Off =
 431           shouldDump(ExplicitDWO, ".debug_loclists.dwo", DIDT_ID_DebugLoclists,
 432                      DObj->getLoclistsDWOSection().Data)) {
 433     DWARFDataExtractor Data(*DObj, DObj->getLoclistsDWOSection(),
 434                             isLittleEndian(), 0);
 435     dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off);
 436   }
 437
 438   if (const auto *Off =
 439           shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
 440                      DObj->getLocDWOSection().Data)) {
 441     DWARFDataExtractor Data(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
 442                             4);
 443     DWARFDebugLoclists Loc(Data, /*Version=*/4);
 444     if (*Off) {
 445       uint64_t Offset = **Off;
 446       Loc.dumpLocationList(&Offset, OS,
 447                            /*BaseAddr=*/None, getRegisterInfo(), *DObj, nullptr,
 448                            LLDumpOpts, /*Indent=*/0);
 449       OS << "\n";
 450     } else {
 451       Loc.dumpRange(0, Data.getData().size(), OS, getRegisterInfo(), *DObj,
 452                     LLDumpOpts);
 453     }
 454   }
 455
 456   if (const Optional<uint64_t> *Off =
 457           shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
 458                      DObj->getFrameSection().Data)) {
 459     if (Expected<const DWARFDebugFrame *> DF = getDebugFrame())
 460       (*DF)->dump(OS, DumpOpts, getRegisterInfo(), *Off);
 461     else
 462       RecoverableErrorHandler(DF.takeError());
 463   }
 464
 465   if (const Optional<uint64_t> *Off =
 466           shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,
 467                      DObj->getEHFrameSection().Data)) {
 468     if (Expected<const DWARFDebugFrame *> DF = getEHFrame())
 469       (*DF)->dump(OS, DumpOpts, getRegisterInfo(), *Off);
 470     else
 471       RecoverableErrorHandler(DF.takeError());
 472   }
 473
 474   if (shouldDump(Explicit, ".debug_macro", DIDT_ID_DebugMacro,
 475                  DObj->getMacroSection().Data)) {
 476     if (auto Macro = getDebugMacro())
 477       Macro->dump(OS);
 478   }
 479
 480   if (shouldDump(Explicit, ".debug_macro.dwo", DIDT_ID_DebugMacro,
 481                  DObj->getMacroDWOSection())) {
 482     if (auto MacroDWO = getDebugMacroDWO())
 483       MacroDWO->dump(OS);
 484   }
 485
 486   if (shouldDump(Explicit, ".debug_macinfo", DIDT_ID_DebugMacro,
 487                  DObj->getMacinfoSection())) {
 488     if (auto Macinfo = getDebugMacinfo())
 489       Macinfo->dump(OS);
 490   }
 491
 492   if (shouldDump(Explicit, ".debug_macinfo.dwo", DIDT_ID_DebugMacro,
 493                  DObj->getMacinfoDWOSection())) {
 494     if (auto MacinfoDWO = getDebugMacinfoDWO())
 495       MacinfoDWO->dump(OS);
 496   }
 497
 498   if (shouldDump(Explicit, ".debug_aranges", DIDT_ID_DebugAranges,
 499                  DObj->getArangesSection())) {
 500     uint64_t offset = 0;
 501     DWARFDataExtractor arangesData(DObj->getArangesSection(), isLittleEndian(),
 502                                    0);
 503     DWARFDebugArangeSet set;
 504     while (arangesData.isValidOffset(offset)) {
 505       if (Error E =
 506               set.extract(arangesData, &offset, DumpOpts.WarningHandler)) {
 507         RecoverableErrorHandler(std::move(E));
 508         break;
 509       }
 510       set.dump(OS);
 511     }
 512   }
 513
 514   auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser,
 515                              DIDumpOptions DumpOpts,
 516                              Optional<uint64_t> DumpOffset) {
 517     while (!Parser.done()) {
 518       if (DumpOffset && Parser.getOffset() != *DumpOffset) {
 519         Parser.skip(DumpOpts.WarningHandler, DumpOpts.WarningHandler);
 520         continue;
 521       }
 522       OS << "debug_line[" << format("0x%8.8" PRIx64, Parser.getOffset())
 523          << "]\n";
 524       Parser.parseNext(DumpOpts.WarningHandler, DumpOpts.WarningHandler, &OS,
 525                        DumpOpts.Verbose);
 526     }
 527   };
 528
 529   auto DumpStrSection = [&](StringRef Section) {
 530     DataExtractor StrData(Section, isLittleEndian(), 0);
 531     uint64_t Offset = 0;
 532     uint64_t StrOffset = 0;
 533     while (StrData.isValidOffset(Offset)) {
 534       Error Err = Error::success();
 535       const char *CStr = StrData.getCStr(&Offset, &Err);
 536       if (Err) {
 537         DumpOpts.WarningHandler(std::move(Err));
 538         return;
 539       }
 540       OS << format("0x%8.8" PRIx64 ": \"", StrOffset);
 541       OS.write_escaped(CStr);
 542       OS << "\"\n";
 543       StrOffset = Offset;
 544     }
 545   };
 546
 547   if (const auto *Off = shouldDump(Explicit, ".debug_line", DIDT_ID_DebugLine,
 548                                    DObj->getLineSection().Data)) {
 549     DWARFDataExtractor LineData(*DObj, DObj->getLineSection(), isLittleEndian(),
 550                                 0);
 551     DWARFDebugLine::SectionParser Parser(LineData, *this, normal_units());
 552     DumpLineSection(Parser, DumpOpts, *Off);
 553   }
 554
 555   if (const auto *Off =
 556           shouldDump(ExplicitDWO, ".debug_line.dwo", DIDT_ID_DebugLine,
 557                      DObj->getLineDWOSection().Data)) {
 558     DWARFDataExtractor LineData(*DObj, DObj->getLineDWOSection(),
 559                                 isLittleEndian(), 0);
 560     DWARFDebugLine::SectionParser Parser(LineData, *this, dwo_units());
 561     DumpLineSection(Parser, DumpOpts, *Off);
 562   }
 563
 564   if (shouldDump(Explicit, ".debug_cu_index", DIDT_ID_DebugCUIndex,
 565                  DObj->getCUIndexSection())) {
 566     getCUIndex().dump(OS);
 567   }
 568
 569   if (shouldDump(Explicit, ".debug_tu_index", DIDT_ID_DebugTUIndex,
 570                  DObj->getTUIndexSection())) {
 571     getTUIndex().dump(OS);
 572   }
 573
 574   if (shouldDump(Explicit, ".debug_str", DIDT_ID_DebugStr,
 575                  DObj->getStrSection()))
 576     DumpStrSection(DObj->getStrSection());
 577
 578   if (shouldDump(ExplicitDWO, ".debug_str.dwo", DIDT_ID_DebugStr,
 579                  DObj->getStrDWOSection()))
 580     DumpStrSection(DObj->getStrDWOSection());
 581
 582   if (shouldDump(Explicit, ".debug_line_str", DIDT_ID_DebugLineStr,
 583                  DObj->getLineStrSection()))
 584     DumpStrSection(DObj->getLineStrSection());
 585
 586   if (shouldDump(Explicit, ".debug_addr", DIDT_ID_DebugAddr,
 587                  DObj->getAddrSection().Data)) {
 588     DWARFDataExtractor AddrData(*DObj, DObj->getAddrSection(),
 589                                    isLittleEndian(), 0);
 590     dumpAddrSection(OS, AddrData, DumpOpts, getMaxVersion(), getCUAddrSize());
 591   }
 592
 593   if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges,
 594                  DObj->getRangesSection().Data)) {
 595     uint8_t savedAddressByteSize = getCUAddrSize();
 596     DWARFDataExtractor rangesData(*DObj, DObj->getRangesSection(),
 597                                   isLittleEndian(), savedAddressByteSize);
 598     uint64_t offset = 0;
 599     DWARFDebugRangeList rangeList;
 600     while (rangesData.isValidOffset(offset)) {
 601       if (Error E = rangeList.extract(rangesData, &offset)) {
 602         DumpOpts.RecoverableErrorHandler(std::move(E));
 603         break;
 604       }
 605       rangeList.dump(OS);
 606     }
 607   }
 608
 609   auto LookupPooledAddress = [&](uint32_t Index) -> Optional<SectionedAddress> {
 610     const auto &CUs = compile_units();
 611     auto I = CUs.begin();
 612     if (I == CUs.end())
 613       return None;
 614     return (*I)->getAddrOffsetSectionItem(Index);
 615   };
 616
 617   if (shouldDump(Explicit, ".debug_rnglists", DIDT_ID_DebugRnglists,
 618                  DObj->getRnglistsSection().Data)) {
 619     DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsSection(),
 620                                    isLittleEndian(), 0);
 621     dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts);
 622   }
 623
 624   if (shouldDump(ExplicitDWO, ".debug_rnglists.dwo", DIDT_ID_DebugRnglists,
 625                  DObj->getRnglistsDWOSection().Data)) {
 626     DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsDWOSection(),
 627                                    isLittleEndian(), 0);
 628     dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts);
 629   }
 630
 631   if (shouldDump(Explicit, ".debug_pubnames", DIDT_ID_DebugPubnames,
 632                  DObj->getPubnamesSection().Data)) {
 633     DWARFDataExtractor PubTableData(*DObj, DObj->getPubnamesSection(),
 634                                     isLittleEndian(), 0);
 635     dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/false);
 636   }
 637
 638   if (shouldDump(Explicit, ".debug_pubtypes", DIDT_ID_DebugPubtypes,
 639                  DObj->getPubtypesSection().Data)) {
 640     DWARFDataExtractor PubTableData(*DObj, DObj->getPubtypesSection(),
 641                                     isLittleEndian(), 0);
 642     dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/false);
 643   }
 644
 645   if (shouldDump(Explicit, ".debug_gnu_pubnames", DIDT_ID_DebugGnuPubnames,
 646                  DObj->getGnuPubnamesSection().Data)) {
 647     DWARFDataExtractor PubTableData(*DObj, DObj->getGnuPubnamesSection(),
 648                                     isLittleEndian(), 0);
 649     dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/true);
 650   }
 651
 652   if (shouldDump(Explicit, ".debug_gnu_pubtypes", DIDT_ID_DebugGnuPubtypes,
 653                  DObj->getGnuPubtypesSection().Data)) {
 654     DWARFDataExtractor PubTableData(*DObj, DObj->getGnuPubtypesSection(),
 655                                     isLittleEndian(), 0);
 656     dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/true);
 657   }
 658
 659   if (shouldDump(Explicit, ".debug_str_offsets", DIDT_ID_DebugStrOffsets,
 660                  DObj->getStrOffsetsSection().Data))
 661     dumpStringOffsetsSection(
 662         OS, DumpOpts, "debug_str_offsets", *DObj, DObj->getStrOffsetsSection(),
 663         DObj->getStrSection(), normal_units(), isLittleEndian());
 664   if (shouldDump(ExplicitDWO, ".debug_str_offsets.dwo", DIDT_ID_DebugStrOffsets,
 665                  DObj->getStrOffsetsDWOSection().Data))
 666     dumpStringOffsetsSection(OS, DumpOpts, "debug_str_offsets.dwo", *DObj,
 667                              DObj->getStrOffsetsDWOSection(),
 668                              DObj->getStrDWOSection(), dwo_units(),
 669                              isLittleEndian());
 670
 671   if (shouldDump(Explicit, ".gdb_index", DIDT_ID_GdbIndex,
 672                  DObj->getGdbIndexSection())) {
 673     getGdbIndex().dump(OS);
 674   }
 675
 676   if (shouldDump(Explicit, ".apple_names", DIDT_ID_AppleNames,
 677                  DObj->getAppleNamesSection().Data))
 678     getAppleNames().dump(OS);
 679
 680   if (shouldDump(Explicit, ".apple_types", DIDT_ID_AppleTypes,
 681                  DObj->getAppleTypesSection().Data))
 682     getAppleTypes().dump(OS);
 683
 684   if (shouldDump(Explicit, ".apple_namespaces", DIDT_ID_AppleNamespaces,
 685                  DObj->getAppleNamespacesSection().Data))
 686     getAppleNamespaces().dump(OS);
 687
 688   if (shouldDump(Explicit, ".apple_objc", DIDT_ID_AppleObjC,
 689                  DObj->getAppleObjCSection().Data))
 690     getAppleObjC().dump(OS);
 691   if (shouldDump(Explicit, ".debug_names", DIDT_ID_DebugNames,
 692                  DObj->getNamesSection().Data))
 693     getDebugNames().dump(OS);
 694 }
 695
 696 DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) {
 697   parseDWOUnits(LazyParse);
 698
 699   if (const auto &CUI = getCUIndex()) {
 700     if (const auto *R = CUI.getFromHash(Hash))
 701       return dyn_cast_or_null<DWARFCompileUnit>(
 702           DWOUnits.getUnitForIndexEntry(*R));
 703     return nullptr;
 704   }
 705
 706   // If there's no index, just search through the CUs in the DWO - there's
 707   // probably only one unless this is something like LTO - though an in-process
 708   // built/cached lookup table could be used in that case to improve repeated
 709   // lookups of different CUs in the DWO.
 710   for (const auto &DWOCU : dwo_compile_units()) {
 711     // Might not have parsed DWO ID yet.
 712     if (!DWOCU->getDWOId()) {
 713       if (Optional<uint64_t> DWOId =
 714           toUnsigned(DWOCU->getUnitDIE().find(DW_AT_GNU_dwo_id)))
 715         DWOCU->setDWOId(*DWOId);
 716       else
 717         // No DWO ID?
 718         continue;
 719     }
 720     if (DWOCU->getDWOId() == Hash)
 721       return dyn_cast<DWARFCompileUnit>(DWOCU.get());
 722   }
 723   return nullptr;
 724 }
 725
 726 DWARFDie DWARFContext::getDIEForOffset(uint64_t Offset) {
 727   parseNormalUnits();
 728   if (auto *CU = NormalUnits.getUnitForOffset(Offset))
 729     return CU->getDIEForOffset(Offset);
 730   return DWARFDie();
 731 }
 732
 733 bool DWARFContext::verify(raw_ostream &OS, DIDumpOptions DumpOpts) {
 734   bool Success = true;
 735   DWARFVerifier verifier(OS, *this, DumpOpts);
 736
 737   Success &= verifier.handleDebugAbbrev();
 738   if (DumpOpts.DumpType & DIDT_DebugInfo)
 739     Success &= verifier.handleDebugInfo();
 740   if (DumpOpts.DumpType & DIDT_DebugLine)
 741     Success &= verifier.handleDebugLine();
 742   Success &= verifier.handleAccelTables();
 743   return Success;
 744 }
 745
 746 const DWARFUnitIndex &DWARFContext::getCUIndex() {
 747   if (CUIndex)
 748     return *CUIndex;
 749
 750   DataExtractor CUIndexData(DObj->getCUIndexSection(), isLittleEndian(), 0);
 751
 752   CUIndex = std::make_unique<DWARFUnitIndex>(DW_SECT_INFO);
 753   CUIndex->parse(CUIndexData);
 754   return *CUIndex;
 755 }
 756
 757 const DWARFUnitIndex &DWARFContext::getTUIndex() {
 758   if (TUIndex)
 759     return *TUIndex;
 760
 761   DataExtractor TUIndexData(DObj->getTUIndexSection(), isLittleEndian(), 0);
 762
 763   TUIndex = std::make_unique<DWARFUnitIndex>(DW_SECT_EXT_TYPES);
 764   TUIndex->parse(TUIndexData);
 765   return *TUIndex;
 766 }
 767
 768 DWARFGdbIndex &DWARFContext::getGdbIndex() {
 769   if (GdbIndex)
 770     return *GdbIndex;
 771
 772   DataExtractor GdbIndexData(DObj->getGdbIndexSection(), true /*LE*/, 0);
 773   GdbIndex = std::make_unique<DWARFGdbIndex>();
 774   GdbIndex->parse(GdbIndexData);
 775   return *GdbIndex;
 776 }
 777
 778 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
 779   if (Abbrev)
 780     return Abbrev.get();
 781
 782   DataExtractor abbrData(DObj->getAbbrevSection(), isLittleEndian(), 0);
 783
 784   Abbrev.reset(new DWARFDebugAbbrev());
 785   Abbrev->extract(abbrData);
 786   return Abbrev.get();
 787 }
 788
 789 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() {
 790   if (AbbrevDWO)
 791     return AbbrevDWO.get();
 792
 793   DataExtractor abbrData(DObj->getAbbrevDWOSection(), isLittleEndian(), 0);
 794   AbbrevDWO.reset(new DWARFDebugAbbrev());
 795   AbbrevDWO->extract(abbrData);
 796   return AbbrevDWO.get();
 797 }
 798
 799 const DWARFDebugLoc *DWARFContext::getDebugLoc() {
 800   if (Loc)
 801     return Loc.get();
 802
 803   // Assume all units have the same address byte size.
 804   auto LocData =
 805       getNumCompileUnits()
 806           ? DWARFDataExtractor(*DObj, DObj->getLocSection(), isLittleEndian(),
 807                                getUnitAtIndex(0)->getAddressByteSize())
 808           : DWARFDataExtractor("", isLittleEndian(), 0);
 809   Loc.reset(new DWARFDebugLoc(std::move(LocData)));
 810   return Loc.get();
 811 }
 812
 813 const DWARFDebugAranges *DWARFContext::getDebugAranges() {
 814   if (Aranges)
 815     return Aranges.get();
 816
 817   Aranges.reset(new DWARFDebugAranges());
 818   Aranges->generate(this);
 819   return Aranges.get();
 820 }
 821
 822 Expected<const DWARFDebugFrame *> DWARFContext::getDebugFrame() {
 823   if (DebugFrame)
 824     return DebugFrame.get();
 825
 826   const DWARFSection &DS = DObj->getFrameSection();
 827
 828   // There's a "bug" in the DWARFv3 standard with respect to the target address
 829   // size within debug frame sections. While DWARF is supposed to be independent
 830   // of its container, FDEs have fields with size being "target address size",
 831   // which isn't specified in DWARF in general. It's only specified for CUs, but
 832   // .eh_frame can appear without a .debug_info section. Follow the example of
 833   // other tools (libdwarf) and extract this from the container (ObjectFile
 834   // provides this information). This problem is fixed in DWARFv4
 835   // See this dwarf-discuss discussion for more details:
 836   // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
 837   DWARFDataExtractor DebugFrameData(*DObj, DS, isLittleEndian(),
 838                                     DObj->getAddressSize());
 839   auto DF =
 840       std::make_unique<DWARFDebugFrame>(getArch(), /*IsEH=*/false, DS.Address);
 841   if (Error E = DF->parse(DebugFrameData))
 842     return std::move(E);
 843
 844   DebugFrame.swap(DF);
 845   return DebugFrame.get();
 846 }
 847
 848 Expected<const DWARFDebugFrame *> DWARFContext::getEHFrame() {
 849   if (EHFrame)
 850     return EHFrame.get();
 851
 852   const DWARFSection &DS = DObj->getEHFrameSection();
 853   DWARFDataExtractor DebugFrameData(*DObj, DS, isLittleEndian(),
 854                                     DObj->getAddressSize());
 855
 856   auto DF =
 857       std::make_unique<DWARFDebugFrame>(getArch(), /*IsEH=*/true, DS.Address);
 858   if (Error E = DF->parse(DebugFrameData))
 859     return std::move(E);
 860   DebugFrame.swap(DF);
 861   return DebugFrame.get();
 862 }
 863
 864 const DWARFDebugMacro *DWARFContext::getDebugMacro() {
 865   if (!Macro)
 866     Macro = parseMacroOrMacinfo(MacroSection);
 867   return Macro.get();
 868 }
 869
 870 const DWARFDebugMacro *DWARFContext::getDebugMacroDWO() {
 871   if (!MacroDWO)
 872     MacroDWO = parseMacroOrMacinfo(MacroDwoSection);
 873   return MacroDWO.get();
 874 }
 875
 876 const DWARFDebugMacro *DWARFContext::getDebugMacinfo() {
 877   if (!Macinfo)
 878     Macinfo = parseMacroOrMacinfo(MacinfoSection);
 879   return Macinfo.get();
 880 }
 881
 882 const DWARFDebugMacro *DWARFContext::getDebugMacinfoDWO() {
 883   if (!MacinfoDWO)
 884     MacinfoDWO = parseMacroOrMacinfo(MacinfoDwoSection);
 885   return MacinfoDWO.get();
 886 }
 887
 888 template <typename T>
 889 static T &getAccelTable(std::unique_ptr<T> &Cache, const DWARFObject &Obj,
 890                         const DWARFSection &Section, StringRef StringSection,
 891                         bool IsLittleEndian) {
 892   if (Cache)
 893     return *Cache;
 894   DWARFDataExtractor AccelSection(Obj, Section, IsLittleEndian, 0);
 895   DataExtractor StrData(StringSection, IsLittleEndian, 0);
 896   Cache.reset(new T(AccelSection, StrData));
 897   if (Error E = Cache->extract())
 898     llvm::consumeError(std::move(E));
 899   return *Cache;
 900 }
 901
 902 const DWARFDebugNames &DWARFContext::getDebugNames() {
 903   return getAccelTable(Names, *DObj, DObj->getNamesSection(),
 904                        DObj->getStrSection(), isLittleEndian());
 905 }
 906
 907 const AppleAcceleratorTable &DWARFContext::getAppleNames() {
 908   return getAccelTable(AppleNames, *DObj, DObj->getAppleNamesSection(),
 909                        DObj->getStrSection(), isLittleEndian());
 910 }
 911
 912 const AppleAcceleratorTable &DWARFContext::getAppleTypes() {
 913   return getAccelTable(AppleTypes, *DObj, DObj->getAppleTypesSection(),
 914                        DObj->getStrSection(), isLittleEndian());
 915 }
 916
 917 const AppleAcceleratorTable &DWARFContext::getAppleNamespaces() {
 918   return getAccelTable(AppleNamespaces, *DObj,
 919                        DObj->getAppleNamespacesSection(),
 920                        DObj->getStrSection(), isLittleEndian());
 921 }
 922
 923 const AppleAcceleratorTable &DWARFContext::getAppleObjC() {
 924   return getAccelTable(AppleObjC, *DObj, DObj->getAppleObjCSection(),
 925                        DObj->getStrSection(), isLittleEndian());
 926 }
 927
 928 const DWARFDebugLine::LineTable *
 929 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
 930   Expected<const DWARFDebugLine::LineTable *> ExpectedLineTable =
 931       getLineTableForUnit(U, WarningHandler);
 932   if (!ExpectedLineTable) {
 933     WarningHandler(ExpectedLineTable.takeError());
 934     return nullptr;
 935   }
 936   return *ExpectedLineTable;
 937 }
 938
 939 Expected<const DWARFDebugLine::LineTable *> DWARFContext::getLineTableForUnit(
 940     DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) {
 941   if (!Line)
 942     Line.reset(new DWARFDebugLine);
 943
 944   auto UnitDIE = U->getUnitDIE();
 945   if (!UnitDIE)
 946     return nullptr;
 947
 948   auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list));
 949   if (!Offset)
 950     return nullptr; // No line table for this compile unit.
 951
 952   uint64_t stmtOffset = *Offset + U->getLineTableOffset();
 953   // See if the line table is cached.
 954   if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
 955     return lt;
 956
 957   // Make sure the offset is good before we try to parse.
 958   if (stmtOffset >= U->getLineSection().Data.size())
 959     return nullptr;
 960
 961   // We have to parse it first.
 962   DWARFDataExtractor lineData(*DObj, U->getLineSection(), isLittleEndian(),
 963                               U->getAddressByteSize());
 964   return Line->getOrParseLineTable(lineData, stmtOffset, *this, U,
 965                                    RecoverableErrorHandler);
 966 }
 967
 968 void DWARFContext::parseNormalUnits() {
 969   if (!NormalUnits.empty())
 970     return;
 971   DObj->forEachInfoSections([&](const DWARFSection &S) {
 972     NormalUnits.addUnitsForSection(*this, S, DW_SECT_INFO);
 973   });
 974   NormalUnits.finishedInfoUnits();
 975   DObj->forEachTypesSections([&](const DWARFSection &S) {
 976     NormalUnits.addUnitsForSection(*this, S, DW_SECT_EXT_TYPES);
 977   });
 978 }
 979
 980 void DWARFContext::parseDWOUnits(bool Lazy) {
 981   if (!DWOUnits.empty())
 982     return;
 983   DObj->forEachInfoDWOSections([&](const DWARFSection &S) {
 984     DWOUnits.addUnitsForDWOSection(*this, S, DW_SECT_INFO, Lazy);
 985   });
 986   DWOUnits.finishedInfoUnits();
 987   DObj->forEachTypesDWOSections([&](const DWARFSection &S) {
 988     DWOUnits.addUnitsForDWOSection(*this, S, DW_SECT_EXT_TYPES, Lazy);
 989   });
 990 }
 991
 992 DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint64_t Offset) {
 993   parseNormalUnits();
 994   return dyn_cast_or_null<DWARFCompileUnit>(
 995       NormalUnits.getUnitForOffset(Offset));
 996 }
 997
 998 DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
 999   // First, get the offset of the compile unit.
1000   uint64_t CUOffset = getDebugAranges()->findAddress(Address);
1001   // Retrieve the compile unit.
1002   return getCompileUnitForOffset(CUOffset);
1003 }
1004
1005 DWARFContext::DIEsForAddress DWARFContext::getDIEsForAddress(uint64_t Address) {
1006   DIEsForAddress Result;
1007
1008   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
1009   if (!CU)
1010     return Result;
1011
1012   Result.CompileUnit = CU;
1013   Result.FunctionDIE = CU->getSubroutineForAddress(Address);
1014
1015   std::vector<DWARFDie> Worklist;
1016   Worklist.push_back(Result.FunctionDIE);
1017   while (!Worklist.empty()) {
1018     DWARFDie DIE = Worklist.back();
1019     Worklist.pop_back();
1020
1021     if (!DIE.isValid())
1022       continue;
1023
1024     if (DIE.getTag() == DW_TAG_lexical_block &&
1025         DIE.addressRangeContainsAddress(Address)) {
1026       Result.BlockDIE = DIE;
1027       break;
1028     }
1029
1030     append_range(Worklist, DIE);
1031   }
1032
1033   return Result;
1034 }
1035
1036 /// TODO: change input parameter from "uint64_t Address"
1037 ///       into "SectionedAddress Address"
1038 static bool getFunctionNameAndStartLineForAddress(
1039     DWARFCompileUnit *CU, uint64_t Address, FunctionNameKind Kind,
1040     DILineInfoSpecifier::FileLineInfoKind FileNameKind,
1041     std::string &FunctionName, std::string &StartFile, uint32_t &StartLine,
1042     Optional<uint64_t> &StartAddress) {
1043   // The address may correspond to instruction in some inlined function,
1044   // so we have to build the chain of inlined functions and take the
1045   // name of the topmost function in it.
1046   SmallVector<DWARFDie, 4> InlinedChain;
1047   CU->getInlinedChainForAddress(Address, InlinedChain);
1048   if (InlinedChain.empty())
1049     return false;
1050
1051   const DWARFDie &DIE = InlinedChain[0];
1052   bool FoundResult = false;
1053   const char *Name = nullptr;
1054   if (Kind != FunctionNameKind::None && (Name = DIE.getSubroutineName(Kind))) {
1055     FunctionName = Name;
1056     FoundResult = true;
1057   }
1058   std::string DeclFile = DIE.getDeclFile(FileNameKind);
1059   if (!DeclFile.empty()) {
1060     StartFile = DeclFile;
1061     FoundResult = true;
1062   }
1063   if (auto DeclLineResult = DIE.getDeclLine()) {
1064     StartLine = DeclLineResult;
1065     FoundResult = true;
1066   }
1067   if (auto LowPcAddr = toSectionedAddress(DIE.find(DW_AT_low_pc)))
1068     StartAddress = LowPcAddr->Address;
1069   return FoundResult;
1070 }
1071
1072 static Optional<uint64_t> getTypeSize(DWARFDie Type, uint64_t PointerSize) {
1073   if (auto SizeAttr = Type.find(DW_AT_byte_size))
1074     if (Optional<uint64_t> Size = SizeAttr->getAsUnsignedConstant())
1075       return Size;
1076
1077   switch (Type.getTag()) {
1078   case DW_TAG_pointer_type:
1079   case DW_TAG_reference_type:
1080   case DW_TAG_rvalue_reference_type:
1081     return PointerSize;
1082   case DW_TAG_ptr_to_member_type: {
1083     if (DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type))
1084       if (BaseType.getTag() == DW_TAG_subroutine_type)
1085         return 2 * PointerSize;
1086     return PointerSize;
1087   }
1088   case DW_TAG_const_type:
1089   case DW_TAG_volatile_type:
1090   case DW_TAG_restrict_type:
1091   case DW_TAG_typedef: {
1092     if (DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type))
1093       return getTypeSize(BaseType, PointerSize);
1094     break;
1095   }
1096   case DW_TAG_array_type: {
1097     DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type);
1098     if (!BaseType)
1099       return Optional<uint64_t>();
1100     Optional<uint64_t> BaseSize = getTypeSize(BaseType, PointerSize);
1101     if (!BaseSize)
1102       return Optional<uint64_t>();
1103     uint64_t Size = *BaseSize;
1104     for (DWARFDie Child : Type) {
1105       if (Child.getTag() != DW_TAG_subrange_type)
1106         continue;
1107
1108       if (auto ElemCountAttr = Child.find(DW_AT_count))
1109         if (Optional<uint64_t> ElemCount =
1110                 ElemCountAttr->getAsUnsignedConstant())
1111           Size *= *ElemCount;
1112       if (auto UpperBoundAttr = Child.find(DW_AT_upper_bound))
1113         if (Optional<int64_t> UpperBound =
1114                 UpperBoundAttr->getAsSignedConstant()) {
1115           int64_t LowerBound = 0;
1116           if (auto LowerBoundAttr = Child.find(DW_AT_lower_bound))
1117             LowerBound = LowerBoundAttr->getAsSignedConstant().getValueOr(0);
1118           Size *= *UpperBound - LowerBound + 1;
1119         }
1120     }
1121     return Size;
1122   }
1123   default:
1124     break;
1125   }
1126   return Optional<uint64_t>();
1127 }
1128
1129 static Optional<int64_t>
1130 getExpressionFrameOffset(ArrayRef<uint8_t> Expr,
1131                          Optional<unsigned> FrameBaseReg) {
1132   if (!Expr.empty() &&
1133       (Expr[0] == DW_OP_fbreg ||
1134        (FrameBaseReg && Expr[0] == DW_OP_breg0 + *FrameBaseReg))) {
1135     unsigned Count;
1136     int64_t Offset = decodeSLEB128(Expr.data() + 1, &Count, Expr.end());
1137     // A single DW_OP_fbreg or DW_OP_breg.
1138     if (Expr.size() == Count + 1)
1139       return Offset;
1140     // Same + DW_OP_deref (Fortran arrays look like this).
1141     if (Expr.size() == Count + 2 && Expr[Count + 1] == DW_OP_deref)
1142       return Offset;
1143     // Fallthrough. Do not accept ex. (DW_OP_breg W29, DW_OP_stack_value)
1144   }
1145   return None;
1146 }
1147
1148 void DWARFContext::addLocalsForDie(DWARFCompileUnit *CU, DWARFDie Subprogram,
1149                                    DWARFDie Die, std::vector<DILocal> &Result) {
1150   if (Die.getTag() == DW_TAG_variable ||
1151       Die.getTag() == DW_TAG_formal_parameter) {
1152     DILocal Local;
1153     if (const char *Name = Subprogram.getSubroutineName(DINameKind::ShortName))
1154       Local.FunctionName = Name;
1155
1156     Optional<unsigned> FrameBaseReg;
1157     if (auto FrameBase = Subprogram.find(DW_AT_frame_base))
1158       if (Optional<ArrayRef<uint8_t>> Expr = FrameBase->getAsBlock())
1159         if (!Expr->empty() && (*Expr)[0] >= DW_OP_reg0 &&
1160             (*Expr)[0] <= DW_OP_reg31) {
1161           FrameBaseReg = (*Expr)[0] - DW_OP_reg0;
1162         }
1163
1164     if (Expected<std::vector<DWARFLocationExpression>> Loc =
1165             Die.getLocations(DW_AT_location)) {
1166       for (const auto &Entry : *Loc) {
1167         if (Optional<int64_t> FrameOffset =
1168                 getExpressionFrameOffset(Entry.Expr, FrameBaseReg)) {
1169           Local.FrameOffset = *FrameOffset;
1170           break;
1171         }
1172       }
1173     } else {
1174       // FIXME: missing DW_AT_location is OK here, but other errors should be
1175       // reported to the user.
1176       consumeError(Loc.takeError());
1177     }
1178
1179     if (auto TagOffsetAttr = Die.find(DW_AT_LLVM_tag_offset))
1180       Local.TagOffset = TagOffsetAttr->getAsUnsignedConstant();
1181
1182     if (auto Origin =
1183             Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
1184       Die = Origin;
1185     if (auto NameAttr = Die.find(DW_AT_name))
1186       if (Optional<const char *> Name = NameAttr->getAsCString())
1187         Local.Name = *Name;
1188     if (auto Type = Die.getAttributeValueAsReferencedDie(DW_AT_type))
1189       Local.Size = getTypeSize(Type, getCUAddrSize());
1190     if (auto DeclFileAttr = Die.find(DW_AT_decl_file)) {
1191       if (const auto *LT = CU->getContext().getLineTableForUnit(CU))
1192         LT->getFileNameByIndex(
1193             DeclFileAttr->getAsUnsignedConstant().getValue(),
1194             CU->getCompilationDir(),
1195             DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath,
1196             Local.DeclFile);
1197     }
1198     if (auto DeclLineAttr = Die.find(DW_AT_decl_line))
1199       Local.DeclLine = DeclLineAttr->getAsUnsignedConstant().getValue();
1200
1201     Result.push_back(Local);
1202     return;
1203   }
1204
1205   if (Die.getTag() == DW_TAG_inlined_subroutine)
1206     if (auto Origin =
1207             Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
1208       Subprogram = Origin;
1209
1210   for (auto Child : Die)
1211     addLocalsForDie(CU, Subprogram, Child, Result);
1212 }
1213
1214 std::vector<DILocal>
1215 DWARFContext::getLocalsForAddress(object::SectionedAddress Address) {
1216   std::vector<DILocal> Result;
1217   DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
1218   if (!CU)
1219     return Result;
1220
1221   DWARFDie Subprogram = CU->getSubroutineForAddress(Address.Address);
1222   if (Subprogram.isValid())
1223     addLocalsForDie(CU, Subprogram, Subprogram, Result);
1224   return Result;
1225 }
1226
1227 DILineInfo DWARFContext::getLineInfoForAddress(object::SectionedAddress Address,
1228                                                DILineInfoSpecifier Spec) {
1229   DILineInfo Result;
1230
1231   DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
1232   if (!CU)
1233     return Result;
1234
1235   getFunctionNameAndStartLineForAddress(
1236       CU, Address.Address, Spec.FNKind, Spec.FLIKind, Result.FunctionName,
1237       Result.StartFileName, Result.StartLine, Result.StartAddress);
1238   if (Spec.FLIKind != FileLineInfoKind::None) {
1239     if (const DWARFLineTable *LineTable = getLineTableForUnit(CU)) {
1240       LineTable->getFileLineInfoForAddress(
1241           {Address.Address, Address.SectionIndex}, CU->getCompilationDir(),
1242           Spec.FLIKind, Result);
1243     }
1244   }
1245   return Result;
1246 }
1247
1248 DILineInfoTable DWARFContext::getLineInfoForAddressRange(
1249     object::SectionedAddress Address, uint64_t Size, DILineInfoSpecifier Spec) {
1250   DILineInfoTable Lines;
1251   DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
1252   if (!CU)
1253     return Lines;
1254
1255   uint32_t StartLine = 0;
1256   std::string StartFileName;
1257   std::string FunctionName(DILineInfo::BadString);
1258   Optional<uint64_t> StartAddress;
1259   getFunctionNameAndStartLineForAddress(CU, Address.Address, Spec.FNKind,
1260                                         Spec.FLIKind, FunctionName,
1261                                         StartFileName, StartLine, StartAddress);
1262
1263   // If the Specifier says we don't need FileLineInfo, just
1264   // return the top-most function at the starting address.
1265   if (Spec.FLIKind == FileLineInfoKind::None) {
1266     DILineInfo Result;
1267     Result.FunctionName = FunctionName;
1268     Result.StartFileName = StartFileName;
1269     Result.StartLine = StartLine;
1270     Result.StartAddress = StartAddress;
1271     Lines.push_back(std::make_pair(Address.Address, Result));
1272     return Lines;
1273   }
1274
1275   const DWARFLineTable *LineTable = getLineTableForUnit(CU);
1276
1277   // Get the index of row we're looking for in the line table.
1278   std::vector<uint32_t> RowVector;
1279   if (!LineTable->lookupAddressRange({Address.Address, Address.SectionIndex},
1280                                      Size, RowVector)) {
1281     return Lines;
1282   }
1283
1284   for (uint32_t RowIndex : RowVector) {
1285     // Take file number and line/column from the row.
1286     const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
1287     DILineInfo Result;
1288     LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(),
1289                                   Spec.FLIKind, Result.FileName);
1290     Result.FunctionName = FunctionName;
1291     Result.Line = Row.Line;
1292     Result.Column = Row.Column;
1293     Result.StartFileName = StartFileName;
1294     Result.StartLine = StartLine;
1295     Result.StartAddress = StartAddress;
1296     Lines.push_back(std::make_pair(Row.Address.Address, Result));
1297   }
1298
1299   return Lines;
1300 }
1301
1302 DIInliningInfo
1303 DWARFContext::getInliningInfoForAddress(object::SectionedAddress Address,
1304                                         DILineInfoSpecifier Spec) {
1305   DIInliningInfo InliningInfo;
1306
1307   DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
1308   if (!CU)
1309     return InliningInfo;
1310
1311   const DWARFLineTable *LineTable = nullptr;
1312   SmallVector<DWARFDie, 4> InlinedChain;
1313   CU->getInlinedChainForAddress(Address.Address, InlinedChain);
1314   if (InlinedChain.size() == 0) {
1315     // If there is no DIE for address (e.g. it is in unavailable .dwo file),
1316     // try to at least get file/line info from symbol table.
1317     if (Spec.FLIKind != FileLineInfoKind::None) {
1318       DILineInfo Frame;
1319       LineTable = getLineTableForUnit(CU);
1320       if (LineTable && LineTable->getFileLineInfoForAddress(
1321                            {Address.Address, Address.SectionIndex},
1322                            CU->getCompilationDir(), Spec.FLIKind, Frame))
1323         InliningInfo.addFrame(Frame);
1324     }
1325     return InliningInfo;
1326   }
1327
1328   uint32_t CallFile = 0, CallLine = 0, CallColumn = 0, CallDiscriminator = 0;
1329   for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) {
1330     DWARFDie &FunctionDIE = InlinedChain[i];
1331     DILineInfo Frame;
1332     // Get function name if necessary.
1333     if (const char *Name = FunctionDIE.getSubroutineName(Spec.FNKind))
1334       Frame.FunctionName = Name;
1335     if (auto DeclLineResult = FunctionDIE.getDeclLine())
1336       Frame.StartLine = DeclLineResult;
1337     Frame.StartFileName = FunctionDIE.getDeclFile(Spec.FLIKind);
1338     if (auto LowPcAddr = toSectionedAddress(FunctionDIE.find(DW_AT_low_pc)))
1339       Frame.StartAddress = LowPcAddr->Address;
1340     if (Spec.FLIKind != FileLineInfoKind::None) {
1341       if (i == 0) {
1342         // For the topmost frame, initialize the line table of this
1343         // compile unit and fetch file/line info from it.
1344         LineTable = getLineTableForUnit(CU);
1345         // For the topmost routine, get file/line info from line table.
1346         if (LineTable)
1347           LineTable->getFileLineInfoForAddress(
1348               {Address.Address, Address.SectionIndex}, CU->getCompilationDir(),
1349               Spec.FLIKind, Frame);
1350       } else {
1351         // Otherwise, use call file, call line and call column from
1352         // previous DIE in inlined chain.
1353         if (LineTable)
1354           LineTable->getFileNameByIndex(CallFile, CU->getCompilationDir(),
1355                                         Spec.FLIKind, Frame.FileName);
1356         Frame.Line = CallLine;
1357         Frame.Column = CallColumn;
1358         Frame.Discriminator = CallDiscriminator;
1359       }
1360       // Get call file/line/column of a current DIE.
1361       if (i + 1 < n) {
1362         FunctionDIE.getCallerFrame(CallFile, CallLine, CallColumn,
1363                                    CallDiscriminator);
1364       }
1365     }
1366     InliningInfo.addFrame(Frame);
1367   }
1368   return InliningInfo;
1369 }
1370
1371 std::shared_ptr<DWARFContext>
1372 DWARFContext::getDWOContext(StringRef AbsolutePath) {
1373   if (auto S = DWP.lock()) {
1374     DWARFContext *Ctxt = S->Context.get();
1375     return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1376   }
1377
1378   std::weak_ptr<DWOFile> *Entry = &DWOFiles[AbsolutePath];
1379
1380   if (auto S = Entry->lock()) {
1381     DWARFContext *Ctxt = S->Context.get();
1382     return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1383   }
1384
1385   Expected<OwningBinary<ObjectFile>> Obj = [&] {
1386     if (!CheckedForDWP) {
1387       SmallString<128> DWPName;
1388       auto Obj = object::ObjectFile::createObjectFile(
1389           this->DWPName.empty()
1390               ? (DObj->getFileName() + ".dwp").toStringRef(DWPName)
1391               : StringRef(this->DWPName));
1392       if (Obj) {
1393         Entry = &DWP;
1394         return Obj;
1395       } else {
1396         CheckedForDWP = true;
1397         // TODO: Should this error be handled (maybe in a high verbosity mode)
1398         // before falling back to .dwo files?
1399         consumeError(Obj.takeError());
1400       }
1401     }
1402
1403     return object::ObjectFile::createObjectFile(AbsolutePath);
1404   }();
1405
1406   if (!Obj) {
1407     // TODO: Actually report errors helpfully.
1408     consumeError(Obj.takeError());
1409     return nullptr;
1410   }
1411
1412   auto S = std::make_shared<DWOFile>();
1413   S->File = std::move(Obj.get());
1414   S->Context = DWARFContext::create(*S->File.getBinary(),
1415                                     ProcessDebugRelocations::Ignore);
1416   *Entry = S;
1417   auto *Ctxt = S->Context.get();
1418   return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1419 }
1420
1421 static Error createError(const Twine &Reason, llvm::Error E) {
1422   return make_error<StringError>(Reason + toString(std::move(E)),
1423                                  inconvertibleErrorCode());
1424 }
1425
1426 /// SymInfo contains information about symbol: it's address
1427 /// and section index which is -1LL for absolute symbols.
1428 struct SymInfo {
1429   uint64_t Address;
1430   uint64_t SectionIndex;
1431 };
1432
1433 /// Returns the address of symbol relocation used against and a section index.
1434 /// Used for futher relocations computation. Symbol's section load address is
1435 static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj,
1436                                        const RelocationRef &Reloc,
1437                                        const LoadedObjectInfo *L,
1438                                        std::map<SymbolRef, SymInfo> &Cache) {
1439   SymInfo Ret = {0, (uint64_t)-1LL};
1440   object::section_iterator RSec = Obj.section_end();
1441   object::symbol_iterator Sym = Reloc.getSymbol();
1442
1443   std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end();
1444   // First calculate the address of the symbol or section as it appears
1445   // in the object file
1446   if (Sym != Obj.symbol_end()) {
1447     bool New;
1448     std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}});
1449     if (!New)
1450       return CacheIt->second;
1451
1452     Expected<uint64_t> SymAddrOrErr = Sym->getAddress();
1453     if (!SymAddrOrErr)
1454       return createError("failed to compute symbol address: ",
1455                          SymAddrOrErr.takeError());
1456
1457     // Also remember what section this symbol is in for later
1458     auto SectOrErr = Sym->getSection();
1459     if (!SectOrErr)
1460       return createError("failed to get symbol section: ",
1461                          SectOrErr.takeError());
1462
1463     RSec = *SectOrErr;
1464     Ret.Address = *SymAddrOrErr;
1465   } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) {
1466     RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl());
1467     Ret.Address = RSec->getAddress();
1468   }
1469
1470   if (RSec != Obj.section_end())
1471     Ret.SectionIndex = RSec->getIndex();
1472
1473   // If we are given load addresses for the sections, we need to adjust:
1474   // SymAddr = (Address of Symbol Or Section in File) -
1475   //           (Address of Section in File) +
1476   //           (Load Address of Section)
1477   // RSec is now either the section being targeted or the section
1478   // containing the symbol being targeted. In either case,
1479   // we need to perform the same computation.
1480   if (L && RSec != Obj.section_end())
1481     if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(*RSec))
1482       Ret.Address += SectionLoadAddress - RSec->getAddress();
1483
1484   if (CacheIt != Cache.end())
1485     CacheIt->second = Ret;
1486
1487   return Ret;
1488 }
1489
1490 static bool isRelocScattered(const object::ObjectFile &Obj,
1491                              const RelocationRef &Reloc) {
1492   const MachOObjectFile *MachObj = dyn_cast<MachOObjectFile>(&Obj);
1493   if (!MachObj)
1494     return false;
1495   // MachO also has relocations that point to sections and
1496   // scattered relocations.
1497   auto RelocInfo = MachObj->getRelocation(Reloc.getRawDataRefImpl());
1498   return MachObj->isRelocationScattered(RelocInfo);
1499 }
1500
1501 namespace {
1502 struct DWARFSectionMap final : public DWARFSection {
1503   RelocAddrMap Relocs;
1504 };
1505
1506 class DWARFObjInMemory final : public DWARFObject {
1507   bool IsLittleEndian;
1508   uint8_t AddressSize;
1509   StringRef FileName;
1510   const object::ObjectFile *Obj = nullptr;
1511   std::vector<SectionName> SectionNames;
1512
1513   using InfoSectionMap = MapVector<object::SectionRef, DWARFSectionMap,
1514                                    std::map<object::SectionRef, unsigned>>;
1515
1516   InfoSectionMap InfoSections;
1517   InfoSectionMap TypesSections;
1518   InfoSectionMap InfoDWOSections;
1519   InfoSectionMap TypesDWOSections;
1520
1521   DWARFSectionMap LocSection;
1522   DWARFSectionMap LoclistsSection;
1523   DWARFSectionMap LoclistsDWOSection;
1524   DWARFSectionMap LineSection;
1525   DWARFSectionMap RangesSection;
1526   DWARFSectionMap RnglistsSection;
1527   DWARFSectionMap StrOffsetsSection;
1528   DWARFSectionMap LineDWOSection;
1529   DWARFSectionMap FrameSection;
1530   DWARFSectionMap EHFrameSection;
1531   DWARFSectionMap LocDWOSection;
1532   DWARFSectionMap StrOffsetsDWOSection;
1533   DWARFSectionMap RangesDWOSection;
1534   DWARFSectionMap RnglistsDWOSection;
1535   DWARFSectionMap AddrSection;
1536   DWARFSectionMap AppleNamesSection;
1537   DWARFSectionMap AppleTypesSection;
1538   DWARFSectionMap AppleNamespacesSection;
1539   DWARFSectionMap AppleObjCSection;
1540   DWARFSectionMap NamesSection;
1541   DWARFSectionMap PubnamesSection;
1542   DWARFSectionMap PubtypesSection;
1543   DWARFSectionMap GnuPubnamesSection;
1544   DWARFSectionMap GnuPubtypesSection;
1545   DWARFSectionMap MacroSection;
1546
1547   DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
1548     return StringSwitch<DWARFSectionMap *>(Name)
1549         .Case("debug_loc", &LocSection)
1550         .Case("debug_loclists", &LoclistsSection)
1551         .Case("debug_loclists.dwo", &LoclistsDWOSection)
1552         .Case("debug_line", &LineSection)
1553         .Case("debug_frame", &FrameSection)
1554         .Case("eh_frame", &EHFrameSection)
1555         .Case("debug_str_offsets", &StrOffsetsSection)
1556         .Case("debug_ranges", &RangesSection)
1557         .Case("debug_rnglists", &RnglistsSection)
1558         .Case("debug_loc.dwo", &LocDWOSection)
1559         .Case("debug_line.dwo", &LineDWOSection)
1560         .Case("debug_names", &NamesSection)
1561         .Case("debug_rnglists.dwo", &RnglistsDWOSection)
1562         .Case("debug_str_offsets.dwo", &StrOffsetsDWOSection)
1563         .Case("debug_addr", &AddrSection)
1564         .Case("apple_names", &AppleNamesSection)
1565         .Case("debug_pubnames", &PubnamesSection)
1566         .Case("debug_pubtypes", &PubtypesSection)
1567         .Case("debug_gnu_pubnames", &GnuPubnamesSection)
1568         .Case("debug_gnu_pubtypes", &GnuPubtypesSection)
1569         .Case("apple_types", &AppleTypesSection)
1570         .Case("apple_namespaces", &AppleNamespacesSection)
1571         .Case("apple_namespac", &AppleNamespacesSection)
1572         .Case("apple_objc", &AppleObjCSection)
1573         .Case("debug_macro", &MacroSection)
1574         .Default(nullptr);
1575   }
1576
1577   StringRef AbbrevSection;
1578   StringRef ArangesSection;
1579   StringRef StrSection;
1580   StringRef MacinfoSection;
1581   StringRef MacinfoDWOSection;
1582   StringRef MacroDWOSection;
1583   StringRef AbbrevDWOSection;
1584   StringRef StrDWOSection;
1585   StringRef CUIndexSection;
1586   StringRef GdbIndexSection;
1587   StringRef TUIndexSection;
1588   StringRef LineStrSection;
1589
1590   // A deque holding section data whose iterators are not invalidated when
1591   // new decompressed sections are inserted at the end.
1592   std::deque<SmallString<0>> UncompressedSections;
1593
1594   StringRef *mapSectionToMember(StringRef Name) {
1595     if (DWARFSection *Sec = mapNameToDWARFSection(Name))
1596       return &Sec->Data;
1597     return StringSwitch<StringRef *>(Name)
1598         .Case("debug_abbrev", &AbbrevSection)
1599         .Case("debug_aranges", &ArangesSection)
1600         .Case("debug_str", &StrSection)
1601         .Case("debug_macinfo", &MacinfoSection)
1602         .Case("debug_macinfo.dwo", &MacinfoDWOSection)
1603         .Case("debug_macro.dwo", &MacroDWOSection)
1604         .Case("debug_abbrev.dwo", &AbbrevDWOSection)
1605         .Case("debug_str.dwo", &StrDWOSection)
1606         .Case("debug_cu_index", &CUIndexSection)
1607         .Case("debug_tu_index", &TUIndexSection)
1608         .Case("gdb_index", &GdbIndexSection)
1609         .Case("debug_line_str", &LineStrSection)
1610         // Any more debug info sections go here.
1611         .Default(nullptr);
1612   }
1613
1614   /// If Sec is compressed section, decompresses and updates its contents
1615   /// provided by Data. Otherwise leaves it unchanged.
1616   Error maybeDecompress(const object::SectionRef &Sec, StringRef Name,
1617                         StringRef &Data) {
1618     if (!Decompressor::isCompressed(Sec))
1619       return Error::success();
1620
1621     Expected<Decompressor> Decompressor =
1622         Decompressor::create(Name, Data, IsLittleEndian, AddressSize == 8);
1623     if (!Decompressor)
1624       return Decompressor.takeError();
1625
1626     SmallString<0> Out;
1627     if (auto Err = Decompressor->resizeAndDecompress(Out))
1628       return Err;
1629
1630     UncompressedSections.push_back(std::move(Out));
1631     Data = UncompressedSections.back();
1632
1633     return Error::success();
1634   }
1635
1636 public:
1637   DWARFObjInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
1638                    uint8_t AddrSize, bool IsLittleEndian)
1639       : IsLittleEndian(IsLittleEndian) {
1640     for (const auto &SecIt : Sections) {
1641       if (StringRef *SectionData = mapSectionToMember(SecIt.first()))
1642         *SectionData = SecIt.second->getBuffer();
1643       else if (SecIt.first() == "debug_info")
1644         // Find debug_info and debug_types data by section rather than name as
1645         // there are multiple, comdat grouped, of these sections.
1646         InfoSections[SectionRef()].Data = SecIt.second->getBuffer();
1647       else if (SecIt.first() == "debug_info.dwo")
1648         InfoDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
1649       else if (SecIt.first() == "debug_types")
1650         TypesSections[SectionRef()].Data = SecIt.second->getBuffer();
1651       else if (SecIt.first() == "debug_types.dwo")
1652         TypesDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
1653     }
1654   }
1655   DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
1656                    function_ref<void(Error)> HandleError,
1657                    function_ref<void(Error)> HandleWarning,
1658                    DWARFContext::ProcessDebugRelocations RelocAction)
1659       : IsLittleEndian(Obj.isLittleEndian()),
1660         AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()),
1661         Obj(&Obj) {
1662
1663     StringMap<unsigned> SectionAmountMap;
1664     for (const SectionRef &Section : Obj.sections()) {
1665       StringRef Name;
1666       if (auto NameOrErr = Section.getName())
1667         Name = *NameOrErr;
1668       else
1669         consumeError(NameOrErr.takeError());
1670
1671       ++SectionAmountMap[Name];
1672       SectionNames.push_back({ Name, true });
1673
1674       // Skip BSS and Virtual sections, they aren't interesting.
1675       if (Section.isBSS() || Section.isVirtual())
1676         continue;
1677
1678       // Skip sections stripped by dsymutil.
1679       if (Section.isStripped())
1680         continue;
1681
1682       StringRef Data;
1683       Expected<section_iterator> SecOrErr = Section.getRelocatedSection();
1684       if (!SecOrErr) {
1685         HandleError(createError("failed to get relocated section: ",
1686                                 SecOrErr.takeError()));
1687         continue;
1688       }
1689
1690       // Try to obtain an already relocated version of this section.
1691       // Else use the unrelocated section from the object file. We'll have to
1692       // apply relocations ourselves later.
1693       section_iterator RelocatedSection =
1694           Obj.isRelocatableObject() ? *SecOrErr : Obj.section_end();
1695       if (!L || !L->getLoadedSectionContents(*RelocatedSection, Data)) {
1696         Expected<StringRef> E = Section.getContents();
1697         if (E)
1698           Data = *E;
1699         else
1700           // maybeDecompress below will error.
1701           consumeError(E.takeError());
1702       }
1703
1704       if (auto Err = maybeDecompress(Section, Name, Data)) {
1705         HandleError(createError("failed to decompress '" + Name + "', ",
1706                                 std::move(Err)));
1707         continue;
1708       }
1709
1710       // Compressed sections names in GNU style starts from ".z",
1711       // at this point section is decompressed and we drop compression prefix.
1712       Name = Name.substr(
1713           Name.find_first_not_of("._z")); // Skip ".", "z" and "_" prefixes.
1714
1715       // Map platform specific debug section names to DWARF standard section
1716       // names.
1717       Name = Obj.mapDebugSectionName(Name);
1718
1719       if (StringRef *SectionData = mapSectionToMember(Name)) {
1720         *SectionData = Data;
1721         if (Name == "debug_ranges") {
1722           // FIXME: Use the other dwo range section when we emit it.
1723           RangesDWOSection.Data = Data;
1724         } else if (Name == "debug_frame" || Name == "eh_frame") {
1725           if (DWARFSection *S = mapNameToDWARFSection(Name))
1726             S->Address = Section.getAddress();
1727         }
1728       } else if (InfoSectionMap *Sections =
1729                      StringSwitch<InfoSectionMap *>(Name)
1730                          .Case("debug_info", &InfoSections)
1731                          .Case("debug_info.dwo", &InfoDWOSections)
1732                          .Case("debug_types", &TypesSections)
1733                          .Case("debug_types.dwo", &TypesDWOSections)
1734                          .Default(nullptr)) {
1735         // Find debug_info and debug_types data by section rather than name as
1736         // there are multiple, comdat grouped, of these sections.
1737         DWARFSectionMap &S = (*Sections)[Section];
1738         S.Data = Data;
1739       }
1740
1741       if (RelocatedSection != Obj.section_end() && Name.contains(".dwo"))
1742         HandleWarning(
1743             createError("Unexpected relocations for dwo section " + Name));
1744
1745       if (RelocatedSection == Obj.section_end() ||
1746           (RelocAction == DWARFContext::ProcessDebugRelocations::Ignore))
1747         continue;
1748
1749       StringRef RelSecName;
1750       if (auto NameOrErr = RelocatedSection->getName())
1751         RelSecName = *NameOrErr;
1752       else
1753         consumeError(NameOrErr.takeError());
1754
1755       // If the section we're relocating was relocated already by the JIT,
1756       // then we used the relocated version above, so we do not need to process
1757       // relocations for it now.
1758       StringRef RelSecData;
1759       if (L && L->getLoadedSectionContents(*RelocatedSection, RelSecData))
1760         continue;
1761
1762       // In Mach-o files, the relocations do not need to be applied if
1763       // there is no load offset to apply. The value read at the
1764       // relocation point already factors in the section address
1765       // (actually applying the relocations will produce wrong results
1766       // as the section address will be added twice).
1767       if (!L && isa<MachOObjectFile>(&Obj))
1768         continue;
1769
1770       RelSecName = RelSecName.substr(
1771           RelSecName.find_first_not_of("._z")); // Skip . and _ prefixes.
1772
1773       // TODO: Add support for relocations in other sections as needed.
1774       // Record relocations for the debug_info and debug_line sections.
1775       DWARFSectionMap *Sec = mapNameToDWARFSection(RelSecName);
1776       RelocAddrMap *Map = Sec ? &Sec->Relocs : nullptr;
1777       if (!Map) {
1778         // Find debug_info and debug_types relocs by section rather than name
1779         // as there are multiple, comdat grouped, of these sections.
1780         if (RelSecName == "debug_info")
1781           Map = &static_cast<DWARFSectionMap &>(InfoSections[*RelocatedSection])
1782                      .Relocs;
1783         else if (RelSecName == "debug_types")
1784           Map =
1785               &static_cast<DWARFSectionMap &>(TypesSections[*RelocatedSection])
1786                    .Relocs;
1787         else
1788           continue;
1789       }
1790
1791       if (Section.relocation_begin() == Section.relocation_end())
1792         continue;
1793
1794       // Symbol to [address, section index] cache mapping.
1795       std::map<SymbolRef, SymInfo> AddrCache;
1796       SupportsRelocation Supports;
1797       RelocationResolver Resolver;
1798       std::tie(Supports, Resolver) = getRelocationResolver(Obj);
1799       for (const RelocationRef &Reloc : Section.relocations()) {
1800         // FIXME: it's not clear how to correctly handle scattered
1801         // relocations.
1802         if (isRelocScattered(Obj, Reloc))
1803           continue;
1804
1805         Expected<SymInfo> SymInfoOrErr =
1806             getSymbolInfo(Obj, Reloc, L, AddrCache);
1807         if (!SymInfoOrErr) {
1808           HandleError(SymInfoOrErr.takeError());
1809           continue;
1810         }
1811
1812         // Check if Resolver can handle this relocation type early so as not to
1813         // handle invalid cases in DWARFDataExtractor.
1814         //
1815         // TODO Don't store Resolver in every RelocAddrEntry.
1816         if (Supports && Supports(Reloc.getType())) {
1817           auto I = Map->try_emplace(
1818               Reloc.getOffset(),
1819               RelocAddrEntry{SymInfoOrErr->SectionIndex, Reloc,
1820                              SymInfoOrErr->Address,
1821                              Optional<object::RelocationRef>(), 0, Resolver});
1822           // If we didn't successfully insert that's because we already had a
1823           // relocation for that offset. Store it as a second relocation in the
1824           // same RelocAddrEntry instead.
1825           if (!I.second) {
1826             RelocAddrEntry &entry = I.first->getSecond();
1827             if (entry.Reloc2) {
1828               HandleError(createError(
1829                   "At most two relocations per offset are supported"));
1830             }
1831             entry.Reloc2 = Reloc;
1832             entry.SymbolValue2 = SymInfoOrErr->Address;
1833           }
1834         } else {
1835           SmallString<32> Type;
1836           Reloc.getTypeName(Type);
1837           // FIXME: Support more relocations & change this to an error
1838           HandleWarning(
1839               createError("failed to compute relocation: " + Type + ", ",
1840                           errorCodeToError(object_error::parse_failed)));
1841         }
1842       }
1843     }
1844
1845     for (SectionName &S : SectionNames)
1846       if (SectionAmountMap[S.Name] > 1)
1847         S.IsNameUnique = false;
1848   }
1849
1850   Optional<RelocAddrEntry> find(const DWARFSection &S,
1851                                 uint64_t Pos) const override {
1852     auto &Sec = static_cast<const DWARFSectionMap &>(S);
1853     RelocAddrMap::const_iterator AI = Sec.Relocs.find(Pos);
1854     if (AI == Sec.Relocs.end())
1855       return None;
1856     return AI->second;
1857   }
1858
1859   const object::ObjectFile *getFile() const override { return Obj; }
1860
1861   ArrayRef<SectionName> getSectionNames() const override {
1862     return SectionNames;
1863   }
1864
1865   bool isLittleEndian() const override { return IsLittleEndian; }
1866   StringRef getAbbrevDWOSection() const override { return AbbrevDWOSection; }
1867   const DWARFSection &getLineDWOSection() const override {
1868     return LineDWOSection;
1869   }
1870   const DWARFSection &getLocDWOSection() const override {
1871     return LocDWOSection;
1872   }
1873   StringRef getStrDWOSection() const override { return StrDWOSection; }
1874   const DWARFSection &getStrOffsetsDWOSection() const override {
1875     return StrOffsetsDWOSection;
1876   }
1877   const DWARFSection &getRangesDWOSection() const override {
1878     return RangesDWOSection;
1879   }
1880   const DWARFSection &getRnglistsDWOSection() const override {
1881     return RnglistsDWOSection;
1882   }
1883   const DWARFSection &getLoclistsDWOSection() const override {
1884     return LoclistsDWOSection;
1885   }
1886   const DWARFSection &getAddrSection() const override { return AddrSection; }
1887   StringRef getCUIndexSection() const override { return CUIndexSection; }
1888   StringRef getGdbIndexSection() const override { return GdbIndexSection; }
1889   StringRef getTUIndexSection() const override { return TUIndexSection; }
1890
1891   // DWARF v5
1892   const DWARFSection &getStrOffsetsSection() const override {
1893     return StrOffsetsSection;
1894   }
1895   StringRef getLineStrSection() const override { return LineStrSection; }
1896
1897   // Sections for DWARF5 split dwarf proposal.
1898   void forEachInfoDWOSections(
1899       function_ref<void(const DWARFSection &)> F) const override {
1900     for (auto &P : InfoDWOSections)
1901       F(P.second);
1902   }
1903   void forEachTypesDWOSections(
1904       function_ref<void(const DWARFSection &)> F) const override {
1905     for (auto &P : TypesDWOSections)
1906       F(P.second);
1907   }
1908
1909   StringRef getAbbrevSection() const override { return AbbrevSection; }
1910   const DWARFSection &getLocSection() const override { return LocSection; }
1911   const DWARFSection &getLoclistsSection() const override { return LoclistsSection; }
1912   StringRef getArangesSection() const override { return ArangesSection; }
1913   const DWARFSection &getFrameSection() const override {
1914     return FrameSection;
1915   }
1916   const DWARFSection &getEHFrameSection() const override {
1917     return EHFrameSection;
1918   }
1919   const DWARFSection &getLineSection() const override { return LineSection; }
1920   StringRef getStrSection() const override { return StrSection; }
1921   const DWARFSection &getRangesSection() const override { return RangesSection; }
1922   const DWARFSection &getRnglistsSection() const override {
1923     return RnglistsSection;
1924   }
1925   const DWARFSection &getMacroSection() const override { return MacroSection; }
1926   StringRef getMacroDWOSection() const override { return MacroDWOSection; }
1927   StringRef getMacinfoSection() const override { return MacinfoSection; }
1928   StringRef getMacinfoDWOSection() const override { return MacinfoDWOSection; }
1929   const DWARFSection &getPubnamesSection() const override { return PubnamesSection; }
1930   const DWARFSection &getPubtypesSection() const override { return PubtypesSection; }
1931   const DWARFSection &getGnuPubnamesSection() const override {
1932     return GnuPubnamesSection;
1933   }
1934   const DWARFSection &getGnuPubtypesSection() const override {
1935     return GnuPubtypesSection;
1936   }
1937   const DWARFSection &getAppleNamesSection() const override {
1938     return AppleNamesSection;
1939   }
1940   const DWARFSection &getAppleTypesSection() const override {
1941     return AppleTypesSection;
1942   }
1943   const DWARFSection &getAppleNamespacesSection() const override {
1944     return AppleNamespacesSection;
1945   }
1946   const DWARFSection &getAppleObjCSection() const override {
1947     return AppleObjCSection;
1948   }
1949   const DWARFSection &getNamesSection() const override {
1950     return NamesSection;
1951   }
1952
1953   StringRef getFileName() const override { return FileName; }
1954   uint8_t getAddressSize() const override { return AddressSize; }
1955   void forEachInfoSections(
1956       function_ref<void(const DWARFSection &)> F) const override {
1957     for (auto &P : InfoSections)
1958       F(P.second);
1959   }
1960   void forEachTypesSections(
1961       function_ref<void(const DWARFSection &)> F) const override {
1962     for (auto &P : TypesSections)
1963       F(P.second);
1964   }
1965 };
1966 } // namespace
1967
1968 std::unique_ptr<DWARFContext>
1969 DWARFContext::create(const object::ObjectFile &Obj,
1970                      ProcessDebugRelocations RelocAction,
1971                      const LoadedObjectInfo *L, std::string DWPName,
1972                      std::function<void(Error)> RecoverableErrorHandler,
1973                      std::function<void(Error)> WarningHandler) {
1974   auto DObj = std::make_unique<DWARFObjInMemory>(
1975       Obj, L, RecoverableErrorHandler, WarningHandler, RelocAction);
1976   return std::make_unique<DWARFContext>(std::move(DObj), std::move(DWPName),
1977                                         RecoverableErrorHandler,
1978                                         WarningHandler);
1979 }
1980
1981 std::unique_ptr<DWARFContext>
1982 DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
1983                      uint8_t AddrSize, bool isLittleEndian,
1984                      std::function<void(Error)> RecoverableErrorHandler,
1985                      std::function<void(Error)> WarningHandler) {
1986   auto DObj =
1987       std::make_unique<DWARFObjInMemory>(Sections, AddrSize, isLittleEndian);
1988   return std::make_unique<DWARFContext>(
1989       std::move(DObj), "", RecoverableErrorHandler, WarningHandler);
1990 }
1991
1992 Error DWARFContext::loadRegisterInfo(const object::ObjectFile &Obj) {
1993   // Detect the architecture from the object file. We usually don't need OS
1994   // info to lookup a target and create register info.
1995   Triple TT;
1996   TT.setArch(Triple::ArchType(Obj.getArch()));
1997   TT.setVendor(Triple::UnknownVendor);
1998   TT.setOS(Triple::UnknownOS);
1999   std::string TargetLookupError;
2000   const Target *TheTarget =
2001       TargetRegistry::lookupTarget(TT.str(), TargetLookupError);
2002   if (!TargetLookupError.empty())
2003     return createStringError(errc::invalid_argument,
2004                              TargetLookupError.c_str());
2005   RegInfo.reset(TheTarget->createMCRegInfo(TT.str()));
2006   return Error::success();
2007 }
2008
2009 uint8_t DWARFContext::getCUAddrSize() {
2010   // In theory, different compile units may have different address byte
2011   // sizes, but for simplicity we just use the address byte size of the
2012   // first compile unit. In practice the address size field is repeated across
2013   // various DWARF headers (at least in version 5) to make it easier to dump
2014   // them independently, not to enable varying the address size.
2015   auto CUs = compile_units();
2016   return CUs.empty() ? 0 : (*CUs.begin())->getAddressByteSize();
2017 }