LLVM  15.0.0git
DWARFDebugLine.cpp
Go to the documentation of this file.
1 //===- DWARFDebugLine.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/Optional.h"
11 #include "llvm/ADT/SmallString.h"
12 #include "llvm/ADT/SmallVector.h"
13 #include "llvm/ADT/StringRef.h"
18 #include "llvm/Support/Errc.h"
19 #include "llvm/Support/Format.h"
22 #include <algorithm>
23 #include <cassert>
24 #include <cinttypes>
25 #include <cstdint>
26 #include <cstdio>
27 #include <utility>
28 
29 using namespace llvm;
30 using namespace dwarf;
31 
32 namespace llvm {
33 class DwarfContext;
34 }
35 
37 
38 namespace {
39 
40 struct ContentDescriptor {
43 };
44 
45 using ContentDescriptors = SmallVector<ContentDescriptor, 4>;
46 
47 } // end anonymous namespace
48 
50  return Version >= 2 && Version <= 5;
51 }
52 
54  dwarf::LineNumberEntryFormat ContentType) {
55  switch (ContentType) {
56  case dwarf::DW_LNCT_timestamp:
57  HasModTime = true;
58  break;
59  case dwarf::DW_LNCT_size:
60  HasLength = true;
61  break;
62  case dwarf::DW_LNCT_MD5:
63  HasMD5 = true;
64  break;
65  case dwarf::DW_LNCT_LLVM_source:
66  HasSource = true;
67  break;
68  default:
69  // We only care about values we consider optional, and new values may be
70  // added in the vendor extension range, so we do not match exhaustively.
71  break;
72  }
73 }
74 
76 
78  uint16_t DwarfVersion = getVersion();
79  assert(DwarfVersion != 0 &&
80  "line table prologue has no dwarf version information");
81  if (DwarfVersion >= 5)
82  return FileIndex < FileNames.size();
83  return FileIndex != 0 && FileIndex <= FileNames.size();
84 }
85 
87  if (FileNames.empty())
88  return None;
89  uint16_t DwarfVersion = getVersion();
90  assert(DwarfVersion != 0 &&
91  "line table prologue has no dwarf version information");
92  // In DWARF v5 the file names are 0-indexed.
93  if (DwarfVersion >= 5)
94  return FileNames.size() - 1;
95  return FileNames.size();
96 }
97 
100  uint16_t DwarfVersion = getVersion();
101  assert(DwarfVersion != 0 &&
102  "line table prologue has no dwarf version information");
103  // In DWARF v5 the file names are 0-indexed.
104  if (DwarfVersion >= 5)
105  return FileNames[Index];
106  return FileNames[Index - 1];
107 }
108 
110  TotalLength = PrologueLength = 0;
111  SegSelectorSize = 0;
112  MinInstLength = MaxOpsPerInst = DefaultIsStmt = LineBase = LineRange = 0;
113  OpcodeBase = 0;
115  ContentTypes = ContentTypeTracker();
116  StandardOpcodeLengths.clear();
117  IncludeDirectories.clear();
118  FileNames.clear();
119 }
120 
122  DIDumpOptions DumpOptions) const {
123  if (!totalLengthIsValid())
124  return;
125  int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(FormParams.Format);
126  OS << "Line table prologue:\n"
127  << format(" total_length: 0x%0*" PRIx64 "\n", OffsetDumpWidth,
128  TotalLength)
129  << " format: " << dwarf::FormatString(FormParams.Format) << "\n"
130  << format(" version: %u\n", getVersion());
131  if (!versionIsSupported(getVersion()))
132  return;
133  if (getVersion() >= 5)
134  OS << format(" address_size: %u\n", getAddressSize())
135  << format(" seg_select_size: %u\n", SegSelectorSize);
136  OS << format(" prologue_length: 0x%0*" PRIx64 "\n", OffsetDumpWidth,
137  PrologueLength)
138  << format(" min_inst_length: %u\n", MinInstLength)
139  << format(getVersion() >= 4 ? "max_ops_per_inst: %u\n" : "", MaxOpsPerInst)
140  << format(" default_is_stmt: %u\n", DefaultIsStmt)
141  << format(" line_base: %i\n", LineBase)
142  << format(" line_range: %u\n", LineRange)
143  << format(" opcode_base: %u\n", OpcodeBase);
144 
145  for (uint32_t I = 0; I != StandardOpcodeLengths.size(); ++I)
146  OS << formatv("standard_opcode_lengths[{0}] = {1}\n",
147  static_cast<dwarf::LineNumberOps>(I + 1),
148  StandardOpcodeLengths[I]);
149 
150  if (!IncludeDirectories.empty()) {
151  // DWARF v5 starts directory indexes at 0.
152  uint32_t DirBase = getVersion() >= 5 ? 0 : 1;
153  for (uint32_t I = 0; I != IncludeDirectories.size(); ++I) {
154  OS << format("include_directories[%3u] = ", I + DirBase);
155  IncludeDirectories[I].dump(OS, DumpOptions);
156  OS << '\n';
157  }
158  }
159 
160  if (!FileNames.empty()) {
161  // DWARF v5 starts file indexes at 0.
162  uint32_t FileBase = getVersion() >= 5 ? 0 : 1;
163  for (uint32_t I = 0; I != FileNames.size(); ++I) {
164  const FileNameEntry &FileEntry = FileNames[I];
165  OS << format("file_names[%3u]:\n", I + FileBase);
166  OS << " name: ";
167  FileEntry.Name.dump(OS, DumpOptions);
168  OS << '\n'
169  << format(" dir_index: %" PRIu64 "\n", FileEntry.DirIdx);
170  if (ContentTypes.HasMD5)
171  OS << " md5_checksum: " << FileEntry.Checksum.digest() << '\n';
172  if (ContentTypes.HasModTime)
173  OS << format(" mod_time: 0x%8.8" PRIx64 "\n", FileEntry.ModTime);
174  if (ContentTypes.HasLength)
175  OS << format(" length: 0x%8.8" PRIx64 "\n", FileEntry.Length);
176  if (ContentTypes.HasSource) {
177  OS << " source: ";
178  FileEntry.Source.dump(OS, DumpOptions);
179  OS << '\n';
180  }
181  }
182  }
183 }
184 
185 // Parse v2-v4 directory and file tables.
186 static Error
188  uint64_t *OffsetPtr,
190  std::vector<DWARFFormValue> &IncludeDirectories,
191  std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
192  while (true) {
193  Error Err = Error::success();
194  StringRef S = DebugLineData.getCStrRef(OffsetPtr, &Err);
195  if (Err) {
196  consumeError(std::move(Err));
198  "include directories table was not null "
199  "terminated before the end of the prologue");
200  }
201  if (S.empty())
202  break;
203  DWARFFormValue Dir =
204  DWARFFormValue::createFromPValue(dwarf::DW_FORM_string, S.data());
205  IncludeDirectories.push_back(Dir);
206  }
207 
208  ContentTypes.HasModTime = true;
209  ContentTypes.HasLength = true;
210 
211  while (true) {
212  Error Err = Error::success();
213  StringRef Name = DebugLineData.getCStrRef(OffsetPtr, &Err);
214  if (!Err && Name.empty())
215  break;
216 
218  FileEntry.Name =
219  DWARFFormValue::createFromPValue(dwarf::DW_FORM_string, Name.data());
220  FileEntry.DirIdx = DebugLineData.getULEB128(OffsetPtr, &Err);
221  FileEntry.ModTime = DebugLineData.getULEB128(OffsetPtr, &Err);
222  FileEntry.Length = DebugLineData.getULEB128(OffsetPtr, &Err);
223 
224  if (Err) {
225  consumeError(std::move(Err));
226  return createStringError(
228  "file names table was not null terminated before "
229  "the end of the prologue");
230  }
231  FileNames.push_back(FileEntry);
232  }
233 
234  return Error::success();
235 }
236 
237 // Parse v5 directory/file entry content descriptions.
238 // Returns the descriptors, or an error if we did not find a path or ran off
239 // the end of the prologue.
241 parseV5EntryFormat(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
242  DWARFDebugLine::ContentTypeTracker *ContentTypes) {
243  Error Err = Error::success();
244  ContentDescriptors Descriptors;
245  int FormatCount = DebugLineData.getU8(OffsetPtr, &Err);
246  bool HasPath = false;
247  for (int I = 0; I != FormatCount && !Err; ++I) {
248  ContentDescriptor Descriptor;
249  Descriptor.Type =
250  dwarf::LineNumberEntryFormat(DebugLineData.getULEB128(OffsetPtr, &Err));
251  Descriptor.Form = dwarf::Form(DebugLineData.getULEB128(OffsetPtr, &Err));
252  if (Descriptor.Type == dwarf::DW_LNCT_path)
253  HasPath = true;
254  if (ContentTypes)
255  ContentTypes->trackContentType(Descriptor.Type);
256  Descriptors.push_back(Descriptor);
257  }
258 
259  if (Err)
261  "failed to parse entry content descriptors: %s",
262  toString(std::move(Err)).c_str());
263 
264  if (!HasPath)
266  "failed to parse entry content descriptions"
267  " because no path was found");
268  return Descriptors;
269 }
270 
271 static Error
273  uint64_t *OffsetPtr, const dwarf::FormParams &FormParams,
274  const DWARFContext &Ctx, const DWARFUnit *U,
276  std::vector<DWARFFormValue> &IncludeDirectories,
277  std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
278  // Get the directory entry description.
279  llvm::Expected<ContentDescriptors> DirDescriptors =
280  parseV5EntryFormat(DebugLineData, OffsetPtr, nullptr);
281  if (!DirDescriptors)
282  return DirDescriptors.takeError();
283 
284  // Get the directory entries, according to the format described above.
285  uint64_t DirEntryCount = DebugLineData.getULEB128(OffsetPtr);
286  for (uint64_t I = 0; I != DirEntryCount; ++I) {
287  for (auto Descriptor : *DirDescriptors) {
288  DWARFFormValue Value(Descriptor.Form);
289  switch (Descriptor.Type) {
290  case DW_LNCT_path:
291  if (!Value.extractValue(DebugLineData, OffsetPtr, FormParams, &Ctx, U))
293  "failed to parse directory entry because "
294  "extracting the form value failed");
295  IncludeDirectories.push_back(Value);
296  break;
297  default:
298  if (!Value.skipValue(DebugLineData, OffsetPtr, FormParams))
300  "failed to parse directory entry because "
301  "skipping the form value failed");
302  }
303  }
304  }
305 
306  // Get the file entry description.
307  llvm::Expected<ContentDescriptors> FileDescriptors =
308  parseV5EntryFormat(DebugLineData, OffsetPtr, &ContentTypes);
309  if (!FileDescriptors)
310  return FileDescriptors.takeError();
311 
312  // Get the file entries, according to the format described above.
313  uint64_t FileEntryCount = DebugLineData.getULEB128(OffsetPtr);
314  for (uint64_t I = 0; I != FileEntryCount; ++I) {
316  for (auto Descriptor : *FileDescriptors) {
317  DWARFFormValue Value(Descriptor.Form);
318  if (!Value.extractValue(DebugLineData, OffsetPtr, FormParams, &Ctx, U))
320  "failed to parse file entry because "
321  "extracting the form value failed");
322  switch (Descriptor.Type) {
323  case DW_LNCT_path:
324  FileEntry.Name = Value;
325  break;
326  case DW_LNCT_LLVM_source:
327  FileEntry.Source = Value;
328  break;
329  case DW_LNCT_directory_index:
330  FileEntry.DirIdx = Value.getAsUnsignedConstant().getValue();
331  break;
332  case DW_LNCT_timestamp:
333  FileEntry.ModTime = Value.getAsUnsignedConstant().getValue();
334  break;
335  case DW_LNCT_size:
336  FileEntry.Length = Value.getAsUnsignedConstant().getValue();
337  break;
338  case DW_LNCT_MD5:
339  if (!Value.getAsBlock() || Value.getAsBlock().getValue().size() != 16)
340  return createStringError(
342  "failed to parse file entry because the MD5 hash is invalid");
343  std::uninitialized_copy_n(Value.getAsBlock().getValue().begin(), 16,
344  FileEntry.Checksum.begin());
345  break;
346  default:
347  break;
348  }
349  }
350  FileNames.push_back(FileEntry);
351  }
352  return Error::success();
353 }
354 
356  uint64_t Length = PrologueLength + sizeofTotalLength() +
357  sizeof(getVersion()) + sizeofPrologueLength();
358  if (getVersion() >= 5)
359  Length += 2; // Address + Segment selector sizes.
360  return Length;
361 }
362 
364  DWARFDataExtractor DebugLineData, uint64_t *OffsetPtr,
365  function_ref<void(Error)> RecoverableErrorHandler, const DWARFContext &Ctx,
366  const DWARFUnit *U) {
367  const uint64_t PrologueOffset = *OffsetPtr;
368 
369  clear();
370  DataExtractor::Cursor Cursor(*OffsetPtr);
371  std::tie(TotalLength, FormParams.Format) =
372  DebugLineData.getInitialLength(Cursor);
373 
374  DebugLineData =
375  DWARFDataExtractor(DebugLineData, Cursor.tell() + TotalLength);
376  FormParams.Version = DebugLineData.getU16(Cursor);
377  if (Cursor && !versionIsSupported(getVersion())) {
378  // Treat this error as unrecoverable - we cannot be sure what any of
379  // the data represents including the length field, so cannot skip it or make
380  // any reasonable assumptions.
381  *OffsetPtr = Cursor.tell();
382  return createStringError(
384  "parsing line table prologue at offset 0x%8.8" PRIx64
385  ": unsupported version %" PRIu16,
386  PrologueOffset, getVersion());
387  }
388 
389  if (getVersion() >= 5) {
390  FormParams.AddrSize = DebugLineData.getU8(Cursor);
391  assert((!Cursor || DebugLineData.getAddressSize() == 0 ||
392  DebugLineData.getAddressSize() == getAddressSize()) &&
393  "Line table header and data extractor disagree");
394  SegSelectorSize = DebugLineData.getU8(Cursor);
395  }
396 
397  PrologueLength =
398  DebugLineData.getRelocatedValue(Cursor, sizeofPrologueLength());
399  const uint64_t EndPrologueOffset = PrologueLength + Cursor.tell();
400  DebugLineData = DWARFDataExtractor(DebugLineData, EndPrologueOffset);
401  MinInstLength = DebugLineData.getU8(Cursor);
402  if (getVersion() >= 4)
403  MaxOpsPerInst = DebugLineData.getU8(Cursor);
404  DefaultIsStmt = DebugLineData.getU8(Cursor);
405  LineBase = DebugLineData.getU8(Cursor);
406  LineRange = DebugLineData.getU8(Cursor);
407  OpcodeBase = DebugLineData.getU8(Cursor);
408 
409  if (Cursor && OpcodeBase == 0) {
410  // If the opcode base is 0, we cannot read the standard opcode lengths (of
411  // which there are supposed to be one fewer than the opcode base). Assume
412  // there are no standard opcodes and continue parsing.
413  RecoverableErrorHandler(createStringError(
415  "parsing line table prologue at offset 0x%8.8" PRIx64
416  " found opcode base of 0. Assuming no standard opcodes",
417  PrologueOffset));
418  } else if (Cursor) {
419  StandardOpcodeLengths.reserve(OpcodeBase - 1);
420  for (uint32_t I = 1; I < OpcodeBase; ++I) {
421  uint8_t OpLen = DebugLineData.getU8(Cursor);
422  StandardOpcodeLengths.push_back(OpLen);
423  }
424  }
425 
426  *OffsetPtr = Cursor.tell();
427  // A corrupt file name or directory table does not prevent interpretation of
428  // the main line program, so check the cursor state now so that its errors can
429  // be handled separately.
430  if (!Cursor)
431  return createStringError(
433  "parsing line table prologue at offset 0x%8.8" PRIx64 ": %s",
434  PrologueOffset, toString(Cursor.takeError()).c_str());
435 
436  Error E =
437  getVersion() >= 5
438  ? parseV5DirFileTables(DebugLineData, OffsetPtr, FormParams, Ctx, U,
439  ContentTypes, IncludeDirectories, FileNames)
440  : parseV2DirFileTables(DebugLineData, OffsetPtr, ContentTypes,
441  IncludeDirectories, FileNames);
442  if (E) {
443  RecoverableErrorHandler(joinErrors(
446  "parsing line table prologue at 0x%8.8" PRIx64
447  " found an invalid directory or file table description at"
448  " 0x%8.8" PRIx64,
449  PrologueOffset, *OffsetPtr),
450  std::move(E)));
451  return Error::success();
452  }
453 
454  assert(*OffsetPtr <= EndPrologueOffset);
455  if (*OffsetPtr != EndPrologueOffset) {
456  RecoverableErrorHandler(createStringError(
458  "unknown data in line table prologue at offset 0x%8.8" PRIx64
459  ": parsing ended (at offset 0x%8.8" PRIx64
460  ") before reaching the prologue end at offset 0x%8.8" PRIx64,
461  PrologueOffset, *OffsetPtr, EndPrologueOffset));
462  }
463  return Error::success();
464 }
465 
466 DWARFDebugLine::Row::Row(bool DefaultIsStmt) { reset(DefaultIsStmt); }
467 
469  Discriminator = 0;
470  BasicBlock = false;
471  PrologueEnd = false;
472  EpilogueBegin = false;
473 }
474 
475 void DWARFDebugLine::Row::reset(bool DefaultIsStmt) {
476  Address.Address = 0;
477  Address.SectionIndex = object::SectionedAddress::UndefSection;
478  Line = 1;
479  Column = 0;
480  File = 1;
481  Isa = 0;
482  Discriminator = 0;
483  IsStmt = DefaultIsStmt;
484  BasicBlock = false;
485  EndSequence = false;
486  PrologueEnd = false;
487  EpilogueBegin = false;
488 }
489 
491  OS.indent(Indent)
492  << "Address Line Column File ISA Discriminator Flags\n";
493  OS.indent(Indent)
494  << "------------------ ------ ------ ------ --- ------------- "
495  "-------------\n";
496 }
497 
499  OS << format("0x%16.16" PRIx64 " %6u %6u", Address.Address, Line, Column)
500  << format(" %6u %3u %13u ", File, Isa, Discriminator)
501  << (IsStmt ? " is_stmt" : "") << (BasicBlock ? " basic_block" : "")
502  << (PrologueEnd ? " prologue_end" : "")
503  << (EpilogueBegin ? " epilogue_begin" : "")
504  << (EndSequence ? " end_sequence" : "") << '\n';
505 }
506 
508 
510  LowPC = 0;
511  HighPC = 0;
513  FirstRowIndex = 0;
514  LastRowIndex = 0;
515  Empty = true;
516 }
517 
519 
521  DIDumpOptions DumpOptions) const {
522  Prologue.dump(OS, DumpOptions);
523 
524  if (!Rows.empty()) {
525  OS << '\n';
526  Row::dumpTableHeader(OS, 0);
527  for (const Row &R : Rows) {
528  R.dump(OS);
529  }
530  }
531 
532  // Terminate the table with a final blank line to clearly delineate it from
533  // later dumps.
534  OS << '\n';
535 }
536 
538  Prologue.clear();
539  Rows.clear();
540  Sequences.clear();
541 }
542 
543 DWARFDebugLine::ParsingState::ParsingState(
544  struct LineTable *LT, uint64_t TableOffset,
546  : LineTable(LT), LineTableOffset(TableOffset), ErrorHandler(ErrorHandler) {
547  resetRowAndSequence();
548 }
549 
550 void DWARFDebugLine::ParsingState::resetRowAndSequence() {
551  Row.reset(LineTable->Prologue.DefaultIsStmt);
552  Sequence.reset();
553 }
554 
555 void DWARFDebugLine::ParsingState::appendRowToMatrix() {
556  unsigned RowNumber = LineTable->Rows.size();
557  if (Sequence.Empty) {
558  // Record the beginning of instruction sequence.
559  Sequence.Empty = false;
560  Sequence.LowPC = Row.Address.Address;
561  Sequence.FirstRowIndex = RowNumber;
562  }
563  LineTable->appendRow(Row);
564  if (Row.EndSequence) {
565  // Record the end of instruction sequence.
566  Sequence.HighPC = Row.Address.Address;
567  Sequence.LastRowIndex = RowNumber + 1;
568  Sequence.SectionIndex = Row.Address.SectionIndex;
569  if (Sequence.isValid())
570  LineTable->appendSequence(Sequence);
571  Sequence.reset();
572  }
573  Row.postAppend();
574 }
575 
578  LineTableConstIter Pos = LineTableMap.find(Offset);
579  if (Pos != LineTableMap.end())
580  return &Pos->second;
581  return nullptr;
582 }
583 
585  DWARFDataExtractor &DebugLineData, uint64_t Offset, const DWARFContext &Ctx,
586  const DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) {
587  if (!DebugLineData.isValidOffset(Offset))
588  return createStringError(errc::invalid_argument, "offset 0x%8.8" PRIx64
589  " is not a valid debug line section offset",
590  Offset);
591 
592  std::pair<LineTableIter, bool> Pos =
593  LineTableMap.insert(LineTableMapTy::value_type(Offset, LineTable()));
594  LineTable *LT = &Pos.first->second;
595  if (Pos.second) {
596  if (Error Err =
597  LT->parse(DebugLineData, &Offset, Ctx, U, RecoverableErrorHandler))
598  return std::move(Err);
599  return LT;
600  }
601  return LT;
602 }
603 
605  LineTableMap.erase(Offset);
606 }
607 
608 static StringRef getOpcodeName(uint8_t Opcode, uint8_t OpcodeBase) {
609  assert(Opcode != 0);
610  if (Opcode < OpcodeBase)
611  return LNStandardString(Opcode);
612  return "special";
613 }
614 
615 uint64_t DWARFDebugLine::ParsingState::advanceAddr(uint64_t OperationAdvance,
616  uint8_t Opcode,
617  uint64_t OpcodeOffset) {
618  StringRef OpcodeName = getOpcodeName(Opcode, LineTable->Prologue.OpcodeBase);
619  // For versions less than 4, the MaxOpsPerInst member is set to 0, as the
620  // maximum_operations_per_instruction field wasn't introduced until DWARFv4.
621  // Don't warn about bad values in this situation.
622  if (ReportAdvanceAddrProblem && LineTable->Prologue.getVersion() >= 4 &&
623  LineTable->Prologue.MaxOpsPerInst != 1)
626  "line table program at offset 0x%8.8" PRIx64
627  " contains a %s opcode at offset 0x%8.8" PRIx64
628  ", but the prologue maximum_operations_per_instruction value is %" PRId8
629  ", which is unsupported. Assuming a value of 1 instead",
630  LineTableOffset, OpcodeName.data(), OpcodeOffset,
631  LineTable->Prologue.MaxOpsPerInst));
632  if (ReportAdvanceAddrProblem && LineTable->Prologue.MinInstLength == 0)
633  ErrorHandler(
635  "line table program at offset 0x%8.8" PRIx64
636  " contains a %s opcode at offset 0x%8.8" PRIx64
637  ", but the prologue minimum_instruction_length value "
638  "is 0, which prevents any address advancing",
639  LineTableOffset, OpcodeName.data(), OpcodeOffset));
640  ReportAdvanceAddrProblem = false;
641  uint64_t AddrOffset = OperationAdvance * LineTable->Prologue.MinInstLength;
642  Row.Address.Address += AddrOffset;
643  return AddrOffset;
644 }
645 
647 DWARFDebugLine::ParsingState::advanceAddrForOpcode(uint8_t Opcode,
648  uint64_t OpcodeOffset) {
649  assert(Opcode == DW_LNS_const_add_pc ||
650  Opcode >= LineTable->Prologue.OpcodeBase);
651  if (ReportBadLineRange && LineTable->Prologue.LineRange == 0) {
652  StringRef OpcodeName =
653  getOpcodeName(Opcode, LineTable->Prologue.OpcodeBase);
654  ErrorHandler(
656  "line table program at offset 0x%8.8" PRIx64
657  " contains a %s opcode at offset 0x%8.8" PRIx64
658  ", but the prologue line_range value is 0. The "
659  "address and line will not be adjusted",
660  LineTableOffset, OpcodeName.data(), OpcodeOffset));
661  ReportBadLineRange = false;
662  }
663 
664  uint8_t OpcodeValue = Opcode;
665  if (Opcode == DW_LNS_const_add_pc)
666  OpcodeValue = 255;
667  uint8_t AdjustedOpcode = OpcodeValue - LineTable->Prologue.OpcodeBase;
668  uint64_t OperationAdvance =
669  LineTable->Prologue.LineRange != 0
670  ? AdjustedOpcode / LineTable->Prologue.LineRange
671  : 0;
672  uint64_t AddrOffset = advanceAddr(OperationAdvance, Opcode, OpcodeOffset);
673  return {AddrOffset, AdjustedOpcode};
674 }
675 
677 DWARFDebugLine::ParsingState::handleSpecialOpcode(uint8_t Opcode,
678  uint64_t OpcodeOffset) {
679  // A special opcode value is chosen based on the amount that needs
680  // to be added to the line and address registers. The maximum line
681  // increment for a special opcode is the value of the line_base
682  // field in the header, plus the value of the line_range field,
683  // minus 1 (line base + line range - 1). If the desired line
684  // increment is greater than the maximum line increment, a standard
685  // opcode must be used instead of a special opcode. The "address
686  // advance" is calculated by dividing the desired address increment
687  // by the minimum_instruction_length field from the header. The
688  // special opcode is then calculated using the following formula:
689  //
690  // opcode = (desired line increment - line_base) +
691  // (line_range * address advance) + opcode_base
692  //
693  // If the resulting opcode is greater than 255, a standard opcode
694  // must be used instead.
695  //
696  // To decode a special opcode, subtract the opcode_base from the
697  // opcode itself to give the adjusted opcode. The amount to
698  // increment the address register is the result of the adjusted
699  // opcode divided by the line_range multiplied by the
700  // minimum_instruction_length field from the header. That is:
701  //
702  // address increment = (adjusted opcode / line_range) *
703  // minimum_instruction_length
704  //
705  // The amount to increment the line register is the line_base plus
706  // the result of the adjusted opcode modulo the line_range. That is:
707  //
708  // line increment = line_base + (adjusted opcode % line_range)
709 
711  advanceAddrForOpcode(Opcode, OpcodeOffset);
712  int32_t LineOffset = 0;
713  if (LineTable->Prologue.LineRange != 0)
714  LineOffset =
715  LineTable->Prologue.LineBase +
716  (AddrAdvanceResult.AdjustedOpcode % LineTable->Prologue.LineRange);
717  Row.Line += LineOffset;
718  return {AddrAdvanceResult.AddrDelta, LineOffset};
719 }
720 
721 /// Parse a ULEB128 using the specified \p Cursor. \returns the parsed value on
722 /// success, or None if \p Cursor is in a failing state.
723 template <typename T>
725  DataExtractor::Cursor &Cursor) {
726  T Value = Data.getULEB128(Cursor);
727  if (Cursor)
728  return Value;
729  return None;
730 }
731 
733  DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
734  const DWARFContext &Ctx, const DWARFUnit *U,
735  function_ref<void(Error)> RecoverableErrorHandler, raw_ostream *OS,
736  bool Verbose) {
737  assert((OS || !Verbose) && "cannot have verbose output without stream");
738  const uint64_t DebugLineOffset = *OffsetPtr;
739 
740  clear();
741 
742  Error PrologueErr =
743  Prologue.parse(DebugLineData, OffsetPtr, RecoverableErrorHandler, Ctx, U);
744 
745  if (OS) {
746  DIDumpOptions DumpOptions;
747  DumpOptions.Verbose = Verbose;
748  Prologue.dump(*OS, DumpOptions);
749  }
750 
751  if (PrologueErr) {
752  // Ensure there is a blank line after the prologue to clearly delineate it
753  // from later dumps.
754  if (OS)
755  *OS << "\n";
756  return PrologueErr;
757  }
758 
760  if (!DebugLineData.isValidOffsetForDataOfSize(DebugLineOffset,
761  ProgramLength)) {
762  assert(DebugLineData.size() > DebugLineOffset &&
763  "prologue parsing should handle invalid offset");
764  uint64_t BytesRemaining = DebugLineData.size() - DebugLineOffset;
765  RecoverableErrorHandler(
767  "line table program with offset 0x%8.8" PRIx64
768  " has length 0x%8.8" PRIx64 " but only 0x%8.8" PRIx64
769  " bytes are available",
770  DebugLineOffset, ProgramLength, BytesRemaining));
771  // Continue by capping the length at the number of remaining bytes.
772  ProgramLength = BytesRemaining;
773  }
774 
775  // Create a DataExtractor which can only see the data up to the end of the
776  // table, to prevent reading past the end.
777  const uint64_t EndOffset = DebugLineOffset + ProgramLength;
778  DWARFDataExtractor TableData(DebugLineData, EndOffset);
779 
780  // See if we should tell the data extractor the address size.
781  if (TableData.getAddressSize() == 0)
783  else
784  assert(Prologue.getAddressSize() == 0 ||
785  Prologue.getAddressSize() == TableData.getAddressSize());
786 
787  ParsingState State(this, DebugLineOffset, RecoverableErrorHandler);
788 
789  *OffsetPtr = DebugLineOffset + Prologue.getLength();
790  if (OS && *OffsetPtr < EndOffset) {
791  *OS << '\n';
792  Row::dumpTableHeader(*OS, /*Indent=*/Verbose ? 12 : 0);
793  }
794  bool TombstonedAddress = false;
795  auto EmitRow = [&] {
796  if (!TombstonedAddress) {
797  if (Verbose) {
798  *OS << "\n";
799  OS->indent(12);
800  }
801  if (OS)
802  State.Row.dump(*OS);
803  State.appendRowToMatrix();
804  }
805  };
806  while (*OffsetPtr < EndOffset) {
807  DataExtractor::Cursor Cursor(*OffsetPtr);
808 
809  if (Verbose)
810  *OS << format("0x%08.08" PRIx64 ": ", *OffsetPtr);
811 
812  uint64_t OpcodeOffset = *OffsetPtr;
813  uint8_t Opcode = TableData.getU8(Cursor);
814  size_t RowCount = Rows.size();
815 
816  if (Cursor && Verbose)
817  *OS << format("%02.02" PRIx8 " ", Opcode);
818 
819  if (Opcode == 0) {
820  // Extended Opcodes always start with a zero opcode followed by
821  // a uleb128 length so you can skip ones you don't know about
822  uint64_t Len = TableData.getULEB128(Cursor);
823  uint64_t ExtOffset = Cursor.tell();
824 
825  // Tolerate zero-length; assume length is correct and soldier on.
826  if (Len == 0) {
827  if (Cursor && Verbose)
828  *OS << "Badly formed extended line op (length 0)\n";
829  if (!Cursor) {
830  if (Verbose)
831  *OS << "\n";
832  RecoverableErrorHandler(Cursor.takeError());
833  }
834  *OffsetPtr = Cursor.tell();
835  continue;
836  }
837 
838  uint8_t SubOpcode = TableData.getU8(Cursor);
839  // OperandOffset will be the same as ExtOffset, if it was not possible to
840  // read the SubOpcode.
841  uint64_t OperandOffset = Cursor.tell();
842  if (Verbose)
843  *OS << LNExtendedString(SubOpcode);
844  switch (SubOpcode) {
845  case DW_LNE_end_sequence:
846  // Set the end_sequence register of the state machine to true and
847  // append a row to the matrix using the current values of the
848  // state-machine registers. Then reset the registers to the initial
849  // values specified above. Every statement program sequence must end
850  // with a DW_LNE_end_sequence instruction which creates a row whose
851  // address is that of the byte after the last target machine instruction
852  // of the sequence.
853  State.Row.EndSequence = true;
854  // No need to test the Cursor is valid here, since it must be to get
855  // into this code path - if it were invalid, the default case would be
856  // followed.
857  EmitRow();
858  State.resetRowAndSequence();
859  break;
860 
861  case DW_LNE_set_address:
862  // Takes a single relocatable address as an operand. The size of the
863  // operand is the size appropriate to hold an address on the target
864  // machine. Set the address register to the value given by the
865  // relocatable address. All of the other statement program opcodes
866  // that affect the address register add a delta to it. This instruction
867  // stores a relocatable value into it instead.
868  //
869  // Make sure the extractor knows the address size. If not, infer it
870  // from the size of the operand.
871  {
872  uint8_t ExtractorAddressSize = TableData.getAddressSize();
873  uint64_t OpcodeAddressSize = Len - 1;
874  if (ExtractorAddressSize != OpcodeAddressSize &&
875  ExtractorAddressSize != 0)
876  RecoverableErrorHandler(createStringError(
878  "mismatching address size at offset 0x%8.8" PRIx64
879  " expected 0x%2.2" PRIx8 " found 0x%2.2" PRIx64,
880  ExtOffset, ExtractorAddressSize, Len - 1));
881 
882  // Assume that the line table is correct and temporarily override the
883  // address size. If the size is unsupported, give up trying to read
884  // the address and continue to the next opcode.
885  if (OpcodeAddressSize != 1 && OpcodeAddressSize != 2 &&
886  OpcodeAddressSize != 4 && OpcodeAddressSize != 8) {
887  RecoverableErrorHandler(createStringError(
889  "address size 0x%2.2" PRIx64
890  " of DW_LNE_set_address opcode at offset 0x%8.8" PRIx64
891  " is unsupported",
892  OpcodeAddressSize, ExtOffset));
893  TableData.skip(Cursor, OpcodeAddressSize);
894  } else {
895  TableData.setAddressSize(OpcodeAddressSize);
896  State.Row.Address.Address = TableData.getRelocatedAddress(
897  Cursor, &State.Row.Address.SectionIndex);
898 
899  uint64_t Tombstone =
900  dwarf::computeTombstoneAddress(OpcodeAddressSize);
901  TombstonedAddress = State.Row.Address.Address == Tombstone;
902 
903  // Restore the address size if the extractor already had it.
904  if (ExtractorAddressSize != 0)
905  TableData.setAddressSize(ExtractorAddressSize);
906  }
907 
908  if (Cursor && Verbose) {
909  *OS << " (";
910  DWARFFormValue::dumpAddress(*OS, OpcodeAddressSize, State.Row.Address.Address);
911  *OS << ')';
912  }
913  }
914  break;
915 
916  case DW_LNE_define_file:
917  // Takes 4 arguments. The first is a null terminated string containing
918  // a source file name. The second is an unsigned LEB128 number
919  // representing the directory index of the directory in which the file
920  // was found. The third is an unsigned LEB128 number representing the
921  // time of last modification of the file. The fourth is an unsigned
922  // LEB128 number representing the length in bytes of the file. The time
923  // and length fields may contain LEB128(0) if the information is not
924  // available.
925  //
926  // The directory index represents an entry in the include_directories
927  // section of the statement program prologue. The index is LEB128(0)
928  // if the file was found in the current directory of the compilation,
929  // LEB128(1) if it was found in the first directory in the
930  // include_directories section, and so on. The directory index is
931  // ignored for file names that represent full path names.
932  //
933  // The files are numbered, starting at 1, in the order in which they
934  // appear; the names in the prologue come before names defined by
935  // the DW_LNE_define_file instruction. These numbers are used in the
936  // the file register of the state machine.
937  {
938  FileNameEntry FileEntry;
939  const char *Name = TableData.getCStr(Cursor);
940  FileEntry.Name =
941  DWARFFormValue::createFromPValue(dwarf::DW_FORM_string, Name);
942  FileEntry.DirIdx = TableData.getULEB128(Cursor);
943  FileEntry.ModTime = TableData.getULEB128(Cursor);
944  FileEntry.Length = TableData.getULEB128(Cursor);
945  Prologue.FileNames.push_back(FileEntry);
946  if (Cursor && Verbose)
947  *OS << " (" << Name << ", dir=" << FileEntry.DirIdx << ", mod_time="
948  << format("(0x%16.16" PRIx64 ")", FileEntry.ModTime)
949  << ", length=" << FileEntry.Length << ")";
950  }
951  break;
952 
953  case DW_LNE_set_discriminator:
954  State.Row.Discriminator = TableData.getULEB128(Cursor);
955  if (Cursor && Verbose)
956  *OS << " (" << State.Row.Discriminator << ")";
957  break;
958 
959  default:
960  if (Cursor && Verbose)
961  *OS << format("Unrecognized extended op 0x%02.02" PRIx8, SubOpcode)
962  << format(" length %" PRIx64, Len);
963  // Len doesn't include the zero opcode byte or the length itself, but
964  // it does include the sub_opcode, so we have to adjust for that.
965  TableData.skip(Cursor, Len - 1);
966  break;
967  }
968  // Make sure the length as recorded in the table and the standard length
969  // for the opcode match. If they don't, continue from the end as claimed
970  // by the table. Similarly, continue from the claimed end in the event of
971  // a parsing error.
972  uint64_t End = ExtOffset + Len;
973  if (Cursor && Cursor.tell() != End)
974  RecoverableErrorHandler(createStringError(
976  "unexpected line op length at offset 0x%8.8" PRIx64
977  " expected 0x%2.2" PRIx64 " found 0x%2.2" PRIx64,
978  ExtOffset, Len, Cursor.tell() - ExtOffset));
979  if (!Cursor && Verbose) {
980  DWARFDataExtractor::Cursor ByteCursor(OperandOffset);
981  uint8_t Byte = TableData.getU8(ByteCursor);
982  if (ByteCursor) {
983  *OS << " (<parsing error>";
984  do {
985  *OS << format(" %2.2" PRIx8, Byte);
986  Byte = TableData.getU8(ByteCursor);
987  } while (ByteCursor);
988  *OS << ")";
989  }
990 
991  // The only parse failure in this case should be if the end was reached.
992  // In that case, throw away the error, as the main Cursor's error will
993  // be sufficient.
994  consumeError(ByteCursor.takeError());
995  }
996  *OffsetPtr = End;
997  } else if (Opcode < Prologue.OpcodeBase) {
998  if (Verbose)
999  *OS << LNStandardString(Opcode);
1000  switch (Opcode) {
1001  // Standard Opcodes
1002  case DW_LNS_copy:
1003  // Takes no arguments. Append a row to the matrix using the
1004  // current values of the state-machine registers.
1005  EmitRow();
1006  break;
1007 
1008  case DW_LNS_advance_pc:
1009  // Takes a single unsigned LEB128 operand, multiplies it by the
1010  // min_inst_length field of the prologue, and adds the
1011  // result to the address register of the state machine.
1012  if (Optional<uint64_t> Operand =
1013  parseULEB128<uint64_t>(TableData, Cursor)) {
1014  uint64_t AddrOffset =
1015  State.advanceAddr(*Operand, Opcode, OpcodeOffset);
1016  if (Verbose)
1017  *OS << " (" << AddrOffset << ")";
1018  }
1019  break;
1020 
1021  case DW_LNS_advance_line:
1022  // Takes a single signed LEB128 operand and adds that value to
1023  // the line register of the state machine.
1024  {
1025  int64_t LineDelta = TableData.getSLEB128(Cursor);
1026  if (Cursor) {
1027  State.Row.Line += LineDelta;
1028  if (Verbose)
1029  *OS << " (" << State.Row.Line << ")";
1030  }
1031  }
1032  break;
1033 
1034  case DW_LNS_set_file:
1035  // Takes a single unsigned LEB128 operand and stores it in the file
1036  // register of the state machine.
1037  if (Optional<uint16_t> File =
1038  parseULEB128<uint16_t>(TableData, Cursor)) {
1039  State.Row.File = *File;
1040  if (Verbose)
1041  *OS << " (" << State.Row.File << ")";
1042  }
1043  break;
1044 
1045  case DW_LNS_set_column:
1046  // Takes a single unsigned LEB128 operand and stores it in the
1047  // column register of the state machine.
1048  if (Optional<uint16_t> Column =
1049  parseULEB128<uint16_t>(TableData, Cursor)) {
1050  State.Row.Column = *Column;
1051  if (Verbose)
1052  *OS << " (" << State.Row.Column << ")";
1053  }
1054  break;
1055 
1056  case DW_LNS_negate_stmt:
1057  // Takes no arguments. Set the is_stmt register of the state
1058  // machine to the logical negation of its current value.
1059  State.Row.IsStmt = !State.Row.IsStmt;
1060  break;
1061 
1062  case DW_LNS_set_basic_block:
1063  // Takes no arguments. Set the basic_block register of the
1064  // state machine to true
1065  State.Row.BasicBlock = true;
1066  break;
1067 
1068  case DW_LNS_const_add_pc:
1069  // Takes no arguments. Add to the address register of the state
1070  // machine the address increment value corresponding to special
1071  // opcode 255. The motivation for DW_LNS_const_add_pc is this:
1072  // when the statement program needs to advance the address by a
1073  // small amount, it can use a single special opcode, which occupies
1074  // a single byte. When it needs to advance the address by up to
1075  // twice the range of the last special opcode, it can use
1076  // DW_LNS_const_add_pc followed by a special opcode, for a total
1077  // of two bytes. Only if it needs to advance the address by more
1078  // than twice that range will it need to use both DW_LNS_advance_pc
1079  // and a special opcode, requiring three or more bytes.
1080  {
1081  uint64_t AddrOffset =
1082  State.advanceAddrForOpcode(Opcode, OpcodeOffset).AddrDelta;
1083  if (Verbose)
1084  *OS << format(" (0x%16.16" PRIx64 ")", AddrOffset);
1085  }
1086  break;
1087 
1088  case DW_LNS_fixed_advance_pc:
1089  // Takes a single uhalf operand. Add to the address register of
1090  // the state machine the value of the (unencoded) operand. This
1091  // is the only extended opcode that takes an argument that is not
1092  // a variable length number. The motivation for DW_LNS_fixed_advance_pc
1093  // is this: existing assemblers cannot emit DW_LNS_advance_pc or
1094  // special opcodes because they cannot encode LEB128 numbers or
1095  // judge when the computation of a special opcode overflows and
1096  // requires the use of DW_LNS_advance_pc. Such assemblers, however,
1097  // can use DW_LNS_fixed_advance_pc instead, sacrificing compression.
1098  {
1099  uint16_t PCOffset =
1100  TableData.getRelocatedValue(Cursor, 2);
1101  if (Cursor) {
1102  State.Row.Address.Address += PCOffset;
1103  if (Verbose)
1104  *OS << format(" (0x%4.4" PRIx16 ")", PCOffset);
1105  }
1106  }
1107  break;
1108 
1109  case DW_LNS_set_prologue_end:
1110  // Takes no arguments. Set the prologue_end register of the
1111  // state machine to true
1112  State.Row.PrologueEnd = true;
1113  break;
1114 
1115  case DW_LNS_set_epilogue_begin:
1116  // Takes no arguments. Set the basic_block register of the
1117  // state machine to true
1118  State.Row.EpilogueBegin = true;
1119  break;
1120 
1121  case DW_LNS_set_isa:
1122  // Takes a single unsigned LEB128 operand and stores it in the
1123  // ISA register of the state machine.
1124  if (Optional<uint8_t> Isa = parseULEB128<uint8_t>(TableData, Cursor)) {
1125  State.Row.Isa = *Isa;
1126  if (Verbose)
1127  *OS << " (" << (uint64_t)State.Row.Isa << ")";
1128  }
1129  break;
1130 
1131  default:
1132  // Handle any unknown standard opcodes here. We know the lengths
1133  // of such opcodes because they are specified in the prologue
1134  // as a multiple of LEB128 operands for each opcode.
1135  {
1136  assert(Opcode - 1U < Prologue.StandardOpcodeLengths.size());
1137  if (Verbose)
1138  *OS << "Unrecognized standard opcode";
1139  uint8_t OpcodeLength = Prologue.StandardOpcodeLengths[Opcode - 1];
1140  std::vector<uint64_t> Operands;
1141  for (uint8_t I = 0; I < OpcodeLength; ++I) {
1143  parseULEB128<uint64_t>(TableData, Cursor))
1144  Operands.push_back(*Value);
1145  else
1146  break;
1147  }
1148  if (Verbose && !Operands.empty()) {
1149  *OS << " (operands: ";
1150  bool First = true;
1151  for (uint64_t Value : Operands) {
1152  if (!First)
1153  *OS << ", ";
1154  First = false;
1155  *OS << format("0x%16.16" PRIx64, Value);
1156  }
1157  if (Verbose)
1158  *OS << ')';
1159  }
1160  }
1161  break;
1162  }
1163 
1164  *OffsetPtr = Cursor.tell();
1165  } else {
1166  // Special Opcodes.
1168  State.handleSpecialOpcode(Opcode, OpcodeOffset);
1169 
1170  if (Verbose)
1171  *OS << "address += " << Delta.Address << ", line += " << Delta.Line;
1172  EmitRow();
1173  *OffsetPtr = Cursor.tell();
1174  }
1175 
1176  // When a row is added to the matrix, it is also dumped, which includes a
1177  // new line already, so don't add an extra one.
1178  if (Verbose && Rows.size() == RowCount)
1179  *OS << "\n";
1180 
1181  // Most parse failures other than when parsing extended opcodes are due to
1182  // failures to read ULEBs. Bail out of parsing, since we don't know where to
1183  // continue reading from as there is no stated length for such byte
1184  // sequences. Print the final trailing new line if needed before doing so.
1185  if (!Cursor && Opcode != 0) {
1186  if (Verbose)
1187  *OS << "\n";
1188  return Cursor.takeError();
1189  }
1190 
1191  if (!Cursor)
1192  RecoverableErrorHandler(Cursor.takeError());
1193  }
1194 
1195  if (!State.Sequence.Empty)
1196  RecoverableErrorHandler(createStringError(
1198  "last sequence in debug line table at offset 0x%8.8" PRIx64
1199  " is not terminated",
1200  DebugLineOffset));
1201 
1202  // Sort all sequences so that address lookup will work faster.
1203  if (!Sequences.empty()) {
1204  llvm::sort(Sequences, Sequence::orderByHighPC);
1205  // Note: actually, instruction address ranges of sequences should not
1206  // overlap (in shared objects and executables). If they do, the address
1207  // lookup would still work, though, but result would be ambiguous.
1208  // We don't report warning in this case. For example,
1209  // sometimes .so compiled from multiple object files contains a few
1210  // rudimentary sequences for address ranges [0x0, 0xsomething).
1211  }
1212 
1213  // Terminate the table with a final blank line to clearly delineate it from
1214  // later dumps.
1215  if (OS)
1216  *OS << "\n";
1217 
1218  return Error::success();
1219 }
1220 
1221 uint32_t DWARFDebugLine::LineTable::findRowInSeq(
1222  const DWARFDebugLine::Sequence &Seq,
1223  object::SectionedAddress Address) const {
1224  if (!Seq.containsPC(Address))
1225  return UnknownRowIndex;
1226  assert(Seq.SectionIndex == Address.SectionIndex);
1227  // In some cases, e.g. first instruction in a function, the compiler generates
1228  // two entries, both with the same address. We want the last one.
1229  //
1230  // In general we want a non-empty range: the last row whose address is less
1231  // than or equal to Address. This can be computed as upper_bound - 1.
1233  Row.Address = Address;
1234  RowIter FirstRow = Rows.begin() + Seq.FirstRowIndex;
1235  RowIter LastRow = Rows.begin() + Seq.LastRowIndex;
1236  assert(FirstRow->Address.Address <= Row.Address.Address &&
1237  Row.Address.Address < LastRow[-1].Address.Address);
1238  RowIter RowPos = std::upper_bound(FirstRow + 1, LastRow - 1, Row,
1240  1;
1241  assert(Seq.SectionIndex == RowPos->Address.SectionIndex);
1242  return RowPos - Rows.begin();
1243 }
1244 
1246  object::SectionedAddress Address) const {
1247 
1248  // Search for relocatable addresses
1249  uint32_t Result = lookupAddressImpl(Address);
1250 
1251  if (Result != UnknownRowIndex ||
1252  Address.SectionIndex == object::SectionedAddress::UndefSection)
1253  return Result;
1254 
1255  // Search for absolute addresses
1256  Address.SectionIndex = object::SectionedAddress::UndefSection;
1257  return lookupAddressImpl(Address);
1258 }
1259 
1260 uint32_t DWARFDebugLine::LineTable::lookupAddressImpl(
1261  object::SectionedAddress Address) const {
1262  // First, find an instruction sequence containing the given address.
1264  Sequence.SectionIndex = Address.SectionIndex;
1265  Sequence.HighPC = Address.Address;
1266  SequenceIter It = llvm::upper_bound(Sequences, Sequence,
1268  if (It == Sequences.end() || It->SectionIndex != Address.SectionIndex)
1269  return UnknownRowIndex;
1270  return findRowInSeq(*It, Address);
1271 }
1272 
1274  object::SectionedAddress Address, uint64_t Size,
1275  std::vector<uint32_t> &Result) const {
1276 
1277  // Search for relocatable addresses
1278  if (lookupAddressRangeImpl(Address, Size, Result))
1279  return true;
1280 
1281  if (Address.SectionIndex == object::SectionedAddress::UndefSection)
1282  return false;
1283 
1284  // Search for absolute addresses
1285  Address.SectionIndex = object::SectionedAddress::UndefSection;
1286  return lookupAddressRangeImpl(Address, Size, Result);
1287 }
1288 
1289 bool DWARFDebugLine::LineTable::lookupAddressRangeImpl(
1290  object::SectionedAddress Address, uint64_t Size,
1291  std::vector<uint32_t> &Result) const {
1292  if (Sequences.empty())
1293  return false;
1294  uint64_t EndAddr = Address.Address + Size;
1295  // First, find an instruction sequence containing the given address.
1297  Sequence.SectionIndex = Address.SectionIndex;
1298  Sequence.HighPC = Address.Address;
1299  SequenceIter LastSeq = Sequences.end();
1300  SequenceIter SeqPos = llvm::upper_bound(
1302  if (SeqPos == LastSeq || !SeqPos->containsPC(Address))
1303  return false;
1304 
1305  SequenceIter StartPos = SeqPos;
1306 
1307  // Add the rows from the first sequence to the vector, starting with the
1308  // index we just calculated
1309 
1310  while (SeqPos != LastSeq && SeqPos->LowPC < EndAddr) {
1311  const DWARFDebugLine::Sequence &CurSeq = *SeqPos;
1312  // For the first sequence, we need to find which row in the sequence is the
1313  // first in our range.
1314  uint32_t FirstRowIndex = CurSeq.FirstRowIndex;
1315  if (SeqPos == StartPos)
1316  FirstRowIndex = findRowInSeq(CurSeq, Address);
1317 
1318  // Figure out the last row in the range.
1319  uint32_t LastRowIndex =
1320  findRowInSeq(CurSeq, {EndAddr - 1, Address.SectionIndex});
1321  if (LastRowIndex == UnknownRowIndex)
1322  LastRowIndex = CurSeq.LastRowIndex - 1;
1323 
1324  assert(FirstRowIndex != UnknownRowIndex);
1325  assert(LastRowIndex != UnknownRowIndex);
1326 
1327  for (uint32_t I = FirstRowIndex; I <= LastRowIndex; ++I) {
1328  Result.push_back(I);
1329  }
1330 
1331  ++SeqPos;
1332  }
1333 
1334  return true;
1335 }
1336 
1337 Optional<StringRef> DWARFDebugLine::LineTable::getSourceByIndex(uint64_t FileIndex,
1338  FileLineInfoKind Kind) const {
1339  if (Kind == FileLineInfoKind::None || !Prologue.hasFileAtIndex(FileIndex))
1340  return None;
1341  const FileNameEntry &Entry = Prologue.getFileNameEntry(FileIndex);
1342  if (auto E = dwarf::toString(Entry.Source))
1343  return StringRef(*E);
1344  return None;
1345 }
1346 
1347 static bool isPathAbsoluteOnWindowsOrPosix(const Twine &Path) {
1348  // Debug info can contain paths from any OS, not necessarily
1349  // an OS we're currently running on. Moreover different compilation units can
1350  // be compiled on different operating systems and linked together later.
1353 }
1354 
1356  uint64_t FileIndex, StringRef CompDir, FileLineInfoKind Kind,
1357  std::string &Result, sys::path::Style Style) const {
1358  if (Kind == FileLineInfoKind::None || !hasFileAtIndex(FileIndex))
1359  return false;
1360  const FileNameEntry &Entry = getFileNameEntry(FileIndex);
1361  auto E = dwarf::toString(Entry.Name);
1362  if (!E)
1363  return false;
1364  StringRef FileName = *E;
1365  if (Kind == FileLineInfoKind::RawValue ||
1366  isPathAbsoluteOnWindowsOrPosix(FileName)) {
1367  Result = std::string(FileName);
1368  return true;
1369  }
1370  if (Kind == FileLineInfoKind::BaseNameOnly) {
1371  Result = std::string(llvm::sys::path::filename(FileName));
1372  return true;
1373  }
1374 
1375  SmallString<16> FilePath;
1376  StringRef IncludeDir;
1377  // Be defensive about the contents of Entry.
1378  if (getVersion() >= 5) {
1379  // DirIdx 0 is the compilation directory, so don't include it for
1380  // relative names.
1381  if ((Entry.DirIdx != 0 || Kind != FileLineInfoKind::RelativeFilePath) &&
1382  Entry.DirIdx < IncludeDirectories.size())
1383  IncludeDir = dwarf::toStringRef(IncludeDirectories[Entry.DirIdx]);
1384  } else {
1385  if (0 < Entry.DirIdx && Entry.DirIdx <= IncludeDirectories.size())
1386  IncludeDir = dwarf::toStringRef(IncludeDirectories[Entry.DirIdx - 1]);
1387  }
1388 
1389  // For absolute paths only, include the compilation directory of compile unit.
1390  // We know that FileName is not absolute, the only way to have an absolute
1391  // path at this point would be if IncludeDir is absolute.
1392  if (Kind == FileLineInfoKind::AbsoluteFilePath && !CompDir.empty() &&
1393  !isPathAbsoluteOnWindowsOrPosix(IncludeDir))
1394  sys::path::append(FilePath, Style, CompDir);
1395 
1396  assert((Kind == FileLineInfoKind::AbsoluteFilePath ||
1397  Kind == FileLineInfoKind::RelativeFilePath) &&
1398  "invalid FileLineInfo Kind");
1399 
1400  // sys::path::append skips empty strings.
1401  sys::path::append(FilePath, Style, IncludeDir, FileName);
1402  Result = std::string(FilePath.str());
1403  return true;
1404 }
1405 
1407  object::SectionedAddress Address, const char *CompDir,
1408  FileLineInfoKind Kind, DILineInfo &Result) const {
1409  // Get the index of row we're looking for in the line table.
1410  uint32_t RowIndex = lookupAddress(Address);
1411  if (RowIndex == -1U)
1412  return false;
1413  // Take file number and line/column from the row.
1414  const auto &Row = Rows[RowIndex];
1415  if (!getFileNameByIndex(Row.File, CompDir, Kind, Result.FileName))
1416  return false;
1417  Result.Line = Row.Line;
1418  Result.Column = Row.Column;
1419  Result.Discriminator = Row.Discriminator;
1420  Result.Source = getSourceByIndex(Row.File, Kind);
1421  return true;
1422 }
1423 
1424 // We want to supply the Unit associated with a .debug_line[.dwo] table when
1425 // we dump it, if possible, but still dump the table even if there isn't a Unit.
1426 // Therefore, collect up handles on all the Units that point into the
1427 // line-table section.
1431  for (const auto &U : Units)
1432  if (auto CUDIE = U->getUnitDIE())
1433  if (auto StmtOffset = toSectionOffset(CUDIE.find(DW_AT_stmt_list)))
1434  LineToUnit.insert(std::make_pair(*StmtOffset, &*U));
1435  return LineToUnit;
1436 }
1437 
1441  : DebugLineData(Data), Context(C) {
1442  LineToUnit = buildLineToUnitMap(Units);
1443  if (!DebugLineData.isValidOffset(Offset))
1444  Done = true;
1445 }
1446 
1448  return TotalLength != 0u;
1449 }
1450 
1452  function_ref<void(Error)> RecoverableErrorHandler,
1453  function_ref<void(Error)> UnrecoverableErrorHandler, raw_ostream *OS,
1454  bool Verbose) {
1455  assert(DebugLineData.isValidOffset(Offset) &&
1456  "parsing should have terminated");
1457  DWARFUnit *U = prepareToParse(Offset);
1458  uint64_t OldOffset = Offset;
1459  LineTable LT;
1460  if (Error Err = LT.parse(DebugLineData, &Offset, Context, U,
1461  RecoverableErrorHandler, OS, Verbose))
1462  UnrecoverableErrorHandler(std::move(Err));
1463  moveToNextTable(OldOffset, LT.Prologue);
1464  return LT;
1465 }
1466 
1468  function_ref<void(Error)> RecoverableErrorHandler,
1469  function_ref<void(Error)> UnrecoverableErrorHandler) {
1470  assert(DebugLineData.isValidOffset(Offset) &&
1471  "parsing should have terminated");
1472  DWARFUnit *U = prepareToParse(Offset);
1473  uint64_t OldOffset = Offset;
1474  LineTable LT;
1475  if (Error Err = LT.Prologue.parse(DebugLineData, &Offset,
1476  RecoverableErrorHandler, Context, U))
1477  UnrecoverableErrorHandler(std::move(Err));
1478  moveToNextTable(OldOffset, LT.Prologue);
1479 }
1480 
1481 DWARFUnit *DWARFDebugLine::SectionParser::prepareToParse(uint64_t Offset) {
1482  DWARFUnit *U = nullptr;
1483  auto It = LineToUnit.find(Offset);
1484  if (It != LineToUnit.end())
1485  U = It->second;
1486  DebugLineData.setAddressSize(U ? U->getAddressByteSize() : 0);
1487  return U;
1488 }
1489 
1490 void DWARFDebugLine::SectionParser::moveToNextTable(uint64_t OldOffset,
1491  const Prologue &P) {
1492  // If the length field is not valid, we don't know where the next table is, so
1493  // cannot continue to parse. Mark the parser as done, and leave the Offset
1494  // value as it currently is. This will be the end of the bad length field.
1495  if (!P.totalLengthIsValid()) {
1496  Done = true;
1497  return;
1498  }
1499 
1500  Offset = OldOffset + P.TotalLength + P.sizeofTotalLength();
1501  if (!DebugLineData.isValidOffset(Offset)) {
1502  Done = true;
1503  }
1504 }
DWARFFormValue.h
llvm::errc::invalid_argument
@ invalid_argument
llvm::dwarf::LineNumberEntryFormat
LineNumberEntryFormat
Definition: Dwarf.h:377
llvm::DWARFDebugLine::Prologue::sizeofTotalLength
uint32_t sizeofTotalLength() const
Definition: DWARFDebugLine.h:101
isPathAbsoluteOnWindowsOrPosix
static bool isPathAbsoluteOnWindowsOrPosix(const Twine &Path)
Definition: DWARFDebugLine.cpp:1347
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::upper_bound
auto upper_bound(R &&Range, T &&Value)
Provide wrappers to std::upper_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1749
llvm::objcarc::Sequence
Sequence
Definition: PtrState.h:41
llvm::DWARFDebugLine::Sequence::reset
void reset()
Definition: DWARFDebugLine.cpp:509
Optional.h
llvm::DWARFDebugLine::getOrParseLineTable
Expected< const LineTable * > getOrParseLineTable(DWARFDataExtractor &DebugLineData, uint64_t Offset, const DWARFContext &Ctx, const DWARFUnit *U, function_ref< void(Error)> RecoverableErrorHandler)
Definition: DWARFDebugLine.cpp:584
llvm::sys::path::Style::posix
@ posix
llvm::DWARFDebugLine::Prologue::getAddressSize
uint8_t getAddressSize() const
Definition: DWARFDebugLine.h:98
llvm::DWARFDebugLine::Sequence::LastRowIndex
unsigned LastRowIndex
Definition: DWARFDebugLine.h:206
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::DWARFDebugLine::LineTable::LineTable
LineTable()
Definition: DWARFDebugLine.cpp:518
llvm::InlinerFunctionImportStatsOpts::Verbose
@ Verbose
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
llvm::dwarf::Form
Form
Definition: Dwarf.h:132
llvm::sys::path::is_absolute
bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
Definition: Path.cpp:671
llvm::object::SectionedAddress::Address
uint64_t Address
Definition: ObjectFile.h:147
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
DWARFDebugLine.h
llvm::DWARFDebugLine::Row::dump
void dump(raw_ostream &OS) const
Definition: DWARFDebugLine.cpp:498
llvm::DWARFDebugLine::Row::orderByAddress
static bool orderByAddress(const Row &LHS, const Row &RHS)
Definition: DWARFDebugLine.h:143
Errc.h
llvm::DWARFContext
DWARFContext This data structure is the top level entity that deals with dwarf debug information pars...
Definition: DWARFContext.h:47
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::DWARFDebugLine::ParsingState::AddrAndLineDelta::Line
int32_t Line
Definition: DWARFDebugLine.h:388
llvm::dwarf::FormParams::AddrSize
uint8_t AddrSize
Definition: Dwarf.h:655
llvm::Optional< uint64_t >
llvm::DWARFDebugLine::Prologue::parse
Error parse(DWARFDataExtractor Data, uint64_t *OffsetPtr, function_ref< void(Error)> RecoverableErrorHandler, const DWARFContext &Ctx, const DWARFUnit *U=nullptr)
Definition: DWARFDebugLine.cpp:363
llvm::DWARFDebugLine::Prologue::TotalLength
uint64_t TotalLength
The size in bytes of the statement information for this compilation unit (not including the total_len...
Definition: DWARFDebugLine.h:65
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::DWARFDebugLine::ContentTypeTracker::HasModTime
bool HasModTime
Whether filename entries provide a modification timestamp.
Definition: DWARFDebugLine.h:48
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
llvm::DWARFDebugLine::ContentTypeTracker::HasLength
bool HasLength
Whether filename entries provide a file size.
Definition: DWARFDebugLine.h:50
llvm::DWARFDataExtractor
A DataExtractor (typically for an in-memory copy of an object-file section) plus a relocation map for...
Definition: DWARFDataExtractor.h:21
llvm::DWARFDebugLine::LineTable::getFileLineInfoForAddress
bool getFileLineInfoForAddress(object::SectionedAddress Address, const char *CompDir, DILineInfoSpecifier::FileLineInfoKind Kind, DILineInfo &Result) const
Fills the Result argument with the file and line information corresponding to Address.
Definition: DWARFDebugLine.cpp:1406
Format.h
llvm::dwarf::FormParams::Format
DwarfFormat Format
Definition: Dwarf.h:656
llvm::DataExtractor::skip
void skip(Cursor &C, uint64_t Length) const
Advance the Cursor position by the given number of bytes.
Definition: DataExtractor.cpp:228
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1043
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::DWARFDebugLine::getLineTable
const LineTable * getLineTable(uint64_t Offset) const
Definition: DWARFDebugLine.cpp:577
llvm::DWARFDebugLine::Sequence::Sequence
Sequence()
Definition: DWARFDebugLine.cpp:507
llvm::DWARFFormValue::createFromPValue
static DWARFFormValue createFromPValue(dwarf::Form F, const char *V)
Definition: DWARFFormValue.cpp:91
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
llvm::sys::path::append
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:456
llvm::AArch64CC::LT
@ LT
Definition: AArch64BaseInfo.h:266
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::DWARFDebugLine::Row::Row
Row(bool DefaultIsStmt=false)
Definition: DWARFDebugLine.cpp:466
llvm::DWARFUnit::getUnitDIE
DWARFDie getUnitDIE(bool ExtractUnitDIEOnly=true)
Definition: DWARFUnit.h:402
clear
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:149
llvm::DWARFDebugLine::ParsingState::AddrAndLineDelta
Definition: DWARFDebugLine.h:386
llvm::DataExtractor::getULEB128
uint64_t getULEB128(uint64_t *offset_ptr, llvm::Error *Err=nullptr) const
Extract a unsigned LEB128 value from *offset_ptr.
Definition: DataExtractor.cpp:220
llvm::DWARFDebugLine::Prologue::getFileNameEntry
const llvm::DWARFDebugLine::FileNameEntry & getFileNameEntry(uint64_t Index) const
Get DWARF-version aware access to the file name entry at the provided index.
Definition: DWARFDebugLine.cpp:99
llvm::formatv
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
Definition: FormatVariadic.h:251
llvm::DataExtractor::Cursor::takeError
Error takeError()
Return error contained inside this Cursor, if any.
Definition: DataExtractor.h:78
ErrorHandler
static fatal_error_handler_t ErrorHandler
Definition: ErrorHandling.cpp:42
llvm::DWARFDataExtractor::getRelocatedAddress
uint64_t getRelocatedAddress(uint64_t *Off, uint64_t *SecIx=nullptr) const
Extracts an address-sized value and applies a relocation to the result if one exists for the given of...
Definition: DWARFDataExtractor.h:72
llvm::DWARFDebugLine::Sequence::SectionIndex
uint64_t SectionIndex
If relocation information is present then this is the index of the section which contains above addre...
Definition: DWARFDebugLine.h:204
llvm::dwarf::LNExtendedString
StringRef LNExtendedString(unsigned Encoding)
Definition: Dwarf.cpp:446
llvm::DWARFDebugLine::Row
Standard .debug_line state machine structure.
Definition: DWARFDebugLine.h:133
llvm::DIDumpOptions::Verbose
bool Verbose
Definition: DIContext.h:199
llvm::DWARFDataExtractor::getRelocatedValue
uint64_t getRelocatedValue(uint32_t Size, uint64_t *Off, uint64_t *SectionIndex=nullptr, Error *Err=nullptr) const
Extracts a value and applies a relocation to the result if one exists for the given offset.
Definition: DWARFDataExtractor.cpp:48
SmallString.h
llvm::dwarf::computeTombstoneAddress
uint64_t computeTombstoneAddress(uint8_t AddressByteSize)
Definition: Dwarf.h:780
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::DWARFDebugLine::Prologue::hasFileAtIndex
bool hasFileAtIndex(uint64_t FileIndex) const
Definition: DWARFDebugLine.cpp:77
llvm::DWARFDebugLine::LineTable::parse
Error parse(DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr, const DWARFContext &Ctx, const DWARFUnit *U, function_ref< void(Error)> RecoverableErrorHandler, raw_ostream *OS=nullptr, bool Verbose=false)
Parse prologue and all rows.
Definition: DWARFDebugLine.cpp:732
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::DataExtractor::getAddressSize
uint8_t getAddressSize() const
Get the address size for this extractor.
Definition: DataExtractor.h:99
llvm::DWARFDebugLine::Prologue::getLastValidFileIndex
Optional< uint64_t > getLastValidFileIndex() const
Definition: DWARFDebugLine.cpp:86
llvm::DWARFFormValue::dump
void dump(raw_ostream &OS, DIDumpOptions DumpOpts=DIDumpOptions()) const
Definition: DWARFFormValue.cpp:408
llvm::DWARFDebugLine::Prologue::OpcodeBase
uint8_t OpcodeBase
The number assigned to the first special opcode.
Definition: DWARFDebugLine.h:89
DWARFDie.h
parseV5DirFileTables
static Error parseV5DirFileTables(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr, const dwarf::FormParams &FormParams, const DWARFContext &Ctx, const DWARFUnit *U, DWARFDebugLine::ContentTypeTracker &ContentTypes, std::vector< DWARFFormValue > &IncludeDirectories, std::vector< DWARFDebugLine::FileNameEntry > &FileNames)
Definition: DWARFDebugLine.cpp:272
llvm::dwarf::Index
Index
Definition: Dwarf.h:472
llvm::dwarf::toStringRef
StringRef toStringRef(const Optional< DWARFFormValue > &V, StringRef Default={})
Take an optional DWARFFormValue and try to extract a string value from it.
Definition: DWARFFormValue.h:193
llvm::DWARFDebugLine::Prologue::getFileNameByIndex
bool getFileNameByIndex(uint64_t FileIndex, StringRef CompDir, DILineInfoSpecifier::FileLineInfoKind Kind, std::string &Result, sys::path::Style Style=sys::path::Style::native) const
Definition: DWARFDebugLine.cpp:1355
First
into llvm powi allowing the code generator to produce balanced multiplication trees First
Definition: README.txt:54
getOpcodeName
static StringRef getOpcodeName(uint8_t Opcode, uint8_t OpcodeBase)
Definition: DWARFDebugLine.cpp:608
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:318
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::DWARFFormValue
Definition: DWARFFormValue.h:28
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:1451
llvm::DWARFDebugLine::Prologue::totalLengthIsValid
bool totalLengthIsValid() const
Definition: DWARFDebugLine.cpp:1447
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:1027
llvm::sys::path::Style
Style
Definition: Path.h:27
llvm::DWARFDebugLine::FileNameEntry::Length
uint64_t Length
Definition: DWARFDebugLine.h:37
FormatVariadic.h
llvm::DataExtractor::setAddressSize
void setAddressSize(uint8_t Size)
Set the address size for this extractor.
Definition: DataExtractor.h:101
llvm::sys::path::Style::windows
@ windows
llvm::None
const NoneType None
Definition: None.h:24
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::DWARFDebugLine::LineTable::lookupAddressRange
bool lookupAddressRange(object::SectionedAddress Address, uint64_t Size, std::vector< uint32_t > &Result) const
Definition: DWARFDebugLine.cpp:1273
llvm::SmallString< 16 >
versionIsSupported
static bool versionIsSupported(uint16_t Version)
Definition: DWARFDebugLine.cpp:49
Operands
mir Rename Register Operands
Definition: MIRNamerPass.cpp:74
parseULEB128
static Optional< T > parseULEB128(DWARFDataExtractor &Data, DataExtractor::Cursor &Cursor)
Parse a ULEB128 using the specified Cursor.
Definition: DWARFDebugLine.cpp:724
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLFunctionalExtras.h:36
llvm::errc::illegal_byte_sequence
@ illegal_byte_sequence
llvm::DWARFDebugLine::Sequence::HighPC
uint64_t HighPC
Definition: DWARFDebugLine.h:200
llvm::DataExtractor::size
size_t size() const
Return the number of bytes in the underlying buffer.
Definition: DataExtractor.h:688
llvm::DWARFDebugLine::Sequence::orderByHighPC
static bool orderByHighPC(const Sequence &LHS, const Sequence &RHS)
Definition: DWARFDebugLine.h:211
llvm::DWARFDebugLine::Sequence
Represents a series of contiguous machine instructions.
Definition: DWARFDebugLine.h:194
llvm::DWARFDebugLine::Prologue
Definition: DWARFDebugLine.h:60
llvm::DWARFDebugLine::ParsingState::AddrAndAdjustedOpcode::AddrDelta
uint64_t AddrDelta
Definition: DWARFDebugLine.h:377
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
uint64_t
llvm::DataExtractor::isValidOffsetForDataOfSize
bool isValidOffsetForDataOfSize(uint64_t offset, uint64_t length) const
Test the availability of length bytes of data from offset.
Definition: DataExtractor.h:672
llvm::DWARFDebugLine::ParsingState::AddrAndAdjustedOpcode
Definition: DWARFDebugLine.h:376
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::object::SectionedAddress::UndefSection
const static uint64_t UndefSection
Definition: ObjectFile.h:145
llvm::DWARFDebugLine::Row::dumpTableHeader
static void dumpTableHeader(raw_ostream &OS, unsigned Indent)
Definition: DWARFDebugLine.cpp:490
llvm::DWARFDebugLine::Row::reset
void reset(bool DefaultIsStmt)
Definition: DWARFDebugLine.cpp:475
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::DILineInfo
A format-neutral container for source line information.
Definition: DIContext.h:31
llvm::DILineInfoSpecifier::FileLineInfoKind
FileLineInfoKind
Definition: DIContext.h:140
llvm::joinErrors
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:426
llvm::DWARFDebugLine::FileNameEntry::DirIdx
uint64_t DirIdx
Definition: DWARFDebugLine.h:35
llvm::HexStyle::Style
Style
Definition: MCInstPrinter.h:32
llvm::dwarf::FormParams
A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...
Definition: Dwarf.h:653
llvm::DataExtractor::isValidOffset
bool isValidOffset(uint64_t offset) const
Test the validity of offset.
Definition: DataExtractor.h:665
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::DWARFDebugLine::LineTable::lookupAddress
uint32_t lookupAddress(object::SectionedAddress Address) const
Returns the index of the row with file/line info for a given address, or UnknownRowIndex if there is ...
Definition: DWARFDebugLine.cpp:1245
llvm::DWARFDataExtractor::getInitialLength
std::pair< uint64_t, dwarf::DwarfFormat > getInitialLength(uint64_t *Off, Error *Err=nullptr) const
Extracts the DWARF "initial length" field, which can either be a 32-bit value smaller than 0xfffffff0...
Definition: DWARFDataExtractor.cpp:17
llvm::DWARFDebugLine::Sequence::FirstRowIndex
unsigned FirstRowIndex
Definition: DWARFDebugLine.h:205
llvm::DWARFDebugLine::Row::postAppend
void postAppend()
Called after a row is appended to the matrix.
Definition: DWARFDebugLine.cpp:468
EndSequence
@ EndSequence
End of the line table.
Definition: LineTable.cpp:17
llvm::DataExtractor::Cursor::tell
uint64_t tell() const
Return the current position of this Cursor.
Definition: DataExtractor.h:71
llvm::DWARFDebugLine::ParsingState::AddrAndAdjustedOpcode::AdjustedOpcode
uint8_t AdjustedOpcode
Definition: DWARFDebugLine.h:378
llvm::DataExtractor::Cursor
A class representing a position in a DataExtractor, as well as any error encountered during extractio...
Definition: DataExtractor.h:54
llvm::DWARFDebugLine::Row::Discriminator
uint32_t Discriminator
An unsigned integer representing the DWARF path discriminator value for this location.
Definition: DWARFDebugLine.h:167
parseV2DirFileTables
static Error parseV2DirFileTables(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr, DWARFDebugLine::ContentTypeTracker &ContentTypes, std::vector< DWARFFormValue > &IncludeDirectories, std::vector< DWARFDebugLine::FileNameEntry > &FileNames)
Definition: DWARFDebugLine.cpp:187
llvm::dwarf::toString
Optional< const char * > toString(const Optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
Definition: DWARFFormValue.h:177
llvm::DataExtractor::getCStr
const char * getCStr(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a C string from *offset_ptr.
Definition: DataExtractor.h:129
llvm::DWARFDebugLine::clearLineTable
void clearLineTable(uint64_t Offset)
Definition: DWARFDebugLine.cpp:604
llvm::DWARFFormValue::dumpAddress
void dumpAddress(raw_ostream &OS, uint64_t Address) const
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
Dwarf.h
llvm::errc::not_supported
@ not_supported
llvm::DWARFDebugLine::FileNameEntry
Definition: DWARFDebugLine.h:31
uint32_t
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
buildLineToUnitMap
static DWARFDebugLine::SectionParser::LineToUnitMap buildLineToUnitMap(DWARFUnitVector::iterator_range Units)
Definition: DWARFDebugLine.cpp:1429
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::DWARFDebugLine::ContentTypeTracker
Tracks which optional content types are present in a DWARF file name entry format.
Definition: DWARFDebugLine.h:44
llvm::DataExtractor::getU8
uint8_t getU8(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint8_t value from *offset_ptr.
Definition: DataExtractor.cpp:79
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::DWARFUnit::getAddressByteSize
uint8_t getAddressByteSize() const
Definition: DWARFUnit.h:295
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1239
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
uint16_t
llvm::DWARFUnit
Definition: DWARFUnit.h:207
llvm::DWARFDebugLine::Prologue::getLength
uint64_t getLength() const
Length of the prologue in bytes.
Definition: DWARFDebugLine.cpp:355
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::c_str
SmallVectorImpl< T >::const_pointer c_str(SmallVectorImpl< T > &str)
Definition: WindowsSupport.h:193
llvm::DWARFDebugLine::Row::Line
uint32_t Line
An unsigned integer indicating a source line number.
Definition: DWARFDebugLine.h:157
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1562
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::DWARFDebugLine::Row::Address
object::SectionedAddress Address
The program-counter value corresponding to a machine instruction generated by the compiler and sectio...
Definition: DWARFDebugLine.h:153
llvm::DWARFDebugLine::FileNameEntry::Checksum
MD5::MD5Result Checksum
Definition: DWARFDebugLine.h:38
llvm::DataExtractor::getCStrRef
StringRef getCStrRef(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a C string from *offset_ptr.
Definition: DataExtractor.cpp:155
llvm::SmallString::str
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:260
llvm::dwarf::LNStandardString
StringRef LNStandardString(unsigned Standard)
Definition: Dwarf.cpp:435
llvm::DWARFDebugLine::Sequence::containsPC
bool containsPC(object::SectionedAddress PC) const
Definition: DWARFDebugLine.h:220
llvm::DWARFDebugLine::Row::Column
uint16_t Column
An unsigned integer indicating a column number within a source line.
Definition: DWARFDebugLine.h:161
llvm::dwarf::FormParams::Version
uint16_t Version
Definition: Dwarf.h:654
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:597
llvm::DWARFDebugLine::Prologue::FileNames
std::vector< FileNameEntry > FileNames
Definition: DWARFDebugLine.h:94
llvm::DWARFDebugLine::ParsingState::AddrAndLineDelta::Address
uint64_t Address
Definition: DWARFDebugLine.h:387
llvm::DWARFDebugLine::Prologue::clear
void clear()
Definition: DWARFDebugLine.cpp:109
llvm::DWARFDebugLine::FileNameEntry::Source
DWARFFormValue Source
Definition: DWARFDebugLine.h:39
llvm::sys::path::filename
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:577
SmallVector.h
llvm::DWARFDebugLine::Prologue::Prologue
Prologue()
Definition: DWARFDebugLine.cpp:75
llvm::raw_ostream::indent
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
Definition: raw_ostream.cpp:496
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:1467
llvm::DWARFDebugLine::Prologue::StandardOpcodeLengths
std::vector< uint8_t > StandardOpcodeLengths
Definition: DWARFDebugLine.h:92
llvm::object::SectionedAddress
Definition: ObjectFile.h:144
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::DWARFDebugLine::LineTable
Definition: DWARFDebugLine.h:226
parseV5EntryFormat
static llvm::Expected< ContentDescriptors > parseV5EntryFormat(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr, DWARFDebugLine::ContentTypeTracker *ContentTypes)
Definition: DWARFDebugLine.cpp:241
llvm::DWARFDebugLine::SectionParser::SectionParser
SectionParser(DWARFDataExtractor &Data, const DWARFContext &C, DWARFUnitVector::iterator_range Units)
Definition: DWARFDebugLine.cpp:1438
llvm::DWARFDebugLine::Row::File
uint16_t File
An unsigned integer indicating the identity of the source file corresponding to a machine instruction...
Definition: DWARFDebugLine.h:164
llvm::StringRef::data
const LLVM_NODISCARD char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:149
llvm::dwarf::LineNumberOps
LineNumberOps
Line Number Standard Opcode Encodings.
Definition: Dwarf.h:364
llvm::DWARFDebugLine::SectionParser::LineToUnitMap
std::map< uint64_t, DWARFUnit * > LineToUnitMap
Definition: DWARFDebugLine.h:312
llvm::DWARFDebugLine::FileNameEntry::Name
DWARFFormValue Name
Definition: DWARFDebugLine.h:34
llvm::DWARFDebugLine::FileNameEntry::ModTime
uint64_t ModTime
Definition: DWARFDebugLine.h:36
llvm::DWARFDebugLine::LineTable::dump
void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const
Definition: DWARFDebugLine.cpp:520
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:640
llvm::DWARFDebugLine::LineTable::clear
void clear()
Definition: DWARFDebugLine.cpp:537
llvm::DWARFDebugLine::ContentTypeTracker::trackContentType
void trackContentType(dwarf::LineNumberEntryFormat ContentType)
Update tracked content types with ContentType.
Definition: DWARFDebugLine.cpp:53
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::dwarf::DWARF32
@ DWARF32
Definition: Dwarf.h:93
llvm::DWARFDebugLine::Prologue::dump
void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const
Definition: DWARFDebugLine.cpp:121
DWARFDataExtractor.h
llvm::DataExtractor::getU16
uint16_t getU16(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint16_t value from *offset_ptr.
Definition: DataExtractor.cpp:92
llvm::MD5::MD5Result::digest
SmallString< 32 > digest() const
Definition: MD5.cpp:281
llvm::DIDumpOptions
Container for dump options that control which debug information will be dumped.
Definition: DIContext.h:188
llvm::DataExtractor::getSLEB128
int64_t getSLEB128(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a signed LEB128 value from *offset_ptr.
Definition: DataExtractor.cpp:224