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 //===----------------------------------------------------------------------===//
9 #include "llvm/DebugInfo/PDB/DIA/DIASession.h"
10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/DebugInfo/PDB/DIA/DIAEnumDebugStreams.h"
12 #include "llvm/DebugInfo/PDB/DIA/DIAEnumFrameData.h"
13 #include "llvm/DebugInfo/PDB/DIA/DIAEnumInjectedSources.h"
14 #include "llvm/DebugInfo/PDB/DIA/DIAEnumLineNumbers.h"
15 #include "llvm/DebugInfo/PDB/DIA/DIAEnumSectionContribs.h"
16 #include "llvm/DebugInfo/PDB/DIA/DIAEnumSourceFiles.h"
17 #include "llvm/DebugInfo/PDB/DIA/DIAEnumTables.h"
18 #include "llvm/DebugInfo/PDB/DIA/DIAError.h"
19 #include "llvm/DebugInfo/PDB/DIA/DIARawSymbol.h"
20 #include "llvm/DebugInfo/PDB/DIA/DIASourceFile.h"
21 #include "llvm/DebugInfo/PDB/DIA/DIASupport.h"
22 #include "llvm/DebugInfo/PDB/GenericError.h"
23 #include "llvm/DebugInfo/PDB/PDB.h"
24 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
25 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
26 #include "llvm/Support/ConvertUTF.h"
27 #include "llvm/Support/Format.h"
28 #include "llvm/Support/FormatVariadic.h"
29 #include "llvm/Support/raw_ostream.h"
30 
31 using namespace llvm;
32 using namespace llvm::pdb;
33 
34 template <typename... Ts>
35 static Error ErrorFromHResult(HRESULT Result, const char *Str, Ts &&... Args) {
36   SmallString<64> MessageStorage;
37   StringRef Context;
38   if (sizeof...(Args) > 0) {
39     MessageStorage = formatv(Str, std::forward<Ts>(Args)...).str();
40     Context = MessageStorage;
41   } else
42     Context = Str;
43 
44   switch (Result) {
45   case E_PDB_NOT_FOUND:
46     return errorCodeToError(std::error_code(ENOENT, std::generic_category()));
47   case E_PDB_FORMAT:
48     return make_error<DIAError>(dia_error_code::invalid_file_format, Context);
49   case E_INVALIDARG:
50     return make_error<DIAError>(dia_error_code::invalid_parameter, Context);
51   case E_UNEXPECTED:
52     return make_error<DIAError>(dia_error_code::already_loaded, Context);
53   case E_PDB_INVALID_SIG:
54   case E_PDB_INVALID_AGE:
55     return make_error<DIAError>(dia_error_code::debug_info_mismatch, Context);
56   default: {
57     std::string S;
58     raw_string_ostream OS(S);
59     OS << "HRESULT: " << format_hex(static_cast<DWORD>(Result), 10, true)
60        << ": " << Context;
61     return make_error<DIAError>(dia_error_code::unspecified, OS.str());
62   }
63   }
64 }
65 
66 static Error LoadDIA(CComPtr<IDiaDataSource> &DiaDataSource) {
67   if (SUCCEEDED(CoCreateInstance(CLSID_DiaSource, nullptr, CLSCTX_INPROC_SERVER,
68                                  IID_IDiaDataSource,
69                                  reinterpret_cast<LPVOID *>(&DiaDataSource))))
70     return Error::success();
71 
72 // If the CoCreateInstance call above failed, msdia*.dll is not registered.
73 // Try loading the DLL corresponding to the #included DIA SDK.
74 #if !defined(_MSC_VER)
75   return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading);
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 
96 Error DIASession::createFromPdb(StringRef Path,
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 
105   llvm::SmallVector<UTF16, 128> Path16;
106   if (!llvm::convertUTF8ToUTF16String(Path, Path16))
107     return make_error<PDBError>(pdb_error_code::invalid_utf8_path, 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 
122 Error DIASession::createFromExe(StringRef Path,
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 
131   llvm::SmallVector<UTF16, 128> Path16;
132   if (!llvm::convertUTF8ToUTF16String(Path, Path16))
133     return make_error<PDBError>(pdb_error_code::invalid_utf8_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 
169 bool DIASession::addressForVA(uint64_t VA, uint32_t &Section,
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 
180 bool DIASession::addressForRVA(uint32_t RVA, uint32_t &Section,
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>
192 DIASession::getSymbolById(SymIndexId SymbolId) const {
193   CComPtr<IDiaSymbol> LocatedSymbol;
194   if (S_OK != Session->symbolById(SymbolId, &LocatedSymbol))
195     return nullptr;
196 
197   auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, LocatedSymbol);
198   return PDBSymbol::create(*this, std::move(RawSymbol));
199 }
200 
201 std::unique_ptr<PDBSymbol>
202 DIASession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
203   enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
204 
205   CComPtr<IDiaSymbol> Symbol;
206   if (S_OK != Session->findSymbolByVA(Address, EnumVal, &Symbol)) {
207     ULONGLONG LoadAddr = 0;
208     if (S_OK != Session->get_loadAddress(&LoadAddr))
209       return nullptr;
210     DWORD RVA = static_cast<DWORD>(Address - LoadAddr);
211     if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))
212       return nullptr;
213   }
214   auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, Symbol);
215   return PDBSymbol::create(*this, std::move(RawSymbol));
216 }
217 
218 std::unique_ptr<PDBSymbol> DIASession::findSymbolByRVA(uint32_t RVA,
219                                                        PDB_SymType Type) const {
220   enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
221 
222   CComPtr<IDiaSymbol> Symbol;
223   if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))
224     return nullptr;
225 
226   auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, Symbol);
227   return PDBSymbol::create(*this, std::move(RawSymbol));
228 }
229 
230 std::unique_ptr<PDBSymbol>
231 DIASession::findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
232                                    PDB_SymType Type) const {
233   enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
234 
235   CComPtr<IDiaSymbol> Symbol;
236   if (S_OK != Session->findSymbolByAddr(Sect, Offset, EnumVal, &Symbol))
237     return nullptr;
238 
239   auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, Symbol);
240   return PDBSymbol::create(*this, std::move(RawSymbol));
241 }
242 
243 std::unique_ptr<IPDBEnumLineNumbers>
244 DIASession::findLineNumbers(const PDBSymbolCompiland &Compiland,
245                             const IPDBSourceFile &File) const {
246   const DIARawSymbol &RawCompiland =
247       static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());
248   const DIASourceFile &RawFile = static_cast<const DIASourceFile &>(File);
249 
250   CComPtr<IDiaEnumLineNumbers> LineNumbers;
251   if (S_OK != Session->findLines(RawCompiland.getDiaSymbol(),
252                                  RawFile.getDiaFile(), &LineNumbers))
253     return nullptr;
254 
255   return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
256 }
257 
258 std::unique_ptr<IPDBEnumLineNumbers>
259 DIASession::findLineNumbersByAddress(uint64_t Address, uint32_t Length) const {
260   CComPtr<IDiaEnumLineNumbers> LineNumbers;
261   if (S_OK != Session->findLinesByVA(Address, Length, &LineNumbers)) {
262     ULONGLONG LoadAddr = 0;
263     if (S_OK != Session->get_loadAddress(&LoadAddr))
264       return nullptr;
265     DWORD RVA = static_cast<DWORD>(Address - LoadAddr);
266     if (S_OK != Session->findLinesByRVA(RVA, Length, &LineNumbers))
267       return nullptr;
268   }
269   return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
270 }
271 
272 std::unique_ptr<IPDBEnumLineNumbers>
273 DIASession::findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const {
274   CComPtr<IDiaEnumLineNumbers> LineNumbers;
275   if (S_OK != Session->findLinesByRVA(RVA, Length, &LineNumbers))
276     return nullptr;
277 
278   return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
279 }
280 
281 std::unique_ptr<IPDBEnumLineNumbers>
282 DIASession::findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset,
283                                         uint32_t Length) const {
284   CComPtr<IDiaEnumLineNumbers> LineNumbers;
285   if (S_OK != Session->findLinesByAddr(Section, Offset, Length, &LineNumbers))
286     return nullptr;
287 
288   return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
289 }
290 
291 std::unique_ptr<IPDBEnumSourceFiles>
292 DIASession::findSourceFiles(const PDBSymbolCompiland *Compiland,
293                             llvm::StringRef Pattern,
294                             PDB_NameSearchFlags Flags) const {
295   IDiaSymbol *DiaCompiland = nullptr;
296   CComBSTR Utf16Pattern;
297   if (!Pattern.empty())
298     Utf16Pattern = CComBSTR(Pattern.data());
299 
300   if (Compiland)
301     DiaCompiland = static_cast<const DIARawSymbol &>(Compiland->getRawSymbol())
302                        .getDiaSymbol();
303 
304   Flags = static_cast<PDB_NameSearchFlags>(
305       Flags | PDB_NameSearchFlags::NS_FileNameExtMatch);
306   CComPtr<IDiaEnumSourceFiles> SourceFiles;
307   if (S_OK !=
308       Session->findFile(DiaCompiland, Utf16Pattern.m_str, Flags, &SourceFiles))
309     return nullptr;
310   return llvm::make_unique<DIAEnumSourceFiles>(*this, SourceFiles);
311 }
312 
313 std::unique_ptr<IPDBSourceFile>
314 DIASession::findOneSourceFile(const PDBSymbolCompiland *Compiland,
315                               llvm::StringRef Pattern,
316                               PDB_NameSearchFlags Flags) const {
317   auto SourceFiles = findSourceFiles(Compiland, Pattern, Flags);
318   if (!SourceFiles || SourceFiles->getChildCount() == 0)
319     return nullptr;
320   return SourceFiles->getNext();
321 }
322 
323 std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
324 DIASession::findCompilandsForSourceFile(llvm::StringRef Pattern,
325                                         PDB_NameSearchFlags Flags) const {
326   auto File = findOneSourceFile(nullptr, Pattern, Flags);
327   if (!File)
328     return nullptr;
329   return File->getCompilands();
330 }
331 
332 std::unique_ptr<PDBSymbolCompiland>
333 DIASession::findOneCompilandForSourceFile(llvm::StringRef Pattern,
334                                           PDB_NameSearchFlags Flags) const {
335   auto Compilands = findCompilandsForSourceFile(Pattern, Flags);
336   if (!Compilands || Compilands->getChildCount() == 0)
337     return nullptr;
338   return Compilands->getNext();
339 }
340 
341 std::unique_ptr<IPDBEnumSourceFiles> DIASession::getAllSourceFiles() const {
342   CComPtr<IDiaEnumSourceFiles> Files;
343   if (S_OK != Session->findFile(nullptr, nullptr, nsNone, &Files))
344     return nullptr;
345 
346   return llvm::make_unique<DIAEnumSourceFiles>(*this, Files);
347 }
348 
349 std::unique_ptr<IPDBEnumSourceFiles> DIASession::getSourceFilesForCompiland(
350     const PDBSymbolCompiland &Compiland) const {
351   CComPtr<IDiaEnumSourceFiles> Files;
352 
353   const DIARawSymbol &RawSymbol =
354       static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());
355   if (S_OK !=
356       Session->findFile(RawSymbol.getDiaSymbol(), nullptr, nsNone, &Files))
357     return nullptr;
358 
359   return llvm::make_unique<DIAEnumSourceFiles>(*this, Files);
360 }
361 
362 std::unique_ptr<IPDBSourceFile>
363 DIASession::getSourceFileById(uint32_t FileId) const {
364   CComPtr<IDiaSourceFile> LocatedFile;
365   if (S_OK != Session->findFileById(FileId, &LocatedFile))
366     return nullptr;
367 
368   return llvm::make_unique<DIASourceFile>(*this, LocatedFile);
369 }
370 
371 std::unique_ptr<IPDBEnumDataStreams> DIASession::getDebugStreams() const {
372   CComPtr<IDiaEnumDebugStreams> DiaEnumerator;
373   if (S_OK != Session->getEnumDebugStreams(&DiaEnumerator))
374     return nullptr;
375 
376   return llvm::make_unique<DIAEnumDebugStreams>(DiaEnumerator);
377 }
378 
379 std::unique_ptr<IPDBEnumTables> DIASession::getEnumTables() const {
380   CComPtr<IDiaEnumTables> DiaEnumerator;
381   if (S_OK != Session->getEnumTables(&DiaEnumerator))
382     return nullptr;
383 
384   return llvm::make_unique<DIAEnumTables>(DiaEnumerator);
385 }
386 
387 template <class T> static CComPtr<T> getTableEnumerator(IDiaSession &Session) {
388   CComPtr<T> Enumerator;
389   CComPtr<IDiaEnumTables> ET;
390   CComPtr<IDiaTable> Table;
391   ULONG Count = 0;
392 
393   if (Session.getEnumTables(&ET) != S_OK)
394     return nullptr;
395 
396   while (ET->Next(1, &Table, &Count) == S_OK && Count == 1) {
397     // There is only one table that matches the given iid
398     if (S_OK == Table->QueryInterface(__uuidof(T), (void **)&Enumerator))
399       break;
400     Table.Release();
401   }
402   return Enumerator;
403 }
404 std::unique_ptr<IPDBEnumInjectedSources>
405 DIASession::getInjectedSources() const {
406   CComPtr<IDiaEnumInjectedSources> Files =
407       getTableEnumerator<IDiaEnumInjectedSources>(*Session);
408   if (!Files)
409     return nullptr;
410 
411   return llvm::make_unique<DIAEnumInjectedSources>(Files);
412 }
413 
414 std::unique_ptr<IPDBEnumSectionContribs>
415 DIASession::getSectionContribs() const {
416   CComPtr<IDiaEnumSectionContribs> Sections =
417       getTableEnumerator<IDiaEnumSectionContribs>(*Session);
418   if (!Sections)
419     return nullptr;
420 
421   return llvm::make_unique<DIAEnumSectionContribs>(*this, Sections);
422 }
423 
424 std::unique_ptr<IPDBEnumFrameData>
425 DIASession::getFrameData() const {
426   CComPtr<IDiaEnumFrameData> FD =
427       getTableEnumerator<IDiaEnumFrameData>(*Session);
428   if (!FD)
429     return nullptr;
430 
431   return llvm::make_unique<DIAEnumFrameData>(FD);
432 }
433