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