LLVM  14.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"
17 #include "llvm/Support/Errc.h"
18 #include "llvm/Support/Format.h"
20 #include "llvm/Support/WithColor.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().getValue();
327  break;
328  case DW_LNCT_timestamp:
329  FileEntry.ModTime = Value.getAsUnsignedConstant().getValue();
330  break;
331  case DW_LNCT_size:
332  FileEntry.Length = Value.getAsUnsignedConstant().getValue();
333  break;
334  case DW_LNCT_MD5:
335  if (!Value.getAsBlock() || Value.getAsBlock().getValue().size() != 16)
336  return createStringError(
338  "failed to parse file entry because the MD5 hash is invalid");
339  std::uninitialized_copy_n(Value.getAsBlock().getValue().begin(), 16,
340  FileEntry.Checksum.Bytes.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;
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 
600 static StringRef getOpcodeName(uint8_t Opcode, uint8_t OpcodeBase) {
601  assert(Opcode != 0);
602  if (Opcode < OpcodeBase)
603  return LNStandardString(Opcode);
604  return "special";
605 }
606 
607 uint64_t DWARFDebugLine::ParsingState::advanceAddr(uint64_t OperationAdvance,
608  uint8_t Opcode,
609  uint64_t OpcodeOffset) {
610  StringRef OpcodeName = getOpcodeName(Opcode, LineTable->Prologue.OpcodeBase);
611  // For versions less than 4, the MaxOpsPerInst member is set to 0, as the
612  // maximum_operations_per_instruction field wasn't introduced until DWARFv4.
613  // Don't warn about bad values in this situation.
614  if (ReportAdvanceAddrProblem && LineTable->Prologue.getVersion() >= 4 &&
615  LineTable->Prologue.MaxOpsPerInst != 1)
618  "line table program at offset 0x%8.8" PRIx64
619  " contains a %s opcode at offset 0x%8.8" PRIx64
620  ", but the prologue maximum_operations_per_instruction value is %" PRId8
621  ", which is unsupported. Assuming a value of 1 instead",
622  LineTableOffset, OpcodeName.data(), OpcodeOffset,
623  LineTable->Prologue.MaxOpsPerInst));
624  if (ReportAdvanceAddrProblem && LineTable->Prologue.MinInstLength == 0)
625  ErrorHandler(
627  "line table program at offset 0x%8.8" PRIx64
628  " contains a %s opcode at offset 0x%8.8" PRIx64
629  ", but the prologue minimum_instruction_length value "
630  "is 0, which prevents any address advancing",
631  LineTableOffset, OpcodeName.data(), OpcodeOffset));
632  ReportAdvanceAddrProblem = false;
633  uint64_t AddrOffset = OperationAdvance * LineTable->Prologue.MinInstLength;
634  Row.Address.Address += AddrOffset;
635  return AddrOffset;
636 }
637 
639 DWARFDebugLine::ParsingState::advanceAddrForOpcode(uint8_t Opcode,
640  uint64_t OpcodeOffset) {
641  assert(Opcode == DW_LNS_const_add_pc ||
642  Opcode >= LineTable->Prologue.OpcodeBase);
643  if (ReportBadLineRange && LineTable->Prologue.LineRange == 0) {
644  StringRef OpcodeName =
645  getOpcodeName(Opcode, LineTable->Prologue.OpcodeBase);
646  ErrorHandler(
648  "line table program at offset 0x%8.8" PRIx64
649  " contains a %s opcode at offset 0x%8.8" PRIx64
650  ", but the prologue line_range value is 0. The "
651  "address and line will not be adjusted",
652  LineTableOffset, OpcodeName.data(), OpcodeOffset));
653  ReportBadLineRange = false;
654  }
655 
656  uint8_t OpcodeValue = Opcode;
657  if (Opcode == DW_LNS_const_add_pc)
658  OpcodeValue = 255;
659  uint8_t AdjustedOpcode = OpcodeValue - LineTable->Prologue.OpcodeBase;
660  uint64_t OperationAdvance =
661  LineTable->Prologue.LineRange != 0
662  ? AdjustedOpcode / LineTable->Prologue.LineRange
663  : 0;
664  uint64_t AddrOffset = advanceAddr(OperationAdvance, Opcode, OpcodeOffset);
665  return {AddrOffset, AdjustedOpcode};
666 }
667 
669 DWARFDebugLine::ParsingState::handleSpecialOpcode(uint8_t Opcode,
670  uint64_t OpcodeOffset) {
671  // A special opcode value is chosen based on the amount that needs
672  // to be added to the line and address registers. The maximum line
673  // increment for a special opcode is the value of the line_base
674  // field in the header, plus the value of the line_range field,
675  // minus 1 (line base + line range - 1). If the desired line
676  // increment is greater than the maximum line increment, a standard
677  // opcode must be used instead of a special opcode. The "address
678  // advance" is calculated by dividing the desired address increment
679  // by the minimum_instruction_length field from the header. The
680  // special opcode is then calculated using the following formula:
681  //
682  // opcode = (desired line increment - line_base) +
683  // (line_range * address advance) + opcode_base
684  //
685  // If the resulting opcode is greater than 255, a standard opcode
686  // must be used instead.
687  //
688  // To decode a special opcode, subtract the opcode_base from the
689  // opcode itself to give the adjusted opcode. The amount to
690  // increment the address register is the result of the adjusted
691  // opcode divided by the line_range multiplied by the
692  // minimum_instruction_length field from the header. That is:
693  //
694  // address increment = (adjusted opcode / line_range) *
695  // minimum_instruction_length
696  //
697  // The amount to increment the line register is the line_base plus
698  // the result of the adjusted opcode modulo the line_range. That is:
699  //
700  // line increment = line_base + (adjusted opcode % line_range)
701 
703  advanceAddrForOpcode(Opcode, OpcodeOffset);
704  int32_t LineOffset = 0;
705  if (LineTable->Prologue.LineRange != 0)
706  LineOffset =
707  LineTable->Prologue.LineBase +
708  (AddrAdvanceResult.AdjustedOpcode % LineTable->Prologue.LineRange);
709  Row.Line += LineOffset;
710  return {AddrAdvanceResult.AddrDelta, LineOffset};
711 }
712 
713 /// Parse a ULEB128 using the specified \p Cursor. \returns the parsed value on
714 /// success, or None if \p Cursor is in a failing state.
715 template <typename T>
717  DataExtractor::Cursor &Cursor) {
718  T Value = Data.getULEB128(Cursor);
719  if (Cursor)
720  return Value;
721  return None;
722 }
723 
725  DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
726  const DWARFContext &Ctx, const DWARFUnit *U,
727  function_ref<void(Error)> RecoverableErrorHandler, raw_ostream *OS,
728  bool Verbose) {
729  assert((OS || !Verbose) && "cannot have verbose output without stream");
730  const uint64_t DebugLineOffset = *OffsetPtr;
731 
732  clear();
733 
734  Error PrologueErr =
735  Prologue.parse(DebugLineData, OffsetPtr, RecoverableErrorHandler, Ctx, U);
736 
737  if (OS) {
738  DIDumpOptions DumpOptions;
739  DumpOptions.Verbose = Verbose;
740  Prologue.dump(*OS, DumpOptions);
741  }
742 
743  if (PrologueErr) {
744  // Ensure there is a blank line after the prologue to clearly delineate it
745  // from later dumps.
746  if (OS)
747  *OS << "\n";
748  return PrologueErr;
749  }
750 
752  if (!DebugLineData.isValidOffsetForDataOfSize(DebugLineOffset,
753  ProgramLength)) {
754  assert(DebugLineData.size() > DebugLineOffset &&
755  "prologue parsing should handle invalid offset");
756  uint64_t BytesRemaining = DebugLineData.size() - DebugLineOffset;
757  RecoverableErrorHandler(
759  "line table program with offset 0x%8.8" PRIx64
760  " has length 0x%8.8" PRIx64 " but only 0x%8.8" PRIx64
761  " bytes are available",
762  DebugLineOffset, ProgramLength, BytesRemaining));
763  // Continue by capping the length at the number of remaining bytes.
764  ProgramLength = BytesRemaining;
765  }
766 
767  // Create a DataExtractor which can only see the data up to the end of the
768  // table, to prevent reading past the end.
769  const uint64_t EndOffset = DebugLineOffset + ProgramLength;
770  DWARFDataExtractor TableData(DebugLineData, EndOffset);
771 
772  // See if we should tell the data extractor the address size.
773  if (TableData.getAddressSize() == 0)
775  else
776  assert(Prologue.getAddressSize() == 0 ||
777  Prologue.getAddressSize() == TableData.getAddressSize());
778 
779  ParsingState State(this, DebugLineOffset, RecoverableErrorHandler);
780 
781  *OffsetPtr = DebugLineOffset + Prologue.getLength();
782  if (OS && *OffsetPtr < EndOffset) {
783  *OS << '\n';
784  Row::dumpTableHeader(*OS, /*Indent=*/Verbose ? 12 : 0);
785  }
786  bool TombstonedAddress = false;
787  auto EmitRow = [&] {
788  if (!TombstonedAddress) {
789  if (Verbose) {
790  *OS << "\n";
791  OS->indent(12);
792  }
793  if (OS)
794  State.Row.dump(*OS);
795  State.appendRowToMatrix();
796  }
797  };
798  while (*OffsetPtr < EndOffset) {
799  DataExtractor::Cursor Cursor(*OffsetPtr);
800 
801  if (Verbose)
802  *OS << format("0x%08.08" PRIx64 ": ", *OffsetPtr);
803 
804  uint64_t OpcodeOffset = *OffsetPtr;
805  uint8_t Opcode = TableData.getU8(Cursor);
806  size_t RowCount = Rows.size();
807 
808  if (Cursor && Verbose)
809  *OS << format("%02.02" PRIx8 " ", Opcode);
810 
811  if (Opcode == 0) {
812  // Extended Opcodes always start with a zero opcode followed by
813  // a uleb128 length so you can skip ones you don't know about
814  uint64_t Len = TableData.getULEB128(Cursor);
815  uint64_t ExtOffset = Cursor.tell();
816 
817  // Tolerate zero-length; assume length is correct and soldier on.
818  if (Len == 0) {
819  if (Cursor && Verbose)
820  *OS << "Badly formed extended line op (length 0)\n";
821  if (!Cursor) {
822  if (Verbose)
823  *OS << "\n";
824  RecoverableErrorHandler(Cursor.takeError());
825  }
826  *OffsetPtr = Cursor.tell();
827  continue;
828  }
829 
830  uint8_t SubOpcode = TableData.getU8(Cursor);
831  // OperandOffset will be the same as ExtOffset, if it was not possible to
832  // read the SubOpcode.
833  uint64_t OperandOffset = Cursor.tell();
834  if (Verbose)
835  *OS << LNExtendedString(SubOpcode);
836  switch (SubOpcode) {
837  case DW_LNE_end_sequence:
838  // Set the end_sequence register of the state machine to true and
839  // append a row to the matrix using the current values of the
840  // state-machine registers. Then reset the registers to the initial
841  // values specified above. Every statement program sequence must end
842  // with a DW_LNE_end_sequence instruction which creates a row whose
843  // address is that of the byte after the last target machine instruction
844  // of the sequence.
845  State.Row.EndSequence = true;
846  // No need to test the Cursor is valid here, since it must be to get
847  // into this code path - if it were invalid, the default case would be
848  // followed.
849  EmitRow();
850  State.resetRowAndSequence();
851  break;
852 
853  case DW_LNE_set_address:
854  // Takes a single relocatable address as an operand. The size of the
855  // operand is the size appropriate to hold an address on the target
856  // machine. Set the address register to the value given by the
857  // relocatable address. All of the other statement program opcodes
858  // that affect the address register add a delta to it. This instruction
859  // stores a relocatable value into it instead.
860  //
861  // Make sure the extractor knows the address size. If not, infer it
862  // from the size of the operand.
863  {
864  uint8_t ExtractorAddressSize = TableData.getAddressSize();
865  uint64_t OpcodeAddressSize = Len - 1;
866  if (ExtractorAddressSize != OpcodeAddressSize &&
867  ExtractorAddressSize != 0)
868  RecoverableErrorHandler(createStringError(
870  "mismatching address size at offset 0x%8.8" PRIx64
871  " expected 0x%2.2" PRIx8 " found 0x%2.2" PRIx64,
872  ExtOffset, ExtractorAddressSize, Len - 1));
873 
874  // Assume that the line table is correct and temporarily override the
875  // address size. If the size is unsupported, give up trying to read
876  // the address and continue to the next opcode.
877  if (OpcodeAddressSize != 1 && OpcodeAddressSize != 2 &&
878  OpcodeAddressSize != 4 && OpcodeAddressSize != 8) {
879  RecoverableErrorHandler(createStringError(
881  "address size 0x%2.2" PRIx64
882  " of DW_LNE_set_address opcode at offset 0x%8.8" PRIx64
883  " is unsupported",
884  OpcodeAddressSize, ExtOffset));
885  TableData.skip(Cursor, OpcodeAddressSize);
886  } else {
887  TableData.setAddressSize(OpcodeAddressSize);
888  State.Row.Address.Address = TableData.getRelocatedAddress(
889  Cursor, &State.Row.Address.SectionIndex);
890 
891  uint64_t Tombstone =
892  dwarf::computeTombstoneAddress(OpcodeAddressSize);
893  TombstonedAddress = State.Row.Address.Address == Tombstone;
894 
895  // Restore the address size if the extractor already had it.
896  if (ExtractorAddressSize != 0)
897  TableData.setAddressSize(ExtractorAddressSize);
898  }
899 
900  if (Cursor && Verbose) {
901  *OS << " (";
902  DWARFFormValue::dumpAddress(*OS, OpcodeAddressSize, State.Row.Address.Address);
903  *OS << ')';
904  }
905  }
906  break;
907 
908  case DW_LNE_define_file:
909  // Takes 4 arguments. The first is a null terminated string containing
910  // a source file name. The second is an unsigned LEB128 number
911  // representing the directory index of the directory in which the file
912  // was found. The third is an unsigned LEB128 number representing the
913  // time of last modification of the file. The fourth is an unsigned
914  // LEB128 number representing the length in bytes of the file. The time
915  // and length fields may contain LEB128(0) if the information is not
916  // available.
917  //
918  // The directory index represents an entry in the include_directories
919  // section of the statement program prologue. The index is LEB128(0)
920  // if the file was found in the current directory of the compilation,
921  // LEB128(1) if it was found in the first directory in the
922  // include_directories section, and so on. The directory index is
923  // ignored for file names that represent full path names.
924  //
925  // The files are numbered, starting at 1, in the order in which they
926  // appear; the names in the prologue come before names defined by
927  // the DW_LNE_define_file instruction. These numbers are used in the
928  // the file register of the state machine.
929  {
930  FileNameEntry FileEntry;
931  const char *Name = TableData.getCStr(Cursor);
932  FileEntry.Name =
933  DWARFFormValue::createFromPValue(dwarf::DW_FORM_string, Name);
934  FileEntry.DirIdx = TableData.getULEB128(Cursor);
935  FileEntry.ModTime = TableData.getULEB128(Cursor);
936  FileEntry.Length = TableData.getULEB128(Cursor);
937  Prologue.FileNames.push_back(FileEntry);
938  if (Cursor && Verbose)
939  *OS << " (" << Name << ", dir=" << FileEntry.DirIdx << ", mod_time="
940  << format("(0x%16.16" PRIx64 ")", FileEntry.ModTime)
941  << ", length=" << FileEntry.Length << ")";
942  }
943  break;
944 
945  case DW_LNE_set_discriminator:
946  State.Row.Discriminator = TableData.getULEB128(Cursor);
947  if (Cursor && Verbose)
948  *OS << " (" << State.Row.Discriminator << ")";
949  break;
950 
951  default:
952  if (Cursor && Verbose)
953  *OS << format("Unrecognized extended op 0x%02.02" PRIx8, SubOpcode)
954  << format(" length %" PRIx64, Len);
955  // Len doesn't include the zero opcode byte or the length itself, but
956  // it does include the sub_opcode, so we have to adjust for that.
957  TableData.skip(Cursor, Len - 1);
958  break;
959  }
960  // Make sure the length as recorded in the table and the standard length
961  // for the opcode match. If they don't, continue from the end as claimed
962  // by the table. Similarly, continue from the claimed end in the event of
963  // a parsing error.
964  uint64_t End = ExtOffset + Len;
965  if (Cursor && Cursor.tell() != End)
966  RecoverableErrorHandler(createStringError(
968  "unexpected line op length at offset 0x%8.8" PRIx64
969  " expected 0x%2.2" PRIx64 " found 0x%2.2" PRIx64,
970  ExtOffset, Len, Cursor.tell() - ExtOffset));
971  if (!Cursor && Verbose) {
972  DWARFDataExtractor::Cursor ByteCursor(OperandOffset);
973  uint8_t Byte = TableData.getU8(ByteCursor);
974  if (ByteCursor) {
975  *OS << " (<parsing error>";
976  do {
977  *OS << format(" %2.2" PRIx8, Byte);
978  Byte = TableData.getU8(ByteCursor);
979  } while (ByteCursor);
980  *OS << ")";
981  }
982 
983  // The only parse failure in this case should be if the end was reached.
984  // In that case, throw away the error, as the main Cursor's error will
985  // be sufficient.
986  consumeError(ByteCursor.takeError());
987  }
988  *OffsetPtr = End;
989  } else if (Opcode < Prologue.OpcodeBase) {
990  if (Verbose)
991  *OS << LNStandardString(Opcode);
992  switch (Opcode) {
993  // Standard Opcodes
994  case DW_LNS_copy:
995  // Takes no arguments. Append a row to the matrix using the
996  // current values of the state-machine registers.
997  EmitRow();
998  break;
999 
1000  case DW_LNS_advance_pc:
1001  // Takes a single unsigned LEB128 operand, multiplies it by the
1002  // min_inst_length field of the prologue, and adds the
1003  // result to the address register of the state machine.
1004  if (Optional<uint64_t> Operand =
1005  parseULEB128<uint64_t>(TableData, Cursor)) {
1006  uint64_t AddrOffset =
1007  State.advanceAddr(*Operand, Opcode, OpcodeOffset);
1008  if (Verbose)
1009  *OS << " (" << AddrOffset << ")";
1010  }
1011  break;
1012 
1013  case DW_LNS_advance_line:
1014  // Takes a single signed LEB128 operand and adds that value to
1015  // the line register of the state machine.
1016  {
1017  int64_t LineDelta = TableData.getSLEB128(Cursor);
1018  if (Cursor) {
1019  State.Row.Line += LineDelta;
1020  if (Verbose)
1021  *OS << " (" << State.Row.Line << ")";
1022  }
1023  }
1024  break;
1025 
1026  case DW_LNS_set_file:
1027  // Takes a single unsigned LEB128 operand and stores it in the file
1028  // register of the state machine.
1029  if (Optional<uint16_t> File =
1030  parseULEB128<uint16_t>(TableData, Cursor)) {
1031  State.Row.File = *File;
1032  if (Verbose)
1033  *OS << " (" << State.Row.File << ")";
1034  }
1035  break;
1036 
1037  case DW_LNS_set_column:
1038  // Takes a single unsigned LEB128 operand and stores it in the
1039  // column register of the state machine.
1040  if (Optional<uint16_t> Column =
1041  parseULEB128<uint16_t>(TableData, Cursor)) {
1042  State.Row.Column = *Column;
1043  if (Verbose)
1044  *OS << " (" << State.Row.Column << ")";
1045  }
1046  break;
1047 
1048  case DW_LNS_negate_stmt:
1049  // Takes no arguments. Set the is_stmt register of the state
1050  // machine to the logical negation of its current value.
1051  State.Row.IsStmt = !State.Row.IsStmt;
1052  break;
1053 
1054  case DW_LNS_set_basic_block:
1055  // Takes no arguments. Set the basic_block register of the
1056  // state machine to true
1057  State.Row.BasicBlock = true;
1058  break;
1059 
1060  case DW_LNS_const_add_pc:
1061  // Takes no arguments. Add to the address register of the state
1062  // machine the address increment value corresponding to special
1063  // opcode 255. The motivation for DW_LNS_const_add_pc is this:
1064  // when the statement program needs to advance the address by a
1065  // small amount, it can use a single special opcode, which occupies
1066  // a single byte. When it needs to advance the address by up to
1067  // twice the range of the last special opcode, it can use
1068  // DW_LNS_const_add_pc followed by a special opcode, for a total
1069  // of two bytes. Only if it needs to advance the address by more
1070  // than twice that range will it need to use both DW_LNS_advance_pc
1071  // and a special opcode, requiring three or more bytes.
1072  {
1073  uint64_t AddrOffset =
1074  State.advanceAddrForOpcode(Opcode, OpcodeOffset).AddrDelta;
1075  if (Verbose)
1076  *OS << format(" (0x%16.16" PRIx64 ")", AddrOffset);
1077  }
1078  break;
1079 
1080  case DW_LNS_fixed_advance_pc:
1081  // Takes a single uhalf operand. Add to the address register of
1082  // the state machine the value of the (unencoded) operand. This
1083  // is the only extended opcode that takes an argument that is not
1084  // a variable length number. The motivation for DW_LNS_fixed_advance_pc
1085  // is this: existing assemblers cannot emit DW_LNS_advance_pc or
1086  // special opcodes because they cannot encode LEB128 numbers or
1087  // judge when the computation of a special opcode overflows and
1088  // requires the use of DW_LNS_advance_pc. Such assemblers, however,
1089  // can use DW_LNS_fixed_advance_pc instead, sacrificing compression.
1090  {
1091  uint16_t PCOffset =
1092  TableData.getRelocatedValue(Cursor, 2);
1093  if (Cursor) {
1094  State.Row.Address.Address += PCOffset;
1095  if (Verbose)
1096  *OS << format(" (0x%4.4" PRIx16 ")", PCOffset);
1097  }
1098  }
1099  break;
1100 
1101  case DW_LNS_set_prologue_end:
1102  // Takes no arguments. Set the prologue_end register of the
1103  // state machine to true
1104  State.Row.PrologueEnd = true;
1105  break;
1106 
1107  case DW_LNS_set_epilogue_begin:
1108  // Takes no arguments. Set the basic_block register of the
1109  // state machine to true
1110  State.Row.EpilogueBegin = true;
1111  break;
1112 
1113  case DW_LNS_set_isa:
1114  // Takes a single unsigned LEB128 operand and stores it in the
1115  // ISA register of the state machine.
1116  if (Optional<uint8_t> Isa = parseULEB128<uint8_t>(TableData, Cursor)) {
1117  State.Row.Isa = *Isa;
1118  if (Verbose)
1119  *OS << " (" << (uint64_t)State.Row.Isa << ")";
1120  }
1121  break;
1122 
1123  default:
1124  // Handle any unknown standard opcodes here. We know the lengths
1125  // of such opcodes because they are specified in the prologue
1126  // as a multiple of LEB128 operands for each opcode.
1127  {
1128  assert(Opcode - 1U < Prologue.StandardOpcodeLengths.size());
1129  if (Verbose)
1130  *OS << "Unrecognized standard opcode";
1131  uint8_t OpcodeLength = Prologue.StandardOpcodeLengths[Opcode - 1];
1132  std::vector<uint64_t> Operands;
1133  for (uint8_t I = 0; I < OpcodeLength; ++I) {
1135  parseULEB128<uint64_t>(TableData, Cursor))
1136  Operands.push_back(*Value);
1137  else
1138  break;
1139  }
1140  if (Verbose && !Operands.empty()) {
1141  *OS << " (operands: ";
1142  bool First = true;
1143  for (uint64_t Value : Operands) {
1144  if (!First)
1145  *OS << ", ";
1146  First = false;
1147  *OS << format("0x%16.16" PRIx64, Value);
1148  }
1149  if (Verbose)
1150  *OS << ')';
1151  }
1152  }
1153  break;
1154  }
1155 
1156  *OffsetPtr = Cursor.tell();
1157  } else {
1158  // Special Opcodes.
1160  State.handleSpecialOpcode(Opcode, OpcodeOffset);
1161 
1162  if (Verbose)
1163  *OS << "address += " << Delta.Address << ", line += " << Delta.Line;
1164  EmitRow();
1165  *OffsetPtr = Cursor.tell();
1166  }
1167 
1168  // When a row is added to the matrix, it is also dumped, which includes a
1169  // new line already, so don't add an extra one.
1170  if (Verbose && Rows.size() == RowCount)
1171  *OS << "\n";
1172 
1173  // Most parse failures other than when parsing extended opcodes are due to
1174  // failures to read ULEBs. Bail out of parsing, since we don't know where to
1175  // continue reading from as there is no stated length for such byte
1176  // sequences. Print the final trailing new line if needed before doing so.
1177  if (!Cursor && Opcode != 0) {
1178  if (Verbose)
1179  *OS << "\n";
1180  return Cursor.takeError();
1181  }
1182 
1183  if (!Cursor)
1184  RecoverableErrorHandler(Cursor.takeError());
1185  }
1186 
1187  if (!State.Sequence.Empty)
1188  RecoverableErrorHandler(createStringError(
1190  "last sequence in debug line table at offset 0x%8.8" PRIx64
1191  " is not terminated",
1192  DebugLineOffset));
1193 
1194  // Sort all sequences so that address lookup will work faster.
1195  if (!Sequences.empty()) {
1196  llvm::sort(Sequences, Sequence::orderByHighPC);
1197  // Note: actually, instruction address ranges of sequences should not
1198  // overlap (in shared objects and executables). If they do, the address
1199  // lookup would still work, though, but result would be ambiguous.
1200  // We don't report warning in this case. For example,
1201  // sometimes .so compiled from multiple object files contains a few
1202  // rudimentary sequences for address ranges [0x0, 0xsomething).
1203  }
1204 
1205  // Terminate the table with a final blank line to clearly delineate it from
1206  // later dumps.
1207  if (OS)
1208  *OS << "\n";
1209 
1210  return Error::success();
1211 }
1212 
1213 uint32_t DWARFDebugLine::LineTable::findRowInSeq(
1214  const DWARFDebugLine::Sequence &Seq,
1215  object::SectionedAddress Address) const {
1216  if (!Seq.containsPC(Address))
1217  return UnknownRowIndex;
1218  assert(Seq.SectionIndex == Address.SectionIndex);
1219  // In some cases, e.g. first instruction in a function, the compiler generates
1220  // two entries, both with the same address. We want the last one.
1221  //
1222  // In general we want a non-empty range: the last row whose address is less
1223  // than or equal to Address. This can be computed as upper_bound - 1.
1225  Row.Address = Address;
1226  RowIter FirstRow = Rows.begin() + Seq.FirstRowIndex;
1227  RowIter LastRow = Rows.begin() + Seq.LastRowIndex;
1228  assert(FirstRow->Address.Address <= Row.Address.Address &&
1229  Row.Address.Address < LastRow[-1].Address.Address);
1230  RowIter RowPos = std::upper_bound(FirstRow + 1, LastRow - 1, Row,
1232  1;
1233  assert(Seq.SectionIndex == RowPos->Address.SectionIndex);
1234  return RowPos - Rows.begin();
1235 }
1236 
1238  object::SectionedAddress Address) const {
1239 
1240  // Search for relocatable addresses
1241  uint32_t Result = lookupAddressImpl(Address);
1242 
1243  if (Result != UnknownRowIndex ||
1245  return Result;
1246 
1247  // Search for absolute addresses
1249  return lookupAddressImpl(Address);
1250 }
1251 
1252 uint32_t DWARFDebugLine::LineTable::lookupAddressImpl(
1253  object::SectionedAddress Address) const {
1254  // First, find an instruction sequence containing the given address.
1256  Sequence.SectionIndex = Address.SectionIndex;
1257  Sequence.HighPC = Address.Address;
1258  SequenceIter It = llvm::upper_bound(Sequences, Sequence,
1260  if (It == Sequences.end() || It->SectionIndex != Address.SectionIndex)
1261  return UnknownRowIndex;
1262  return findRowInSeq(*It, Address);
1263 }
1264 
1267  std::vector<uint32_t> &Result) const {
1268 
1269  // Search for relocatable addresses
1270  if (lookupAddressRangeImpl(Address, Size, Result))
1271  return true;
1272 
1273  if (Address.SectionIndex == object::SectionedAddress::UndefSection)
1274  return false;
1275 
1276  // Search for absolute addresses
1278  return lookupAddressRangeImpl(Address, Size, Result);
1279 }
1280 
1281 bool DWARFDebugLine::LineTable::lookupAddressRangeImpl(
1283  std::vector<uint32_t> &Result) const {
1284  if (Sequences.empty())
1285  return false;
1286  uint64_t EndAddr = Address.Address + Size;
1287  // First, find an instruction sequence containing the given address.
1289  Sequence.SectionIndex = Address.SectionIndex;
1290  Sequence.HighPC = Address.Address;
1291  SequenceIter LastSeq = Sequences.end();
1292  SequenceIter SeqPos = llvm::upper_bound(
1294  if (SeqPos == LastSeq || !SeqPos->containsPC(Address))
1295  return false;
1296 
1297  SequenceIter StartPos = SeqPos;
1298 
1299  // Add the rows from the first sequence to the vector, starting with the
1300  // index we just calculated
1301 
1302  while (SeqPos != LastSeq && SeqPos->LowPC < EndAddr) {
1303  const DWARFDebugLine::Sequence &CurSeq = *SeqPos;
1304  // For the first sequence, we need to find which row in the sequence is the
1305  // first in our range.
1306  uint32_t FirstRowIndex = CurSeq.FirstRowIndex;
1307  if (SeqPos == StartPos)
1308  FirstRowIndex = findRowInSeq(CurSeq, Address);
1309 
1310  // Figure out the last row in the range.
1311  uint32_t LastRowIndex =
1312  findRowInSeq(CurSeq, {EndAddr - 1, Address.SectionIndex});
1313  if (LastRowIndex == UnknownRowIndex)
1314  LastRowIndex = CurSeq.LastRowIndex - 1;
1315 
1316  assert(FirstRowIndex != UnknownRowIndex);
1317  assert(LastRowIndex != UnknownRowIndex);
1318 
1319  for (uint32_t I = FirstRowIndex; I <= LastRowIndex; ++I) {
1320  Result.push_back(I);
1321  }
1322 
1323  ++SeqPos;
1324  }
1325 
1326  return true;
1327 }
1328 
1329 Optional<StringRef> DWARFDebugLine::LineTable::getSourceByIndex(uint64_t FileIndex,
1330  FileLineInfoKind Kind) const {
1331  if (Kind == FileLineInfoKind::None || !Prologue.hasFileAtIndex(FileIndex))
1332  return None;
1333  const FileNameEntry &Entry = Prologue.getFileNameEntry(FileIndex);
1334  if (Optional<const char *> source = Entry.Source.getAsCString())
1335  return StringRef(*source);
1336  return None;
1337 }
1338 
1339 static bool isPathAbsoluteOnWindowsOrPosix(const Twine &Path) {
1340  // Debug info can contain paths from any OS, not necessarily
1341  // an OS we're currently running on. Moreover different compilation units can
1342  // be compiled on different operating systems and linked together later.
1345 }
1346 
1348  uint64_t FileIndex, StringRef CompDir, FileLineInfoKind Kind,
1349  std::string &Result, sys::path::Style Style) const {
1350  if (Kind == FileLineInfoKind::None || !hasFileAtIndex(FileIndex))
1351  return false;
1352  const FileNameEntry &Entry = getFileNameEntry(FileIndex);
1353  Optional<const char *> Name = Entry.Name.getAsCString();
1354  if (!Name)
1355  return false;
1356  StringRef FileName = *Name;
1357  if (Kind == FileLineInfoKind::RawValue ||
1358  isPathAbsoluteOnWindowsOrPosix(FileName)) {
1359  Result = std::string(FileName);
1360  return true;
1361  }
1362  if (Kind == FileLineInfoKind::BaseNameOnly) {
1363  Result = std::string(llvm::sys::path::filename(FileName));
1364  return true;
1365  }
1366 
1367  SmallString<16> FilePath;
1368  StringRef IncludeDir;
1369  // Be defensive about the contents of Entry.
1370  if (getVersion() >= 5) {
1371  // DirIdx 0 is the compilation directory, so don't include it for
1372  // relative names.
1373  if ((Entry.DirIdx != 0 || Kind != FileLineInfoKind::RelativeFilePath) &&
1374  Entry.DirIdx < IncludeDirectories.size())
1375  IncludeDir = IncludeDirectories[Entry.DirIdx].getAsCString().getValue();
1376  } else {
1377  if (0 < Entry.DirIdx && Entry.DirIdx <= IncludeDirectories.size())
1378  IncludeDir =
1379  IncludeDirectories[Entry.DirIdx - 1].getAsCString().getValue();
1380  }
1381 
1382  // For absolute paths only, include the compilation directory of compile unit.
1383  // We know that FileName is not absolute, the only way to have an absolute
1384  // path at this point would be if IncludeDir is absolute.
1385  if (Kind == FileLineInfoKind::AbsoluteFilePath && !CompDir.empty() &&
1386  !isPathAbsoluteOnWindowsOrPosix(IncludeDir))
1387  sys::path::append(FilePath, Style, CompDir);
1388 
1389  assert((Kind == FileLineInfoKind::AbsoluteFilePath ||
1390  Kind == FileLineInfoKind::RelativeFilePath) &&
1391  "invalid FileLineInfo Kind");
1392 
1393  // sys::path::append skips empty strings.
1394  sys::path::append(FilePath, Style, IncludeDir, FileName);
1395  Result = std::string(FilePath.str());
1396  return true;
1397 }
1398 
1400  object::SectionedAddress Address, const char *CompDir,
1401  FileLineInfoKind Kind, DILineInfo &Result) const {
1402  // Get the index of row we're looking for in the line table.
1403  uint32_t RowIndex = lookupAddress(Address);
1404  if (RowIndex == -1U)
1405  return false;
1406  // Take file number and line/column from the row.
1407  const auto &Row = Rows[RowIndex];
1408  if (!getFileNameByIndex(Row.File, CompDir, Kind, Result.FileName))
1409  return false;
1410  Result.Line = Row.Line;
1411  Result.Column = Row.Column;
1412  Result.Discriminator = Row.Discriminator;
1413  Result.Source = getSourceByIndex(Row.File, Kind);
1414  return true;
1415 }
1416 
1417 // We want to supply the Unit associated with a .debug_line[.dwo] table when
1418 // we dump it, if possible, but still dump the table even if there isn't a Unit.
1419 // Therefore, collect up handles on all the Units that point into the
1420 // line-table section.
1424  for (const auto &U : Units)
1425  if (auto CUDIE = U->getUnitDIE())
1426  if (auto StmtOffset = toSectionOffset(CUDIE.find(DW_AT_stmt_list)))
1427  LineToUnit.insert(std::make_pair(*StmtOffset, &*U));
1428  return LineToUnit;
1429 }
1430 
1434  : DebugLineData(Data), Context(C) {
1435  LineToUnit = buildLineToUnitMap(Units);
1436  if (!DebugLineData.isValidOffset(Offset))
1437  Done = true;
1438 }
1439 
1441  return TotalLength != 0u;
1442 }
1443 
1445  function_ref<void(Error)> RecoverableErrorHandler,
1446  function_ref<void(Error)> UnrecoverableErrorHandler, raw_ostream *OS,
1447  bool Verbose) {
1448  assert(DebugLineData.isValidOffset(Offset) &&
1449  "parsing should have terminated");
1450  DWARFUnit *U = prepareToParse(Offset);
1451  uint64_t OldOffset = Offset;
1452  LineTable LT;
1453  if (Error Err = LT.parse(DebugLineData, &Offset, Context, U,
1454  RecoverableErrorHandler, OS, Verbose))
1455  UnrecoverableErrorHandler(std::move(Err));
1456  moveToNextTable(OldOffset, LT.Prologue);
1457  return LT;
1458 }
1459 
1461  function_ref<void(Error)> RecoverableErrorHandler,
1462  function_ref<void(Error)> UnrecoverableErrorHandler) {
1463  assert(DebugLineData.isValidOffset(Offset) &&
1464  "parsing should have terminated");
1465  DWARFUnit *U = prepareToParse(Offset);
1466  uint64_t OldOffset = Offset;
1467  LineTable LT;
1468  if (Error Err = LT.Prologue.parse(DebugLineData, &Offset,
1469  RecoverableErrorHandler, Context, U))
1470  UnrecoverableErrorHandler(std::move(Err));
1471  moveToNextTable(OldOffset, LT.Prologue);
1472 }
1473 
1474 DWARFUnit *DWARFDebugLine::SectionParser::prepareToParse(uint64_t Offset) {
1475  DWARFUnit *U = nullptr;
1476  auto It = LineToUnit.find(Offset);
1477  if (It != LineToUnit.end())
1478  U = It->second;
1479  DebugLineData.setAddressSize(U ? U->getAddressByteSize() : 0);
1480  return U;
1481 }
1482 
1483 void DWARFDebugLine::SectionParser::moveToNextTable(uint64_t OldOffset,
1484  const Prologue &P) {
1485  // If the length field is not valid, we don't know where the next table is, so
1486  // cannot continue to parse. Mark the parser as done, and leave the Offset
1487  // value as it currently is. This will be the end of the bad length field.
1488  if (!P.totalLengthIsValid()) {
1489  Done = true;
1490  return;
1491  }
1492 
1493  Offset = OldOffset + P.TotalLength + P.sizeofTotalLength();
1494  if (!DebugLineData.isValidOffset(Offset)) {
1495  Done = true;
1496  }
1497 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
DWARFFormValue.h
llvm::errc::invalid_argument
@ invalid_argument
llvm::dwarf::LineNumberEntryFormat
LineNumberEntryFormat
Definition: Dwarf.h:372
llvm::DWARFDebugLine::Prologue::sizeofTotalLength
uint32_t sizeofTotalLength() const
Definition: DWARFDebugLine.h:104
isPathAbsoluteOnWindowsOrPosix
static bool isPathAbsoluteOnWindowsOrPosix(const Twine &Path)
Definition: DWARFDebugLine.cpp:1339
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
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:1674
llvm::objcarc::Sequence
Sequence
Definition: PtrState.h:41
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
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
T
llvm::DWARFDebugLine::Prologue::getAddressSize
uint8_t getAddressSize() const
Definition: DWARFDebugLine.h:101
llvm::DWARFDebugLine::Sequence::LastRowIndex
unsigned LastRowIndex
Definition: DWARFDebugLine.h:209
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:1168
llvm::dwarf::Form
Form
Definition: Dwarf.h:131
llvm::sys::path::is_absolute
bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
Definition: Path.cpp:667
llvm::object::SectionedAddress::Address
uint64_t Address
Definition: ObjectFile.h:147
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:331
DWARFDebugLine.h
llvm::DWARFDebugLine::Row::dump
void dump(raw_ostream &OS) const
Definition: DWARFDebugLine.cpp:494
llvm::DWARFDebugLine::Row::orderByAddress
static bool orderByAddress(const Row &LHS, const Row &RHS)
Definition: DWARFDebugLine.h:146
Errc.h
llvm::DWARFContext
DWARFContext This data structure is the top level entity that deals with dwarf debug information pars...
Definition: DWARFContext.h:53
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:390
llvm::dwarf::FormParams::AddrSize
uint8_t AddrSize
Definition: Dwarf.h:650
DWARFRelocMap.h
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:68
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::DWARFDebugLine::ContentTypeTracker::HasModTime
bool HasModTime
Whether filename entries provide a modification timestamp.
Definition: DWARFDebugLine.h:51
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::DWARFDebugLine::ContentTypeTracker::HasLength
bool HasLength
Whether filename entries provide a file size.
Definition: DWARFDebugLine.h:53
llvm::DWARFDataExtractor
A DataExtractor (typically for an in-memory copy of an object-file section) plus a relocation map for...
Definition: DWARFDataExtractor.h:21
llvm::DWARFDebugLine::LineTable::getFileLineInfoForAddress
bool getFileLineInfoForAddress(object::SectionedAddress Address, const char *CompDir, DILineInfoSpecifier::FileLineInfoKind Kind, DILineInfo &Result) const
Fills the Result argument with the file and line information corresponding to Address.
Definition: DWARFDebugLine.cpp:1399
Format.h
llvm::dwarf::FormParams::Format
DwarfFormat Format
Definition: Dwarf.h:651
llvm::DataExtractor::skip
void skip(Cursor &C, uint64_t Length) const
Advance the Cursor position by the given number of bytes.
Definition: DataExtractor.cpp:229
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1035
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:88
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
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:454
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:390
clear
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:234
llvm::DWARFDebugLine::ParsingState::AddrAndLineDelta
Definition: DWARFDebugLine.h:388
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:221
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:250
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:207
llvm::dwarf::LNExtendedString
StringRef LNExtendedString(unsigned Encoding)
Definition: Dwarf.cpp:446
llvm::DWARFDebugLine::Row
Standard .debug_line state machine structure.
Definition: DWARFDebugLine.h:136
llvm::DIDumpOptions::Verbose
bool Verbose
Definition: DIContext.h:191
llvm::DWARFDataExtractor::getRelocatedValue
uint64_t getRelocatedValue(uint32_t Size, uint64_t *Off, uint64_t *SectionIndex=nullptr, Error *Err=nullptr) const
Extracts a value and applies a relocation to the result if one exists for the given offset.
Definition: DWARFDataExtractor.cpp:46
SmallString.h
llvm::dwarf::computeTombstoneAddress
uint64_t computeTombstoneAddress(uint8_t AddressByteSize)
Definition: Dwarf.h:772
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:724
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:405
llvm::DWARFDebugLine::Prologue::OpcodeBase
uint8_t OpcodeBase
The number assigned to the first special opcode.
Definition: DWARFDebugLine.h:92
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::MD5::MD5Result::Bytes
std::array< uint8_t, 16 > Bytes
Definition: MD5.h:44
llvm::dwarf::Index
Index
Definition: Dwarf.h:467
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:1347
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:600
llvm::dwarf::FormatString
StringRef FormatString(DwarfFormat Format)
Definition: Dwarf.cpp:790
llvm::dwarf::toSectionOffset
Optional< uint64_t > toSectionOffset(const Optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract an section offset.
Definition: DWARFFormValue.h:303
llvm::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:26
llvm::DWARFDebugLine::SectionParser::parseNext
LineTable parseNext(function_ref< void(Error)> RecoverableErrorHandler, function_ref< void(Error)> UnrecoverableErrorHandler, raw_ostream *OS=nullptr, bool Verbose=false)
Get the next line table from the section.
Definition: DWARFDebugLine.cpp:1444
llvm::DWARFDebugLine::Prologue::totalLengthIsValid
bool totalLengthIsValid() const
Definition: DWARFDebugLine.cpp:1440
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:991
llvm::sys::path::Style
Style
Definition: Path.h:28
llvm::DWARFDebugLine::FileNameEntry::Length
uint64_t Length
Definition: DWARFDebugLine.h:40
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:23
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:1265
llvm::SmallString< 16 >
versionIsSupported
static bool versionIsSupported(uint16_t Version)
Definition: DWARFDebugLine.cpp:45
Operands
mir Rename Register Operands
Definition: MIRNamerPass.cpp:78
parseULEB128
static Optional< T > parseULEB128(DWARFDataExtractor &Data, DataExtractor::Cursor &Cursor)
Parse a ULEB128 using the specified Cursor.
Definition: DWARFDebugLine.cpp:716
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:168
llvm::errc::illegal_byte_sequence
@ illegal_byte_sequence
llvm::DWARFDebugLine::Sequence::HighPC
uint64_t HighPC
Definition: DWARFDebugLine.h:203
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:214
llvm::DWARFDebugLine::Sequence
Represents a series of contiguous machine instructions.
Definition: DWARFDebugLine.h:197
llvm::DWARFDebugLine::Prologue
Definition: DWARFDebugLine.h:63
llvm::DWARFDebugLine::ParsingState::AddrAndAdjustedOpcode::AddrDelta
uint64_t AddrDelta
Definition: DWARFDebugLine.h:379
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:378
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:59
llvm::DILineInfo
A format-neutral container for source line information.
Definition: DIContext.h:31
llvm::DILineInfoSpecifier::FileLineInfoKind
FileLineInfoKind
Definition: DIContext.h:136
llvm::joinErrors
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:428
llvm::DWARFDebugLine::FileNameEntry::DirIdx
uint64_t DirIdx
Definition: DWARFDebugLine.h:38
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:648
llvm::HighlightColor::Address
@ Address
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:1237
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:15
llvm::DWARFDebugLine::Sequence::FirstRowIndex
unsigned FirstRowIndex
Definition: DWARFDebugLine.h:208
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:380
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:170
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:175
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::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:34
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:1422
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:47
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:80
WithColor.h
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:286
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1231
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
uint16_t
llvm::DWARFUnit
Definition: DWARFUnit.h:203
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:157
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:160
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1492
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:156
llvm::DWARFDebugLine::FileNameEntry::Checksum
MD5::MD5Result Checksum
Definition: DWARFDebugLine.h:41
llvm::DataExtractor::getCStrRef
StringRef getCStrRef(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a C string from *offset_ptr.
Definition: DataExtractor.cpp:156
llvm::SmallString::str
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:259
llvm::dwarf::LNStandardString
StringRef LNStandardString(unsigned Standard)
Definition: Dwarf.cpp:435
llvm::DWARFDebugLine::Sequence::containsPC
bool containsPC(object::SectionedAddress PC) const
Definition: DWARFDebugLine.h:223
llvm::DWARFDebugLine::Row::Column
uint16_t Column
An unsigned integer indicating a column number within a source line.
Definition: DWARFDebugLine.h:164
llvm::dwarf::FormParams::Version
uint16_t Version
Definition: Dwarf.h:649
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:589
llvm::DWARFDebugLine::Prologue::FileNames
std::vector< FileNameEntry > FileNames
Definition: DWARFDebugLine.h:97
llvm::DWARFDebugLine::ParsingState::AddrAndLineDelta::Address
uint64_t Address
Definition: DWARFDebugLine.h:389
llvm::DWARFDebugLine::Prologue::clear
void clear()
Definition: DWARFDebugLine.cpp:105
llvm::DWARFDebugLine::FileNameEntry::Source
DWARFFormValue Source
Definition: DWARFDebugLine.h:42
llvm::sys::path::filename
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:573
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:497
llvm::DWARFDebugLine::SectionParser::skip
void skip(function_ref< void(Error)> RecoverableErrorHandler, function_ref< void(Error)> UnrecoverableErrorHandler)
Skip the current line table and go to the following line table (if present) immediately.
Definition: DWARFDebugLine.cpp:1460
llvm::DWARFDebugLine::Prologue::StandardOpcodeLengths
std::vector< uint8_t > StandardOpcodeLengths
Definition: DWARFDebugLine.h:95
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:229
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:1431
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:167
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:359
llvm::DWARFDebugLine::SectionParser::LineToUnitMap
std::map< uint64_t, DWARFUnit * > LineToUnitMap
Definition: DWARFDebugLine.h:314
llvm::DWARFDebugLine::FileNameEntry::Name
DWARFFormValue Name
Definition: DWARFDebugLine.h:37
llvm::DWARFDebugLine::FileNameEntry::ModTime
uint64_t ModTime
Definition: DWARFDebugLine.h:39
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:635
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:75
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:205
llvm::dwarf::DWARF32
@ DWARF32
Definition: Dwarf.h:92
llvm::DWARFDebugLine::Prologue::dump
void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const
Definition: DWARFDebugLine.cpp:117
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:93
llvm::MD5::MD5Result::digest
SmallString< 32 > digest() const
Definition: MD5.cpp:282
llvm::DIDumpOptions
Container for dump options that control which debug information will be dumped.
Definition: DIContext.h:180
llvm::DataExtractor::getSLEB128
int64_t getSLEB128(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a signed LEB128 value from *offset_ptr.
Definition: DataExtractor.cpp:225