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/DIAEnumLineNumbers.h"
13 #include "llvm/DebugInfo/PDB/DIA/DIAEnumSourceFiles.h"
14 #include "llvm/DebugInfo/PDB/DIA/DIAError.h"
15 #include "llvm/DebugInfo/PDB/DIA/DIARawSymbol.h"
16 #include "llvm/DebugInfo/PDB/DIA/DIASourceFile.h"
17 #include "llvm/DebugInfo/PDB/DIA/DIASupport.h"
18 #include "llvm/DebugInfo/PDB/GenericError.h"
19 #include "llvm/DebugInfo/PDB/PDB.h"
20 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
21 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
22 #include "llvm/Support/ConvertUTF.h"
23 
24 using namespace llvm;
25 using namespace llvm::pdb;
26 
27 static Error ErrorFromHResult(HRESULT Result) {
28   switch (Result) {
29   case E_PDB_NOT_FOUND:
30     return make_error<GenericError>(generic_error_code::invalid_path);
31   case E_PDB_FORMAT:
32     return make_error<DIAError>(dia_error_code::invalid_file_format);
33   case E_INVALIDARG:
34     return make_error<DIAError>(dia_error_code::invalid_parameter);
35   case E_UNEXPECTED:
36     return make_error<DIAError>(dia_error_code::already_loaded);
37   case E_PDB_INVALID_SIG:
38   case E_PDB_INVALID_AGE:
39     return make_error<DIAError>(dia_error_code::debug_info_mismatch);
40   default:
41     return make_error<DIAError>(dia_error_code::unspecified);
42   }
43 }
44 
45 static Error LoadDIA(CComPtr<IDiaDataSource> &DiaDataSource) {
46   if (SUCCEEDED(CoCreateInstance(CLSID_DiaSource, nullptr, CLSCTX_INPROC_SERVER,
47                                  IID_IDiaDataSource,
48                                  reinterpret_cast<LPVOID *>(&DiaDataSource))))
49     return Error::success();
50 
51 // If the CoCreateInstance call above failed, msdia*.dll is not registered.
52 // Try loading the DLL corresponding to the #included DIA SDK.
53 #if !defined(_MSC_VER)
54   return llvm::make_error<GenericError>(
55       "DIA is only supported when using MSVC.");
56 #else
57   const wchar_t *msdia_dll = nullptr;
58 #if _MSC_VER >= 1900 && _MSC_VER < 2000
59   msdia_dll = L"msdia140.dll"; // VS2015
60 #elif _MSC_VER >= 1800
61   msdia_dll = L"msdia120.dll"; // VS2013
62 #else
63 #error "Unknown Visual Studio version."
64 #endif
65 
66   HRESULT HR;
67   if (FAILED(HR = NoRegCoCreate(msdia_dll, CLSID_DiaSource, IID_IDiaDataSource,
68                                 reinterpret_cast<LPVOID *>(&DiaDataSource))))
69     return ErrorFromHResult(HR);
70   return Error::success();
71 #endif
72 }
73 
74 DIASession::DIASession(CComPtr<IDiaSession> DiaSession) : Session(DiaSession) {}
75 
76 Error DIASession::createFromPdb(StringRef Path,
77                                 std::unique_ptr<IPDBSession> &Session) {
78   CComPtr<IDiaDataSource> DiaDataSource;
79   CComPtr<IDiaSession> DiaSession;
80 
81   // We assume that CoInitializeEx has already been called by the executable.
82   if (auto E = LoadDIA(DiaDataSource))
83     return E;
84 
85   llvm::SmallVector<UTF16, 128> Path16;
86   if (!llvm::convertUTF8ToUTF16String(Path, Path16))
87     return make_error<GenericError>(generic_error_code::invalid_path);
88 
89   const wchar_t *Path16Str = reinterpret_cast<const wchar_t*>(Path16.data());
90   HRESULT HR;
91   if (FAILED(HR = DiaDataSource->loadDataFromPdb(Path16Str)))
92     return ErrorFromHResult(HR);
93 
94   if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
95     return ErrorFromHResult(HR);
96 
97   Session.reset(new DIASession(DiaSession));
98   return Error::success();
99 }
100 
101 Error DIASession::createFromExe(StringRef Path,
102                                 std::unique_ptr<IPDBSession> &Session) {
103   CComPtr<IDiaDataSource> DiaDataSource;
104   CComPtr<IDiaSession> DiaSession;
105 
106   // We assume that CoInitializeEx has already been called by the executable.
107   if (auto EC = LoadDIA(DiaDataSource))
108     return EC;
109 
110   llvm::SmallVector<UTF16, 128> Path16;
111   if (!llvm::convertUTF8ToUTF16String(Path, Path16))
112     return make_error<GenericError>(generic_error_code::invalid_path, Path);
113 
114   const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());
115   HRESULT HR;
116   if (FAILED(HR = DiaDataSource->loadDataForExe(Path16Str, nullptr, nullptr)))
117     return ErrorFromHResult(HR);
118 
119   if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
120     return ErrorFromHResult(HR);
121 
122   Session.reset(new DIASession(DiaSession));
123   return Error::success();
124 }
125 
126 uint64_t DIASession::getLoadAddress() const {
127   uint64_t LoadAddress;
128   bool success = (S_OK == Session->get_loadAddress(&LoadAddress));
129   return (success) ? LoadAddress : 0;
130 }
131 
132 void DIASession::setLoadAddress(uint64_t Address) {
133   Session->put_loadAddress(Address);
134 }
135 
136 std::unique_ptr<PDBSymbolExe> DIASession::getGlobalScope() const {
137   CComPtr<IDiaSymbol> GlobalScope;
138   if (S_OK != Session->get_globalScope(&GlobalScope))
139     return nullptr;
140 
141   auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, GlobalScope);
142   auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
143   std::unique_ptr<PDBSymbolExe> ExeSymbol(
144       static_cast<PDBSymbolExe *>(PdbSymbol.release()));
145   return ExeSymbol;
146 }
147 
148 std::unique_ptr<PDBSymbol> DIASession::getSymbolById(uint32_t SymbolId) const {
149   CComPtr<IDiaSymbol> LocatedSymbol;
150   if (S_OK != Session->symbolById(SymbolId, &LocatedSymbol))
151     return nullptr;
152 
153   auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, LocatedSymbol);
154   return PDBSymbol::create(*this, std::move(RawSymbol));
155 }
156 
157 std::unique_ptr<PDBSymbol>
158 DIASession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
159   enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
160 
161   CComPtr<IDiaSymbol> Symbol;
162   if (S_OK != Session->findSymbolByVA(Address, EnumVal, &Symbol)) {
163     ULONGLONG LoadAddr = 0;
164     if (S_OK != Session->get_loadAddress(&LoadAddr))
165       return nullptr;
166     DWORD RVA = static_cast<DWORD>(Address - LoadAddr);
167     if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))
168       return nullptr;
169   }
170   auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, Symbol);
171   return PDBSymbol::create(*this, std::move(RawSymbol));
172 }
173 
174 std::unique_ptr<IPDBEnumLineNumbers>
175 DIASession::findLineNumbers(const PDBSymbolCompiland &Compiland,
176                             const IPDBSourceFile &File) const {
177   const DIARawSymbol &RawCompiland =
178       static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());
179   const DIASourceFile &RawFile = static_cast<const DIASourceFile &>(File);
180 
181   CComPtr<IDiaEnumLineNumbers> LineNumbers;
182   if (S_OK !=
183       Session->findLines(RawCompiland.getDiaSymbol(), RawFile.getDiaFile(),
184                          &LineNumbers))
185     return nullptr;
186 
187   return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
188 }
189 
190 std::unique_ptr<IPDBEnumLineNumbers>
191 DIASession::findLineNumbersByAddress(uint64_t Address, uint32_t Length) const {
192   CComPtr<IDiaEnumLineNumbers> LineNumbers;
193   if (S_OK != Session->findLinesByVA(Address, Length, &LineNumbers))
194     return nullptr;
195 
196   return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
197 }
198 
199 std::unique_ptr<IPDBEnumSourceFiles>
200 DIASession::findSourceFiles(const PDBSymbolCompiland *Compiland,
201                             llvm::StringRef Pattern,
202                             PDB_NameSearchFlags Flags) const {
203   IDiaSymbol *DiaCompiland = nullptr;
204   CComBSTR Utf16Pattern;
205   if (!Pattern.empty())
206     Utf16Pattern = CComBSTR(Pattern.data());
207 
208   if (Compiland)
209     DiaCompiland = static_cast<const DIARawSymbol &>(Compiland->getRawSymbol())
210                        .getDiaSymbol();
211 
212   Flags = static_cast<PDB_NameSearchFlags>(
213       Flags | PDB_NameSearchFlags::NS_FileNameExtMatch);
214   CComPtr<IDiaEnumSourceFiles> SourceFiles;
215   if (S_OK !=
216       Session->findFile(DiaCompiland, Utf16Pattern.m_str, Flags, &SourceFiles))
217     return nullptr;
218   return llvm::make_unique<DIAEnumSourceFiles>(*this, SourceFiles);
219 }
220 
221 std::unique_ptr<IPDBSourceFile>
222 DIASession::findOneSourceFile(const PDBSymbolCompiland *Compiland,
223                               llvm::StringRef Pattern,
224                               PDB_NameSearchFlags Flags) const {
225   auto SourceFiles = findSourceFiles(Compiland, Pattern, Flags);
226   if (!SourceFiles || SourceFiles->getChildCount() == 0)
227     return nullptr;
228   return SourceFiles->getNext();
229 }
230 
231 std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
232 DIASession::findCompilandsForSourceFile(llvm::StringRef Pattern,
233                                         PDB_NameSearchFlags Flags) const {
234   auto File = findOneSourceFile(nullptr, Pattern, Flags);
235   if (!File)
236     return nullptr;
237   return File->getCompilands();
238 }
239 
240 std::unique_ptr<PDBSymbolCompiland>
241 DIASession::findOneCompilandForSourceFile(llvm::StringRef Pattern,
242                                           PDB_NameSearchFlags Flags) const {
243   auto Compilands = findCompilandsForSourceFile(Pattern, Flags);
244   if (!Compilands || Compilands->getChildCount() == 0)
245     return nullptr;
246   return Compilands->getNext();
247 }
248 
249 std::unique_ptr<IPDBEnumSourceFiles> DIASession::getAllSourceFiles() const {
250   CComPtr<IDiaEnumSourceFiles> Files;
251   if (S_OK != Session->findFile(nullptr, nullptr, nsNone, &Files))
252     return nullptr;
253 
254   return llvm::make_unique<DIAEnumSourceFiles>(*this, Files);
255 }
256 
257 std::unique_ptr<IPDBEnumSourceFiles> DIASession::getSourceFilesForCompiland(
258     const PDBSymbolCompiland &Compiland) const {
259   CComPtr<IDiaEnumSourceFiles> Files;
260 
261   const DIARawSymbol &RawSymbol =
262       static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());
263   if (S_OK !=
264       Session->findFile(RawSymbol.getDiaSymbol(), nullptr, nsNone, &Files))
265     return nullptr;
266 
267   return llvm::make_unique<DIAEnumSourceFiles>(*this, Files);
268 }
269 
270 std::unique_ptr<IPDBSourceFile>
271 DIASession::getSourceFileById(uint32_t FileId) const {
272   CComPtr<IDiaSourceFile> LocatedFile;
273   if (S_OK != Session->findFileById(FileId, &LocatedFile))
274     return nullptr;
275 
276   return llvm::make_unique<DIASourceFile>(*this, LocatedFile);
277 }
278 
279 std::unique_ptr<IPDBEnumDataStreams> DIASession::getDebugStreams() const {
280   CComPtr<IDiaEnumDebugStreams> DiaEnumerator;
281   if (S_OK != Session->getEnumDebugStreams(&DiaEnumerator))
282     return nullptr;
283 
284   return llvm::make_unique<DIAEnumDebugStreams>(DiaEnumerator);
285 }
286