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