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