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