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/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 make_error<GenericError>(generic_error_code::invalid_path, Context);
  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<GenericError>(
  75       "DIA is only supported when using MSVC.");
  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<GenericError>(generic_error_code::invalid_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<GenericError>(generic_error_code::invalid_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> DIASession::getSymbolById(uint32_t 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>(*this, 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 }