LLVM  13.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 
9 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
10 #include "llvm/ADT/ArrayRef.h"
11 #include "llvm/ADT/None.h"
12 #include "llvm/ADT/Optional.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/BinaryFormat/Dwarf.h"
15 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
16 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
17 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
18 #include "llvm/Support/ErrorHandling.h"
19 #include "llvm/Support/Format.h"
20 #include "llvm/Support/WithColor.h"
21 #include "llvm/Support/raw_ostream.h"
22 #include <cinttypes>
23 #include <cstdint>
24 #include <limits>
25 
26 using namespace llvm;
27 using namespace dwarf;
28 
29 static const DWARFFormValue::FormClass DWARF5FormClasses[] = {
30  DWARFFormValue::FC_Unknown, // 0x0
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  DWARFFormValue::FC_Address, // 0x2001 DW_FORM_addrx_offset
78 };
79 
80 DWARFFormValue DWARFFormValue::createFromSValue(dwarf::Form F, int64_t V) {
81  return DWARFFormValue(F, ValueType(V));
82 }
83 
84 DWARFFormValue DWARFFormValue::createFromUValue(dwarf::Form F, uint64_t V) {
85  return DWARFFormValue(F, ValueType(V));
86 }
87 
88 DWARFFormValue DWARFFormValue::createFromPValue(dwarf::Form F, const char *V) {
89  return DWARFFormValue(F, ValueType(V));
90 }
91 
92 DWARFFormValue DWARFFormValue::createFromBlockValue(dwarf::Form F,
93  ArrayRef<uint8_t> D) {
94  ValueType V;
95  V.uval = D.size();
96  V.data = D.data();
97  return DWARFFormValue(F, V);
98 }
99 
100 DWARFFormValue DWARFFormValue::createFromUnit(dwarf::Form F, const DWARFUnit *U,
101  uint64_t *OffsetPtr) {
102  DWARFFormValue FormValue(F);
103  FormValue.extractValue(U->getDebugInfoExtractor(), OffsetPtr,
104  U->getFormParams(), U);
105  return FormValue;
106 }
107 
108 bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
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  case DW_FORM_implicit_const:
172  if (Optional<uint8_t> FixedSize =
173  dwarf::getFixedFormByteSize(Form, Params)) {
174  *OffsetPtr += *FixedSize;
175  return true;
176  }
177  return false;
178 
179  // signed or unsigned LEB 128 values.
180  case DW_FORM_sdata:
181  DebugInfoData.getSLEB128(OffsetPtr);
182  return true;
183 
184  case DW_FORM_udata:
185  case DW_FORM_ref_udata:
186  case DW_FORM_strx:
187  case DW_FORM_addrx:
188  case DW_FORM_loclistx:
189  case DW_FORM_rnglistx:
190  case DW_FORM_GNU_addr_index:
191  case DW_FORM_GNU_str_index:
192  DebugInfoData.getULEB128(OffsetPtr);
193  return true;
194 
195  case DW_FORM_LLVM_addrx_offset:
196  DebugInfoData.getULEB128(OffsetPtr);
197  *OffsetPtr += 4;
198  return true;
199 
200  case DW_FORM_indirect:
201  Indirect = true;
202  Form = static_cast<dwarf::Form>(DebugInfoData.getULEB128(OffsetPtr));
203  break;
204 
205  default:
206  return false;
207  }
208  } while (Indirect);
209  return true;
210 }
211 
212 bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
213  // First, check DWARF5 form classes.
214  if (Form < makeArrayRef(DWARF5FormClasses).size() &&
215  DWARF5FormClasses[Form] == FC)
216  return true;
217  // Check more forms from extensions and proposals.
218  switch (Form) {
219  case DW_FORM_GNU_ref_alt:
220  return (FC == FC_Reference);
221  case DW_FORM_GNU_addr_index:
222  return (FC == FC_Address);
223  case DW_FORM_GNU_str_index:
224  case DW_FORM_GNU_strp_alt:
225  return (FC == FC_String);
226  case DW_FORM_LLVM_addrx_offset:
227  return (FC == FC_Address);
228  default:
229  break;
230  }
231 
232  if (FC == FC_SectionOffset) {
233  if (Form == DW_FORM_strp || Form == DW_FORM_line_strp)
234  return true;
235  // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section
236  // offset. If we don't have a DWARFUnit, default to the old behavior.
237  if (Form == DW_FORM_data4 || Form == DW_FORM_data8)
238  return !U || U->getVersion() <= 3;
239  }
240 
241  return false;
242 }
243 
244 bool DWARFFormValue::extractValue(const DWARFDataExtractor &Data,
245  uint64_t *OffsetPtr, dwarf::FormParams FP,
246  const DWARFContext *Ctx,
247  const DWARFUnit *CU) {
248  if (!Ctx && CU)
249  Ctx = &CU->getContext();
250  C = Ctx;
251  U = CU;
252  Format = FP.Format;
253  bool Indirect = false;
254  bool IsBlock = false;
255  Value.data = nullptr;
256  // Read the value for the form into value and follow and DW_FORM_indirect
257  // instances we run into
258  Error Err = Error::success();
259  do {
260  Indirect = false;
261  switch (Form) {
262  case DW_FORM_addr:
263  case DW_FORM_ref_addr: {
264  uint16_t Size =
265  (Form == DW_FORM_addr) ? FP.AddrSize : FP.getRefAddrByteSize();
266  Value.uval =
267  Data.getRelocatedValue(Size, OffsetPtr, &Value.SectionIndex, &Err);
268  break;
269  }
270  case DW_FORM_exprloc:
271  case DW_FORM_block:
272  Value.uval = Data.getULEB128(OffsetPtr, &Err);
273  IsBlock = true;
274  break;
275  case DW_FORM_block1:
276  Value.uval = Data.getU8(OffsetPtr, &Err);
277  IsBlock = true;
278  break;
279  case DW_FORM_block2:
280  Value.uval = Data.getU16(OffsetPtr, &Err);
281  IsBlock = true;
282  break;
283  case DW_FORM_block4:
284  Value.uval = Data.getU32(OffsetPtr, &Err);
285  IsBlock = true;
286  break;
287  case DW_FORM_data1:
288  case DW_FORM_ref1:
289  case DW_FORM_flag:
290  case DW_FORM_strx1:
291  case DW_FORM_addrx1:
292  Value.uval = Data.getU8(OffsetPtr, &Err);
293  break;
294  case DW_FORM_data2:
295  case DW_FORM_ref2:
296  case DW_FORM_strx2:
297  case DW_FORM_addrx2:
298  Value.uval = Data.getU16(OffsetPtr, &Err);
299  break;
300  case DW_FORM_strx3:
301  Value.uval = Data.getU24(OffsetPtr, &Err);
302  break;
303  case DW_FORM_data4:
304  case DW_FORM_ref4:
305  case DW_FORM_ref_sup4:
306  case DW_FORM_strx4:
307  case DW_FORM_addrx4:
308  Value.uval = Data.getRelocatedValue(4, OffsetPtr, nullptr, &Err);
309  break;
310  case DW_FORM_data8:
311  case DW_FORM_ref8:
312  case DW_FORM_ref_sup8:
313  Value.uval = Data.getRelocatedValue(8, OffsetPtr, nullptr, &Err);
314  break;
315  case DW_FORM_data16:
316  // Treat this like a 16-byte block.
317  Value.uval = 16;
318  IsBlock = true;
319  break;
320  case DW_FORM_sdata:
321  Value.sval = Data.getSLEB128(OffsetPtr, &Err);
322  break;
323  case DW_FORM_udata:
324  case DW_FORM_ref_udata:
325  case DW_FORM_rnglistx:
326  case DW_FORM_loclistx:
327  case DW_FORM_GNU_addr_index:
328  case DW_FORM_GNU_str_index:
329  case DW_FORM_addrx:
330  case DW_FORM_strx:
331  Value.uval = Data.getULEB128(OffsetPtr, &Err);
332  break;
333  case DW_FORM_LLVM_addrx_offset:
334  Value.uval = Data.getULEB128(OffsetPtr, &Err) << 32;
335  Value.uval = Data.getU32(OffsetPtr, &Err);
336  break;
337  case DW_FORM_string:
338  Value.cstr = Data.getCStr(OffsetPtr, &Err);
339  break;
340  case DW_FORM_indirect:
341  Form = static_cast<dwarf::Form>(Data.getULEB128(OffsetPtr, &Err));
342  Indirect = true;
343  break;
344  case DW_FORM_strp:
345  case DW_FORM_sec_offset:
346  case DW_FORM_GNU_ref_alt:
347  case DW_FORM_GNU_strp_alt:
348  case DW_FORM_line_strp:
349  case DW_FORM_strp_sup: {
350  Value.uval = Data.getRelocatedValue(FP.getDwarfOffsetByteSize(),
351  OffsetPtr, nullptr, &Err);
352  break;
353  }
354  case DW_FORM_flag_present:
355  Value.uval = 1;
356  break;
357  case DW_FORM_ref_sig8:
358  Value.uval = Data.getU64(OffsetPtr, &Err);
359  break;
360  case DW_FORM_implicit_const:
361  // Value has been already set by DWARFFormValue::createFromSValue.
362  break;
363  default:
364  // DWARFFormValue::skipValue() will have caught this and caused all
365  // DWARF DIEs to fail to be parsed, so this code is not be reachable.
366  llvm_unreachable("unsupported form");
367  }
368  } while (Indirect && !Err);
369 
370  if (IsBlock)
371  Value.data = Data.getBytes(OffsetPtr, Value.uval, &Err).bytes_begin();
372 
373  return !errorToBool(std::move(Err));
374 }
375 
376 void DWARFFormValue::dumpAddress(raw_ostream &OS, uint8_t AddressSize,
377  uint64_t Address) {
378  uint8_t HexDigits = AddressSize * 2;
379  OS << format("0x%*.*" PRIx64, HexDigits, HexDigits, Address);
380 }
381 
382 void DWARFFormValue::dumpSectionedAddress(raw_ostream &OS,
383  DIDumpOptions DumpOpts,
384  object::SectionedAddress SA) const {
385  dumpAddress(OS, U->getAddressByteSize(), SA.Address);
386  dumpAddressSection(U->getContext().getDWARFObj(), OS, DumpOpts,
387  SA.SectionIndex);
388 }
389 
390 void DWARFFormValue::dumpAddressSection(const DWARFObject &Obj, raw_ostream &OS,
391  DIDumpOptions DumpOpts,
392  uint64_t SectionIndex) {
393  if (!DumpOpts.Verbose || SectionIndex == -1ULL)
394  return;
395  ArrayRef<SectionName> SectionNames = Obj.getSectionNames();
396  const auto &SecRef = SectionNames[SectionIndex];
397 
398  OS << " \"" << SecRef.Name << '\"';
399 
400  // Print section index if name is not unique.
401  if (!SecRef.IsNameUnique)
402  OS << format(" [%" PRIu64 "]", SectionIndex);
403 }
404 
405 void DWARFFormValue::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
406  uint64_t UValue = Value.uval;
407  bool CURelativeOffset = false;
408  raw_ostream &AddrOS = DumpOpts.ShowAddresses
409  ? WithColor(OS, HighlightColor::Address).get()
410  : nulls();
411  int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(Format);
412  switch (Form) {
413  case DW_FORM_addr:
414  dumpSectionedAddress(AddrOS, DumpOpts, {Value.uval, Value.SectionIndex});
415  break;
416  case DW_FORM_addrx:
417  case DW_FORM_addrx1:
418  case DW_FORM_addrx2:
419  case DW_FORM_addrx3:
420  case DW_FORM_addrx4:
421  case DW_FORM_GNU_addr_index: {
422  if (U == nullptr) {
423  OS << "<invalid dwarf unit>";
424  break;
425  }
426  Optional<object::SectionedAddress> A = U->getAddrOffsetSectionItem(UValue);
427  if (!A || DumpOpts.Verbose)
428  AddrOS << format("indexed (%8.8x) address = ", (uint32_t)UValue);
429  if (A)
430  dumpSectionedAddress(AddrOS, DumpOpts, *A);
431  else
432  OS << "<unresolved>";
433  break;
434  }
435  case DW_FORM_LLVM_addrx_offset: {
436  if (U == nullptr) {
437  OS << "<invalid dwarf unit>";
438  break;
439  }
440  uint32_t Index = UValue >> 32;
441  uint32_t Offset = UValue & 0xffffffff;
442  Optional<object::SectionedAddress> A = U->getAddrOffsetSectionItem(Index);
443  if (!A || DumpOpts.Verbose)
444  AddrOS << format("indexed (%8.8x) + 0x%x address = ", Index, Offset);
445  if (A) {
446  A->Address += Offset;
447  dumpSectionedAddress(AddrOS, DumpOpts, *A);
448  } else
449  OS << "<unresolved>";
450  break;
451  }
452  case DW_FORM_flag_present:
453  OS << "true";
454  break;
455  case DW_FORM_flag:
456  case DW_FORM_data1:
457  OS << format("0x%02x", (uint8_t)UValue);
458  break;
459  case DW_FORM_data2:
460  OS << format("0x%04x", (uint16_t)UValue);
461  break;
462  case DW_FORM_data4:
463  OS << format("0x%08x", (uint32_t)UValue);
464  break;
465  case DW_FORM_ref_sig8:
466  AddrOS << format("0x%016" PRIx64, UValue);
467  break;
468  case DW_FORM_data8:
469  OS << format("0x%016" PRIx64, UValue);
470  break;
471  case DW_FORM_data16:
472  OS << format_bytes(ArrayRef<uint8_t>(Value.data, 16), None, 16, 16);
473  break;
474  case DW_FORM_string:
475  OS << '"';
476  OS.write_escaped(Value.cstr);
477  OS << '"';
478  break;
479  case DW_FORM_exprloc:
480  case DW_FORM_block:
481  case DW_FORM_block1:
482  case DW_FORM_block2:
483  case DW_FORM_block4:
484  if (UValue > 0) {
485  switch (Form) {
486  case DW_FORM_exprloc:
487  case DW_FORM_block:
488  AddrOS << format("<0x%" PRIx64 "> ", UValue);
489  break;
490  case DW_FORM_block1:
491  AddrOS << format("<0x%2.2x> ", (uint8_t)UValue);
492  break;
493  case DW_FORM_block2:
494  AddrOS << format("<0x%4.4x> ", (uint16_t)UValue);
495  break;
496  case DW_FORM_block4:
497  AddrOS << format("<0x%8.8x> ", (uint32_t)UValue);
498  break;
499  default:
500  break;
501  }
502 
503  const uint8_t *DataPtr = Value.data;
504  if (DataPtr) {
505  // UValue contains size of block
506  const uint8_t *EndDataPtr = DataPtr + UValue;
507  while (DataPtr < EndDataPtr) {
508  AddrOS << format("%2.2x ", *DataPtr);
509  ++DataPtr;
510  }
511  } else
512  OS << "NULL";
513  }
514  break;
515 
516  case DW_FORM_sdata:
517  case DW_FORM_implicit_const:
518  OS << Value.sval;
519  break;
520  case DW_FORM_udata:
521  OS << Value.uval;
522  break;
523  case DW_FORM_strp:
524  if (DumpOpts.Verbose)
525  OS << format(" .debug_str[0x%0*" PRIx64 "] = ", OffsetDumpWidth, UValue);
526  dumpString(OS);
527  break;
528  case DW_FORM_line_strp:
529  if (DumpOpts.Verbose)
530  OS << format(" .debug_line_str[0x%0*" PRIx64 "] = ", OffsetDumpWidth,
531  UValue);
532  dumpString(OS);
533  break;
534  case DW_FORM_strx:
535  case DW_FORM_strx1:
536  case DW_FORM_strx2:
537  case DW_FORM_strx3:
538  case DW_FORM_strx4:
539  case DW_FORM_GNU_str_index:
540  if (DumpOpts.Verbose)
541  OS << format("indexed (%8.8x) string = ", (uint32_t)UValue);
542  dumpString(OS);
543  break;
544  case DW_FORM_GNU_strp_alt:
545  if (DumpOpts.Verbose)
546  OS << format("alt indirect string, offset: 0x%" PRIx64 "", UValue);
547  dumpString(OS);
548  break;
549  case DW_FORM_ref_addr:
550  AddrOS << format("0x%016" PRIx64, UValue);
551  break;
552  case DW_FORM_ref1:
553  CURelativeOffset = true;
554  if (DumpOpts.Verbose)
555  AddrOS << format("cu + 0x%2.2x", (uint8_t)UValue);
556  break;
557  case DW_FORM_ref2:
558  CURelativeOffset = true;
559  if (DumpOpts.Verbose)
560  AddrOS << format("cu + 0x%4.4x", (uint16_t)UValue);
561  break;
562  case DW_FORM_ref4:
563  CURelativeOffset = true;
564  if (DumpOpts.Verbose)
565  AddrOS << format("cu + 0x%4.4x", (uint32_t)UValue);
566  break;
567  case DW_FORM_ref8:
568  CURelativeOffset = true;
569  if (DumpOpts.Verbose)
570  AddrOS << format("cu + 0x%8.8" PRIx64, UValue);
571  break;
572  case DW_FORM_ref_udata:
573  CURelativeOffset = true;
574  if (DumpOpts.Verbose)
575  AddrOS << format("cu + 0x%" PRIx64, UValue);
576  break;
577  case DW_FORM_GNU_ref_alt:
578  AddrOS << format("<alt 0x%" PRIx64 ">", UValue);
579  break;
580 
581  // All DW_FORM_indirect attributes should be resolved prior to calling
582  // this function
583  case DW_FORM_indirect:
584  OS << "DW_FORM_indirect";
585  break;
586 
587  case DW_FORM_rnglistx:
588  OS << format("indexed (0x%x) rangelist = ", (uint32_t)UValue);
589  break;
590 
591  case DW_FORM_loclistx:
592  OS << format("indexed (0x%x) loclist = ", (uint32_t)UValue);
593  break;
594 
595  case DW_FORM_sec_offset:
596  AddrOS << format("0x%0*" PRIx64, OffsetDumpWidth, UValue);
597  break;
598 
599  default:
600  OS << format("DW_FORM(0x%4.4x)", Form);
601  break;
602  }
603 
604  if (CURelativeOffset) {
605  if (DumpOpts.Verbose)
606  OS << " => {";
607  if (DumpOpts.ShowAddresses)
608  WithColor(OS, HighlightColor::Address).get()
609  << format("0x%8.8" PRIx64, UValue + (U ? U->getOffset() : 0));
610  if (DumpOpts.Verbose)
611  OS << "}";
612  }
613 }
614 
615 void DWARFFormValue::dumpString(raw_ostream &OS) const {
616  Optional<const char *> DbgStr = getAsCString();
617  if (DbgStr.hasValue()) {
618  auto COS = WithColor(OS, HighlightColor::String);
619  COS.get() << '"';
620  COS.get().write_escaped(DbgStr.getValue());
621  COS.get() << '"';
622  }
623 }
624 
625 Optional<const char *> DWARFFormValue::getAsCString() const {
626  if (!isFormClass(FC_String))
627  return None;
628  if (Form == DW_FORM_string)
629  return Value.cstr;
630  // FIXME: Add support for DW_FORM_GNU_strp_alt
631  if (Form == DW_FORM_GNU_strp_alt || C == nullptr)
632  return None;
633  uint64_t Offset = Value.uval;
634  if (Form == DW_FORM_line_strp) {
635  // .debug_line_str is tracked in the Context.
636  if (const char *Str = C->getLineStringExtractor().getCStr(&Offset))
637  return Str;
638  return None;
639  }
640  if (Form == DW_FORM_GNU_str_index || Form == DW_FORM_strx ||
641  Form == DW_FORM_strx1 || Form == DW_FORM_strx2 || Form == DW_FORM_strx3 ||
642  Form == DW_FORM_strx4) {
643  if (!U)
644  return None;
645  Optional<uint64_t> StrOffset = U->getStringOffsetSectionItem(Offset);
646  if (!StrOffset)
647  return None;
648  Offset = *StrOffset;
649  }
650  // Prefer the Unit's string extractor, because for .dwo it will point to
651  // .debug_str.dwo, while the Context's extractor always uses .debug_str.
652  if (U) {
653  if (const char *Str = U->getStringExtractor().getCStr(&Offset))
654  return Str;
655  return None;
656  }
657  if (const char *Str = C->getStringExtractor().getCStr(&Offset))
658  return Str;
659  return None;
660 }
661 
662 Optional<uint64_t> DWARFFormValue::getAsAddress() const {
663  if (auto SA = getAsSectionedAddress())
664  return SA->Address;
665  return None;
666 }
667 
668 Optional<object::SectionedAddress>
669 DWARFFormValue::getAsSectionedAddress() const {
670  if (!isFormClass(FC_Address))
671  return None;
672  bool AddrOffset = Form == dwarf::DW_FORM_LLVM_addrx_offset;
673  if (Form == DW_FORM_GNU_addr_index || Form == DW_FORM_addrx || AddrOffset) {
674 
675  uint32_t Index = AddrOffset ? (Value.uval >> 32) : Value.uval;
676  if (!U)
677  return None;
678  Optional<object::SectionedAddress> SA = U->getAddrOffsetSectionItem(Index);
679  if (!SA)
680  return None;
681  if (AddrOffset)
682  SA->Address += (Value.uval & 0xffffffff);
683  return SA;
684  }
685  return {{Value.uval, Value.SectionIndex}};
686 }
687 
688 Optional<uint64_t> DWARFFormValue::getAsReference() const {
689  if (auto R = getAsRelativeReference())
690  return R->Unit ? R->Unit->getOffset() + R->Offset : R->Offset;
691  return None;
692 }
693 
694 Optional<DWARFFormValue::UnitOffset> DWARFFormValue::getAsRelativeReference() const {
695  if (!isFormClass(FC_Reference))
696  return None;
697  switch (Form) {
698  case DW_FORM_ref1:
699  case DW_FORM_ref2:
700  case DW_FORM_ref4:
701  case DW_FORM_ref8:
702  case DW_FORM_ref_udata:
703  if (!U)
704  return None;
705  return UnitOffset{const_cast<DWARFUnit*>(U), Value.uval};
706  case DW_FORM_ref_addr:
707  case DW_FORM_ref_sig8:
708  case DW_FORM_GNU_ref_alt:
709  return UnitOffset{nullptr, Value.uval};
710  default:
711  return None;
712  }
713 }
714 
715 Optional<uint64_t> DWARFFormValue::getAsSectionOffset() const {
716  if (!isFormClass(FC_SectionOffset))
717  return None;
718  return Value.uval;
719 }
720 
721 Optional<uint64_t> DWARFFormValue::getAsUnsignedConstant() const {
722  if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag)) ||
723  Form == DW_FORM_sdata)
724  return None;
725  return Value.uval;
726 }
727 
728 Optional<int64_t> DWARFFormValue::getAsSignedConstant() const {
729  if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag)) ||
730  (Form == DW_FORM_udata &&
731  uint64_t(std::numeric_limits<int64_t>::max()) < Value.uval))
732  return None;
733  switch (Form) {
734  case DW_FORM_data4:
735  return int32_t(Value.uval);
736  case DW_FORM_data2:
737  return int16_t(Value.uval);
738  case DW_FORM_data1:
739  return int8_t(Value.uval);
740  case DW_FORM_sdata:
741  case DW_FORM_data8:
742  default:
743  return Value.sval;
744  }
745 }
746 
747 Optional<ArrayRef<uint8_t>> DWARFFormValue::getAsBlock() const {
748  if (!isFormClass(FC_Block) && !isFormClass(FC_Exprloc) &&
749  Form != DW_FORM_data16)
750  return None;
751  return makeArrayRef(Value.data, Value.uval);
752 }
753 
754 Optional<uint64_t> DWARFFormValue::getAsCStringOffset() const {
755  if (!isFormClass(FC_String) && Form == DW_FORM_string)
756  return None;
757  return Value.uval;
758 }
759 
760 Optional<uint64_t> DWARFFormValue::getAsReferenceUVal() const {
761  if (!isFormClass(FC_Reference))
762  return None;
763  return Value.uval;
764 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
DWARFFormValue.h
CmpMode::FP
@ FP
llvm
Definition: AllocatorList.h:23
Optional.h
llvm::DWARFFormValue::getAsSectionedAddress
Optional< object::SectionedAddress > getAsSectionedAddress() const
Definition: DWARFFormValue.cpp:669
StringRef.h
llvm::DWARFFormValue::dumpAddressSection
static void dumpAddressSection(const DWARFObject &Obj, raw_ostream &OS, DIDumpOptions DumpOpts, uint64_t SectionIndex)
Definition: DWARFFormValue.cpp:390
llvm::dwarf::Form
Form
Definition: Dwarf.h:131
llvm::object::SectionedAddress::Address
uint64_t Address
Definition: ObjectFile.h:144
llvm::DWARFFormValue::getAsAddress
Optional< uint64_t > getAsAddress() const
Definition: DWARFFormValue.cpp:662
ErrorHandling.h
llvm::raw_ostream::write_escaped
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning '\', '\t', ' ', '"', and anything that doesn't satisfy llvm::isPrint into an esca...
Definition: raw_ostream.cpp:163
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:332
llvm::DWARFFormValue::FC_Constant
@ FC_Constant
Definition: DWARFFormValue.h:32
R600_InstFlag::FC
@ FC
Definition: R600Defines.h:32
llvm::DWARFFormValue::getAsSignedConstant
Optional< int64_t > getAsSignedConstant() const
Definition: DWARFFormValue.cpp:728
DWARFContext.h
llvm::DWARFFormValue::getAsCString
Optional< const char * > getAsCString() const
Definition: DWARFFormValue.cpp:625
llvm::DWARFFormValue::createFromUValue
static DWARFFormValue createFromUValue(dwarf::Form F, uint64_t V)
Definition: DWARFFormValue.cpp:84
llvm::DWARFFormValue::getAsUnsignedConstant
Optional< uint64_t > getAsUnsignedConstant() const
Definition: DWARFFormValue.cpp:721
llvm::WithColor::get
raw_ostream & get()
Definition: WithColor.h:80
llvm::DWARFContext
DWARFContext This data structure is the top level entity that deals with dwarf debug information pars...
Definition: DWARFContext.h:53
DWARFRelocMap.h
llvm::DWARFFormValue::FC_Exprloc
@ FC_Exprloc
Definition: DWARFFormValue.h:38
llvm::WithColor
An RAII object that temporarily switches an output stream to a specific color.
Definition: WithColor.h:53
llvm::Optional< uint8_t >
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::DWARFFormValue::FC_Reference
@ FC_Reference
Definition: DWARFFormValue.h:35
llvm::DWARFUnit::getFormParams
const dwarf::FormParams & getFormParams() const
Definition: DWARFUnit.h:281
llvm::DWARFDataExtractor
A DataExtractor (typically for an in-memory copy of an object-file section) plus a relocation map for...
Definition: DWARFDataExtractor.h:21
Format.h
llvm::nulls
raw_ostream & nulls()
This returns a reference to a raw_ostream which simply discards output.
Definition: raw_ostream.cpp:899
llvm::Data
@ Data
Definition: SIMachineScheduler.h:56
llvm::DWARFFormValue::FC_Indirect
@ FC_Indirect
Definition: DWARFFormValue.h:36
llvm::object::SectionedAddress::SectionIndex
uint64_t SectionIndex
Definition: ObjectFile.h:145
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::DWARFFormValue::createFromPValue
static DWARFFormValue createFromPValue(dwarf::Form F, const char *V)
Definition: DWARFFormValue.cpp:88
llvm::Optional::hasValue
constexpr bool hasValue() const
Definition: Optional.h:286
llvm::DataExtractor::getULEB128
uint64_t getULEB128(uint64_t *offset_ptr, llvm::Error *Err=nullptr) const
Extract a unsigned LEB128 value from *offset_ptr.
Definition: DataExtractor.cpp:221
llvm::DIDumpOptions::ShowAddresses
bool ShowAddresses
Definition: DIContext.h:193
llvm::DWARFFormValue::createFromSValue
static DWARFFormValue createFromSValue(dwarf::Form F, int64_t V)
Definition: DWARFFormValue.cpp:80
llvm::DIDumpOptions::Verbose
bool Verbose
Definition: DIContext.h:198
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::DWARFObject::getSectionNames
virtual ArrayRef< SectionName > getSectionNames() const
Definition: DWARFObject.h:32
llvm::DWARFFormValue::FC_SectionOffset
@ FC_SectionOffset
Definition: DWARFFormValue.h:37
llvm::DWARFFormValue::dump
void dump(raw_ostream &OS, DIDumpOptions DumpOpts=DIDumpOptions()) const
Definition: DWARFFormValue.cpp:405
llvm::DWARFFormValue::getAsSectionOffset
Optional< uint64_t > getAsSectionOffset() const
Definition: DWARFFormValue.cpp:715
llvm::DWARFFormValue::getAsCStringOffset
Optional< uint64_t > getAsCStringOffset() const
Definition: DWARFFormValue.cpp:754
llvm::dwarf::Index
Index
Definition: Dwarf.h:467
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:50
llvm::DWARFObject
Definition: DWARFObject.h:25
llvm::DWARFFormValue
Definition: DWARFFormValue.h:26
llvm::None
const NoneType None
Definition: None.h:23
llvm::DWARFFormValue::skipValue
bool skipValue(DataExtractor DebugInfoData, uint64_t *OffsetPtr, const dwarf::FormParams Params) const
Skip a form's value in DebugInfoData at the offset specified by OffsetPtr.
Definition: DWARFFormValue.h:136
llvm::DWARFFormValue::getAsRelativeReference
Optional< UnitOffset > getAsRelativeReference() const
Definition: DWARFFormValue.cpp:694
llvm::DWARFUnit::getDebugInfoExtractor
DWARFDataExtractor getDebugInfoExtractor() const
Definition: DWARFUnit.cpp:188
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::DWARFFormValue::FC_String
@ FC_String
Definition: DWARFFormValue.h:33
llvm::DWARFFormValue::createFromBlockValue
static DWARFFormValue createFromBlockValue(dwarf::Form F, ArrayRef< uint8_t > D)
Definition: DWARFFormValue.cpp:92
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::DWARFFormValue::FormClass
FormClass
Definition: DWARFFormValue.h:28
DWARFUnit.h
ArrayRef.h
llvm::dwarf::FormParams
A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...
Definition: Dwarf.h:648
llvm::HighlightColor::Address
@ Address
llvm::DWARFFormValue::FC_Block
@ FC_Block
Definition: DWARFFormValue.h:31
llvm::DWARFFormValue::FC_Flag
@ FC_Flag
Definition: DWARFFormValue.h:34
llvm::errorToBool
bool errorToBool(Error Err)
Helper for converting an Error to a bool.
Definition: Error.h:1029
DWARF5FormClasses
static const DWARFFormValue::FormClass DWARF5FormClasses[]
Definition: DWARFFormValue.cpp:29
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1463
llvm::DataExtractor::getU32
uint32_t getU32(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint32_t value from *offset_ptr.
Definition: DataExtractor.cpp:108
llvm::DataExtractor::getCStr
const char * getCStr(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a C string from *offset_ptr.
Definition: DataExtractor.h:126
llvm::ArrayRef< uint8_t >
None.h
llvm::DWARFFormValue::dumpAddress
void dumpAddress(raw_ostream &OS, uint64_t Address) const
llvm::HighlightColor::String
@ String
Dwarf.h
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
if
if(llvm_vc STREQUAL "") set(fake_version_inc "$
Definition: CMakeLists.txt:14
uint32_t
llvm::format
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
llvm::DataExtractor::getU8
uint8_t getU8(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint8_t value from *offset_ptr.
Definition: DataExtractor.cpp:80
llvm::ValueType
PointerUnion< const Value *, const PseudoSourceValue * > ValueType
Definition: ScheduleDAGInstrs.h:106
llvm::dwarf::getFixedFormByteSize
Optional< uint8_t > getFixedFormByteSize(dwarf::Form Form, FormParams Params)
Get the fixed byte size for a given form.
Definition: Dwarf.cpp:694
WithColor.h
uint16_t
llvm::DWARFUnit
Definition: DWARFUnit.h:203
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::DWARFFormValue::getAsBlock
Optional< ArrayRef< uint8_t > > getAsBlock() const
Definition: DWARFFormValue.cpp:747
llvm::DWARFFormValue::FC_Address
@ FC_Address
Definition: DWARFFormValue.h:30
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:474
llvm::DWARFFormValue::extractValue
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.
Definition: DWARFFormValue.cpp:244
llvm::DWARFFormValue::FC_Unknown
@ FC_Unknown
Definition: DWARFFormValue.h:29
llvm::DataExtractor
Definition: DataExtractor.h:41
llvm::DWARFFormValue::isFormClass
bool isFormClass(FormClass FC) const
Definition: DWARFFormValue.cpp:212
llvm::object::SectionedAddress
Definition: ObjectFile.h:141
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::DWARFFormValue::getAsReference
Optional< uint64_t > getAsReference() const
getAsFoo functions below return the extracted value as Foo if only DWARFFormValue has form class is s...
Definition: DWARFFormValue.cpp:688
llvm::DWARFFormValue::getAsReferenceUVal
Optional< uint64_t > getAsReferenceUVal() const
Definition: DWARFFormValue.cpp:760
llvm::DWARFFormValue::createFromUnit
static DWARFFormValue createFromUnit(dwarf::Form F, const DWARFUnit *Unit, uint64_t *OffsetPtr)
Definition: DWARFFormValue.cpp:100
llvm::DWARFFormValue::UnitOffset
Definition: DWARFFormValue.h:112
raw_ostream.h
llvm::dwarf::getDwarfOffsetByteSize
uint8_t getDwarfOffsetByteSize(DwarfFormat Format)
The size of a reference determined by the DWARF 32/64-bit format.
Definition: Dwarf.h:635
llvm::DWARFFormValue::dumpSectionedAddress
void dumpSectionedAddress(raw_ostream &OS, DIDumpOptions DumpOpts, object::SectionedAddress SA) const
Definition: DWARFFormValue.cpp:382
CU
Definition: AArch64AsmBackend.cpp:506
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::Optional::getValue
constexpr const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:280
llvm::DataExtractor::getU16
uint16_t getU16(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint16_t value from *offset_ptr.
Definition: DataExtractor.cpp:93
llvm::DIDumpOptions
Container for dump options that control which debug information will be dumped.
Definition: DIContext.h:187
llvm::DataExtractor::getSLEB128
int64_t getSLEB128(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a signed LEB128 value from *offset_ptr.
Definition: DataExtractor.cpp:225
Generated on Sun May 16 2021 03:05:54 for LLVM by   doxygen 1.8.17