1 //===- DWARFContext.cpp ---------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/ADT/SmallString.h"
12 #include "llvm/ADT/SmallVector.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/ADT/StringSwitch.h"
15 #include "llvm/BinaryFormat/Dwarf.h"
16 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
17 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
18 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
19 #include "llvm/DebugInfo/DWARF/DWARFDebugAddr.h"
20 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
21 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
22 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
23 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
24 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
25 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
26 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
27 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
28 #include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
29 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
30 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
31 #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
32 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
33 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
34 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
35 #include "llvm/MC/MCRegisterInfo.h"
36 #include "llvm/Object/Decompressor.h"
37 #include "llvm/Object/MachO.h"
38 #include "llvm/Object/ObjectFile.h"
39 #include "llvm/Object/RelocationResolver.h"
40 #include "llvm/Support/Casting.h"
41 #include "llvm/Support/DataExtractor.h"
42 #include "llvm/Support/Error.h"
43 #include "llvm/Support/Format.h"
44 #include "llvm/Support/LEB128.h"
45 #include "llvm/Support/MemoryBuffer.h"
46 #include "llvm/Support/Path.h"
47 #include "llvm/Support/TargetRegistry.h"
48 #include "llvm/Support/raw_ostream.h"
49 #include <algorithm>
50 #include <cstdint>
51 #include <deque>
52 #include <map>
53 #include <string>
54 #include <utility>
55 #include <vector>
56
57 using namespace llvm;
58 using namespace dwarf;
59 using namespace object;
60
61 #define DEBUG_TYPE "dwarf"
62
63 using DWARFLineTable = DWARFDebugLine::LineTable;
64 using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind;
65 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
66
DWARFContext(std::unique_ptr<const DWARFObject> DObj,std::string DWPName,std::function<void (Error)> RecoverableErrorHandler,std::function<void (Error)> WarningHandler)67 DWARFContext::DWARFContext(std::unique_ptr<const DWARFObject> DObj,
68 std::string DWPName,
69 std::function<void(Error)> RecoverableErrorHandler,
70 std::function<void(Error)> WarningHandler)
71 : DIContext(CK_DWARF), DWPName(std::move(DWPName)),
72 RecoverableErrorHandler(RecoverableErrorHandler),
73 WarningHandler(WarningHandler), DObj(std::move(DObj)) {}
74
75 DWARFContext::~DWARFContext() = default;
76
77 /// Dump the UUID load command.
dumpUUID(raw_ostream & OS,const ObjectFile & Obj)78 static void dumpUUID(raw_ostream &OS, const ObjectFile &Obj) {
79 auto *MachO = dyn_cast<MachOObjectFile>(&Obj);
80 if (!MachO)
81 return;
82 for (auto LC : MachO->load_commands()) {
83 raw_ostream::uuid_t UUID;
84 if (LC.C.cmd == MachO::LC_UUID) {
85 if (LC.C.cmdsize < sizeof(UUID) + sizeof(LC.C)) {
86 OS << "error: UUID load command is too short.\n";
87 return;
88 }
89 OS << "UUID: ";
90 memcpy(&UUID, LC.Ptr+sizeof(LC.C), sizeof(UUID));
91 OS.write_uuid(UUID);
92 Triple T = MachO->getArchTriple();
93 OS << " (" << T.getArchName() << ')';
94 OS << ' ' << MachO->getFileName() << '\n';
95 }
96 }
97 }
98
99 using ContributionCollection =
100 std::vector<Optional<StrOffsetsContributionDescriptor>>;
101
102 // Collect all the contributions to the string offsets table from all units,
103 // sort them by their starting offsets and remove duplicates.
104 static ContributionCollection
collectContributionData(DWARFContext::unit_iterator_range Units)105 collectContributionData(DWARFContext::unit_iterator_range Units) {
106 ContributionCollection Contributions;
107 for (const auto &U : Units)
108 if (const auto &C = U->getStringOffsetsTableContribution())
109 Contributions.push_back(C);
110 // Sort the contributions so that any invalid ones are placed at
111 // the start of the contributions vector. This way they are reported
112 // first.
113 llvm::sort(Contributions,
114 [](const Optional<StrOffsetsContributionDescriptor> &L,
115 const Optional<StrOffsetsContributionDescriptor> &R) {
116 if (L && R)
117 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
136 // Dump a DWARF string offsets section. This may be a DWARF v5 formatted
137 // string offsets section, where each compile or type unit contributes a
138 // number of entries (string offsets), with each contribution preceded by
139 // a header containing size and version number. Alternatively, it may be a
140 // monolithic series of string offsets, as generated by the pre-DWARF v5
141 // implementation of split DWARF; however, in that case we still need to
142 // collect contributions of units because the size of the offsets (4 or 8
143 // bytes) depends on the format of the referencing unit (DWARF32 or DWARF64).
dumpStringOffsetsSection(raw_ostream & OS,DIDumpOptions DumpOpts,StringRef SectionName,const DWARFObject & Obj,const DWARFSection & StringOffsetsSection,StringRef StringSection,DWARFContext::unit_iterator_range Units,bool LittleEndian)144 static void dumpStringOffsetsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
145 StringRef SectionName,
146 const DWARFObject &Obj,
147 const DWARFSection &StringOffsetsSection,
148 StringRef StringSection,
149 DWARFContext::unit_iterator_range Units,
150 bool LittleEndian) {
151 auto Contributions = collectContributionData(Units);
152 DWARFDataExtractor StrOffsetExt(Obj, StringOffsetsSection, LittleEndian, 0);
153 DataExtractor StrData(StringSection, LittleEndian, 0);
154 uint64_t SectionSize = StringOffsetsSection.Data.size();
155 uint64_t Offset = 0;
156 for (auto &Contribution : Contributions) {
157 // Report an ill-formed contribution.
158 if (!Contribution) {
159 OS << "error: invalid contribution to string offsets table in section ."
160 << SectionName << ".\n";
161 return;
162 }
163
164 dwarf::DwarfFormat Format = Contribution->getFormat();
165 int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(Format);
166 uint16_t Version = Contribution->getVersion();
167 uint64_t ContributionHeader = Contribution->Base;
168 // In DWARF v5 there is a contribution header that immediately precedes
169 // the string offsets base (the location we have previously retrieved from
170 // the CU DIE's DW_AT_str_offsets attribute). The header is located either
171 // 8 or 16 bytes before the base, depending on the contribution's format.
172 if (Version >= 5)
173 ContributionHeader -= Format == DWARF32 ? 8 : 16;
174
175 // Detect overlapping contributions.
176 if (Offset > ContributionHeader) {
177 DumpOpts.RecoverableErrorHandler(createStringError(
178 errc::invalid_argument,
179 "overlapping contributions to string offsets table in section .%s.",
180 SectionName.data()));
181 }
182 // Report a gap in the table.
183 if (Offset < ContributionHeader) {
184 OS << format("0x%8.8" PRIx64 ": Gap, length = ", Offset);
185 OS << (ContributionHeader - Offset) << "\n";
186 }
187 OS << format("0x%8.8" PRIx64 ": ", ContributionHeader);
188 // In DWARF v5 the contribution size in the descriptor does not equal
189 // the originally encoded length (it does not contain the length of the
190 // version field and the padding, a total of 4 bytes). Add them back in
191 // for reporting.
192 OS << "Contribution size = " << (Contribution->Size + (Version < 5 ? 0 : 4))
193 << ", Format = " << dwarf::FormatString(Format)
194 << ", Version = " << Version << "\n";
195
196 Offset = Contribution->Base;
197 unsigned EntrySize = Contribution->getDwarfOffsetByteSize();
198 while (Offset - Contribution->Base < Contribution->Size) {
199 OS << format("0x%8.8" PRIx64 ": ", Offset);
200 uint64_t StringOffset =
201 StrOffsetExt.getRelocatedValue(EntrySize, &Offset);
202 OS << format("%0*" PRIx64 " ", OffsetDumpWidth, StringOffset);
203 const char *S = StrData.getCStr(&StringOffset);
204 if (S)
205 OS << format("\"%s\"", S);
206 OS << "\n";
207 }
208 }
209 // Report a gap at the end of the table.
210 if (Offset < SectionSize) {
211 OS << format("0x%8.8" PRIx64 ": Gap, length = ", Offset);
212 OS << (SectionSize - Offset) << "\n";
213 }
214 }
215
216 // Dump the .debug_addr section.
dumpAddrSection(raw_ostream & OS,DWARFDataExtractor & AddrData,DIDumpOptions DumpOpts,uint16_t Version,uint8_t AddrSize)217 static void dumpAddrSection(raw_ostream &OS, DWARFDataExtractor &AddrData,
218 DIDumpOptions DumpOpts, uint16_t Version,
219 uint8_t AddrSize) {
220 uint64_t Offset = 0;
221 while (AddrData.isValidOffset(Offset)) {
222 DWARFDebugAddrTable AddrTable;
223 uint64_t TableOffset = Offset;
224 if (Error Err = AddrTable.extract(AddrData, &Offset, Version, AddrSize,
225 DumpOpts.WarningHandler)) {
226 DumpOpts.RecoverableErrorHandler(std::move(Err));
227 // Keep going after an error, if we can, assuming that the length field
228 // could be read. If it couldn't, stop reading the section.
229 if (auto TableLength = AddrTable.getFullLength()) {
230 Offset = TableOffset + *TableLength;
231 continue;
232 }
233 break;
234 }
235 AddrTable.dump(OS, DumpOpts);
236 }
237 }
238
239 // Dump the .debug_rnglists or .debug_rnglists.dwo section (DWARF v5).
dumpRnglistsSection(raw_ostream & OS,DWARFDataExtractor & rnglistData,llvm::function_ref<Optional<object::SectionedAddress> (uint32_t)> LookupPooledAddress,DIDumpOptions DumpOpts)240 static void dumpRnglistsSection(
241 raw_ostream &OS, DWARFDataExtractor &rnglistData,
242 llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
243 LookupPooledAddress,
244 DIDumpOptions DumpOpts) {
245 uint64_t Offset = 0;
246 while (rnglistData.isValidOffset(Offset)) {
247 llvm::DWARFDebugRnglistTable Rnglists;
248 uint64_t TableOffset = Offset;
249 if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
250 DumpOpts.RecoverableErrorHandler(std::move(Err));
251 uint64_t Length = Rnglists.length();
252 // Keep going after an error, if we can, assuming that the length field
253 // could be read. If it couldn't, stop reading the section.
254 if (Length == 0)
255 break;
256 Offset = TableOffset + Length;
257 } else {
258 Rnglists.dump(rnglistData, OS, LookupPooledAddress, DumpOpts);
259 }
260 }
261 }
262
263 std::unique_ptr<DWARFDebugMacro>
parseMacroOrMacinfo(MacroSecType SectionType)264 DWARFContext::parseMacroOrMacinfo(MacroSecType SectionType) {
265 auto Macro = std::make_unique<DWARFDebugMacro>();
266 auto ParseAndDump = [&](DWARFDataExtractor &Data, bool IsMacro) {
267 if (Error Err = IsMacro ? Macro->parseMacro(SectionType == MacroSection
268 ? compile_units()
269 : dwo_compile_units(),
270 SectionType == MacroSection
271 ? getStringExtractor()
272 : getStringDWOExtractor(),
273 Data)
274 : Macro->parseMacinfo(Data)) {
275 RecoverableErrorHandler(std::move(Err));
276 Macro = nullptr;
277 }
278 };
279 switch (SectionType) {
280 case MacinfoSection: {
281 DWARFDataExtractor Data(DObj->getMacinfoSection(), isLittleEndian(), 0);
282 ParseAndDump(Data, /*IsMacro=*/false);
283 break;
284 }
285 case MacinfoDwoSection: {
286 DWARFDataExtractor Data(DObj->getMacinfoDWOSection(), isLittleEndian(), 0);
287 ParseAndDump(Data, /*IsMacro=*/false);
288 break;
289 }
290 case MacroSection: {
291 DWARFDataExtractor Data(*DObj, DObj->getMacroSection(), isLittleEndian(),
292 0);
293 ParseAndDump(Data, /*IsMacro=*/true);
294 break;
295 }
296 case MacroDwoSection: {
297 DWARFDataExtractor Data(DObj->getMacroDWOSection(), isLittleEndian(), 0);
298 ParseAndDump(Data, /*IsMacro=*/true);
299 break;
300 }
301 }
302 return Macro;
303 }
304
dumpLoclistsSection(raw_ostream & OS,DIDumpOptions DumpOpts,DWARFDataExtractor Data,const MCRegisterInfo * MRI,const DWARFObject & Obj,Optional<uint64_t> DumpOffset)305 static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
306 DWARFDataExtractor Data,
307 const MCRegisterInfo *MRI,
308 const DWARFObject &Obj,
309 Optional<uint64_t> DumpOffset) {
310 uint64_t Offset = 0;
311
312 while (Data.isValidOffset(Offset)) {
313 DWARFListTableHeader Header(".debug_loclists", "locations");
314 if (Error E = Header.extract(Data, &Offset)) {
315 DumpOpts.RecoverableErrorHandler(std::move(E));
316 return;
317 }
318
319 Header.dump(Data, OS, DumpOpts);
320
321 uint64_t EndOffset = Header.length() + Header.getHeaderOffset();
322 Data.setAddressSize(Header.getAddrSize());
323 DWARFDebugLoclists Loc(Data, Header.getVersion());
324 if (DumpOffset) {
325 if (DumpOffset >= Offset && DumpOffset < EndOffset) {
326 Offset = *DumpOffset;
327 Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/None, MRI, Obj, nullptr,
328 DumpOpts, /*Indent=*/0);
329 OS << "\n";
330 return;
331 }
332 } else {
333 Loc.dumpRange(Offset, EndOffset - Offset, OS, MRI, Obj, DumpOpts);
334 }
335 Offset = EndOffset;
336 }
337 }
338
dumpPubTableSection(raw_ostream & OS,DIDumpOptions DumpOpts,DWARFDataExtractor Data,bool GnuStyle)339 static void dumpPubTableSection(raw_ostream &OS, DIDumpOptions DumpOpts,
340 DWARFDataExtractor Data, bool GnuStyle) {
341 DWARFDebugPubTable Table;
342 Table.extract(Data, GnuStyle, DumpOpts.RecoverableErrorHandler);
343 Table.dump(OS);
344 }
345
dump(raw_ostream & OS,DIDumpOptions DumpOpts,std::array<Optional<uint64_t>,DIDT_ID_Count> DumpOffsets)346 void DWARFContext::dump(
347 raw_ostream &OS, DIDumpOptions DumpOpts,
348 std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
349 uint64_t DumpType = DumpOpts.DumpType;
350
351 StringRef Extension = sys::path::extension(DObj->getFileName());
352 bool IsDWO = (Extension == ".dwo") || (Extension == ".dwp");
353
354 // Print UUID header.
355 const auto *ObjFile = DObj->getFile();
356 if (DumpType & DIDT_UUID)
357 dumpUUID(OS, *ObjFile);
358
359 // Print a header for each explicitly-requested section.
360 // Otherwise just print one for non-empty sections.
361 // Only print empty .dwo section headers when dumping a .dwo file.
362 bool Explicit = DumpType != DIDT_All && !IsDWO;
363 bool ExplicitDWO = Explicit && IsDWO;
364 auto shouldDump = [&](bool Explicit, const char *Name, unsigned ID,
365 StringRef Section) -> Optional<uint64_t> * {
366 unsigned Mask = 1U << ID;
367 bool Should = (DumpType & Mask) && (Explicit || !Section.empty());
368 if (!Should)
369 return nullptr;
370 OS << "\n" << Name << " contents:\n";
371 return &DumpOffsets[ID];
372 };
373
374 // Dump individual sections.
375 if (shouldDump(Explicit, ".debug_abbrev", DIDT_ID_DebugAbbrev,
376 DObj->getAbbrevSection()))
377 getDebugAbbrev()->dump(OS);
378 if (shouldDump(ExplicitDWO, ".debug_abbrev.dwo", DIDT_ID_DebugAbbrev,
379 DObj->getAbbrevDWOSection()))
380 getDebugAbbrevDWO()->dump(OS);
381
382 auto dumpDebugInfo = [&](const char *Name, unit_iterator_range Units) {
383 OS << '\n' << Name << " contents:\n";
384 if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugInfo])
385 for (const auto &U : Units)
386 U->getDIEForOffset(DumpOffset.getValue())
387 .dump(OS, 0, DumpOpts.noImplicitRecursion());
388 else
389 for (const auto &U : Units)
390 U->dump(OS, DumpOpts);
391 };
392 if ((DumpType & DIDT_DebugInfo)) {
393 if (Explicit || getNumCompileUnits())
394 dumpDebugInfo(".debug_info", info_section_units());
395 if (ExplicitDWO || getNumDWOCompileUnits())
396 dumpDebugInfo(".debug_info.dwo", dwo_info_section_units());
397 }
398
399 auto dumpDebugType = [&](const char *Name, unit_iterator_range Units) {
400 OS << '\n' << Name << " contents:\n";
401 for (const auto &U : Units)
402 if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugTypes])
403 U->getDIEForOffset(*DumpOffset)
404 .dump(OS, 0, DumpOpts.noImplicitRecursion());
405 else
406 U->dump(OS, DumpOpts);
407 };
408 if ((DumpType & DIDT_DebugTypes)) {
409 if (Explicit || getNumTypeUnits())
410 dumpDebugType(".debug_types", types_section_units());
411 if (ExplicitDWO || getNumDWOTypeUnits())
412 dumpDebugType(".debug_types.dwo", dwo_types_section_units());
413 }
414
415 DIDumpOptions LLDumpOpts = DumpOpts;
416 if (LLDumpOpts.Verbose)
417 LLDumpOpts.DisplayRawContents = true;
418
419 if (const auto *Off = shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
420 DObj->getLocSection().Data)) {
421 getDebugLoc()->dump(OS, getRegisterInfo(), *DObj, LLDumpOpts, *Off);
422 }
423 if (const auto *Off =
424 shouldDump(Explicit, ".debug_loclists", DIDT_ID_DebugLoclists,
425 DObj->getLoclistsSection().Data)) {
426 DWARFDataExtractor Data(*DObj, DObj->getLoclistsSection(), isLittleEndian(),
427 0);
428 dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off);
429 }
430 if (const auto *Off =
431 shouldDump(ExplicitDWO, ".debug_loclists.dwo", DIDT_ID_DebugLoclists,
432 DObj->getLoclistsDWOSection().Data)) {
433 DWARFDataExtractor Data(*DObj, DObj->getLoclistsDWOSection(),
434 isLittleEndian(), 0);
435 dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off);
436 }
437
438 if (const auto *Off =
439 shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
440 DObj->getLocDWOSection().Data)) {
441 DWARFDataExtractor Data(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
442 4);
443 DWARFDebugLoclists Loc(Data, /*Version=*/4);
444 if (*Off) {
445 uint64_t Offset = **Off;
446 Loc.dumpLocationList(&Offset, OS,
447 /*BaseAddr=*/None, getRegisterInfo(), *DObj, nullptr,
448 LLDumpOpts, /*Indent=*/0);
449 OS << "\n";
450 } else {
451 Loc.dumpRange(0, Data.getData().size(), OS, getRegisterInfo(), *DObj,
452 LLDumpOpts);
453 }
454 }
455
456 if (const Optional<uint64_t> *Off =
457 shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
458 DObj->getFrameSection().Data)) {
459 if (Expected<const DWARFDebugFrame *> DF = getDebugFrame())
460 (*DF)->dump(OS, DumpOpts, getRegisterInfo(), *Off);
461 else
462 RecoverableErrorHandler(DF.takeError());
463 }
464
465 if (const Optional<uint64_t> *Off =
466 shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,
467 DObj->getEHFrameSection().Data)) {
468 if (Expected<const DWARFDebugFrame *> DF = getEHFrame())
469 (*DF)->dump(OS, DumpOpts, getRegisterInfo(), *Off);
470 else
471 RecoverableErrorHandler(DF.takeError());
472 }
473
474 if (shouldDump(Explicit, ".debug_macro", DIDT_ID_DebugMacro,
475 DObj->getMacroSection().Data)) {
476 if (auto Macro = getDebugMacro())
477 Macro->dump(OS);
478 }
479
480 if (shouldDump(Explicit, ".debug_macro.dwo", DIDT_ID_DebugMacro,
481 DObj->getMacroDWOSection())) {
482 if (auto MacroDWO = getDebugMacroDWO())
483 MacroDWO->dump(OS);
484 }
485
486 if (shouldDump(Explicit, ".debug_macinfo", DIDT_ID_DebugMacro,
487 DObj->getMacinfoSection())) {
488 if (auto Macinfo = getDebugMacinfo())
489 Macinfo->dump(OS);
490 }
491
492 if (shouldDump(Explicit, ".debug_macinfo.dwo", DIDT_ID_DebugMacro,
493 DObj->getMacinfoDWOSection())) {
494 if (auto MacinfoDWO = getDebugMacinfoDWO())
495 MacinfoDWO->dump(OS);
496 }
497
498 if (shouldDump(Explicit, ".debug_aranges", DIDT_ID_DebugAranges,
499 DObj->getArangesSection())) {
500 uint64_t offset = 0;
501 DWARFDataExtractor arangesData(DObj->getArangesSection(), isLittleEndian(),
502 0);
503 DWARFDebugArangeSet set;
504 while (arangesData.isValidOffset(offset)) {
505 if (Error E =
506 set.extract(arangesData, &offset, DumpOpts.WarningHandler)) {
507 RecoverableErrorHandler(std::move(E));
508 break;
509 }
510 set.dump(OS);
511 }
512 }
513
514 auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser,
515 DIDumpOptions DumpOpts,
516 Optional<uint64_t> DumpOffset) {
517 while (!Parser.done()) {
518 if (DumpOffset && Parser.getOffset() != *DumpOffset) {
519 Parser.skip(DumpOpts.WarningHandler, DumpOpts.WarningHandler);
520 continue;
521 }
522 OS << "debug_line[" << format("0x%8.8" PRIx64, Parser.getOffset())
523 << "]\n";
524 Parser.parseNext(DumpOpts.WarningHandler, DumpOpts.WarningHandler, &OS,
525 DumpOpts.Verbose);
526 }
527 };
528
529 auto DumpStrSection = [&](StringRef Section) {
530 DataExtractor StrData(Section, isLittleEndian(), 0);
531 uint64_t Offset = 0;
532 uint64_t StrOffset = 0;
533 while (StrData.isValidOffset(Offset)) {
534 Error Err = Error::success();
535 const char *CStr = StrData.getCStr(&Offset, &Err);
536 if (Err) {
537 DumpOpts.WarningHandler(std::move(Err));
538 return;
539 }
540 OS << format("0x%8.8" PRIx64 ": \"", StrOffset);
541 OS.write_escaped(CStr);
542 OS << "\"\n";
543 StrOffset = Offset;
544 }
545 };
546
547 if (const auto *Off = shouldDump(Explicit, ".debug_line", DIDT_ID_DebugLine,
548 DObj->getLineSection().Data)) {
549 DWARFDataExtractor LineData(*DObj, DObj->getLineSection(), isLittleEndian(),
550 0);
551 DWARFDebugLine::SectionParser Parser(LineData, *this, normal_units());
552 DumpLineSection(Parser, DumpOpts, *Off);
553 }
554
555 if (const auto *Off =
556 shouldDump(ExplicitDWO, ".debug_line.dwo", DIDT_ID_DebugLine,
557 DObj->getLineDWOSection().Data)) {
558 DWARFDataExtractor LineData(*DObj, DObj->getLineDWOSection(),
559 isLittleEndian(), 0);
560 DWARFDebugLine::SectionParser Parser(LineData, *this, dwo_units());
561 DumpLineSection(Parser, DumpOpts, *Off);
562 }
563
564 if (shouldDump(Explicit, ".debug_cu_index", DIDT_ID_DebugCUIndex,
565 DObj->getCUIndexSection())) {
566 getCUIndex().dump(OS);
567 }
568
569 if (shouldDump(Explicit, ".debug_tu_index", DIDT_ID_DebugTUIndex,
570 DObj->getTUIndexSection())) {
571 getTUIndex().dump(OS);
572 }
573
574 if (shouldDump(Explicit, ".debug_str", DIDT_ID_DebugStr,
575 DObj->getStrSection()))
576 DumpStrSection(DObj->getStrSection());
577
578 if (shouldDump(ExplicitDWO, ".debug_str.dwo", DIDT_ID_DebugStr,
579 DObj->getStrDWOSection()))
580 DumpStrSection(DObj->getStrDWOSection());
581
582 if (shouldDump(Explicit, ".debug_line_str", DIDT_ID_DebugLineStr,
583 DObj->getLineStrSection()))
584 DumpStrSection(DObj->getLineStrSection());
585
586 if (shouldDump(Explicit, ".debug_addr", DIDT_ID_DebugAddr,
587 DObj->getAddrSection().Data)) {
588 DWARFDataExtractor AddrData(*DObj, DObj->getAddrSection(),
589 isLittleEndian(), 0);
590 dumpAddrSection(OS, AddrData, DumpOpts, getMaxVersion(), getCUAddrSize());
591 }
592
593 if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges,
594 DObj->getRangesSection().Data)) {
595 uint8_t savedAddressByteSize = getCUAddrSize();
596 DWARFDataExtractor rangesData(*DObj, DObj->getRangesSection(),
597 isLittleEndian(), savedAddressByteSize);
598 uint64_t offset = 0;
599 DWARFDebugRangeList rangeList;
600 while (rangesData.isValidOffset(offset)) {
601 if (Error E = rangeList.extract(rangesData, &offset)) {
602 DumpOpts.RecoverableErrorHandler(std::move(E));
603 break;
604 }
605 rangeList.dump(OS);
606 }
607 }
608
609 auto LookupPooledAddress = [&](uint32_t Index) -> Optional<SectionedAddress> {
610 const auto &CUs = compile_units();
611 auto I = CUs.begin();
612 if (I == CUs.end())
613 return None;
614 return (*I)->getAddrOffsetSectionItem(Index);
615 };
616
617 if (shouldDump(Explicit, ".debug_rnglists", DIDT_ID_DebugRnglists,
618 DObj->getRnglistsSection().Data)) {
619 DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsSection(),
620 isLittleEndian(), 0);
621 dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts);
622 }
623
624 if (shouldDump(ExplicitDWO, ".debug_rnglists.dwo", DIDT_ID_DebugRnglists,
625 DObj->getRnglistsDWOSection().Data)) {
626 DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsDWOSection(),
627 isLittleEndian(), 0);
628 dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts);
629 }
630
631 if (shouldDump(Explicit, ".debug_pubnames", DIDT_ID_DebugPubnames,
632 DObj->getPubnamesSection().Data)) {
633 DWARFDataExtractor PubTableData(*DObj, DObj->getPubnamesSection(),
634 isLittleEndian(), 0);
635 dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/false);
636 }
637
638 if (shouldDump(Explicit, ".debug_pubtypes", DIDT_ID_DebugPubtypes,
639 DObj->getPubtypesSection().Data)) {
640 DWARFDataExtractor PubTableData(*DObj, DObj->getPubtypesSection(),
641 isLittleEndian(), 0);
642 dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/false);
643 }
644
645 if (shouldDump(Explicit, ".debug_gnu_pubnames", DIDT_ID_DebugGnuPubnames,
646 DObj->getGnuPubnamesSection().Data)) {
647 DWARFDataExtractor PubTableData(*DObj, DObj->getGnuPubnamesSection(),
648 isLittleEndian(), 0);
649 dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/true);
650 }
651
652 if (shouldDump(Explicit, ".debug_gnu_pubtypes", DIDT_ID_DebugGnuPubtypes,
653 DObj->getGnuPubtypesSection().Data)) {
654 DWARFDataExtractor PubTableData(*DObj, DObj->getGnuPubtypesSection(),
655 isLittleEndian(), 0);
656 dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/true);
657 }
658
659 if (shouldDump(Explicit, ".debug_str_offsets", DIDT_ID_DebugStrOffsets,
660 DObj->getStrOffsetsSection().Data))
661 dumpStringOffsetsSection(
662 OS, DumpOpts, "debug_str_offsets", *DObj, DObj->getStrOffsetsSection(),
663 DObj->getStrSection(), normal_units(), isLittleEndian());
664 if (shouldDump(ExplicitDWO, ".debug_str_offsets.dwo", DIDT_ID_DebugStrOffsets,
665 DObj->getStrOffsetsDWOSection().Data))
666 dumpStringOffsetsSection(OS, DumpOpts, "debug_str_offsets.dwo", *DObj,
667 DObj->getStrOffsetsDWOSection(),
668 DObj->getStrDWOSection(), dwo_units(),
669 isLittleEndian());
670
671 if (shouldDump(Explicit, ".gdb_index", DIDT_ID_GdbIndex,
672 DObj->getGdbIndexSection())) {
673 getGdbIndex().dump(OS);
674 }
675
676 if (shouldDump(Explicit, ".apple_names", DIDT_ID_AppleNames,
677 DObj->getAppleNamesSection().Data))
678 getAppleNames().dump(OS);
679
680 if (shouldDump(Explicit, ".apple_types", DIDT_ID_AppleTypes,
681 DObj->getAppleTypesSection().Data))
682 getAppleTypes().dump(OS);
683
684 if (shouldDump(Explicit, ".apple_namespaces", DIDT_ID_AppleNamespaces,
685 DObj->getAppleNamespacesSection().Data))
686 getAppleNamespaces().dump(OS);
687
688 if (shouldDump(Explicit, ".apple_objc", DIDT_ID_AppleObjC,
689 DObj->getAppleObjCSection().Data))
690 getAppleObjC().dump(OS);
691 if (shouldDump(Explicit, ".debug_names", DIDT_ID_DebugNames,
692 DObj->getNamesSection().Data))
693 getDebugNames().dump(OS);
694 }
695
getDWOCompileUnitForHash(uint64_t Hash)696 DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) {
697 parseDWOUnits(LazyParse);
698
699 if (const auto &CUI = getCUIndex()) {
700 if (const auto *R = CUI.getFromHash(Hash))
701 return dyn_cast_or_null<DWARFCompileUnit>(
702 DWOUnits.getUnitForIndexEntry(*R));
703 return nullptr;
704 }
705
706 // If there's no index, just search through the CUs in the DWO - there's
707 // probably only one unless this is something like LTO - though an in-process
708 // built/cached lookup table could be used in that case to improve repeated
709 // lookups of different CUs in the DWO.
710 for (const auto &DWOCU : dwo_compile_units()) {
711 // Might not have parsed DWO ID yet.
712 if (!DWOCU->getDWOId()) {
713 if (Optional<uint64_t> DWOId =
714 toUnsigned(DWOCU->getUnitDIE().find(DW_AT_GNU_dwo_id)))
715 DWOCU->setDWOId(*DWOId);
716 else
717 // No DWO ID?
718 continue;
719 }
720 if (DWOCU->getDWOId() == Hash)
721 return dyn_cast<DWARFCompileUnit>(DWOCU.get());
722 }
723 return nullptr;
724 }
725
getDIEForOffset(uint64_t Offset)726 DWARFDie DWARFContext::getDIEForOffset(uint64_t Offset) {
727 parseNormalUnits();
728 if (auto *CU = NormalUnits.getUnitForOffset(Offset))
729 return CU->getDIEForOffset(Offset);
730 return DWARFDie();
731 }
732
verify(raw_ostream & OS,DIDumpOptions DumpOpts)733 bool DWARFContext::verify(raw_ostream &OS, DIDumpOptions DumpOpts) {
734 bool Success = true;
735 DWARFVerifier verifier(OS, *this, DumpOpts);
736
737 Success &= verifier.handleDebugAbbrev();
738 if (DumpOpts.DumpType & DIDT_DebugInfo)
739 Success &= verifier.handleDebugInfo();
740 if (DumpOpts.DumpType & DIDT_DebugLine)
741 Success &= verifier.handleDebugLine();
742 Success &= verifier.handleAccelTables();
743 return Success;
744 }
745
getCUIndex()746 const DWARFUnitIndex &DWARFContext::getCUIndex() {
747 if (CUIndex)
748 return *CUIndex;
749
750 DataExtractor CUIndexData(DObj->getCUIndexSection(), isLittleEndian(), 0);
751
752 CUIndex = std::make_unique<DWARFUnitIndex>(DW_SECT_INFO);
753 CUIndex->parse(CUIndexData);
754 return *CUIndex;
755 }
756
getTUIndex()757 const DWARFUnitIndex &DWARFContext::getTUIndex() {
758 if (TUIndex)
759 return *TUIndex;
760
761 DataExtractor TUIndexData(DObj->getTUIndexSection(), isLittleEndian(), 0);
762
763 TUIndex = std::make_unique<DWARFUnitIndex>(DW_SECT_EXT_TYPES);
764 TUIndex->parse(TUIndexData);
765 return *TUIndex;
766 }
767
getGdbIndex()768 DWARFGdbIndex &DWARFContext::getGdbIndex() {
769 if (GdbIndex)
770 return *GdbIndex;
771
772 DataExtractor GdbIndexData(DObj->getGdbIndexSection(), true /*LE*/, 0);
773 GdbIndex = std::make_unique<DWARFGdbIndex>();
774 GdbIndex->parse(GdbIndexData);
775 return *GdbIndex;
776 }
777
getDebugAbbrev()778 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
779 if (Abbrev)
780 return Abbrev.get();
781
782 DataExtractor abbrData(DObj->getAbbrevSection(), isLittleEndian(), 0);
783
784 Abbrev.reset(new DWARFDebugAbbrev());
785 Abbrev->extract(abbrData);
786 return Abbrev.get();
787 }
788
getDebugAbbrevDWO()789 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() {
790 if (AbbrevDWO)
791 return AbbrevDWO.get();
792
793 DataExtractor abbrData(DObj->getAbbrevDWOSection(), isLittleEndian(), 0);
794 AbbrevDWO.reset(new DWARFDebugAbbrev());
795 AbbrevDWO->extract(abbrData);
796 return AbbrevDWO.get();
797 }
798
getDebugLoc()799 const DWARFDebugLoc *DWARFContext::getDebugLoc() {
800 if (Loc)
801 return Loc.get();
802
803 // Assume all units have the same address byte size.
804 auto LocData =
805 getNumCompileUnits()
806 ? DWARFDataExtractor(*DObj, DObj->getLocSection(), isLittleEndian(),
807 getUnitAtIndex(0)->getAddressByteSize())
808 : DWARFDataExtractor("", isLittleEndian(), 0);
809 Loc.reset(new DWARFDebugLoc(std::move(LocData)));
810 return Loc.get();
811 }
812
getDebugAranges()813 const DWARFDebugAranges *DWARFContext::getDebugAranges() {
814 if (Aranges)
815 return Aranges.get();
816
817 Aranges.reset(new DWARFDebugAranges());
818 Aranges->generate(this);
819 return Aranges.get();
820 }
821
getDebugFrame()822 Expected<const DWARFDebugFrame *> DWARFContext::getDebugFrame() {
823 if (DebugFrame)
824 return DebugFrame.get();
825
826 const DWARFSection &DS = DObj->getFrameSection();
827
828 // There's a "bug" in the DWARFv3 standard with respect to the target address
829 // size within debug frame sections. While DWARF is supposed to be independent
830 // of its container, FDEs have fields with size being "target address size",
831 // which isn't specified in DWARF in general. It's only specified for CUs, but
832 // .eh_frame can appear without a .debug_info section. Follow the example of
833 // other tools (libdwarf) and extract this from the container (ObjectFile
834 // provides this information). This problem is fixed in DWARFv4
835 // See this dwarf-discuss discussion for more details:
836 // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
837 DWARFDataExtractor DebugFrameData(*DObj, DS, isLittleEndian(),
838 DObj->getAddressSize());
839 auto DF =
840 std::make_unique<DWARFDebugFrame>(getArch(), /*IsEH=*/false, DS.Address);
841 if (Error E = DF->parse(DebugFrameData))
842 return std::move(E);
843
844 DebugFrame.swap(DF);
845 return DebugFrame.get();
846 }
847
getEHFrame()848 Expected<const DWARFDebugFrame *> DWARFContext::getEHFrame() {
849 if (EHFrame)
850 return EHFrame.get();
851
852 const DWARFSection &DS = DObj->getEHFrameSection();
853 DWARFDataExtractor DebugFrameData(*DObj, DS, isLittleEndian(),
854 DObj->getAddressSize());
855
856 auto DF =
857 std::make_unique<DWARFDebugFrame>(getArch(), /*IsEH=*/true, DS.Address);
858 if (Error E = DF->parse(DebugFrameData))
859 return std::move(E);
860 DebugFrame.swap(DF);
861 return DebugFrame.get();
862 }
863
getDebugMacro()864 const DWARFDebugMacro *DWARFContext::getDebugMacro() {
865 if (!Macro)
866 Macro = parseMacroOrMacinfo(MacroSection);
867 return Macro.get();
868 }
869
getDebugMacroDWO()870 const DWARFDebugMacro *DWARFContext::getDebugMacroDWO() {
871 if (!MacroDWO)
872 MacroDWO = parseMacroOrMacinfo(MacroDwoSection);
873 return MacroDWO.get();
874 }
875
getDebugMacinfo()876 const DWARFDebugMacro *DWARFContext::getDebugMacinfo() {
877 if (!Macinfo)
878 Macinfo = parseMacroOrMacinfo(MacinfoSection);
879 return Macinfo.get();
880 }
881
getDebugMacinfoDWO()882 const DWARFDebugMacro *DWARFContext::getDebugMacinfoDWO() {
883 if (!MacinfoDWO)
884 MacinfoDWO = parseMacroOrMacinfo(MacinfoDwoSection);
885 return MacinfoDWO.get();
886 }
887
888 template <typename T>
getAccelTable(std::unique_ptr<T> & Cache,const DWARFObject & Obj,const DWARFSection & Section,StringRef StringSection,bool IsLittleEndian)889 static T &getAccelTable(std::unique_ptr<T> &Cache, const DWARFObject &Obj,
890 const DWARFSection &Section, StringRef StringSection,
891 bool IsLittleEndian) {
892 if (Cache)
893 return *Cache;
894 DWARFDataExtractor AccelSection(Obj, Section, IsLittleEndian, 0);
895 DataExtractor StrData(StringSection, IsLittleEndian, 0);
896 Cache.reset(new T(AccelSection, StrData));
897 if (Error E = Cache->extract())
898 llvm::consumeError(std::move(E));
899 return *Cache;
900 }
901
getDebugNames()902 const DWARFDebugNames &DWARFContext::getDebugNames() {
903 return getAccelTable(Names, *DObj, DObj->getNamesSection(),
904 DObj->getStrSection(), isLittleEndian());
905 }
906
getAppleNames()907 const AppleAcceleratorTable &DWARFContext::getAppleNames() {
908 return getAccelTable(AppleNames, *DObj, DObj->getAppleNamesSection(),
909 DObj->getStrSection(), isLittleEndian());
910 }
911
getAppleTypes()912 const AppleAcceleratorTable &DWARFContext::getAppleTypes() {
913 return getAccelTable(AppleTypes, *DObj, DObj->getAppleTypesSection(),
914 DObj->getStrSection(), isLittleEndian());
915 }
916
getAppleNamespaces()917 const AppleAcceleratorTable &DWARFContext::getAppleNamespaces() {
918 return getAccelTable(AppleNamespaces, *DObj,
919 DObj->getAppleNamespacesSection(),
920 DObj->getStrSection(), isLittleEndian());
921 }
922
getAppleObjC()923 const AppleAcceleratorTable &DWARFContext::getAppleObjC() {
924 return getAccelTable(AppleObjC, *DObj, DObj->getAppleObjCSection(),
925 DObj->getStrSection(), isLittleEndian());
926 }
927
928 const DWARFDebugLine::LineTable *
getLineTableForUnit(DWARFUnit * U)929 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
930 Expected<const DWARFDebugLine::LineTable *> ExpectedLineTable =
931 getLineTableForUnit(U, WarningHandler);
932 if (!ExpectedLineTable) {
933 WarningHandler(ExpectedLineTable.takeError());
934 return nullptr;
935 }
936 return *ExpectedLineTable;
937 }
938
getLineTableForUnit(DWARFUnit * U,function_ref<void (Error)> RecoverableErrorHandler)939 Expected<const DWARFDebugLine::LineTable *> DWARFContext::getLineTableForUnit(
940 DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) {
941 if (!Line)
942 Line.reset(new DWARFDebugLine);
943
944 auto UnitDIE = U->getUnitDIE();
945 if (!UnitDIE)
946 return nullptr;
947
948 auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list));
949 if (!Offset)
950 return nullptr; // No line table for this compile unit.
951
952 uint64_t stmtOffset = *Offset + U->getLineTableOffset();
953 // See if the line table is cached.
954 if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
955 return lt;
956
957 // Make sure the offset is good before we try to parse.
958 if (stmtOffset >= U->getLineSection().Data.size())
959 return nullptr;
960
961 // We have to parse it first.
962 DWARFDataExtractor lineData(*DObj, U->getLineSection(), isLittleEndian(),
963 U->getAddressByteSize());
964 return Line->getOrParseLineTable(lineData, stmtOffset, *this, U,
965 RecoverableErrorHandler);
966 }
967
parseNormalUnits()968 void DWARFContext::parseNormalUnits() {
969 if (!NormalUnits.empty())
970 return;
971 DObj->forEachInfoSections([&](const DWARFSection &S) {
972 NormalUnits.addUnitsForSection(*this, S, DW_SECT_INFO);
973 });
974 NormalUnits.finishedInfoUnits();
975 DObj->forEachTypesSections([&](const DWARFSection &S) {
976 NormalUnits.addUnitsForSection(*this, S, DW_SECT_EXT_TYPES);
977 });
978 }
979
parseDWOUnits(bool Lazy)980 void DWARFContext::parseDWOUnits(bool Lazy) {
981 if (!DWOUnits.empty())
982 return;
983 DObj->forEachInfoDWOSections([&](const DWARFSection &S) {
984 DWOUnits.addUnitsForDWOSection(*this, S, DW_SECT_INFO, Lazy);
985 });
986 DWOUnits.finishedInfoUnits();
987 DObj->forEachTypesDWOSections([&](const DWARFSection &S) {
988 DWOUnits.addUnitsForDWOSection(*this, S, DW_SECT_EXT_TYPES, Lazy);
989 });
990 }
991
getCompileUnitForOffset(uint64_t Offset)992 DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint64_t Offset) {
993 parseNormalUnits();
994 return dyn_cast_or_null<DWARFCompileUnit>(
995 NormalUnits.getUnitForOffset(Offset));
996 }
997
getCompileUnitForAddress(uint64_t Address)998 DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
999 // First, get the offset of the compile unit.
1000 uint64_t CUOffset = getDebugAranges()->findAddress(Address);
1001 // Retrieve the compile unit.
1002 return getCompileUnitForOffset(CUOffset);
1003 }
1004
getDIEsForAddress(uint64_t Address)1005 DWARFContext::DIEsForAddress DWARFContext::getDIEsForAddress(uint64_t Address) {
1006 DIEsForAddress Result;
1007
1008 DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
1009 if (!CU)
1010 return Result;
1011
1012 Result.CompileUnit = CU;
1013 Result.FunctionDIE = CU->getSubroutineForAddress(Address);
1014
1015 std::vector<DWARFDie> Worklist;
1016 Worklist.push_back(Result.FunctionDIE);
1017 while (!Worklist.empty()) {
1018 DWARFDie DIE = Worklist.back();
1019 Worklist.pop_back();
1020
1021 if (!DIE.isValid())
1022 continue;
1023
1024 if (DIE.getTag() == DW_TAG_lexical_block &&
1025 DIE.addressRangeContainsAddress(Address)) {
1026 Result.BlockDIE = DIE;
1027 break;
1028 }
1029
1030 append_range(Worklist, DIE);
1031 }
1032
1033 return Result;
1034 }
1035
1036 /// TODO: change input parameter from "uint64_t Address"
1037 /// into "SectionedAddress Address"
getFunctionNameAndStartLineForAddress(DWARFCompileUnit * CU,uint64_t Address,FunctionNameKind Kind,DILineInfoSpecifier::FileLineInfoKind FileNameKind,std::string & FunctionName,std::string & StartFile,uint32_t & StartLine,Optional<uint64_t> & StartAddress)1038 static bool getFunctionNameAndStartLineForAddress(
1039 DWARFCompileUnit *CU, uint64_t Address, FunctionNameKind Kind,
1040 DILineInfoSpecifier::FileLineInfoKind FileNameKind,
1041 std::string &FunctionName, std::string &StartFile, uint32_t &StartLine,
1042 Optional<uint64_t> &StartAddress) {
1043 // The address may correspond to instruction in some inlined function,
1044 // so we have to build the chain of inlined functions and take the
1045 // name of the topmost function in it.
1046 SmallVector<DWARFDie, 4> InlinedChain;
1047 CU->getInlinedChainForAddress(Address, InlinedChain);
1048 if (InlinedChain.empty())
1049 return false;
1050
1051 const DWARFDie &DIE = InlinedChain[0];
1052 bool FoundResult = false;
1053 const char *Name = nullptr;
1054 if (Kind != FunctionNameKind::None && (Name = DIE.getSubroutineName(Kind))) {
1055 FunctionName = Name;
1056 FoundResult = true;
1057 }
1058 std::string DeclFile = DIE.getDeclFile(FileNameKind);
1059 if (!DeclFile.empty()) {
1060 StartFile = DeclFile;
1061 FoundResult = true;
1062 }
1063 if (auto DeclLineResult = DIE.getDeclLine()) {
1064 StartLine = DeclLineResult;
1065 FoundResult = true;
1066 }
1067 if (auto LowPcAddr = toSectionedAddress(DIE.find(DW_AT_low_pc)))
1068 StartAddress = LowPcAddr->Address;
1069 return FoundResult;
1070 }
1071
getTypeSize(DWARFDie Type,uint64_t PointerSize)1072 static Optional<uint64_t> getTypeSize(DWARFDie Type, uint64_t PointerSize) {
1073 if (auto SizeAttr = Type.find(DW_AT_byte_size))
1074 if (Optional<uint64_t> Size = SizeAttr->getAsUnsignedConstant())
1075 return Size;
1076
1077 switch (Type.getTag()) {
1078 case DW_TAG_pointer_type:
1079 case DW_TAG_reference_type:
1080 case DW_TAG_rvalue_reference_type:
1081 return PointerSize;
1082 case DW_TAG_ptr_to_member_type: {
1083 if (DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type))
1084 if (BaseType.getTag() == DW_TAG_subroutine_type)
1085 return 2 * PointerSize;
1086 return PointerSize;
1087 }
1088 case DW_TAG_const_type:
1089 case DW_TAG_volatile_type:
1090 case DW_TAG_restrict_type:
1091 case DW_TAG_typedef: {
1092 if (DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type))
1093 return getTypeSize(BaseType, PointerSize);
1094 break;
1095 }
1096 case DW_TAG_array_type: {
1097 DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type);
1098 if (!BaseType)
1099 return Optional<uint64_t>();
1100 Optional<uint64_t> BaseSize = getTypeSize(BaseType, PointerSize);
1101 if (!BaseSize)
1102 return Optional<uint64_t>();
1103 uint64_t Size = *BaseSize;
1104 for (DWARFDie Child : Type) {
1105 if (Child.getTag() != DW_TAG_subrange_type)
1106 continue;
1107
1108 if (auto ElemCountAttr = Child.find(DW_AT_count))
1109 if (Optional<uint64_t> ElemCount =
1110 ElemCountAttr->getAsUnsignedConstant())
1111 Size *= *ElemCount;
1112 if (auto UpperBoundAttr = Child.find(DW_AT_upper_bound))
1113 if (Optional<int64_t> UpperBound =
1114 UpperBoundAttr->getAsSignedConstant()) {
1115 int64_t LowerBound = 0;
1116 if (auto LowerBoundAttr = Child.find(DW_AT_lower_bound))
1117 LowerBound = LowerBoundAttr->getAsSignedConstant().getValueOr(0);
1118 Size *= *UpperBound - LowerBound + 1;
1119 }
1120 }
1121 return Size;
1122 }
1123 default:
1124 break;
1125 }
1126 return Optional<uint64_t>();
1127 }
1128
1129 static Optional<int64_t>
getExpressionFrameOffset(ArrayRef<uint8_t> Expr,Optional<unsigned> FrameBaseReg)1130 getExpressionFrameOffset(ArrayRef<uint8_t> Expr,
1131 Optional<unsigned> FrameBaseReg) {
1132 if (!Expr.empty() &&
1133 (Expr[0] == DW_OP_fbreg ||
1134 (FrameBaseReg && Expr[0] == DW_OP_breg0 + *FrameBaseReg))) {
1135 unsigned Count;
1136 int64_t Offset = decodeSLEB128(Expr.data() + 1, &Count, Expr.end());
1137 // A single DW_OP_fbreg or DW_OP_breg.
1138 if (Expr.size() == Count + 1)
1139 return Offset;
1140 // Same + DW_OP_deref (Fortran arrays look like this).
1141 if (Expr.size() == Count + 2 && Expr[Count + 1] == DW_OP_deref)
1142 return Offset;
1143 // Fallthrough. Do not accept ex. (DW_OP_breg W29, DW_OP_stack_value)
1144 }
1145 return None;
1146 }
1147
addLocalsForDie(DWARFCompileUnit * CU,DWARFDie Subprogram,DWARFDie Die,std::vector<DILocal> & Result)1148 void DWARFContext::addLocalsForDie(DWARFCompileUnit *CU, DWARFDie Subprogram,
1149 DWARFDie Die, std::vector<DILocal> &Result) {
1150 if (Die.getTag() == DW_TAG_variable ||
1151 Die.getTag() == DW_TAG_formal_parameter) {
1152 DILocal Local;
1153 if (const char *Name = Subprogram.getSubroutineName(DINameKind::ShortName))
1154 Local.FunctionName = Name;
1155
1156 Optional<unsigned> FrameBaseReg;
1157 if (auto FrameBase = Subprogram.find(DW_AT_frame_base))
1158 if (Optional<ArrayRef<uint8_t>> Expr = FrameBase->getAsBlock())
1159 if (!Expr->empty() && (*Expr)[0] >= DW_OP_reg0 &&
1160 (*Expr)[0] <= DW_OP_reg31) {
1161 FrameBaseReg = (*Expr)[0] - DW_OP_reg0;
1162 }
1163
1164 if (Expected<std::vector<DWARFLocationExpression>> Loc =
1165 Die.getLocations(DW_AT_location)) {
1166 for (const auto &Entry : *Loc) {
1167 if (Optional<int64_t> FrameOffset =
1168 getExpressionFrameOffset(Entry.Expr, FrameBaseReg)) {
1169 Local.FrameOffset = *FrameOffset;
1170 break;
1171 }
1172 }
1173 } else {
1174 // FIXME: missing DW_AT_location is OK here, but other errors should be
1175 // reported to the user.
1176 consumeError(Loc.takeError());
1177 }
1178
1179 if (auto TagOffsetAttr = Die.find(DW_AT_LLVM_tag_offset))
1180 Local.TagOffset = TagOffsetAttr->getAsUnsignedConstant();
1181
1182 if (auto Origin =
1183 Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
1184 Die = Origin;
1185 if (auto NameAttr = Die.find(DW_AT_name))
1186 if (Optional<const char *> Name = NameAttr->getAsCString())
1187 Local.Name = *Name;
1188 if (auto Type = Die.getAttributeValueAsReferencedDie(DW_AT_type))
1189 Local.Size = getTypeSize(Type, getCUAddrSize());
1190 if (auto DeclFileAttr = Die.find(DW_AT_decl_file)) {
1191 if (const auto *LT = CU->getContext().getLineTableForUnit(CU))
1192 LT->getFileNameByIndex(
1193 DeclFileAttr->getAsUnsignedConstant().getValue(),
1194 CU->getCompilationDir(),
1195 DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath,
1196 Local.DeclFile);
1197 }
1198 if (auto DeclLineAttr = Die.find(DW_AT_decl_line))
1199 Local.DeclLine = DeclLineAttr->getAsUnsignedConstant().getValue();
1200
1201 Result.push_back(Local);
1202 return;
1203 }
1204
1205 if (Die.getTag() == DW_TAG_inlined_subroutine)
1206 if (auto Origin =
1207 Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
1208 Subprogram = Origin;
1209
1210 for (auto Child : Die)
1211 addLocalsForDie(CU, Subprogram, Child, Result);
1212 }
1213
1214 std::vector<DILocal>
getLocalsForAddress(object::SectionedAddress Address)1215 DWARFContext::getLocalsForAddress(object::SectionedAddress Address) {
1216 std::vector<DILocal> Result;
1217 DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
1218 if (!CU)
1219 return Result;
1220
1221 DWARFDie Subprogram = CU->getSubroutineForAddress(Address.Address);
1222 if (Subprogram.isValid())
1223 addLocalsForDie(CU, Subprogram, Subprogram, Result);
1224 return Result;
1225 }
1226
getLineInfoForAddress(object::SectionedAddress Address,DILineInfoSpecifier Spec)1227 DILineInfo DWARFContext::getLineInfoForAddress(object::SectionedAddress Address,
1228 DILineInfoSpecifier Spec) {
1229 DILineInfo Result;
1230
1231 DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
1232 if (!CU)
1233 return Result;
1234
1235 getFunctionNameAndStartLineForAddress(
1236 CU, Address.Address, Spec.FNKind, Spec.FLIKind, Result.FunctionName,
1237 Result.StartFileName, Result.StartLine, Result.StartAddress);
1238 if (Spec.FLIKind != FileLineInfoKind::None) {
1239 if (const DWARFLineTable *LineTable = getLineTableForUnit(CU)) {
1240 LineTable->getFileLineInfoForAddress(
1241 {Address.Address, Address.SectionIndex}, CU->getCompilationDir(),
1242 Spec.FLIKind, Result);
1243 }
1244 }
1245 return Result;
1246 }
1247
getLineInfoForAddressRange(object::SectionedAddress Address,uint64_t Size,DILineInfoSpecifier Spec)1248 DILineInfoTable DWARFContext::getLineInfoForAddressRange(
1249 object::SectionedAddress Address, uint64_t Size, DILineInfoSpecifier Spec) {
1250 DILineInfoTable Lines;
1251 DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
1252 if (!CU)
1253 return Lines;
1254
1255 uint32_t StartLine = 0;
1256 std::string StartFileName;
1257 std::string FunctionName(DILineInfo::BadString);
1258 Optional<uint64_t> StartAddress;
1259 getFunctionNameAndStartLineForAddress(CU, Address.Address, Spec.FNKind,
1260 Spec.FLIKind, FunctionName,
1261 StartFileName, StartLine, StartAddress);
1262
1263 // If the Specifier says we don't need FileLineInfo, just
1264 // return the top-most function at the starting address.
1265 if (Spec.FLIKind == FileLineInfoKind::None) {
1266 DILineInfo Result;
1267 Result.FunctionName = FunctionName;
1268 Result.StartFileName = StartFileName;
1269 Result.StartLine = StartLine;
1270 Result.StartAddress = StartAddress;
1271 Lines.push_back(std::make_pair(Address.Address, Result));
1272 return Lines;
1273 }
1274
1275 const DWARFLineTable *LineTable = getLineTableForUnit(CU);
1276
1277 // Get the index of row we're looking for in the line table.
1278 std::vector<uint32_t> RowVector;
1279 if (!LineTable->lookupAddressRange({Address.Address, Address.SectionIndex},
1280 Size, RowVector)) {
1281 return Lines;
1282 }
1283
1284 for (uint32_t RowIndex : RowVector) {
1285 // Take file number and line/column from the row.
1286 const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
1287 DILineInfo Result;
1288 LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(),
1289 Spec.FLIKind, Result.FileName);
1290 Result.FunctionName = FunctionName;
1291 Result.Line = Row.Line;
1292 Result.Column = Row.Column;
1293 Result.StartFileName = StartFileName;
1294 Result.StartLine = StartLine;
1295 Result.StartAddress = StartAddress;
1296 Lines.push_back(std::make_pair(Row.Address.Address, Result));
1297 }
1298
1299 return Lines;
1300 }
1301
1302 DIInliningInfo
getInliningInfoForAddress(object::SectionedAddress Address,DILineInfoSpecifier Spec)1303 DWARFContext::getInliningInfoForAddress(object::SectionedAddress Address,
1304 DILineInfoSpecifier Spec) {
1305 DIInliningInfo InliningInfo;
1306
1307 DWARFCompileUnit *CU = getCompileUnitForAddress(Address.Address);
1308 if (!CU)
1309 return InliningInfo;
1310
1311 const DWARFLineTable *LineTable = nullptr;
1312 SmallVector<DWARFDie, 4> InlinedChain;
1313 CU->getInlinedChainForAddress(Address.Address, InlinedChain);
1314 if (InlinedChain.size() == 0) {
1315 // If there is no DIE for address (e.g. it is in unavailable .dwo file),
1316 // try to at least get file/line info from symbol table.
1317 if (Spec.FLIKind != FileLineInfoKind::None) {
1318 DILineInfo Frame;
1319 LineTable = getLineTableForUnit(CU);
1320 if (LineTable && LineTable->getFileLineInfoForAddress(
1321 {Address.Address, Address.SectionIndex},
1322 CU->getCompilationDir(), Spec.FLIKind, Frame))
1323 InliningInfo.addFrame(Frame);
1324 }
1325 return InliningInfo;
1326 }
1327
1328 uint32_t CallFile = 0, CallLine = 0, CallColumn = 0, CallDiscriminator = 0;
1329 for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) {
1330 DWARFDie &FunctionDIE = InlinedChain[i];
1331 DILineInfo Frame;
1332 // Get function name if necessary.
1333 if (const char *Name = FunctionDIE.getSubroutineName(Spec.FNKind))
1334 Frame.FunctionName = Name;
1335 if (auto DeclLineResult = FunctionDIE.getDeclLine())
1336 Frame.StartLine = DeclLineResult;
1337 Frame.StartFileName = FunctionDIE.getDeclFile(Spec.FLIKind);
1338 if (auto LowPcAddr = toSectionedAddress(FunctionDIE.find(DW_AT_low_pc)))
1339 Frame.StartAddress = LowPcAddr->Address;
1340 if (Spec.FLIKind != FileLineInfoKind::None) {
1341 if (i == 0) {
1342 // For the topmost frame, initialize the line table of this
1343 // compile unit and fetch file/line info from it.
1344 LineTable = getLineTableForUnit(CU);
1345 // For the topmost routine, get file/line info from line table.
1346 if (LineTable)
1347 LineTable->getFileLineInfoForAddress(
1348 {Address.Address, Address.SectionIndex}, CU->getCompilationDir(),
1349 Spec.FLIKind, Frame);
1350 } else {
1351 // Otherwise, use call file, call line and call column from
1352 // previous DIE in inlined chain.
1353 if (LineTable)
1354 LineTable->getFileNameByIndex(CallFile, CU->getCompilationDir(),
1355 Spec.FLIKind, Frame.FileName);
1356 Frame.Line = CallLine;
1357 Frame.Column = CallColumn;
1358 Frame.Discriminator = CallDiscriminator;
1359 }
1360 // Get call file/line/column of a current DIE.
1361 if (i + 1 < n) {
1362 FunctionDIE.getCallerFrame(CallFile, CallLine, CallColumn,
1363 CallDiscriminator);
1364 }
1365 }
1366 InliningInfo.addFrame(Frame);
1367 }
1368 return InliningInfo;
1369 }
1370
1371 std::shared_ptr<DWARFContext>
getDWOContext(StringRef AbsolutePath)1372 DWARFContext::getDWOContext(StringRef AbsolutePath) {
1373 if (auto S = DWP.lock()) {
1374 DWARFContext *Ctxt = S->Context.get();
1375 return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1376 }
1377
1378 std::weak_ptr<DWOFile> *Entry = &DWOFiles[AbsolutePath];
1379
1380 if (auto S = Entry->lock()) {
1381 DWARFContext *Ctxt = S->Context.get();
1382 return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1383 }
1384
1385 Expected<OwningBinary<ObjectFile>> Obj = [&] {
1386 if (!CheckedForDWP) {
1387 SmallString<128> DWPName;
1388 auto Obj = object::ObjectFile::createObjectFile(
1389 this->DWPName.empty()
1390 ? (DObj->getFileName() + ".dwp").toStringRef(DWPName)
1391 : StringRef(this->DWPName));
1392 if (Obj) {
1393 Entry = &DWP;
1394 return Obj;
1395 } else {
1396 CheckedForDWP = true;
1397 // TODO: Should this error be handled (maybe in a high verbosity mode)
1398 // before falling back to .dwo files?
1399 consumeError(Obj.takeError());
1400 }
1401 }
1402
1403 return object::ObjectFile::createObjectFile(AbsolutePath);
1404 }();
1405
1406 if (!Obj) {
1407 // TODO: Actually report errors helpfully.
1408 consumeError(Obj.takeError());
1409 return nullptr;
1410 }
1411
1412 auto S = std::make_shared<DWOFile>();
1413 S->File = std::move(Obj.get());
1414 S->Context = DWARFContext::create(*S->File.getBinary());
1415 *Entry = S;
1416 auto *Ctxt = S->Context.get();
1417 return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1418 }
1419
createError(const Twine & Reason,llvm::Error E)1420 static Error createError(const Twine &Reason, llvm::Error E) {
1421 return make_error<StringError>(Reason + toString(std::move(E)),
1422 inconvertibleErrorCode());
1423 }
1424
1425 /// SymInfo contains information about symbol: it's address
1426 /// and section index which is -1LL for absolute symbols.
1427 struct SymInfo {
1428 uint64_t Address;
1429 uint64_t SectionIndex;
1430 };
1431
1432 /// Returns the address of symbol relocation used against and a section index.
1433 /// 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)1434 static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj,
1435 const RelocationRef &Reloc,
1436 const LoadedObjectInfo *L,
1437 std::map<SymbolRef, SymInfo> &Cache) {
1438 SymInfo Ret = {0, (uint64_t)-1LL};
1439 object::section_iterator RSec = Obj.section_end();
1440 object::symbol_iterator Sym = Reloc.getSymbol();
1441
1442 std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end();
1443 // First calculate the address of the symbol or section as it appears
1444 // in the object file
1445 if (Sym != Obj.symbol_end()) {
1446 bool New;
1447 std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}});
1448 if (!New)
1449 return CacheIt->second;
1450
1451 Expected<uint64_t> SymAddrOrErr = Sym->getAddress();
1452 if (!SymAddrOrErr)
1453 return createError("failed to compute symbol address: ",
1454 SymAddrOrErr.takeError());
1455
1456 // Also remember what section this symbol is in for later
1457 auto SectOrErr = Sym->getSection();
1458 if (!SectOrErr)
1459 return createError("failed to get symbol section: ",
1460 SectOrErr.takeError());
1461
1462 RSec = *SectOrErr;
1463 Ret.Address = *SymAddrOrErr;
1464 } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) {
1465 RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl());
1466 Ret.Address = RSec->getAddress();
1467 }
1468
1469 if (RSec != Obj.section_end())
1470 Ret.SectionIndex = RSec->getIndex();
1471
1472 // If we are given load addresses for the sections, we need to adjust:
1473 // SymAddr = (Address of Symbol Or Section in File) -
1474 // (Address of Section in File) +
1475 // (Load Address of Section)
1476 // RSec is now either the section being targeted or the section
1477 // containing the symbol being targeted. In either case,
1478 // we need to perform the same computation.
1479 if (L && RSec != Obj.section_end())
1480 if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(*RSec))
1481 Ret.Address += SectionLoadAddress - RSec->getAddress();
1482
1483 if (CacheIt != Cache.end())
1484 CacheIt->second = Ret;
1485
1486 return Ret;
1487 }
1488
isRelocScattered(const object::ObjectFile & Obj,const RelocationRef & Reloc)1489 static bool isRelocScattered(const object::ObjectFile &Obj,
1490 const RelocationRef &Reloc) {
1491 const MachOObjectFile *MachObj = dyn_cast<MachOObjectFile>(&Obj);
1492 if (!MachObj)
1493 return false;
1494 // MachO also has relocations that point to sections and
1495 // scattered relocations.
1496 auto RelocInfo = MachObj->getRelocation(Reloc.getRawDataRefImpl());
1497 return MachObj->isRelocationScattered(RelocInfo);
1498 }
1499
1500 namespace {
1501 struct DWARFSectionMap final : public DWARFSection {
1502 RelocAddrMap Relocs;
1503 };
1504
1505 class DWARFObjInMemory final : public DWARFObject {
1506 bool IsLittleEndian;
1507 uint8_t AddressSize;
1508 StringRef FileName;
1509 const object::ObjectFile *Obj = nullptr;
1510 std::vector<SectionName> SectionNames;
1511
1512 using InfoSectionMap = MapVector<object::SectionRef, DWARFSectionMap,
1513 std::map<object::SectionRef, unsigned>>;
1514
1515 InfoSectionMap InfoSections;
1516 InfoSectionMap TypesSections;
1517 InfoSectionMap InfoDWOSections;
1518 InfoSectionMap TypesDWOSections;
1519
1520 DWARFSectionMap LocSection;
1521 DWARFSectionMap LoclistsSection;
1522 DWARFSectionMap LoclistsDWOSection;
1523 DWARFSectionMap LineSection;
1524 DWARFSectionMap RangesSection;
1525 DWARFSectionMap RnglistsSection;
1526 DWARFSectionMap StrOffsetsSection;
1527 DWARFSectionMap LineDWOSection;
1528 DWARFSectionMap FrameSection;
1529 DWARFSectionMap EHFrameSection;
1530 DWARFSectionMap LocDWOSection;
1531 DWARFSectionMap StrOffsetsDWOSection;
1532 DWARFSectionMap RangesDWOSection;
1533 DWARFSectionMap RnglistsDWOSection;
1534 DWARFSectionMap AddrSection;
1535 DWARFSectionMap AppleNamesSection;
1536 DWARFSectionMap AppleTypesSection;
1537 DWARFSectionMap AppleNamespacesSection;
1538 DWARFSectionMap AppleObjCSection;
1539 DWARFSectionMap NamesSection;
1540 DWARFSectionMap PubnamesSection;
1541 DWARFSectionMap PubtypesSection;
1542 DWARFSectionMap GnuPubnamesSection;
1543 DWARFSectionMap GnuPubtypesSection;
1544 DWARFSectionMap MacroSection;
1545
mapNameToDWARFSection(StringRef Name)1546 DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
1547 return StringSwitch<DWARFSectionMap *>(Name)
1548 .Case("debug_loc", &LocSection)
1549 .Case("debug_loclists", &LoclistsSection)
1550 .Case("debug_loclists.dwo", &LoclistsDWOSection)
1551 .Case("debug_line", &LineSection)
1552 .Case("debug_frame", &FrameSection)
1553 .Case("eh_frame", &EHFrameSection)
1554 .Case("debug_str_offsets", &StrOffsetsSection)
1555 .Case("debug_ranges", &RangesSection)
1556 .Case("debug_rnglists", &RnglistsSection)
1557 .Case("debug_loc.dwo", &LocDWOSection)
1558 .Case("debug_line.dwo", &LineDWOSection)
1559 .Case("debug_names", &NamesSection)
1560 .Case("debug_rnglists.dwo", &RnglistsDWOSection)
1561 .Case("debug_str_offsets.dwo", &StrOffsetsDWOSection)
1562 .Case("debug_addr", &AddrSection)
1563 .Case("apple_names", &AppleNamesSection)
1564 .Case("debug_pubnames", &PubnamesSection)
1565 .Case("debug_pubtypes", &PubtypesSection)
1566 .Case("debug_gnu_pubnames", &GnuPubnamesSection)
1567 .Case("debug_gnu_pubtypes", &GnuPubtypesSection)
1568 .Case("apple_types", &AppleTypesSection)
1569 .Case("apple_namespaces", &AppleNamespacesSection)
1570 .Case("apple_namespac", &AppleNamespacesSection)
1571 .Case("apple_objc", &AppleObjCSection)
1572 .Case("debug_macro", &MacroSection)
1573 .Default(nullptr);
1574 }
1575
1576 StringRef AbbrevSection;
1577 StringRef ArangesSection;
1578 StringRef StrSection;
1579 StringRef MacinfoSection;
1580 StringRef MacinfoDWOSection;
1581 StringRef MacroDWOSection;
1582 StringRef AbbrevDWOSection;
1583 StringRef StrDWOSection;
1584 StringRef CUIndexSection;
1585 StringRef GdbIndexSection;
1586 StringRef TUIndexSection;
1587 StringRef LineStrSection;
1588
1589 // A deque holding section data whose iterators are not invalidated when
1590 // new decompressed sections are inserted at the end.
1591 std::deque<SmallString<0>> UncompressedSections;
1592
mapSectionToMember(StringRef Name)1593 StringRef *mapSectionToMember(StringRef Name) {
1594 if (DWARFSection *Sec = mapNameToDWARFSection(Name))
1595 return &Sec->Data;
1596 return StringSwitch<StringRef *>(Name)
1597 .Case("debug_abbrev", &AbbrevSection)
1598 .Case("debug_aranges", &ArangesSection)
1599 .Case("debug_str", &StrSection)
1600 .Case("debug_macinfo", &MacinfoSection)
1601 .Case("debug_macinfo.dwo", &MacinfoDWOSection)
1602 .Case("debug_macro.dwo", &MacroDWOSection)
1603 .Case("debug_abbrev.dwo", &AbbrevDWOSection)
1604 .Case("debug_str.dwo", &StrDWOSection)
1605 .Case("debug_cu_index", &CUIndexSection)
1606 .Case("debug_tu_index", &TUIndexSection)
1607 .Case("gdb_index", &GdbIndexSection)
1608 .Case("debug_line_str", &LineStrSection)
1609 // Any more debug info sections go here.
1610 .Default(nullptr);
1611 }
1612
1613 /// If Sec is compressed section, decompresses and updates its contents
1614 /// provided by Data. Otherwise leaves it unchanged.
maybeDecompress(const object::SectionRef & Sec,StringRef Name,StringRef & Data)1615 Error maybeDecompress(const object::SectionRef &Sec, StringRef Name,
1616 StringRef &Data) {
1617 if (!Decompressor::isCompressed(Sec))
1618 return Error::success();
1619
1620 Expected<Decompressor> Decompressor =
1621 Decompressor::create(Name, Data, IsLittleEndian, AddressSize == 8);
1622 if (!Decompressor)
1623 return Decompressor.takeError();
1624
1625 SmallString<0> Out;
1626 if (auto Err = Decompressor->resizeAndDecompress(Out))
1627 return Err;
1628
1629 UncompressedSections.push_back(std::move(Out));
1630 Data = UncompressedSections.back();
1631
1632 return Error::success();
1633 }
1634
1635 public:
DWARFObjInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> & Sections,uint8_t AddrSize,bool IsLittleEndian)1636 DWARFObjInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
1637 uint8_t AddrSize, bool IsLittleEndian)
1638 : IsLittleEndian(IsLittleEndian) {
1639 for (const auto &SecIt : Sections) {
1640 if (StringRef *SectionData = mapSectionToMember(SecIt.first()))
1641 *SectionData = SecIt.second->getBuffer();
1642 else if (SecIt.first() == "debug_info")
1643 // Find debug_info and debug_types data by section rather than name as
1644 // there are multiple, comdat grouped, of these sections.
1645 InfoSections[SectionRef()].Data = SecIt.second->getBuffer();
1646 else if (SecIt.first() == "debug_info.dwo")
1647 InfoDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
1648 else if (SecIt.first() == "debug_types")
1649 TypesSections[SectionRef()].Data = SecIt.second->getBuffer();
1650 else if (SecIt.first() == "debug_types.dwo")
1651 TypesDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
1652 }
1653 }
DWARFObjInMemory(const object::ObjectFile & Obj,const LoadedObjectInfo * L,function_ref<void (Error)> HandleError,function_ref<void (Error)> HandleWarning)1654 DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
1655 function_ref<void(Error)> HandleError, function_ref<void(Error)> HandleWarning )
1656 : IsLittleEndian(Obj.isLittleEndian()),
1657 AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()),
1658 Obj(&Obj) {
1659
1660 StringMap<unsigned> SectionAmountMap;
1661 for (const SectionRef &Section : Obj.sections()) {
1662 StringRef Name;
1663 if (auto NameOrErr = Section.getName())
1664 Name = *NameOrErr;
1665 else
1666 consumeError(NameOrErr.takeError());
1667
1668 ++SectionAmountMap[Name];
1669 SectionNames.push_back({ Name, true });
1670
1671 // Skip BSS and Virtual sections, they aren't interesting.
1672 if (Section.isBSS() || Section.isVirtual())
1673 continue;
1674
1675 // Skip sections stripped by dsymutil.
1676 if (Section.isStripped())
1677 continue;
1678
1679 StringRef Data;
1680 Expected<section_iterator> SecOrErr = Section.getRelocatedSection();
1681 if (!SecOrErr) {
1682 HandleError(createError("failed to get relocated section: ",
1683 SecOrErr.takeError()));
1684 continue;
1685 }
1686
1687 // Try to obtain an already relocated version of this section.
1688 // Else use the unrelocated section from the object file. We'll have to
1689 // apply relocations ourselves later.
1690 section_iterator RelocatedSection =
1691 Obj.isRelocatableObject() ? *SecOrErr : Obj.section_end();
1692 if (!L || !L->getLoadedSectionContents(*RelocatedSection, Data)) {
1693 Expected<StringRef> E = Section.getContents();
1694 if (E)
1695 Data = *E;
1696 else
1697 // maybeDecompress below will error.
1698 consumeError(E.takeError());
1699 }
1700
1701 if (auto Err = maybeDecompress(Section, Name, Data)) {
1702 HandleError(createError("failed to decompress '" + Name + "', ",
1703 std::move(Err)));
1704 continue;
1705 }
1706
1707 // Compressed sections names in GNU style starts from ".z",
1708 // at this point section is decompressed and we drop compression prefix.
1709 Name = Name.substr(
1710 Name.find_first_not_of("._z")); // Skip ".", "z" and "_" prefixes.
1711
1712 // Map platform specific debug section names to DWARF standard section
1713 // names.
1714 Name = Obj.mapDebugSectionName(Name);
1715
1716 if (StringRef *SectionData = mapSectionToMember(Name)) {
1717 *SectionData = Data;
1718 if (Name == "debug_ranges") {
1719 // FIXME: Use the other dwo range section when we emit it.
1720 RangesDWOSection.Data = Data;
1721 } else if (Name == "debug_frame" || Name == "eh_frame") {
1722 if (DWARFSection *S = mapNameToDWARFSection(Name))
1723 S->Address = Section.getAddress();
1724 }
1725 } else if (InfoSectionMap *Sections =
1726 StringSwitch<InfoSectionMap *>(Name)
1727 .Case("debug_info", &InfoSections)
1728 .Case("debug_info.dwo", &InfoDWOSections)
1729 .Case("debug_types", &TypesSections)
1730 .Case("debug_types.dwo", &TypesDWOSections)
1731 .Default(nullptr)) {
1732 // Find debug_info and debug_types data by section rather than name as
1733 // there are multiple, comdat grouped, of these sections.
1734 DWARFSectionMap &S = (*Sections)[Section];
1735 S.Data = Data;
1736 }
1737
1738 if (RelocatedSection == Obj.section_end())
1739 continue;
1740
1741 StringRef RelSecName;
1742 if (auto NameOrErr = RelocatedSection->getName())
1743 RelSecName = *NameOrErr;
1744 else
1745 consumeError(NameOrErr.takeError());
1746
1747 // If the section we're relocating was relocated already by the JIT,
1748 // then we used the relocated version above, so we do not need to process
1749 // relocations for it now.
1750 StringRef RelSecData;
1751 if (L && L->getLoadedSectionContents(*RelocatedSection, RelSecData))
1752 continue;
1753
1754 // In Mach-o files, the relocations do not need to be applied if
1755 // there is no load offset to apply. The value read at the
1756 // relocation point already factors in the section address
1757 // (actually applying the relocations will produce wrong results
1758 // as the section address will be added twice).
1759 if (!L && isa<MachOObjectFile>(&Obj))
1760 continue;
1761
1762 RelSecName = RelSecName.substr(
1763 RelSecName.find_first_not_of("._z")); // Skip . and _ prefixes.
1764
1765 // TODO: Add support for relocations in other sections as needed.
1766 // Record relocations for the debug_info and debug_line sections.
1767 DWARFSectionMap *Sec = mapNameToDWARFSection(RelSecName);
1768 RelocAddrMap *Map = Sec ? &Sec->Relocs : nullptr;
1769 if (!Map) {
1770 // Find debug_info and debug_types relocs by section rather than name
1771 // as there are multiple, comdat grouped, of these sections.
1772 if (RelSecName == "debug_info")
1773 Map = &static_cast<DWARFSectionMap &>(InfoSections[*RelocatedSection])
1774 .Relocs;
1775 else if (RelSecName == "debug_info.dwo")
1776 Map = &static_cast<DWARFSectionMap &>(
1777 InfoDWOSections[*RelocatedSection])
1778 .Relocs;
1779 else if (RelSecName == "debug_types")
1780 Map =
1781 &static_cast<DWARFSectionMap &>(TypesSections[*RelocatedSection])
1782 .Relocs;
1783 else if (RelSecName == "debug_types.dwo")
1784 Map = &static_cast<DWARFSectionMap &>(
1785 TypesDWOSections[*RelocatedSection])
1786 .Relocs;
1787 else
1788 continue;
1789 }
1790
1791 if (Section.relocation_begin() == Section.relocation_end())
1792 continue;
1793
1794 // Symbol to [address, section index] cache mapping.
1795 std::map<SymbolRef, SymInfo> AddrCache;
1796 SupportsRelocation Supports;
1797 RelocationResolver Resolver;
1798 std::tie(Supports, Resolver) = getRelocationResolver(Obj);
1799 for (const RelocationRef &Reloc : Section.relocations()) {
1800 // FIXME: it's not clear how to correctly handle scattered
1801 // relocations.
1802 if (isRelocScattered(Obj, Reloc))
1803 continue;
1804
1805 Expected<SymInfo> SymInfoOrErr =
1806 getSymbolInfo(Obj, Reloc, L, AddrCache);
1807 if (!SymInfoOrErr) {
1808 HandleError(SymInfoOrErr.takeError());
1809 continue;
1810 }
1811
1812 // Check if Resolver can handle this relocation type early so as not to
1813 // handle invalid cases in DWARFDataExtractor.
1814 //
1815 // TODO Don't store Resolver in every RelocAddrEntry.
1816 if (Supports && Supports(Reloc.getType())) {
1817 auto I = Map->try_emplace(
1818 Reloc.getOffset(),
1819 RelocAddrEntry{SymInfoOrErr->SectionIndex, Reloc,
1820 SymInfoOrErr->Address,
1821 Optional<object::RelocationRef>(), 0, Resolver});
1822 // If we didn't successfully insert that's because we already had a
1823 // relocation for that offset. Store it as a second relocation in the
1824 // same RelocAddrEntry instead.
1825 if (!I.second) {
1826 RelocAddrEntry &entry = I.first->getSecond();
1827 if (entry.Reloc2) {
1828 HandleError(createError(
1829 "At most two relocations per offset are supported"));
1830 }
1831 entry.Reloc2 = Reloc;
1832 entry.SymbolValue2 = SymInfoOrErr->Address;
1833 }
1834 } else {
1835 SmallString<32> Type;
1836 Reloc.getTypeName(Type);
1837 // FIXME: Support more relocations & change this to an error
1838 HandleWarning(
1839 createError("failed to compute relocation: " + Type + ", ",
1840 errorCodeToError(object_error::parse_failed)));
1841 }
1842 }
1843 }
1844
1845 for (SectionName &S : SectionNames)
1846 if (SectionAmountMap[S.Name] > 1)
1847 S.IsNameUnique = false;
1848 }
1849
find(const DWARFSection & S,uint64_t Pos) const1850 Optional<RelocAddrEntry> find(const DWARFSection &S,
1851 uint64_t Pos) const override {
1852 auto &Sec = static_cast<const DWARFSectionMap &>(S);
1853 RelocAddrMap::const_iterator AI = Sec.Relocs.find(Pos);
1854 if (AI == Sec.Relocs.end())
1855 return None;
1856 return AI->second;
1857 }
1858
getFile() const1859 const object::ObjectFile *getFile() const override { return Obj; }
1860
getSectionNames() const1861 ArrayRef<SectionName> getSectionNames() const override {
1862 return SectionNames;
1863 }
1864
isLittleEndian() const1865 bool isLittleEndian() const override { return IsLittleEndian; }
getAbbrevDWOSection() const1866 StringRef getAbbrevDWOSection() const override { return AbbrevDWOSection; }
getLineDWOSection() const1867 const DWARFSection &getLineDWOSection() const override {
1868 return LineDWOSection;
1869 }
getLocDWOSection() const1870 const DWARFSection &getLocDWOSection() const override {
1871 return LocDWOSection;
1872 }
getStrDWOSection() const1873 StringRef getStrDWOSection() const override { return StrDWOSection; }
getStrOffsetsDWOSection() const1874 const DWARFSection &getStrOffsetsDWOSection() const override {
1875 return StrOffsetsDWOSection;
1876 }
getRangesDWOSection() const1877 const DWARFSection &getRangesDWOSection() const override {
1878 return RangesDWOSection;
1879 }
getRnglistsDWOSection() const1880 const DWARFSection &getRnglistsDWOSection() const override {
1881 return RnglistsDWOSection;
1882 }
getLoclistsDWOSection() const1883 const DWARFSection &getLoclistsDWOSection() const override {
1884 return LoclistsDWOSection;
1885 }
getAddrSection() const1886 const DWARFSection &getAddrSection() const override { return AddrSection; }
getCUIndexSection() const1887 StringRef getCUIndexSection() const override { return CUIndexSection; }
getGdbIndexSection() const1888 StringRef getGdbIndexSection() const override { return GdbIndexSection; }
getTUIndexSection() const1889 StringRef getTUIndexSection() const override { return TUIndexSection; }
1890
1891 // DWARF v5
getStrOffsetsSection() const1892 const DWARFSection &getStrOffsetsSection() const override {
1893 return StrOffsetsSection;
1894 }
getLineStrSection() const1895 StringRef getLineStrSection() const override { return LineStrSection; }
1896
1897 // Sections for DWARF5 split dwarf proposal.
forEachInfoDWOSections(function_ref<void (const DWARFSection &)> F) const1898 void forEachInfoDWOSections(
1899 function_ref<void(const DWARFSection &)> F) const override {
1900 for (auto &P : InfoDWOSections)
1901 F(P.second);
1902 }
forEachTypesDWOSections(function_ref<void (const DWARFSection &)> F) const1903 void forEachTypesDWOSections(
1904 function_ref<void(const DWARFSection &)> F) const override {
1905 for (auto &P : TypesDWOSections)
1906 F(P.second);
1907 }
1908
getAbbrevSection() const1909 StringRef getAbbrevSection() const override { return AbbrevSection; }
getLocSection() const1910 const DWARFSection &getLocSection() const override { return LocSection; }
getLoclistsSection() const1911 const DWARFSection &getLoclistsSection() const override { return LoclistsSection; }
getArangesSection() const1912 StringRef getArangesSection() const override { return ArangesSection; }
getFrameSection() const1913 const DWARFSection &getFrameSection() const override {
1914 return FrameSection;
1915 }
getEHFrameSection() const1916 const DWARFSection &getEHFrameSection() const override {
1917 return EHFrameSection;
1918 }
getLineSection() const1919 const DWARFSection &getLineSection() const override { return LineSection; }
getStrSection() const1920 StringRef getStrSection() const override { return StrSection; }
getRangesSection() const1921 const DWARFSection &getRangesSection() const override { return RangesSection; }
getRnglistsSection() const1922 const DWARFSection &getRnglistsSection() const override {
1923 return RnglistsSection;
1924 }
getMacroSection() const1925 const DWARFSection &getMacroSection() const override { return MacroSection; }
getMacroDWOSection() const1926 StringRef getMacroDWOSection() const override { return MacroDWOSection; }
getMacinfoSection() const1927 StringRef getMacinfoSection() const override { return MacinfoSection; }
getMacinfoDWOSection() const1928 StringRef getMacinfoDWOSection() const override { return MacinfoDWOSection; }
getPubnamesSection() const1929 const DWARFSection &getPubnamesSection() const override { return PubnamesSection; }
getPubtypesSection() const1930 const DWARFSection &getPubtypesSection() const override { return PubtypesSection; }
getGnuPubnamesSection() const1931 const DWARFSection &getGnuPubnamesSection() const override {
1932 return GnuPubnamesSection;
1933 }
getGnuPubtypesSection() const1934 const DWARFSection &getGnuPubtypesSection() const override {
1935 return GnuPubtypesSection;
1936 }
getAppleNamesSection() const1937 const DWARFSection &getAppleNamesSection() const override {
1938 return AppleNamesSection;
1939 }
getAppleTypesSection() const1940 const DWARFSection &getAppleTypesSection() const override {
1941 return AppleTypesSection;
1942 }
getAppleNamespacesSection() const1943 const DWARFSection &getAppleNamespacesSection() const override {
1944 return AppleNamespacesSection;
1945 }
getAppleObjCSection() const1946 const DWARFSection &getAppleObjCSection() const override {
1947 return AppleObjCSection;
1948 }
getNamesSection() const1949 const DWARFSection &getNamesSection() const override {
1950 return NamesSection;
1951 }
1952
getFileName() const1953 StringRef getFileName() const override { return FileName; }
getAddressSize() const1954 uint8_t getAddressSize() const override { return AddressSize; }
forEachInfoSections(function_ref<void (const DWARFSection &)> F) const1955 void forEachInfoSections(
1956 function_ref<void(const DWARFSection &)> F) const override {
1957 for (auto &P : InfoSections)
1958 F(P.second);
1959 }
forEachTypesSections(function_ref<void (const DWARFSection &)> F) const1960 void forEachTypesSections(
1961 function_ref<void(const DWARFSection &)> F) const override {
1962 for (auto &P : TypesSections)
1963 F(P.second);
1964 }
1965 };
1966 } // namespace
1967
1968 std::unique_ptr<DWARFContext>
create(const object::ObjectFile & Obj,const LoadedObjectInfo * L,std::string DWPName,std::function<void (Error)> RecoverableErrorHandler,std::function<void (Error)> WarningHandler)1969 DWARFContext::create(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
1970 std::string DWPName,
1971 std::function<void(Error)> RecoverableErrorHandler,
1972 std::function<void(Error)> WarningHandler) {
1973 auto DObj =
1974 std::make_unique<DWARFObjInMemory>(Obj, L, RecoverableErrorHandler, WarningHandler);
1975 return std::make_unique<DWARFContext>(std::move(DObj), std::move(DWPName),
1976 RecoverableErrorHandler,
1977 WarningHandler);
1978 }
1979
1980 std::unique_ptr<DWARFContext>
create(const StringMap<std::unique_ptr<MemoryBuffer>> & Sections,uint8_t AddrSize,bool isLittleEndian,std::function<void (Error)> RecoverableErrorHandler,std::function<void (Error)> WarningHandler)1981 DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
1982 uint8_t AddrSize, bool isLittleEndian,
1983 std::function<void(Error)> RecoverableErrorHandler,
1984 std::function<void(Error)> WarningHandler) {
1985 auto DObj =
1986 std::make_unique<DWARFObjInMemory>(Sections, AddrSize, isLittleEndian);
1987 return std::make_unique<DWARFContext>(
1988 std::move(DObj), "", RecoverableErrorHandler, WarningHandler);
1989 }
1990
loadRegisterInfo(const object::ObjectFile & Obj)1991 Error DWARFContext::loadRegisterInfo(const object::ObjectFile &Obj) {
1992 // Detect the architecture from the object file. We usually don't need OS
1993 // info to lookup a target and create register info.
1994 Triple TT;
1995 TT.setArch(Triple::ArchType(Obj.getArch()));
1996 TT.setVendor(Triple::UnknownVendor);
1997 TT.setOS(Triple::UnknownOS);
1998 std::string TargetLookupError;
1999 const Target *TheTarget =
2000 TargetRegistry::lookupTarget(TT.str(), TargetLookupError);
2001 if (!TargetLookupError.empty())
2002 return createStringError(errc::invalid_argument,
2003 TargetLookupError.c_str());
2004 RegInfo.reset(TheTarget->createMCRegInfo(TT.str()));
2005 return Error::success();
2006 }
2007
getCUAddrSize()2008 uint8_t DWARFContext::getCUAddrSize() {
2009 // In theory, different compile units may have different address byte
2010 // sizes, but for simplicity we just use the address byte size of the
2011 // first compile unit. In practice the address size field is repeated across
2012 // various DWARF headers (at least in version 5) to make it easier to dump
2013 // them independently, not to enable varying the address size.
2014 auto CUs = compile_units();
2015 return CUs.empty() ? 0 : (*CUs.begin())->getAddressByteSize();
2016 }
2017