1 //===- NativeSession.cpp - Native implementation of IPDBSession -*- C++ -*-===//
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/PDB/Native/NativeSession.h"
10 
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
13 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
14 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
15 #include "llvm/DebugInfo/PDB/Native/NativeCompilandSymbol.h"
16 #include "llvm/DebugInfo/PDB/Native/NativeEnumTypes.h"
17 #include "llvm/DebugInfo/PDB/Native/NativeExeSymbol.h"
18 #include "llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h"
19 #include "llvm/DebugInfo/PDB/Native/NativeTypeEnum.h"
20 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
21 #include "llvm/DebugInfo/PDB/Native/RawError.h"
22 #include "llvm/DebugInfo/PDB/Native/SymbolCache.h"
23 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
24 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
25 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
26 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
27 #include "llvm/Support/Allocator.h"
28 #include "llvm/Support/BinaryByteStream.h"
29 #include "llvm/Support/Error.h"
30 #include "llvm/Support/ErrorOr.h"
31 #include "llvm/Support/MemoryBuffer.h"
32 
33 #include <algorithm>
34 #include <cassert>
35 #include <memory>
36 #include <utility>
37 
38 using namespace llvm;
39 using namespace llvm::msf;
40 using namespace llvm::pdb;
41 
42 static DbiStream *getDbiStreamPtr(PDBFile &File) {
43   Expected<DbiStream &> DbiS = File.getPDBDbiStream();
44   if (DbiS)
45     return &DbiS.get();
46 
47   consumeError(DbiS.takeError());
48   return nullptr;
49 }
50 
51 NativeSession::NativeSession(std::unique_ptr<PDBFile> PdbFile,
52                              std::unique_ptr<BumpPtrAllocator> Allocator)
53     : Pdb(std::move(PdbFile)), Allocator(std::move(Allocator)),
54       Cache(*this, getDbiStreamPtr(*Pdb)) {}
55 
56 NativeSession::~NativeSession() = default;
57 
58 Error NativeSession::createFromPdb(std::unique_ptr<MemoryBuffer> Buffer,
59                                    std::unique_ptr<IPDBSession> &Session) {
60   StringRef Path = Buffer->getBufferIdentifier();
61   auto Stream = llvm::make_unique<MemoryBufferByteStream>(
62       std::move(Buffer), llvm::support::little);
63 
64   auto Allocator = llvm::make_unique<BumpPtrAllocator>();
65   auto File = llvm::make_unique<PDBFile>(Path, std::move(Stream), *Allocator);
66   if (auto EC = File->parseFileHeaders())
67     return EC;
68   if (auto EC = File->parseStreamData())
69     return EC;
70 
71   Session =
72       llvm::make_unique<NativeSession>(std::move(File), std::move(Allocator));
73 
74   return Error::success();
75 }
76 
77 Error NativeSession::createFromExe(StringRef Path,
78                                    std::unique_ptr<IPDBSession> &Session) {
79   return make_error<RawError>(raw_error_code::feature_unsupported);
80 }
81 
82 uint64_t NativeSession::getLoadAddress() const { return 0; }
83 
84 bool NativeSession::setLoadAddress(uint64_t Address) { return false; }
85 
86 std::unique_ptr<PDBSymbolExe> NativeSession::getGlobalScope() {
87   return PDBSymbol::createAs<PDBSymbolExe>(*this, getNativeGlobalScope());
88 }
89 
90 std::unique_ptr<PDBSymbol>
91 NativeSession::getSymbolById(SymIndexId SymbolId) const {
92   return Cache.getSymbolById(SymbolId);
93 }
94 
95 bool NativeSession::addressForVA(uint64_t VA, uint32_t &Section,
96                                  uint32_t &Offset) const {
97   return false;
98 }
99 
100 bool NativeSession::addressForRVA(uint32_t VA, uint32_t &Section,
101                                   uint32_t &Offset) const {
102   return false;
103 }
104 
105 std::unique_ptr<PDBSymbol>
106 NativeSession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
107   return nullptr;
108 }
109 
110 std::unique_ptr<PDBSymbol>
111 NativeSession::findSymbolByRVA(uint32_t RVA, PDB_SymType Type) const {
112   return nullptr;
113 }
114 
115 std::unique_ptr<PDBSymbol>
116 NativeSession::findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
117                                       PDB_SymType Type) const {
118   return nullptr;
119 }
120 
121 std::unique_ptr<IPDBEnumLineNumbers>
122 NativeSession::findLineNumbers(const PDBSymbolCompiland &Compiland,
123                                const IPDBSourceFile &File) const {
124   return nullptr;
125 }
126 
127 std::unique_ptr<IPDBEnumLineNumbers>
128 NativeSession::findLineNumbersByAddress(uint64_t Address,
129                                         uint32_t Length) const {
130   return nullptr;
131 }
132 
133 std::unique_ptr<IPDBEnumLineNumbers>
134 NativeSession::findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const {
135   return nullptr;
136 }
137 
138 std::unique_ptr<IPDBEnumLineNumbers>
139 NativeSession::findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset,
140                                            uint32_t Length) const {
141   return nullptr;
142 }
143 
144 std::unique_ptr<IPDBEnumSourceFiles>
145 NativeSession::findSourceFiles(const PDBSymbolCompiland *Compiland,
146                                StringRef Pattern,
147                                PDB_NameSearchFlags Flags) const {
148   return nullptr;
149 }
150 
151 std::unique_ptr<IPDBSourceFile>
152 NativeSession::findOneSourceFile(const PDBSymbolCompiland *Compiland,
153                                  StringRef Pattern,
154                                  PDB_NameSearchFlags Flags) const {
155   return nullptr;
156 }
157 
158 std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
159 NativeSession::findCompilandsForSourceFile(StringRef Pattern,
160                                            PDB_NameSearchFlags Flags) const {
161   return nullptr;
162 }
163 
164 std::unique_ptr<PDBSymbolCompiland>
165 NativeSession::findOneCompilandForSourceFile(StringRef Pattern,
166                                              PDB_NameSearchFlags Flags) const {
167   return nullptr;
168 }
169 
170 std::unique_ptr<IPDBEnumSourceFiles> NativeSession::getAllSourceFiles() const {
171   return nullptr;
172 }
173 
174 std::unique_ptr<IPDBEnumSourceFiles> NativeSession::getSourceFilesForCompiland(
175     const PDBSymbolCompiland &Compiland) const {
176   return nullptr;
177 }
178 
179 std::unique_ptr<IPDBSourceFile>
180 NativeSession::getSourceFileById(uint32_t FileId) const {
181   return nullptr;
182 }
183 
184 std::unique_ptr<IPDBEnumDataStreams> NativeSession::getDebugStreams() const {
185   return nullptr;
186 }
187 
188 std::unique_ptr<IPDBEnumTables> NativeSession::getEnumTables() const {
189   return nullptr;
190 }
191 
192 std::unique_ptr<IPDBEnumInjectedSources>
193 NativeSession::getInjectedSources() const {
194   return nullptr;
195 }
196 
197 std::unique_ptr<IPDBEnumSectionContribs>
198 NativeSession::getSectionContribs() const {
199   return nullptr;
200 }
201 
202 std::unique_ptr<IPDBEnumFrameData>
203 NativeSession::getFrameData() const {
204   return nullptr;
205 }
206 
207 void NativeSession::initializeExeSymbol() {
208   if (ExeSymbol == 0)
209     ExeSymbol = Cache.createSymbol<NativeExeSymbol>();
210 }
211 
212 NativeExeSymbol &NativeSession::getNativeGlobalScope() const {
213   const_cast<NativeSession &>(*this).initializeExeSymbol();
214 
215   return Cache.getNativeSymbolById<NativeExeSymbol>(ExeSymbol);
216 }
217