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