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/DWARFDie.h"
29 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
30 #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
31 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
32 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
33 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
34 #include "llvm/Object/Decompressor.h"
35 #include "llvm/Object/MachO.h"
36 #include "llvm/Object/ObjectFile.h"
37 #include "llvm/Object/RelocVisitor.h"
38 #include "llvm/Support/Casting.h"
39 #include "llvm/Support/DataExtractor.h"
40 #include "llvm/Support/Error.h"
41 #include "llvm/Support/Format.h"
42 #include "llvm/Support/MemoryBuffer.h"
43 #include "llvm/Support/raw_ostream.h"
44 #include <algorithm>
45 #include <cstdint>
46 #include <map>
47 #include <string>
48 #include <tuple>
49 #include <utility>
50 #include <vector>
51 
52 using namespace llvm;
53 using namespace dwarf;
54 using namespace object;
55 
56 #define DEBUG_TYPE "dwarf"
57 
58 using DWARFLineTable = DWARFDebugLine::LineTable;
59 using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind;
60 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
61 
62 uint64_t llvm::getRelocatedValue(const DataExtractor &Data, uint32_t Size,
63                                  uint32_t *Off, const RelocAddrMap *Relocs,
64                                  uint64_t *SectionIndex) {
65   if (!Relocs)
66     return Data.getUnsigned(Off, Size);
67   RelocAddrMap::const_iterator AI = Relocs->find(*Off);
68   if (AI == Relocs->end())
69     return Data.getUnsigned(Off, Size);
70   if (SectionIndex)
71     *SectionIndex = AI->second.SectionIndex;
72   return Data.getUnsigned(Off, Size) + AI->second.Value;
73 }
74 
75 static void dumpAccelSection(raw_ostream &OS, StringRef Name,
76                              const DWARFSection& Section, StringRef StringSection,
77                              bool LittleEndian) {
78   DataExtractor AccelSection(Section.Data, LittleEndian, 0);
79   DataExtractor StrData(StringSection, LittleEndian, 0);
80   OS << "\n." << Name << " contents:\n";
81   DWARFAcceleratorTable Accel(AccelSection, StrData, Section.Relocs);
82   if (!Accel.extract())
83     return;
84   Accel.dump(OS);
85 }
86 
87 static void
88 dumpDWARFv5StringOffsetsSection(raw_ostream &OS, StringRef SectionName,
89                                 const DWARFSection &StringOffsetsSection,
90                                 StringRef StringSection, bool LittleEndian) {
91   DataExtractor StrOffsetExt(StringOffsetsSection.Data, LittleEndian, 0);
92   uint32_t Offset = 0;
93   uint64_t SectionSize = StringOffsetsSection.Data.size();
94 
95   while (Offset < SectionSize) {
96     unsigned Version = 0;
97     DwarfFormat Format = DWARF32;
98     unsigned EntrySize = 4;
99     // Perform validation and extract the segment size from the header.
100     if (!StrOffsetExt.isValidOffsetForDataOfSize(Offset, 4)) {
101       OS << "error: invalid contribution to string offsets table in section ."
102          << SectionName << ".\n";
103       return;
104     }
105     uint32_t ContributionStart = Offset;
106     uint64_t ContributionSize = StrOffsetExt.getU32(&Offset);
107     // A contribution size of 0xffffffff indicates DWARF64, with the actual size
108     // in the following 8 bytes. Otherwise, the DWARF standard mandates that
109     // the contribution size must be at most 0xfffffff0.
110     if (ContributionSize == 0xffffffff) {
111       if (!StrOffsetExt.isValidOffsetForDataOfSize(Offset, 8)) {
112         OS << "error: invalid contribution to string offsets table in section ."
113            << SectionName << ".\n";
114         return;
115       }
116       Format = DWARF64;
117       EntrySize = 8;
118       ContributionSize = StrOffsetExt.getU64(&Offset);
119     } else if (ContributionSize > 0xfffffff0) {
120       OS << "error: invalid contribution to string offsets table in section ."
121          << SectionName << ".\n";
122       return;
123     }
124 
125     // We must ensure that we don't read a partial record at the end, so we
126     // validate for a multiple of EntrySize. Also, we're expecting a version
127     // number and padding, which adds an additional 4 bytes.
128     uint64_t ValidationSize =
129         4 + ((ContributionSize + EntrySize - 1) & (-(uint64_t)EntrySize));
130     if (!StrOffsetExt.isValidOffsetForDataOfSize(Offset, ValidationSize)) {
131       OS << "error: contribution to string offsets table in section ."
132          << SectionName << " has invalid length.\n";
133       return;
134     }
135 
136     Version = StrOffsetExt.getU16(&Offset);
137     Offset += 2;
138     OS << format("0x%8.8x: ", ContributionStart);
139     OS << "Contribution size = " << ContributionSize
140        << ", Version = " << Version << "\n";
141 
142     uint32_t ContributionBase = Offset;
143     DataExtractor StrData(StringSection, LittleEndian, 0);
144     while (Offset - ContributionBase < ContributionSize) {
145       OS << format("0x%8.8x: ", Offset);
146       // FIXME: We can only extract strings in DWARF32 format at the moment.
147       uint64_t StringOffset = getRelocatedValue(
148           StrOffsetExt, EntrySize, &Offset, &StringOffsetsSection.Relocs);
149       if (Format == DWARF32) {
150         OS << format("%8.8x ", StringOffset);
151         uint32_t StringOffset32 = (uint32_t)StringOffset;
152         const char *S = StrData.getCStr(&StringOffset32);
153         if (S)
154           OS << format("\"%s\"", S);
155       } else
156         OS << format("%16.16x ", StringOffset);
157       OS << "\n";
158     }
159   }
160 }
161 
162 // Dump a DWARF string offsets section. This may be a DWARF v5 formatted
163 // string offsets section, where each compile or type unit contributes a
164 // number of entries (string offsets), with each contribution preceded by
165 // a header containing size and version number. Alternatively, it may be a
166 // monolithic series of string offsets, as generated by the pre-DWARF v5
167 // implementation of split DWARF.
168 static void dumpStringOffsetsSection(raw_ostream &OS, StringRef SectionName,
169                                      const DWARFSection &StringOffsetsSection,
170                                      StringRef StringSection, bool LittleEndian,
171                                      unsigned MaxVersion) {
172   if (StringOffsetsSection.Data.empty())
173     return;
174   OS << "\n." << SectionName << " contents:\n";
175   // If we have at least one (compile or type) unit with DWARF v5 or greater,
176   // we assume that the section is formatted like a DWARF v5 string offsets
177   // section.
178   if (MaxVersion >= 5)
179     dumpDWARFv5StringOffsetsSection(OS, SectionName, StringOffsetsSection,
180                                     StringSection, LittleEndian);
181   else {
182     DataExtractor strOffsetExt(StringOffsetsSection.Data, LittleEndian, 0);
183     uint32_t offset = 0;
184     uint64_t size = StringOffsetsSection.Data.size();
185     // Ensure that size is a multiple of the size of an entry.
186     if (size & ((uint64_t)(sizeof(uint32_t) - 1))) {
187       OS << "error: size of ." << SectionName << " is not a multiple of "
188          << sizeof(uint32_t) << ".\n";
189       size &= -(uint64_t)sizeof(uint32_t);
190     }
191     DataExtractor StrData(StringSection, LittleEndian, 0);
192     while (offset < size) {
193       OS << format("0x%8.8x: ", offset);
194       uint32_t StringOffset = strOffsetExt.getU32(&offset);
195       OS << format("%8.8x  ", StringOffset);
196       const char *S = StrData.getCStr(&StringOffset);
197       if (S)
198         OS << format("\"%s\"", S);
199       OS << "\n";
200     }
201   }
202 }
203 
204 void DWARFContext::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
205   DIDumpType DumpType = DumpOpts.DumpType;
206   bool DumpEH = DumpOpts.DumpEH;
207   bool SummarizeTypes = DumpOpts.SummarizeTypes;
208 
209   if (DumpType == DIDT_All || DumpType == DIDT_Abbrev) {
210     OS << ".debug_abbrev contents:\n";
211     getDebugAbbrev()->dump(OS);
212   }
213 
214   if (DumpType == DIDT_All || DumpType == DIDT_AbbrevDwo)
215     if (const DWARFDebugAbbrev *D = getDebugAbbrevDWO()) {
216       OS << "\n.debug_abbrev.dwo contents:\n";
217       D->dump(OS);
218     }
219 
220   if (DumpType == DIDT_All || DumpType == DIDT_Info) {
221     OS << "\n.debug_info contents:\n";
222     for (const auto &CU : compile_units())
223       CU->dump(OS, DumpOpts);
224   }
225 
226   if ((DumpType == DIDT_All || DumpType == DIDT_InfoDwo) &&
227       getNumDWOCompileUnits()) {
228     OS << "\n.debug_info.dwo contents:\n";
229     for (const auto &DWOCU : dwo_compile_units())
230       DWOCU->dump(OS, DumpOpts);
231   }
232 
233   if ((DumpType == DIDT_All || DumpType == DIDT_Types) && getNumTypeUnits()) {
234     OS << "\n.debug_types contents:\n";
235     for (const auto &TUS : type_unit_sections())
236       for (const auto &TU : TUS)
237         TU->dump(OS, SummarizeTypes);
238   }
239 
240   if ((DumpType == DIDT_All || DumpType == DIDT_TypesDwo) &&
241       getNumDWOTypeUnits()) {
242     OS << "\n.debug_types.dwo contents:\n";
243     for (const auto &DWOTUS : dwo_type_unit_sections())
244       for (const auto &DWOTU : DWOTUS)
245         DWOTU->dump(OS, SummarizeTypes);
246   }
247 
248   if (DumpType == DIDT_All || DumpType == DIDT_Loc) {
249     OS << "\n.debug_loc contents:\n";
250     getDebugLoc()->dump(OS);
251   }
252 
253   if (DumpType == DIDT_All || DumpType == DIDT_LocDwo) {
254     OS << "\n.debug_loc.dwo contents:\n";
255     getDebugLocDWO()->dump(OS);
256   }
257 
258   if (DumpType == DIDT_All || DumpType == DIDT_Frames) {
259     OS << "\n.debug_frame contents:\n";
260     getDebugFrame()->dump(OS);
261     if (DumpEH) {
262       OS << "\n.eh_frame contents:\n";
263       getEHFrame()->dump(OS);
264     }
265   }
266 
267   if (DumpType == DIDT_All || DumpType == DIDT_Macro) {
268     OS << "\n.debug_macinfo contents:\n";
269     getDebugMacro()->dump(OS);
270   }
271 
272   uint32_t offset = 0;
273   if (DumpType == DIDT_All || DumpType == DIDT_Aranges) {
274     OS << "\n.debug_aranges contents:\n";
275     DataExtractor arangesData(getARangeSection(), isLittleEndian(), 0);
276     DWARFDebugArangeSet set;
277     while (set.extract(arangesData, &offset))
278       set.dump(OS);
279   }
280 
281   uint8_t savedAddressByteSize = 0;
282   if (DumpType == DIDT_All || DumpType == DIDT_Line) {
283     OS << "\n.debug_line contents:\n";
284     for (const auto &CU : compile_units()) {
285       savedAddressByteSize = CU->getAddressByteSize();
286       auto CUDIE = CU->getUnitDIE();
287       if (!CUDIE)
288         continue;
289       if (auto StmtOffset = toSectionOffset(CUDIE.find(DW_AT_stmt_list))) {
290         DataExtractor lineData(getLineSection().Data, isLittleEndian(),
291                                savedAddressByteSize);
292         DWARFDebugLine::LineTable LineTable;
293         uint32_t Offset = *StmtOffset;
294         LineTable.parse(lineData, &getLineSection().Relocs, &Offset);
295         LineTable.dump(OS);
296       }
297     }
298   }
299 
300   if (DumpType == DIDT_All || DumpType == DIDT_CUIndex) {
301     OS << "\n.debug_cu_index contents:\n";
302     getCUIndex().dump(OS);
303   }
304 
305   if (DumpType == DIDT_All || DumpType == DIDT_TUIndex) {
306     OS << "\n.debug_tu_index contents:\n";
307     getTUIndex().dump(OS);
308   }
309 
310   if (DumpType == DIDT_All || DumpType == DIDT_LineDwo) {
311     OS << "\n.debug_line.dwo contents:\n";
312     unsigned stmtOffset = 0;
313     DataExtractor lineData(getLineDWOSection().Data, isLittleEndian(),
314                            savedAddressByteSize);
315     DWARFDebugLine::LineTable LineTable;
316     while (LineTable.Prologue.parse(lineData, &stmtOffset)) {
317       LineTable.dump(OS);
318       LineTable.clear();
319     }
320   }
321 
322   if (DumpType == DIDT_All || DumpType == DIDT_Str) {
323     OS << "\n.debug_str contents:\n";
324     DataExtractor strData(getStringSection(), isLittleEndian(), 0);
325     offset = 0;
326     uint32_t strOffset = 0;
327     while (const char *s = strData.getCStr(&offset)) {
328       OS << format("0x%8.8x: \"%s\"\n", strOffset, s);
329       strOffset = offset;
330     }
331   }
332 
333   if ((DumpType == DIDT_All || DumpType == DIDT_StrDwo) &&
334       !getStringDWOSection().empty()) {
335     OS << "\n.debug_str.dwo contents:\n";
336     DataExtractor strDWOData(getStringDWOSection(), isLittleEndian(), 0);
337     offset = 0;
338     uint32_t strDWOOffset = 0;
339     while (const char *s = strDWOData.getCStr(&offset)) {
340       OS << format("0x%8.8x: \"%s\"\n", strDWOOffset, s);
341       strDWOOffset = offset;
342     }
343   }
344 
345   if (DumpType == DIDT_All || DumpType == DIDT_Ranges) {
346     OS << "\n.debug_ranges contents:\n";
347     // In fact, different compile units may have different address byte
348     // sizes, but for simplicity we just use the address byte size of the last
349     // compile unit (there is no easy and fast way to associate address range
350     // list and the compile unit it describes).
351     DataExtractor rangesData(getRangeSection().Data, isLittleEndian(),
352                              savedAddressByteSize);
353     offset = 0;
354     DWARFDebugRangeList rangeList;
355     while (rangeList.extract(rangesData, &offset, getRangeSection().Relocs))
356       rangeList.dump(OS);
357   }
358 
359   if (DumpType == DIDT_All || DumpType == DIDT_Pubnames)
360     DWARFDebugPubTable(getPubNamesSection(), isLittleEndian(), false)
361         .dump("debug_pubnames", OS);
362 
363   if (DumpType == DIDT_All || DumpType == DIDT_Pubtypes)
364     DWARFDebugPubTable(getPubTypesSection(), isLittleEndian(), false)
365         .dump("debug_pubtypes", OS);
366 
367   if (DumpType == DIDT_All || DumpType == DIDT_GnuPubnames)
368     DWARFDebugPubTable(getGnuPubNamesSection(), isLittleEndian(),
369                        true /* GnuStyle */)
370         .dump("debug_gnu_pubnames", OS);
371 
372   if (DumpType == DIDT_All || DumpType == DIDT_GnuPubtypes)
373     DWARFDebugPubTable(getGnuPubTypesSection(), isLittleEndian(),
374                        true /* GnuStyle */)
375         .dump("debug_gnu_pubtypes", OS);
376 
377   if (DumpType == DIDT_All || DumpType == DIDT_StrOffsets)
378     dumpStringOffsetsSection(OS, "debug_str_offsets", getStringOffsetSection(),
379                              getStringSection(), isLittleEndian(),
380                              getMaxVersion());
381 
382   if (DumpType == DIDT_All || DumpType == DIDT_StrOffsetsDwo) {
383     dumpStringOffsetsSection(OS, "debug_str_offsets.dwo",
384                              getStringOffsetDWOSection(), getStringDWOSection(),
385                              isLittleEndian(), getMaxVersion());
386   }
387 
388   if ((DumpType == DIDT_All || DumpType == DIDT_GdbIndex) &&
389       !getGdbIndexSection().empty()) {
390     OS << "\n.gnu_index contents:\n";
391     getGdbIndex().dump(OS);
392   }
393 
394   if (DumpType == DIDT_All || DumpType == DIDT_AppleNames)
395     dumpAccelSection(OS, "apple_names", getAppleNamesSection(),
396                      getStringSection(), isLittleEndian());
397 
398   if (DumpType == DIDT_All || DumpType == DIDT_AppleTypes)
399     dumpAccelSection(OS, "apple_types", getAppleTypesSection(),
400                      getStringSection(), isLittleEndian());
401 
402   if (DumpType == DIDT_All || DumpType == DIDT_AppleNamespaces)
403     dumpAccelSection(OS, "apple_namespaces", getAppleNamespacesSection(),
404                      getStringSection(), isLittleEndian());
405 
406   if (DumpType == DIDT_All || DumpType == DIDT_AppleObjC)
407     dumpAccelSection(OS, "apple_objc", getAppleObjCSection(),
408                      getStringSection(), isLittleEndian());
409 }
410 
411 DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) {
412   // FIXME: Improve this for the case where this DWO file is really a DWP file
413   // with an index - use the index for lookup instead of a linear search.
414   for (const auto &DWOCU : dwo_compile_units())
415     if (DWOCU->getDWOId() == Hash)
416       return DWOCU.get();
417   return nullptr;
418 }
419 
420 DWARFDie DWARFContext::getDIEForOffset(uint32_t Offset) {
421   parseCompileUnits();
422   if (auto *CU = CUs.getUnitForOffset(Offset))
423     return CU->getDIEForOffset(Offset);
424   return DWARFDie();
425 }
426 
427 bool DWARFContext::verify(raw_ostream &OS, DIDumpType DumpType) {
428   bool Success = true;
429   DWARFVerifier verifier(OS, *this);
430   if (DumpType == DIDT_All || DumpType == DIDT_Info) {
431     if (!verifier.handleDebugInfo())
432       Success = false;
433   }
434   if (DumpType == DIDT_All || DumpType == DIDT_Line) {
435     if (!verifier.handleDebugLine())
436       Success = false;
437   }
438   if (DumpType == DIDT_All || DumpType == DIDT_AppleNames) {
439     if (!verifier.handleAppleNames())
440       Success = false;
441   }
442   return Success;
443 }
444 
445 const DWARFUnitIndex &DWARFContext::getCUIndex() {
446   if (CUIndex)
447     return *CUIndex;
448 
449   DataExtractor CUIndexData(getCUIndexSection(), isLittleEndian(), 0);
450 
451   CUIndex = llvm::make_unique<DWARFUnitIndex>(DW_SECT_INFO);
452   CUIndex->parse(CUIndexData);
453   return *CUIndex;
454 }
455 
456 const DWARFUnitIndex &DWARFContext::getTUIndex() {
457   if (TUIndex)
458     return *TUIndex;
459 
460   DataExtractor TUIndexData(getTUIndexSection(), isLittleEndian(), 0);
461 
462   TUIndex = llvm::make_unique<DWARFUnitIndex>(DW_SECT_TYPES);
463   TUIndex->parse(TUIndexData);
464   return *TUIndex;
465 }
466 
467 DWARFGdbIndex &DWARFContext::getGdbIndex() {
468   if (GdbIndex)
469     return *GdbIndex;
470 
471   DataExtractor GdbIndexData(getGdbIndexSection(), true /*LE*/, 0);
472   GdbIndex = llvm::make_unique<DWARFGdbIndex>();
473   GdbIndex->parse(GdbIndexData);
474   return *GdbIndex;
475 }
476 
477 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
478   if (Abbrev)
479     return Abbrev.get();
480 
481   DataExtractor abbrData(getAbbrevSection(), isLittleEndian(), 0);
482 
483   Abbrev.reset(new DWARFDebugAbbrev());
484   Abbrev->extract(abbrData);
485   return Abbrev.get();
486 }
487 
488 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() {
489   if (AbbrevDWO)
490     return AbbrevDWO.get();
491 
492   DataExtractor abbrData(getAbbrevDWOSection(), isLittleEndian(), 0);
493   AbbrevDWO.reset(new DWARFDebugAbbrev());
494   AbbrevDWO->extract(abbrData);
495   return AbbrevDWO.get();
496 }
497 
498 const DWARFDebugLoc *DWARFContext::getDebugLoc() {
499   if (Loc)
500     return Loc.get();
501 
502   DataExtractor LocData(getLocSection().Data, isLittleEndian(), 0);
503   Loc.reset(new DWARFDebugLoc(getLocSection().Relocs));
504   // assume all compile units have the same address byte size
505   if (getNumCompileUnits())
506     Loc->parse(LocData, getCompileUnitAtIndex(0)->getAddressByteSize());
507   return Loc.get();
508 }
509 
510 const DWARFDebugLocDWO *DWARFContext::getDebugLocDWO() {
511   if (LocDWO)
512     return LocDWO.get();
513 
514   DataExtractor LocData(getLocDWOSection().Data, isLittleEndian(), 0);
515   LocDWO.reset(new DWARFDebugLocDWO());
516   LocDWO->parse(LocData);
517   return LocDWO.get();
518 }
519 
520 const DWARFDebugAranges *DWARFContext::getDebugAranges() {
521   if (Aranges)
522     return Aranges.get();
523 
524   Aranges.reset(new DWARFDebugAranges());
525   Aranges->generate(this);
526   return Aranges.get();
527 }
528 
529 const DWARFDebugFrame *DWARFContext::getDebugFrame() {
530   if (DebugFrame)
531     return DebugFrame.get();
532 
533   // There's a "bug" in the DWARFv3 standard with respect to the target address
534   // size within debug frame sections. While DWARF is supposed to be independent
535   // of its container, FDEs have fields with size being "target address size",
536   // which isn't specified in DWARF in general. It's only specified for CUs, but
537   // .eh_frame can appear without a .debug_info section. Follow the example of
538   // other tools (libdwarf) and extract this from the container (ObjectFile
539   // provides this information). This problem is fixed in DWARFv4
540   // See this dwarf-discuss discussion for more details:
541   // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
542   DataExtractor debugFrameData(getDebugFrameSection(), isLittleEndian(),
543                                getAddressSize());
544   DebugFrame.reset(new DWARFDebugFrame(false /* IsEH */));
545   DebugFrame->parse(debugFrameData);
546   return DebugFrame.get();
547 }
548 
549 const DWARFDebugFrame *DWARFContext::getEHFrame() {
550   if (EHFrame)
551     return EHFrame.get();
552 
553   DataExtractor debugFrameData(getEHFrameSection(), isLittleEndian(),
554                                getAddressSize());
555   DebugFrame.reset(new DWARFDebugFrame(true /* IsEH */));
556   DebugFrame->parse(debugFrameData);
557   return DebugFrame.get();
558 }
559 
560 const DWARFDebugMacro *DWARFContext::getDebugMacro() {
561   if (Macro)
562     return Macro.get();
563 
564   DataExtractor MacinfoData(getMacinfoSection(), isLittleEndian(), 0);
565   Macro.reset(new DWARFDebugMacro());
566   Macro->parse(MacinfoData);
567   return Macro.get();
568 }
569 
570 const DWARFLineTable *
571 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
572   if (!Line)
573     Line.reset(new DWARFDebugLine(&getLineSection().Relocs));
574 
575   auto UnitDIE = U->getUnitDIE();
576   if (!UnitDIE)
577     return nullptr;
578 
579   auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list));
580   if (!Offset)
581     return nullptr; // No line table for this compile unit.
582 
583   uint32_t stmtOffset = *Offset + U->getLineTableOffset();
584   // See if the line table is cached.
585   if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
586     return lt;
587 
588   // Make sure the offset is good before we try to parse.
589   if (stmtOffset >= U->getLineSection().size())
590     return nullptr;
591 
592   // We have to parse it first.
593   DataExtractor lineData(U->getLineSection(), isLittleEndian(),
594                          U->getAddressByteSize());
595   return Line->getOrParseLineTable(lineData, stmtOffset);
596 }
597 
598 void DWARFContext::parseCompileUnits() {
599   CUs.parse(*this, getInfoSection());
600 }
601 
602 void DWARFContext::parseTypeUnits() {
603   if (!TUs.empty())
604     return;
605   for (const auto &I : getTypesSections()) {
606     TUs.emplace_back();
607     TUs.back().parse(*this, I.second);
608   }
609 }
610 
611 void DWARFContext::parseDWOCompileUnits() {
612   DWOCUs.parseDWO(*this, getInfoDWOSection());
613 }
614 
615 void DWARFContext::parseDWOTypeUnits() {
616   if (!DWOTUs.empty())
617     return;
618   for (const auto &I : getTypesDWOSections()) {
619     DWOTUs.emplace_back();
620     DWOTUs.back().parseDWO(*this, I.second);
621   }
622 }
623 
624 DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint32_t Offset) {
625   parseCompileUnits();
626   return CUs.getUnitForOffset(Offset);
627 }
628 
629 DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
630   // First, get the offset of the compile unit.
631   uint32_t CUOffset = getDebugAranges()->findAddress(Address);
632   // Retrieve the compile unit.
633   return getCompileUnitForOffset(CUOffset);
634 }
635 
636 static bool getFunctionNameAndStartLineForAddress(DWARFCompileUnit *CU,
637                                                   uint64_t Address,
638                                                   FunctionNameKind Kind,
639                                                   std::string &FunctionName,
640                                                   uint32_t &StartLine) {
641   // The address may correspond to instruction in some inlined function,
642   // so we have to build the chain of inlined functions and take the
643   // name of the topmost function in it.
644   SmallVector<DWARFDie, 4> InlinedChain;
645   CU->getInlinedChainForAddress(Address, InlinedChain);
646   if (InlinedChain.empty())
647     return false;
648 
649   const DWARFDie &DIE = InlinedChain[0];
650   bool FoundResult = false;
651   const char *Name = nullptr;
652   if (Kind != FunctionNameKind::None && (Name = DIE.getSubroutineName(Kind))) {
653     FunctionName = Name;
654     FoundResult = true;
655   }
656   if (auto DeclLineResult = DIE.getDeclLine()) {
657     StartLine = DeclLineResult;
658     FoundResult = true;
659   }
660 
661   return FoundResult;
662 }
663 
664 DILineInfo DWARFContext::getLineInfoForAddress(uint64_t Address,
665                                                DILineInfoSpecifier Spec) {
666   DILineInfo Result;
667 
668   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
669   if (!CU)
670     return Result;
671   getFunctionNameAndStartLineForAddress(CU, Address, Spec.FNKind,
672                                         Result.FunctionName,
673                                         Result.StartLine);
674   if (Spec.FLIKind != FileLineInfoKind::None) {
675     if (const DWARFLineTable *LineTable = getLineTableForUnit(CU))
676       LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
677                                            Spec.FLIKind, Result);
678   }
679   return Result;
680 }
681 
682 DILineInfoTable
683 DWARFContext::getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
684                                          DILineInfoSpecifier Spec) {
685   DILineInfoTable  Lines;
686   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
687   if (!CU)
688     return Lines;
689 
690   std::string FunctionName = "<invalid>";
691   uint32_t StartLine = 0;
692   getFunctionNameAndStartLineForAddress(CU, Address, Spec.FNKind, FunctionName,
693                                         StartLine);
694 
695   // If the Specifier says we don't need FileLineInfo, just
696   // return the top-most function at the starting address.
697   if (Spec.FLIKind == FileLineInfoKind::None) {
698     DILineInfo Result;
699     Result.FunctionName = FunctionName;
700     Result.StartLine = StartLine;
701     Lines.push_back(std::make_pair(Address, Result));
702     return Lines;
703   }
704 
705   const DWARFLineTable *LineTable = getLineTableForUnit(CU);
706 
707   // Get the index of row we're looking for in the line table.
708   std::vector<uint32_t> RowVector;
709   if (!LineTable->lookupAddressRange(Address, Size, RowVector))
710     return Lines;
711 
712   for (uint32_t RowIndex : RowVector) {
713     // Take file number and line/column from the row.
714     const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
715     DILineInfo Result;
716     LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(),
717                                   Spec.FLIKind, Result.FileName);
718     Result.FunctionName = FunctionName;
719     Result.Line = Row.Line;
720     Result.Column = Row.Column;
721     Result.StartLine = StartLine;
722     Lines.push_back(std::make_pair(Row.Address, Result));
723   }
724 
725   return Lines;
726 }
727 
728 DIInliningInfo
729 DWARFContext::getInliningInfoForAddress(uint64_t Address,
730                                         DILineInfoSpecifier Spec) {
731   DIInliningInfo InliningInfo;
732 
733   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
734   if (!CU)
735     return InliningInfo;
736 
737   const DWARFLineTable *LineTable = nullptr;
738   SmallVector<DWARFDie, 4> InlinedChain;
739   CU->getInlinedChainForAddress(Address, InlinedChain);
740   if (InlinedChain.size() == 0) {
741     // If there is no DIE for address (e.g. it is in unavailable .dwo file),
742     // try to at least get file/line info from symbol table.
743     if (Spec.FLIKind != FileLineInfoKind::None) {
744       DILineInfo Frame;
745       LineTable = getLineTableForUnit(CU);
746       if (LineTable &&
747           LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
748                                                Spec.FLIKind, Frame))
749         InliningInfo.addFrame(Frame);
750     }
751     return InliningInfo;
752   }
753 
754   uint32_t CallFile = 0, CallLine = 0, CallColumn = 0, CallDiscriminator = 0;
755   for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) {
756     DWARFDie &FunctionDIE = InlinedChain[i];
757     DILineInfo Frame;
758     // Get function name if necessary.
759     if (const char *Name = FunctionDIE.getSubroutineName(Spec.FNKind))
760       Frame.FunctionName = Name;
761     if (auto DeclLineResult = FunctionDIE.getDeclLine())
762       Frame.StartLine = DeclLineResult;
763     if (Spec.FLIKind != FileLineInfoKind::None) {
764       if (i == 0) {
765         // For the topmost frame, initialize the line table of this
766         // compile unit and fetch file/line info from it.
767         LineTable = getLineTableForUnit(CU);
768         // For the topmost routine, get file/line info from line table.
769         if (LineTable)
770           LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
771                                                Spec.FLIKind, Frame);
772       } else {
773         // Otherwise, use call file, call line and call column from
774         // previous DIE in inlined chain.
775         if (LineTable)
776           LineTable->getFileNameByIndex(CallFile, CU->getCompilationDir(),
777                                         Spec.FLIKind, Frame.FileName);
778         Frame.Line = CallLine;
779         Frame.Column = CallColumn;
780         Frame.Discriminator = CallDiscriminator;
781       }
782       // Get call file/line/column of a current DIE.
783       if (i + 1 < n) {
784         FunctionDIE.getCallerFrame(CallFile, CallLine, CallColumn,
785                                    CallDiscriminator);
786       }
787     }
788     InliningInfo.addFrame(Frame);
789   }
790   return InliningInfo;
791 }
792 
793 std::shared_ptr<DWARFContext>
794 DWARFContext::getDWOContext(StringRef AbsolutePath) {
795   if (auto S = DWP.lock()) {
796     DWARFContext *Ctxt = S->Context.get();
797     return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
798   }
799 
800   std::weak_ptr<DWOFile> *Entry = &DWOFiles[AbsolutePath];
801 
802   if (auto S = Entry->lock()) {
803     DWARFContext *Ctxt = S->Context.get();
804     return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
805   }
806 
807   SmallString<128> DWPName;
808   Expected<OwningBinary<ObjectFile>> Obj = [&] {
809     if (!CheckedForDWP) {
810       (getFileName() + ".dwp").toVector(DWPName);
811       auto Obj = object::ObjectFile::createObjectFile(DWPName);
812       if (Obj) {
813         Entry = &DWP;
814         return Obj;
815       } else {
816         CheckedForDWP = true;
817         // TODO: Should this error be handled (maybe in a high verbosity mode)
818         // before falling back to .dwo files?
819         consumeError(Obj.takeError());
820       }
821     }
822 
823     return object::ObjectFile::createObjectFile(AbsolutePath);
824   }();
825 
826   if (!Obj) {
827     // TODO: Actually report errors helpfully.
828     consumeError(Obj.takeError());
829     return nullptr;
830   }
831 
832   auto S = std::make_shared<DWOFile>();
833   S->File = std::move(Obj.get());
834   S->Context = llvm::make_unique<DWARFContextInMemory>(*S->File.getBinary());
835   *Entry = S;
836   auto *Ctxt = S->Context.get();
837   return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
838 }
839 
840 static Error createError(const Twine &Reason, llvm::Error E) {
841   return make_error<StringError>(Reason + toString(std::move(E)),
842                                  inconvertibleErrorCode());
843 }
844 
845 /// SymInfo contains information about symbol: it's address
846 /// and section index which is -1LL for absolute symbols.
847 struct SymInfo {
848   uint64_t Address;
849   uint64_t SectionIndex;
850 };
851 
852 /// Returns the address of symbol relocation used against and a section index.
853 /// Used for futher relocations computation. Symbol's section load address is
854 static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj,
855                                        const RelocationRef &Reloc,
856                                        const LoadedObjectInfo *L,
857                                        std::map<SymbolRef, SymInfo> &Cache) {
858   SymInfo Ret = {0, (uint64_t)-1LL};
859   object::section_iterator RSec = Obj.section_end();
860   object::symbol_iterator Sym = Reloc.getSymbol();
861 
862   std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end();
863   // First calculate the address of the symbol or section as it appears
864   // in the object file
865   if (Sym != Obj.symbol_end()) {
866     bool New;
867     std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}});
868     if (!New)
869       return CacheIt->second;
870 
871     Expected<uint64_t> SymAddrOrErr = Sym->getAddress();
872     if (!SymAddrOrErr)
873       return createError("error: failed to compute symbol address: ",
874                          SymAddrOrErr.takeError());
875 
876     // Also remember what section this symbol is in for later
877     auto SectOrErr = Sym->getSection();
878     if (!SectOrErr)
879       return createError("error: failed to get symbol section: ",
880                          SectOrErr.takeError());
881 
882     RSec = *SectOrErr;
883     Ret.Address = *SymAddrOrErr;
884   } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) {
885     RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl());
886     Ret.Address = RSec->getAddress();
887   }
888 
889   if (RSec != Obj.section_end())
890     Ret.SectionIndex = RSec->getIndex();
891 
892   // If we are given load addresses for the sections, we need to adjust:
893   // SymAddr = (Address of Symbol Or Section in File) -
894   //           (Address of Section in File) +
895   //           (Load Address of Section)
896   // RSec is now either the section being targeted or the section
897   // containing the symbol being targeted. In either case,
898   // we need to perform the same computation.
899   if (L && RSec != Obj.section_end())
900     if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(*RSec))
901       Ret.Address += SectionLoadAddress - RSec->getAddress();
902 
903   if (CacheIt != Cache.end())
904     CacheIt->second = Ret;
905 
906   return Ret;
907 }
908 
909 static bool isRelocScattered(const object::ObjectFile &Obj,
910                              const RelocationRef &Reloc) {
911   const MachOObjectFile *MachObj = dyn_cast<MachOObjectFile>(&Obj);
912   if (!MachObj)
913     return false;
914   // MachO also has relocations that point to sections and
915   // scattered relocations.
916   auto RelocInfo = MachObj->getRelocation(Reloc.getRawDataRefImpl());
917   return MachObj->isRelocationScattered(RelocInfo);
918 }
919 
920 Error DWARFContextInMemory::maybeDecompress(const SectionRef &Sec,
921                                             StringRef Name, StringRef &Data) {
922   if (!Decompressor::isCompressed(Sec))
923     return Error::success();
924 
925   Expected<Decompressor> Decompressor =
926       Decompressor::create(Name, Data, IsLittleEndian, AddressSize == 8);
927   if (!Decompressor)
928     return Decompressor.takeError();
929 
930   SmallString<32> Out;
931   if (auto Err = Decompressor->resizeAndDecompress(Out))
932     return Err;
933 
934   UncompressedSections.emplace_back(std::move(Out));
935   Data = UncompressedSections.back();
936 
937   return Error::success();
938 }
939 
940 DWARFContextInMemory::DWARFContextInMemory(const object::ObjectFile &Obj,
941                                            const LoadedObjectInfo *L)
942     : FileName(Obj.getFileName()), IsLittleEndian(Obj.isLittleEndian()),
943       AddressSize(Obj.getBytesInAddress()) {
944   for (const SectionRef &Section : Obj.sections()) {
945     StringRef name;
946     Section.getName(name);
947     // Skip BSS and Virtual sections, they aren't interesting.
948     bool IsBSS = Section.isBSS();
949     if (IsBSS)
950       continue;
951     bool IsVirtual = Section.isVirtual();
952     if (IsVirtual)
953       continue;
954     StringRef data;
955 
956     section_iterator RelocatedSection = Section.getRelocatedSection();
957     // Try to obtain an already relocated version of this section.
958     // Else use the unrelocated section from the object file. We'll have to
959     // apply relocations ourselves later.
960     if (!L || !L->getLoadedSectionContents(*RelocatedSection, data))
961       Section.getContents(data);
962 
963     if (auto Err = maybeDecompress(Section, name, data)) {
964       errs() << "error: failed to decompress '" + name + "', " +
965                     toString(std::move(Err))
966              << '\n';
967       continue;
968     }
969 
970     // Compressed sections names in GNU style starts from ".z",
971     // at this point section is decompressed and we drop compression prefix.
972     name = name.substr(
973         name.find_first_not_of("._z")); // Skip ".", "z" and "_" prefixes.
974 
975     if (StringRef *SectionData = MapSectionToMember(name)) {
976       *SectionData = data;
977       if (name == "debug_ranges") {
978         // FIXME: Use the other dwo range section when we emit it.
979         RangeDWOSection.Data = data;
980       }
981     } else if (name == "debug_types") {
982       // Find debug_types data by section rather than name as there are
983       // multiple, comdat grouped, debug_types sections.
984       TypesSections[Section].Data = data;
985     } else if (name == "debug_types.dwo") {
986       TypesDWOSections[Section].Data = data;
987     }
988 
989     // Map platform specific debug section names to DWARF standard section
990     // names.
991     name = Obj.mapDebugSectionName(name);
992 
993     if (RelocatedSection == Obj.section_end())
994       continue;
995 
996     StringRef RelSecName;
997     StringRef RelSecData;
998     RelocatedSection->getName(RelSecName);
999 
1000     // If the section we're relocating was relocated already by the JIT,
1001     // then we used the relocated version above, so we do not need to process
1002     // relocations for it now.
1003     if (L && L->getLoadedSectionContents(*RelocatedSection, RelSecData))
1004       continue;
1005 
1006     // In Mach-o files, the relocations do not need to be applied if
1007     // there is no load offset to apply. The value read at the
1008     // relocation point already factors in the section address
1009     // (actually applying the relocations will produce wrong results
1010     // as the section address will be added twice).
1011     if (!L && isa<MachOObjectFile>(&Obj))
1012       continue;
1013 
1014     RelSecName = RelSecName.substr(
1015         RelSecName.find_first_not_of("._z")); // Skip . and _ prefixes.
1016 
1017     // TODO: Add support for relocations in other sections as needed.
1018     // Record relocations for the debug_info and debug_line sections.
1019     RelocAddrMap *Map =
1020         StringSwitch<RelocAddrMap *>(RelSecName)
1021             .Case("debug_info", &InfoSection.Relocs)
1022             .Case("debug_loc", &LocSection.Relocs)
1023             .Case("debug_info.dwo", &InfoDWOSection.Relocs)
1024             .Case("debug_line", &LineSection.Relocs)
1025             .Case("debug_str_offsets", &StringOffsetSection.Relocs)
1026             .Case("debug_ranges", &RangeSection.Relocs)
1027             .Case("debug_addr", &AddrSection.Relocs)
1028             .Case("apple_names", &AppleNamesSection.Relocs)
1029             .Case("apple_types", &AppleTypesSection.Relocs)
1030             .Case("apple_namespaces", &AppleNamespacesSection.Relocs)
1031             .Case("apple_namespac", &AppleNamespacesSection.Relocs)
1032             .Case("apple_objc", &AppleObjCSection.Relocs)
1033             .Default(nullptr);
1034     if (!Map) {
1035       // Find debug_types relocs by section rather than name as there are
1036       // multiple, comdat grouped, debug_types sections.
1037       if (RelSecName == "debug_types")
1038         Map = &TypesSections[*RelocatedSection].Relocs;
1039       else if (RelSecName == "debug_types.dwo")
1040         Map = &TypesDWOSections[*RelocatedSection].Relocs;
1041       else
1042         continue;
1043     }
1044 
1045     if (Section.relocation_begin() == Section.relocation_end())
1046       continue;
1047 
1048     // Symbol to [address, section index] cache mapping.
1049     std::map<SymbolRef, SymInfo> AddrCache;
1050     for (const RelocationRef &Reloc : Section.relocations()) {
1051       // FIXME: it's not clear how to correctly handle scattered
1052       // relocations.
1053       if (isRelocScattered(Obj, Reloc))
1054         continue;
1055 
1056       Expected<SymInfo> SymInfoOrErr = getSymbolInfo(Obj, Reloc, L, AddrCache);
1057       if (!SymInfoOrErr) {
1058         errs() << toString(SymInfoOrErr.takeError()) << '\n';
1059         continue;
1060       }
1061 
1062       object::RelocVisitor V(Obj);
1063       uint64_t Val = V.visit(Reloc.getType(), Reloc, SymInfoOrErr->Address);
1064       if (V.error()) {
1065         SmallString<32> Name;
1066         Reloc.getTypeName(Name);
1067         errs() << "error: failed to compute relocation: " << Name << "\n";
1068         continue;
1069       }
1070       RelocAddrEntry Rel = {SymInfoOrErr->SectionIndex, Val};
1071       Map->insert({Reloc.getOffset(), Rel});
1072     }
1073   }
1074 }
1075 
1076 DWARFContextInMemory::DWARFContextInMemory(
1077     const StringMap<std::unique_ptr<MemoryBuffer>> &Sections, uint8_t AddrSize,
1078     bool isLittleEndian)
1079     : IsLittleEndian(isLittleEndian), AddressSize(AddrSize) {
1080   for (const auto &SecIt : Sections) {
1081     if (StringRef *SectionData = MapSectionToMember(SecIt.first()))
1082       *SectionData = SecIt.second->getBuffer();
1083   }
1084 }
1085 
1086 StringRef *DWARFContextInMemory::MapSectionToMember(StringRef Name) {
1087   return StringSwitch<StringRef *>(Name)
1088       .Case("debug_info", &InfoSection.Data)
1089       .Case("debug_abbrev", &AbbrevSection)
1090       .Case("debug_loc", &LocSection.Data)
1091       .Case("debug_line", &LineSection.Data)
1092       .Case("debug_aranges", &ARangeSection)
1093       .Case("debug_frame", &DebugFrameSection)
1094       .Case("eh_frame", &EHFrameSection)
1095       .Case("debug_str", &StringSection)
1096       .Case("debug_str_offsets", &StringOffsetSection.Data)
1097       .Case("debug_ranges", &RangeSection.Data)
1098       .Case("debug_macinfo", &MacinfoSection)
1099       .Case("debug_pubnames", &PubNamesSection)
1100       .Case("debug_pubtypes", &PubTypesSection)
1101       .Case("debug_gnu_pubnames", &GnuPubNamesSection)
1102       .Case("debug_gnu_pubtypes", &GnuPubTypesSection)
1103       .Case("debug_info.dwo", &InfoDWOSection.Data)
1104       .Case("debug_abbrev.dwo", &AbbrevDWOSection)
1105       .Case("debug_loc.dwo", &LocDWOSection.Data)
1106       .Case("debug_line.dwo", &LineDWOSection.Data)
1107       .Case("debug_str.dwo", &StringDWOSection)
1108       .Case("debug_str_offsets.dwo", &StringOffsetDWOSection.Data)
1109       .Case("debug_addr", &AddrSection.Data)
1110       .Case("apple_names", &AppleNamesSection.Data)
1111       .Case("apple_types", &AppleTypesSection.Data)
1112       .Case("apple_namespaces", &AppleNamespacesSection.Data)
1113       .Case("apple_namespac", &AppleNamespacesSection.Data)
1114       .Case("apple_objc", &AppleObjCSection.Data)
1115       .Case("debug_cu_index", &CUIndexSection)
1116       .Case("debug_tu_index", &TUIndexSection)
1117       .Case("gdb_index", &GdbIndexSection)
1118       // Any more debug info sections go here.
1119       .Default(nullptr);
1120 }
1121 
1122 void DWARFContextInMemory::anchor() {}
1123