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
57using namespace llvm;
58using namespace dwarf;
59using namespace object;
60
61#define DEBUG_TYPE "dwarf"
62
63using DWARFLineTable = DWARFDebugLine::LineTable;
64using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind;
65using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
66
67DWARFContext::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
75DWARFContext::~DWARFContext() = default;
76
77/// Dump the UUID load command.
78static 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
99using 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.
104static ContributionCollection
105collectContributionData(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).
144static 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.
217static 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).
240static 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
263std::unique_ptr<DWARFDebugMacro>
264DWARFContext::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
305static 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
339static 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
346void 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
696DWARFCompileUnit *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
726DWARFDie DWARFContext::getDIEForOffset(uint64_t Offset) {
727  parseNormalUnits();
728  if (auto *CU = NormalUnits.getUnitForOffset(Offset))
729    return CU->getDIEForOffset(Offset);
730  return DWARFDie();
731}
732
733bool 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
746const 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
757const 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
768DWARFGdbIndex &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
778const 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
789const 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
799const 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
813const 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
822Expected<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
848Expected<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
864const DWARFDebugMacro *DWARFContext::getDebugMacro() {
865  if (!Macro)
866    Macro = parseMacroOrMacinfo(MacroSection);
867  return Macro.get();
868}
869
870const DWARFDebugMacro *DWARFContext::getDebugMacroDWO() {
871  if (!MacroDWO)
872    MacroDWO = parseMacroOrMacinfo(MacroDwoSection);
873  return MacroDWO.get();
874}
875
876const DWARFDebugMacro *DWARFContext::getDebugMacinfo() {
877  if (!Macinfo)
878    Macinfo = parseMacroOrMacinfo(MacinfoSection);
879  return Macinfo.get();
880}
881
882const DWARFDebugMacro *DWARFContext::getDebugMacinfoDWO() {
883  if (!MacinfoDWO)
884    MacinfoDWO = parseMacroOrMacinfo(MacinfoDwoSection);
885  return MacinfoDWO.get();
886}
887
888template <typename T>
889static 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
902const DWARFDebugNames &DWARFContext::getDebugNames() {
903  return getAccelTable(Names, *DObj, DObj->getNamesSection(),
904                       DObj->getStrSection(), isLittleEndian());
905}
906
907const AppleAcceleratorTable &DWARFContext::getAppleNames() {
908  return getAccelTable(AppleNames, *DObj, DObj->getAppleNamesSection(),
909                       DObj->getStrSection(), isLittleEndian());
910}
911
912const AppleAcceleratorTable &DWARFContext::getAppleTypes() {
913  return getAccelTable(AppleTypes, *DObj, DObj->getAppleTypesSection(),
914                       DObj->getStrSection(), isLittleEndian());
915}
916
917const AppleAcceleratorTable &DWARFContext::getAppleNamespaces() {
918  return getAccelTable(AppleNamespaces, *DObj,
919                       DObj->getAppleNamespacesSection(),
920                       DObj->getStrSection(), isLittleEndian());
921}
922
923const AppleAcceleratorTable &DWARFContext::getAppleObjC() {
924  return getAccelTable(AppleObjC, *DObj, DObj->getAppleObjCSection(),
925                       DObj->getStrSection(), isLittleEndian());
926}
927
928const DWARFDebugLine::LineTable *
929DWARFContext::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
939Expected<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
968void 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
980void 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
992DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint64_t Offset) {
993  parseNormalUnits();
994  return dyn_cast_or_null<DWARFCompileUnit>(
995      NormalUnits.getUnitForOffset(Offset));
996}
997
998DWARFCompileUnit *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
1005DWARFContext::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"
1038static 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
1072static 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
1129static Optional<int64_t>
1130getExpressionFrameOffset(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
1148void 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
1214std::vector<DILocal>
1215DWARFContext::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
1227DILineInfo 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
1248DILineInfoTable 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
1302DIInliningInfo
1303DWARFContext::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
1371std::shared_ptr<DWARFContext>
1372DWARFContext::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  *Entry = S;
1416  auto *Ctxt = S->Context.get();
1417  return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1418}
1419
1420static Error createError(const Twine &Reason, llvm::Error E) {
1421  return make_error<StringError>(Reason + toString(std::move(E)),
1422                                 inconvertibleErrorCode());
1423}
1424
1425/// SymInfo contains information about symbol: it's address
1426/// and section index which is -1LL for absolute symbols.
1427struct SymInfo {
1428  uint64_t Address;
1429  uint64_t SectionIndex;
1430};
1431
1432/// Returns the address of symbol relocation used against and a section index.
1433/// Used for futher relocations computation. Symbol's section load address is
1434static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj,
1435                                       const RelocationRef &Reloc,
1436                                       const LoadedObjectInfo *L,
1437                                       std::map<SymbolRef, SymInfo> &Cache) {
1438  SymInfo Ret = {0, (uint64_t)-1LL};
1439  object::section_iterator RSec = Obj.section_end();
1440  object::symbol_iterator Sym = Reloc.getSymbol();
1441
1442  std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end();
1443  // First calculate the address of the symbol or section as it appears
1444  // in the object file
1445  if (Sym != Obj.symbol_end()) {
1446    bool New;
1447    std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}});
1448    if (!New)
1449      return CacheIt->second;
1450
1451    Expected<uint64_t> SymAddrOrErr = Sym->getAddress();
1452    if (!SymAddrOrErr)
1453      return createError("failed to compute symbol address: ",
1454                         SymAddrOrErr.takeError());
1455
1456    // Also remember what section this symbol is in for later
1457    auto SectOrErr = Sym->getSection();
1458    if (!SectOrErr)
1459      return createError("failed to get symbol section: ",
1460                         SectOrErr.takeError());
1461
1462    RSec = *SectOrErr;
1463    Ret.Address = *SymAddrOrErr;
1464  } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) {
1465    RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl());
1466    Ret.Address = RSec->getAddress();
1467  }
1468
1469  if (RSec != Obj.section_end())
1470    Ret.SectionIndex = RSec->getIndex();
1471
1472  // If we are given load addresses for the sections, we need to adjust:
1473  // SymAddr = (Address of Symbol Or Section in File) -
1474  //           (Address of Section in File) +
1475  //           (Load Address of Section)
1476  // RSec is now either the section being targeted or the section
1477  // containing the symbol being targeted. In either case,
1478  // we need to perform the same computation.
1479  if (L && RSec != Obj.section_end())
1480    if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(*RSec))
1481      Ret.Address += SectionLoadAddress - RSec->getAddress();
1482
1483  if (CacheIt != Cache.end())
1484    CacheIt->second = Ret;
1485
1486  return Ret;
1487}
1488
1489static bool isRelocScattered(const object::ObjectFile &Obj,
1490                             const RelocationRef &Reloc) {
1491  const MachOObjectFile *MachObj = dyn_cast<MachOObjectFile>(&Obj);
1492  if (!MachObj)
1493    return false;
1494  // MachO also has relocations that point to sections and
1495  // scattered relocations.
1496  auto RelocInfo = MachObj->getRelocation(Reloc.getRawDataRefImpl());
1497  return MachObj->isRelocationScattered(RelocInfo);
1498}
1499
1500namespace {
1501struct DWARFSectionMap final : public DWARFSection {
1502  RelocAddrMap Relocs;
1503};
1504
1505class DWARFObjInMemory final : public DWARFObject {
1506  bool IsLittleEndian;
1507  uint8_t AddressSize;
1508  StringRef FileName;
1509  const object::ObjectFile *Obj = nullptr;
1510  std::vector<SectionName> SectionNames;
1511
1512  using InfoSectionMap = MapVector<object::SectionRef, DWARFSectionMap,
1513                                   std::map<object::SectionRef, unsigned>>;
1514
1515  InfoSectionMap InfoSections;
1516  InfoSectionMap TypesSections;
1517  InfoSectionMap InfoDWOSections;
1518  InfoSectionMap TypesDWOSections;
1519
1520  DWARFSectionMap LocSection;
1521  DWARFSectionMap LoclistsSection;
1522  DWARFSectionMap LoclistsDWOSection;
1523  DWARFSectionMap LineSection;
1524  DWARFSectionMap RangesSection;
1525  DWARFSectionMap RnglistsSection;
1526  DWARFSectionMap StrOffsetsSection;
1527  DWARFSectionMap LineDWOSection;
1528  DWARFSectionMap FrameSection;
1529  DWARFSectionMap EHFrameSection;
1530  DWARFSectionMap LocDWOSection;
1531  DWARFSectionMap StrOffsetsDWOSection;
1532  DWARFSectionMap RangesDWOSection;
1533  DWARFSectionMap RnglistsDWOSection;
1534  DWARFSectionMap AddrSection;
1535  DWARFSectionMap AppleNamesSection;
1536  DWARFSectionMap AppleTypesSection;
1537  DWARFSectionMap AppleNamespacesSection;
1538  DWARFSectionMap AppleObjCSection;
1539  DWARFSectionMap NamesSection;
1540  DWARFSectionMap PubnamesSection;
1541  DWARFSectionMap PubtypesSection;
1542  DWARFSectionMap GnuPubnamesSection;
1543  DWARFSectionMap GnuPubtypesSection;
1544  DWARFSectionMap MacroSection;
1545
1546  DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
1547    return StringSwitch<DWARFSectionMap *>(Name)
1548        .Case("debug_loc", &LocSection)
1549        .Case("debug_loclists", &LoclistsSection)
1550        .Case("debug_loclists.dwo", &LoclistsDWOSection)
1551        .Case("debug_line", &LineSection)
1552        .Case("debug_frame", &FrameSection)
1553        .Case("eh_frame", &EHFrameSection)
1554        .Case("debug_str_offsets", &StrOffsetsSection)
1555        .Case("debug_ranges", &RangesSection)
1556        .Case("debug_rnglists", &RnglistsSection)
1557        .Case("debug_loc.dwo", &LocDWOSection)
1558        .Case("debug_line.dwo", &LineDWOSection)
1559        .Case("debug_names", &NamesSection)
1560        .Case("debug_rnglists.dwo", &RnglistsDWOSection)
1561        .Case("debug_str_offsets.dwo", &StrOffsetsDWOSection)
1562        .Case("debug_addr", &AddrSection)
1563        .Case("apple_names", &AppleNamesSection)
1564        .Case("debug_pubnames", &PubnamesSection)
1565        .Case("debug_pubtypes", &PubtypesSection)
1566        .Case("debug_gnu_pubnames", &GnuPubnamesSection)
1567        .Case("debug_gnu_pubtypes", &GnuPubtypesSection)
1568        .Case("apple_types", &AppleTypesSection)
1569        .Case("apple_namespaces", &AppleNamespacesSection)
1570        .Case("apple_namespac", &AppleNamespacesSection)
1571        .Case("apple_objc", &AppleObjCSection)
1572        .Case("debug_macro", &MacroSection)
1573        .Default(nullptr);
1574  }
1575
1576  StringRef AbbrevSection;
1577  StringRef ArangesSection;
1578  StringRef StrSection;
1579  StringRef MacinfoSection;
1580  StringRef MacinfoDWOSection;
1581  StringRef MacroDWOSection;
1582  StringRef AbbrevDWOSection;
1583  StringRef StrDWOSection;
1584  StringRef CUIndexSection;
1585  StringRef GdbIndexSection;
1586  StringRef TUIndexSection;
1587  StringRef LineStrSection;
1588
1589  // A deque holding section data whose iterators are not invalidated when
1590  // new decompressed sections are inserted at the end.
1591  std::deque<SmallString<0>> UncompressedSections;
1592
1593  StringRef *mapSectionToMember(StringRef Name) {
1594    if (DWARFSection *Sec = mapNameToDWARFSection(Name))
1595      return &Sec->Data;
1596    return StringSwitch<StringRef *>(Name)
1597        .Case("debug_abbrev", &AbbrevSection)
1598        .Case("debug_aranges", &ArangesSection)
1599        .Case("debug_str", &StrSection)
1600        .Case("debug_macinfo", &MacinfoSection)
1601        .Case("debug_macinfo.dwo", &MacinfoDWOSection)
1602        .Case("debug_macro.dwo", &MacroDWOSection)
1603        .Case("debug_abbrev.dwo", &AbbrevDWOSection)
1604        .Case("debug_str.dwo", &StrDWOSection)
1605        .Case("debug_cu_index", &CUIndexSection)
1606        .Case("debug_tu_index", &TUIndexSection)
1607        .Case("gdb_index", &GdbIndexSection)
1608        .Case("debug_line_str", &LineStrSection)
1609        // Any more debug info sections go here.
1610        .Default(nullptr);
1611  }
1612
1613  /// If Sec is compressed section, decompresses and updates its contents
1614  /// provided by Data. Otherwise leaves it unchanged.
1615  Error maybeDecompress(const object::SectionRef &Sec, StringRef Name,
1616                        StringRef &Data) {
1617    if (!Decompressor::isCompressed(Sec))
1618      return Error::success();
1619
1620    Expected<Decompressor> Decompressor =
1621        Decompressor::create(Name, Data, IsLittleEndian, AddressSize == 8);
1622    if (!Decompressor)
1623      return Decompressor.takeError();
1624
1625    SmallString<0> Out;
1626    if (auto Err = Decompressor->resizeAndDecompress(Out))
1627      return Err;
1628
1629    UncompressedSections.push_back(std::move(Out));
1630    Data = UncompressedSections.back();
1631
1632    return Error::success();
1633  }
1634
1635public:
1636  DWARFObjInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
1637                   uint8_t AddrSize, bool IsLittleEndian)
1638      : IsLittleEndian(IsLittleEndian) {
1639    for (const auto &SecIt : Sections) {
1640      if (StringRef *SectionData = mapSectionToMember(SecIt.first()))
1641        *SectionData = SecIt.second->getBuffer();
1642      else if (SecIt.first() == "debug_info")
1643        // Find debug_info and debug_types data by section rather than name as
1644        // there are multiple, comdat grouped, of these sections.
1645        InfoSections[SectionRef()].Data = SecIt.second->getBuffer();
1646      else if (SecIt.first() == "debug_info.dwo")
1647        InfoDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
1648      else if (SecIt.first() == "debug_types")
1649        TypesSections[SectionRef()].Data = SecIt.second->getBuffer();
1650      else if (SecIt.first() == "debug_types.dwo")
1651        TypesDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
1652    }
1653  }
1654  DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
1655                   function_ref<void(Error)> HandleError, function_ref<void(Error)> HandleWarning )
1656      : IsLittleEndian(Obj.isLittleEndian()),
1657        AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()),
1658        Obj(&Obj) {
1659
1660    StringMap<unsigned> SectionAmountMap;
1661    for (const SectionRef &Section : Obj.sections()) {
1662      StringRef Name;
1663      if (auto NameOrErr = Section.getName())
1664        Name = *NameOrErr;
1665      else
1666        consumeError(NameOrErr.takeError());
1667
1668      ++SectionAmountMap[Name];
1669      SectionNames.push_back({ Name, true });
1670
1671      // Skip BSS and Virtual sections, they aren't interesting.
1672      if (Section.isBSS() || Section.isVirtual())
1673        continue;
1674
1675      // Skip sections stripped by dsymutil.
1676      if (Section.isStripped())
1677        continue;
1678
1679      StringRef Data;
1680      Expected<section_iterator> SecOrErr = Section.getRelocatedSection();
1681      if (!SecOrErr) {
1682        HandleError(createError("failed to get relocated section: ",
1683                                SecOrErr.takeError()));
1684        continue;
1685      }
1686
1687      // Try to obtain an already relocated version of this section.
1688      // Else use the unrelocated section from the object file. We'll have to
1689      // apply relocations ourselves later.
1690      section_iterator RelocatedSection = *SecOrErr;
1691      if (!L || !L->getLoadedSectionContents(*RelocatedSection, Data)) {
1692        Expected<StringRef> E = Section.getContents();
1693        if (E)
1694          Data = *E;
1695        else
1696          // maybeDecompress below will error.
1697          consumeError(E.takeError());
1698      }
1699
1700      if (auto Err = maybeDecompress(Section, Name, Data)) {
1701        HandleError(createError("failed to decompress '" + Name + "', ",
1702                                std::move(Err)));
1703        continue;
1704      }
1705
1706      // Compressed sections names in GNU style starts from ".z",
1707      // at this point section is decompressed and we drop compression prefix.
1708      Name = Name.substr(
1709          Name.find_first_not_of("._z")); // Skip ".", "z" and "_" prefixes.
1710
1711      // Map platform specific debug section names to DWARF standard section
1712      // names.
1713      Name = Obj.mapDebugSectionName(Name);
1714
1715      if (StringRef *SectionData = mapSectionToMember(Name)) {
1716        *SectionData = Data;
1717        if (Name == "debug_ranges") {
1718          // FIXME: Use the other dwo range section when we emit it.
1719          RangesDWOSection.Data = Data;
1720        } else if (Name == "debug_frame" || Name == "eh_frame") {
1721          if (DWARFSection *S = mapNameToDWARFSection(Name))
1722            S->Address = Section.getAddress();
1723        }
1724      } else if (InfoSectionMap *Sections =
1725                     StringSwitch<InfoSectionMap *>(Name)
1726                         .Case("debug_info", &InfoSections)
1727                         .Case("debug_info.dwo", &InfoDWOSections)
1728                         .Case("debug_types", &TypesSections)
1729                         .Case("debug_types.dwo", &TypesDWOSections)
1730                         .Default(nullptr)) {
1731        // Find debug_info and debug_types data by section rather than name as
1732        // there are multiple, comdat grouped, of these sections.
1733        DWARFSectionMap &S = (*Sections)[Section];
1734        S.Data = Data;
1735      }
1736
1737      if (RelocatedSection == Obj.section_end())
1738        continue;
1739
1740      StringRef RelSecName;
1741      if (auto NameOrErr = RelocatedSection->getName())
1742        RelSecName = *NameOrErr;
1743      else
1744        consumeError(NameOrErr.takeError());
1745
1746      // If the section we're relocating was relocated already by the JIT,
1747      // then we used the relocated version above, so we do not need to process
1748      // relocations for it now.
1749      StringRef RelSecData;
1750      if (L && L->getLoadedSectionContents(*RelocatedSection, RelSecData))
1751        continue;
1752
1753      // In Mach-o files, the relocations do not need to be applied if
1754      // there is no load offset to apply. The value read at the
1755      // relocation point already factors in the section address
1756      // (actually applying the relocations will produce wrong results
1757      // as the section address will be added twice).
1758      if (!L && isa<MachOObjectFile>(&Obj))
1759        continue;
1760
1761      RelSecName = RelSecName.substr(
1762          RelSecName.find_first_not_of("._z")); // Skip . and _ prefixes.
1763
1764      // TODO: Add support for relocations in other sections as needed.
1765      // Record relocations for the debug_info and debug_line sections.
1766      DWARFSectionMap *Sec = mapNameToDWARFSection(RelSecName);
1767      RelocAddrMap *Map = Sec ? &Sec->Relocs : nullptr;
1768      if (!Map) {
1769        // Find debug_info and debug_types relocs by section rather than name
1770        // as there are multiple, comdat grouped, of these sections.
1771        if (RelSecName == "debug_info")
1772          Map = &static_cast<DWARFSectionMap &>(InfoSections[*RelocatedSection])
1773                     .Relocs;
1774        else if (RelSecName == "debug_info.dwo")
1775          Map = &static_cast<DWARFSectionMap &>(
1776                     InfoDWOSections[*RelocatedSection])
1777                     .Relocs;
1778        else if (RelSecName == "debug_types")
1779          Map =
1780              &static_cast<DWARFSectionMap &>(TypesSections[*RelocatedSection])
1781                   .Relocs;
1782        else if (RelSecName == "debug_types.dwo")
1783          Map = &static_cast<DWARFSectionMap &>(
1784                     TypesDWOSections[*RelocatedSection])
1785                     .Relocs;
1786        else
1787          continue;
1788      }
1789
1790      if (Section.relocation_begin() == Section.relocation_end())
1791        continue;
1792
1793      // Symbol to [address, section index] cache mapping.
1794      std::map<SymbolRef, SymInfo> AddrCache;
1795      SupportsRelocation Supports;
1796      RelocationResolver Resolver;
1797      std::tie(Supports, Resolver) = getRelocationResolver(Obj);
1798      for (const RelocationRef &Reloc : Section.relocations()) {
1799        // FIXME: it's not clear how to correctly handle scattered
1800        // relocations.
1801        if (isRelocScattered(Obj, Reloc))
1802          continue;
1803
1804        Expected<SymInfo> SymInfoOrErr =
1805            getSymbolInfo(Obj, Reloc, L, AddrCache);
1806        if (!SymInfoOrErr) {
1807          HandleError(SymInfoOrErr.takeError());
1808          continue;
1809        }
1810
1811        // Check if Resolver can handle this relocation type early so as not to
1812        // handle invalid cases in DWARFDataExtractor.
1813        //
1814        // TODO Don't store Resolver in every RelocAddrEntry.
1815        if (Supports && Supports(Reloc.getType())) {
1816          auto I = Map->try_emplace(
1817              Reloc.getOffset(),
1818              RelocAddrEntry{SymInfoOrErr->SectionIndex, Reloc,
1819                             SymInfoOrErr->Address,
1820                             Optional<object::RelocationRef>(), 0, Resolver});
1821          // If we didn't successfully insert that's because we already had a
1822          // relocation for that offset. Store it as a second relocation in the
1823          // same RelocAddrEntry instead.
1824          if (!I.second) {
1825            RelocAddrEntry &entry = I.first->getSecond();
1826            if (entry.Reloc2) {
1827              HandleError(createError(
1828                  "At most two relocations per offset are supported"));
1829            }
1830            entry.Reloc2 = Reloc;
1831            entry.SymbolValue2 = SymInfoOrErr->Address;
1832          }
1833        } else {
1834          SmallString<32> Type;
1835          Reloc.getTypeName(Type);
1836          // FIXME: Support more relocations & change this to an error
1837          HandleWarning(
1838              createError("failed to compute relocation: " + Type + ", ",
1839                          errorCodeToError(object_error::parse_failed)));
1840        }
1841      }
1842    }
1843
1844    for (SectionName &S : SectionNames)
1845      if (SectionAmountMap[S.Name] > 1)
1846        S.IsNameUnique = false;
1847  }
1848
1849  Optional<RelocAddrEntry> find(const DWARFSection &S,
1850                                uint64_t Pos) const override {
1851    auto &Sec = static_cast<const DWARFSectionMap &>(S);
1852    RelocAddrMap::const_iterator AI = Sec.Relocs.find(Pos);
1853    if (AI == Sec.Relocs.end())
1854      return None;
1855    return AI->second;
1856  }
1857
1858  const object::ObjectFile *getFile() const override { return Obj; }
1859
1860  ArrayRef<SectionName> getSectionNames() const override {
1861    return SectionNames;
1862  }
1863
1864  bool isLittleEndian() const override { return IsLittleEndian; }
1865  StringRef getAbbrevDWOSection() const override { return AbbrevDWOSection; }
1866  const DWARFSection &getLineDWOSection() const override {
1867    return LineDWOSection;
1868  }
1869  const DWARFSection &getLocDWOSection() const override {
1870    return LocDWOSection;
1871  }
1872  StringRef getStrDWOSection() const override { return StrDWOSection; }
1873  const DWARFSection &getStrOffsetsDWOSection() const override {
1874    return StrOffsetsDWOSection;
1875  }
1876  const DWARFSection &getRangesDWOSection() const override {
1877    return RangesDWOSection;
1878  }
1879  const DWARFSection &getRnglistsDWOSection() const override {
1880    return RnglistsDWOSection;
1881  }
1882  const DWARFSection &getLoclistsDWOSection() const override {
1883    return LoclistsDWOSection;
1884  }
1885  const DWARFSection &getAddrSection() const override { return AddrSection; }
1886  StringRef getCUIndexSection() const override { return CUIndexSection; }
1887  StringRef getGdbIndexSection() const override { return GdbIndexSection; }
1888  StringRef getTUIndexSection() const override { return TUIndexSection; }
1889
1890  // DWARF v5
1891  const DWARFSection &getStrOffsetsSection() const override {
1892    return StrOffsetsSection;
1893  }
1894  StringRef getLineStrSection() const override { return LineStrSection; }
1895
1896  // Sections for DWARF5 split dwarf proposal.
1897  void forEachInfoDWOSections(
1898      function_ref<void(const DWARFSection &)> F) const override {
1899    for (auto &P : InfoDWOSections)
1900      F(P.second);
1901  }
1902  void forEachTypesDWOSections(
1903      function_ref<void(const DWARFSection &)> F) const override {
1904    for (auto &P : TypesDWOSections)
1905      F(P.second);
1906  }
1907
1908  StringRef getAbbrevSection() const override { return AbbrevSection; }
1909  const DWARFSection &getLocSection() const override { return LocSection; }
1910  const DWARFSection &getLoclistsSection() const override { return LoclistsSection; }
1911  StringRef getArangesSection() const override { return ArangesSection; }
1912  const DWARFSection &getFrameSection() const override {
1913    return FrameSection;
1914  }
1915  const DWARFSection &getEHFrameSection() const override {
1916    return EHFrameSection;
1917  }
1918  const DWARFSection &getLineSection() const override { return LineSection; }
1919  StringRef getStrSection() const override { return StrSection; }
1920  const DWARFSection &getRangesSection() const override { return RangesSection; }
1921  const DWARFSection &getRnglistsSection() const override {
1922    return RnglistsSection;
1923  }
1924  const DWARFSection &getMacroSection() const override { return MacroSection; }
1925  StringRef getMacroDWOSection() const override { return MacroDWOSection; }
1926  StringRef getMacinfoSection() const override { return MacinfoSection; }
1927  StringRef getMacinfoDWOSection() const override { return MacinfoDWOSection; }
1928  const DWARFSection &getPubnamesSection() const override { return PubnamesSection; }
1929  const DWARFSection &getPubtypesSection() const override { return PubtypesSection; }
1930  const DWARFSection &getGnuPubnamesSection() const override {
1931    return GnuPubnamesSection;
1932  }
1933  const DWARFSection &getGnuPubtypesSection() const override {
1934    return GnuPubtypesSection;
1935  }
1936  const DWARFSection &getAppleNamesSection() const override {
1937    return AppleNamesSection;
1938  }
1939  const DWARFSection &getAppleTypesSection() const override {
1940    return AppleTypesSection;
1941  }
1942  const DWARFSection &getAppleNamespacesSection() const override {
1943    return AppleNamespacesSection;
1944  }
1945  const DWARFSection &getAppleObjCSection() const override {
1946    return AppleObjCSection;
1947  }
1948  const DWARFSection &getNamesSection() const override {
1949    return NamesSection;
1950  }
1951
1952  StringRef getFileName() const override { return FileName; }
1953  uint8_t getAddressSize() const override { return AddressSize; }
1954  void forEachInfoSections(
1955      function_ref<void(const DWARFSection &)> F) const override {
1956    for (auto &P : InfoSections)
1957      F(P.second);
1958  }
1959  void forEachTypesSections(
1960      function_ref<void(const DWARFSection &)> F) const override {
1961    for (auto &P : TypesSections)
1962      F(P.second);
1963  }
1964};
1965} // namespace
1966
1967std::unique_ptr<DWARFContext>
1968DWARFContext::create(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
1969                     std::string DWPName,
1970                     std::function<void(Error)> RecoverableErrorHandler,
1971                     std::function<void(Error)> WarningHandler) {
1972  auto DObj =
1973      std::make_unique<DWARFObjInMemory>(Obj, L, RecoverableErrorHandler, WarningHandler);
1974  return std::make_unique<DWARFContext>(std::move(DObj), std::move(DWPName),
1975                                        RecoverableErrorHandler,
1976                                        WarningHandler);
1977}
1978
1979std::unique_ptr<DWARFContext>
1980DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
1981                     uint8_t AddrSize, bool isLittleEndian,
1982                     std::function<void(Error)> RecoverableErrorHandler,
1983                     std::function<void(Error)> WarningHandler) {
1984  auto DObj =
1985      std::make_unique<DWARFObjInMemory>(Sections, AddrSize, isLittleEndian);
1986  return std::make_unique<DWARFContext>(
1987      std::move(DObj), "", RecoverableErrorHandler, WarningHandler);
1988}
1989
1990Error DWARFContext::loadRegisterInfo(const object::ObjectFile &Obj) {
1991  // Detect the architecture from the object file. We usually don't need OS
1992  // info to lookup a target and create register info.
1993  Triple TT;
1994  TT.setArch(Triple::ArchType(Obj.getArch()));
1995  TT.setVendor(Triple::UnknownVendor);
1996  TT.setOS(Triple::UnknownOS);
1997  std::string TargetLookupError;
1998  const Target *TheTarget =
1999      TargetRegistry::lookupTarget(TT.str(), TargetLookupError);
2000  if (!TargetLookupError.empty())
2001    return createStringError(errc::invalid_argument,
2002                             TargetLookupError.c_str());
2003  RegInfo.reset(TheTarget->createMCRegInfo(TT.str()));
2004  return Error::success();
2005}
2006
2007uint8_t DWARFContext::getCUAddrSize() {
2008  // In theory, different compile units may have different address byte
2009  // sizes, but for simplicity we just use the address byte size of the
2010  // first compile unit. In practice the address size field is repeated across
2011  // various DWARF headers (at least in version 5) to make it easier to dump
2012  // them independently, not to enable varying the address size.
2013  auto CUs = compile_units();
2014  return CUs.empty() ? 0 : (*CUs.begin())->getAddressByteSize();
2015}
2016