LLVM  14.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"
36 #include "llvm/MC/TargetRegistry.h"
38 #include "llvm/Object/MachO.h"
39 #include "llvm/Object/ObjectFile.h"
41 #include "llvm/Support/Casting.h"
43 #include "llvm/Support/Error.h"
44 #include "llvm/Support/Format.h"
45 #include "llvm/Support/LEB128.h"
47 #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.
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"
1041  std::string &FunctionName, std::string &StartFile, uint32_t &StartLine,
1042  Optional<uint64_t> &StartAddress) {
1043  // The address may correspond to instruction in some inlined function,
1044  // so we have to build the chain of inlined functions and take the
1045  // name of the topmost function in it.
1046  SmallVector<DWARFDie, 4> InlinedChain;
1047  CU->getInlinedChainForAddress(Address, InlinedChain);
1048  if (InlinedChain.empty())
1049  return false;
1050 
1051  const DWARFDie &DIE = InlinedChain[0];
1052  bool FoundResult = false;
1053  const char *Name = nullptr;
1054  if (Kind != FunctionNameKind::None && (Name = DIE.getSubroutineName(Kind))) {
1055  FunctionName = Name;
1056  FoundResult = true;
1057  }
1058  std::string DeclFile = DIE.getDeclFile(FileNameKind);
1059  if (!DeclFile.empty()) {
1060  StartFile = DeclFile;
1061  FoundResult = true;
1062  }
1063  if (auto DeclLineResult = DIE.getDeclLine()) {
1064  StartLine = DeclLineResult;
1065  FoundResult = true;
1066  }
1067  if (auto LowPcAddr = toSectionedAddress(DIE.find(DW_AT_low_pc)))
1068  StartAddress = LowPcAddr->Address;
1069  return FoundResult;
1070 }
1071 
1073  if (auto SizeAttr = Type.find(DW_AT_byte_size))
1074  if (Optional<uint64_t> Size = SizeAttr->getAsUnsignedConstant())
1075  return Size;
1076 
1077  switch (Type.getTag()) {
1078  case DW_TAG_pointer_type:
1079  case DW_TAG_reference_type:
1080  case DW_TAG_rvalue_reference_type:
1081  return PointerSize;
1082  case DW_TAG_ptr_to_member_type: {
1083  if (DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type))
1084  if (BaseType.getTag() == DW_TAG_subroutine_type)
1085  return 2 * PointerSize;
1086  return PointerSize;
1087  }
1088  case DW_TAG_const_type:
1089  case DW_TAG_volatile_type:
1090  case DW_TAG_restrict_type:
1091  case DW_TAG_typedef: {
1092  if (DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type))
1093  return getTypeSize(BaseType, PointerSize);
1094  break;
1095  }
1096  case DW_TAG_array_type: {
1097  DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type);
1098  if (!BaseType)
1099  return Optional<uint64_t>();
1101  if (!BaseSize)
1102  return Optional<uint64_t>();
1103  uint64_t Size = *BaseSize;
1104  for (DWARFDie Child : Type) {
1105  if (Child.getTag() != DW_TAG_subrange_type)
1106  continue;
1107 
1108  if (auto ElemCountAttr = Child.find(DW_AT_count))
1109  if (Optional<uint64_t> ElemCount =
1110  ElemCountAttr->getAsUnsignedConstant())
1111  Size *= *ElemCount;
1112  if (auto UpperBoundAttr = Child.find(DW_AT_upper_bound))
1113  if (Optional<int64_t> UpperBound =
1114  UpperBoundAttr->getAsSignedConstant()) {
1115  int64_t LowerBound = 0;
1116  if (auto LowerBoundAttr = Child.find(DW_AT_lower_bound))
1117  LowerBound = LowerBoundAttr->getAsSignedConstant().getValueOr(0);
1118  Size *= *UpperBound - LowerBound + 1;
1119  }
1120  }
1121  return Size;
1122  }
1123  default:
1124  break;
1125  }
1126  return Optional<uint64_t>();
1127 }
1128 
1129 static Optional<int64_t>
1131  Optional<unsigned> FrameBaseReg) {
1132  if (!Expr.empty() &&
1133  (Expr[0] == DW_OP_fbreg ||
1134  (FrameBaseReg && Expr[0] == DW_OP_breg0 + *FrameBaseReg))) {
1135  unsigned Count;
1136  int64_t Offset = decodeSLEB128(Expr.data() + 1, &Count, Expr.end());
1137  // A single DW_OP_fbreg or DW_OP_breg.
1138  if (Expr.size() == Count + 1)
1139  return Offset;
1140  // Same + DW_OP_deref (Fortran arrays look like this).
1141  if (Expr.size() == Count + 2 && Expr[Count + 1] == DW_OP_deref)
1142  return Offset;
1143  // Fallthrough. Do not accept ex. (DW_OP_breg W29, DW_OP_stack_value)
1144  }
1145  return None;
1146 }
1147 
1148 void DWARFContext::addLocalsForDie(DWARFCompileUnit *CU, DWARFDie Subprogram,
1149  DWARFDie Die, std::vector<DILocal> &Result) {
1150  if (Die.getTag() == DW_TAG_variable ||
1151  Die.getTag() == DW_TAG_formal_parameter) {
1152  DILocal Local;
1153  if (const char *Name = Subprogram.getSubroutineName(DINameKind::ShortName))
1154  Local.FunctionName = Name;
1155 
1156  Optional<unsigned> FrameBaseReg;
1157  if (auto FrameBase = Subprogram.find(DW_AT_frame_base))
1158  if (Optional<ArrayRef<uint8_t>> Expr = FrameBase->getAsBlock())
1159  if (!Expr->empty() && (*Expr)[0] >= DW_OP_reg0 &&
1160  (*Expr)[0] <= DW_OP_reg31) {
1161  FrameBaseReg = (*Expr)[0] - DW_OP_reg0;
1162  }
1163 
1164  if (Expected<std::vector<DWARFLocationExpression>> Loc =
1165  Die.getLocations(DW_AT_location)) {
1166  for (const auto &Entry : *Loc) {
1167  if (Optional<int64_t> FrameOffset =
1168  getExpressionFrameOffset(Entry.Expr, FrameBaseReg)) {
1169  Local.FrameOffset = *FrameOffset;
1170  break;
1171  }
1172  }
1173  } else {
1174  // FIXME: missing DW_AT_location is OK here, but other errors should be
1175  // reported to the user.
1176  consumeError(Loc.takeError());
1177  }
1178 
1179  if (auto TagOffsetAttr = Die.find(DW_AT_LLVM_tag_offset))
1180  Local.TagOffset = TagOffsetAttr->getAsUnsignedConstant();
1181 
1182  if (auto Origin =
1183  Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
1184  Die = Origin;
1185  if (auto NameAttr = Die.find(DW_AT_name))
1186  if (Optional<const char *> Name = NameAttr->getAsCString())
1187  Local.Name = *Name;
1188  if (auto Type = Die.getAttributeValueAsReferencedDie(DW_AT_type))
1189  Local.Size = getTypeSize(Type, getCUAddrSize());
1190  if (auto DeclFileAttr = Die.find(DW_AT_decl_file)) {
1191  if (const auto *LT = CU->getContext().getLineTableForUnit(CU))
1192  LT->getFileNameByIndex(
1193  DeclFileAttr->getAsUnsignedConstant().getValue(),
1194  CU->getCompilationDir(),
1196  Local.DeclFile);
1197  }
1198  if (auto DeclLineAttr = Die.find(DW_AT_decl_line))
1199  Local.DeclLine = DeclLineAttr->getAsUnsignedConstant().getValue();
1200 
1201  Result.push_back(Local);
1202  return;
1203  }
1204 
1205  if (Die.getTag() == DW_TAG_inlined_subroutine)
1206  if (auto Origin =
1207  Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
1208  Subprogram = Origin;
1209 
1210  for (auto Child : Die)
1211  addLocalsForDie(CU, Subprogram, Child, Result);
1212 }
1213 
1214 std::vector<DILocal>
1216  std::vector<DILocal> Result;
1218  if (!CU)
1219  return Result;
1220 
1221  DWARFDie Subprogram = CU->getSubroutineForAddress(Address.Address);
1222  if (Subprogram.isValid())
1223  addLocalsForDie(CU, Subprogram, Subprogram, Result);
1224  return Result;
1225 }
1226 
1228  DILineInfoSpecifier Spec) {
1229  DILineInfo Result;
1230 
1232  if (!CU)
1233  return Result;
1234 
1236  CU, Address.Address, Spec.FNKind, Spec.FLIKind, Result.FunctionName,
1237  Result.StartFileName, Result.StartLine, Result.StartAddress);
1238  if (Spec.FLIKind != FileLineInfoKind::None) {
1239  if (const DWARFLineTable *LineTable = getLineTableForUnit(CU)) {
1240  LineTable->getFileLineInfoForAddress(
1241  {Address.Address, Address.SectionIndex}, CU->getCompilationDir(),
1242  Spec.FLIKind, Result);
1243  }
1244  }
1245  return Result;
1246 }
1247 
1250  DILineInfoTable Lines;
1252  if (!CU)
1253  return Lines;
1254 
1255  uint32_t StartLine = 0;
1256  std::string StartFileName;
1257  std::string FunctionName(DILineInfo::BadString);
1258  Optional<uint64_t> StartAddress;
1260  Spec.FLIKind, FunctionName,
1261  StartFileName, StartLine, StartAddress);
1262 
1263  // If the Specifier says we don't need FileLineInfo, just
1264  // return the top-most function at the starting address.
1265  if (Spec.FLIKind == FileLineInfoKind::None) {
1266  DILineInfo Result;
1267  Result.FunctionName = FunctionName;
1268  Result.StartFileName = StartFileName;
1269  Result.StartLine = StartLine;
1270  Result.StartAddress = StartAddress;
1271  Lines.push_back(std::make_pair(Address.Address, Result));
1272  return Lines;
1273  }
1274 
1275  const DWARFLineTable *LineTable = getLineTableForUnit(CU);
1276 
1277  // Get the index of row we're looking for in the line table.
1278  std::vector<uint32_t> RowVector;
1279  if (!LineTable->lookupAddressRange({Address.Address, Address.SectionIndex},
1280  Size, RowVector)) {
1281  return Lines;
1282  }
1283 
1284  for (uint32_t RowIndex : RowVector) {
1285  // Take file number and line/column from the row.
1286  const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
1287  DILineInfo Result;
1288  LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(),
1289  Spec.FLIKind, Result.FileName);
1290  Result.FunctionName = FunctionName;
1291  Result.Line = Row.Line;
1292  Result.Column = Row.Column;
1293  Result.StartFileName = StartFileName;
1294  Result.StartLine = StartLine;
1295  Result.StartAddress = StartAddress;
1296  Lines.push_back(std::make_pair(Row.Address.Address, Result));
1297  }
1298 
1299  return Lines;
1300 }
1301 
1304  DILineInfoSpecifier Spec) {
1305  DIInliningInfo InliningInfo;
1306 
1308  if (!CU)
1309  return InliningInfo;
1310 
1311  const DWARFLineTable *LineTable = nullptr;
1312  SmallVector<DWARFDie, 4> InlinedChain;
1313  CU->getInlinedChainForAddress(Address.Address, InlinedChain);
1314  if (InlinedChain.size() == 0) {
1315  // If there is no DIE for address (e.g. it is in unavailable .dwo file),
1316  // try to at least get file/line info from symbol table.
1317  if (Spec.FLIKind != FileLineInfoKind::None) {
1318  DILineInfo Frame;
1319  LineTable = getLineTableForUnit(CU);
1320  if (LineTable && LineTable->getFileLineInfoForAddress(
1321  {Address.Address, Address.SectionIndex},
1322  CU->getCompilationDir(), Spec.FLIKind, Frame))
1323  InliningInfo.addFrame(Frame);
1324  }
1325  return InliningInfo;
1326  }
1327 
1328  uint32_t CallFile = 0, CallLine = 0, CallColumn = 0, CallDiscriminator = 0;
1329  for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) {
1330  DWARFDie &FunctionDIE = InlinedChain[i];
1331  DILineInfo Frame;
1332  // Get function name if necessary.
1333  if (const char *Name = FunctionDIE.getSubroutineName(Spec.FNKind))
1334  Frame.FunctionName = Name;
1335  if (auto DeclLineResult = FunctionDIE.getDeclLine())
1336  Frame.StartLine = DeclLineResult;
1337  Frame.StartFileName = FunctionDIE.getDeclFile(Spec.FLIKind);
1338  if (auto LowPcAddr = toSectionedAddress(FunctionDIE.find(DW_AT_low_pc)))
1339  Frame.StartAddress = LowPcAddr->Address;
1340  if (Spec.FLIKind != FileLineInfoKind::None) {
1341  if (i == 0) {
1342  // For the topmost frame, initialize the line table of this
1343  // compile unit and fetch file/line info from it.
1344  LineTable = getLineTableForUnit(CU);
1345  // For the topmost routine, get file/line info from line table.
1346  if (LineTable)
1347  LineTable->getFileLineInfoForAddress(
1348  {Address.Address, Address.SectionIndex}, CU->getCompilationDir(),
1349  Spec.FLIKind, Frame);
1350  } else {
1351  // Otherwise, use call file, call line and call column from
1352  // previous DIE in inlined chain.
1353  if (LineTable)
1354  LineTable->getFileNameByIndex(CallFile, CU->getCompilationDir(),
1355  Spec.FLIKind, Frame.FileName);
1356  Frame.Line = CallLine;
1357  Frame.Column = CallColumn;
1358  Frame.Discriminator = CallDiscriminator;
1359  }
1360  // Get call file/line/column of a current DIE.
1361  if (i + 1 < n) {
1362  FunctionDIE.getCallerFrame(CallFile, CallLine, CallColumn,
1363  CallDiscriminator);
1364  }
1365  }
1366  InliningInfo.addFrame(Frame);
1367  }
1368  return InliningInfo;
1369 }
1370 
1371 std::shared_ptr<DWARFContext>
1373  if (auto S = DWP.lock()) {
1374  DWARFContext *Ctxt = S->Context.get();
1375  return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1376  }
1377 
1378  std::weak_ptr<DWOFile> *Entry = &DWOFiles[AbsolutePath];
1379 
1380  if (auto S = Entry->lock()) {
1381  DWARFContext *Ctxt = S->Context.get();
1382  return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1383  }
1384 
1386  if (!CheckedForDWP) {
1387  SmallString<128> DWPName;
1389  this->DWPName.empty()
1390  ? (DObj->getFileName() + ".dwp").toStringRef(DWPName)
1391  : StringRef(this->DWPName));
1392  if (Obj) {
1393  Entry = &DWP;
1394  return Obj;
1395  } else {
1396  CheckedForDWP = true;
1397  // TODO: Should this error be handled (maybe in a high verbosity mode)
1398  // before falling back to .dwo files?
1399  consumeError(Obj.takeError());
1400  }
1401  }
1402 
1403  return object::ObjectFile::createObjectFile(AbsolutePath);
1404  }();
1405 
1406  if (!Obj) {
1407  // TODO: Actually report errors helpfully.
1408  consumeError(Obj.takeError());
1409  return nullptr;
1410  }
1411 
1412  auto S = std::make_shared<DWOFile>();
1413  S->File = std::move(Obj.get());
1414  S->Context = DWARFContext::create(*S->File.getBinary(),
1416  *Entry = S;
1417  auto *Ctxt = S->Context.get();
1418  return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1419 }
1420 
1421 static Error createError(const Twine &Reason, llvm::Error E) {
1422  return make_error<StringError>(Reason + toString(std::move(E)),
1424 }
1425 
1426 /// SymInfo contains information about symbol: it's address
1427 /// and section index which is -1LL for absolute symbols.
1428 struct SymInfo {
1431 };
1432 
1433 /// Returns the address of symbol relocation used against and a section index.
1434 /// Used for futher relocations computation. Symbol's section load address is
1436  const RelocationRef &Reloc,
1437  const LoadedObjectInfo *L,
1438  std::map<SymbolRef, SymInfo> &Cache) {
1439  SymInfo Ret = {0, (uint64_t)-1LL};
1441  object::symbol_iterator Sym = Reloc.getSymbol();
1442 
1443  std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end();
1444  // First calculate the address of the symbol or section as it appears
1445  // in the object file
1446  if (Sym != Obj.symbol_end()) {
1447  bool New;
1448  std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}});
1449  if (!New)
1450  return CacheIt->second;
1451 
1452  Expected<uint64_t> SymAddrOrErr = Sym->getAddress();
1453  if (!SymAddrOrErr)
1454  return createError("failed to compute symbol address: ",
1455  SymAddrOrErr.takeError());
1456 
1457  // Also remember what section this symbol is in for later
1458  auto SectOrErr = Sym->getSection();
1459  if (!SectOrErr)
1460  return createError("failed to get symbol section: ",
1461  SectOrErr.takeError());
1462 
1463  RSec = *SectOrErr;
1464  Ret.Address = *SymAddrOrErr;
1465  } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) {
1466  RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl());
1467  Ret.Address = RSec->getAddress();
1468  }
1469 
1470  if (RSec != Obj.section_end())
1471  Ret.SectionIndex = RSec->getIndex();
1472 
1473  // If we are given load addresses for the sections, we need to adjust:
1474  // SymAddr = (Address of Symbol Or Section in File) -
1475  // (Address of Section in File) +
1476  // (Load Address of Section)
1477  // RSec is now either the section being targeted or the section
1478  // containing the symbol being targeted. In either case,
1479  // we need to perform the same computation.
1480  if (L && RSec != Obj.section_end())
1481  if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(*RSec))
1482  Ret.Address += SectionLoadAddress - RSec->getAddress();
1483 
1484  if (CacheIt != Cache.end())
1485  CacheIt->second = Ret;
1486 
1487  return Ret;
1488 }
1489 
1490 static bool isRelocScattered(const object::ObjectFile &Obj,
1491  const RelocationRef &Reloc) {
1492  const MachOObjectFile *MachObj = dyn_cast<MachOObjectFile>(&Obj);
1493  if (!MachObj)
1494  return false;
1495  // MachO also has relocations that point to sections and
1496  // scattered relocations.
1497  auto RelocInfo = MachObj->getRelocation(Reloc.getRawDataRefImpl());
1498  return MachObj->isRelocationScattered(RelocInfo);
1499 }
1500 
1501 namespace {
1502 struct DWARFSectionMap final : public DWARFSection {
1503  RelocAddrMap Relocs;
1504 };
1505 
1506 class DWARFObjInMemory final : public DWARFObject {
1507  bool IsLittleEndian;
1508  uint8_t AddressSize;
1509  StringRef FileName;
1510  const object::ObjectFile *Obj = nullptr;
1511  std::vector<SectionName> SectionNames;
1512 
1513  using InfoSectionMap = MapVector<object::SectionRef, DWARFSectionMap,
1514  std::map<object::SectionRef, unsigned>>;
1515 
1516  InfoSectionMap InfoSections;
1517  InfoSectionMap TypesSections;
1518  InfoSectionMap InfoDWOSections;
1519  InfoSectionMap TypesDWOSections;
1520 
1521  DWARFSectionMap LocSection;
1522  DWARFSectionMap LoclistsSection;
1523  DWARFSectionMap LoclistsDWOSection;
1524  DWARFSectionMap LineSection;
1525  DWARFSectionMap RangesSection;
1526  DWARFSectionMap RnglistsSection;
1527  DWARFSectionMap StrOffsetsSection;
1528  DWARFSectionMap LineDWOSection;
1529  DWARFSectionMap FrameSection;
1530  DWARFSectionMap EHFrameSection;
1531  DWARFSectionMap LocDWOSection;
1532  DWARFSectionMap StrOffsetsDWOSection;
1533  DWARFSectionMap RangesDWOSection;
1534  DWARFSectionMap RnglistsDWOSection;
1535  DWARFSectionMap AddrSection;
1536  DWARFSectionMap AppleNamesSection;
1537  DWARFSectionMap AppleTypesSection;
1538  DWARFSectionMap AppleNamespacesSection;
1539  DWARFSectionMap AppleObjCSection;
1540  DWARFSectionMap NamesSection;
1541  DWARFSectionMap PubnamesSection;
1542  DWARFSectionMap PubtypesSection;
1543  DWARFSectionMap GnuPubnamesSection;
1544  DWARFSectionMap GnuPubtypesSection;
1545  DWARFSectionMap MacroSection;
1546 
1547  DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
1549  .Case("debug_loc", &LocSection)
1550  .Case("debug_loclists", &LoclistsSection)
1551  .Case("debug_loclists.dwo", &LoclistsDWOSection)
1552  .Case("debug_line", &LineSection)
1553  .Case("debug_frame", &FrameSection)
1554  .Case("eh_frame", &EHFrameSection)
1555  .Case("debug_str_offsets", &StrOffsetsSection)
1556  .Case("debug_ranges", &RangesSection)
1557  .Case("debug_rnglists", &RnglistsSection)
1558  .Case("debug_loc.dwo", &LocDWOSection)
1559  .Case("debug_line.dwo", &LineDWOSection)
1560  .Case("debug_names", &NamesSection)
1561  .Case("debug_rnglists.dwo", &RnglistsDWOSection)
1562  .Case("debug_str_offsets.dwo", &StrOffsetsDWOSection)
1563  .Case("debug_addr", &AddrSection)
1564  .Case("apple_names", &AppleNamesSection)
1565  .Case("debug_pubnames", &PubnamesSection)
1566  .Case("debug_pubtypes", &PubtypesSection)
1567  .Case("debug_gnu_pubnames", &GnuPubnamesSection)
1568  .Case("debug_gnu_pubtypes", &GnuPubtypesSection)
1569  .Case("apple_types", &AppleTypesSection)
1570  .Case("apple_namespaces", &AppleNamespacesSection)
1571  .Case("apple_namespac", &AppleNamespacesSection)
1572  .Case("apple_objc", &AppleObjCSection)
1573  .Case("debug_macro", &MacroSection)
1574  .Default(nullptr);
1575  }
1576 
1577  StringRef AbbrevSection;
1578  StringRef ArangesSection;
1579  StringRef StrSection;
1580  StringRef MacinfoSection;
1581  StringRef MacinfoDWOSection;
1582  StringRef MacroDWOSection;
1583  StringRef AbbrevDWOSection;
1584  StringRef StrDWOSection;
1585  StringRef CUIndexSection;
1586  StringRef GdbIndexSection;
1587  StringRef TUIndexSection;
1588  StringRef LineStrSection;
1589 
1590  // A deque holding section data whose iterators are not invalidated when
1591  // new decompressed sections are inserted at the end.
1592  std::deque<SmallString<0>> UncompressedSections;
1593 
1594  StringRef *mapSectionToMember(StringRef Name) {
1595  if (DWARFSection *Sec = mapNameToDWARFSection(Name))
1596  return &Sec->Data;
1598  .Case("debug_abbrev", &AbbrevSection)
1599  .Case("debug_aranges", &ArangesSection)
1600  .Case("debug_str", &StrSection)
1601  .Case("debug_macinfo", &MacinfoSection)
1602  .Case("debug_macinfo.dwo", &MacinfoDWOSection)
1603  .Case("debug_macro.dwo", &MacroDWOSection)
1604  .Case("debug_abbrev.dwo", &AbbrevDWOSection)
1605  .Case("debug_str.dwo", &StrDWOSection)
1606  .Case("debug_cu_index", &CUIndexSection)
1607  .Case("debug_tu_index", &TUIndexSection)
1608  .Case("gdb_index", &GdbIndexSection)
1609  .Case("debug_line_str", &LineStrSection)
1610  // Any more debug info sections go here.
1611  .Default(nullptr);
1612  }
1613 
1614  /// If Sec is compressed section, decompresses and updates its contents
1615  /// provided by Data. Otherwise leaves it unchanged.
1616  Error maybeDecompress(const object::SectionRef &Sec, StringRef Name,
1617  StringRef &Data) {
1618  if (!Decompressor::isCompressed(Sec))
1619  return Error::success();
1620 
1621  Expected<Decompressor> Decompressor =
1622  Decompressor::create(Name, Data, IsLittleEndian, AddressSize == 8);
1623  if (!Decompressor)
1624  return Decompressor.takeError();
1625 
1626  SmallString<0> Out;
1627  if (auto Err = Decompressor->resizeAndDecompress(Out))
1628  return Err;
1629 
1630  UncompressedSections.push_back(std::move(Out));
1631  Data = UncompressedSections.back();
1632 
1633  return Error::success();
1634  }
1635 
1636 public:
1637  DWARFObjInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
1638  uint8_t AddrSize, bool IsLittleEndian)
1639  : IsLittleEndian(IsLittleEndian) {
1640  for (const auto &SecIt : Sections) {
1641  if (StringRef *SectionData = mapSectionToMember(SecIt.first()))
1642  *SectionData = SecIt.second->getBuffer();
1643  else if (SecIt.first() == "debug_info")
1644  // Find debug_info and debug_types data by section rather than name as
1645  // there are multiple, comdat grouped, of these sections.
1646  InfoSections[SectionRef()].Data = SecIt.second->getBuffer();
1647  else if (SecIt.first() == "debug_info.dwo")
1648  InfoDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
1649  else if (SecIt.first() == "debug_types")
1650  TypesSections[SectionRef()].Data = SecIt.second->getBuffer();
1651  else if (SecIt.first() == "debug_types.dwo")
1652  TypesDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
1653  }
1654  }
1655  DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
1656  function_ref<void(Error)> HandleError,
1657  function_ref<void(Error)> HandleWarning,
1659  : IsLittleEndian(Obj.isLittleEndian()),
1660  AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()),
1661  Obj(&Obj) {
1662 
1663  StringMap<unsigned> SectionAmountMap;
1664  for (const SectionRef &Section : Obj.sections()) {
1665  StringRef Name;
1666  if (auto NameOrErr = Section.getName())
1667  Name = *NameOrErr;
1668  else
1669  consumeError(NameOrErr.takeError());
1670 
1671  ++SectionAmountMap[Name];
1672  SectionNames.push_back({ Name, true });
1673 
1674  // Skip BSS and Virtual sections, they aren't interesting.
1675  if (Section.isBSS() || Section.isVirtual())
1676  continue;
1677 
1678  // Skip sections stripped by dsymutil.
1679  if (Section.isStripped())
1680  continue;
1681 
1682  StringRef Data;
1683  Expected<section_iterator> SecOrErr = Section.getRelocatedSection();
1684  if (!SecOrErr) {
1685  HandleError(createError("failed to get relocated section: ",
1686  SecOrErr.takeError()));
1687  continue;
1688  }
1689 
1690  // Try to obtain an already relocated version of this section.
1691  // Else use the unrelocated section from the object file. We'll have to
1692  // apply relocations ourselves later.
1693  section_iterator RelocatedSection =
1694  Obj.isRelocatableObject() ? *SecOrErr : Obj.section_end();
1695  if (!L || !L->getLoadedSectionContents(*RelocatedSection, Data)) {
1696  Expected<StringRef> E = Section.getContents();
1697  if (E)
1698  Data = *E;
1699  else
1700  // maybeDecompress below will error.
1701  consumeError(E.takeError());
1702  }
1703 
1704  if (auto Err = maybeDecompress(Section, Name, Data)) {
1705  HandleError(createError("failed to decompress '" + Name + "', ",
1706  std::move(Err)));
1707  continue;
1708  }
1709 
1710  // Compressed sections names in GNU style starts from ".z",
1711  // at this point section is decompressed and we drop compression prefix.
1712  Name = Name.substr(
1713  Name.find_first_not_of("._z")); // Skip ".", "z" and "_" prefixes.
1714 
1715  // Map platform specific debug section names to DWARF standard section
1716  // names.
1717  Name = Obj.mapDebugSectionName(Name);
1718 
1719  if (StringRef *SectionData = mapSectionToMember(Name)) {
1720  *SectionData = Data;
1721  if (Name == "debug_ranges") {
1722  // FIXME: Use the other dwo range section when we emit it.
1723  RangesDWOSection.Data = Data;
1724  } else if (Name == "debug_frame" || Name == "eh_frame") {
1725  if (DWARFSection *S = mapNameToDWARFSection(Name))
1726  S->Address = Section.getAddress();
1727  }
1728  } else if (InfoSectionMap *Sections =
1730  .Case("debug_info", &InfoSections)
1731  .Case("debug_info.dwo", &InfoDWOSections)
1732  .Case("debug_types", &TypesSections)
1733  .Case("debug_types.dwo", &TypesDWOSections)
1734  .Default(nullptr)) {
1735  // Find debug_info and debug_types data by section rather than name as
1736  // there are multiple, comdat grouped, of these sections.
1737  DWARFSectionMap &S = (*Sections)[Section];
1738  S.Data = Data;
1739  }
1740 
1741  if (RelocatedSection != Obj.section_end() && Name.contains(".dwo"))
1742  HandleWarning(
1743  createError("Unexpected relocations for dwo section " + Name));
1744 
1745  if (RelocatedSection == Obj.section_end() ||
1747  continue;
1748 
1749  StringRef RelSecName;
1750  if (auto NameOrErr = RelocatedSection->getName())
1751  RelSecName = *NameOrErr;
1752  else
1753  consumeError(NameOrErr.takeError());
1754 
1755  // If the section we're relocating was relocated already by the JIT,
1756  // then we used the relocated version above, so we do not need to process
1757  // relocations for it now.
1758  StringRef RelSecData;
1759  if (L && L->getLoadedSectionContents(*RelocatedSection, RelSecData))
1760  continue;
1761 
1762  // In Mach-o files, the relocations do not need to be applied if
1763  // there is no load offset to apply. The value read at the
1764  // relocation point already factors in the section address
1765  // (actually applying the relocations will produce wrong results
1766  // as the section address will be added twice).
1767  if (!L && isa<MachOObjectFile>(&Obj))
1768  continue;
1769 
1770  RelSecName = RelSecName.substr(
1771  RelSecName.find_first_not_of("._z")); // Skip . and _ prefixes.
1772 
1773  // TODO: Add support for relocations in other sections as needed.
1774  // Record relocations for the debug_info and debug_line sections.
1775  DWARFSectionMap *Sec = mapNameToDWARFSection(RelSecName);
1776  RelocAddrMap *Map = Sec ? &Sec->Relocs : nullptr;
1777  if (!Map) {
1778  // Find debug_info and debug_types relocs by section rather than name
1779  // as there are multiple, comdat grouped, of these sections.
1780  if (RelSecName == "debug_info")
1781  Map = &static_cast<DWARFSectionMap &>(InfoSections[*RelocatedSection])
1782  .Relocs;
1783  else if (RelSecName == "debug_types")
1784  Map =
1785  &static_cast<DWARFSectionMap &>(TypesSections[*RelocatedSection])
1786  .Relocs;
1787  else
1788  continue;
1789  }
1790 
1791  if (Section.relocation_begin() == Section.relocation_end())
1792  continue;
1793 
1794  // Symbol to [address, section index] cache mapping.
1795  std::map<SymbolRef, SymInfo> AddrCache;
1796  SupportsRelocation Supports;
1798  std::tie(Supports, Resolver) = getRelocationResolver(Obj);
1799  for (const RelocationRef &Reloc : Section.relocations()) {
1800  // FIXME: it's not clear how to correctly handle scattered
1801  // relocations.
1802  if (isRelocScattered(Obj, Reloc))
1803  continue;
1804 
1805  Expected<SymInfo> SymInfoOrErr =
1806  getSymbolInfo(Obj, Reloc, L, AddrCache);
1807  if (!SymInfoOrErr) {
1808  HandleError(SymInfoOrErr.takeError());
1809  continue;
1810  }
1811 
1812  // Check if Resolver can handle this relocation type early so as not to
1813  // handle invalid cases in DWARFDataExtractor.
1814  //
1815  // TODO Don't store Resolver in every RelocAddrEntry.
1816  if (Supports && Supports(Reloc.getType())) {
1817  auto I = Map->try_emplace(
1818  Reloc.getOffset(),
1819  RelocAddrEntry{SymInfoOrErr->SectionIndex, Reloc,
1820  SymInfoOrErr->Address,
1821  Optional<object::RelocationRef>(), 0, Resolver});
1822  // If we didn't successfully insert that's because we already had a
1823  // relocation for that offset. Store it as a second relocation in the
1824  // same RelocAddrEntry instead.
1825  if (!I.second) {
1826  RelocAddrEntry &entry = I.first->getSecond();
1827  if (entry.Reloc2) {
1828  HandleError(createError(
1829  "At most two relocations per offset are supported"));
1830  }
1831  entry.Reloc2 = Reloc;
1832  entry.SymbolValue2 = SymInfoOrErr->Address;
1833  }
1834  } else {
1836  Reloc.getTypeName(Type);
1837  // FIXME: Support more relocations & change this to an error
1838  HandleWarning(
1839  createError("failed to compute relocation: " + Type + ", ",
1840  errorCodeToError(object_error::parse_failed)));
1841  }
1842  }
1843  }
1844 
1845  for (SectionName &S : SectionNames)
1846  if (SectionAmountMap[S.Name] > 1)
1847  S.IsNameUnique = false;
1848  }
1849 
1851  uint64_t Pos) const override {
1852  auto &Sec = static_cast<const DWARFSectionMap &>(S);
1853  RelocAddrMap::const_iterator AI = Sec.Relocs.find(Pos);
1854  if (AI == Sec.Relocs.end())
1855  return None;
1856  return AI->second;
1857  }
1858 
1859  const object::ObjectFile *getFile() const override { return Obj; }
1860 
1861  ArrayRef<SectionName> getSectionNames() const override {
1862  return SectionNames;
1863  }
1864 
1865  bool isLittleEndian() const override { return IsLittleEndian; }
1866  StringRef getAbbrevDWOSection() const override { return AbbrevDWOSection; }
1867  const DWARFSection &getLineDWOSection() const override {
1868  return LineDWOSection;
1869  }
1870  const DWARFSection &getLocDWOSection() const override {
1871  return LocDWOSection;
1872  }
1873  StringRef getStrDWOSection() const override { return StrDWOSection; }
1874  const DWARFSection &getStrOffsetsDWOSection() const override {
1875  return StrOffsetsDWOSection;
1876  }
1877  const DWARFSection &getRangesDWOSection() const override {
1878  return RangesDWOSection;
1879  }
1880  const DWARFSection &getRnglistsDWOSection() const override {
1881  return RnglistsDWOSection;
1882  }
1883  const DWARFSection &getLoclistsDWOSection() const override {
1884  return LoclistsDWOSection;
1885  }
1886  const DWARFSection &getAddrSection() const override { return AddrSection; }
1887  StringRef getCUIndexSection() const override { return CUIndexSection; }
1888  StringRef getGdbIndexSection() const override { return GdbIndexSection; }
1889  StringRef getTUIndexSection() const override { return TUIndexSection; }
1890 
1891  // DWARF v5
1892  const DWARFSection &getStrOffsetsSection() const override {
1893  return StrOffsetsSection;
1894  }
1895  StringRef getLineStrSection() const override { return LineStrSection; }
1896 
1897  // Sections for DWARF5 split dwarf proposal.
1898  void forEachInfoDWOSections(
1899  function_ref<void(const DWARFSection &)> F) const override {
1900  for (auto &P : InfoDWOSections)
1901  F(P.second);
1902  }
1903  void forEachTypesDWOSections(
1904  function_ref<void(const DWARFSection &)> F) const override {
1905  for (auto &P : TypesDWOSections)
1906  F(P.second);
1907  }
1908 
1909  StringRef getAbbrevSection() const override { return AbbrevSection; }
1910  const DWARFSection &getLocSection() const override { return LocSection; }
1911  const DWARFSection &getLoclistsSection() const override { return LoclistsSection; }
1912  StringRef getArangesSection() const override { return ArangesSection; }
1913  const DWARFSection &getFrameSection() const override {
1914  return FrameSection;
1915  }
1916  const DWARFSection &getEHFrameSection() const override {
1917  return EHFrameSection;
1918  }
1919  const DWARFSection &getLineSection() const override { return LineSection; }
1920  StringRef getStrSection() const override { return StrSection; }
1921  const DWARFSection &getRangesSection() const override { return RangesSection; }
1922  const DWARFSection &getRnglistsSection() const override {
1923  return RnglistsSection;
1924  }
1925  const DWARFSection &getMacroSection() const override { return MacroSection; }
1926  StringRef getMacroDWOSection() const override { return MacroDWOSection; }
1927  StringRef getMacinfoSection() const override { return MacinfoSection; }
1928  StringRef getMacinfoDWOSection() const override { return MacinfoDWOSection; }
1929  const DWARFSection &getPubnamesSection() const override { return PubnamesSection; }
1930  const DWARFSection &getPubtypesSection() const override { return PubtypesSection; }
1931  const DWARFSection &getGnuPubnamesSection() const override {
1932  return GnuPubnamesSection;
1933  }
1934  const DWARFSection &getGnuPubtypesSection() const override {
1935  return GnuPubtypesSection;
1936  }
1937  const DWARFSection &getAppleNamesSection() const override {
1938  return AppleNamesSection;
1939  }
1940  const DWARFSection &getAppleTypesSection() const override {
1941  return AppleTypesSection;
1942  }
1943  const DWARFSection &getAppleNamespacesSection() const override {
1944  return AppleNamespacesSection;
1945  }
1946  const DWARFSection &getAppleObjCSection() const override {
1947  return AppleObjCSection;
1948  }
1949  const DWARFSection &getNamesSection() const override {
1950  return NamesSection;
1951  }
1952 
1953  StringRef getFileName() const override { return FileName; }
1954  uint8_t getAddressSize() const override { return AddressSize; }
1955  void forEachInfoSections(
1956  function_ref<void(const DWARFSection &)> F) const override {
1957  for (auto &P : InfoSections)
1958  F(P.second);
1959  }
1960  void forEachTypesSections(
1961  function_ref<void(const DWARFSection &)> F) const override {
1962  for (auto &P : TypesSections)
1963  F(P.second);
1964  }
1965 };
1966 } // namespace
1967 
1968 std::unique_ptr<DWARFContext>
1970  ProcessDebugRelocations RelocAction,
1971  const LoadedObjectInfo *L, std::string DWPName,
1972  std::function<void(Error)> RecoverableErrorHandler,
1973  std::function<void(Error)> WarningHandler) {
1974  auto DObj = std::make_unique<DWARFObjInMemory>(
1975  Obj, L, RecoverableErrorHandler, WarningHandler, RelocAction);
1976  return std::make_unique<DWARFContext>(std::move(DObj), std::move(DWPName),
1977  RecoverableErrorHandler,
1978  WarningHandler);
1979 }
1980 
1981 std::unique_ptr<DWARFContext>
1982 DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
1983  uint8_t AddrSize, bool isLittleEndian,
1984  std::function<void(Error)> RecoverableErrorHandler,
1985  std::function<void(Error)> WarningHandler) {
1986  auto DObj =
1987  std::make_unique<DWARFObjInMemory>(Sections, AddrSize, isLittleEndian);
1988  return std::make_unique<DWARFContext>(
1989  std::move(DObj), "", RecoverableErrorHandler, WarningHandler);
1990 }
1991 
1993  // Detect the architecture from the object file. We usually don't need OS
1994  // info to lookup a target and create register info.
1995  Triple TT;
1996  TT.setArch(Triple::ArchType(Obj.getArch()));
1997  TT.setVendor(Triple::UnknownVendor);
1998  TT.setOS(Triple::UnknownOS);
1999  std::string TargetLookupError;
2000  const Target *TheTarget =
2001  TargetRegistry::lookupTarget(TT.str(), TargetLookupError);
2002  if (!TargetLookupError.empty())
2004  TargetLookupError.c_str());
2005  RegInfo.reset(TheTarget->createMCRegInfo(TT.str()));
2006  return Error::success();
2007 }
2008 
2010  // In theory, different compile units may have different address byte
2011  // sizes, but for simplicity we just use the address byte size of the
2012  // first compile unit. In practice the address size field is repeated across
2013  // various DWARF headers (at least in version 5) to make it easier to dump
2014  // them independently, not to enable varying the address size.
2015  auto CUs = compile_units();
2016  return CUs.empty() ? 0 : (*CUs.begin())->getAddressByteSize();
2017 }
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::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
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::DWARFVerifier
A class that verifies DWARF debug information given a DWARF Context.
Definition: DWARFVerifier.h:33
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:351
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:283
llvm::DWARFContext::create
static std::unique_ptr< DWARFContext > create(const object::ObjectFile &Obj, ProcessDebugRelocations RelocAction=ProcessDebugRelocations::Process, const LoadedObjectInfo *L=nullptr, std::string DWPName="", std::function< void(Error)> RecoverableErrorHandler=WithColor::defaultErrorHandler, std::function< void(Error)> WarningHandler=WithColor::defaultWarningHandler)
Definition: DWARFContext.cpp:1969
llvm::sys::path::extension
StringRef extension(StringRef path, Style style=Style::native)
Get extension.
Definition: Path.cpp:586
llvm::DWARFContext::getEHFrame
Expected< const DWARFDebugFrame * > getEHFrame()
Get a pointer to the parsed eh frame information object.
Definition: DWARFContext.cpp:848
DWARFGdbIndex.h
DWARFAcceleratorTable.h
llvm::SIInstrFlags::DS
@ DS
Definition: SIDefines.h:59
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
T
llvm::DIInliningInfo
A format-neutral container for inlined code description.
Definition: DIContext.h:87
llvm::DILineInfoSpecifier
Controls which fields of DILineInfo container should be filled with data.
Definition: DIContext.h:135
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:348
llvm::StringSwitch::Default
LLVM_NODISCARD R Default(T Value)
Definition: StringSwitch.h:181
llvm::DIDumpOptions::DumpType
unsigned DumpType
Definition: DIContext.h:181
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:137
llvm::toString
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:1020
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
getTypeSize
static Optional< uint64_t > getTypeSize(DWARFDie Type, uint64_t PointerSize)
Definition: DWARFContext.cpp:1072
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:331
llvm::DWARFContext::getLineInfoForAddressRange
DILineInfoTable getLineInfoForAddressRange(object::SectionedAddress Address, uint64_t Size, DILineInfoSpecifier Specifier=DILineInfoSpecifier()) override
Definition: DWARFContext.cpp:1248
DWARFDebugLine.h
DWARFContext.h
llvm::dwarf::toSectionedAddress
Optional< object::SectionedAddress > toSectionedAddress(const Optional< DWARFFormValue > &V)
Definition: DWARFFormValue.h:282
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::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:214
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
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:1435
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:33
getAccelTable
static T & getAccelTable(std::unique_ptr< T > &Cache, const DWARFObject &Obj, const DWARFSection &Section, StringRef StringSection, bool IsLittleEndian)
Definition: DWARFContext.cpp:889
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:252
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:1130
llvm::DWARFVerifier::handleDebugInfo
bool handleDebugInfo()
Verify the information in the .debug_info and .debug_types sections.
Definition: DWARFVerifier.cpp:399
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:1215
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:1035
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:55
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:162
F
#define F(x, y, z)
Definition: MD5.cpp:56
getFunctionNameAndStartLineForAddress
static bool getFunctionNameAndStartLineForAddress(DWARFCompileUnit *CU, uint64_t Address, FunctionNameKind Kind, DILineInfoSpecifier::FileLineInfoKind FileNameKind, std::string &FunctionName, std::string &StartFile, uint32_t &StartLine, Optional< uint64_t > &StartAddress)
TODO: change input parameter from "uint64_t Address" into "SectionedAddress Address".
Definition: DWARFContext.cpp:1038
MachO.h
llvm::DWARFContext::getInliningInfoForAddress
DIInliningInfo getInliningInfoForAddress(object::SectionedAddress Address, DILineInfoSpecifier Specifier=DILineInfoSpecifier()) override
Definition: DWARFContext.cpp:1303
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:266
llvm::DWARFUnit::getUnitDIE
DWARFDie getUnitDIE(bool ExtractUnitDIEOnly=true)
Definition: DWARFUnit.h:390
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:2000
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:611
llvm::Target::createMCRegInfo
MCRegisterInfo * createMCRegInfo(StringRef TT) const
createMCRegInfo - Create a MCRegisterInfo implementation.
Definition: TargetRegistry.h:420
SymInfo::SectionIndex
uint64_t SectionIndex
Definition: DWARFContext.cpp:1430
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:136
llvm::object::ObjectFile::isRelocatableObject
virtual bool isRelocatableObject() const =0
True if this is a relocatable object (.o/.obj).
llvm::DIDumpOptions::Verbose
bool Verbose
Definition: DIContext.h:191
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:131
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:56
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:105
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:217
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:232
DWARFDebugLoc.h
llvm::DWARFDie::getCallerFrame
void getCallerFrame(uint32_t &CallFile, uint32_t &CallLine, uint32_t &CallColumn, uint32_t &CallDiscriminator) const
Retrieves values of DW_AT_call_file, DW_AT_call_line and DW_AT_call_column from DIE (or zeroes if the...
Definition: DWARFDie.cpp:1039
llvm::DWARFContext::getArch
Triple::ArchType getArch() const
Definition: DWARFContext.h:417
dumpUUID
static void dumpUUID(raw_ostream &OS, const ObjectFile &Obj)
Dump the UUID load command.
Definition: DWARFContext.cpp:78
llvm::DWARFDie::getDeclFile
std::string getDeclFile(DILineInfoSpecifier::FileLineInfoKind Kind) const
Definition: DWARFDie.cpp:1032
llvm::DWARFListTableBase::length
uint64_t length()
Definition: DWARFListTable.h:198
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:303
llvm::DWARFVerifier::handleDebugLine
bool handleDebugLine()
Verify the information in the .debug_line section.
Definition: DWARFVerifier.cpp:909
llvm::DWARFDebugLine::LineTable::Rows
RowVector Rows
Definition: DWARFDebugLine.h:289
llvm::DW_SECT_EXT_TYPES
@ DW_SECT_EXT_TYPES
Definition: DWARFUnitIndex.h:62
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::DWARFObject
Definition: DWARFObject.h: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:490
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:991
llvm::DWARFContext::getStringDWOExtractor
DataExtractor getStringDWOExtractor() const
Definition: DWARFContext.h:332
llvm::DWARFUnit::getLineSection
const DWARFSection & getLineSection() const
Definition: DWARFUnit.h:299
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:1429
llvm::None
const NoneType None
Definition: None.h:23
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::DWARFContext::ProcessDebugRelocations::Ignore
@ Ignore
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:1558
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:168
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:163
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:409
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:268
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:261
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::DWARFDebugLoc
Definition: DWARFDebugLoc.h:85
llvm::DWARFDebugRnglistTable
Definition: DWARFDebugRnglists.h:60
uint64_t
llvm::object::symbol_iterator
Definition: ObjectFile.h:207
llvm::DWARFDebugLine::SectionParser
Helper to allow for parsing of an entire .debug_line section in sequence.
Definition: DWARFDebugLine.h:312
llvm::DWARFVerifier::handleDebugAbbrev
bool handleDebugAbbrev()
Verify the information in any of the following sections, if available: .debug_abbrev,...
Definition: DWARFVerifier.cpp:306
llvm::DWARFDie::getDeclLine
uint64_t getDeclLine() const
Returns the declaration line (start line) for a DIE, assuming it specifies a subprogram.
Definition: DWARFDie.cpp:1027
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:1571
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:2009
llvm::DWARFContext::dwo_compile_units
compile_unit_range dwo_compile_units()
Get compile units in the DWO context.
Definition: DWARFContext.h:195
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::DILineInfo
A format-neutral container for source line information.
Definition: DIContext.h:31
llvm::DWARFDie::find
Optional< DWARFFormValue > find(dwarf::Attribute Attr) const
Extract the specified attribute from this DIE.
Definition: DWARFDie.cpp:819
MCRegisterInfo.h
llvm::DILineInfoSpecifier::FileLineInfoKind
FileLineInfoKind
Definition: DIContext.h:136
DWARFDebugRnglists.h
llvm::HighlightColor::Address
@ Address
llvm::DataExtractor::isValidOffset
bool isValidOffset(uint64_t offset) const
Test the validity of offset.
Definition: DataExtractor.h:665
llvm::object::ObjectFile::createObjectFile
static Expected< OwningBinary< ObjectFile > > createObjectFile(StringRef ObjectPath)
Definition: ObjectFile.cpp:185
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:1609
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:241
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:46
llvm::DWARFContext::getTUIndex
const DWARFUnitIndex & getTUIndex()
Definition: DWARFContext.cpp:757
llvm::object::getRelocationResolver
std::pair< SupportsRelocation, RelocationResolver > getRelocationResolver(const ObjectFile &Obj)
Definition: RelocationResolver.cpp:645
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:1372
llvm::DIDT_All
@ DIDT_All
Definition: DIContext.h:170
llvm::DWARFContext::~DWARFContext
~DWARFContext()
llvm::DWARFUnitVector::getUnitForIndexEntry
DWARFUnit * getUnitForIndexEntry(const DWARFUnitIndex::Entry &E)
Definition: DWARFUnit.cpp:144
llvm::DWARFDie::getLocations
Expected< DWARFLocationExpressionsVector > getLocations(dwarf::Attribute Attr) const
Definition: DWARFDie.cpp:964
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:129
Extension
Definition: AArch64AsmParser.cpp:3254
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:58
Dwarf.h
llvm::object::ObjectFile
This class is the base class for all object file types.
Definition: ObjectFile.h:228
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:569
uint32_t
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1748
llvm::COFF::SectionSize
@ SectionSize
Definition: COFF.h:61
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:149
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:175
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:149
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:1227
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:83
llvm::DWARFListTableBase::extract
Error extract(DWARFDataExtractor Data, uint64_t *OffsetPtr)
Extract an entire table, including all list entries.
Definition: DWARFListTable.h:202
llvm::DWARFUnit::getAddressByteSize
uint8_t getAddressByteSize() const
Definition: DWARFUnit.h:286
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1231
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:381
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:260
llvm::DWARFDebugNames::dump
void dump(raw_ostream &OS) const override
Definition: DWARFAcceleratorTable.cpp:791
Casting.h
llvm::DWARFContext::getCompileUnitForOffset
DWARFCompileUnit * getCompileUnitForOffset(uint64_t Offset)
Return the compile unit that includes an offset (relative to .debug_info).
Definition: DWARFContext.cpp: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:1492
llvm::DILocal
Definition: DIContext.h:119
llvm::DIDumpOptions::DisplayRawContents
bool DisplayRawContents
Definition: DIContext.h:192
llvm::TargetStackID::Default
@ Default
Definition: TargetFrameLowering.h:28
llvm::DILineInfo::StartAddress
Optional< uint64_t > StartAddress
Definition: DIContext.h:43
llvm::unique
auto unique(Range &&R, Predicate P)
Definition: STLExtras.h:1704
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:253
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:210
llvm::DWARFDebugPubTable::extract
void extract(DWARFDataExtractor Data, bool GnuStyle, function_ref< void(Error)> RecoverableErrorHandler)
Definition: DWARFDebugPubTable.cpp:22
llvm::object::ObjectFile::mapDebugSectionName
virtual StringRef mapDebugSectionName(StringRef Name) const
Maps a debug section name to a standard DWARF section name.
Definition: ObjectFile.h:343
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:589
llvm::DWARFDie::getAttributeValueAsReferencedDie
DWARFDie getAttributeValueAsReferencedDie(dwarf::Attribute Attr) const
Extract the specified attribute from this DIE as the referenced DIE.
Definition: DWARFDie.cpp:876
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:146
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:144
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
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:322
llvm::DWARFDebugLine::LineTable
Definition: DWARFDebugLine.h:229
SymInfo
SymInfo contains information about symbol: it's address and section index which is -1LL for absolute ...
Definition: DWARFContext.cpp:1428
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:203
llvm::raw_ostream::uuid_t
uint8_t[16] uuid_t
Output a formatted UUID with dash separators.
Definition: raw_ostream.h:272
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:148
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:168
llvm::DWARFDebugAbbrev::dump
void dump(raw_ostream &OS) const
Definition: DWARFDebugAbbrev.cpp:128
llvm::DWARFContext::DIEsForAddress
Wraps the returned DIEs for a given address.
Definition: DWARFContext.h: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:1490
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
DWARFDebugAddr.h
llvm::DWARFListTableHeader::getAddrSize
uint8_t getAddrSize() const
Definition: DWARFListTable.h:94
llvm::DWARFContext::ProcessDebugRelocations
ProcessDebugRelocations
Definition: DWARFContext.h:389
llvm::DWARFDebugAranges
Definition: DWARFDebugAranges.h:21
TargetRegistry.h
llvm::DWARFSection::Data
StringRef Data
Definition: DWARFSection.h:17
CU
Definition: AArch64AsmBackend.cpp:501
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:393
llvm::DWARFContext::getAppleNamespaces
const AppleAcceleratorTable & getAppleNamespaces()
Get a reference to the parsed accelerator table object.
Definition: DWARFContext.cpp:917
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:154
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:1992
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::DWARFDie::getSubroutineName
const char * getSubroutineName(DINameKind Kind) const
If a DIE represents a subprogram (or inlined subroutine), returns its mangled name (or short name,...
Definition: DWARFDie.cpp:994
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:37
llvm::DIDumpOptions
Container for dump options that control which debug information will be dumped.
Definition: DIContext.h:180
llvm::DIDumpOptions::RecoverableErrorHandler
std::function< void(Error)> RecoverableErrorHandler
Definition: DIContext.h:212
llvm::DILineInfo::StartFileName
std::string StartFileName
Definition: DIContext.h:38