LLVM 19.0.0git
DIASession.cpp
Go to the documentation of this file.
1//===- DIASession.cpp - DIA 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//===----------------------------------------------------------------------===//
26#include "llvm/Support/Format.h"
29
30using namespace llvm;
31using namespace llvm::pdb;
32
33template <typename... Ts>
34static Error ErrorFromHResult(HRESULT Result, const char *Str, Ts &&... Args) {
35 SmallString<64> MessageStorage;
36 StringRef Context;
37 if (sizeof...(Args) > 0) {
38 MessageStorage = formatv(Str, std::forward<Ts>(Args)...).str();
39 Context = MessageStorage;
40 } else
41 Context = Str;
42
43 switch (Result) {
44 case E_PDB_NOT_FOUND:
45 return errorCodeToError(std::error_code(ENOENT, std::generic_category()));
46 case E_PDB_FORMAT:
47 return make_error<DIAError>(dia_error_code::invalid_file_format, Context);
48 case E_INVALIDARG:
49 return make_error<DIAError>(dia_error_code::invalid_parameter, Context);
50 case E_UNEXPECTED:
51 return make_error<DIAError>(dia_error_code::already_loaded, Context);
52 case E_PDB_INVALID_SIG:
53 case E_PDB_INVALID_AGE:
54 return make_error<DIAError>(dia_error_code::debug_info_mismatch, Context);
55 default: {
56 std::string S;
58 OS << "HRESULT: " << format_hex(static_cast<DWORD>(Result), 10, true)
59 << ": " << Context;
60 return make_error<DIAError>(dia_error_code::unspecified, OS.str());
61 }
62 }
63}
64
65static Error LoadDIA(CComPtr<IDiaDataSource> &DiaDataSource) {
66 if (SUCCEEDED(CoCreateInstance(CLSID_DiaSource, nullptr, CLSCTX_INPROC_SERVER,
67 IID_IDiaDataSource,
68 reinterpret_cast<LPVOID *>(&DiaDataSource))))
69 return Error::success();
70
71// If the CoCreateInstance call above failed, msdia*.dll is not registered.
72// Try loading the DLL corresponding to the #included DIA SDK.
73#if !defined(_MSC_VER)
74 return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading);
75#else
76 const wchar_t *msdia_dll = L"msdia140.dll";
77 HRESULT HR;
78 if (FAILED(HR = NoRegCoCreate(msdia_dll, CLSID_DiaSource, IID_IDiaDataSource,
79 reinterpret_cast<LPVOID *>(&DiaDataSource))))
80 return ErrorFromHResult(HR, "Calling NoRegCoCreate");
81 return Error::success();
82#endif
83}
84
85DIASession::DIASession(CComPtr<IDiaSession> DiaSession) : Session(DiaSession) {}
86
88 std::unique_ptr<IPDBSession> &Session) {
89 CComPtr<IDiaDataSource> DiaDataSource;
90 CComPtr<IDiaSession> DiaSession;
91
92 // We assume that CoInitializeEx has already been called by the executable.
93 if (auto E = LoadDIA(DiaDataSource))
94 return E;
95
98 return make_error<PDBError>(pdb_error_code::invalid_utf8_path, Path);
99
100 const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());
101 HRESULT HR;
102 if (FAILED(HR = DiaDataSource->loadDataFromPdb(Path16Str))) {
103 return ErrorFromHResult(HR, "Calling loadDataFromPdb {0}", Path);
104 }
105
106 if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
107 return ErrorFromHResult(HR, "Calling openSession");
108
109 Session.reset(new DIASession(DiaSession));
110 return Error::success();
111}
112
114 std::unique_ptr<IPDBSession> &Session) {
115 CComPtr<IDiaDataSource> DiaDataSource;
116 CComPtr<IDiaSession> DiaSession;
117
118 // We assume that CoInitializeEx has already been called by the executable.
119 if (auto EC = LoadDIA(DiaDataSource))
120 return EC;
121
124 return make_error<PDBError>(pdb_error_code::invalid_utf8_path, Path);
125
126 const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());
127 HRESULT HR;
128 if (FAILED(HR = DiaDataSource->loadDataForExe(Path16Str, nullptr, nullptr)))
129 return ErrorFromHResult(HR, "Calling loadDataForExe");
130
131 if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
132 return ErrorFromHResult(HR, "Calling openSession");
133
134 Session.reset(new DIASession(DiaSession));
135 return Error::success();
136}
137
139 uint64_t LoadAddress;
140 bool success = (S_OK == Session->get_loadAddress(&LoadAddress));
141 return (success) ? LoadAddress : 0;
142}
143
145 return (S_OK == Session->put_loadAddress(Address));
146}
147
148std::unique_ptr<PDBSymbolExe> DIASession::getGlobalScope() {
149 CComPtr<IDiaSymbol> GlobalScope;
150 if (S_OK != Session->get_globalScope(&GlobalScope))
151 return nullptr;
152
153 auto RawSymbol = std::make_unique<DIARawSymbol>(*this, GlobalScope);
154 auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
155 std::unique_ptr<PDBSymbolExe> ExeSymbol(
156 static_cast<PDBSymbolExe *>(PdbSymbol.release()));
157 return ExeSymbol;
158}
159
161 uint32_t &Offset) const {
162 DWORD ArgSection, ArgOffset = 0;
163 if (S_OK == Session->addressForVA(VA, &ArgSection, &ArgOffset)) {
164 Section = static_cast<uint32_t>(ArgSection);
165 Offset = static_cast<uint32_t>(ArgOffset);
166 return true;
167 }
168 return false;
169}
170
172 uint32_t &Offset) const {
173 DWORD ArgSection, ArgOffset = 0;
174 if (S_OK == Session->addressForRVA(RVA, &ArgSection, &ArgOffset)) {
175 Section = static_cast<uint32_t>(ArgSection);
176 Offset = static_cast<uint32_t>(ArgOffset);
177 return true;
178 }
179 return false;
180}
181
182std::unique_ptr<PDBSymbol>
184 CComPtr<IDiaSymbol> LocatedSymbol;
185 if (S_OK != Session->symbolById(SymbolId, &LocatedSymbol))
186 return nullptr;
187
188 auto RawSymbol = std::make_unique<DIARawSymbol>(*this, LocatedSymbol);
189 return PDBSymbol::create(*this, std::move(RawSymbol));
190}
191
194 enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
195
196 CComPtr<IDiaSymbol> Symbol;
197 if (S_OK != Session->findSymbolByVA(Address, EnumVal, &Symbol)) {
198 ULONGLONG LoadAddr = 0;
199 if (S_OK != Session->get_loadAddress(&LoadAddr))
200 return nullptr;
201 DWORD RVA = static_cast<DWORD>(Address - LoadAddr);
202 if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))
203 return nullptr;
204 }
205 auto RawSymbol = std::make_unique<DIARawSymbol>(*this, Symbol);
206 return PDBSymbol::create(*this, std::move(RawSymbol));
207}
208
209std::unique_ptr<PDBSymbol> DIASession::findSymbolByRVA(uint32_t RVA,
211 enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
212
213 CComPtr<IDiaSymbol> Symbol;
214 if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))
215 return nullptr;
216
217 auto RawSymbol = std::make_unique<DIARawSymbol>(*this, Symbol);
218 return PDBSymbol::create(*this, std::move(RawSymbol));
219}
220
221std::unique_ptr<PDBSymbol>
224 enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
225
226 CComPtr<IDiaSymbol> Symbol;
227 if (S_OK != Session->findSymbolByAddr(Sect, Offset, EnumVal, &Symbol))
228 return nullptr;
229
230 auto RawSymbol = std::make_unique<DIARawSymbol>(*this, Symbol);
231 return PDBSymbol::create(*this, std::move(RawSymbol));
232}
233
234std::unique_ptr<IPDBEnumLineNumbers>
236 const IPDBSourceFile &File) const {
237 const DIARawSymbol &RawCompiland =
238 static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());
239 const DIASourceFile &RawFile = static_cast<const DIASourceFile &>(File);
240
241 CComPtr<IDiaEnumLineNumbers> LineNumbers;
242 if (S_OK != Session->findLines(RawCompiland.getDiaSymbol(),
243 RawFile.getDiaFile(), &LineNumbers))
244 return nullptr;
245
246 return std::make_unique<DIAEnumLineNumbers>(LineNumbers);
247}
248
249std::unique_ptr<IPDBEnumLineNumbers>
251 CComPtr<IDiaEnumLineNumbers> LineNumbers;
252 if (S_OK != Session->findLinesByVA(Address, Length, &LineNumbers)) {
253 ULONGLONG LoadAddr = 0;
254 if (S_OK != Session->get_loadAddress(&LoadAddr))
255 return nullptr;
256 DWORD RVA = static_cast<DWORD>(Address - LoadAddr);
257 if (S_OK != Session->findLinesByRVA(RVA, Length, &LineNumbers))
258 return nullptr;
259 }
260 return std::make_unique<DIAEnumLineNumbers>(LineNumbers);
261}
262
263std::unique_ptr<IPDBEnumLineNumbers>
265 CComPtr<IDiaEnumLineNumbers> LineNumbers;
266 if (S_OK != Session->findLinesByRVA(RVA, Length, &LineNumbers))
267 return nullptr;
268
269 return std::make_unique<DIAEnumLineNumbers>(LineNumbers);
270}
271
272std::unique_ptr<IPDBEnumLineNumbers>
274 uint32_t Length) const {
275 CComPtr<IDiaEnumLineNumbers> LineNumbers;
276 if (S_OK != Session->findLinesByAddr(Section, Offset, Length, &LineNumbers))
277 return nullptr;
278
279 return std::make_unique<DIAEnumLineNumbers>(LineNumbers);
280}
281
282std::unique_ptr<IPDBEnumSourceFiles>
285 PDB_NameSearchFlags Flags) const {
286 IDiaSymbol *DiaCompiland = nullptr;
287 CComBSTR Utf16Pattern;
288 if (!Pattern.empty())
289 Utf16Pattern = CComBSTR(Pattern.data());
290
291 if (Compiland)
292 DiaCompiland = static_cast<const DIARawSymbol &>(Compiland->getRawSymbol())
293 .getDiaSymbol();
294
295 Flags = static_cast<PDB_NameSearchFlags>(
297 CComPtr<IDiaEnumSourceFiles> SourceFiles;
298 if (S_OK !=
299 Session->findFile(DiaCompiland, Utf16Pattern.m_str, Flags, &SourceFiles))
300 return nullptr;
301 return std::make_unique<DIAEnumSourceFiles>(*this, SourceFiles);
302}
303
304std::unique_ptr<IPDBSourceFile>
307 PDB_NameSearchFlags Flags) const {
309 if (!SourceFiles || SourceFiles->getChildCount() == 0)
310 return nullptr;
311 return SourceFiles->getNext();
312}
313
314std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
316 PDB_NameSearchFlags Flags) const {
317 auto File = findOneSourceFile(nullptr, Pattern, Flags);
318 if (!File)
319 return nullptr;
320 return File->getCompilands();
321}
322
323std::unique_ptr<PDBSymbolCompiland>
325 PDB_NameSearchFlags Flags) const {
326 auto Compilands = findCompilandsForSourceFile(Pattern, Flags);
327 if (!Compilands || Compilands->getChildCount() == 0)
328 return nullptr;
329 return Compilands->getNext();
330}
331
332std::unique_ptr<IPDBEnumSourceFiles> DIASession::getAllSourceFiles() const {
333 CComPtr<IDiaEnumSourceFiles> Files;
334 if (S_OK != Session->findFile(nullptr, nullptr, nsNone, &Files))
335 return nullptr;
336
337 return std::make_unique<DIAEnumSourceFiles>(*this, Files);
338}
339
340std::unique_ptr<IPDBEnumSourceFiles> DIASession::getSourceFilesForCompiland(
341 const PDBSymbolCompiland &Compiland) const {
342 CComPtr<IDiaEnumSourceFiles> Files;
343
344 const DIARawSymbol &RawSymbol =
345 static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());
346 if (S_OK !=
347 Session->findFile(RawSymbol.getDiaSymbol(), nullptr, nsNone, &Files))
348 return nullptr;
349
350 return std::make_unique<DIAEnumSourceFiles>(*this, Files);
351}
352
353std::unique_ptr<IPDBSourceFile>
355 CComPtr<IDiaSourceFile> LocatedFile;
356 if (S_OK != Session->findFileById(FileId, &LocatedFile))
357 return nullptr;
358
359 return std::make_unique<DIASourceFile>(*this, LocatedFile);
360}
361
362std::unique_ptr<IPDBEnumDataStreams> DIASession::getDebugStreams() const {
363 CComPtr<IDiaEnumDebugStreams> DiaEnumerator;
364 if (S_OK != Session->getEnumDebugStreams(&DiaEnumerator))
365 return nullptr;
366
367 return std::make_unique<DIAEnumDebugStreams>(DiaEnumerator);
368}
369
370std::unique_ptr<IPDBEnumTables> DIASession::getEnumTables() const {
371 CComPtr<IDiaEnumTables> DiaEnumerator;
372 if (S_OK != Session->getEnumTables(&DiaEnumerator))
373 return nullptr;
374
375 return std::make_unique<DIAEnumTables>(DiaEnumerator);
376}
377
378template <class T> static CComPtr<T> getTableEnumerator(IDiaSession &Session) {
379 CComPtr<T> Enumerator;
380 CComPtr<IDiaEnumTables> ET;
381 CComPtr<IDiaTable> Table;
382 ULONG Count = 0;
383
384 if (Session.getEnumTables(&ET) != S_OK)
385 return nullptr;
386
387 while (ET->Next(1, &Table, &Count) == S_OK && Count == 1) {
388 // There is only one table that matches the given iid
389 if (S_OK == Table->QueryInterface(__uuidof(T), (void **)&Enumerator))
390 break;
391 Table.Release();
392 }
393 return Enumerator;
394}
395std::unique_ptr<IPDBEnumInjectedSources>
397 CComPtr<IDiaEnumInjectedSources> Files =
398 getTableEnumerator<IDiaEnumInjectedSources>(*Session);
399 if (!Files)
400 return nullptr;
401
402 return std::make_unique<DIAEnumInjectedSources>(Files);
403}
404
405std::unique_ptr<IPDBEnumSectionContribs>
407 CComPtr<IDiaEnumSectionContribs> Sections =
408 getTableEnumerator<IDiaEnumSectionContribs>(*Session);
409 if (!Sections)
410 return nullptr;
411
412 return std::make_unique<DIAEnumSectionContribs>(*this, Sections);
413}
414
415std::unique_ptr<IPDBEnumFrameData>
417 CComPtr<IDiaEnumFrameData> FD =
418 getTableEnumerator<IDiaEnumFrameData>(*Session);
419 if (!FD)
420 return nullptr;
421
422 return std::make_unique<DIAEnumFrameData>(FD);
423}
static Error ErrorFromHResult(HRESULT Result, const char *Str, Ts &&... Args)
Definition: DIASession.cpp:34
static CComPtr< T > getTableEnumerator(IDiaSession &Session)
Definition: DIASession.cpp:378
static Error LoadDIA(CComPtr< IDiaDataSource > &DiaDataSource)
Definition: DIASession.cpp:65
This file contains some templates that are useful if you are working with the STL at all.
raw_pwrite_stream & OS
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
pointer data()
Return a pointer to the vector's buffer, even if empty().
Definition: SmallVector.h:299
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
CComPtr< IDiaSymbol > getDiaSymbol() const
Definition: DIARawSymbol.h:25
std::unique_ptr< IPDBSourceFile > findOneSourceFile(const PDBSymbolCompiland *Compiland, llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:305
std::unique_ptr< IPDBEnumSourceFiles > findSourceFiles(const PDBSymbolCompiland *Compiland, llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:283
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const override
Definition: DIASession.cpp:264
std::unique_ptr< IPDBEnumSourceFiles > getSourceFilesForCompiland(const PDBSymbolCompiland &Compiland) const override
Definition: DIASession.cpp:340
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbersByAddress(uint64_t Address, uint32_t Length) const override
Definition: DIASession.cpp:250
static Error createFromExe(StringRef Path, std::unique_ptr< IPDBSession > &Session)
Definition: DIASession.cpp:113
uint64_t getLoadAddress() const override
Definition: DIASession.cpp:138
std::unique_ptr< IPDBEnumSourceFiles > getAllSourceFiles() const override
Definition: DIASession.cpp:332
bool addressForVA(uint64_t VA, uint32_t &Section, uint32_t &Offset) const override
Definition: DIASession.cpp:160
std::unique_ptr< PDBSymbolExe > getGlobalScope() override
Definition: DIASession.cpp:148
std::unique_ptr< PDBSymbol > findSymbolByAddress(uint64_t Address, PDB_SymType Type) override
Definition: DIASession.cpp:192
std::unique_ptr< IPDBEnumInjectedSources > getInjectedSources() const override
Definition: DIASession.cpp:396
std::unique_ptr< PDBSymbolCompiland > findOneCompilandForSourceFile(llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:324
DIASession(CComPtr< IDiaSession > DiaSession)
Definition: DIASession.cpp:85
std::unique_ptr< IPDBEnumChildren< PDBSymbolCompiland > > findCompilandsForSourceFile(llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:315
bool setLoadAddress(uint64_t Address) override
Definition: DIASession.cpp:144
static Error createFromPdb(StringRef Path, std::unique_ptr< IPDBSession > &Session)
Definition: DIASession.cpp:87
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbers(const PDBSymbolCompiland &Compiland, const IPDBSourceFile &File) const override
Definition: DIASession.cpp:235
std::unique_ptr< IPDBEnumDataStreams > getDebugStreams() const override
Definition: DIASession.cpp:362
bool addressForRVA(uint32_t RVA, uint32_t &Section, uint32_t &Offset) const override
Definition: DIASession.cpp:171
std::unique_ptr< PDBSymbol > getSymbolById(SymIndexId SymbolId) const override
Definition: DIASession.cpp:183
std::unique_ptr< IPDBSourceFile > getSourceFileById(uint32_t FileId) const override
Definition: DIASession.cpp:354
std::unique_ptr< IPDBEnumFrameData > getFrameData() const override
Definition: DIASession.cpp:416
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset, uint32_t Length) const override
Definition: DIASession.cpp:273
std::unique_ptr< PDBSymbol > findSymbolByRVA(uint32_t RVA, PDB_SymType Type) override
Definition: DIASession.cpp:209
std::unique_ptr< IPDBEnumTables > getEnumTables() const override
Definition: DIASession.cpp:370
std::unique_ptr< PDBSymbol > findSymbolBySectOffset(uint32_t Section, uint32_t Offset, PDB_SymType Type) override
Definition: DIASession.cpp:222
std::unique_ptr< IPDBEnumSectionContribs > getSectionContribs() const override
Definition: DIASession.cpp:406
CComPtr< IDiaSourceFile > getDiaFile() const
Definition: DIASourceFile.h:31
IPDBSourceFile defines an interface used to represent source files whose information are stored in th...
static std::unique_ptr< PDBSymbol > create(const IPDBSession &PDBSession, std::unique_ptr< IPDBRawSymbol > RawSymbol)
Definition: PDBSymbol.cpp:102
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:661
PDB_NameSearchFlags
Defines flags used for enumerating child symbols.
Definition: PDBTypes.h:102
@ NS_FileNameExtMatch
Definition: PDBTypes.h:106
PDB_SymType
These values correspond to the SymTagEnum enumeration, and are documented here: https://msdn....
Definition: PDBTypes.h:243
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Length
Definition: DWP.cpp:456
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
FormattedNumber format_hex(uint64_t N, unsigned Width, bool Upper=false)
format_hex - Output N as a fixed width hexadecimal.
Definition: Format.h:187
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:111
bool convertUTF8ToUTF16String(StringRef SrcUTF8, SmallVectorImpl< UTF16 > &DstUTF16)
Converts a UTF-8 string into a UTF-16 string with native endianness.