LLVM  7.0.0svn
DWARFDebugFrame.cpp
Go to the documentation of this file.
1 //===- DWARFDebugFrame.h - Parsing of .debug_frame ------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
11 #include "llvm/ADT/DenseMap.h"
12 #include "llvm/ADT/Optional.h"
13 #include "llvm/ADT/StringExtras.h"
14 #include "llvm/ADT/StringRef.h"
16 #include "llvm/Support/Casting.h"
17 #include "llvm/Support/Compiler.h"
20 #include "llvm/Support/Format.h"
22 #include <algorithm>
23 #include <cassert>
24 #include <cinttypes>
25 #include <cstdint>
26 #include <string>
27 #include <vector>
28 
29 using namespace llvm;
30 using namespace dwarf;
31 
32 
33 // See DWARF standard v3, section 7.23
34 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
35 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
36 
38  uint32_t EndOffset) {
39  while (*Offset < EndOffset) {
40  uint8_t Opcode = Data.getU8(Offset);
41  // Some instructions have a primary opcode encoded in the top bits.
42  uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK;
43 
44  if (Primary) {
45  // If it's a primary opcode, the first operand is encoded in the bottom
46  // bits of the opcode itself.
47  uint64_t Op1 = Opcode & DWARF_CFI_PRIMARY_OPERAND_MASK;
48  switch (Primary) {
49  default:
50  return make_error<StringError>(
51  "Invalid primary CFI opcode",
52  std::make_error_code(std::errc::illegal_byte_sequence));
53  case DW_CFA_advance_loc:
54  case DW_CFA_restore:
55  addInstruction(Primary, Op1);
56  break;
57  case DW_CFA_offset:
58  addInstruction(Primary, Op1, Data.getULEB128(Offset));
59  break;
60  }
61  } else {
62  // Extended opcode - its value is Opcode itself.
63  switch (Opcode) {
64  default:
65  return make_error<StringError>(
66  "Invalid extended CFI opcode",
67  std::make_error_code(std::errc::illegal_byte_sequence));
68  case DW_CFA_nop:
69  case DW_CFA_remember_state:
70  case DW_CFA_restore_state:
71  case DW_CFA_GNU_window_save:
72  // No operands
73  addInstruction(Opcode);
74  break;
75  case DW_CFA_set_loc:
76  // Operands: Address
77  addInstruction(Opcode, Data.getAddress(Offset));
78  break;
79  case DW_CFA_advance_loc1:
80  // Operands: 1-byte delta
81  addInstruction(Opcode, Data.getU8(Offset));
82  break;
83  case DW_CFA_advance_loc2:
84  // Operands: 2-byte delta
85  addInstruction(Opcode, Data.getU16(Offset));
86  break;
87  case DW_CFA_advance_loc4:
88  // Operands: 4-byte delta
89  addInstruction(Opcode, Data.getU32(Offset));
90  break;
91  case DW_CFA_restore_extended:
92  case DW_CFA_undefined:
93  case DW_CFA_same_value:
94  case DW_CFA_def_cfa_register:
95  case DW_CFA_def_cfa_offset:
96  case DW_CFA_GNU_args_size:
97  // Operands: ULEB128
98  addInstruction(Opcode, Data.getULEB128(Offset));
99  break;
100  case DW_CFA_def_cfa_offset_sf:
101  // Operands: SLEB128
102  addInstruction(Opcode, Data.getSLEB128(Offset));
103  break;
104  case DW_CFA_offset_extended:
105  case DW_CFA_register:
106  case DW_CFA_def_cfa:
107  case DW_CFA_val_offset: {
108  // Operands: ULEB128, ULEB128
109  // Note: We can not embed getULEB128 directly into function
110  // argument list. getULEB128 changes Offset and order of evaluation
111  // for arguments is unspecified.
112  auto op1 = Data.getULEB128(Offset);
113  auto op2 = Data.getULEB128(Offset);
114  addInstruction(Opcode, op1, op2);
115  break;
116  }
117  case DW_CFA_offset_extended_sf:
118  case DW_CFA_def_cfa_sf:
119  case DW_CFA_val_offset_sf: {
120  // Operands: ULEB128, SLEB128
121  // Note: see comment for the previous case
122  auto op1 = Data.getULEB128(Offset);
123  auto op2 = (uint64_t)Data.getSLEB128(Offset);
124  addInstruction(Opcode, op1, op2);
125  break;
126  }
127  case DW_CFA_def_cfa_expression: {
128  uint32_t ExprLength = Data.getULEB128(Offset);
129  addInstruction(Opcode, 0);
130  DataExtractor Extractor(
131  Data.getData().slice(*Offset, *Offset + ExprLength),
132  Data.isLittleEndian(), Data.getAddressSize());
133  Instructions.back().Expression = DWARFExpression(
134  Extractor, Data.getAddressSize(), dwarf::DWARF_VERSION);
135  *Offset += ExprLength;
136  break;
137  }
138  case DW_CFA_expression:
139  case DW_CFA_val_expression: {
140  auto RegNum = Data.getULEB128(Offset);
141  auto BlockLength = Data.getULEB128(Offset);
142  addInstruction(Opcode, RegNum, 0);
143  DataExtractor Extractor(
144  Data.getData().slice(*Offset, *Offset + BlockLength),
145  Data.isLittleEndian(), Data.getAddressSize());
146  Instructions.back().Expression = DWARFExpression(
147  Extractor, Data.getAddressSize(), dwarf::DWARF_VERSION);
148  *Offset += BlockLength;
149  break;
150  }
151  }
152  }
153  }
154 
155  return Error::success();
156 }
157 
158 namespace {
159 
160 
161 } // end anonymous namespace
162 
163 ArrayRef<CFIProgram::OperandType[2]> CFIProgram::getOperandTypes() {
164  static OperandType OpTypes[DW_CFA_restore+1][2];
165  static bool Initialized = false;
166  if (Initialized) {
167  return ArrayRef<OperandType[2]>(&OpTypes[0], DW_CFA_restore+1);
168  }
169  Initialized = true;
170 
171 #define DECLARE_OP2(OP, OPTYPE0, OPTYPE1) \
172  do { \
173  OpTypes[OP][0] = OPTYPE0; \
174  OpTypes[OP][1] = OPTYPE1; \
175  } while (false)
176 #define DECLARE_OP1(OP, OPTYPE0) DECLARE_OP2(OP, OPTYPE0, OT_None)
177 #define DECLARE_OP0(OP) DECLARE_OP1(OP, OT_None)
178 
179  DECLARE_OP1(DW_CFA_set_loc, OT_Address);
180  DECLARE_OP1(DW_CFA_advance_loc, OT_FactoredCodeOffset);
181  DECLARE_OP1(DW_CFA_advance_loc1, OT_FactoredCodeOffset);
182  DECLARE_OP1(DW_CFA_advance_loc2, OT_FactoredCodeOffset);
183  DECLARE_OP1(DW_CFA_advance_loc4, OT_FactoredCodeOffset);
184  DECLARE_OP1(DW_CFA_MIPS_advance_loc8, OT_FactoredCodeOffset);
185  DECLARE_OP2(DW_CFA_def_cfa, OT_Register, OT_Offset);
186  DECLARE_OP2(DW_CFA_def_cfa_sf, OT_Register, OT_SignedFactDataOffset);
187  DECLARE_OP1(DW_CFA_def_cfa_register, OT_Register);
188  DECLARE_OP1(DW_CFA_def_cfa_offset, OT_Offset);
189  DECLARE_OP1(DW_CFA_def_cfa_offset_sf, OT_SignedFactDataOffset);
190  DECLARE_OP1(DW_CFA_def_cfa_expression, OT_Expression);
191  DECLARE_OP1(DW_CFA_undefined, OT_Register);
192  DECLARE_OP1(DW_CFA_same_value, OT_Register);
193  DECLARE_OP2(DW_CFA_offset, OT_Register, OT_UnsignedFactDataOffset);
194  DECLARE_OP2(DW_CFA_offset_extended, OT_Register, OT_UnsignedFactDataOffset);
195  DECLARE_OP2(DW_CFA_offset_extended_sf, OT_Register, OT_SignedFactDataOffset);
196  DECLARE_OP2(DW_CFA_val_offset, OT_Register, OT_UnsignedFactDataOffset);
197  DECLARE_OP2(DW_CFA_val_offset_sf, OT_Register, OT_SignedFactDataOffset);
198  DECLARE_OP2(DW_CFA_register, OT_Register, OT_Register);
199  DECLARE_OP2(DW_CFA_expression, OT_Register, OT_Expression);
200  DECLARE_OP2(DW_CFA_val_expression, OT_Register, OT_Expression);
201  DECLARE_OP1(DW_CFA_restore, OT_Register);
202  DECLARE_OP1(DW_CFA_restore_extended, OT_Register);
203  DECLARE_OP0(DW_CFA_remember_state);
204  DECLARE_OP0(DW_CFA_restore_state);
205  DECLARE_OP0(DW_CFA_GNU_window_save);
206  DECLARE_OP1(DW_CFA_GNU_args_size, OT_Offset);
207  DECLARE_OP0(DW_CFA_nop);
208 
209 #undef DECLARE_OP0
210 #undef DECLARE_OP1
211 #undef DECLARE_OP2
212 
213  return ArrayRef<OperandType[2]>(&OpTypes[0], DW_CFA_restore+1);
214 }
215 
216 /// Print \p Opcode's operand number \p OperandIdx which has value \p Operand.
217 void CFIProgram::printOperand(raw_ostream &OS, const MCRegisterInfo *MRI,
218  bool IsEH, const Instruction &Instr,
219  unsigned OperandIdx, uint64_t Operand) const {
220  assert(OperandIdx < 2);
221  uint8_t Opcode = Instr.Opcode;
222  OperandType Type = getOperandTypes()[Opcode][OperandIdx];
223 
224  switch (Type) {
225  case OT_Unset: {
226  OS << " Unsupported " << (OperandIdx ? "second" : "first") << " operand to";
227  auto OpcodeName = CallFrameString(Opcode);
228  if (!OpcodeName.empty())
229  OS << " " << OpcodeName;
230  else
231  OS << format(" Opcode %x", Opcode);
232  break;
233  }
234  case OT_None:
235  break;
236  case OT_Address:
237  OS << format(" %" PRIx64, Operand);
238  break;
239  case OT_Offset:
240  // The offsets are all encoded in a unsigned form, but in practice
241  // consumers use them signed. It's most certainly legacy due to
242  // the lack of signed variants in the first Dwarf standards.
243  OS << format(" %+" PRId64, int64_t(Operand));
244  break;
245  case OT_FactoredCodeOffset: // Always Unsigned
246  if (CodeAlignmentFactor)
247  OS << format(" %" PRId64, Operand * CodeAlignmentFactor);
248  else
249  OS << format(" %" PRId64 "*code_alignment_factor" , Operand);
250  break;
251  case OT_SignedFactDataOffset:
252  if (DataAlignmentFactor)
253  OS << format(" %" PRId64, int64_t(Operand) * DataAlignmentFactor);
254  else
255  OS << format(" %" PRId64 "*data_alignment_factor" , int64_t(Operand));
256  break;
257  case OT_UnsignedFactDataOffset:
258  if (DataAlignmentFactor)
259  OS << format(" %" PRId64, Operand * DataAlignmentFactor);
260  else
261  OS << format(" %" PRId64 "*data_alignment_factor" , Operand);
262  break;
263  case OT_Register:
264  OS << format(" reg%" PRId64, Operand);
265  break;
266  case OT_Expression:
267  assert(Instr.Expression && "missing DWARFExpression object");
268  OS << " ";
269  Instr.Expression->print(OS, MRI, IsEH);
270  break;
271  }
272 }
273 
274 void CFIProgram::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
275  unsigned IndentLevel) const {
276  for (const auto &Instr : Instructions) {
277  uint8_t Opcode = Instr.Opcode;
278  if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
280  OS.indent(2 * IndentLevel);
281  OS << CallFrameString(Opcode) << ":";
282  for (unsigned i = 0; i < Instr.Ops.size(); ++i)
283  printOperand(OS, MRI, IsEH, Instr, i, Instr.Ops[i]);
284  OS << '\n';
285  }
286 }
287 
288 void CIE::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const {
289  OS << format("%08x %08x %08x CIE", (uint32_t)Offset, (uint32_t)Length,
290  DW_CIE_ID)
291  << "\n";
292  OS << format(" Version: %d\n", Version);
293  OS << " Augmentation: \"" << Augmentation << "\"\n";
294  if (Version >= 4) {
295  OS << format(" Address size: %u\n", (uint32_t)AddressSize);
296  OS << format(" Segment desc size: %u\n",
297  (uint32_t)SegmentDescriptorSize);
298  }
299  OS << format(" Code alignment factor: %u\n", (uint32_t)CodeAlignmentFactor);
300  OS << format(" Data alignment factor: %d\n", (int32_t)DataAlignmentFactor);
301  OS << format(" Return address column: %d\n", (int32_t)ReturnAddressRegister);
302  if (Personality)
303  OS << format(" Personality Address: %08x\n", *Personality);
304  if (!AugmentationData.empty()) {
305  OS << " Augmentation data: ";
306  for (uint8_t Byte : AugmentationData)
307  OS << ' ' << hexdigit(Byte >> 4) << hexdigit(Byte & 0xf);
308  OS << "\n";
309  }
310  OS << "\n";
311  CFIs.dump(OS, MRI, IsEH);
312  OS << "\n";
313 }
314 
315 void FDE::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const {
316  OS << format("%08x %08x %08x FDE ", (uint32_t)Offset, (uint32_t)Length,
317  (int32_t)LinkedCIEOffset);
318  OS << format("cie=%08x pc=%08x...%08x\n", (int32_t)LinkedCIEOffset,
319  (uint32_t)InitialLocation,
320  (uint32_t)InitialLocation + (uint32_t)AddressRange);
321  if (LSDAAddress)
322  OS << format(" LSDA Address: %08x\n", *LSDAAddress);
323  CFIs.dump(OS, MRI, IsEH);
324  OS << "\n";
325 }
326 
327 DWARFDebugFrame::DWARFDebugFrame(bool IsEH, uint64_t EHFrameAddress)
328  : IsEH(IsEH), EHFrameAddress(EHFrameAddress) {}
329 
331 
333  uint32_t Offset, int Length) {
334  errs() << "DUMP: ";
335  for (int i = 0; i < Length; ++i) {
336  uint8_t c = Data.getU8(&Offset);
337  errs().write_hex(c); errs() << " ";
338  }
339  errs() << "\n";
340 }
341 
342 // This is a workaround for old compilers which do not allow
343 // noreturn attribute usage in lambdas. Once the support for those
344 // compilers are phased out, we can remove this and return back to
345 // a ReportError lambda: [StartOffset](const char *ErrorMsg).
347  const char *ErrorMsg) {
348  std::string Str;
349  raw_string_ostream OS(Str);
350  OS << format(ErrorMsg, StartOffset);
351  OS.flush();
352  report_fatal_error(Str);
353 }
354 
356  uint32_t Offset = 0;
358 
359  while (Data.isValidOffset(Offset)) {
360  uint32_t StartOffset = Offset;
361 
362  bool IsDWARF64 = false;
363  uint64_t Length = Data.getU32(&Offset);
364  uint64_t Id;
365 
366  if (Length == UINT32_MAX) {
367  // DWARF-64 is distinguished by the first 32 bits of the initial length
368  // field being 0xffffffff. Then, the next 64 bits are the actual entry
369  // length.
370  IsDWARF64 = true;
371  Length = Data.getU64(&Offset);
372  }
373 
374  // At this point, Offset points to the next field after Length.
375  // Length is the structure size excluding itself. Compute an offset one
376  // past the end of the structure (needed to know how many instructions to
377  // read).
378  // TODO: For honest DWARF64 support, DataExtractor will have to treat
379  // offset_ptr as uint64_t*
380  uint32_t StartStructureOffset = Offset;
381  uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
382 
383  // The Id field's size depends on the DWARF format
384  Id = Data.getUnsigned(&Offset, (IsDWARF64 && !IsEH) ? 8 : 4);
385  bool IsCIE =
386  ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID || (IsEH && !Id));
387 
388  if (IsCIE) {
389  uint8_t Version = Data.getU8(&Offset);
390  const char *Augmentation = Data.getCStr(&Offset);
391  StringRef AugmentationString(Augmentation ? Augmentation : "");
392  uint8_t AddressSize = Version < 4 ? Data.getAddressSize() :
393  Data.getU8(&Offset);
394  Data.setAddressSize(AddressSize);
395  uint8_t SegmentDescriptorSize = Version < 4 ? 0 : Data.getU8(&Offset);
396  uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
397  int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
398  uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
399 
400  // Parse the augmentation data for EH CIEs
401  StringRef AugmentationData("");
402  uint32_t FDEPointerEncoding = DW_EH_PE_absptr;
403  uint32_t LSDAPointerEncoding = DW_EH_PE_omit;
404  Optional<uint64_t> Personality;
405  Optional<uint32_t> PersonalityEncoding;
406  if (IsEH) {
407  Optional<uint64_t> AugmentationLength;
408  uint32_t StartAugmentationOffset;
409  uint32_t EndAugmentationOffset;
410 
411  // Walk the augmentation string to get all the augmentation data.
412  for (unsigned i = 0, e = AugmentationString.size(); i != e; ++i) {
413  switch (AugmentationString[i]) {
414  default:
415  ReportError(StartOffset,
416  "Unknown augmentation character in entry at %lx");
417  case 'L':
418  LSDAPointerEncoding = Data.getU8(&Offset);
419  break;
420  case 'P': {
421  if (Personality)
422  ReportError(StartOffset,
423  "Duplicate personality in entry at %lx");
424  PersonalityEncoding = Data.getU8(&Offset);
425  Personality = Data.getEncodedPointer(
426  &Offset, *PersonalityEncoding,
427  EHFrameAddress ? EHFrameAddress + Offset : 0);
428  break;
429  }
430  case 'R':
431  FDEPointerEncoding = Data.getU8(&Offset);
432  break;
433  case 'S':
434  // Current frame is a signal trampoline.
435  break;
436  case 'z':
437  if (i)
438  ReportError(StartOffset,
439  "'z' must be the first character at %lx");
440  // Parse the augmentation length first. We only parse it if
441  // the string contains a 'z'.
442  AugmentationLength = Data.getULEB128(&Offset);
443  StartAugmentationOffset = Offset;
444  EndAugmentationOffset = Offset +
445  static_cast<uint32_t>(*AugmentationLength);
446  }
447  }
448 
449  if (AugmentationLength.hasValue()) {
450  if (Offset != EndAugmentationOffset)
451  ReportError(StartOffset, "Parsing augmentation data at %lx failed");
452 
453  AugmentationData = Data.getData().slice(StartAugmentationOffset,
454  EndAugmentationOffset);
455  }
456  }
457 
458  auto Cie = llvm::make_unique<CIE>(
459  StartOffset, Length, Version, AugmentationString, AddressSize,
460  SegmentDescriptorSize, CodeAlignmentFactor, DataAlignmentFactor,
461  ReturnAddressRegister, AugmentationData, FDEPointerEncoding,
462  LSDAPointerEncoding, Personality, PersonalityEncoding);
463  CIEs[StartOffset] = Cie.get();
464  Entries.emplace_back(std::move(Cie));
465  } else {
466  // FDE
467  uint64_t CIEPointer = Id;
468  uint64_t InitialLocation = 0;
469  uint64_t AddressRange = 0;
470  Optional<uint64_t> LSDAAddress;
471  CIE *Cie = CIEs[IsEH ? (StartStructureOffset - CIEPointer) : CIEPointer];
472 
473  if (IsEH) {
474  // The address size is encoded in the CIE we reference.
475  if (!Cie)
476  ReportError(StartOffset,
477  "Parsing FDE data at %lx failed due to missing CIE");
478 
479  if (auto Val = Data.getEncodedPointer(
480  &Offset, Cie->getFDEPointerEncoding(),
481  EHFrameAddress ? EHFrameAddress + Offset : 0)) {
482  InitialLocation = *Val;
483  }
484  if (auto Val = Data.getEncodedPointer(
485  &Offset, Cie->getFDEPointerEncoding(), 0)) {
486  AddressRange = *Val;
487  }
488 
489  StringRef AugmentationString = Cie->getAugmentationString();
490  if (!AugmentationString.empty()) {
491  // Parse the augmentation length and data for this FDE.
492  uint64_t AugmentationLength = Data.getULEB128(&Offset);
493 
494  uint32_t EndAugmentationOffset =
495  Offset + static_cast<uint32_t>(AugmentationLength);
496 
497  // Decode the LSDA if the CIE augmentation string said we should.
498  if (Cie->getLSDAPointerEncoding() != DW_EH_PE_omit) {
499  LSDAAddress = Data.getEncodedPointer(
500  &Offset, Cie->getLSDAPointerEncoding(),
501  EHFrameAddress ? Offset + EHFrameAddress : 0);
502  }
503 
504  if (Offset != EndAugmentationOffset)
505  ReportError(StartOffset, "Parsing augmentation data at %lx failed");
506  }
507  } else {
508  InitialLocation = Data.getAddress(&Offset);
509  AddressRange = Data.getAddress(&Offset);
510  }
511 
512  Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer,
513  InitialLocation, AddressRange,
514  Cie, LSDAAddress));
515  }
516 
517  if (Error E =
518  Entries.back()->cfis().parse(Data, &Offset, EndStructureOffset)) {
519  report_fatal_error(toString(std::move(E)));
520  }
521 
522  if (Offset != EndStructureOffset)
523  ReportError(StartOffset, "Parsing entry instructions at %lx failed");
524  }
525 }
526 
527 FrameEntry *DWARFDebugFrame::getEntryAtOffset(uint64_t Offset) const {
528  auto It =
529  std::lower_bound(Entries.begin(), Entries.end(), Offset,
530  [](const std::unique_ptr<FrameEntry> &E,
531  uint64_t Offset) { return E->getOffset() < Offset; });
532  if (It != Entries.end() && (*It)->getOffset() == Offset)
533  return It->get();
534  return nullptr;
535 }
536 
538  Optional<uint64_t> Offset) const {
539  if (Offset) {
540  if (auto *Entry = getEntryAtOffset(*Offset))
541  Entry->dump(OS, MRI, IsEH);
542  return;
543  }
544 
545  OS << "\n";
546  for (const auto &Entry : Entries)
547  Entry->dump(OS, MRI, IsEH);
548 }
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
uint64_t getULEB128(uint32_t *offset_ptr) const
Extract a unsigned LEB128 value from *offset_ptr.
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:115
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:137
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
Error parse(DataExtractor Data, uint32_t *Offset, uint32_t EndOffset)
Parse and store a sequence of CFI instructions from Data, starting at *Offset and ending at EndOffset...
An entry in either debug_frame or eh_frame.
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.
StringRef getData() const
Get the data pointed to by this extractor.
Definition: DataExtractor.h:55
const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK
uint32_t getLSDAPointerEncoding() const
uint16_t getU16(uint32_t *offset_ptr) const
Extract a uint16_t value from *offset_ptr.
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:955
uint32_t getU32(uint32_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
std::error_code make_error_code(BitcodeError E)
raw_ostream & write_hex(unsigned long long N)
Output N in hexadecimal, without any prefix or padding.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
auto lower_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range))
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1004
#define DECLARE_OP2(OP, OPTYPE0, OPTYPE1)
bool isLittleEndian() const
Get the endianness for this extractor.
Definition: DataExtractor.h:57
char hexdigit(unsigned X, bool LowerCase=false)
hexdigit - Return the hexadecimal character for the given number X (which should be less than 16)...
Definition: StringExtras.h:37
int64_t getSLEB128(uint32_t *offset_ptr) const
Extract a signed LEB128 value from *offset_ptr.
void dump(raw_ostream &OS, const MCRegisterInfo *MRI, Optional< uint64_t > Offset) const
Dump the section data into the given stream.
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
unsigned const MachineRegisterInfo * MRI
DWARF Frame Description Entry (FDE)
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
StringRef CallFrameString(unsigned Encoding)
Definition: Dwarf.cpp:458
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
uint32_t getFDEPointerEncoding() const
uint8_t getAddressSize() const
Get the address size for this extractor.
Definition: DataExtractor.h:59
#define LLVM_ATTRIBUTE_UNUSED
Definition: Compiler.h:147
uint8_t getU8(uint32_t *offset_ptr) const
Extract a uint8_t value from *offset_ptr.
uint64_t getAddress(uint32_t *offset_ptr) const
Extract an pointer from *offset_ptr.
void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH, unsigned IndentLevel=1) const
uint64_t getU64(uint32_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK
Optional< uint64_t > getEncodedPointer(uint32_t *Offset, uint8_t Encoding, uint64_t AbsPosOffset=0) const
Extracts a DWARF-encoded pointer in Offset using Encoding.
void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const override
Dump the instructions in this CFI fragment.
const uint32_t DW_CIE_ID
Special ID values that distinguish a CIE from a FDE in DWARF CFI.
Definition: Dwarf.h:70
A DataExtractor (typically for an in-memory copy of an object-file section) plus a relocation map for...
static ErrorSuccess success()
Create a success value.
Definition: Error.h:321
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: StringRef.h:710
#define DECLARE_OP0(OP)
void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const override
Dump the instructions in this CFI fragment.
#define LLVM_ATTRIBUTE_NORETURN
Definition: Compiler.h:209
DWARF Common Information Entry (CIE)
void setAddressSize(uint8_t Size)
Set the address size for this extractor.
Definition: DataExtractor.h:61
This file contains constants used for implementing Dwarf debug support.
DWARFDebugFrame(bool IsEH=false, uint64_t EHFrameAddress=0)
#define DECLARE_OP1(OP, OPTYPE0)
StringRef getAugmentationString() const
bool hasValue() const
Definition: Optional.h:183
uint64_t getUnsigned(uint32_t *offset_ptr, uint32_t byte_size) const
Extract an unsigned integer of size byte_size from *offset_ptr.
An instruction consists of a DWARF CFI opcode and an optional sequence of operands.
const char * getCStr(uint32_t *offset_ptr) const
Extract a C string from *offset_ptr.
bool isValidOffset(uint32_t offset) const
Test the validity of offset.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:477
static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data, uint32_t Offset, int Length)
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
Optional< DWARFExpression > Expression
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
void parse(DWARFDataExtractor Data)
Parse the section from raw data.
static void LLVM_ATTRIBUTE_NORETURN ReportError(uint32_t StartOffset, const char *ErrorMsg)
const uint64_t Version
Definition: InstrProf.h:895
const uint64_t DW64_CIE_ID
Definition: Dwarf.h:71