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