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