contrib/llvm/lib/DebugInfo/PDB/DIA/DIASession.cpp

   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 }