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 //===----------------------------------------------------------------------===//
8 #include "llvm/DebugInfo/PDB/DIA/DIASession.h"
9 #include "llvm/ADT/STLExtras.h"
10 #include "llvm/DebugInfo/PDB/DIA/DIAEnumDebugStreams.h"
11 #include "llvm/DebugInfo/PDB/DIA/DIAEnumFrameData.h"
12 #include "llvm/DebugInfo/PDB/DIA/DIAEnumInjectedSources.h"
13 #include "llvm/DebugInfo/PDB/DIA/DIAEnumLineNumbers.h"
14 #include "llvm/DebugInfo/PDB/DIA/DIAEnumSectionContribs.h"
15 #include "llvm/DebugInfo/PDB/DIA/DIAEnumSourceFiles.h"
16 #include "llvm/DebugInfo/PDB/DIA/DIAEnumTables.h"
17 #include "llvm/DebugInfo/PDB/DIA/DIAError.h"
18 #include "llvm/DebugInfo/PDB/DIA/DIARawSymbol.h"
19 #include "llvm/DebugInfo/PDB/DIA/DIASourceFile.h"
20 #include "llvm/DebugInfo/PDB/DIA/DIASupport.h"
21 #include "llvm/DebugInfo/PDB/GenericError.h"
22 #include "llvm/DebugInfo/PDB/PDB.h"
23 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
24 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
25 #include "llvm/Support/ConvertUTF.h"
26 #include "llvm/Support/Format.h"
27 #include "llvm/Support/FormatVariadic.h"
28 #include "llvm/Support/raw_ostream.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;
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;
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 = nullptr;
77 #if _MSC_VER >= 1900 && _MSC_VER < 2000
78   msdia_dll = L"msdia140.dll"; // VS2015
79 #elif _MSC_VER >= 1800
80   msdia_dll = L"msdia120.dll"; // VS2013
81 #else
82 #error "Unknown Visual Studio version."
83 #endif
84 
85   HRESULT HR;
86   if (FAILED(HR = NoRegCoCreate(msdia_dll, CLSID_DiaSource, IID_IDiaDataSource,
87                                 reinterpret_cast<LPVOID *>(&DiaDataSource))))
88     return ErrorFromHResult(HR, "Calling NoRegCoCreate");
89   return Error::success();
90 #endif
91 }
92 
93 DIASession::DIASession(CComPtr<IDiaSession> DiaSession) : Session(DiaSession) {}
94 
95 Error DIASession::createFromPdb(StringRef Path,
96                                 std::unique_ptr<IPDBSession> &Session) {
97   CComPtr<IDiaDataSource> DiaDataSource;
98   CComPtr<IDiaSession> DiaSession;
99 
100   // We assume that CoInitializeEx has already been called by the executable.
101   if (auto E = LoadDIA(DiaDataSource))
102     return E;
103 
104   llvm::SmallVector<UTF16, 128> Path16;
105   if (!llvm::convertUTF8ToUTF16String(Path, Path16))
106     return make_error<PDBError>(pdb_error_code::invalid_utf8_path, Path);
107 
108   const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());
109   HRESULT HR;
110   if (FAILED(HR = DiaDataSource->loadDataFromPdb(Path16Str))) {
111     return ErrorFromHResult(HR, "Calling loadDataFromPdb {0}", Path);
112   }
113 
114   if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
115     return ErrorFromHResult(HR, "Calling openSession");
116 
117   Session.reset(new DIASession(DiaSession));
118   return Error::success();
119 }
120 
121 Error DIASession::createFromExe(StringRef Path,
122                                 std::unique_ptr<IPDBSession> &Session) {
123   CComPtr<IDiaDataSource> DiaDataSource;
124   CComPtr<IDiaSession> DiaSession;
125 
126   // We assume that CoInitializeEx has already been called by the executable.
127   if (auto EC = LoadDIA(DiaDataSource))
128     return EC;
129 
130   llvm::SmallVector<UTF16, 128> Path16;
131   if (!llvm::convertUTF8ToUTF16String(Path, Path16))
132     return make_error<PDBError>(pdb_error_code::invalid_utf8_path, Path);
133 
134   const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());
135   HRESULT HR;
136   if (FAILED(HR = DiaDataSource->loadDataForExe(Path16Str, nullptr, nullptr)))
137     return ErrorFromHResult(HR, "Calling loadDataForExe");
138 
139   if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
140     return ErrorFromHResult(HR, "Calling openSession");
141 
142   Session.reset(new DIASession(DiaSession));
143   return Error::success();
144 }
145 
146 uint64_t DIASession::getLoadAddress() const {
147   uint64_t LoadAddress;
148   bool success = (S_OK == Session->get_loadAddress(&LoadAddress));
149   return (success) ? LoadAddress : 0;
150 }
151 
152 bool DIASession::setLoadAddress(uint64_t Address) {
153   return (S_OK == Session->put_loadAddress(Address));
154 }
155 
156 std::unique_ptr<PDBSymbolExe> DIASession::getGlobalScope() {
157   CComPtr<IDiaSymbol> GlobalScope;
158   if (S_OK != Session->get_globalScope(&GlobalScope))
159     return nullptr;
160 
161   auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, GlobalScope);
162   auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
163   std::unique_ptr<PDBSymbolExe> ExeSymbol(
164       static_cast<PDBSymbolExe *>(PdbSymbol.release()));
165   return ExeSymbol;
166 }
167 
168 bool DIASession::addressForVA(uint64_t VA, uint32_t &Section,
169                               uint32_t &Offset) const {
170   DWORD ArgSection, ArgOffset = 0;
171   if (S_OK == Session->addressForVA(VA, &ArgSection, &ArgOffset)) {
172     Section = static_cast<uint32_t>(ArgSection);
173     Offset = static_cast<uint32_t>(ArgOffset);
174     return true;
175   }
176   return false;
177 }
178 
179 bool DIASession::addressForRVA(uint32_t RVA, uint32_t &Section,
180                                uint32_t &Offset) const {
181   DWORD ArgSection, ArgOffset = 0;
182   if (S_OK == Session->addressForRVA(RVA, &ArgSection, &ArgOffset)) {
183     Section = static_cast<uint32_t>(ArgSection);
184     Offset = static_cast<uint32_t>(ArgOffset);
185     return true;
186   }
187   return false;
188 }
189 
190 std::unique_ptr<PDBSymbol>
191 DIASession::getSymbolById(SymIndexId 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>
201 DIASession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
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>
230 DIASession::findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
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>
243 DIASession::findLineNumbers(const PDBSymbolCompiland &Compiland,
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>
272 DIASession::findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const {
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>
281 DIASession::findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset,
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>
291 DIASession::findSourceFiles(const PDBSymbolCompiland *Compiland,
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>(
304       Flags | PDB_NameSearchFlags::NS_FileNameExtMatch);
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>
313 DIASession::findOneSourceFile(const PDBSymbolCompiland *Compiland,
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>>
323 DIASession::findCompilandsForSourceFile(llvm::StringRef Pattern,
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>
332 DIASession::findOneCompilandForSourceFile(llvm::StringRef Pattern,
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>
362 DIASession::getSourceFileById(uint32_t FileId) const {
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>
404 DIASession::getInjectedSources() const {
405   CComPtr<IDiaEnumInjectedSources> Files =
406       getTableEnumerator<IDiaEnumInjectedSources>(*Session);
407   if (!Files)
408     return nullptr;
409 
410   return llvm::make_unique<DIAEnumInjectedSources>(Files);
411 }
412 
413 std::unique_ptr<IPDBEnumSectionContribs>
414 DIASession::getSectionContribs() const {
415   CComPtr<IDiaEnumSectionContribs> Sections =
416       getTableEnumerator<IDiaEnumSectionContribs>(*Session);
417   if (!Sections)
418     return nullptr;
419 
420   return llvm::make_unique<DIAEnumSectionContribs>(*this, Sections);
421 }
422 
423 std::unique_ptr<IPDBEnumFrameData>
424 DIASession::getFrameData() const {
425   CComPtr<IDiaEnumFrameData> FD =
426       getTableEnumerator<IDiaEnumFrameData>(*Session);
427   if (!FD)
428     return nullptr;
429 
430   return llvm::make_unique<DIAEnumFrameData>(FD);
431 }
432