LLVM  7.0.0svn
DIASession.cpp
Go to the documentation of this file.
1 //===- DIASession.cpp - DIA 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 //===----------------------------------------------------------------------===//
10 #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 make_error<GenericError>(generic_error_code::invalid_path, Context);
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<GenericError>(
75  "DIA is only supported when using MSVC.");
76 #else
77  const wchar_t *msdia_dll = nullptr;
78 #if _MSC_VER >= 1900 && _MSC_VER < 2000
79  msdia_dll = L"msdia140.dll"; // VS2015
80 #elif _MSC_VER >= 1800
81  msdia_dll = L"msdia120.dll"; // VS2013
82 #else
83 #error "Unknown Visual Studio version."
84 #endif
85 
86  HRESULT HR;
87  if (FAILED(HR = NoRegCoCreate(msdia_dll, CLSID_DiaSource, IID_IDiaDataSource,
88  reinterpret_cast<LPVOID *>(&DiaDataSource))))
89  return ErrorFromHResult(HR, "Calling NoRegCoCreate");
90  return Error::success();
91 #endif
92 }
93 
94 DIASession::DIASession(CComPtr<IDiaSession> DiaSession) : Session(DiaSession) {}
95 
97  std::unique_ptr<IPDBSession> &Session) {
98  CComPtr<IDiaDataSource> DiaDataSource;
99  CComPtr<IDiaSession> DiaSession;
100 
101  // We assume that CoInitializeEx has already been called by the executable.
102  if (auto E = LoadDIA(DiaDataSource))
103  return E;
104 
106  if (!llvm::convertUTF8ToUTF16String(Path, Path16))
107  return make_error<GenericError>(generic_error_code::invalid_path);
108 
109  const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());
110  HRESULT HR;
111  if (FAILED(HR = DiaDataSource->loadDataFromPdb(Path16Str))) {
112  return ErrorFromHResult(HR, "Calling loadDataFromPdb {0}", Path);
113  }
114 
115  if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
116  return ErrorFromHResult(HR, "Calling openSession");
117 
118  Session.reset(new DIASession(DiaSession));
119  return Error::success();
120 }
121 
123  std::unique_ptr<IPDBSession> &Session) {
124  CComPtr<IDiaDataSource> DiaDataSource;
125  CComPtr<IDiaSession> DiaSession;
126 
127  // We assume that CoInitializeEx has already been called by the executable.
128  if (auto EC = LoadDIA(DiaDataSource))
129  return EC;
130 
132  if (!llvm::convertUTF8ToUTF16String(Path, Path16))
133  return make_error<GenericError>(generic_error_code::invalid_path, Path);
134 
135  const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());
136  HRESULT HR;
137  if (FAILED(HR = DiaDataSource->loadDataForExe(Path16Str, nullptr, nullptr)))
138  return ErrorFromHResult(HR, "Calling loadDataForExe");
139 
140  if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
141  return ErrorFromHResult(HR, "Calling openSession");
142 
143  Session.reset(new DIASession(DiaSession));
144  return Error::success();
145 }
146 
147 uint64_t DIASession::getLoadAddress() const {
148  uint64_t LoadAddress;
149  bool success = (S_OK == Session->get_loadAddress(&LoadAddress));
150  return (success) ? LoadAddress : 0;
151 }
152 
153 bool DIASession::setLoadAddress(uint64_t Address) {
154  return (S_OK == Session->put_loadAddress(Address));
155 }
156 
157 std::unique_ptr<PDBSymbolExe> DIASession::getGlobalScope() {
158  CComPtr<IDiaSymbol> GlobalScope;
159  if (S_OK != Session->get_globalScope(&GlobalScope))
160  return nullptr;
161 
162  auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, GlobalScope);
163  auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
164  std::unique_ptr<PDBSymbolExe> ExeSymbol(
165  static_cast<PDBSymbolExe *>(PdbSymbol.release()));
166  return ExeSymbol;
167 }
168 
170  uint32_t &Offset) const {
171  DWORD ArgSection, ArgOffset = 0;
172  if (S_OK == Session->addressForVA(VA, &ArgSection, &ArgOffset)) {
173  Section = static_cast<uint32_t>(ArgSection);
174  Offset = static_cast<uint32_t>(ArgOffset);
175  return true;
176  }
177  return false;
178 }
179 
181  uint32_t &Offset) const {
182  DWORD ArgSection, ArgOffset = 0;
183  if (S_OK == Session->addressForRVA(RVA, &ArgSection, &ArgOffset)) {
184  Section = static_cast<uint32_t>(ArgSection);
185  Offset = static_cast<uint32_t>(ArgOffset);
186  return true;
187  }
188  return false;
189 }
190 
191 std::unique_ptr<PDBSymbol> DIASession::getSymbolById(uint32_t SymbolId) const {
192  CComPtr<IDiaSymbol> LocatedSymbol;
193  if (S_OK != Session->symbolById(SymbolId, &LocatedSymbol))
194  return nullptr;
195 
196  auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, LocatedSymbol);
197  return PDBSymbol::create(*this, std::move(RawSymbol));
198 }
199 
200 std::unique_ptr<PDBSymbol>
202  enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
203 
204  CComPtr<IDiaSymbol> Symbol;
205  if (S_OK != Session->findSymbolByVA(Address, EnumVal, &Symbol)) {
206  ULONGLONG LoadAddr = 0;
207  if (S_OK != Session->get_loadAddress(&LoadAddr))
208  return nullptr;
209  DWORD RVA = static_cast<DWORD>(Address - LoadAddr);
210  if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))
211  return nullptr;
212  }
213  auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, Symbol);
214  return PDBSymbol::create(*this, std::move(RawSymbol));
215 }
216 
217 std::unique_ptr<PDBSymbol> DIASession::findSymbolByRVA(uint32_t RVA,
218  PDB_SymType Type) const {
219  enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
220 
221  CComPtr<IDiaSymbol> Symbol;
222  if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))
223  return nullptr;
224 
225  auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, Symbol);
226  return PDBSymbol::create(*this, std::move(RawSymbol));
227 }
228 
229 std::unique_ptr<PDBSymbol>
231  PDB_SymType Type) const {
232  enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
233 
234  CComPtr<IDiaSymbol> Symbol;
235  if (S_OK != Session->findSymbolByAddr(Sect, Offset, EnumVal, &Symbol))
236  return nullptr;
237 
238  auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, Symbol);
239  return PDBSymbol::create(*this, std::move(RawSymbol));
240 }
241 
242 std::unique_ptr<IPDBEnumLineNumbers>
244  const IPDBSourceFile &File) const {
245  const DIARawSymbol &RawCompiland =
246  static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());
247  const DIASourceFile &RawFile = static_cast<const DIASourceFile &>(File);
248 
249  CComPtr<IDiaEnumLineNumbers> LineNumbers;
250  if (S_OK != Session->findLines(RawCompiland.getDiaSymbol(),
251  RawFile.getDiaFile(), &LineNumbers))
252  return nullptr;
253 
254  return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
255 }
256 
257 std::unique_ptr<IPDBEnumLineNumbers>
258 DIASession::findLineNumbersByAddress(uint64_t Address, uint32_t Length) const {
259  CComPtr<IDiaEnumLineNumbers> LineNumbers;
260  if (S_OK != Session->findLinesByVA(Address, Length, &LineNumbers)) {
261  ULONGLONG LoadAddr = 0;
262  if (S_OK != Session->get_loadAddress(&LoadAddr))
263  return nullptr;
264  DWORD RVA = static_cast<DWORD>(Address - LoadAddr);
265  if (S_OK != Session->findLinesByRVA(RVA, Length, &LineNumbers))
266  return nullptr;
267  }
268  return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
269 }
270 
271 std::unique_ptr<IPDBEnumLineNumbers>
273  CComPtr<IDiaEnumLineNumbers> LineNumbers;
274  if (S_OK != Session->findLinesByRVA(RVA, Length, &LineNumbers))
275  return nullptr;
276 
277  return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
278 }
279 
280 std::unique_ptr<IPDBEnumLineNumbers>
282  uint32_t Length) const {
283  CComPtr<IDiaEnumLineNumbers> LineNumbers;
284  if (S_OK != Session->findLinesByAddr(Section, Offset, Length, &LineNumbers))
285  return nullptr;
286 
287  return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
288 }
289 
290 std::unique_ptr<IPDBEnumSourceFiles>
292  llvm::StringRef Pattern,
293  PDB_NameSearchFlags Flags) const {
294  IDiaSymbol *DiaCompiland = nullptr;
295  CComBSTR Utf16Pattern;
296  if (!Pattern.empty())
297  Utf16Pattern = CComBSTR(Pattern.data());
298 
299  if (Compiland)
300  DiaCompiland = static_cast<const DIARawSymbol &>(Compiland->getRawSymbol())
301  .getDiaSymbol();
302 
303  Flags = static_cast<PDB_NameSearchFlags>(
305  CComPtr<IDiaEnumSourceFiles> SourceFiles;
306  if (S_OK !=
307  Session->findFile(DiaCompiland, Utf16Pattern.m_str, Flags, &SourceFiles))
308  return nullptr;
309  return llvm::make_unique<DIAEnumSourceFiles>(*this, SourceFiles);
310 }
311 
312 std::unique_ptr<IPDBSourceFile>
314  llvm::StringRef Pattern,
315  PDB_NameSearchFlags Flags) const {
316  auto SourceFiles = findSourceFiles(Compiland, Pattern, Flags);
317  if (!SourceFiles || SourceFiles->getChildCount() == 0)
318  return nullptr;
319  return SourceFiles->getNext();
320 }
321 
322 std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
324  PDB_NameSearchFlags Flags) const {
325  auto File = findOneSourceFile(nullptr, Pattern, Flags);
326  if (!File)
327  return nullptr;
328  return File->getCompilands();
329 }
330 
331 std::unique_ptr<PDBSymbolCompiland>
333  PDB_NameSearchFlags Flags) const {
334  auto Compilands = findCompilandsForSourceFile(Pattern, Flags);
335  if (!Compilands || Compilands->getChildCount() == 0)
336  return nullptr;
337  return Compilands->getNext();
338 }
339 
340 std::unique_ptr<IPDBEnumSourceFiles> DIASession::getAllSourceFiles() const {
341  CComPtr<IDiaEnumSourceFiles> Files;
342  if (S_OK != Session->findFile(nullptr, nullptr, nsNone, &Files))
343  return nullptr;
344 
345  return llvm::make_unique<DIAEnumSourceFiles>(*this, Files);
346 }
347 
348 std::unique_ptr<IPDBEnumSourceFiles> DIASession::getSourceFilesForCompiland(
349  const PDBSymbolCompiland &Compiland) const {
350  CComPtr<IDiaEnumSourceFiles> Files;
351 
352  const DIARawSymbol &RawSymbol =
353  static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());
354  if (S_OK !=
355  Session->findFile(RawSymbol.getDiaSymbol(), nullptr, nsNone, &Files))
356  return nullptr;
357 
358  return llvm::make_unique<DIAEnumSourceFiles>(*this, Files);
359 }
360 
361 std::unique_ptr<IPDBSourceFile>
363  CComPtr<IDiaSourceFile> LocatedFile;
364  if (S_OK != Session->findFileById(FileId, &LocatedFile))
365  return nullptr;
366 
367  return llvm::make_unique<DIASourceFile>(*this, LocatedFile);
368 }
369 
370 std::unique_ptr<IPDBEnumDataStreams> DIASession::getDebugStreams() const {
371  CComPtr<IDiaEnumDebugStreams> DiaEnumerator;
372  if (S_OK != Session->getEnumDebugStreams(&DiaEnumerator))
373  return nullptr;
374 
375  return llvm::make_unique<DIAEnumDebugStreams>(DiaEnumerator);
376 }
377 
378 std::unique_ptr<IPDBEnumTables> DIASession::getEnumTables() const {
379  CComPtr<IDiaEnumTables> DiaEnumerator;
380  if (S_OK != Session->getEnumTables(&DiaEnumerator))
381  return nullptr;
382 
383  return llvm::make_unique<DIAEnumTables>(DiaEnumerator);
384 }
385 
386 template <class T> static CComPtr<T> getTableEnumerator(IDiaSession &Session) {
387  CComPtr<T> Enumerator;
388  CComPtr<IDiaEnumTables> ET;
389  CComPtr<IDiaTable> Table;
390  ULONG Count = 0;
391 
392  if (Session.getEnumTables(&ET) != S_OK)
393  return nullptr;
394 
395  while (ET->Next(1, &Table, &Count) == S_OK && Count == 1) {
396  // There is only one table that matches the given iid
397  if (S_OK == Table->QueryInterface(__uuidof(T), (void **)&Enumerator))
398  break;
399  Table.Release();
400  }
401  return Enumerator;
402 }
403 std::unique_ptr<IPDBEnumInjectedSources>
405  CComPtr<IDiaEnumInjectedSources> Files =
406  getTableEnumerator<IDiaEnumInjectedSources>(*Session);
407  if (!Files)
408  return nullptr;
409 
410  return llvm::make_unique<DIAEnumInjectedSources>(*this, Files);
411 }
412 
413 std::unique_ptr<IPDBEnumSectionContribs>
415  CComPtr<IDiaEnumSectionContribs> Sections =
416  getTableEnumerator<IDiaEnumSectionContribs>(*Session);
417  if (!Sections)
418  return nullptr;
419 
420  return llvm::make_unique<DIAEnumSectionContribs>(*this, Sections);
421 }
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const override
Definition: DIASession.cpp:272
LLVMContext & Context
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
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:157
PDB_NameSearchFlags
Defines flags used for enumerating child symbols.
Definition: PDBTypes.h:97
std::unique_ptr< IPDBEnumInjectedSources > getInjectedSources() const override
Definition: DIASession.cpp:404
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:201
std::unique_ptr< IPDBEnumChildren< PDBSymbolCompiland > > findCompilandsForSourceFile(llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:323
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
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:362
bool setLoadAddress(uint64_t Address) override
Definition: DIASession.cpp:153
static std::unique_ptr< PDBSymbol > create(const IPDBSession &PDBSession, std::unique_ptr< IPDBRawSymbol > Symbol)
Definition: PDBSymbol.cpp:67
std::unique_ptr< IPDBEnumSourceFiles > findSourceFiles(const PDBSymbolCompiland *Compiland, llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:291
static Error createFromPdb(StringRef Path, std::unique_ptr< IPDBSession > &Session)
Definition: DIASession.cpp:96
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset, uint32_t Length) const override
Definition: DIASession.cpp:281
std::unique_ptr< IPDBSourceFile > findOneSourceFile(const PDBSymbolCompiland *Compiland, llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:313
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbersByAddress(uint64_t Address, uint32_t Length) const override
Definition: DIASession.cpp:258
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:179
std::unique_ptr< PDBSymbol > findSymbolByRVA(uint32_t RVA, PDB_SymType Type) const override
Definition: DIASession.cpp:217
std::unique_ptr< IPDBEnumSourceFiles > getSourceFilesForCompiland(const PDBSymbolCompiland &Compiland) const override
Definition: DIASession.cpp:348
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
std::unique_ptr< IPDBEnumSourceFiles > getAllSourceFiles() const override
Definition: DIASession.cpp:340
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static Error ErrorFromHResult(HRESULT Result, const char *Str, Ts &&... Args)
Definition: DIASession.cpp:34
DIASession(CComPtr< IDiaSession > DiaSession)
Definition: DIASession.cpp:94
std::unique_ptr< IPDBEnumLineNumbers > findLineNumbers(const PDBSymbolCompiland &Compiland, const IPDBSourceFile &File) const override
Definition: DIASession.cpp:243
std::string & str()
Flushes the stream contents to the target string and returns the string&#39;s reference.
Definition: raw_ostream.h:483
bool addressForRVA(uint32_t RVA, uint32_t &Section, uint32_t &Offset) const override
Definition: DIASession.cpp:180
std::unique_ptr< IPDBEnumDataStreams > getDebugStreams() const override
Definition: DIASession.cpp:370
static ErrorSuccess success()
Create a success value.
Definition: Error.h:313
std::unique_ptr< PDBSymbolCompiland > findOneCompilandForSourceFile(llvm::StringRef Pattern, PDB_NameSearchFlags Flags) const override
Definition: DIASession.cpp:332
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:862
std::unique_ptr< PDBSymbol > findSymbolBySectOffset(uint32_t Section, uint32_t Offset, PDB_SymType Type) const override
Definition: DIASession.cpp:230
const IPDBRawSymbol & getRawSymbol() const
Definition: PDBSymbol.h:118
CComPtr< IDiaSourceFile > getDiaFile() const
Definition: DIASourceFile.h:32
std::unique_ptr< IPDBEnumSectionContribs > getSectionContribs() const override
Definition: DIASession.cpp:414
success
Parameters (see the expansion example below): (the builder, addr, loaded, new_val, ordering, /* OUT.
static CComPtr< T > getTableEnumerator(IDiaSession &Session)
Definition: DIASession.cpp:386
pointer data()
Return a pointer to the vector&#39;s buffer, even if empty().
Definition: SmallVector.h:143
std::unique_ptr< PDBSymbol > getSymbolById(uint32_t SymbolId) const override
Definition: DIASession.cpp:191
std::unique_ptr< IPDBEnumTables > getEnumTables() const override
Definition: DIASession.cpp:378
CComPtr< IDiaSymbol > getDiaSymbol() const
Definition: DIARawSymbol.h:25
static Error createFromExe(StringRef Path, std::unique_ptr< IPDBSession > &Session)
Definition: DIASession.cpp:122
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:467
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
bool addressForVA(uint64_t VA, uint32_t &Section, uint32_t &Offset) const override
Definition: DIASession.cpp:169
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
uint64_t getLoadAddress() const override
Definition: DIASession.cpp:147
constexpr char Args[]
Key for Kernel::Metadata::mArgs.