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