1 //===- NativeSession.cpp - Native implementation of IPDBSession -*- C++ -*-===//
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/PDB/Native/NativeSession.h"
11
12 #include "llvm/ADT/STLExtras.h"
13 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
14 #include "llvm/DebugInfo/PDB/GenericError.h"
15 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
16 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
17 #include "llvm/DebugInfo/PDB/Native/NativeBuiltinSymbol.h"
18 #include "llvm/DebugInfo/PDB/Native/NativeCompilandSymbol.h"
19 #include "llvm/DebugInfo/PDB/Native/NativeEnumSymbol.h"
20 #include "llvm/DebugInfo/PDB/Native/NativeEnumTypes.h"
21 #include "llvm/DebugInfo/PDB/Native/NativeExeSymbol.h"
22 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
23 #include "llvm/DebugInfo/PDB/Native/RawError.h"
24 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
25 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
26 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
27 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
28 #include "llvm/Support/Allocator.h"
29 #include "llvm/Support/BinaryByteStream.h"
30 #include "llvm/Support/Error.h"
31 #include "llvm/Support/ErrorOr.h"
32 #include "llvm/Support/MemoryBuffer.h"
33
34 #include <algorithm>
35 #include <cassert>
36 #include <memory>
37 #include <utility>
38
39 using namespace llvm;
40 using namespace llvm::msf;
41 using namespace llvm::pdb;
42
43 namespace {
44 // Maps codeview::SimpleTypeKind of a built-in type to the parameters necessary
45 // to instantiate a NativeBuiltinSymbol for that type.
46 static const struct BuiltinTypeEntry {
47 codeview::SimpleTypeKind Kind;
48 PDB_BuiltinType Type;
49 uint32_t Size;
50 } BuiltinTypes[] = {
51 {codeview::SimpleTypeKind::Int32, PDB_BuiltinType::Int, 4},
52 {codeview::SimpleTypeKind::UInt32, PDB_BuiltinType::UInt, 4},
53 {codeview::SimpleTypeKind::UInt32Long, PDB_BuiltinType::UInt, 4},
54 {codeview::SimpleTypeKind::UInt64Quad, PDB_BuiltinType::UInt, 8},
55 {codeview::SimpleTypeKind::NarrowCharacter, PDB_BuiltinType::Char, 1},
56 {codeview::SimpleTypeKind::SignedCharacter, PDB_BuiltinType::Char, 1},
57 {codeview::SimpleTypeKind::UnsignedCharacter, PDB_BuiltinType::UInt, 1},
58 {codeview::SimpleTypeKind::UInt16Short, PDB_BuiltinType::UInt, 2},
59 {codeview::SimpleTypeKind::Boolean8, PDB_BuiltinType::Bool, 1}
60 // This table can be grown as necessary, but these are the only types we've
61 // needed so far.
62 };
63 } // namespace
64
NativeSession(std::unique_ptr<PDBFile> PdbFile,std::unique_ptr<BumpPtrAllocator> Allocator)65 NativeSession::NativeSession(std::unique_ptr<PDBFile> PdbFile,
66 std::unique_ptr<BumpPtrAllocator> Allocator)
67 : Pdb(std::move(PdbFile)), Allocator(std::move(Allocator)) {}
68
69 NativeSession::~NativeSession() = default;
70
createFromPdb(std::unique_ptr<MemoryBuffer> Buffer,std::unique_ptr<IPDBSession> & Session)71 Error NativeSession::createFromPdb(std::unique_ptr<MemoryBuffer> Buffer,
72 std::unique_ptr<IPDBSession> &Session) {
73 StringRef Path = Buffer->getBufferIdentifier();
74 auto Stream = llvm::make_unique<MemoryBufferByteStream>(
75 std::move(Buffer), llvm::support::little);
76
77 auto Allocator = llvm::make_unique<BumpPtrAllocator>();
78 auto File = llvm::make_unique<PDBFile>(Path, std::move(Stream), *Allocator);
79 if (auto EC = File->parseFileHeaders())
80 return EC;
81 if (auto EC = File->parseStreamData())
82 return EC;
83
84 Session =
85 llvm::make_unique<NativeSession>(std::move(File), std::move(Allocator));
86
87 return Error::success();
88 }
89
createFromExe(StringRef Path,std::unique_ptr<IPDBSession> & Session)90 Error NativeSession::createFromExe(StringRef Path,
91 std::unique_ptr<IPDBSession> &Session) {
92 return make_error<RawError>(raw_error_code::feature_unsupported);
93 }
94
95 std::unique_ptr<PDBSymbolCompiland>
createCompilandSymbol(DbiModuleDescriptor MI)96 NativeSession::createCompilandSymbol(DbiModuleDescriptor MI) {
97 const auto Id = static_cast<SymIndexId>(SymbolCache.size());
98 SymbolCache.push_back(
99 llvm::make_unique<NativeCompilandSymbol>(*this, Id, MI));
100 return llvm::make_unique<PDBSymbolCompiland>(
101 *this, std::unique_ptr<IPDBRawSymbol>(SymbolCache[Id]->clone()));
102 }
103
104 std::unique_ptr<PDBSymbolTypeEnum>
createEnumSymbol(codeview::TypeIndex Index)105 NativeSession::createEnumSymbol(codeview::TypeIndex Index) {
106 const auto Id = findSymbolByTypeIndex(Index);
107 return llvm::make_unique<PDBSymbolTypeEnum>(
108 *this, std::unique_ptr<IPDBRawSymbol>(SymbolCache[Id]->clone()));
109 }
110
111 std::unique_ptr<IPDBEnumSymbols>
createTypeEnumerator(codeview::TypeLeafKind Kind)112 NativeSession::createTypeEnumerator(codeview::TypeLeafKind Kind) {
113 auto Tpi = Pdb->getPDBTpiStream();
114 if (!Tpi) {
115 consumeError(Tpi.takeError());
116 return nullptr;
117 }
118 auto &Types = Tpi->typeCollection();
119 return std::unique_ptr<IPDBEnumSymbols>(
120 new NativeEnumTypes(*this, Types, codeview::LF_ENUM));
121 }
122
findSymbolByTypeIndex(codeview::TypeIndex Index)123 SymIndexId NativeSession::findSymbolByTypeIndex(codeview::TypeIndex Index) {
124 // First see if it's already in our cache.
125 const auto Entry = TypeIndexToSymbolId.find(Index);
126 if (Entry != TypeIndexToSymbolId.end())
127 return Entry->second;
128
129 // Symbols for built-in types are created on the fly.
130 if (Index.isSimple()) {
131 // FIXME: We will eventually need to handle pointers to other simple types,
132 // which are still simple types in the world of CodeView TypeIndexes.
133 if (Index.getSimpleMode() != codeview::SimpleTypeMode::Direct)
134 return 0;
135 const auto Kind = Index.getSimpleKind();
136 const auto It =
137 std::find_if(std::begin(BuiltinTypes), std::end(BuiltinTypes),
138 [Kind](const BuiltinTypeEntry &Builtin) {
139 return Builtin.Kind == Kind;
140 });
141 if (It == std::end(BuiltinTypes))
142 return 0;
143 SymIndexId Id = SymbolCache.size();
144 SymbolCache.emplace_back(
145 llvm::make_unique<NativeBuiltinSymbol>(*this, Id, It->Type, It->Size));
146 TypeIndexToSymbolId[Index] = Id;
147 return Id;
148 }
149
150 // We need to instantiate and cache the desired type symbol.
151 auto Tpi = Pdb->getPDBTpiStream();
152 if (!Tpi) {
153 consumeError(Tpi.takeError());
154 return 0;
155 }
156 auto &Types = Tpi->typeCollection();
157 const auto &I = Types.getType(Index);
158 const auto Id = static_cast<SymIndexId>(SymbolCache.size());
159 // TODO(amccarth): Make this handle all types, not just LF_ENUMs.
160 assert(I.kind() == codeview::LF_ENUM);
161 SymbolCache.emplace_back(llvm::make_unique<NativeEnumSymbol>(*this, Id, I));
162 TypeIndexToSymbolId[Index] = Id;
163 return Id;
164 }
165
getLoadAddress() const166 uint64_t NativeSession::getLoadAddress() const { return 0; }
167
setLoadAddress(uint64_t Address)168 bool NativeSession::setLoadAddress(uint64_t Address) { return false; }
169
getGlobalScope()170 std::unique_ptr<PDBSymbolExe> NativeSession::getGlobalScope() {
171 const auto Id = static_cast<SymIndexId>(SymbolCache.size());
172 SymbolCache.push_back(llvm::make_unique<NativeExeSymbol>(*this, Id));
173 auto RawSymbol = SymbolCache[Id]->clone();
174 auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
175 std::unique_ptr<PDBSymbolExe> ExeSymbol(
176 static_cast<PDBSymbolExe *>(PdbSymbol.release()));
177 return ExeSymbol;
178 }
179
180 std::unique_ptr<PDBSymbol>
getSymbolById(uint32_t SymbolId) const181 NativeSession::getSymbolById(uint32_t SymbolId) const {
182 // If the caller has a SymbolId, it'd better be in our SymbolCache.
183 return SymbolId < SymbolCache.size()
184 ? PDBSymbol::create(*this, SymbolCache[SymbolId]->clone())
185 : nullptr;
186 }
187
addressForVA(uint64_t VA,uint32_t & Section,uint32_t & Offset) const188 bool NativeSession::addressForVA(uint64_t VA, uint32_t &Section,
189 uint32_t &Offset) const {
190 return false;
191 }
192
addressForRVA(uint32_t VA,uint32_t & Section,uint32_t & Offset) const193 bool NativeSession::addressForRVA(uint32_t VA, uint32_t &Section,
194 uint32_t &Offset) const {
195 return false;
196 }
197
198 std::unique_ptr<PDBSymbol>
findSymbolByAddress(uint64_t Address,PDB_SymType Type) const199 NativeSession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
200 return nullptr;
201 }
202
203 std::unique_ptr<PDBSymbol>
findSymbolByRVA(uint32_t RVA,PDB_SymType Type) const204 NativeSession::findSymbolByRVA(uint32_t RVA, PDB_SymType Type) const {
205 return nullptr;
206 }
207
208 std::unique_ptr<PDBSymbol>
findSymbolBySectOffset(uint32_t Sect,uint32_t Offset,PDB_SymType Type) const209 NativeSession::findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
210 PDB_SymType Type) const {
211 return nullptr;
212 }
213
214 std::unique_ptr<IPDBEnumLineNumbers>
findLineNumbers(const PDBSymbolCompiland & Compiland,const IPDBSourceFile & File) const215 NativeSession::findLineNumbers(const PDBSymbolCompiland &Compiland,
216 const IPDBSourceFile &File) const {
217 return nullptr;
218 }
219
220 std::unique_ptr<IPDBEnumLineNumbers>
findLineNumbersByAddress(uint64_t Address,uint32_t Length) const221 NativeSession::findLineNumbersByAddress(uint64_t Address,
222 uint32_t Length) const {
223 return nullptr;
224 }
225
226 std::unique_ptr<IPDBEnumLineNumbers>
findLineNumbersByRVA(uint32_t RVA,uint32_t Length) const227 NativeSession::findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const {
228 return nullptr;
229 }
230
231 std::unique_ptr<IPDBEnumLineNumbers>
findLineNumbersBySectOffset(uint32_t Section,uint32_t Offset,uint32_t Length) const232 NativeSession::findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset,
233 uint32_t Length) const {
234 return nullptr;
235 }
236
237 std::unique_ptr<IPDBEnumSourceFiles>
findSourceFiles(const PDBSymbolCompiland * Compiland,StringRef Pattern,PDB_NameSearchFlags Flags) const238 NativeSession::findSourceFiles(const PDBSymbolCompiland *Compiland,
239 StringRef Pattern,
240 PDB_NameSearchFlags Flags) const {
241 return nullptr;
242 }
243
244 std::unique_ptr<IPDBSourceFile>
findOneSourceFile(const PDBSymbolCompiland * Compiland,StringRef Pattern,PDB_NameSearchFlags Flags) const245 NativeSession::findOneSourceFile(const PDBSymbolCompiland *Compiland,
246 StringRef Pattern,
247 PDB_NameSearchFlags Flags) const {
248 return nullptr;
249 }
250
251 std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
findCompilandsForSourceFile(StringRef Pattern,PDB_NameSearchFlags Flags) const252 NativeSession::findCompilandsForSourceFile(StringRef Pattern,
253 PDB_NameSearchFlags Flags) const {
254 return nullptr;
255 }
256
257 std::unique_ptr<PDBSymbolCompiland>
findOneCompilandForSourceFile(StringRef Pattern,PDB_NameSearchFlags Flags) const258 NativeSession::findOneCompilandForSourceFile(StringRef Pattern,
259 PDB_NameSearchFlags Flags) const {
260 return nullptr;
261 }
262
getAllSourceFiles() const263 std::unique_ptr<IPDBEnumSourceFiles> NativeSession::getAllSourceFiles() const {
264 return nullptr;
265 }
266
getSourceFilesForCompiland(const PDBSymbolCompiland & Compiland) const267 std::unique_ptr<IPDBEnumSourceFiles> NativeSession::getSourceFilesForCompiland(
268 const PDBSymbolCompiland &Compiland) const {
269 return nullptr;
270 }
271
272 std::unique_ptr<IPDBSourceFile>
getSourceFileById(uint32_t FileId) const273 NativeSession::getSourceFileById(uint32_t FileId) const {
274 return nullptr;
275 }
276
getDebugStreams() const277 std::unique_ptr<IPDBEnumDataStreams> NativeSession::getDebugStreams() const {
278 return nullptr;
279 }
280
getEnumTables() const281 std::unique_ptr<IPDBEnumTables> NativeSession::getEnumTables() const {
282 return nullptr;
283 }
284
285 std::unique_ptr<IPDBEnumInjectedSources>
getInjectedSources() const286 NativeSession::getInjectedSources() const {
287 return nullptr;
288 }
289
290 std::unique_ptr<IPDBEnumSectionContribs>
getSectionContribs() const291 NativeSession::getSectionContribs() const {
292 return nullptr;
293 }
294