LLVM  12.0.0git
DWARFFormValue.cpp
Go to the documentation of this file.
1 //===- DWARFFormValue.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/ArrayRef.h"
11 #include "llvm/ADT/None.h"
12 #include "llvm/ADT/Optional.h"
13 #include "llvm/ADT/StringRef.h"
19 #include "llvm/Support/Format.h"
20 #include "llvm/Support/WithColor.h"
22 #include <cinttypes>
23 #include <cstdint>
24 #include <limits>
25 
26 using namespace llvm;
27 using namespace dwarf;
28 
31  DWARFFormValue::FC_Address, // 0x01 DW_FORM_addr
32  DWARFFormValue::FC_Unknown, // 0x02 unused
33  DWARFFormValue::FC_Block, // 0x03 DW_FORM_block2
34  DWARFFormValue::FC_Block, // 0x04 DW_FORM_block4
35  DWARFFormValue::FC_Constant, // 0x05 DW_FORM_data2
36  // --- These can be FC_SectionOffset in DWARF3 and below:
37  DWARFFormValue::FC_Constant, // 0x06 DW_FORM_data4
38  DWARFFormValue::FC_Constant, // 0x07 DW_FORM_data8
39  // ---
40  DWARFFormValue::FC_String, // 0x08 DW_FORM_string
41  DWARFFormValue::FC_Block, // 0x09 DW_FORM_block
42  DWARFFormValue::FC_Block, // 0x0a DW_FORM_block1
43  DWARFFormValue::FC_Constant, // 0x0b DW_FORM_data1
44  DWARFFormValue::FC_Flag, // 0x0c DW_FORM_flag
45  DWARFFormValue::FC_Constant, // 0x0d DW_FORM_sdata
46  DWARFFormValue::FC_String, // 0x0e DW_FORM_strp
47  DWARFFormValue::FC_Constant, // 0x0f DW_FORM_udata
48  DWARFFormValue::FC_Reference, // 0x10 DW_FORM_ref_addr
49  DWARFFormValue::FC_Reference, // 0x11 DW_FORM_ref1
50  DWARFFormValue::FC_Reference, // 0x12 DW_FORM_ref2
51  DWARFFormValue::FC_Reference, // 0x13 DW_FORM_ref4
52  DWARFFormValue::FC_Reference, // 0x14 DW_FORM_ref8
53  DWARFFormValue::FC_Reference, // 0x15 DW_FORM_ref_udata
54  DWARFFormValue::FC_Indirect, // 0x16 DW_FORM_indirect
55  DWARFFormValue::FC_SectionOffset, // 0x17 DW_FORM_sec_offset
56  DWARFFormValue::FC_Exprloc, // 0x18 DW_FORM_exprloc
57  DWARFFormValue::FC_Flag, // 0x19 DW_FORM_flag_present
58  DWARFFormValue::FC_String, // 0x1a DW_FORM_strx
59  DWARFFormValue::FC_Address, // 0x1b DW_FORM_addrx
60  DWARFFormValue::FC_Reference, // 0x1c DW_FORM_ref_sup4
61  DWARFFormValue::FC_String, // 0x1d DW_FORM_strp_sup
62  DWARFFormValue::FC_Constant, // 0x1e DW_FORM_data16
63  DWARFFormValue::FC_String, // 0x1f DW_FORM_line_strp
64  DWARFFormValue::FC_Reference, // 0x20 DW_FORM_ref_sig8
65  DWARFFormValue::FC_Constant, // 0x21 DW_FORM_implicit_const
66  DWARFFormValue::FC_SectionOffset, // 0x22 DW_FORM_loclistx
67  DWARFFormValue::FC_SectionOffset, // 0x23 DW_FORM_rnglistx
68  DWARFFormValue::FC_Reference, // 0x24 DW_FORM_ref_sup8
69  DWARFFormValue::FC_String, // 0x25 DW_FORM_strx1
70  DWARFFormValue::FC_String, // 0x26 DW_FORM_strx2
71  DWARFFormValue::FC_String, // 0x27 DW_FORM_strx3
72  DWARFFormValue::FC_String, // 0x28 DW_FORM_strx4
73  DWARFFormValue::FC_Address, // 0x29 DW_FORM_addrx1
74  DWARFFormValue::FC_Address, // 0x2a DW_FORM_addrx2
75  DWARFFormValue::FC_Address, // 0x2b DW_FORM_addrx3
76  DWARFFormValue::FC_Address, // 0x2c DW_FORM_addrx4
77 
78 };
79 
81  return DWARFFormValue(F, ValueType(V));
82 }
83 
85  return DWARFFormValue(F, ValueType(V));
86 }
87 
89  return DWARFFormValue(F, ValueType(V));
90 }
91 
94  ValueType V;
95  V.uval = D.size();
96  V.data = D.data();
97  return DWARFFormValue(F, V);
98 }
99 
101  uint64_t *OffsetPtr) {
102  DWARFFormValue FormValue(F);
103  FormValue.extractValue(U->getDebugInfoExtractor(), OffsetPtr,
104  U->getFormParams(), U);
105  return FormValue;
106 }
107 
109  uint64_t *OffsetPtr,
110  const dwarf::FormParams Params) {
111  bool Indirect = false;
112  do {
113  switch (Form) {
114  // Blocks of inlined data that have a length field and the data bytes
115  // inlined in the .debug_info.
116  case DW_FORM_exprloc:
117  case DW_FORM_block: {
118  uint64_t size = DebugInfoData.getULEB128(OffsetPtr);
119  *OffsetPtr += size;
120  return true;
121  }
122  case DW_FORM_block1: {
123  uint8_t size = DebugInfoData.getU8(OffsetPtr);
124  *OffsetPtr += size;
125  return true;
126  }
127  case DW_FORM_block2: {
128  uint16_t size = DebugInfoData.getU16(OffsetPtr);
129  *OffsetPtr += size;
130  return true;
131  }
132  case DW_FORM_block4: {
133  uint32_t size = DebugInfoData.getU32(OffsetPtr);
134  *OffsetPtr += size;
135  return true;
136  }
137 
138  // Inlined NULL terminated C-strings.
139  case DW_FORM_string:
140  DebugInfoData.getCStr(OffsetPtr);
141  return true;
142 
143  case DW_FORM_addr:
144  case DW_FORM_ref_addr:
145  case DW_FORM_flag_present:
146  case DW_FORM_data1:
147  case DW_FORM_data2:
148  case DW_FORM_data4:
149  case DW_FORM_data8:
150  case DW_FORM_data16:
151  case DW_FORM_flag:
152  case DW_FORM_ref1:
153  case DW_FORM_ref2:
154  case DW_FORM_ref4:
155  case DW_FORM_ref8:
156  case DW_FORM_ref_sig8:
157  case DW_FORM_ref_sup4:
158  case DW_FORM_ref_sup8:
159  case DW_FORM_strx1:
160  case DW_FORM_strx2:
161  case DW_FORM_strx4:
162  case DW_FORM_addrx1:
163  case DW_FORM_addrx2:
164  case DW_FORM_addrx4:
165  case DW_FORM_sec_offset:
166  case DW_FORM_strp:
167  case DW_FORM_strp_sup:
168  case DW_FORM_line_strp:
169  case DW_FORM_GNU_ref_alt:
170  case DW_FORM_GNU_strp_alt:
171  if (Optional<uint8_t> FixedSize =
172  dwarf::getFixedFormByteSize(Form, Params)) {
173  *OffsetPtr += *FixedSize;
174  return true;
175  }
176  return false;
177 
178  // signed or unsigned LEB 128 values.
179  case DW_FORM_sdata:
180  DebugInfoData.getSLEB128(OffsetPtr);
181  return true;
182 
183  case DW_FORM_udata:
184  case DW_FORM_ref_udata:
185  case DW_FORM_strx:
186  case DW_FORM_addrx:
187  case DW_FORM_loclistx:
188  case DW_FORM_rnglistx:
189  case DW_FORM_GNU_addr_index:
190  case DW_FORM_GNU_str_index:
191  DebugInfoData.getULEB128(OffsetPtr);
192  return true;
193 
194  case DW_FORM_indirect:
195  Indirect = true;
196  Form = static_cast<dwarf::Form>(DebugInfoData.getULEB128(OffsetPtr));
197  break;
198 
199  default:
200  return false;
201  }
202  } while (Indirect);
203  return true;
204 }
205 
207  // First, check DWARF5 form classes.
209  DWARF5FormClasses[Form] == FC)
210  return true;
211  // Check more forms from extensions and proposals.
212  switch (Form) {
213  case DW_FORM_GNU_ref_alt:
214  return (FC == FC_Reference);
215  case DW_FORM_GNU_addr_index:
216  return (FC == FC_Address);
217  case DW_FORM_GNU_str_index:
218  case DW_FORM_GNU_strp_alt:
219  return (FC == FC_String);
220  default:
221  break;
222  }
223 
224  if (FC == FC_SectionOffset) {
225  if (Form == DW_FORM_strp || Form == DW_FORM_line_strp)
226  return true;
227  // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section
228  // offset. If we don't have a DWARFUnit, default to the old behavior.
229  if (Form == DW_FORM_data4 || Form == DW_FORM_data8)
230  return !U || U->getVersion() <= 3;
231  }
232 
233  return false;
234 }
235 
237  uint64_t *OffsetPtr, dwarf::FormParams FP,
238  const DWARFContext *Ctx,
239  const DWARFUnit *CU) {
240  if (!Ctx && CU)
241  Ctx = &CU->getContext();
242  C = Ctx;
243  U = CU;
244  Format = FP.Format;
245  bool Indirect = false;
246  bool IsBlock = false;
247  Value.data = nullptr;
248  // Read the value for the form into value and follow and DW_FORM_indirect
249  // instances we run into
250  Error Err = Error::success();
251  do {
252  Indirect = false;
253  switch (Form) {
254  case DW_FORM_addr:
255  case DW_FORM_ref_addr: {
256  uint16_t Size =
257  (Form == DW_FORM_addr) ? FP.AddrSize : FP.getRefAddrByteSize();
258  Value.uval =
259  Data.getRelocatedValue(Size, OffsetPtr, &Value.SectionIndex, &Err);
260  break;
261  }
262  case DW_FORM_exprloc:
263  case DW_FORM_block:
264  Value.uval = Data.getULEB128(OffsetPtr, &Err);
265  IsBlock = true;
266  break;
267  case DW_FORM_block1:
268  Value.uval = Data.getU8(OffsetPtr, &Err);
269  IsBlock = true;
270  break;
271  case DW_FORM_block2:
272  Value.uval = Data.getU16(OffsetPtr, &Err);
273  IsBlock = true;
274  break;
275  case DW_FORM_block4:
276  Value.uval = Data.getU32(OffsetPtr, &Err);
277  IsBlock = true;
278  break;
279  case DW_FORM_data1:
280  case DW_FORM_ref1:
281  case DW_FORM_flag:
282  case DW_FORM_strx1:
283  case DW_FORM_addrx1:
284  Value.uval = Data.getU8(OffsetPtr, &Err);
285  break;
286  case DW_FORM_data2:
287  case DW_FORM_ref2:
288  case DW_FORM_strx2:
289  case DW_FORM_addrx2:
290  Value.uval = Data.getU16(OffsetPtr, &Err);
291  break;
292  case DW_FORM_strx3:
293  Value.uval = Data.getU24(OffsetPtr, &Err);
294  break;
295  case DW_FORM_data4:
296  case DW_FORM_ref4:
297  case DW_FORM_ref_sup4:
298  case DW_FORM_strx4:
299  case DW_FORM_addrx4:
300  Value.uval = Data.getRelocatedValue(4, OffsetPtr, nullptr, &Err);
301  break;
302  case DW_FORM_data8:
303  case DW_FORM_ref8:
304  case DW_FORM_ref_sup8:
305  Value.uval = Data.getRelocatedValue(8, OffsetPtr, nullptr, &Err);
306  break;
307  case DW_FORM_data16:
308  // Treat this like a 16-byte block.
309  Value.uval = 16;
310  IsBlock = true;
311  break;
312  case DW_FORM_sdata:
313  Value.sval = Data.getSLEB128(OffsetPtr, &Err);
314  break;
315  case DW_FORM_udata:
316  case DW_FORM_ref_udata:
317  case DW_FORM_rnglistx:
318  case DW_FORM_loclistx:
319  case DW_FORM_GNU_addr_index:
320  case DW_FORM_GNU_str_index:
321  case DW_FORM_addrx:
322  case DW_FORM_strx:
323  Value.uval = Data.getULEB128(OffsetPtr, &Err);
324  break;
325  case DW_FORM_string:
326  Value.cstr = Data.getCStr(OffsetPtr, &Err);
327  break;
328  case DW_FORM_indirect:
329  Form = static_cast<dwarf::Form>(Data.getULEB128(OffsetPtr, &Err));
330  Indirect = true;
331  break;
332  case DW_FORM_strp:
333  case DW_FORM_sec_offset:
334  case DW_FORM_GNU_ref_alt:
335  case DW_FORM_GNU_strp_alt:
336  case DW_FORM_line_strp:
337  case DW_FORM_strp_sup: {
339  OffsetPtr, nullptr, &Err);
340  break;
341  }
342  case DW_FORM_flag_present:
343  Value.uval = 1;
344  break;
345  case DW_FORM_ref_sig8:
346  Value.uval = Data.getU64(OffsetPtr, &Err);
347  break;
348  default:
349  // DWARFFormValue::skipValue() will have caught this and caused all
350  // DWARF DIEs to fail to be parsed, so this code is not be reachable.
351  llvm_unreachable("unsupported form");
352  }
353  } while (Indirect && !Err);
354 
355  if (IsBlock)
356  Value.data = Data.getBytes(OffsetPtr, Value.uval, &Err).bytes_begin();
357 
358  return !errorToBool(std::move(Err));
359 }
360 
362  DIDumpOptions DumpOpts,
363  object::SectionedAddress SA) const {
364  OS << format("0x%016" PRIx64, SA.Address);
365  dumpAddressSection(U->getContext().getDWARFObj(), OS, DumpOpts,
366  SA.SectionIndex);
367 }
368 
370  DIDumpOptions DumpOpts,
371  uint64_t SectionIndex) {
372  if (!DumpOpts.Verbose || SectionIndex == -1ULL)
373  return;
374  ArrayRef<SectionName> SectionNames = Obj.getSectionNames();
375  const auto &SecRef = SectionNames[SectionIndex];
376 
377  OS << " \"" << SecRef.Name << '\"';
378 
379  // Print section index if name is not unique.
380  if (!SecRef.IsNameUnique)
381  OS << format(" [%" PRIu64 "]", SectionIndex);
382 }
383 
384 void DWARFFormValue::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
385  uint64_t UValue = Value.uval;
386  bool CURelativeOffset = false;
387  raw_ostream &AddrOS = DumpOpts.ShowAddresses
389  : nulls();
390  int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(Format);
391  switch (Form) {
392  case DW_FORM_addr:
393  dumpSectionedAddress(AddrOS, DumpOpts, {Value.uval, Value.SectionIndex});
394  break;
395  case DW_FORM_addrx:
396  case DW_FORM_addrx1:
397  case DW_FORM_addrx2:
398  case DW_FORM_addrx3:
399  case DW_FORM_addrx4:
400  case DW_FORM_GNU_addr_index: {
401  if (U == nullptr) {
402  OS << "<invalid dwarf unit>";
403  break;
404  }
405  Optional<object::SectionedAddress> A = U->getAddrOffsetSectionItem(UValue);
406  if (!A || DumpOpts.Verbose)
407  AddrOS << format("indexed (%8.8x) address = ", (uint32_t)UValue);
408  if (A)
409  dumpSectionedAddress(AddrOS, DumpOpts, *A);
410  else
411  OS << "<unresolved>";
412  break;
413  }
414  case DW_FORM_flag_present:
415  OS << "true";
416  break;
417  case DW_FORM_flag:
418  case DW_FORM_data1:
419  OS << format("0x%02x", (uint8_t)UValue);
420  break;
421  case DW_FORM_data2:
422  OS << format("0x%04x", (uint16_t)UValue);
423  break;
424  case DW_FORM_data4:
425  OS << format("0x%08x", (uint32_t)UValue);
426  break;
427  case DW_FORM_ref_sig8:
428  AddrOS << format("0x%016" PRIx64, UValue);
429  break;
430  case DW_FORM_data8:
431  OS << format("0x%016" PRIx64, UValue);
432  break;
433  case DW_FORM_data16:
434  OS << format_bytes(ArrayRef<uint8_t>(Value.data, 16), None, 16, 16);
435  break;
436  case DW_FORM_string:
437  OS << '"';
438  OS.write_escaped(Value.cstr);
439  OS << '"';
440  break;
441  case DW_FORM_exprloc:
442  case DW_FORM_block:
443  case DW_FORM_block1:
444  case DW_FORM_block2:
445  case DW_FORM_block4:
446  if (UValue > 0) {
447  switch (Form) {
448  case DW_FORM_exprloc:
449  case DW_FORM_block:
450  AddrOS << format("<0x%" PRIx64 "> ", UValue);
451  break;
452  case DW_FORM_block1:
453  AddrOS << format("<0x%2.2x> ", (uint8_t)UValue);
454  break;
455  case DW_FORM_block2:
456  AddrOS << format("<0x%4.4x> ", (uint16_t)UValue);
457  break;
458  case DW_FORM_block4:
459  AddrOS << format("<0x%8.8x> ", (uint32_t)UValue);
460  break;
461  default:
462  break;
463  }
464 
465  const uint8_t *DataPtr = Value.data;
466  if (DataPtr) {
467  // UValue contains size of block
468  const uint8_t *EndDataPtr = DataPtr + UValue;
469  while (DataPtr < EndDataPtr) {
470  AddrOS << format("%2.2x ", *DataPtr);
471  ++DataPtr;
472  }
473  } else
474  OS << "NULL";
475  }
476  break;
477 
478  case DW_FORM_sdata:
479  OS << Value.sval;
480  break;
481  case DW_FORM_udata:
482  OS << Value.uval;
483  break;
484  case DW_FORM_strp:
485  if (DumpOpts.Verbose)
486  OS << format(" .debug_str[0x%0*" PRIx64 "] = ", OffsetDumpWidth, UValue);
487  dumpString(OS);
488  break;
489  case DW_FORM_line_strp:
490  if (DumpOpts.Verbose)
491  OS << format(" .debug_line_str[0x%0*" PRIx64 "] = ", OffsetDumpWidth,
492  UValue);
493  dumpString(OS);
494  break;
495  case DW_FORM_strx:
496  case DW_FORM_strx1:
497  case DW_FORM_strx2:
498  case DW_FORM_strx3:
499  case DW_FORM_strx4:
500  case DW_FORM_GNU_str_index:
501  if (DumpOpts.Verbose)
502  OS << format("indexed (%8.8x) string = ", (uint32_t)UValue);
503  dumpString(OS);
504  break;
505  case DW_FORM_GNU_strp_alt:
506  if (DumpOpts.Verbose)
507  OS << format("alt indirect string, offset: 0x%" PRIx64 "", UValue);
508  dumpString(OS);
509  break;
510  case DW_FORM_ref_addr:
511  AddrOS << format("0x%016" PRIx64, UValue);
512  break;
513  case DW_FORM_ref1:
514  CURelativeOffset = true;
515  if (DumpOpts.Verbose)
516  AddrOS << format("cu + 0x%2.2x", (uint8_t)UValue);
517  break;
518  case DW_FORM_ref2:
519  CURelativeOffset = true;
520  if (DumpOpts.Verbose)
521  AddrOS << format("cu + 0x%4.4x", (uint16_t)UValue);
522  break;
523  case DW_FORM_ref4:
524  CURelativeOffset = true;
525  if (DumpOpts.Verbose)
526  AddrOS << format("cu + 0x%4.4x", (uint32_t)UValue);
527  break;
528  case DW_FORM_ref8:
529  CURelativeOffset = true;
530  if (DumpOpts.Verbose)
531  AddrOS << format("cu + 0x%8.8" PRIx64, UValue);
532  break;
533  case DW_FORM_ref_udata:
534  CURelativeOffset = true;
535  if (DumpOpts.Verbose)
536  AddrOS << format("cu + 0x%" PRIx64, UValue);
537  break;
538  case DW_FORM_GNU_ref_alt:
539  AddrOS << format("<alt 0x%" PRIx64 ">", UValue);
540  break;
541 
542  // All DW_FORM_indirect attributes should be resolved prior to calling
543  // this function
544  case DW_FORM_indirect:
545  OS << "DW_FORM_indirect";
546  break;
547 
548  case DW_FORM_rnglistx:
549  OS << format("indexed (0x%x) rangelist = ", (uint32_t)UValue);
550  break;
551 
552  case DW_FORM_loclistx:
553  OS << format("indexed (0x%x) loclist = ", (uint32_t)UValue);
554  break;
555 
556  case DW_FORM_sec_offset:
557  AddrOS << format("0x%0*" PRIx64, OffsetDumpWidth, UValue);
558  break;
559 
560  default:
561  OS << format("DW_FORM(0x%4.4x)", Form);
562  break;
563  }
564 
565  if (CURelativeOffset) {
566  if (DumpOpts.Verbose)
567  OS << " => {";
568  if (DumpOpts.ShowAddresses)
570  << format("0x%8.8" PRIx64, UValue + (U ? U->getOffset() : 0));
571  if (DumpOpts.Verbose)
572  OS << "}";
573  }
574 }
575 
576 void DWARFFormValue::dumpString(raw_ostream &OS) const {
577  Optional<const char *> DbgStr = getAsCString();
578  if (DbgStr.hasValue()) {
579  auto COS = WithColor(OS, HighlightColor::String);
580  COS.get() << '"';
581  COS.get().write_escaped(DbgStr.getValue());
582  COS.get() << '"';
583  }
584 }
585 
587  if (!isFormClass(FC_String))
588  return None;
589  if (Form == DW_FORM_string)
590  return Value.cstr;
591  // FIXME: Add support for DW_FORM_GNU_strp_alt
592  if (Form == DW_FORM_GNU_strp_alt || C == nullptr)
593  return None;
594  uint64_t Offset = Value.uval;
595  if (Form == DW_FORM_line_strp) {
596  // .debug_line_str is tracked in the Context.
597  if (const char *Str = C->getLineStringExtractor().getCStr(&Offset))
598  return Str;
599  return None;
600  }
601  if (Form == DW_FORM_GNU_str_index || Form == DW_FORM_strx ||
602  Form == DW_FORM_strx1 || Form == DW_FORM_strx2 || Form == DW_FORM_strx3 ||
603  Form == DW_FORM_strx4) {
604  if (!U)
605  return None;
606  Optional<uint64_t> StrOffset = U->getStringOffsetSectionItem(Offset);
607  if (!StrOffset)
608  return None;
609  Offset = *StrOffset;
610  }
611  // Prefer the Unit's string extractor, because for .dwo it will point to
612  // .debug_str.dwo, while the Context's extractor always uses .debug_str.
613  if (U) {
614  if (const char *Str = U->getStringExtractor().getCStr(&Offset))
615  return Str;
616  return None;
617  }
618  if (const char *Str = C->getStringExtractor().getCStr(&Offset))
619  return Str;
620  return None;
621 }
622 
624  if (auto SA = getAsSectionedAddress())
625  return SA->Address;
626  return None;
627 }
628 
631  if (!isFormClass(FC_Address))
632  return None;
633  if (Form == DW_FORM_GNU_addr_index || Form == DW_FORM_addrx) {
634  uint32_t Index = Value.uval;
635  if (!U)
636  return None;
637  Optional<object::SectionedAddress> SA = U->getAddrOffsetSectionItem(Index);
638  if (!SA)
639  return None;
640  return SA;
641  }
642  return {{Value.uval, Value.SectionIndex}};
643 }
644 
646  if (auto R = getAsRelativeReference())
647  return R->Unit ? R->Unit->getOffset() + R->Offset : R->Offset;
648  return None;
649 }
650 
652  if (!isFormClass(FC_Reference))
653  return None;
654  switch (Form) {
655  case DW_FORM_ref1:
656  case DW_FORM_ref2:
657  case DW_FORM_ref4:
658  case DW_FORM_ref8:
659  case DW_FORM_ref_udata:
660  if (!U)
661  return None;
662  return UnitOffset{const_cast<DWARFUnit*>(U), Value.uval};
663  case DW_FORM_ref_addr:
664  case DW_FORM_ref_sig8:
665  case DW_FORM_GNU_ref_alt:
666  return UnitOffset{nullptr, Value.uval};
667  default:
668  return None;
669  }
670 }
671 
673  if (!isFormClass(FC_SectionOffset))
674  return None;
675  return Value.uval;
676 }
677 
679  if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag)) ||
680  Form == DW_FORM_sdata)
681  return None;
682  return Value.uval;
683 }
684 
686  if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag)) ||
687  (Form == DW_FORM_udata &&
688  uint64_t(std::numeric_limits<int64_t>::max()) < Value.uval))
689  return None;
690  switch (Form) {
691  case DW_FORM_data4:
692  return int32_t(Value.uval);
693  case DW_FORM_data2:
694  return int16_t(Value.uval);
695  case DW_FORM_data1:
696  return int8_t(Value.uval);
697  case DW_FORM_sdata:
698  case DW_FORM_data8:
699  default:
700  return Value.sval;
701  }
702 }
703 
705  if (!isFormClass(FC_Block) && !isFormClass(FC_Exprloc) &&
706  Form != DW_FORM_data16)
707  return None;
708  return makeArrayRef(Value.data, Value.uval);
709 }
710 
712  if (!isFormClass(FC_String) && Form == DW_FORM_string)
713  return None;
714  return Value.uval;
715 }
716 
718  if (!isFormClass(FC_Reference))
719  return None;
720  return Value.uval;
721 }
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.
A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...
Definition: Dwarf.h:554
PointerUnion< const Value *, const PseudoSourceValue * > ValueType
uint16_t getU16(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint16_t value from *offset_ptr.
Optional< UnitOffset > getAsRelativeReference() const
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static const DWARFFormValue::FormClass DWARF5FormClasses[]
An RAII object that temporarily switches an output stream to a specific color.
Definition: WithColor.h:53
static DWARFFormValue createFromBlockValue(dwarf::Form F, ArrayRef< uint8_t > D)
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
uint8_t getRefAddrByteSize() const
The definition of the size of form DW_FORM_ref_addr depends on the version.
Definition: Dwarf.h:562
uint32_t getU32(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint32_t value from *offset_ptr.
F(f)
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.
bool isFormClass(FormClass FC) const
const dwarf::FormParams & getFormParams() const
Definition: DWARFUnit.h:284
static DWARFFormValue createFromUnit(dwarf::Form F, const DWARFUnit *Unit, uint64_t *OffsetPtr)
Optional< uint64_t > getAsReference() const
getAsFoo functions below return the extracted value as Foo if only DWARFFormValue has form class is s...
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:458
Optional< ArrayRef< uint8_t > > getAsBlock() const
int64_t getSLEB128(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a signed LEB128 value from *offset_ptr.
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...
Container for dump options that control which debug information will be dumped.
Definition: DIContext.h:181
raw_ostream & get()
Definition: WithColor.h:80
void dumpSectionedAddress(raw_ostream &OS, DIDumpOptions DumpOpts, object::SectionedAddress SA) const
Optional< object::SectionedAddress > getAsSectionedAddress() const
const char * getCStr(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a C string from *offset_ptr.
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:156
bool errorToBool(Error Err)
Helper for converting an Error to a bool.
Definition: Error.h:1029
static void dumpAddressSection(const DWARFObject &Obj, raw_ostream &OS, DIDumpOptions DumpOpts, uint64_t SectionIndex)
Optional< uint64_t > getAsAddress() const
Optional< uint64_t > getAsUnsignedConstant() const
DWARFContext & getContext() const
Definition: DWARFUnit.h:281
static DWARFFormValue createFromUValue(dwarf::Form F, uint64_t V)
uint64_t getULEB128(uint64_t *offset_ptr, llvm::Error *Err=nullptr) const
Extract a unsigned LEB128 value from *offset_ptr.
StringRef getBytes(uint64_t *OffsetPtr, uint64_t Length, Error *Err=nullptr) const
Extract a fixed number of bytes from the specified offset.
Optional< uint64_t > getAsReferenceUVal() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const T * data() const
Definition: ArrayRef.h:153
A DataExtractor (typically for an in-memory copy of an object-file section) plus a relocation map for...
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning &#39;\&#39;, &#39;&#39;, &#39; &#39;, &#39;"&#39;, and anything that doesn&#39;t satisfy llvm::isPrint into an escape...
static ErrorSuccess success()
Create a success value.
Definition: Error.h:332
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:350
DWARFContext This data structure is the top level entity that deals with dwarf debug information pars...
Definition: DWARFContext.h:53
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Optional< uint64_t > getAsCStringOffset() const
auto size(R &&Range, std::enable_if_t< std::is_same< typename std::iterator_traits< decltype(Range.begin())>::iterator_category, std::random_access_iterator_tag >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1473
This file contains constants used for implementing Dwarf debug support.
DWARFDataExtractor getDebugInfoExtractor() const
Definition: DWARFUnit.cpp:213
static DWARFFormValue createFromPValue(dwarf::Form F, const char *V)
Optional< uint8_t > getFixedFormByteSize(dwarf::Form Form, FormParams Params)
Get the fixed byte size for a given form.
Definition: Dwarf.cpp:677
uint32_t getU24(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a 24-bit unsigned value from *offset_ptr and return it in a uint32_t.
bool hasValue() const
Definition: Optional.h:259
uint8_t getDwarfOffsetByteSize(DwarfFormat Format)
The size of a reference determined by the DWARF 32/64-bit format.
Definition: Dwarf.h:541
const unsigned char * bytes_begin() const
Definition: StringRef.h:135
Optional< const char * > getAsCString() const
virtual ArrayRef< SectionName > getSectionNames() const
Definition: DWARFObject.h:32
uint32_t Size
Definition: Profile.cpp:46
Optional< int64_t > getAsSignedConstant() const
DwarfFormat Format
Definition: Dwarf.h:557
LLVM Value Representation.
Definition: Value.h:74
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
raw_ostream & nulls()
This returns a reference to a raw_ostream which simply discards output.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
uint64_t getU64(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint64_t value from *offset_ptr.
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.
static DWARFFormValue createFromSValue(dwarf::Form F, int64_t V)
uint8_t getDwarfOffsetByteSize() const
The size of a reference is determined by the DWARF 32/64-bit format.
Definition: Dwarf.h:569
Optional< uint64_t > getAsSectionOffset() const