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