LLVM  10.0.0svn
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"
19 #include "llvm/Support/WithColor.h"
21 #include <algorithm>
22 #include <cassert>
23 #include <cinttypes>
24 #include <cstdint>
25 #include <cstdio>
26 #include <utility>
27 
28 using namespace llvm;
29 using namespace dwarf;
30 
32 
33 namespace {
34 
35 struct ContentDescriptor {
38 };
39 
40 using ContentDescriptors = SmallVector<ContentDescriptor, 4>;
41 
42 } // end anonmyous namespace
43 
45  dwarf::LineNumberEntryFormat ContentType) {
46  switch (ContentType) {
47  case dwarf::DW_LNCT_timestamp:
48  HasModTime = true;
49  break;
50  case dwarf::DW_LNCT_size:
51  HasLength = true;
52  break;
53  case dwarf::DW_LNCT_MD5:
54  HasMD5 = true;
55  break;
56  case dwarf::DW_LNCT_LLVM_source:
57  HasSource = true;
58  break;
59  default:
60  // We only care about values we consider optional, and new values may be
61  // added in the vendor extension range, so we do not match exhaustively.
62  break;
63  }
64 }
65 
67 
68 bool DWARFDebugLine::Prologue::hasFileAtIndex(uint64_t FileIndex) const {
69  uint16_t DwarfVersion = getVersion();
70  assert(DwarfVersion != 0 &&
71  "line table prologue has no dwarf version information");
72  if (DwarfVersion >= 5)
73  return FileIndex < FileNames.size();
74  return FileIndex != 0 && FileIndex <= FileNames.size();
75 }
76 
79  uint16_t DwarfVersion = getVersion();
80  assert(DwarfVersion != 0 &&
81  "line table prologue has no dwarf version information");
82  // In DWARF v5 the file names are 0-indexed.
83  if (DwarfVersion >= 5)
84  return FileNames[Index];
85  return FileNames[Index - 1];
86 }
87 
89  TotalLength = PrologueLength = 0;
90  SegSelectorSize = 0;
91  MinInstLength = MaxOpsPerInst = DefaultIsStmt = LineBase = LineRange = 0;
92  OpcodeBase = 0;
94  ContentTypes = ContentTypeTracker();
95  StandardOpcodeLengths.clear();
96  IncludeDirectories.clear();
97  FileNames.clear();
98 }
99 
101  DIDumpOptions DumpOptions) const {
102  OS << "Line table prologue:\n"
103  << format(" total_length: 0x%8.8" PRIx64 "\n", TotalLength)
104  << format(" version: %u\n", getVersion());
105  if (getVersion() >= 5)
106  OS << format(" address_size: %u\n", getAddressSize())
107  << format(" seg_select_size: %u\n", SegSelectorSize);
108  OS << format(" prologue_length: 0x%8.8" PRIx64 "\n", PrologueLength)
109  << format(" min_inst_length: %u\n", MinInstLength)
110  << format(getVersion() >= 4 ? "max_ops_per_inst: %u\n" : "", MaxOpsPerInst)
111  << format(" default_is_stmt: %u\n", DefaultIsStmt)
112  << format(" line_base: %i\n", LineBase)
113  << format(" line_range: %u\n", LineRange)
114  << format(" opcode_base: %u\n", OpcodeBase);
115 
116  for (uint32_t I = 0; I != StandardOpcodeLengths.size(); ++I)
117  OS << format("standard_opcode_lengths[%s] = %u\n",
118  LNStandardString(I + 1).data(), StandardOpcodeLengths[I]);
119 
120  if (!IncludeDirectories.empty()) {
121  // DWARF v5 starts directory indexes at 0.
122  uint32_t DirBase = getVersion() >= 5 ? 0 : 1;
123  for (uint32_t I = 0; I != IncludeDirectories.size(); ++I) {
124  OS << format("include_directories[%3u] = ", I + DirBase);
125  IncludeDirectories[I].dump(OS, DumpOptions);
126  OS << '\n';
127  }
128  }
129 
130  if (!FileNames.empty()) {
131  // DWARF v5 starts file indexes at 0.
132  uint32_t FileBase = getVersion() >= 5 ? 0 : 1;
133  for (uint32_t I = 0; I != FileNames.size(); ++I) {
134  const FileNameEntry &FileEntry = FileNames[I];
135  OS << format("file_names[%3u]:\n", I + FileBase);
136  OS << " name: ";
137  FileEntry.Name.dump(OS, DumpOptions);
138  OS << '\n'
139  << format(" dir_index: %" PRIu64 "\n", FileEntry.DirIdx);
140  if (ContentTypes.HasMD5)
141  OS << " md5_checksum: " << FileEntry.Checksum.digest() << '\n';
142  if (ContentTypes.HasModTime)
143  OS << format(" mod_time: 0x%8.8" PRIx64 "\n", FileEntry.ModTime);
144  if (ContentTypes.HasLength)
145  OS << format(" length: 0x%8.8" PRIx64 "\n", FileEntry.Length);
146  if (ContentTypes.HasSource) {
147  OS << " source: ";
148  FileEntry.Source.dump(OS, DumpOptions);
149  OS << '\n';
150  }
151  }
152  }
153 }
154 
155 // Parse v2-v4 directory and file tables.
156 static void
158  uint64_t *OffsetPtr, uint64_t EndPrologueOffset,
160  std::vector<DWARFFormValue> &IncludeDirectories,
161  std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
162  while (*OffsetPtr < EndPrologueOffset) {
163  StringRef S = DebugLineData.getCStrRef(OffsetPtr);
164  if (S.empty())
165  break;
166  DWARFFormValue Dir =
167  DWARFFormValue::createFromPValue(dwarf::DW_FORM_string, S.data());
168  IncludeDirectories.push_back(Dir);
169  }
170 
171  while (*OffsetPtr < EndPrologueOffset) {
172  StringRef Name = DebugLineData.getCStrRef(OffsetPtr);
173  if (Name.empty())
174  break;
176  FileEntry.Name =
177  DWARFFormValue::createFromPValue(dwarf::DW_FORM_string, Name.data());
178  FileEntry.DirIdx = DebugLineData.getULEB128(OffsetPtr);
179  FileEntry.ModTime = DebugLineData.getULEB128(OffsetPtr);
180  FileEntry.Length = DebugLineData.getULEB128(OffsetPtr);
181  FileNames.push_back(FileEntry);
182  }
183 
184  ContentTypes.HasModTime = true;
185  ContentTypes.HasLength = true;
186 }
187 
188 // Parse v5 directory/file entry content descriptions.
189 // Returns the descriptors, or an error if we did not find a path or ran off
190 // the end of the prologue.
192 parseV5EntryFormat(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
193  uint64_t EndPrologueOffset,
194  DWARFDebugLine::ContentTypeTracker *ContentTypes) {
195  ContentDescriptors Descriptors;
196  int FormatCount = DebugLineData.getU8(OffsetPtr);
197  bool HasPath = false;
198  for (int I = 0; I != FormatCount; ++I) {
199  if (*OffsetPtr >= EndPrologueOffset)
200  return createStringError(
202  "failed to parse entry content descriptions at offset "
203  "0x%8.8" PRIx64
204  " because offset extends beyond the prologue end at offset "
205  "0x%8.8" PRIx64,
206  *OffsetPtr, EndPrologueOffset);
207  ContentDescriptor Descriptor;
208  Descriptor.Type =
209  dwarf::LineNumberEntryFormat(DebugLineData.getULEB128(OffsetPtr));
210  Descriptor.Form = dwarf::Form(DebugLineData.getULEB128(OffsetPtr));
211  if (Descriptor.Type == dwarf::DW_LNCT_path)
212  HasPath = true;
213  if (ContentTypes)
214  ContentTypes->trackContentType(Descriptor.Type);
215  Descriptors.push_back(Descriptor);
216  }
217 
218  if (!HasPath)
220  "failed to parse entry content descriptions"
221  " because no path was found");
222  return Descriptors;
223 }
224 
225 static Error
227  uint64_t *OffsetPtr, uint64_t EndPrologueOffset,
229  const DWARFContext &Ctx, const DWARFUnit *U,
231  std::vector<DWARFFormValue> &IncludeDirectories,
232  std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
233  // Get the directory entry description.
234  llvm::Expected<ContentDescriptors> DirDescriptors =
235  parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset, nullptr);
236  if (!DirDescriptors)
237  return DirDescriptors.takeError();
238 
239  // Get the directory entries, according to the format described above.
240  int DirEntryCount = DebugLineData.getU8(OffsetPtr);
241  for (int I = 0; I != DirEntryCount; ++I) {
242  if (*OffsetPtr >= EndPrologueOffset)
243  return createStringError(
245  "failed to parse directory entry at offset "
246  "0x%8.8" PRIx64
247  " because offset extends beyond the prologue end at offset "
248  "0x%8.8" PRIx64,
249  *OffsetPtr, EndPrologueOffset);
250  for (auto Descriptor : *DirDescriptors) {
251  DWARFFormValue Value(Descriptor.Form);
252  switch (Descriptor.Type) {
253  case DW_LNCT_path:
254  if (!Value.extractValue(DebugLineData, OffsetPtr, FormParams, &Ctx, U))
256  "failed to parse directory entry because "
257  "extracting the form value failed.");
258  IncludeDirectories.push_back(Value);
259  break;
260  default:
261  if (!Value.skipValue(DebugLineData, OffsetPtr, FormParams))
263  "failed to parse directory entry because "
264  "skipping the form value failed.");
265  }
266  }
267  }
268 
269  // Get the file entry description.
271  DebugLineData, OffsetPtr, EndPrologueOffset, &ContentTypes);
272  if (!FileDescriptors)
273  return FileDescriptors.takeError();
274 
275  // Get the file entries, according to the format described above.
276  int FileEntryCount = DebugLineData.getU8(OffsetPtr);
277  for (int I = 0; I != FileEntryCount; ++I) {
278  if (*OffsetPtr >= EndPrologueOffset)
279  return createStringError(
281  "failed to parse file entry at offset "
282  "0x%8.8" PRIx64
283  " because offset extends beyond the prologue end at offset "
284  "0x%8.8" PRIx64,
285  *OffsetPtr, EndPrologueOffset);
287  for (auto Descriptor : *FileDescriptors) {
288  DWARFFormValue Value(Descriptor.Form);
289  if (!Value.extractValue(DebugLineData, OffsetPtr, FormParams, &Ctx, U))
291  "failed to parse file entry because "
292  "extracting the form value failed.");
293  switch (Descriptor.Type) {
294  case DW_LNCT_path:
295  FileEntry.Name = Value;
296  break;
297  case DW_LNCT_LLVM_source:
298  FileEntry.Source = Value;
299  break;
300  case DW_LNCT_directory_index:
301  FileEntry.DirIdx = Value.getAsUnsignedConstant().getValue();
302  break;
303  case DW_LNCT_timestamp:
304  FileEntry.ModTime = Value.getAsUnsignedConstant().getValue();
305  break;
306  case DW_LNCT_size:
307  FileEntry.Length = Value.getAsUnsignedConstant().getValue();
308  break;
309  case DW_LNCT_MD5:
310  if (!Value.getAsBlock() || Value.getAsBlock().getValue().size() != 16)
311  return createStringError(
313  "failed to parse file entry because the MD5 hash is invalid");
314  std::uninitialized_copy_n(Value.getAsBlock().getValue().begin(), 16,
315  FileEntry.Checksum.Bytes.begin());
316  break;
317  default:
318  break;
319  }
320  }
321  FileNames.push_back(FileEntry);
322  }
323  return Error::success();
324 }
325 
327  uint64_t *OffsetPtr,
328  const DWARFContext &Ctx,
329  const DWARFUnit *U) {
330  const uint64_t PrologueOffset = *OffsetPtr;
331 
332  clear();
333  TotalLength = DebugLineData.getRelocatedValue(4, OffsetPtr);
334  if (TotalLength == dwarf::DW_LENGTH_DWARF64) {
336  TotalLength = DebugLineData.getU64(OffsetPtr);
337  } else if (TotalLength >= dwarf::DW_LENGTH_lo_reserved) {
339  "parsing line table prologue at offset 0x%8.8" PRIx64
340  " unsupported reserved unit length found of value 0x%8.8" PRIx64,
341  PrologueOffset, TotalLength);
342  }
343  FormParams.Version = DebugLineData.getU16(OffsetPtr);
344  if (getVersion() < 2)
346  "parsing line table prologue at offset 0x%8.8" PRIx64
347  " found unsupported version 0x%2.2" PRIx16,
348  PrologueOffset, getVersion());
349 
350  if (getVersion() >= 5) {
351  FormParams.AddrSize = DebugLineData.getU8(OffsetPtr);
352  assert((DebugLineData.getAddressSize() == 0 ||
353  DebugLineData.getAddressSize() == getAddressSize()) &&
354  "Line table header and data extractor disagree");
355  SegSelectorSize = DebugLineData.getU8(OffsetPtr);
356  }
357 
358  PrologueLength =
359  DebugLineData.getRelocatedValue(sizeofPrologueLength(), OffsetPtr);
360  const uint64_t EndPrologueOffset = PrologueLength + *OffsetPtr;
361  MinInstLength = DebugLineData.getU8(OffsetPtr);
362  if (getVersion() >= 4)
363  MaxOpsPerInst = DebugLineData.getU8(OffsetPtr);
364  DefaultIsStmt = DebugLineData.getU8(OffsetPtr);
365  LineBase = DebugLineData.getU8(OffsetPtr);
366  LineRange = DebugLineData.getU8(OffsetPtr);
367  OpcodeBase = DebugLineData.getU8(OffsetPtr);
368 
369  StandardOpcodeLengths.reserve(OpcodeBase - 1);
370  for (uint32_t I = 1; I < OpcodeBase; ++I) {
371  uint8_t OpLen = DebugLineData.getU8(OffsetPtr);
372  StandardOpcodeLengths.push_back(OpLen);
373  }
374 
375  if (getVersion() >= 5) {
376  if (Error e = parseV5DirFileTables(
377  DebugLineData, OffsetPtr, EndPrologueOffset, FormParams, Ctx, U,
378  ContentTypes, IncludeDirectories, FileNames)) {
379  return joinErrors(
382  "parsing line table prologue at 0x%8.8" PRIx64
383  " found an invalid directory or file table description at"
384  " 0x%8.8" PRIx64,
385  PrologueOffset, *OffsetPtr),
386  std::move(e));
387  }
388  } else
389  parseV2DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset,
390  ContentTypes, IncludeDirectories, FileNames);
391 
392  if (*OffsetPtr != EndPrologueOffset)
394  "parsing line table prologue at 0x%8.8" PRIx64
395  " should have ended at 0x%8.8" PRIx64
396  " but it ended at 0x%8.8" PRIx64,
397  PrologueOffset, EndPrologueOffset, *OffsetPtr);
398  return Error::success();
399 }
400 
401 DWARFDebugLine::Row::Row(bool DefaultIsStmt) { reset(DefaultIsStmt); }
402 
404  Discriminator = 0;
405  BasicBlock = false;
406  PrologueEnd = false;
407  EpilogueBegin = false;
408 }
409 
410 void DWARFDebugLine::Row::reset(bool DefaultIsStmt) {
411  Address.Address = 0;
413  Line = 1;
414  Column = 0;
415  File = 1;
416  Isa = 0;
417  Discriminator = 0;
418  IsStmt = DefaultIsStmt;
419  BasicBlock = false;
420  EndSequence = false;
421  PrologueEnd = false;
422  EpilogueBegin = false;
423 }
424 
426  OS << "Address Line Column File ISA Discriminator Flags\n"
427  << "------------------ ------ ------ ------ --- ------------- "
428  "-------------\n";
429 }
430 
432  OS << format("0x%16.16" PRIx64 " %6u %6u", Address.Address, Line, Column)
433  << format(" %6u %3u %13u ", File, Isa, Discriminator)
434  << (IsStmt ? " is_stmt" : "") << (BasicBlock ? " basic_block" : "")
435  << (PrologueEnd ? " prologue_end" : "")
436  << (EpilogueBegin ? " epilogue_begin" : "")
437  << (EndSequence ? " end_sequence" : "") << '\n';
438 }
439 
441 
443  LowPC = 0;
444  HighPC = 0;
446  FirstRowIndex = 0;
447  LastRowIndex = 0;
448  Empty = true;
449 }
450 
452 
454  DIDumpOptions DumpOptions) const {
455  Prologue.dump(OS, DumpOptions);
456  OS << '\n';
457 
458  if (!Rows.empty()) {
459  Row::dumpTableHeader(OS);
460  for (const Row &R : Rows) {
461  R.dump(OS);
462  }
463  }
464 }
465 
467  Prologue.clear();
468  Rows.clear();
469  Sequences.clear();
470 }
471 
472 DWARFDebugLine::ParsingState::ParsingState(struct LineTable *LT)
473  : LineTable(LT) {
474  resetRowAndSequence();
475 }
476 
477 void DWARFDebugLine::ParsingState::resetRowAndSequence() {
479  Sequence.reset();
480 }
481 
482 void DWARFDebugLine::ParsingState::appendRowToMatrix() {
483  unsigned RowNumber = LineTable->Rows.size();
484  if (Sequence.Empty) {
485  // Record the beginning of instruction sequence.
486  Sequence.Empty = false;
488  Sequence.FirstRowIndex = RowNumber;
489  }
491  if (Row.EndSequence) {
492  // Record the end of instruction sequence.
494  Sequence.LastRowIndex = RowNumber + 1;
496  if (Sequence.isValid())
498  Sequence.reset();
499  }
500  Row.postAppend();
501 }
502 
505  LineTableConstIter Pos = LineTableMap.find(Offset);
506  if (Pos != LineTableMap.end())
507  return &Pos->second;
508  return nullptr;
509 }
510 
512  DWARFDataExtractor &DebugLineData, uint64_t Offset, const DWARFContext &Ctx,
513  const DWARFUnit *U, std::function<void(Error)> RecoverableErrorCallback) {
514  if (!DebugLineData.isValidOffset(Offset))
515  return createStringError(errc::invalid_argument, "offset 0x%8.8" PRIx64
516  " is not a valid debug line section offset",
517  Offset);
518 
519  std::pair<LineTableIter, bool> Pos =
520  LineTableMap.insert(LineTableMapTy::value_type(Offset, LineTable()));
521  LineTable *LT = &Pos.first->second;
522  if (Pos.second) {
523  if (Error Err =
524  LT->parse(DebugLineData, &Offset, Ctx, U, RecoverableErrorCallback))
525  return std::move(Err);
526  return LT;
527  }
528  return LT;
529 }
530 
532  DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
533  const DWARFContext &Ctx, const DWARFUnit *U,
534  std::function<void(Error)> RecoverableErrorCallback, raw_ostream *OS) {
535  const uint64_t DebugLineOffset = *OffsetPtr;
536 
537  clear();
538 
539  Error PrologueErr = Prologue.parse(DebugLineData, OffsetPtr, Ctx, U);
540 
541  if (OS) {
542  // The presence of OS signals verbose dumping.
543  DIDumpOptions DumpOptions;
544  DumpOptions.Verbose = true;
545  Prologue.dump(*OS, DumpOptions);
546  }
547 
548  if (PrologueErr)
549  return PrologueErr;
550 
551  const uint64_t EndOffset =
552  DebugLineOffset + Prologue.TotalLength + Prologue.sizeofTotalLength();
553 
554  // See if we should tell the data extractor the address size.
555  if (DebugLineData.getAddressSize() == 0)
556  DebugLineData.setAddressSize(Prologue.getAddressSize());
557  else
558  assert(Prologue.getAddressSize() == 0 ||
559  Prologue.getAddressSize() == DebugLineData.getAddressSize());
560 
561  ParsingState State(this);
562 
563  while (*OffsetPtr < EndOffset) {
564  if (OS)
565  *OS << format("0x%08.08" PRIx64 ": ", *OffsetPtr);
566 
567  uint8_t Opcode = DebugLineData.getU8(OffsetPtr);
568 
569  if (OS)
570  *OS << format("%02.02" PRIx8 " ", Opcode);
571 
572  if (Opcode == 0) {
573  // Extended Opcodes always start with a zero opcode followed by
574  // a uleb128 length so you can skip ones you don't know about
575  uint64_t Len = DebugLineData.getULEB128(OffsetPtr);
576  uint64_t ExtOffset = *OffsetPtr;
577 
578  // Tolerate zero-length; assume length is correct and soldier on.
579  if (Len == 0) {
580  if (OS)
581  *OS << "Badly formed extended line op (length 0)\n";
582  continue;
583  }
584 
585  uint8_t SubOpcode = DebugLineData.getU8(OffsetPtr);
586  if (OS)
587  *OS << LNExtendedString(SubOpcode);
588  switch (SubOpcode) {
589  case DW_LNE_end_sequence:
590  // Set the end_sequence register of the state machine to true and
591  // append a row to the matrix using the current values of the
592  // state-machine registers. Then reset the registers to the initial
593  // values specified above. Every statement program sequence must end
594  // with a DW_LNE_end_sequence instruction which creates a row whose
595  // address is that of the byte after the last target machine instruction
596  // of the sequence.
597  State.Row.EndSequence = true;
598  State.appendRowToMatrix();
599  if (OS) {
600  *OS << "\n";
601  OS->indent(12);
602  State.Row.dump(*OS);
603  }
604  State.resetRowAndSequence();
605  break;
606 
607  case DW_LNE_set_address:
608  // Takes a single relocatable address as an operand. The size of the
609  // operand is the size appropriate to hold an address on the target
610  // machine. Set the address register to the value given by the
611  // relocatable address. All of the other statement program opcodes
612  // that affect the address register add a delta to it. This instruction
613  // stores a relocatable value into it instead.
614  //
615  // Make sure the extractor knows the address size. If not, infer it
616  // from the size of the operand.
617  if (DebugLineData.getAddressSize() == 0)
618  DebugLineData.setAddressSize(Len - 1);
619  else if (DebugLineData.getAddressSize() != Len - 1) {
621  "mismatching address size at offset 0x%8.8" PRIx64
622  " expected 0x%2.2" PRIx8 " found 0x%2.2" PRIx64,
623  ExtOffset, DebugLineData.getAddressSize(),
624  Len - 1);
625  }
626  State.Row.Address.Address = DebugLineData.getRelocatedAddress(
627  OffsetPtr, &State.Row.Address.SectionIndex);
628  if (OS)
629  *OS << format(" (0x%16.16" PRIx64 ")", State.Row.Address.Address);
630  break;
631 
632  case DW_LNE_define_file:
633  // Takes 4 arguments. The first is a null terminated string containing
634  // a source file name. The second is an unsigned LEB128 number
635  // representing the directory index of the directory in which the file
636  // was found. The third is an unsigned LEB128 number representing the
637  // time of last modification of the file. The fourth is an unsigned
638  // LEB128 number representing the length in bytes of the file. The time
639  // and length fields may contain LEB128(0) if the information is not
640  // available.
641  //
642  // The directory index represents an entry in the include_directories
643  // section of the statement program prologue. The index is LEB128(0)
644  // if the file was found in the current directory of the compilation,
645  // LEB128(1) if it was found in the first directory in the
646  // include_directories section, and so on. The directory index is
647  // ignored for file names that represent full path names.
648  //
649  // The files are numbered, starting at 1, in the order in which they
650  // appear; the names in the prologue come before names defined by
651  // the DW_LNE_define_file instruction. These numbers are used in the
652  // the file register of the state machine.
653  {
654  FileNameEntry FileEntry;
655  const char *Name = DebugLineData.getCStr(OffsetPtr);
656  FileEntry.Name =
657  DWARFFormValue::createFromPValue(dwarf::DW_FORM_string, Name);
658  FileEntry.DirIdx = DebugLineData.getULEB128(OffsetPtr);
659  FileEntry.ModTime = DebugLineData.getULEB128(OffsetPtr);
660  FileEntry.Length = DebugLineData.getULEB128(OffsetPtr);
661  Prologue.FileNames.push_back(FileEntry);
662  if (OS)
663  *OS << " (" << Name << ", dir=" << FileEntry.DirIdx << ", mod_time="
664  << format("(0x%16.16" PRIx64 ")", FileEntry.ModTime)
665  << ", length=" << FileEntry.Length << ")";
666  }
667  break;
668 
669  case DW_LNE_set_discriminator:
670  State.Row.Discriminator = DebugLineData.getULEB128(OffsetPtr);
671  if (OS)
672  *OS << " (" << State.Row.Discriminator << ")";
673  break;
674 
675  default:
676  if (OS)
677  *OS << format("Unrecognized extended op 0x%02.02" PRIx8, SubOpcode)
678  << format(" length %" PRIx64, Len);
679  // Len doesn't include the zero opcode byte or the length itself, but
680  // it does include the sub_opcode, so we have to adjust for that.
681  (*OffsetPtr) += Len - 1;
682  break;
683  }
684  // Make sure the stated and parsed lengths are the same.
685  // Otherwise we have an unparseable line-number program.
686  if (*OffsetPtr - ExtOffset != Len)
688  "unexpected line op length at offset 0x%8.8" PRIx64
689  " expected 0x%2.2" PRIx64 " found 0x%2.2" PRIx64,
690  ExtOffset, Len, *OffsetPtr - ExtOffset);
691  } else if (Opcode < Prologue.OpcodeBase) {
692  if (OS)
693  *OS << LNStandardString(Opcode);
694  switch (Opcode) {
695  // Standard Opcodes
696  case DW_LNS_copy:
697  // Takes no arguments. Append a row to the matrix using the
698  // current values of the state-machine registers.
699  if (OS) {
700  *OS << "\n";
701  OS->indent(12);
702  State.Row.dump(*OS);
703  *OS << "\n";
704  }
705  State.appendRowToMatrix();
706  break;
707 
708  case DW_LNS_advance_pc:
709  // Takes a single unsigned LEB128 operand, multiplies it by the
710  // min_inst_length field of the prologue, and adds the
711  // result to the address register of the state machine.
712  {
713  uint64_t AddrOffset =
714  DebugLineData.getULEB128(OffsetPtr) * Prologue.MinInstLength;
715  State.Row.Address.Address += AddrOffset;
716  if (OS)
717  *OS << " (" << AddrOffset << ")";
718  }
719  break;
720 
721  case DW_LNS_advance_line:
722  // Takes a single signed LEB128 operand and adds that value to
723  // the line register of the state machine.
724  State.Row.Line += DebugLineData.getSLEB128(OffsetPtr);
725  if (OS)
726  *OS << " (" << State.Row.Line << ")";
727  break;
728 
729  case DW_LNS_set_file:
730  // Takes a single unsigned LEB128 operand and stores it in the file
731  // register of the state machine.
732  State.Row.File = DebugLineData.getULEB128(OffsetPtr);
733  if (OS)
734  *OS << " (" << State.Row.File << ")";
735  break;
736 
737  case DW_LNS_set_column:
738  // Takes a single unsigned LEB128 operand and stores it in the
739  // column register of the state machine.
740  State.Row.Column = DebugLineData.getULEB128(OffsetPtr);
741  if (OS)
742  *OS << " (" << State.Row.Column << ")";
743  break;
744 
745  case DW_LNS_negate_stmt:
746  // Takes no arguments. Set the is_stmt register of the state
747  // machine to the logical negation of its current value.
748  State.Row.IsStmt = !State.Row.IsStmt;
749  break;
750 
751  case DW_LNS_set_basic_block:
752  // Takes no arguments. Set the basic_block register of the
753  // state machine to true
754  State.Row.BasicBlock = true;
755  break;
756 
757  case DW_LNS_const_add_pc:
758  // Takes no arguments. Add to the address register of the state
759  // machine the address increment value corresponding to special
760  // opcode 255. The motivation for DW_LNS_const_add_pc is this:
761  // when the statement program needs to advance the address by a
762  // small amount, it can use a single special opcode, which occupies
763  // a single byte. When it needs to advance the address by up to
764  // twice the range of the last special opcode, it can use
765  // DW_LNS_const_add_pc followed by a special opcode, for a total
766  // of two bytes. Only if it needs to advance the address by more
767  // than twice that range will it need to use both DW_LNS_advance_pc
768  // and a special opcode, requiring three or more bytes.
769  {
770  uint8_t AdjustOpcode = 255 - Prologue.OpcodeBase;
771  uint64_t AddrOffset =
772  (AdjustOpcode / Prologue.LineRange) * Prologue.MinInstLength;
773  State.Row.Address.Address += AddrOffset;
774  if (OS)
775  *OS
776  << format(" (0x%16.16" PRIx64 ")", AddrOffset);
777  }
778  break;
779 
780  case DW_LNS_fixed_advance_pc:
781  // Takes a single uhalf operand. Add to the address register of
782  // the state machine the value of the (unencoded) operand. This
783  // is the only extended opcode that takes an argument that is not
784  // a variable length number. The motivation for DW_LNS_fixed_advance_pc
785  // is this: existing assemblers cannot emit DW_LNS_advance_pc or
786  // special opcodes because they cannot encode LEB128 numbers or
787  // judge when the computation of a special opcode overflows and
788  // requires the use of DW_LNS_advance_pc. Such assemblers, however,
789  // can use DW_LNS_fixed_advance_pc instead, sacrificing compression.
790  {
791  uint16_t PCOffset = DebugLineData.getRelocatedValue(2, OffsetPtr);
792  State.Row.Address.Address += PCOffset;
793  if (OS)
794  *OS
795  << format(" (0x%4.4" PRIx16 ")", PCOffset);
796  }
797  break;
798 
799  case DW_LNS_set_prologue_end:
800  // Takes no arguments. Set the prologue_end register of the
801  // state machine to true
802  State.Row.PrologueEnd = true;
803  break;
804 
805  case DW_LNS_set_epilogue_begin:
806  // Takes no arguments. Set the basic_block register of the
807  // state machine to true
808  State.Row.EpilogueBegin = true;
809  break;
810 
811  case DW_LNS_set_isa:
812  // Takes a single unsigned LEB128 operand and stores it in the
813  // column register of the state machine.
814  State.Row.Isa = DebugLineData.getULEB128(OffsetPtr);
815  if (OS)
816  *OS << " (" << State.Row.Isa << ")";
817  break;
818 
819  default:
820  // Handle any unknown standard opcodes here. We know the lengths
821  // of such opcodes because they are specified in the prologue
822  // as a multiple of LEB128 operands for each opcode.
823  {
824  assert(Opcode - 1U < Prologue.StandardOpcodeLengths.size());
825  uint8_t OpcodeLength = Prologue.StandardOpcodeLengths[Opcode - 1];
826  for (uint8_t I = 0; I < OpcodeLength; ++I) {
827  uint64_t Value = DebugLineData.getULEB128(OffsetPtr);
828  if (OS)
829  *OS << format("Skipping ULEB128 value: 0x%16.16" PRIx64 ")\n",
830  Value);
831  }
832  }
833  break;
834  }
835  } else {
836  // Special Opcodes
837 
838  // A special opcode value is chosen based on the amount that needs
839  // to be added to the line and address registers. The maximum line
840  // increment for a special opcode is the value of the line_base
841  // field in the header, plus the value of the line_range field,
842  // minus 1 (line base + line range - 1). If the desired line
843  // increment is greater than the maximum line increment, a standard
844  // opcode must be used instead of a special opcode. The "address
845  // advance" is calculated by dividing the desired address increment
846  // by the minimum_instruction_length field from the header. The
847  // special opcode is then calculated using the following formula:
848  //
849  // opcode = (desired line increment - line_base) +
850  // (line_range * address advance) + opcode_base
851  //
852  // If the resulting opcode is greater than 255, a standard opcode
853  // must be used instead.
854  //
855  // To decode a special opcode, subtract the opcode_base from the
856  // opcode itself to give the adjusted opcode. The amount to
857  // increment the address register is the result of the adjusted
858  // opcode divided by the line_range multiplied by the
859  // minimum_instruction_length field from the header. That is:
860  //
861  // address increment = (adjusted opcode / line_range) *
862  // minimum_instruction_length
863  //
864  // The amount to increment the line register is the line_base plus
865  // the result of the adjusted opcode modulo the line_range. That is:
866  //
867  // line increment = line_base + (adjusted opcode % line_range)
868 
869  uint8_t AdjustOpcode = Opcode - Prologue.OpcodeBase;
870  uint64_t AddrOffset =
871  (AdjustOpcode / Prologue.LineRange) * Prologue.MinInstLength;
872  int32_t LineOffset =
873  Prologue.LineBase + (AdjustOpcode % Prologue.LineRange);
874  State.Row.Line += LineOffset;
875  State.Row.Address.Address += AddrOffset;
876 
877  if (OS) {
878  *OS << "address += " << AddrOffset << ", line += " << LineOffset
879  << "\n";
880  OS->indent(12);
881  State.Row.dump(*OS);
882  }
883 
884  State.appendRowToMatrix();
885  }
886  if(OS)
887  *OS << "\n";
888  }
889 
890  if (!State.Sequence.Empty)
891  RecoverableErrorCallback(
893  "last sequence in debug line table is not terminated!"));
894 
895  // Sort all sequences so that address lookup will work faster.
896  if (!Sequences.empty()) {
897  llvm::sort(Sequences, Sequence::orderByHighPC);
898  // Note: actually, instruction address ranges of sequences should not
899  // overlap (in shared objects and executables). If they do, the address
900  // lookup would still work, though, but result would be ambiguous.
901  // We don't report warning in this case. For example,
902  // sometimes .so compiled from multiple object files contains a few
903  // rudimentary sequences for address ranges [0x0, 0xsomething).
904  }
905 
906  return Error::success();
907 }
908 
909 uint32_t DWARFDebugLine::LineTable::findRowInSeq(
910  const DWARFDebugLine::Sequence &Seq,
912  if (!Seq.containsPC(Address))
913  return UnknownRowIndex;
914  assert(Seq.SectionIndex == Address.SectionIndex);
915  // In some cases, e.g. first instruction in a function, the compiler generates
916  // two entries, both with the same address. We want the last one.
917  //
918  // In general we want a non-empty range: the last row whose address is less
919  // than or equal to Address. This can be computed as upper_bound - 1.
921  Row.Address = Address;
922  RowIter FirstRow = Rows.begin() + Seq.FirstRowIndex;
923  RowIter LastRow = Rows.begin() + Seq.LastRowIndex;
924  assert(FirstRow->Address.Address <= Row.Address.Address &&
925  Row.Address.Address < LastRow[-1].Address.Address);
926  RowIter RowPos = std::upper_bound(FirstRow + 1, LastRow - 1, Row,
928  1;
929  assert(Seq.SectionIndex == RowPos->Address.SectionIndex);
930  return RowPos - Rows.begin();
931 }
932 
934  object::SectionedAddress Address) const {
935 
936  // Search for relocatable addresses
937  uint32_t Result = lookupAddressImpl(Address);
938 
939  if (Result != UnknownRowIndex ||
941  return Result;
942 
943  // Search for absolute addresses
945  return lookupAddressImpl(Address);
946 }
947 
948 uint32_t DWARFDebugLine::LineTable::lookupAddressImpl(
949  object::SectionedAddress Address) const {
950  // First, find an instruction sequence containing the given address.
952  Sequence.SectionIndex = Address.SectionIndex;
953  Sequence.HighPC = Address.Address;
954  SequenceIter It = llvm::upper_bound(Sequences, Sequence,
956  if (It == Sequences.end() || It->SectionIndex != Address.SectionIndex)
957  return UnknownRowIndex;
958  return findRowInSeq(*It, Address);
959 }
960 
962  object::SectionedAddress Address, uint64_t Size,
963  std::vector<uint32_t> &Result) const {
964 
965  // Search for relocatable addresses
966  if (lookupAddressRangeImpl(Address, Size, Result))
967  return true;
968 
970  return false;
971 
972  // Search for absolute addresses
974  return lookupAddressRangeImpl(Address, Size, Result);
975 }
976 
977 bool DWARFDebugLine::LineTable::lookupAddressRangeImpl(
978  object::SectionedAddress Address, uint64_t Size,
979  std::vector<uint32_t> &Result) const {
980  if (Sequences.empty())
981  return false;
982  uint64_t EndAddr = Address.Address + Size;
983  // First, find an instruction sequence containing the given address.
985  Sequence.SectionIndex = Address.SectionIndex;
986  Sequence.HighPC = Address.Address;
987  SequenceIter LastSeq = Sequences.end();
989  Sequences, Sequence, DWARFDebugLine::Sequence::orderByHighPC);
990  if (SeqPos == LastSeq || !SeqPos->containsPC(Address))
991  return false;
992 
993  SequenceIter StartPos = SeqPos;
994 
995  // Add the rows from the first sequence to the vector, starting with the
996  // index we just calculated
997 
998  while (SeqPos != LastSeq && SeqPos->LowPC < EndAddr) {
999  const DWARFDebugLine::Sequence &CurSeq = *SeqPos;
1000  // For the first sequence, we need to find which row in the sequence is the
1001  // first in our range.
1002  uint32_t FirstRowIndex = CurSeq.FirstRowIndex;
1003  if (SeqPos == StartPos)
1004  FirstRowIndex = findRowInSeq(CurSeq, Address);
1005 
1006  // Figure out the last row in the range.
1007  uint32_t LastRowIndex =
1008  findRowInSeq(CurSeq, {EndAddr - 1, Address.SectionIndex});
1009  if (LastRowIndex == UnknownRowIndex)
1010  LastRowIndex = CurSeq.LastRowIndex - 1;
1011 
1012  assert(FirstRowIndex != UnknownRowIndex);
1013  assert(LastRowIndex != UnknownRowIndex);
1014 
1015  for (uint32_t I = FirstRowIndex; I <= LastRowIndex; ++I) {
1016  Result.push_back(I);
1017  }
1018 
1019  ++SeqPos;
1020  }
1021 
1022  return true;
1023 }
1024 
1025 Optional<StringRef> DWARFDebugLine::LineTable::getSourceByIndex(uint64_t FileIndex,
1026  FileLineInfoKind Kind) const {
1027  if (Kind == FileLineInfoKind::None || !Prologue.hasFileAtIndex(FileIndex))
1028  return None;
1029  const FileNameEntry &Entry = Prologue.getFileNameEntry(FileIndex);
1030  if (Optional<const char *> source = Entry.Source.getAsCString())
1031  return StringRef(*source);
1032  return None;
1033 }
1034 
1035 static bool isPathAbsoluteOnWindowsOrPosix(const Twine &Path) {
1036  // Debug info can contain paths from any OS, not necessarily
1037  // an OS we're currently running on. Moreover different compilation units can
1038  // be compiled on different operating systems and linked together later.
1041 }
1042 
1044  uint64_t FileIndex, StringRef CompDir, FileLineInfoKind Kind,
1045  std::string &Result, sys::path::Style Style) const {
1046  if (Kind == FileLineInfoKind::None || !hasFileAtIndex(FileIndex))
1047  return false;
1048  const FileNameEntry &Entry = getFileNameEntry(FileIndex);
1049  StringRef FileName = Entry.Name.getAsCString().getValue();
1050  if (Kind != FileLineInfoKind::AbsoluteFilePath ||
1051  isPathAbsoluteOnWindowsOrPosix(FileName)) {
1052  Result = FileName;
1053  return true;
1054  }
1055 
1056  SmallString<16> FilePath;
1057  StringRef IncludeDir;
1058  // Be defensive about the contents of Entry.
1059  if (getVersion() >= 5) {
1060  if (Entry.DirIdx < IncludeDirectories.size())
1061  IncludeDir = IncludeDirectories[Entry.DirIdx].getAsCString().getValue();
1062  } else {
1063  if (0 < Entry.DirIdx && Entry.DirIdx <= IncludeDirectories.size())
1064  IncludeDir =
1065  IncludeDirectories[Entry.DirIdx - 1].getAsCString().getValue();
1066 
1067  // We may still need to append compilation directory of compile unit.
1068  // We know that FileName is not absolute, the only way to have an
1069  // absolute path at this point would be if IncludeDir is absolute.
1070  if (!CompDir.empty() && !isPathAbsoluteOnWindowsOrPosix(IncludeDir))
1071  sys::path::append(FilePath, Style, CompDir);
1072  }
1073 
1074  // sys::path::append skips empty strings.
1075  sys::path::append(FilePath, Style, IncludeDir, FileName);
1076  Result = FilePath.str();
1077  return true;
1078 }
1079 
1081  object::SectionedAddress Address, const char *CompDir,
1082  FileLineInfoKind Kind, DILineInfo &Result) const {
1083  // Get the index of row we're looking for in the line table.
1084  uint32_t RowIndex = lookupAddress(Address);
1085  if (RowIndex == -1U)
1086  return false;
1087  // Take file number and line/column from the row.
1088  const auto &Row = Rows[RowIndex];
1089  if (!getFileNameByIndex(Row.File, CompDir, Kind, Result.FileName))
1090  return false;
1091  Result.Line = Row.Line;
1092  Result.Column = Row.Column;
1093  Result.Discriminator = Row.Discriminator;
1094  Result.Source = getSourceByIndex(Row.File, Kind);
1095  return true;
1096 }
1097 
1098 // We want to supply the Unit associated with a .debug_line[.dwo] table when
1099 // we dump it, if possible, but still dump the table even if there isn't a Unit.
1100 // Therefore, collect up handles on all the Units that point into the
1101 // line-table section.
1106  for (const auto &CU : CUs)
1107  if (auto CUDIE = CU->getUnitDIE())
1108  if (auto StmtOffset = toSectionOffset(CUDIE.find(DW_AT_stmt_list)))
1109  LineToUnit.insert(std::make_pair(*StmtOffset, &*CU));
1110  for (const auto &TU : TUs)
1111  if (auto TUDIE = TU->getUnitDIE())
1112  if (auto StmtOffset = toSectionOffset(TUDIE.find(DW_AT_stmt_list)))
1113  LineToUnit.insert(std::make_pair(*StmtOffset, &*TU));
1114  return LineToUnit;
1115 }
1116 
1118  const DWARFContext &C,
1119  cu_range CUs, tu_range TUs)
1120  : DebugLineData(Data), Context(C) {
1121  LineToUnit = buildLineToUnitMap(CUs, TUs);
1122  if (!DebugLineData.isValidOffset(Offset))
1123  Done = true;
1124 }
1125 
1127  return TotalLength == dwarf::DW_LENGTH_DWARF64 ||
1128  TotalLength < dwarf::DW_LENGTH_lo_reserved;
1129 }
1130 
1132  function_ref<void(Error)> RecoverableErrorCallback,
1133  function_ref<void(Error)> UnrecoverableErrorCallback, raw_ostream *OS) {
1134  assert(DebugLineData.isValidOffset(Offset) &&
1135  "parsing should have terminated");
1136  DWARFUnit *U = prepareToParse(Offset);
1137  uint64_t OldOffset = Offset;
1138  LineTable LT;
1139  if (Error Err = LT.parse(DebugLineData, &Offset, Context, U,
1140  RecoverableErrorCallback, OS))
1141  UnrecoverableErrorCallback(std::move(Err));
1142  moveToNextTable(OldOffset, LT.Prologue);
1143  return LT;
1144 }
1145 
1147  function_ref<void(Error)> ErrorCallback) {
1148  assert(DebugLineData.isValidOffset(Offset) &&
1149  "parsing should have terminated");
1150  DWARFUnit *U = prepareToParse(Offset);
1151  uint64_t OldOffset = Offset;
1152  LineTable LT;
1153  if (Error Err = LT.Prologue.parse(DebugLineData, &Offset, Context, U))
1154  ErrorCallback(std::move(Err));
1155  moveToNextTable(OldOffset, LT.Prologue);
1156 }
1157 
1158 DWARFUnit *DWARFDebugLine::SectionParser::prepareToParse(uint64_t Offset) {
1159  DWARFUnit *U = nullptr;
1160  auto It = LineToUnit.find(Offset);
1161  if (It != LineToUnit.end())
1162  U = It->second;
1163  DebugLineData.setAddressSize(U ? U->getAddressByteSize() : 0);
1164  return U;
1165 }
1166 
1167 void DWARFDebugLine::SectionParser::moveToNextTable(uint64_t OldOffset,
1168  const Prologue &P) {
1169  // If the length field is not valid, we don't know where the next table is, so
1170  // cannot continue to parse. Mark the parser as done, and leave the Offset
1171  // value as it currently is. This will be the end of the bad length field.
1172  if (!P.totalLengthIsValid()) {
1173  Done = true;
1174  return;
1175  }
1176 
1177  Offset = OldOffset + P.TotalLength + P.sizeofTotalLength();
1178  if (!DebugLineData.isValidOffset(Offset)) {
1179  Done = true;
1180  }
1181 }
SequenceVector::const_iterator SequenceIter
void dump(raw_ostream &OS, DIDumpOptions DumpOpts=DIDumpOptions()) const
const NoneType None
Definition: None.h:23
uint64_t CallInst * C
uint8_t getU8(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint8_t value from *offset_ptr.
uint32_t Discriminator
Definition: DIContext.h:43
A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...
Definition: Dwarf.h:488
Optional< StringRef > Source
Definition: DIContext.h:37
uint64_t LowPC
Sequence describes instructions at address range [LowPC, HighPC) and is described by line table rows ...
std::string FileName
Definition: DIContext.h:35
LLVMContext & Context
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...
uint16_t getU16(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint16_t value from *offset_ptr.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Row(bool DefaultIsStmt=false)
static Error parseV5DirFileTables(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr, uint64_t EndPrologueOffset, const dwarf::FormParams &FormParams, const DWARFContext &Ctx, const DWARFUnit *U, DWARFDebugLine::ContentTypeTracker &ContentTypes, std::vector< DWARFFormValue > &IncludeDirectories, std::vector< DWARFDebugLine::FileNameEntry > &FileNames)
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
uint32_t sizeofTotalLength() const
SmallString< 32 > digest() const
Definition: MD5.cpp:264
StringRef LNExtendedString(unsigned Encoding)
Definition: Dwarf.cpp:424
static bool orderByAddress(const Row &LHS, const Row &RHS)
const char * getCStr(uint64_t *offset_ptr) const
Extract a C string from *offset_ptr.
StringRef LNStandardString(unsigned Standard)
Definition: Dwarf.cpp:413
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
raw_ostream & indent(unsigned NumSpaces)
indent - Insert &#39;NumSpaces&#39; spaces.
uint8_t MinInstLength
The size in bytes of the smallest target machine instruction.
static const uint64_t UndefSection
Definition: ObjectFile.h:140
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:104
uint32_t Line
An unsigned integer indicating a source line number.
SectionParser(DWARFDataExtractor &Data, const DWARFContext &C, cu_range CUs, tu_range TUs)
void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const
bool extractValue(const DWARFDataExtractor &Data, uint64_t *OffsetPtr, dwarf::FormParams FormParams, const DWARFContext *Context=nullptr, const DWARFUnit *Unit=nullptr)
Extracts a value in Data at offset *OffsetPtr.
Error takeError()
Take ownership of the stored error.
Definition: Error.h:552
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.
int64_t getSLEB128(uint64_t *offset_ptr) const
Extract a signed LEB128 value from *offset_ptr.
A format-neutral container for source line information.
Definition: DIContext.h:30
object::SectionedAddress Address
The program-counter value corresponding to a machine instruction generated by the compiler and sectio...
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:455
const llvm::DWARFDebugLine::FileNameEntry & getFileNameEntry(uint64_t Index) const
Get DWARF-version aware access to the file name entry at the provided index.
bool lookupAddressRange(object::SectionedAddress Address, uint64_t Size, std::vector< uint32_t > &Result) const
uint64_t SectionIndex
If relocation information is present then this is the index of the section which contains above addre...
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
Represents a series of contiguous machine instructions.
Optional< ArrayRef< uint8_t > > getAsBlock() const
Expected< const LineTable * > getOrParseLineTable(DWARFDataExtractor &DebugLineData, uint64_t Offset, const DWARFContext &Ctx, const DWARFUnit *U, std::function< void(Error)> RecoverableErrorCallback)
Error parse(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr, const DWARFContext &Ctx, const DWARFUnit *U=nullptr)
void postAppend()
Called after a row is appended to the matrix.
bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
Definition: Path.cpp:663
Tagged union holding either a T or a Error.
Definition: yaml2obj.h:21
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:140
uint8_t LineRange
This parameter affects the meaning of the special opcodes. See below.
uint8_t getAddressByteSize() const
Definition: DWARFUnit.h:284
static llvm::Expected< ContentDescriptors > parseV5EntryFormat(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr, uint64_t EndPrologueOffset, DWARFDebugLine::ContentTypeTracker *ContentTypes)
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:266
uint8_t OpcodeBase
The number assigned to the first special opcode.
void reset(bool DefaultIsStmt)
const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:255
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...
uint64_t TotalLength
The size in bytes of the statement information for this compilation unit (not including the total_len...
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
bool HasModTime
Whether filename entries provide a modification timestamp.
Error parse(DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr, const DWARFContext &Ctx, const DWARFUnit *U, std::function< void(Error)> RecoverableErrorCallback, raw_ostream *OS=nullptr)
Parse prologue and all rows.
Container for dump options that control which debug information will be dumped.
Definition: DIContext.h:171
bool getFileNameByIndex(uint64_t FileIndex, StringRef CompDir, DILineInfoSpecifier::FileLineInfoKind Kind, std::string &Result, sys::path::Style Style=sys::path::Style::native) const
Optional< uint64_t > toSectionOffset(const Optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract an section offset.
uint8_t EndSequence
A boolean indicating that the current address is that of the first byte after the end of a sequence o...
#define P(N)
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
uint32_t Column
Definition: DIContext.h:39
void dump(raw_ostream &OS) const
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
LineTable parseNext(function_ref< void(Error)> RecoverableErrorCallback, function_ref< void(Error)> UnrecoverableErrorCallback, raw_ostream *OS=nullptr)
Get the next line table from the section.
Instrumentation for Order File
uint16_t File
An unsigned integer indicating the identity of the source file corresponding to a machine instruction...
bool HasLength
Whether filename entries provide a file size.
bool hasFileAtIndex(uint64_t FileIndex) const
uint8_t getAddressSize() const
Get the address size for this extractor.
Definition: DataExtractor.h:91
static bool orderByHighPC(const Sequence &LHS, const Sequence &RHS)
Optional< uint64_t > getAsUnsignedConstant() const
uint64_t getULEB128(uint64_t *offset_ptr, llvm::Error *Err=nullptr) const
Extract a unsigned LEB128 value from *offset_ptr.
void appendSequence(const DWARFDebugLine::Sequence &S)
void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const
Standard .debug_line state machine structure.
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1095
A DataExtractor (typically for an in-memory copy of an object-file section) plus a relocation map for...
uint16_t Column
An unsigned integer indicating a column number within a source line.
static ErrorSuccess success()
Create a success value.
Definition: Error.h:326
static DWARFDebugLine::SectionParser::LineToUnitMap buildLineToUnitMap(DWARFDebugLine::SectionParser::cu_range CUs, DWARFDebugLine::SectionParser::tu_range TUs)
std::map< uint64_t, DWARFUnit * > LineToUnitMap
uint32_t Line
Definition: DIContext.h:38
End of the line table.
Definition: LineTable.cpp:17
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
void appendRow(const DWARFDebugLine::Row &R)
DWARFContext This data structure is the top level entity that deals with dwarf debug information pars...
Definition: DWARFContext.h:58
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 ...
static void dumpTableHeader(raw_ostream &OS)
void setAddressSize(uint8_t Size)
Set the address size for this extractor.
Definition: DataExtractor.h:93
std::vector< uint8_t > StandardOpcodeLengths
bool isValidOffset(uint64_t offset) const
Test the validity of offset.
A range adaptor for a pair of iterators.
This file contains constants used for implementing Dwarf debug support.
const LineTable * getLineTable(uint64_t Offset) const
static void parseV2DirFileTables(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr, uint64_t EndPrologueOffset, DWARFDebugLine::ContentTypeTracker &ContentTypes, std::vector< DWARFFormValue > &IncludeDirectories, std::vector< DWARFDebugLine::FileNameEntry > &FileNames)
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:225
static DWARFFormValue createFromPValue(dwarf::Form F, const char *V)
Tracks which optional content types are present in a DWARF file name entry format.
std::vector< FileNameEntry > FileNames
uint32_t Discriminator
An unsigned integer representing the DWARF path discriminator value for this location.
RowVector::const_iterator RowIter
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:423
#define I(x, y, z)
Definition: MD5.cpp:58
Optional< const char * > getAsCString() const
Sequence
A sequence of states that a pointer may go through in which an objc_retain and objc_release are actua...
Definition: PtrState.h:40
uint32_t Size
Definition: Profile.cpp:46
uint8_t DefaultIsStmt
The initial value of theis_stmtregister.
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:136
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
DwarfFormat Format
Definition: Dwarf.h:491
bool containsPC(object::SectionedAddress PC) const
std::array< uint8_t, 16 > Bytes
Definition: MD5.h:56
static bool isPathAbsoluteOnWindowsOrPosix(const Twine &Path)
int8_t LineBase
This parameter affects the meaning of the special opcodes. See below.
LLVM Value Representation.
Definition: Value.h:73
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
uint64_t getU64(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint64_t value from *offset_ptr.
print Print MemDeps of function
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
bool skipValue(DataExtractor DebugInfoData, uint64_t *OffsetPtr, const dwarf::FormParams Params) const
Skip a form&#39;s value in DebugInfoData at the offset specified by OffsetPtr.
void skip(function_ref< void(Error)> ErrorCallback)
Skip the current line table and go to the following line table (if present) immediately.
void trackContentType(dwarf::LineNumberEntryFormat ContentType)
Update tracked content types with ContentType.
StringRef getCStrRef(uint64_t *offset_ptr) const
Extract a C string from *offset_ptr.
LineNumberEntryFormat
Definition: Dwarf.h:233
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1177
auto upper_bound(R &&Range, T &&Value) -> decltype(adl_begin(Range))
Provide wrappers to std::upper_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1276