LLVM  4.0.0
DWARFAcceleratorTable.cpp
Go to the documentation of this file.
1 //===--- DWARFAcceleratorTable.cpp ----------------------------------------===//
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/Support/Dwarf.h"
12 #include "llvm/Support/Format.h"
14 
15 namespace llvm {
16 
18  uint32_t Offset = 0;
19 
20  // Check that we can at least read the header.
21  if (!AccelSection.isValidOffset(offsetof(Header, HeaderDataLength)+4))
22  return false;
23 
24  Hdr.Magic = AccelSection.getU32(&Offset);
25  Hdr.Version = AccelSection.getU16(&Offset);
26  Hdr.HashFunction = AccelSection.getU16(&Offset);
27  Hdr.NumBuckets = AccelSection.getU32(&Offset);
28  Hdr.NumHashes = AccelSection.getU32(&Offset);
29  Hdr.HeaderDataLength = AccelSection.getU32(&Offset);
30 
31  // Check that we can read all the hashes and offsets from the
32  // section (see SourceLevelDebugging.rst for the structure of the index).
33  if (!AccelSection.isValidOffset(sizeof(Hdr) + Hdr.HeaderDataLength +
34  Hdr.NumBuckets*4 + Hdr.NumHashes*8))
35  return false;
36 
37  HdrData.DIEOffsetBase = AccelSection.getU32(&Offset);
38  uint32_t NumAtoms = AccelSection.getU32(&Offset);
39 
40  for (unsigned i = 0; i < NumAtoms; ++i) {
41  uint16_t AtomType = AccelSection.getU16(&Offset);
42  auto AtomForm = static_cast<dwarf::Form>(AccelSection.getU16(&Offset));
43  HdrData.Atoms.push_back(std::make_pair(AtomType, AtomForm));
44  }
45 
46  return true;
47 }
48 
50  // Dump the header.
51  OS << "Magic = " << format("0x%08x", Hdr.Magic) << '\n'
52  << "Version = " << format("0x%04x", Hdr.Version) << '\n'
53  << "Hash function = " << format("0x%08x", Hdr.HashFunction) << '\n'
54  << "Bucket count = " << Hdr.NumBuckets << '\n'
55  << "Hashes count = " << Hdr.NumHashes << '\n'
56  << "HeaderData length = " << Hdr.HeaderDataLength << '\n'
57  << "DIE offset base = " << HdrData.DIEOffsetBase << '\n'
58  << "Number of atoms = " << HdrData.Atoms.size() << '\n';
59 
60  unsigned i = 0;
62  for (const auto &Atom: HdrData.Atoms) {
63  OS << format("Atom[%d] Type: ", i++);
64  auto TypeString = dwarf::AtomTypeString(Atom.first);
65  if (!TypeString.empty())
66  OS << TypeString;
67  else
68  OS << format("DW_ATOM_Unknown_0x%x", Atom.first);
69  OS << " Form: ";
70  auto FormString = dwarf::FormEncodingString(Atom.second);
71  if (!FormString.empty())
72  OS << FormString;
73  else
74  OS << format("DW_FORM_Unknown_0x%x", Atom.second);
75  OS << '\n';
76  AtomForms.push_back(DWARFFormValue(Atom.second));
77  }
78 
79  // Now go through the actual tables and dump them.
80  uint32_t Offset = sizeof(Hdr) + Hdr.HeaderDataLength;
81  unsigned HashesBase = Offset + Hdr.NumBuckets * 4;
82  unsigned OffsetsBase = HashesBase + Hdr.NumHashes * 4;
83 
84  for (unsigned Bucket = 0; Bucket < Hdr.NumBuckets; ++Bucket) {
85  unsigned Index = AccelSection.getU32(&Offset);
86 
87  OS << format("Bucket[%d]\n", Bucket);
88  if (Index == UINT32_MAX) {
89  OS << " EMPTY\n";
90  continue;
91  }
92 
93  for (unsigned HashIdx = Index; HashIdx < Hdr.NumHashes; ++HashIdx) {
94  unsigned HashOffset = HashesBase + HashIdx*4;
95  unsigned OffsetsOffset = OffsetsBase + HashIdx*4;
96  uint32_t Hash = AccelSection.getU32(&HashOffset);
97 
98  if (Hash % Hdr.NumBuckets != Bucket)
99  break;
100 
101  unsigned DataOffset = AccelSection.getU32(&OffsetsOffset);
102  OS << format(" Hash = 0x%08x Offset = 0x%08x\n", Hash, DataOffset);
103  if (!AccelSection.isValidOffset(DataOffset)) {
104  OS << " Invalid section offset\n";
105  continue;
106  }
107  while (AccelSection.isValidOffsetForDataOfSize(DataOffset, 4)) {
108  unsigned StringOffset = AccelSection.getU32(&DataOffset);
109  RelocAddrMap::const_iterator Reloc = Relocs.find(DataOffset-4);
110  if (Reloc != Relocs.end())
111  StringOffset += Reloc->second.second;
112  if (!StringOffset)
113  break;
114  OS << format(" Name: %08x \"%s\"\n", StringOffset,
115  StringSection.getCStr(&StringOffset));
116  unsigned NumData = AccelSection.getU32(&DataOffset);
117  for (unsigned Data = 0; Data < NumData; ++Data) {
118  OS << format(" Data[%d] => ", Data);
119  unsigned i = 0;
120  for (auto &Atom : AtomForms) {
121  OS << format("{Atom[%d]: ", i++);
122  if (Atom.extractValue(AccelSection, &DataOffset, nullptr))
123  Atom.dump(OS);
124  else
125  OS << "Error extracting the value";
126  OS << "} ";
127  }
128  OS << '\n';
129  }
130  }
131  }
132  }
133 }
134 }
size_t i
StringRef AtomTypeString(unsigned Atom)
Definition: Dwarf.cpp:307
bool isValidOffset(uint32_t offset) const
Test the validity of offset.
uint32_t getU32(uint32_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
StringRef FormEncodingString(unsigned Encoding)
Definition: Dwarf.cpp:58
bool isValidOffsetForDataOfSize(uint32_t offset, uint32_t length) const
Test the availability of length bytes of data from offset.
format_object< Ts...> format(const char *Fmt, const Ts &...Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
const char * getCStr(uint32_t *offset_ptr) const
Extract a C string from *offset_ptr.
uint32_t Offset
for(unsigned i=0, e=MI->getNumOperands();i!=e;++i)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
uint16_t getU16(uint32_t *offset_ptr) const
Extract a uint16_t value from *offset_ptr.
void dump(raw_ostream &OS) const
iterator end()
Definition: DenseMap.h:69
iterator find(const KeyT &Val)
Definition: DenseMap.h:127
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
std::string Hash(const Unit &U)
Definition: FuzzerSHA1.cpp:216