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
10#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
11#include "llvm/Support/Dwarf.h"
12#include "llvm/Support/Format.h"
13#include "llvm/Support/raw_ostream.h"
14
15namespace llvm {
16
17bool DWARFAcceleratorTable::extract() {
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    uint16_t AtomForm = AccelSection.getU16(&Offset);
43    HdrData.Atoms.push_back(std::make_pair(AtomType, AtomForm));
44  }
45
46  return true;
47}
48
49void DWARFAcceleratorTable::dump(raw_ostream &OS) const {
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;
61  SmallVector<DWARFFormValue, 3> AtomForms;
62  for (const auto &Atom: HdrData.Atoms) {
63    OS << format("Atom[%d] Type: ", i++);
64    if (const char *TypeString = dwarf::AtomTypeString(Atom.first))
65      OS << TypeString;
66    else
67      OS << format("DW_ATOM_Unknown_0x%x", Atom.first);
68    OS << " Form: ";
69    if (const char *FormString = dwarf::FormEncodingString(Atom.second))
70      OS << FormString;
71    else
72      OS << format("DW_FORM_Unknown_0x%x", Atom.second);
73    OS << '\n';
74    AtomForms.push_back(DWARFFormValue(Atom.second));
75  }
76
77  // Now go through the actual tables and dump them.
78  uint32_t Offset = sizeof(Hdr) + Hdr.HeaderDataLength;
79  unsigned HashesBase = Offset + Hdr.NumBuckets * 4;
80  unsigned OffsetsBase = HashesBase + Hdr.NumHashes * 4;
81
82  for (unsigned Bucket = 0; Bucket < Hdr.NumBuckets; ++Bucket) {
83    unsigned Index = AccelSection.getU32(&Offset);
84
85    OS << format("Bucket[%d]\n", Bucket);
86    if (Index == UINT32_MAX) {
87      OS << "  EMPTY\n";
88      continue;
89    }
90
91    for (unsigned HashIdx = Index; HashIdx < Hdr.NumHashes; ++HashIdx) {
92      unsigned HashOffset = HashesBase + HashIdx*4;
93      unsigned OffsetsOffset = OffsetsBase + HashIdx*4;
94      uint32_t Hash = AccelSection.getU32(&HashOffset);
95
96      if (Hash % Hdr.NumBuckets != Bucket)
97        break;
98
99      unsigned DataOffset = AccelSection.getU32(&OffsetsOffset);
100      OS << format("  Hash = 0x%08x Offset = 0x%08x\n", Hash, DataOffset);
101      if (!AccelSection.isValidOffset(DataOffset)) {
102        OS << "    Invalid section offset\n";
103        continue;
104      }
105      while (AccelSection.isValidOffsetForDataOfSize(DataOffset, 4)) {
106        unsigned StringOffset = AccelSection.getU32(&DataOffset);
107        RelocAddrMap::const_iterator Reloc = Relocs.find(DataOffset-4);
108        if (Reloc != Relocs.end())
109          StringOffset += Reloc->second.second;
110        if (!StringOffset)
111          break;
112        OS << format("    Name: %08x \"%s\"\n", StringOffset,
113                     StringSection.getCStr(&StringOffset));
114        unsigned NumData = AccelSection.getU32(&DataOffset);
115        for (unsigned Data = 0; Data < NumData; ++Data) {
116          OS << format("    Data[%d] => ", Data);
117          unsigned i = 0;
118          for (auto &Atom : AtomForms) {
119            OS << format("{Atom[%d]: ", i++);
120            if (Atom.extractValue(AccelSection, &DataOffset, nullptr))
121              Atom.dump(OS, nullptr);
122            else
123              OS << "Error extracting the value";
124            OS << "} ";
125          }
126          OS << '\n';
127        }
128      }
129    }
130  }
131}
132}
133