Home | History | Annotate | Download | only in DWARF 
      1 //===- DWARFContext.cpp ---------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
     11 #include "llvm/ADT/STLExtras.h"
     12 #include "llvm/ADT/SmallString.h"
     13 #include "llvm/ADT/SmallVector.h"
     14 #include "llvm/ADT/StringRef.h"
     15 #include "llvm/ADT/StringSwitch.h"
     16 #include "llvm/BinaryFormat/Dwarf.h"
     17 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
     18 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
     19 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
     20 #include "llvm/DebugInfo/DWARF/DWARFDebugAddr.h"
     21 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
     22 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
     23 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
     24 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
     25 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
     26 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
     27 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
     28 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
     29 #include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
     30 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
     31 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
     32 #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
     33 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
     34 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
     35 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
     36 #include "llvm/MC/MCRegisterInfo.h"
     37 #include "llvm/Object/Decompressor.h"
     38 #include "llvm/Object/MachO.h"
     39 #include "llvm/Object/ObjectFile.h"
     40 #include "llvm/Object/RelocVisitor.h"
     41 #include "llvm/Support/Casting.h"
     42 #include "llvm/Support/DataExtractor.h"
     43 #include "llvm/Support/Error.h"
     44 #include "llvm/Support/Format.h"
     45 #include "llvm/Support/MemoryBuffer.h"
     46 #include "llvm/Support/Path.h"
     47 #include "llvm/Support/TargetRegistry.h"
     48 #include "llvm/Support/WithColor.h"
     49 #include "llvm/Support/raw_ostream.h"
     50 #include <algorithm>
     51 #include <cstdint>
     52 #include <deque>
     53 #include <map>
     54 #include <string>
     55 #include <utility>
     56 #include <vector>
     57 
     58 using namespace llvm;
     59 using namespace dwarf;
     60 using namespace object;
     61 
     62 #define DEBUG_TYPE "dwarf"
     63 
     64 using DWARFLineTable = DWARFDebugLine::LineTable;
     65 using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind;
     66 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
     67 
     68 DWARFContext::DWARFContext(std::unique_ptr<const DWARFObject> DObj,
     69                            std::string DWPName)
     70     : DIContext(CK_DWARF), DWPName(std::move(DWPName)), DObj(std::move(DObj)) {}
     71 
     72 DWARFContext::~DWARFContext() = default;
     73 
     74 /// Dump the UUID load command.
     75 static void dumpUUID(raw_ostream &OS, const ObjectFile &Obj) {
     76   auto *MachO = dyn_cast<MachOObjectFile>(&Obj);
     77   if (!MachO)
     78     return;
     79   for (auto LC : MachO->load_commands()) {
     80     raw_ostream::uuid_t UUID;
     81     if (LC.C.cmd == MachO::LC_UUID) {
     82       if (LC.C.cmdsize < sizeof(UUID) + sizeof(LC.C)) {
     83         OS << "error: UUID load command is too short.\n";
     84         return;
     85       }
     86       OS << "UUID: ";
     87       memcpy(&UUID, LC.Ptr+sizeof(LC.C), sizeof(UUID));
     88       OS.write_uuid(UUID);
     89       Triple T = MachO->getArchTriple();
     90       OS << " (" << T.getArchName() << ')';
     91       OS << ' ' << MachO->getFileName() << '\n';
     92     }
     93   }
     94 }
     95 
     96 using ContributionCollection =
     97     std::vector<Optional<StrOffsetsContributionDescriptor>>;
     98 
     99 // Collect all the contributions to the string offsets table from all units,
    100 // sort them by their starting offsets and remove duplicates.
    101 static ContributionCollection
    102 collectContributionData(DWARFContext::cu_iterator_range CUs,
    103                         DWARFContext::tu_section_iterator_range TUSs) {
    104   ContributionCollection Contributions;
    105   for (const auto &CU : CUs)
    106     Contributions.push_back(CU->getStringOffsetsTableContribution());
    107   for (const auto &TUS : TUSs)
    108     for (const auto &TU : TUS)
    109       Contributions.push_back(TU->getStringOffsetsTableContribution());
    110 
    111   // Sort the contributions so that any invalid ones are placed at
    112   // the start of the contributions vector. This way they are reported
    113   // first.
    114   llvm::sort(Contributions.begin(), Contributions.end(),
    115              [](const Optional<StrOffsetsContributionDescriptor> &L,
    116                 const Optional<StrOffsetsContributionDescriptor> &R) {
    117                if (L && R) 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 static void dumpDWARFv5StringOffsetsSection(
    137     raw_ostream &OS, StringRef SectionName, const DWARFObject &Obj,
    138     const DWARFSection &StringOffsetsSection, StringRef StringSection,
    139     DWARFContext::cu_iterator_range CUs,
    140     DWARFContext::tu_section_iterator_range TUSs, bool LittleEndian) {
    141   auto Contributions = collectContributionData(CUs, TUSs);
    142   DWARFDataExtractor StrOffsetExt(Obj, StringOffsetsSection, LittleEndian, 0);
    143   DataExtractor StrData(StringSection, LittleEndian, 0);
    144   uint64_t SectionSize = StringOffsetsSection.Data.size();
    145   uint32_t Offset = 0;
    146   for (auto &Contribution : Contributions) {
    147     // Report an ill-formed contribution.
    148     if (!Contribution) {
    149       OS << "error: invalid contribution to string offsets table in section ."
    150          << SectionName << ".\n";
    151       return;
    152     }
    153 
    154     dwarf::DwarfFormat Format = Contribution->getFormat();
    155     uint16_t Version = Contribution->getVersion();
    156     uint64_t ContributionHeader = Contribution->Base;
    157     // In DWARF v5 there is a contribution header that immediately precedes
    158     // the string offsets base (the location we have previously retrieved from
    159     // the CU DIE's DW_AT_str_offsets attribute). The header is located either
    160     // 8 or 16 bytes before the base, depending on the contribution's format.
    161     if (Version >= 5)
    162       ContributionHeader -= Format == DWARF32 ? 8 : 16;
    163 
    164     // Detect overlapping contributions.
    165     if (Offset > ContributionHeader) {
    166       OS << "error: overlapping contributions to string offsets table in "
    167             "section ."
    168          << SectionName << ".\n";
    169       return;
    170     }
    171     // Report a gap in the table.
    172     if (Offset < ContributionHeader) {
    173       OS << format("0x%8.8x: Gap, length = ", Offset);
    174       OS << (ContributionHeader - Offset) << "\n";
    175     }
    176     OS << format("0x%8.8x: ", (uint32_t)ContributionHeader);
    177     // In DWARF v5 the contribution size in the descriptor does not equal
    178     // the originally encoded length (it does not contain the length of the
    179     // version field and the padding, a total of 4 bytes). Add them back in
    180     // for reporting.
    181     OS << "Contribution size = " << (Contribution->Size + (Version < 5 ? 0 : 4))
    182        << ", Format = " << (Format == DWARF32 ? "DWARF32" : "DWARF64")
    183        << ", Version = " << Version << "\n";
    184 
    185     Offset = Contribution->Base;
    186     unsigned EntrySize = Contribution->getDwarfOffsetByteSize();
    187     while (Offset - Contribution->Base < Contribution->Size) {
    188       OS << format("0x%8.8x: ", Offset);
    189       // FIXME: We can only extract strings if the offset fits in 32 bits.
    190       uint64_t StringOffset =
    191           StrOffsetExt.getRelocatedValue(EntrySize, &Offset);
    192       // Extract the string if we can and display it. Otherwise just report
    193       // the offset.
    194       if (StringOffset <= std::numeric_limits<uint32_t>::max()) {
    195         uint32_t StringOffset32 = (uint32_t)StringOffset;
    196         OS << format("%8.8x ", StringOffset32);
    197         const char *S = StrData.getCStr(&StringOffset32);
    198         if (S)
    199           OS << format("\"%s\"", S);
    200       } else
    201         OS << format("%16.16" PRIx64 " ", StringOffset);
    202       OS << "\n";
    203     }
    204   }
    205   // Report a gap at the end of the table.
    206   if (Offset < SectionSize) {
    207     OS << format("0x%8.8x: Gap, length = ", Offset);
    208     OS << (SectionSize - Offset) << "\n";
    209   }
    210 }
    211 
    212 // Dump a DWARF string offsets section. This may be a DWARF v5 formatted
    213 // string offsets section, where each compile or type unit contributes a
    214 // number of entries (string offsets), with each contribution preceded by
    215 // a header containing size and version number. Alternatively, it may be a
    216 // monolithic series of string offsets, as generated by the pre-DWARF v5
    217 // implementation of split DWARF.
    218 static void dumpStringOffsetsSection(
    219     raw_ostream &OS, StringRef SectionName, const DWARFObject &Obj,
    220     const DWARFSection &StringOffsetsSection, StringRef StringSection,
    221     DWARFContext::cu_iterator_range CUs,
    222     DWARFContext::tu_section_iterator_range TUSs, bool LittleEndian,
    223     unsigned MaxVersion) {
    224   // If we have at least one (compile or type) unit with DWARF v5 or greater,
    225   // we assume that the section is formatted like a DWARF v5 string offsets
    226   // section.
    227   if (MaxVersion >= 5)
    228     dumpDWARFv5StringOffsetsSection(OS, SectionName, Obj, StringOffsetsSection,
    229                                     StringSection, CUs, TUSs, LittleEndian);
    230   else {
    231     DataExtractor strOffsetExt(StringOffsetsSection.Data, LittleEndian, 0);
    232     uint32_t offset = 0;
    233     uint64_t size = StringOffsetsSection.Data.size();
    234     // Ensure that size is a multiple of the size of an entry.
    235     if (size & ((uint64_t)(sizeof(uint32_t) - 1))) {
    236       OS << "error: size of ." << SectionName << " is not a multiple of "
    237          << sizeof(uint32_t) << ".\n";
    238       size &= -(uint64_t)sizeof(uint32_t);
    239     }
    240     DataExtractor StrData(StringSection, LittleEndian, 0);
    241     while (offset < size) {
    242       OS << format("0x%8.8x: ", offset);
    243       uint32_t StringOffset = strOffsetExt.getU32(&offset);
    244       OS << format("%8.8x  ", StringOffset);
    245       const char *S = StrData.getCStr(&StringOffset);
    246       if (S)
    247         OS << format("\"%s\"", S);
    248       OS << "\n";
    249     }
    250   }
    251 }
    252 
    253 // Dump the .debug_addr section.
    254 static void dumpAddrSection(raw_ostream &OS, DWARFDataExtractor &AddrData,
    255                             DIDumpOptions DumpOpts, uint16_t Version,
    256                             uint8_t AddrSize) {
    257   // TODO: Make this more general: add callback types to Error.h, create
    258   // implementation and make all DWARF classes use them.
    259   static auto WarnCallback = [](Error Warn) {
    260     handleAllErrors(std::move(Warn), [](ErrorInfoBase &Info) {
    261       WithColor::warning() << Info.message() << '\n';
    262     });
    263   };
    264   uint32_t Offset = 0;
    265   while (AddrData.isValidOffset(Offset)) {
    266     DWARFDebugAddrTable AddrTable;
    267     uint32_t TableOffset = Offset;
    268     if (Error Err = AddrTable.extract(AddrData, &Offset, Version,
    269                                       AddrSize, WarnCallback)) {
    270       WithColor::error() << toString(std::move(Err)) << '\n';
    271       // Keep going after an error, if we can, assuming that the length field
    272       // could be read. If it couldn't, stop reading the section.
    273       if (!AddrTable.hasValidLength())
    274         break;
    275       uint64_t Length = AddrTable.getLength();
    276       Offset = TableOffset + Length;
    277     } else {
    278       AddrTable.dump(OS, DumpOpts);
    279     }
    280   }
    281 }
    282 
    283 // Dump the .debug_rnglists or .debug_rnglists.dwo section (DWARF v5).
    284 static void dumpRnglistsSection(raw_ostream &OS,
    285                                 DWARFDataExtractor &rnglistData,
    286                                 DIDumpOptions DumpOpts) {
    287   uint32_t Offset = 0;
    288   while (rnglistData.isValidOffset(Offset)) {
    289     llvm::DWARFDebugRnglistTable Rnglists;
    290     uint32_t TableOffset = Offset;
    291     if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
    292       WithColor::error() << toString(std::move(Err)) << '\n';
    293       uint64_t Length = Rnglists.length();
    294       // Keep going after an error, if we can, assuming that the length field
    295       // could be read. If it couldn't, stop reading the section.
    296       if (Length == 0)
    297         break;
    298       Offset = TableOffset + Length;
    299     } else {
    300       Rnglists.dump(OS, DumpOpts);
    301     }
    302   }
    303 }
    304 
    305 void DWARFContext::dump(
    306     raw_ostream &OS, DIDumpOptions DumpOpts,
    307     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
    308 
    309   Optional<uint64_t> DumpOffset;
    310   uint64_t DumpType = DumpOpts.DumpType;
    311 
    312   StringRef Extension = sys::path::extension(DObj->getFileName());
    313   bool IsDWO = (Extension == ".dwo") || (Extension == ".dwp");
    314 
    315   // Print UUID header.
    316   const auto *ObjFile = DObj->getFile();
    317   if (DumpType & DIDT_UUID)
    318     dumpUUID(OS, *ObjFile);
    319 
    320   // Print a header for each explicitly-requested section.
    321   // Otherwise just print one for non-empty sections.
    322   // Only print empty .dwo section headers when dumping a .dwo file.
    323   bool Explicit = DumpType != DIDT_All && !IsDWO;
    324   bool ExplicitDWO = Explicit && IsDWO;
    325   auto shouldDump = [&](bool Explicit, const char *Name, unsigned ID,
    326                         StringRef Section) {
    327     DumpOffset = DumpOffsets[ID];
    328     unsigned Mask = 1U << ID;
    329     bool Should = (DumpType & Mask) && (Explicit || !Section.empty());
    330     if (Should)
    331       OS << "\n" << Name << " contents:\n";
    332     return Should;
    333   };
    334 
    335   // Dump individual sections.
    336   if (shouldDump(Explicit, ".debug_abbrev", DIDT_ID_DebugAbbrev,
    337                  DObj->getAbbrevSection()))
    338     getDebugAbbrev()->dump(OS);
    339   if (shouldDump(ExplicitDWO, ".debug_abbrev.dwo", DIDT_ID_DebugAbbrev,
    340                  DObj->getAbbrevDWOSection()))
    341     getDebugAbbrevDWO()->dump(OS);
    342 
    343   auto dumpDebugInfo = [&](bool IsExplicit, const char *Name,
    344                            DWARFSection Section, cu_iterator_range CUs) {
    345     if (shouldDump(IsExplicit, Name, DIDT_ID_DebugInfo, Section.Data)) {
    346       if (DumpOffset)
    347         getDIEForOffset(DumpOffset.getValue())
    348             .dump(OS, 0, DumpOpts.noImplicitRecursion());
    349       else
    350         for (const auto &CU : CUs)
    351           CU->dump(OS, DumpOpts);
    352     }
    353   };
    354   dumpDebugInfo(Explicit, ".debug_info", DObj->getInfoSection(),
    355                 compile_units());
    356   dumpDebugInfo(ExplicitDWO, ".debug_info.dwo", DObj->getInfoDWOSection(),
    357                 dwo_compile_units());
    358 
    359   auto dumpDebugType = [&](const char *Name,
    360                            tu_section_iterator_range TUSections) {
    361     OS << '\n' << Name << " contents:\n";
    362     DumpOffset = DumpOffsets[DIDT_ID_DebugTypes];
    363     for (const auto &TUS : TUSections)
    364       for (const auto &TU : TUS)
    365         if (DumpOffset)
    366           TU->getDIEForOffset(*DumpOffset)
    367               .dump(OS, 0, DumpOpts.noImplicitRecursion());
    368         else
    369           TU->dump(OS, DumpOpts);
    370   };
    371   if ((DumpType & DIDT_DebugTypes)) {
    372     if (Explicit || getNumTypeUnits())
    373       dumpDebugType(".debug_types", type_unit_sections());
    374     if (ExplicitDWO || getNumDWOTypeUnits())
    375       dumpDebugType(".debug_types.dwo", dwo_type_unit_sections());
    376   }
    377 
    378   if (shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
    379                  DObj->getLocSection().Data)) {
    380     getDebugLoc()->dump(OS, getRegisterInfo(), DumpOffset);
    381   }
    382   if (shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
    383                  DObj->getLocDWOSection().Data)) {
    384     getDebugLocDWO()->dump(OS, getRegisterInfo(), DumpOffset);
    385   }
    386 
    387   if (shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
    388                  DObj->getDebugFrameSection()))
    389     getDebugFrame()->dump(OS, getRegisterInfo(), DumpOffset);
    390 
    391   if (shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,
    392                  DObj->getEHFrameSection()))
    393     getEHFrame()->dump(OS, getRegisterInfo(), DumpOffset);
    394 
    395   if (DumpType & DIDT_DebugMacro) {
    396     if (Explicit || !getDebugMacro()->empty()) {
    397       OS << "\n.debug_macinfo contents:\n";
    398       getDebugMacro()->dump(OS);
    399     }
    400   }
    401 
    402   if (shouldDump(Explicit, ".debug_aranges", DIDT_ID_DebugAranges,
    403                  DObj->getARangeSection())) {
    404     uint32_t offset = 0;
    405     DataExtractor arangesData(DObj->getARangeSection(), isLittleEndian(), 0);
    406     DWARFDebugArangeSet set;
    407     while (set.extract(arangesData, &offset))
    408       set.dump(OS);
    409   }
    410 
    411   auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser,
    412                              DIDumpOptions DumpOpts) {
    413     while (!Parser.done()) {
    414       if (DumpOffset && Parser.getOffset() != *DumpOffset) {
    415         Parser.skip();
    416         continue;
    417       }
    418       OS << "debug_line[" << format("0x%8.8x", Parser.getOffset()) << "]\n";
    419       if (DumpOpts.Verbose) {
    420         Parser.parseNext(DWARFDebugLine::warn, DWARFDebugLine::warn, &OS);
    421       } else {
    422         DWARFDebugLine::LineTable LineTable = Parser.parseNext();
    423         LineTable.dump(OS, DumpOpts);
    424       }
    425     }
    426   };
    427 
    428   if (shouldDump(Explicit, ".debug_line", DIDT_ID_DebugLine,
    429                  DObj->getLineSection().Data)) {
    430     DWARFDataExtractor LineData(*DObj, DObj->getLineSection(), isLittleEndian(),
    431                                 0);
    432     DWARFDebugLine::SectionParser Parser(LineData, *this, compile_units(),
    433                                          type_unit_sections());
    434     DumpLineSection(Parser, DumpOpts);
    435   }
    436 
    437   if (shouldDump(ExplicitDWO, ".debug_line.dwo", DIDT_ID_DebugLine,
    438                  DObj->getLineDWOSection().Data)) {
    439     DWARFDataExtractor LineData(*DObj, DObj->getLineDWOSection(),
    440                                 isLittleEndian(), 0);
    441     DWARFDebugLine::SectionParser Parser(LineData, *this, dwo_compile_units(),
    442                                          dwo_type_unit_sections());
    443     DumpLineSection(Parser, DumpOpts);
    444   }
    445 
    446   if (shouldDump(Explicit, ".debug_cu_index", DIDT_ID_DebugCUIndex,
    447                  DObj->getCUIndexSection())) {
    448     getCUIndex().dump(OS);
    449   }
    450 
    451   if (shouldDump(Explicit, ".debug_tu_index", DIDT_ID_DebugTUIndex,
    452                  DObj->getTUIndexSection())) {
    453     getTUIndex().dump(OS);
    454   }
    455 
    456   if (shouldDump(Explicit, ".debug_str", DIDT_ID_DebugStr,
    457                  DObj->getStringSection())) {
    458     DataExtractor strData(DObj->getStringSection(), isLittleEndian(), 0);
    459     uint32_t offset = 0;
    460     uint32_t strOffset = 0;
    461     while (const char *s = strData.getCStr(&offset)) {
    462       OS << format("0x%8.8x: \"%s\"\n", strOffset, s);
    463       strOffset = offset;
    464     }
    465   }
    466   if (shouldDump(ExplicitDWO, ".debug_str.dwo", DIDT_ID_DebugStr,
    467                  DObj->getStringDWOSection())) {
    468     DataExtractor strDWOData(DObj->getStringDWOSection(), isLittleEndian(), 0);
    469     uint32_t offset = 0;
    470     uint32_t strDWOOffset = 0;
    471     while (const char *s = strDWOData.getCStr(&offset)) {
    472       OS << format("0x%8.8x: \"%s\"\n", strDWOOffset, s);
    473       strDWOOffset = offset;
    474     }
    475   }
    476   if (shouldDump(Explicit, ".debug_line_str", DIDT_ID_DebugLineStr,
    477                  DObj->getLineStringSection())) {
    478     DataExtractor strData(DObj->getLineStringSection(), isLittleEndian(), 0);
    479     uint32_t offset = 0;
    480     uint32_t strOffset = 0;
    481     while (const char *s = strData.getCStr(&offset)) {
    482       OS << format("0x%8.8x: \"", strOffset);
    483       OS.write_escaped(s);
    484       OS << "\"\n";
    485       strOffset = offset;
    486     }
    487   }
    488 
    489   if (shouldDump(Explicit, ".debug_addr", DIDT_ID_DebugAddr,
    490                  DObj->getAddrSection().Data)) {
    491     DWARFDataExtractor AddrData(*DObj, DObj->getAddrSection(),
    492                                    isLittleEndian(), 0);
    493     dumpAddrSection(OS, AddrData, DumpOpts, getMaxVersion(), getCUAddrSize());
    494   }
    495 
    496   if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges,
    497                  DObj->getRangeSection().Data)) {
    498     uint8_t savedAddressByteSize = getCUAddrSize();
    499     DWARFDataExtractor rangesData(*DObj, DObj->getRangeSection(),
    500                                   isLittleEndian(), savedAddressByteSize);
    501     uint32_t offset = 0;
    502     DWARFDebugRangeList rangeList;
    503     while (rangesData.isValidOffset(offset)) {
    504       if (Error E = rangeList.extract(rangesData, &offset)) {
    505         WithColor::error() << toString(std::move(E)) << '\n';
    506         break;
    507       }
    508       rangeList.dump(OS);
    509     }
    510   }
    511 
    512   if (shouldDump(Explicit, ".debug_rnglists", DIDT_ID_DebugRnglists,
    513                  DObj->getRnglistsSection().Data)) {
    514     DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsSection(),
    515                                    isLittleEndian(), 0);
    516     dumpRnglistsSection(OS, RnglistData, DumpOpts);
    517   }
    518 
    519   if (shouldDump(ExplicitDWO, ".debug_rnglists.dwo", DIDT_ID_DebugRnglists,
    520                  DObj->getRnglistsDWOSection().Data)) {
    521     DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsDWOSection(),
    522                                    isLittleEndian(), 0);
    523     dumpRnglistsSection(OS, RnglistData, DumpOpts);
    524   }
    525 
    526   if (shouldDump(Explicit, ".debug_pubnames", DIDT_ID_DebugPubnames,
    527                  DObj->getPubNamesSection()))
    528     DWARFDebugPubTable(DObj->getPubNamesSection(), isLittleEndian(), false)
    529         .dump(OS);
    530 
    531   if (shouldDump(Explicit, ".debug_pubtypes", DIDT_ID_DebugPubtypes,
    532                  DObj->getPubTypesSection()))
    533     DWARFDebugPubTable(DObj->getPubTypesSection(), isLittleEndian(), false)
    534         .dump(OS);
    535 
    536   if (shouldDump(Explicit, ".debug_gnu_pubnames", DIDT_ID_DebugGnuPubnames,
    537                  DObj->getGnuPubNamesSection()))
    538     DWARFDebugPubTable(DObj->getGnuPubNamesSection(), isLittleEndian(),
    539                        true /* GnuStyle */)
    540         .dump(OS);
    541 
    542   if (shouldDump(Explicit, ".debug_gnu_pubtypes", DIDT_ID_DebugGnuPubtypes,
    543                  DObj->getGnuPubTypesSection()))
    544     DWARFDebugPubTable(DObj->getGnuPubTypesSection(), isLittleEndian(),
    545                        true /* GnuStyle */)
    546         .dump(OS);
    547 
    548   if (shouldDump(Explicit, ".debug_str_offsets", DIDT_ID_DebugStrOffsets,
    549                  DObj->getStringOffsetSection().Data))
    550     dumpStringOffsetsSection(
    551         OS, "debug_str_offsets", *DObj, DObj->getStringOffsetSection(),
    552         DObj->getStringSection(), compile_units(), type_unit_sections(),
    553         isLittleEndian(), getMaxVersion());
    554   if (shouldDump(ExplicitDWO, ".debug_str_offsets.dwo", DIDT_ID_DebugStrOffsets,
    555                  DObj->getStringOffsetDWOSection().Data))
    556     dumpStringOffsetsSection(
    557         OS, "debug_str_offsets.dwo", *DObj, DObj->getStringOffsetDWOSection(),
    558         DObj->getStringDWOSection(), dwo_compile_units(),
    559         dwo_type_unit_sections(), isLittleEndian(), getMaxVersion());
    560 
    561   if (shouldDump(Explicit, ".gnu_index", DIDT_ID_GdbIndex,
    562                  DObj->getGdbIndexSection())) {
    563     getGdbIndex().dump(OS);
    564   }
    565 
    566   if (shouldDump(Explicit, ".apple_names", DIDT_ID_AppleNames,
    567                  DObj->getAppleNamesSection().Data))
    568     getAppleNames().dump(OS);
    569 
    570   if (shouldDump(Explicit, ".apple_types", DIDT_ID_AppleTypes,
    571                  DObj->getAppleTypesSection().Data))
    572     getAppleTypes().dump(OS);
    573 
    574   if (shouldDump(Explicit, ".apple_namespaces", DIDT_ID_AppleNamespaces,
    575                  DObj->getAppleNamespacesSection().Data))
    576     getAppleNamespaces().dump(OS);
    577 
    578   if (shouldDump(Explicit, ".apple_objc", DIDT_ID_AppleObjC,
    579                  DObj->getAppleObjCSection().Data))
    580     getAppleObjC().dump(OS);
    581   if (shouldDump(Explicit, ".debug_names", DIDT_ID_DebugNames,
    582                  DObj->getDebugNamesSection().Data))
    583     getDebugNames().dump(OS);
    584 }
    585 
    586 DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) {
    587   DWOCUs.parseDWO(*this, DObj->getInfoDWOSection(), true);
    588 
    589   if (const auto &CUI = getCUIndex()) {
    590     if (const auto *R = CUI.getFromHash(Hash))
    591       return DWOCUs.getUnitForIndexEntry(*R);
    592     return nullptr;
    593   }
    594 
    595   // If there's no index, just search through the CUs in the DWO - there's
    596   // probably only one unless this is something like LTO - though an in-process
    597   // built/cached lookup table could be used in that case to improve repeated
    598   // lookups of different CUs in the DWO.
    599   for (const auto &DWOCU : dwo_compile_units()) {
    600     // Might not have parsed DWO ID yet.
    601     if (!DWOCU->getDWOId()) {
    602       if (Optional<uint64_t> DWOId =
    603           toUnsigned(DWOCU->getUnitDIE().find(DW_AT_GNU_dwo_id)))
    604         DWOCU->setDWOId(*DWOId);
    605       else
    606         // No DWO ID?
    607         continue;
    608     }
    609     if (DWOCU->getDWOId() == Hash)
    610       return DWOCU.get();
    611   }
    612   return nullptr;
    613 }
    614 
    615 DWARFDie DWARFContext::getDIEForOffset(uint32_t Offset) {
    616   parseCompileUnits();
    617   if (auto *CU = CUs.getUnitForOffset(Offset))
    618     return CU->getDIEForOffset(Offset);
    619   return DWARFDie();
    620 }
    621 
    622 bool DWARFContext::verify(raw_ostream &OS, DIDumpOptions DumpOpts) {
    623   bool Success = true;
    624   DWARFVerifier verifier(OS, *this, DumpOpts);
    625 
    626   Success &= verifier.handleDebugAbbrev();
    627   if (DumpOpts.DumpType & DIDT_DebugInfo)
    628     Success &= verifier.handleDebugInfo();
    629   if (DumpOpts.DumpType & DIDT_DebugLine)
    630     Success &= verifier.handleDebugLine();
    631   Success &= verifier.handleAccelTables();
    632   return Success;
    633 }
    634 
    635 const DWARFUnitIndex &DWARFContext::getCUIndex() {
    636   if (CUIndex)
    637     return *CUIndex;
    638 
    639   DataExtractor CUIndexData(DObj->getCUIndexSection(), isLittleEndian(), 0);
    640 
    641   CUIndex = llvm::make_unique<DWARFUnitIndex>(DW_SECT_INFO);
    642   CUIndex->parse(CUIndexData);
    643   return *CUIndex;
    644 }
    645 
    646 const DWARFUnitIndex &DWARFContext::getTUIndex() {
    647   if (TUIndex)
    648     return *TUIndex;
    649 
    650   DataExtractor TUIndexData(DObj->getTUIndexSection(), isLittleEndian(), 0);
    651 
    652   TUIndex = llvm::make_unique<DWARFUnitIndex>(DW_SECT_TYPES);
    653   TUIndex->parse(TUIndexData);
    654   return *TUIndex;
    655 }
    656 
    657 DWARFGdbIndex &DWARFContext::getGdbIndex() {
    658   if (GdbIndex)
    659     return *GdbIndex;
    660 
    661   DataExtractor GdbIndexData(DObj->getGdbIndexSection(), true /*LE*/, 0);
    662   GdbIndex = llvm::make_unique<DWARFGdbIndex>();
    663   GdbIndex->parse(GdbIndexData);
    664   return *GdbIndex;
    665 }
    666 
    667 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
    668   if (Abbrev)
    669     return Abbrev.get();
    670 
    671   DataExtractor abbrData(DObj->getAbbrevSection(), isLittleEndian(), 0);
    672 
    673   Abbrev.reset(new DWARFDebugAbbrev());
    674   Abbrev->extract(abbrData);
    675   return Abbrev.get();
    676 }
    677 
    678 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() {
    679   if (AbbrevDWO)
    680     return AbbrevDWO.get();
    681 
    682   DataExtractor abbrData(DObj->getAbbrevDWOSection(), isLittleEndian(), 0);
    683   AbbrevDWO.reset(new DWARFDebugAbbrev());
    684   AbbrevDWO->extract(abbrData);
    685   return AbbrevDWO.get();
    686 }
    687 
    688 const DWARFDebugLoc *DWARFContext::getDebugLoc() {
    689   if (Loc)
    690     return Loc.get();
    691 
    692   Loc.reset(new DWARFDebugLoc);
    693   // Assume all compile units have the same address byte size.
    694   if (getNumCompileUnits()) {
    695     DWARFDataExtractor LocData(*DObj, DObj->getLocSection(), isLittleEndian(),
    696                                getCompileUnitAtIndex(0)->getAddressByteSize());
    697     Loc->parse(LocData);
    698   }
    699   return Loc.get();
    700 }
    701 
    702 const DWARFDebugLocDWO *DWARFContext::getDebugLocDWO() {
    703   if (LocDWO)
    704     return LocDWO.get();
    705 
    706   LocDWO.reset(new DWARFDebugLocDWO());
    707   // Assume all compile units have the same address byte size.
    708   if (getNumCompileUnits()) {
    709     DataExtractor LocData(DObj->getLocDWOSection().Data, isLittleEndian(),
    710                           getCompileUnitAtIndex(0)->getAddressByteSize());
    711     LocDWO->parse(LocData);
    712   }
    713   return LocDWO.get();
    714 }
    715 
    716 const DWARFDebugAranges *DWARFContext::getDebugAranges() {
    717   if (Aranges)
    718     return Aranges.get();
    719 
    720   Aranges.reset(new DWARFDebugAranges());
    721   Aranges->generate(this);
    722   return Aranges.get();
    723 }
    724 
    725 const DWARFDebugFrame *DWARFContext::getDebugFrame() {
    726   if (DebugFrame)
    727     return DebugFrame.get();
    728 
    729   // There's a "bug" in the DWARFv3 standard with respect to the target address
    730   // size within debug frame sections. While DWARF is supposed to be independent
    731   // of its container, FDEs have fields with size being "target address size",
    732   // which isn't specified in DWARF in general. It's only specified for CUs, but
    733   // .eh_frame can appear without a .debug_info section. Follow the example of
    734   // other tools (libdwarf) and extract this from the container (ObjectFile
    735   // provides this information). This problem is fixed in DWARFv4
    736   // See this dwarf-discuss discussion for more details:
    737   // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
    738   DWARFDataExtractor debugFrameData(DObj->getDebugFrameSection(),
    739                                     isLittleEndian(), DObj->getAddressSize());
    740   DebugFrame.reset(new DWARFDebugFrame(false /* IsEH */));
    741   DebugFrame->parse(debugFrameData);
    742   return DebugFrame.get();
    743 }
    744 
    745 const DWARFDebugFrame *DWARFContext::getEHFrame() {
    746   if (EHFrame)
    747     return EHFrame.get();
    748 
    749   DWARFDataExtractor debugFrameData(DObj->getEHFrameSection(), isLittleEndian(),
    750                                     DObj->getAddressSize());
    751   DebugFrame.reset(new DWARFDebugFrame(true /* IsEH */));
    752   DebugFrame->parse(debugFrameData);
    753   return DebugFrame.get();
    754 }
    755 
    756 const DWARFDebugMacro *DWARFContext::getDebugMacro() {
    757   if (Macro)
    758     return Macro.get();
    759 
    760   DataExtractor MacinfoData(DObj->getMacinfoSection(), isLittleEndian(), 0);
    761   Macro.reset(new DWARFDebugMacro());
    762   Macro->parse(MacinfoData);
    763   return Macro.get();
    764 }
    765 
    766 template <typename T>
    767 static T &getAccelTable(std::unique_ptr<T> &Cache, const DWARFObject &Obj,
    768                         const DWARFSection &Section, StringRef StringSection,
    769                         bool IsLittleEndian) {
    770   if (Cache)
    771     return *Cache;
    772   DWARFDataExtractor AccelSection(Obj, Section, IsLittleEndian, 0);
    773   DataExtractor StrData(StringSection, IsLittleEndian, 0);
    774   Cache.reset(new T(AccelSection, StrData));
    775   if (Error E = Cache->extract())
    776     llvm::consumeError(std::move(E));
    777   return *Cache;
    778 }
    779 
    780 const DWARFDebugNames &DWARFContext::getDebugNames() {
    781   return getAccelTable(Names, *DObj, DObj->getDebugNamesSection(),
    782                        DObj->getStringSection(), isLittleEndian());
    783 }
    784 
    785 const AppleAcceleratorTable &DWARFContext::getAppleNames() {
    786   return getAccelTable(AppleNames, *DObj, DObj->getAppleNamesSection(),
    787                        DObj->getStringSection(), isLittleEndian());
    788 }
    789 
    790 const AppleAcceleratorTable &DWARFContext::getAppleTypes() {
    791   return getAccelTable(AppleTypes, *DObj, DObj->getAppleTypesSection(),
    792                        DObj->getStringSection(), isLittleEndian());
    793 }
    794 
    795 const AppleAcceleratorTable &DWARFContext::getAppleNamespaces() {
    796   return getAccelTable(AppleNamespaces, *DObj,
    797                        DObj->getAppleNamespacesSection(),
    798                        DObj->getStringSection(), isLittleEndian());
    799 }
    800 
    801 const AppleAcceleratorTable &DWARFContext::getAppleObjC() {
    802   return getAccelTable(AppleObjC, *DObj, DObj->getAppleObjCSection(),
    803                        DObj->getStringSection(), isLittleEndian());
    804 }
    805 
    806 const DWARFDebugLine::LineTable *
    807 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
    808   Expected<const DWARFDebugLine::LineTable *> ExpectedLineTable =
    809       getLineTableForUnit(U, DWARFDebugLine::warn);
    810   if (!ExpectedLineTable) {
    811     DWARFDebugLine::warn(ExpectedLineTable.takeError());
    812     return nullptr;
    813   }
    814   return *ExpectedLineTable;
    815 }
    816 
    817 Expected<const DWARFDebugLine::LineTable *> DWARFContext::getLineTableForUnit(
    818     DWARFUnit *U, std::function<void(Error)> RecoverableErrorCallback) {
    819   if (!Line)
    820     Line.reset(new DWARFDebugLine);
    821 
    822   auto UnitDIE = U->getUnitDIE();
    823   if (!UnitDIE)
    824     return nullptr;
    825 
    826   auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list));
    827   if (!Offset)
    828     return nullptr; // No line table for this compile unit.
    829 
    830   uint32_t stmtOffset = *Offset + U->getLineTableOffset();
    831   // See if the line table is cached.
    832   if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
    833     return lt;
    834 
    835   // Make sure the offset is good before we try to parse.
    836   if (stmtOffset >= U->getLineSection().Data.size())
    837     return nullptr;
    838 
    839   // We have to parse it first.
    840   DWARFDataExtractor lineData(*DObj, U->getLineSection(), isLittleEndian(),
    841                               U->getAddressByteSize());
    842   return Line->getOrParseLineTable(lineData, stmtOffset, *this, U,
    843                                    RecoverableErrorCallback);
    844 }
    845 
    846 void DWARFContext::parseCompileUnits() {
    847   CUs.parse(*this, DObj->getInfoSection());
    848 }
    849 
    850 void DWARFContext::parseTypeUnits() {
    851   if (!TUs.empty())
    852     return;
    853   DObj->forEachTypesSections([&](const DWARFSection &S) {
    854     TUs.emplace_back();
    855     TUs.back().parse(*this, S);
    856   });
    857 }
    858 
    859 void DWARFContext::parseDWOCompileUnits() {
    860   DWOCUs.parseDWO(*this, DObj->getInfoDWOSection());
    861 }
    862 
    863 void DWARFContext::parseDWOTypeUnits() {
    864   if (!DWOTUs.empty())
    865     return;
    866   DObj->forEachTypesDWOSections([&](const DWARFSection &S) {
    867     DWOTUs.emplace_back();
    868     DWOTUs.back().parseDWO(*this, S);
    869   });
    870 }
    871 
    872 DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint32_t Offset) {
    873   parseCompileUnits();
    874   return CUs.getUnitForOffset(Offset);
    875 }
    876 
    877 DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
    878   // First, get the offset of the compile unit.
    879   uint32_t CUOffset = getDebugAranges()->findAddress(Address);
    880   // Retrieve the compile unit.
    881   return getCompileUnitForOffset(CUOffset);
    882 }
    883 
    884 DWARFContext::DIEsForAddress DWARFContext::getDIEsForAddress(uint64_t Address) {
    885   DIEsForAddress Result;
    886 
    887   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
    888   if (!CU)
    889     return Result;
    890 
    891   Result.CompileUnit = CU;
    892   Result.FunctionDIE = CU->getSubroutineForAddress(Address);
    893 
    894   std::vector<DWARFDie> Worklist;
    895   Worklist.push_back(Result.FunctionDIE);
    896   while (!Worklist.empty()) {
    897     DWARFDie DIE = Worklist.back();
    898     Worklist.pop_back();
    899 
    900     if (DIE.getTag() == DW_TAG_lexical_block &&
    901         DIE.addressRangeContainsAddress(Address)) {
    902       Result.BlockDIE = DIE;
    903       break;
    904     }
    905 
    906     for (auto Child : DIE)
    907       Worklist.push_back(Child);
    908   }
    909 
    910   return Result;
    911 }
    912 
    913 static bool getFunctionNameAndStartLineForAddress(DWARFCompileUnit *CU,
    914                                                   uint64_t Address,
    915                                                   FunctionNameKind Kind,
    916                                                   std::string &FunctionName,
    917                                                   uint32_t &StartLine) {
    918   // The address may correspond to instruction in some inlined function,
    919   // so we have to build the chain of inlined functions and take the
    920   // name of the topmost function in it.
    921   SmallVector<DWARFDie, 4> InlinedChain;
    922   CU->getInlinedChainForAddress(Address, InlinedChain);
    923   if (InlinedChain.empty())
    924     return false;
    925 
    926   const DWARFDie &DIE = InlinedChain[0];
    927   bool FoundResult = false;
    928   const char *Name = nullptr;
    929   if (Kind != FunctionNameKind::None && (Name = DIE.getSubroutineName(Kind))) {
    930     FunctionName = Name;
    931     FoundResult = true;
    932   }
    933   if (auto DeclLineResult = DIE.getDeclLine()) {
    934     StartLine = DeclLineResult;
    935     FoundResult = true;
    936   }
    937 
    938   return FoundResult;
    939 }
    940 
    941 DILineInfo DWARFContext::getLineInfoForAddress(uint64_t Address,
    942                                                DILineInfoSpecifier Spec) {
    943   DILineInfo Result;
    944 
    945   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
    946   if (!CU)
    947     return Result;
    948   getFunctionNameAndStartLineForAddress(CU, Address, Spec.FNKind,
    949                                         Result.FunctionName,
    950                                         Result.StartLine);
    951   if (Spec.FLIKind != FileLineInfoKind::None) {
    952     if (const DWARFLineTable *LineTable = getLineTableForUnit(CU))
    953       LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
    954                                            Spec.FLIKind, Result);
    955   }
    956   return Result;
    957 }
    958 
    959 DILineInfoTable
    960 DWARFContext::getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
    961                                          DILineInfoSpecifier Spec) {
    962   DILineInfoTable  Lines;
    963   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
    964   if (!CU)
    965     return Lines;
    966 
    967   std::string FunctionName = "<invalid>";
    968   uint32_t StartLine = 0;
    969   getFunctionNameAndStartLineForAddress(CU, Address, Spec.FNKind, FunctionName,
    970                                         StartLine);
    971 
    972   // If the Specifier says we don't need FileLineInfo, just
    973   // return the top-most function at the starting address.
    974   if (Spec.FLIKind == FileLineInfoKind::None) {
    975     DILineInfo Result;
    976     Result.FunctionName = FunctionName;
    977     Result.StartLine = StartLine;
    978     Lines.push_back(std::make_pair(Address, Result));
    979     return Lines;
    980   }
    981 
    982   const DWARFLineTable *LineTable = getLineTableForUnit(CU);
    983 
    984   // Get the index of row we're looking for in the line table.
    985   std::vector<uint32_t> RowVector;
    986   if (!LineTable->lookupAddressRange(Address, Size, RowVector))
    987     return Lines;
    988 
    989   for (uint32_t RowIndex : RowVector) {
    990     // Take file number and line/column from the row.
    991     const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
    992     DILineInfo Result;
    993     LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(),
    994                                   Spec.FLIKind, Result.FileName);
    995     Result.FunctionName = FunctionName;
    996     Result.Line = Row.Line;
    997     Result.Column = Row.Column;
    998     Result.StartLine = StartLine;
    999     Lines.push_back(std::make_pair(Row.Address, Result));
   1000   }
   1001 
   1002   return Lines;
   1003 }
   1004 
   1005 DIInliningInfo
   1006 DWARFContext::getInliningInfoForAddress(uint64_t Address,
   1007                                         DILineInfoSpecifier Spec) {
   1008   DIInliningInfo InliningInfo;
   1009 
   1010   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
   1011   if (!CU)
   1012     return InliningInfo;
   1013 
   1014   const DWARFLineTable *LineTable = nullptr;
   1015   SmallVector<DWARFDie, 4> InlinedChain;
   1016   CU->getInlinedChainForAddress(Address, InlinedChain);
   1017   if (InlinedChain.size() == 0) {
   1018     // If there is no DIE for address (e.g. it is in unavailable .dwo file),
   1019     // try to at least get file/line info from symbol table.
   1020     if (Spec.FLIKind != FileLineInfoKind::None) {
   1021       DILineInfo Frame;
   1022       LineTable = getLineTableForUnit(CU);
   1023       if (LineTable &&
   1024           LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
   1025                                                Spec.FLIKind, Frame))
   1026         InliningInfo.addFrame(Frame);
   1027     }
   1028     return InliningInfo;
   1029   }
   1030 
   1031   uint32_t CallFile = 0, CallLine = 0, CallColumn = 0, CallDiscriminator = 0;
   1032   for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) {
   1033     DWARFDie &FunctionDIE = InlinedChain[i];
   1034     DILineInfo Frame;
   1035     // Get function name if necessary.
   1036     if (const char *Name = FunctionDIE.getSubroutineName(Spec.FNKind))
   1037       Frame.FunctionName = Name;
   1038     if (auto DeclLineResult = FunctionDIE.getDeclLine())
   1039       Frame.StartLine = DeclLineResult;
   1040     if (Spec.FLIKind != FileLineInfoKind::None) {
   1041       if (i == 0) {
   1042         // For the topmost frame, initialize the line table of this
   1043         // compile unit and fetch file/line info from it.
   1044         LineTable = getLineTableForUnit(CU);
   1045         // For the topmost routine, get file/line info from line table.
   1046         if (LineTable)
   1047           LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
   1048                                                Spec.FLIKind, Frame);
   1049       } else {
   1050         // Otherwise, use call file, call line and call column from
   1051         // previous DIE in inlined chain.
   1052         if (LineTable)
   1053           LineTable->getFileNameByIndex(CallFile, CU->getCompilationDir(),
   1054                                         Spec.FLIKind, Frame.FileName);
   1055         Frame.Line = CallLine;
   1056         Frame.Column = CallColumn;
   1057         Frame.Discriminator = CallDiscriminator;
   1058       }
   1059       // Get call file/line/column of a current DIE.
   1060       if (i + 1 < n) {
   1061         FunctionDIE.getCallerFrame(CallFile, CallLine, CallColumn,
   1062                                    CallDiscriminator);
   1063       }
   1064     }
   1065     InliningInfo.addFrame(Frame);
   1066   }
   1067   return InliningInfo;
   1068 }
   1069 
   1070 std::shared_ptr<DWARFContext>
   1071 DWARFContext::getDWOContext(StringRef AbsolutePath) {
   1072   if (auto S = DWP.lock()) {
   1073     DWARFContext *Ctxt = S->Context.get();
   1074     return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
   1075   }
   1076 
   1077   std::weak_ptr<DWOFile> *Entry = &DWOFiles[AbsolutePath];
   1078 
   1079   if (auto S = Entry->lock()) {
   1080     DWARFContext *Ctxt = S->Context.get();
   1081     return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
   1082   }
   1083 
   1084   Expected<OwningBinary<ObjectFile>> Obj = [&] {
   1085     if (!CheckedForDWP) {
   1086       SmallString<128> DWPName;
   1087       auto Obj = object::ObjectFile::createObjectFile(
   1088           this->DWPName.empty()
   1089               ? (DObj->getFileName() + ".dwp").toStringRef(DWPName)
   1090               : StringRef(this->DWPName));
   1091       if (Obj) {
   1092         Entry = &DWP;
   1093         return Obj;
   1094       } else {
   1095         CheckedForDWP = true;
   1096         // TODO: Should this error be handled (maybe in a high verbosity mode)
   1097         // before falling back to .dwo files?
   1098         consumeError(Obj.takeError());
   1099       }
   1100     }
   1101 
   1102     return object::ObjectFile::createObjectFile(AbsolutePath);
   1103   }();
   1104 
   1105   if (!Obj) {
   1106     // TODO: Actually report errors helpfully.
   1107     consumeError(Obj.takeError());
   1108     return nullptr;
   1109   }
   1110 
   1111   auto S = std::make_shared<DWOFile>();
   1112   S->File = std::move(Obj.get());
   1113   S->Context = DWARFContext::create(*S->File.getBinary());
   1114   *Entry = S;
   1115   auto *Ctxt = S->Context.get();
   1116   return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
   1117 }
   1118 
   1119 static Error createError(const Twine &Reason, llvm::Error E) {
   1120   return make_error<StringError>(Reason + toString(std::move(E)),
   1121                                  inconvertibleErrorCode());
   1122 }
   1123 
   1124 /// SymInfo contains information about symbol: it's address
   1125 /// and section index which is -1LL for absolute symbols.
   1126 struct SymInfo {
   1127   uint64_t Address;
   1128   uint64_t SectionIndex;
   1129 };
   1130 
   1131 /// Returns the address of symbol relocation used against and a section index.
   1132 /// Used for futher relocations computation. Symbol's section load address is
   1133 static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj,
   1134                                        const RelocationRef &Reloc,
   1135                                        const LoadedObjectInfo *L,
   1136                                        std::map<SymbolRef, SymInfo> &Cache) {
   1137   SymInfo Ret = {0, (uint64_t)-1LL};
   1138   object::section_iterator RSec = Obj.section_end();
   1139   object::symbol_iterator Sym = Reloc.getSymbol();
   1140 
   1141   std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end();
   1142   // First calculate the address of the symbol or section as it appears
   1143   // in the object file
   1144   if (Sym != Obj.symbol_end()) {
   1145     bool New;
   1146     std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}});
   1147     if (!New)
   1148       return CacheIt->second;
   1149 
   1150     Expected<uint64_t> SymAddrOrErr = Sym->getAddress();
   1151     if (!SymAddrOrErr)
   1152       return createError("failed to compute symbol address: ",
   1153                          SymAddrOrErr.takeError());
   1154 
   1155     // Also remember what section this symbol is in for later
   1156     auto SectOrErr = Sym->getSection();
   1157     if (!SectOrErr)
   1158       return createError("failed to get symbol section: ",
   1159                          SectOrErr.takeError());
   1160 
   1161     RSec = *SectOrErr;
   1162     Ret.Address = *SymAddrOrErr;
   1163   } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) {
   1164     RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl());
   1165     Ret.Address = RSec->getAddress();
   1166   }
   1167 
   1168   if (RSec != Obj.section_end())
   1169     Ret.SectionIndex = RSec->getIndex();
   1170 
   1171   // If we are given load addresses for the sections, we need to adjust:
   1172   // SymAddr = (Address of Symbol Or Section in File) -
   1173   //           (Address of Section in File) +
   1174   //           (Load Address of Section)
   1175   // RSec is now either the section being targeted or the section
   1176   // containing the symbol being targeted. In either case,
   1177   // we need to perform the same computation.
   1178   if (L && RSec != Obj.section_end())
   1179     if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(*RSec))
   1180       Ret.Address += SectionLoadAddress - RSec->getAddress();
   1181 
   1182   if (CacheIt != Cache.end())
   1183     CacheIt->second = Ret;
   1184 
   1185   return Ret;
   1186 }
   1187 
   1188 static bool isRelocScattered(const object::ObjectFile &Obj,
   1189                              const RelocationRef &Reloc) {
   1190   const MachOObjectFile *MachObj = dyn_cast<MachOObjectFile>(&Obj);
   1191   if (!MachObj)
   1192     return false;
   1193   // MachO also has relocations that point to sections and
   1194   // scattered relocations.
   1195   auto RelocInfo = MachObj->getRelocation(Reloc.getRawDataRefImpl());
   1196   return MachObj->isRelocationScattered(RelocInfo);
   1197 }
   1198 
   1199 ErrorPolicy DWARFContext::defaultErrorHandler(Error E) {
   1200   WithColor::error() << toString(std::move(E)) << '\n';
   1201   return ErrorPolicy::Continue;
   1202 }
   1203 
   1204 namespace {
   1205 struct DWARFSectionMap final : public DWARFSection {
   1206   RelocAddrMap Relocs;
   1207 };
   1208 
   1209 class DWARFObjInMemory final : public DWARFObject {
   1210   bool IsLittleEndian;
   1211   uint8_t AddressSize;
   1212   StringRef FileName;
   1213   const object::ObjectFile *Obj = nullptr;
   1214   std::vector<SectionName> SectionNames;
   1215 
   1216   using TypeSectionMap = MapVector<object::SectionRef, DWARFSectionMap,
   1217                                    std::map<object::SectionRef, unsigned>>;
   1218 
   1219   TypeSectionMap TypesSections;
   1220   TypeSectionMap TypesDWOSections;
   1221 
   1222   DWARFSectionMap InfoSection;
   1223   DWARFSectionMap LocSection;
   1224   DWARFSectionMap LineSection;
   1225   DWARFSectionMap RangeSection;
   1226   DWARFSectionMap RnglistsSection;
   1227   DWARFSectionMap StringOffsetSection;
   1228   DWARFSectionMap InfoDWOSection;
   1229   DWARFSectionMap LineDWOSection;
   1230   DWARFSectionMap LocDWOSection;
   1231   DWARFSectionMap StringOffsetDWOSection;
   1232   DWARFSectionMap RangeDWOSection;
   1233   DWARFSectionMap RnglistsDWOSection;
   1234   DWARFSectionMap AddrSection;
   1235   DWARFSectionMap AppleNamesSection;
   1236   DWARFSectionMap AppleTypesSection;
   1237   DWARFSectionMap AppleNamespacesSection;
   1238   DWARFSectionMap AppleObjCSection;
   1239   DWARFSectionMap DebugNamesSection;
   1240 
   1241   DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
   1242     return StringSwitch<DWARFSectionMap *>(Name)
   1243         .Case("debug_info", &InfoSection)
   1244         .Case("debug_loc", &LocSection)
   1245         .Case("debug_line", &LineSection)
   1246         .Case("debug_str_offsets", &StringOffsetSection)
   1247         .Case("debug_ranges", &RangeSection)
   1248         .Case("debug_rnglists", &RnglistsSection)
   1249         .Case("debug_info.dwo", &InfoDWOSection)
   1250         .Case("debug_loc.dwo", &LocDWOSection)
   1251         .Case("debug_line.dwo", &LineDWOSection)
   1252         .Case("debug_names", &DebugNamesSection)
   1253         .Case("debug_rnglists.dwo", &RnglistsDWOSection)
   1254         .Case("debug_str_offsets.dwo", &StringOffsetDWOSection)
   1255         .Case("debug_addr", &AddrSection)
   1256         .Case("apple_names", &AppleNamesSection)
   1257         .Case("apple_types", &AppleTypesSection)
   1258         .Case("apple_namespaces", &AppleNamespacesSection)
   1259         .Case("apple_namespac", &AppleNamespacesSection)
   1260         .Case("apple_objc", &AppleObjCSection)
   1261         .Default(nullptr);
   1262   }
   1263 
   1264   StringRef AbbrevSection;
   1265   StringRef ARangeSection;
   1266   StringRef DebugFrameSection;
   1267   StringRef EHFrameSection;
   1268   StringRef StringSection;
   1269   StringRef MacinfoSection;
   1270   StringRef PubNamesSection;
   1271   StringRef PubTypesSection;
   1272   StringRef GnuPubNamesSection;
   1273   StringRef AbbrevDWOSection;
   1274   StringRef StringDWOSection;
   1275   StringRef GnuPubTypesSection;
   1276   StringRef CUIndexSection;
   1277   StringRef GdbIndexSection;
   1278   StringRef TUIndexSection;
   1279   StringRef LineStringSection;
   1280 
   1281   // A deque holding section data whose iterators are not invalidated when
   1282   // new decompressed sections are inserted at the end.
   1283   std::deque<SmallString<0>> UncompressedSections;
   1284 
   1285   StringRef *mapSectionToMember(StringRef Name) {
   1286     if (DWARFSection *Sec = mapNameToDWARFSection(Name))
   1287       return &Sec->Data;
   1288     return StringSwitch<StringRef *>(Name)
   1289         .Case("debug_abbrev", &AbbrevSection)
   1290         .Case("debug_aranges", &ARangeSection)
   1291         .Case("debug_frame", &DebugFrameSection)
   1292         .Case("eh_frame", &EHFrameSection)
   1293         .Case("debug_str", &StringSection)
   1294         .Case("debug_macinfo", &MacinfoSection)
   1295         .Case("debug_pubnames", &PubNamesSection)
   1296         .Case("debug_pubtypes", &PubTypesSection)
   1297         .Case("debug_gnu_pubnames", &GnuPubNamesSection)
   1298         .Case("debug_gnu_pubtypes", &GnuPubTypesSection)
   1299         .Case("debug_abbrev.dwo", &AbbrevDWOSection)
   1300         .Case("debug_str.dwo", &StringDWOSection)
   1301         .Case("debug_cu_index", &CUIndexSection)
   1302         .Case("debug_tu_index", &TUIndexSection)
   1303         .Case("gdb_index", &GdbIndexSection)
   1304         .Case("debug_line_str", &LineStringSection)
   1305         // Any more debug info sections go here.
   1306         .Default(nullptr);
   1307   }
   1308 
   1309   /// If Sec is compressed section, decompresses and updates its contents
   1310   /// provided by Data. Otherwise leaves it unchanged.
   1311   Error maybeDecompress(const object::SectionRef &Sec, StringRef Name,
   1312                         StringRef &Data) {
   1313     if (!Decompressor::isCompressed(Sec))
   1314       return Error::success();
   1315 
   1316     Expected<Decompressor> Decompressor =
   1317         Decompressor::create(Name, Data, IsLittleEndian, AddressSize == 8);
   1318     if (!Decompressor)
   1319       return Decompressor.takeError();
   1320 
   1321     SmallString<0> Out;
   1322     if (auto Err = Decompressor->resizeAndDecompress(Out))
   1323       return Err;
   1324 
   1325     UncompressedSections.push_back(std::move(Out));
   1326     Data = UncompressedSections.back();
   1327 
   1328     return Error::success();
   1329   }
   1330 
   1331 public:
   1332   DWARFObjInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
   1333                    uint8_t AddrSize, bool IsLittleEndian)
   1334       : IsLittleEndian(IsLittleEndian) {
   1335     for (const auto &SecIt : Sections) {
   1336       if (StringRef *SectionData = mapSectionToMember(SecIt.first()))
   1337         *SectionData = SecIt.second->getBuffer();
   1338     }
   1339   }
   1340   DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
   1341                    function_ref<ErrorPolicy(Error)> HandleError)
   1342       : IsLittleEndian(Obj.isLittleEndian()),
   1343         AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()),
   1344         Obj(&Obj) {
   1345 
   1346     StringMap<unsigned> SectionAmountMap;
   1347     for (const SectionRef &Section : Obj.sections()) {
   1348       StringRef Name;
   1349       Section.getName(Name);
   1350       ++SectionAmountMap[Name];
   1351       SectionNames.push_back({ Name, true });
   1352 
   1353       // Skip BSS and Virtual sections, they aren't interesting.
   1354       if (Section.isBSS() || Section.isVirtual())
   1355         continue;
   1356 
   1357       // Skip sections stripped by dsymutil.
   1358       if (Section.isStripped())
   1359         continue;
   1360 
   1361       StringRef Data;
   1362       section_iterator RelocatedSection = Section.getRelocatedSection();
   1363       // Try to obtain an already relocated version of this section.
   1364       // Else use the unrelocated section from the object file. We'll have to
   1365       // apply relocations ourselves later.
   1366       if (!L || !L->getLoadedSectionContents(*RelocatedSection, Data))
   1367         Section.getContents(Data);
   1368 
   1369       if (auto Err = maybeDecompress(Section, Name, Data)) {
   1370         ErrorPolicy EP = HandleError(createError(
   1371             "failed to decompress '" + Name + "', ", std::move(Err)));
   1372         if (EP == ErrorPolicy::Halt)
   1373           return;
   1374         continue;
   1375       }
   1376 
   1377       // Compressed sections names in GNU style starts from ".z",
   1378       // at this point section is decompressed and we drop compression prefix.
   1379       Name = Name.substr(
   1380           Name.find_first_not_of("._z")); // Skip ".", "z" and "_" prefixes.
   1381 
   1382       // Map platform specific debug section names to DWARF standard section
   1383       // names.
   1384       Name = Obj.mapDebugSectionName(Name);
   1385 
   1386       if (StringRef *SectionData = mapSectionToMember(Name)) {
   1387         *SectionData = Data;
   1388         if (Name == "debug_ranges") {
   1389           // FIXME: Use the other dwo range section when we emit it.
   1390           RangeDWOSection.Data = Data;
   1391         }
   1392       } else if (Name == "debug_types") {
   1393         // Find debug_types data by section rather than name as there are
   1394         // multiple, comdat grouped, debug_types sections.
   1395         TypesSections[Section].Data = Data;
   1396       } else if (Name == "debug_types.dwo") {
   1397         TypesDWOSections[Section].Data = Data;
   1398       }
   1399 
   1400       if (RelocatedSection == Obj.section_end())
   1401         continue;
   1402 
   1403       StringRef RelSecName;
   1404       StringRef RelSecData;
   1405       RelocatedSection->getName(RelSecName);
   1406 
   1407       // If the section we're relocating was relocated already by the JIT,
   1408       // then we used the relocated version above, so we do not need to process
   1409       // relocations for it now.
   1410       if (L && L->getLoadedSectionContents(*RelocatedSection, RelSecData))
   1411         continue;
   1412 
   1413       // In Mach-o files, the relocations do not need to be applied if
   1414       // there is no load offset to apply. The value read at the
   1415       // relocation point already factors in the section address
   1416       // (actually applying the relocations will produce wrong results
   1417       // as the section address will be added twice).
   1418       if (!L && isa<MachOObjectFile>(&Obj))
   1419         continue;
   1420 
   1421       RelSecName = RelSecName.substr(
   1422           RelSecName.find_first_not_of("._z")); // Skip . and _ prefixes.
   1423 
   1424       // TODO: Add support for relocations in other sections as needed.
   1425       // Record relocations for the debug_info and debug_line sections.
   1426       DWARFSectionMap *Sec = mapNameToDWARFSection(RelSecName);
   1427       RelocAddrMap *Map = Sec ? &Sec->Relocs : nullptr;
   1428       if (!Map) {
   1429         // Find debug_types relocs by section rather than name as there are
   1430         // multiple, comdat grouped, debug_types sections.
   1431         if (RelSecName == "debug_types")
   1432           Map =
   1433               &static_cast<DWARFSectionMap &>(TypesSections[*RelocatedSection])
   1434                    .Relocs;
   1435         else if (RelSecName == "debug_types.dwo")
   1436           Map = &static_cast<DWARFSectionMap &>(
   1437                      TypesDWOSections[*RelocatedSection])
   1438                      .Relocs;
   1439         else
   1440           continue;
   1441       }
   1442 
   1443       if (Section.relocation_begin() == Section.relocation_end())
   1444         continue;
   1445 
   1446       // Symbol to [address, section index] cache mapping.
   1447       std::map<SymbolRef, SymInfo> AddrCache;
   1448       for (const RelocationRef &Reloc : Section.relocations()) {
   1449         // FIXME: it's not clear how to correctly handle scattered
   1450         // relocations.
   1451         if (isRelocScattered(Obj, Reloc))
   1452           continue;
   1453 
   1454         Expected<SymInfo> SymInfoOrErr =
   1455             getSymbolInfo(Obj, Reloc, L, AddrCache);
   1456         if (!SymInfoOrErr) {
   1457           if (HandleError(SymInfoOrErr.takeError()) == ErrorPolicy::Halt)
   1458             return;
   1459           continue;
   1460         }
   1461 
   1462         object::RelocVisitor V(Obj);
   1463         uint64_t Val = V.visit(Reloc.getType(), Reloc, SymInfoOrErr->Address);
   1464         if (V.error()) {
   1465           SmallString<32> Type;
   1466           Reloc.getTypeName(Type);
   1467           ErrorPolicy EP = HandleError(
   1468               createError("failed to compute relocation: " + Type + ", ",
   1469                           errorCodeToError(object_error::parse_failed)));
   1470           if (EP == ErrorPolicy::Halt)
   1471             return;
   1472           continue;
   1473         }
   1474         RelocAddrEntry Rel = {SymInfoOrErr->SectionIndex, Val};
   1475         Map->insert({Reloc.getOffset(), Rel});
   1476       }
   1477     }
   1478 
   1479     for (SectionName &S : SectionNames)
   1480       if (SectionAmountMap[S.Name] > 1)
   1481         S.IsNameUnique = false;
   1482   }
   1483 
   1484   Optional<RelocAddrEntry> find(const DWARFSection &S,
   1485                                 uint64_t Pos) const override {
   1486     auto &Sec = static_cast<const DWARFSectionMap &>(S);
   1487     RelocAddrMap::const_iterator AI = Sec.Relocs.find(Pos);
   1488     if (AI == Sec.Relocs.end())
   1489       return None;
   1490     return AI->second;
   1491   }
   1492 
   1493   const object::ObjectFile *getFile() const override { return Obj; }
   1494 
   1495   ArrayRef<SectionName> getSectionNames() const override {
   1496     return SectionNames;
   1497   }
   1498 
   1499   bool isLittleEndian() const override { return IsLittleEndian; }
   1500   StringRef getAbbrevDWOSection() const override { return AbbrevDWOSection; }
   1501   const DWARFSection &getLineDWOSection() const override {
   1502     return LineDWOSection;
   1503   }
   1504   const DWARFSection &getLocDWOSection() const override {
   1505     return LocDWOSection;
   1506   }
   1507   StringRef getStringDWOSection() const override { return StringDWOSection; }
   1508   const DWARFSection &getStringOffsetDWOSection() const override {
   1509     return StringOffsetDWOSection;
   1510   }
   1511   const DWARFSection &getRangeDWOSection() const override {
   1512     return RangeDWOSection;
   1513   }
   1514   const DWARFSection &getRnglistsDWOSection() const override {
   1515     return RnglistsDWOSection;
   1516   }
   1517   const DWARFSection &getAddrSection() const override { return AddrSection; }
   1518   StringRef getCUIndexSection() const override { return CUIndexSection; }
   1519   StringRef getGdbIndexSection() const override { return GdbIndexSection; }
   1520   StringRef getTUIndexSection() const override { return TUIndexSection; }
   1521 
   1522   // DWARF v5
   1523   const DWARFSection &getStringOffsetSection() const override {
   1524     return StringOffsetSection;
   1525   }
   1526   StringRef getLineStringSection() const override { return LineStringSection; }
   1527 
   1528   // Sections for DWARF5 split dwarf proposal.
   1529   const DWARFSection &getInfoDWOSection() const override {
   1530     return InfoDWOSection;
   1531   }
   1532   void forEachTypesDWOSections(
   1533       function_ref<void(const DWARFSection &)> F) const override {
   1534     for (auto &P : TypesDWOSections)
   1535       F(P.second);
   1536   }
   1537 
   1538   StringRef getAbbrevSection() const override { return AbbrevSection; }
   1539   const DWARFSection &getLocSection() const override { return LocSection; }
   1540   StringRef getARangeSection() const override { return ARangeSection; }
   1541   StringRef getDebugFrameSection() const override { return DebugFrameSection; }
   1542   StringRef getEHFrameSection() const override { return EHFrameSection; }
   1543   const DWARFSection &getLineSection() const override { return LineSection; }
   1544   StringRef getStringSection() const override { return StringSection; }
   1545   const DWARFSection &getRangeSection() const override { return RangeSection; }
   1546   const DWARFSection &getRnglistsSection() const override {
   1547     return RnglistsSection;
   1548   }
   1549   StringRef getMacinfoSection() const override { return MacinfoSection; }
   1550   StringRef getPubNamesSection() const override { return PubNamesSection; }
   1551   StringRef getPubTypesSection() const override { return PubTypesSection; }
   1552   StringRef getGnuPubNamesSection() const override {
   1553     return GnuPubNamesSection;
   1554   }
   1555   StringRef getGnuPubTypesSection() const override {
   1556     return GnuPubTypesSection;
   1557   }
   1558   const DWARFSection &getAppleNamesSection() const override {
   1559     return AppleNamesSection;
   1560   }
   1561   const DWARFSection &getAppleTypesSection() const override {
   1562     return AppleTypesSection;
   1563   }
   1564   const DWARFSection &getAppleNamespacesSection() const override {
   1565     return AppleNamespacesSection;
   1566   }
   1567   const DWARFSection &getAppleObjCSection() const override {
   1568     return AppleObjCSection;
   1569   }
   1570   const DWARFSection &getDebugNamesSection() const override {
   1571     return DebugNamesSection;
   1572   }
   1573 
   1574   StringRef getFileName() const override { return FileName; }
   1575   uint8_t getAddressSize() const override { return AddressSize; }
   1576   const DWARFSection &getInfoSection() const override { return InfoSection; }
   1577   void forEachTypesSections(
   1578       function_ref<void(const DWARFSection &)> F) const override {
   1579     for (auto &P : TypesSections)
   1580       F(P.second);
   1581   }
   1582 };
   1583 } // namespace
   1584 
   1585 std::unique_ptr<DWARFContext>
   1586 DWARFContext::create(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
   1587                      function_ref<ErrorPolicy(Error)> HandleError,
   1588                      std::string DWPName) {
   1589   auto DObj = llvm::make_unique<DWARFObjInMemory>(Obj, L, HandleError);
   1590   return llvm::make_unique<DWARFContext>(std::move(DObj), std::move(DWPName));
   1591 }
   1592 
   1593 std::unique_ptr<DWARFContext>
   1594 DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
   1595                      uint8_t AddrSize, bool isLittleEndian) {
   1596   auto DObj =
   1597       llvm::make_unique<DWARFObjInMemory>(Sections, AddrSize, isLittleEndian);
   1598   return llvm::make_unique<DWARFContext>(std::move(DObj), "");
   1599 }
   1600 
   1601 Error DWARFContext::loadRegisterInfo(const object::ObjectFile &Obj) {
   1602   // Detect the architecture from the object file. We usually don't need OS
   1603   // info to lookup a target and create register info.
   1604   Triple TT;
   1605   TT.setArch(Triple::ArchType(Obj.getArch()));
   1606   TT.setVendor(Triple::UnknownVendor);
   1607   TT.setOS(Triple::UnknownOS);
   1608   std::string TargetLookupError;
   1609   const Target *TheTarget =
   1610       TargetRegistry::lookupTarget(TT.str(), TargetLookupError);
   1611   if (!TargetLookupError.empty())
   1612     return make_error<StringError>(TargetLookupError, inconvertibleErrorCode());
   1613   RegInfo.reset(TheTarget->createMCRegInfo(TT.str()));
   1614   return Error::success();
   1615 }
   1616 
   1617 uint8_t DWARFContext::getCUAddrSize() {
   1618   // In theory, different compile units may have different address byte
   1619   // sizes, but for simplicity we just use the address byte size of the
   1620   // last compile unit. In practice the address size field is repeated across
   1621   // various DWARF headers (at least in version 5) to make it easier to dump
   1622   // them independently, not to enable varying the address size.
   1623   uint8_t Addr = 0;
   1624   for (const auto &CU : compile_units()) {
   1625     Addr = CU->getAddressByteSize();
   1626     break;
   1627   }
   1628   return Addr;
   1629 }
   1630