LLVM  10.0.0svn
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 //===----------------------------------------------------------------------===//
9 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/DebugInfo/PDB/PDB.h"
26 #include "llvm/Support/Format.h"
29 
30 using namespace llvm;
31 using namespace llvm::pdb;
32 
33 template <typename... Ts>
34 static Error ErrorFromHResult(HRESULT Result, const char *Str, Ts &&... Args) {
35  SmallString<64> MessageStorage;
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;
57  raw_string_ostream OS(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 
65 static 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 
85 DIASession::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 
97  if (!llvm::convertUTF8ToUTF16String(Path, Path16))
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 
123  if (!llvm::convertUTF8ToUTF16String(Path, Path16))
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 
138 uint64_t DIASession::getLoadAddress() const {
139  uint64_t LoadAddress;
140  bool success = (S_OK == Session->get_loadAddress(&LoadAddress));
141  return (success) ? LoadAddress : 0;
142 }
143 
144 bool DIASession::setLoadAddress(uint64_t Address) {
145  return (S_OK == Session->put_loadAddress(Address));
146 }
147 
148 std::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 
182 std::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 
192 std::unique_ptr<PDBSymbol>
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 
209 std::unique_ptr<PDBSymbol> DIASession::findSymbolByRVA(uint32_t RVA,
210  PDB_SymType Type) const {
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 
221 std::unique_ptr<PDBSymbol>
223  PDB_SymType Type) const {
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 
234 std::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 
249 std::unique_ptr<IPDBEnumLineNumbers>
250 DIASession::findLineNumbersByAddress(uint64_t Address, uint32_t Length) const {
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 
263 std::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 
272 std::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 
282 std::unique_ptr<IPDBEnumSourceFiles>
284  llvm::StringRef Pattern,
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 
304 std::unique_ptr<IPDBSourceFile>
306  llvm::StringRef Pattern,
307  PDB_NameSearchFlags Flags) const {
308  auto SourceFiles = findSourceFiles(Compiland, Pattern, Flags);
309  if (!SourceFiles || SourceFiles->getChildCount() == 0)
310  return nullptr;
311  return SourceFiles->getNext();
312 }
313 
314 std::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 
323 std::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 
332 std::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 
340 std::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 
353 std::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 
362 std::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 
370 std::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 
378 template <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 }
395 std::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 
405 std::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 
415 std::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 }
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const override
Definition: DIASession.cpp:264
LLVMContext & Context
This class represents lattice values for constants.
Definition: AllocatorList.h:23
FormattedNumber format_hex(uint64_t N, unsigned Width, bool Upper=false)
format_hex - Output N as a fixed width hexadecimal.
Definition: Format.h:186
std::unique_ptr< PDBSymbolExe > getGlobalScope() override
Definition: DIASession.cpp:148
PDB_NameSearchFlags
Defines flags used for enumerating child symbols.
Definition: PDBTypes.h:100
std::unique_ptr< IPDBEnumInjectedSources > getInjectedSources() const override
Definition: DIASession.cpp:396
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
std::unique_ptr< PDBSymbol > findSymbolByAddress(uint64_t Address, PDB_SymType Type) const override
Definition: DIASession.cpp:193
std::unique_ptr< IPDBEnumChildren< PDBSymbolCompiland > > findCompilandsForSourceFile(llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:315
IPDBSourceFile defines an interface used to represent source files whose information are stored in th...
std::unique_ptr< IPDBSourceFile > getSourceFileById(uint32_t FileId) const override
Definition: DIASession.cpp:354
bool setLoadAddress(uint64_t Address) override
Definition: DIASession.cpp:144
std::unique_ptr< PDBSymbol > getSymbolById(SymIndexId SymbolId) const override
Definition: DIASession.cpp:183
std::unique_ptr< IPDBEnumSourceFiles > findSourceFiles(const PDBSymbolCompiland *Compiland, llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:283
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:126
static Error createFromPdb(StringRef Path, std::unique_ptr< IPDBSession > &Session)
Definition: DIASession.cpp:87
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset, uint32_t Length) const override
Definition: DIASession.cpp:273
std::unique_ptr< IPDBEnumFrameData > getFrameData() const override
Definition: DIASession.cpp:416
std::unique_ptr< IPDBSourceFile > findOneSourceFile(const PDBSymbolCompiland *Compiland, llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:305
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbersByAddress(uint64_t Address, uint32_t Length) const override
Definition: DIASession.cpp:250
bool convertUTF8ToUTF16String(StringRef SrcUTF8, SmallVectorImpl< UTF16 > &DstUTF16)
Converts a UTF-8 string into a UTF-16 string with native endianness.
PDB_SymType
These values correspond to the SymTagEnum enumeration, and are documented here: https://msdn.microsoft.com/en-us/library/bkedss5f.aspx.
Definition: PDBTypes.h:241
std::unique_ptr< PDBSymbol > findSymbolByRVA(uint32_t RVA, PDB_SymType Type) const override
Definition: DIASession.cpp:209
std::unique_ptr< IPDBEnumSourceFiles > getSourceFilesForCompiland(const PDBSymbolCompiland &Compiland) const override
Definition: DIASession.cpp:340
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
std::unique_ptr< IPDBEnumSourceFiles > getAllSourceFiles() const override
Definition: DIASession.cpp:332
Instrumentation for Order File
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
static Error ErrorFromHResult(HRESULT Result, const char *Str, Ts &&... Args)
Definition: DIASession.cpp:34
DIASession(CComPtr< IDiaSession > DiaSession)
Definition: DIASession.cpp:85
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbers(const PDBSymbolCompiland &Compiland, const IPDBSourceFile &File) const override
Definition: DIASession.cpp:235
std::string & str()
Flushes the stream contents to the target string and returns the string&#39;s reference.
Definition: raw_ostream.h:519
bool addressForRVA(uint32_t RVA, uint32_t &Section, uint32_t &Offset) const override
Definition: DIASession.cpp:171
std::unique_ptr< IPDBEnumDataStreams > getDebugStreams() const override
Definition: DIASession.cpp:362
static ErrorSuccess success()
Create a success value.
Definition: Error.h:326
std::unique_ptr< PDBSymbolCompiland > findOneCompilandForSourceFile(llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:324
static Error LoadDIA(CComPtr< IDiaDataSource > &DiaDataSource)
Definition: DIASession.cpp:65
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
std::unique_ptr< PDBSymbol > findSymbolBySectOffset(uint32_t Section, uint32_t Offset, PDB_SymType Type) const override
Definition: DIASession.cpp:222
const IPDBRawSymbol & getRawSymbol() const
Definition: PDBSymbol.h:148
CComPtr< IDiaSourceFile > getDiaFile() const
Definition: DIASourceFile.h:31
std::unique_ptr< IPDBEnumSectionContribs > getSectionContribs() const override
Definition: DIASession.cpp:406
success
Parameters (see the expansion example below): (the builder, addr, loaded, new_val, ordering, /* OUT.
static CComPtr< T > getTableEnumerator(IDiaSession &Session)
Definition: DIASession.cpp:378
pointer data()
Return a pointer to the vector&#39;s buffer, even if empty().
Definition: SmallVector.h:144
std::unique_ptr< IPDBEnumTables > getEnumTables() const override
Definition: DIASession.cpp:370
CComPtr< IDiaSymbol > getDiaSymbol() const
Definition: DIARawSymbol.h:25
static Error createFromExe(StringRef Path, std::unique_ptr< IPDBSession > &Session)
Definition: DIASession.cpp:113
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:122
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:503
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
bool addressForVA(uint64_t VA, uint32_t &Section, uint32_t &Offset) const override
Definition: DIASession.cpp:160
static std::unique_ptr< PDBSymbol > create(const IPDBSession &PDBSession, std::unique_ptr< IPDBRawSymbol > RawSymbol)
Definition: PDBSymbol.cpp:102
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
uint64_t getLoadAddress() const override
Definition: DIASession.cpp:138
constexpr char Args[]
Key for Kernel::Metadata::mArgs.