1 //===- DWARFGdbIndex.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/DWARFGdbIndex.h"
10 #include "llvm/ADT/SmallVector.h"
11 #include "llvm/ADT/StringRef.h"
12 #include "llvm/Support/DataExtractor.h"
13 #include "llvm/Support/Format.h"
14 #include "llvm/Support/FormatVariadic.h"
15 #include "llvm/Support/raw_ostream.h"
16 #include <cassert>
17 #include <cinttypes>
18 #include <cstdint>
19 #include <set>
20 #include <utility>
21 
22 using namespace llvm;
23 
24 // .gdb_index section format reference:
25 // https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html
26 
27 void DWARFGdbIndex::dumpCUList(raw_ostream &OS) const {
28   OS << format("\n  CU list offset = 0x%x, has %" PRId64 " entries:",
29                CuListOffset, (uint64_t)CuList.size())
30      << '\n';
31   uint32_t I = 0;
32   for (const CompUnitEntry &CU : CuList)
33     OS << format("    %d: Offset = 0x%llx, Length = 0x%llx\n", I++, CU.Offset,
34                  CU.Length);
35 }
36 
37 void DWARFGdbIndex::dumpTUList(raw_ostream &OS) const {
38   OS << formatv("\n  Types CU list offset = {0:x}, has {1} entries:\n",
39                 TuListOffset, TuList.size());
40   uint32_t I = 0;
41   for (const TypeUnitEntry &TU : TuList)
42     OS << formatv("    {0}: offset = {1:x8}, type_offset = {2:x8}, "
43                   "type_signature = {3:x16}\n",
44                   I++, TU.Offset, TU.TypeOffset, TU.TypeSignature);
45 }
46 
47 void DWARFGdbIndex::dumpAddressArea(raw_ostream &OS) const {
48   OS << format("\n  Address area offset = 0x%x, has %" PRId64 " entries:",
49                AddressAreaOffset, (uint64_t)AddressArea.size())
50      << '\n';
51   for (const AddressEntry &Addr : AddressArea)
52     OS << format(
53         "    Low/High address = [0x%llx, 0x%llx) (Size: 0x%llx), CU id = %d\n",
54         Addr.LowAddress, Addr.HighAddress, Addr.HighAddress - Addr.LowAddress,
55         Addr.CuIndex);
56 }
57 
58 void DWARFGdbIndex::dumpSymbolTable(raw_ostream &OS) const {
59   OS << format("\n  Symbol table offset = 0x%x, size = %" PRId64
60                ", filled slots:",
61                SymbolTableOffset, (uint64_t)SymbolTable.size())
62      << '\n';
63   uint32_t I = -1;
64   for (const SymTableEntry &E : SymbolTable) {
65     ++I;
66     if (!E.NameOffset && !E.VecOffset)
67       continue;
68 
69     OS << format("    %d: Name offset = 0x%x, CU vector offset = 0x%x\n", I,
70                  E.NameOffset, E.VecOffset);
71 
72     StringRef Name = ConstantPoolStrings.substr(
73         ConstantPoolOffset - StringPoolOffset + E.NameOffset);
74 
75     auto CuVector = llvm::find_if(
76         ConstantPoolVectors,
77         [&](const std::pair<uint32_t, SmallVector<uint32_t, 0>> &V) {
78           return V.first == E.VecOffset;
79         });
80     assert(CuVector != ConstantPoolVectors.end() && "Invalid symbol table");
81     uint32_t CuVectorId = CuVector - ConstantPoolVectors.begin();
82     OS << format("      String name: %s, CU vector index: %d\n", Name.data(),
83                  CuVectorId);
84   }
85 }
86 
87 void DWARFGdbIndex::dumpConstantPool(raw_ostream &OS) const {
88   OS << format("\n  Constant pool offset = 0x%x, has %" PRId64 " CU vectors:",
89                ConstantPoolOffset, (uint64_t)ConstantPoolVectors.size());
90   uint32_t I = 0;
91   for (const auto &V : ConstantPoolVectors) {
92     OS << format("\n    %d(0x%x): ", I++, V.first);
93     for (uint32_t Val : V.second)
94       OS << format("0x%x ", Val);
95   }
96   OS << '\n';
97 }
98 
99 void DWARFGdbIndex::dump(raw_ostream &OS) {
100   if (HasError) {
101     OS << "\n<error parsing>\n";
102     return;
103   }
104 
105   if (HasContent) {
106     OS << "  Version = " << Version << '\n';
107     dumpCUList(OS);
108     dumpTUList(OS);
109     dumpAddressArea(OS);
110     dumpSymbolTable(OS);
111     dumpConstantPool(OS);
112   }
113 }
114 
115 bool DWARFGdbIndex::parseImpl(DataExtractor Data) {
116   uint64_t Offset = 0;
117 
118   // Only version 7 and 8 are supported at this moment.
119   Version = Data.getU32(&Offset);
120   if (Version != 7 && Version != 8)
121     return false;
122 
123   CuListOffset = Data.getU32(&Offset);
124   TuListOffset = Data.getU32(&Offset);
125   AddressAreaOffset = Data.getU32(&Offset);
126   SymbolTableOffset = Data.getU32(&Offset);
127   ConstantPoolOffset = Data.getU32(&Offset);
128 
129   if (Offset != CuListOffset)
130     return false;
131 
132   uint32_t CuListSize = (TuListOffset - CuListOffset) / 16;
133   CuList.reserve(CuListSize);
134   for (uint32_t i = 0; i < CuListSize; ++i) {
135     uint64_t CuOffset = Data.getU64(&Offset);
136     uint64_t CuLength = Data.getU64(&Offset);
137     CuList.push_back({CuOffset, CuLength});
138   }
139 
140   // CU Types are no longer needed as DWARF skeleton type units never made it
141   // into the standard.
142   uint32_t TuListSize = (AddressAreaOffset - TuListOffset) / 24;
143   TuList.resize(TuListSize);
144   for (uint32_t I = 0; I < TuListSize; ++I) {
145     uint64_t CuOffset = Data.getU64(&Offset);
146     uint64_t TypeOffset = Data.getU64(&Offset);
147     uint64_t Signature = Data.getU64(&Offset);
148     TuList[I] = {CuOffset, TypeOffset, Signature};
149   }
150 
151   uint32_t AddressAreaSize = (SymbolTableOffset - AddressAreaOffset) / 20;
152   AddressArea.reserve(AddressAreaSize);
153   for (uint32_t i = 0; i < AddressAreaSize; ++i) {
154     uint64_t LowAddress = Data.getU64(&Offset);
155     uint64_t HighAddress = Data.getU64(&Offset);
156     uint32_t CuIndex = Data.getU32(&Offset);
157     AddressArea.push_back({LowAddress, HighAddress, CuIndex});
158   }
159 
160   // The symbol table. This is an open addressed hash table. The size of the
161   // hash table is always a power of 2.
162   // Each slot in the hash table consists of a pair of offset_type values. The
163   // first value is the offset of the symbol's name in the constant pool. The
164   // second value is the offset of the CU vector in the constant pool.
165   // If both values are 0, then this slot in the hash table is empty. This is ok
166   // because while 0 is a valid constant pool index, it cannot be a valid index
167   // for both a string and a CU vector.
168   uint32_t SymTableSize = (ConstantPoolOffset - SymbolTableOffset) / 8;
169   SymbolTable.reserve(SymTableSize);
170   std::set<uint32_t> CUOffsets;
171   for (uint32_t i = 0; i < SymTableSize; ++i) {
172     uint32_t NameOffset = Data.getU32(&Offset);
173     uint32_t CuVecOffset = Data.getU32(&Offset);
174     SymbolTable.push_back({NameOffset, CuVecOffset});
175     if (NameOffset || CuVecOffset)
176       CUOffsets.insert(CuVecOffset);
177   }
178 
179   // The constant pool. CU vectors are stored first, followed by strings.
180   // The first value is the number of CU indices in the vector. Each subsequent
181   // value is the index and symbol attributes of a CU in the CU list.
182   for (auto CUOffset : CUOffsets) {
183     Offset = ConstantPoolOffset + CUOffset;
184     ConstantPoolVectors.emplace_back(0, SmallVector<uint32_t, 0>());
185     auto &Vec = ConstantPoolVectors.back();
186     Vec.first = Offset - ConstantPoolOffset;
187 
188     uint32_t Num = Data.getU32(&Offset);
189     for (uint32_t J = 0; J < Num; ++J)
190       Vec.second.push_back(Data.getU32(&Offset));
191   }
192 
193   ConstantPoolStrings = Data.getData().drop_front(Offset);
194   StringPoolOffset = Offset;
195   return true;
196 }
197 
198 void DWARFGdbIndex::parse(DataExtractor Data) {
199   HasContent = !Data.getData().empty();
200   HasError = HasContent && !parseImpl(Data);
201 }
202