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