Comparar texto

Encuentra la diferencia entre dos archivos de texto

Editor live

Ocultar sin cambios

Sin ajuste de línea

Vista

Nivel de detalle

Resaltado de sintaxis

Diffchecker Desktop La forma más segura de usar Diffchecker. ¡Obtén la app de Diffchecker Desktop: tus diffs nunca salen de tu computadora!Obtener Desktop

Untitled diff

Creado hace 9 añosEl diff nunca expira

1 eliminación

Líneas
Total
Eliminado

Caracteres
Total
Eliminado

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

290 líneas

2 adiciones

Líneas
Total
Añadido

Caracteres
Total
Añadido

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

290 líneas

//===- DIASession.cpp - DIA implementation of IPDBSession -------*- C++ -*-===//

// The LLVM Compiler Infrastructure

// This file is distributed under the University of Illinois Open Source

// License. See LICENSE.TXT for details.

//===----------------------------------------------------------------------===//

#include "llvm/DebugInfo/PDB/DIA/DIASession.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/DebugInfo/PDB/DIA/DIAEnumDebugStreams.h"

#include "llvm/DebugInfo/PDB/DIA/DIAEnumLineNumbers.h"

#include "llvm/DebugInfo/PDB/DIA/DIAEnumSourceFiles.h"

#include "llvm/DebugInfo/PDB/DIA/DIAError.h"

#include "llvm/DebugInfo/PDB/DIA/DIARawSymbol.h"

#include "llvm/DebugInfo/PDB/DIA/DIASourceFile.h"

#include "llvm/DebugInfo/PDB/DIA/DIASupport.h"

#include "llvm/DebugInfo/PDB/GenericError.h"

#include "llvm/DebugInfo/PDB/PDB.h"

#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"

#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"

#include "llvm/Support/ConvertUTF.h"

using namespace llvm;

using namespace llvm::pdb;

namespace {

Error ErrorFromHResult(HRESULT Result) {

switch (Result) {

case E_PDB_NOT_FOUND:

return make_error<GenericError>(generic_error_code::invalid_path);

case E_PDB_FORMAT:

return make_error<DIAError>(dia_error_code::invalid_file_format);

case E_INVALIDARG:

return make_error<DIAError>(dia_error_code::invalid_parameter);

case E_UNEXPECTED:

return make_error<DIAError>(dia_error_code::already_loaded);

case E_PDB_INVALID_SIG:

case E_PDB_INVALID_AGE:

return make_error<DIAError>(dia_error_code::debug_info_mismatch);

default:

return make_error<DIAError>(dia_error_code::unspecified);

}

Error LoadDIA(CComPtr<IDiaDataSource> &DiaDataSource) {

if (SUCCEEDED(CoCreateInstance(CLSID_DiaSource, nullptr, CLSCTX_INPROC_SERVER,

IID_IDiaDataSource,

reinterpret_cast<LPVOID *>(&DiaDataSource))))

return Error::success();

// If the CoCreateInstance call above failed, msdia*.dll is not registered.

// Try loading the DLL corresponding to the #included DIA SDK.

#if !defined(_MSC_VER)

return llvm::make_error<GenericError>(

"DIA is only supported when using MSVC.");

#endif

const wchar_t *msdia_dll = nullptr;

#if _MSC_VER == 1900

#if _MSC_VER >= 1900 && _MSC_VER < 2000

msdia_dll = L"msdia140.dll"; // VS2015

#elif _MSC_VER == 1800

msdia_dll = L"msdia120.dll"; // VS2013

#else

#error "Unknown Visual Studio version."

#endif

HRESULT HR;

if (FAILED(HR = NoRegCoCreate(msdia_dll, CLSID_DiaSource, IID_IDiaDataSource,

reinterpret_cast<LPVOID *>(&DiaDataSource))))

return ErrorFromHResult(HR);

return Error::success();

}

DIASession::DIASession(CComPtr<IDiaSession> DiaSession) : Session(DiaSession) {}

Error DIASession::createFromPdb(StringRef Path,

std::unique_ptr<IPDBSession> &Session) {

CComPtr<IDiaDataSource> DiaDataSource;

CComPtr<IDiaSession> DiaSession;

// We assume that CoInitializeEx has already been called by the executable.

if (auto E = LoadDIA(DiaDataSource))

return E;

llvm::SmallVector<UTF16, 128> Path16;

if (!llvm::convertUTF8ToUTF16String(Path, Path16))

return make_error<GenericError>(generic_error_code::invalid_path);

const wchar_t *Path16Str = reinterpret_cast<const wchar_t*>(Path16.data());

HRESULT HR;

if (FAILED(HR = DiaDataSource->loadDataFromPdb(Path16Str)))

return ErrorFromHResult(HR);

if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))

return ErrorFromHResult(HR);

Session.reset(new DIASession(DiaSession));

return Error::success();

}

Error DIASession::createFromExe(StringRef Path,

std::unique_ptr<IPDBSession> &Session) {

CComPtr<IDiaDataSource> DiaDataSource;

CComPtr<IDiaSession> DiaSession;

// We assume that CoInitializeEx has already been called by the executable.

if (auto EC = LoadDIA(DiaDataSource))

return EC;

llvm::SmallVector<UTF16, 128> Path16;

if (!llvm::convertUTF8ToUTF16String(Path, Path16))

return make_error<GenericError>(generic_error_code::invalid_path, Path);

const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());

HRESULT HR;

if (FAILED(HR = DiaDataSource->loadDataForExe(Path16Str, nullptr, nullptr)))

return ErrorFromHResult(HR);

if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))

return ErrorFromHResult(HR);

Session.reset(new DIASession(DiaSession));

return Error::success();

}

uint64_t DIASession::getLoadAddress() const {

uint64_t LoadAddress;

bool success = (S_OK == Session->get_loadAddress(&LoadAddress));

return (success) ? LoadAddress : 0;

}

void DIASession::setLoadAddress(uint64_t Address) {

Session->put_loadAddress(Address);

}

std::unique_ptr<PDBSymbolExe> DIASession::getGlobalScope() const {

CComPtr<IDiaSymbol> GlobalScope;

if (S_OK != Session->get_globalScope(&GlobalScope))

return nullptr;

auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, GlobalScope);

auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));

std::unique_ptr<PDBSymbolExe> ExeSymbol(

static_cast<PDBSymbolExe *>(PdbSymbol.release()));

return ExeSymbol;

}

std::unique_ptr<PDBSymbol> DIASession::getSymbolById(uint32_t SymbolId) const {

CComPtr<IDiaSymbol> LocatedSymbol;

if (S_OK != Session->symbolById(SymbolId, &LocatedSymbol))

return nullptr;

auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, LocatedSymbol);

return PDBSymbol::create(*this, std::move(RawSymbol));

}

std::unique_ptr<PDBSymbol>

DIASession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {

enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);

CComPtr<IDiaSymbol> Symbol;

if (S_OK != Session->findSymbolByVA(Address, EnumVal, &Symbol)) {

ULONGLONG LoadAddr = 0;

if (S_OK != Session->get_loadAddress(&LoadAddr))

return nullptr;

DWORD RVA = static_cast<DWORD>(Address - LoadAddr);

if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))

return nullptr;

}

auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, Symbol);

return PDBSymbol::create(*this, std::move(RawSymbol));

}

std::unique_ptr<IPDBEnumLineNumbers>

DIASession::findLineNumbers(const PDBSymbolCompiland &Compiland,

const IPDBSourceFile &File) const {

const DIARawSymbol &RawCompiland =

static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());

const DIASourceFile &RawFile = static_cast<const DIASourceFile &>(File);

CComPtr<IDiaEnumLineNumbers> LineNumbers;

if (S_OK !=

Session->findLines(RawCompiland.getDiaSymbol(), RawFile.getDiaFile(),

&LineNumbers))

return nullptr;

return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);

}

std::unique_ptr<IPDBEnumLineNumbers>

DIASession::findLineNumbersByAddress(uint64_t Address, uint32_t Length) const {

CComPtr<IDiaEnumLineNumbers> LineNumbers;

if (S_OK != Session->findLinesByVA(Address, Length, &LineNumbers))

return nullptr;

return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);

}

std::unique_ptr<IPDBEnumSourceFiles>

DIASession::findSourceFiles(const PDBSymbolCompiland *Compiland,

llvm::StringRef Pattern,

PDB_NameSearchFlags Flags) const {

IDiaSymbol *DiaCompiland = nullptr;

CComBSTR Utf16Pattern;

if (!Pattern.empty())

Utf16Pattern = CComBSTR(Pattern.data());

if (Compiland)

DiaCompiland = static_cast<const DIARawSymbol &>(Compiland->getRawSymbol())

.getDiaSymbol();

Flags = static_cast<PDB_NameSearchFlags>(

Flags | PDB_NameSearchFlags::NS_FileNameExtMatch);

CComPtr<IDiaEnumSourceFiles> SourceFiles;

if (S_OK !=

Session->findFile(DiaCompiland, Utf16Pattern.m_str, Flags, &SourceFiles))

return nullptr;

return llvm::make_unique<DIAEnumSourceFiles>(*this, SourceFiles);

}

std::unique_ptr<IPDBSourceFile>

DIASession::findOneSourceFile(const PDBSymbolCompiland *Compiland,

llvm::StringRef Pattern,

PDB_NameSearchFlags Flags) const {

auto SourceFiles = findSourceFiles(Compiland, Pattern, Flags);

if (!SourceFiles || SourceFiles->getChildCount() == 0)

return nullptr;

return SourceFiles->getNext();

}

std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>

DIASession::findCompilandsForSourceFile(llvm::StringRef Pattern,

PDB_NameSearchFlags Flags) const {

auto File = findOneSourceFile(nullptr, Pattern, Flags);

if (!File)

return nullptr;

return File->getCompilands();

}

std::unique_ptr<PDBSymbolCompiland>

DIASession::findOneCompilandForSourceFile(llvm::StringRef Pattern,

PDB_NameSearchFlags Flags) const {

auto Compilands = findCompilandsForSourceFile(Pattern, Flags);

if (!Compilands || Compilands->getChildCount() == 0)

return nullptr;

return Compilands->getNext();

}

std::unique_ptr<IPDBEnumSourceFiles> DIASession::getAllSourceFiles() const {

CComPtr<IDiaEnumSourceFiles> Files;

if (S_OK != Session->findFile(nullptr, nullptr, nsNone, &Files))

return nullptr;

return llvm::make_unique<DIAEnumSourceFiles>(*this, Files);

}

std::unique_ptr<IPDBEnumSourceFiles> DIASession::getSourceFilesForCompiland(

const PDBSymbolCompiland &Compiland) const {

CComPtr<IDiaEnumSourceFiles> Files;

const DIARawSymbol &RawSymbol =

static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());

if (S_OK !=

Session->findFile(RawSymbol.getDiaSymbol(), nullptr, nsNone, &Files))

return nullptr;

return llvm::make_unique<DIAEnumSourceFiles>(*this, Files);

}

std::unique_ptr<IPDBSourceFile>

DIASession::getSourceFileById(uint32_t FileId) const {

CComPtr<IDiaSourceFile> LocatedFile;

if (S_OK != Session->findFileById(FileId, &LocatedFile))

return nullptr;

return llvm::make_unique<DIASourceFile>(*this, LocatedFile);

}

std::unique_ptr<IPDBEnumDataStreams> DIASession::getDebugStreams() const {

CComPtr<IDiaEnumDebugStreams> DiaEnumerator;

if (S_OK != Session->getEnumDebugStreams(&DiaEnumerator))

return nullptr;

return llvm::make_unique<DIAEnumDebugStreams>(DiaEnumerator);

}

Diferencias guardadas

Texto original

Abrir archivo

//===- DIASession.cpp - DIA implementation of IPDBSession -------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/PDB/DIA/DIASession.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/DebugInfo/PDB/DIA/DIAEnumDebugStreams.h"
#include "llvm/DebugInfo/PDB/DIA/DIAEnumLineNumbers.h"
#include "llvm/DebugInfo/PDB/DIA/DIAEnumSourceFiles.h"
#include "llvm/DebugInfo/PDB/DIA/DIAError.h"
#include "llvm/DebugInfo/PDB/DIA/DIARawSymbol.h"
#include "llvm/DebugInfo/PDB/DIA/DIASourceFile.h"
#include "llvm/DebugInfo/PDB/DIA/DIASupport.h"
#include "llvm/DebugInfo/PDB/GenericError.h"
#include "llvm/DebugInfo/PDB/PDB.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
#include "llvm/Support/ConvertUTF.h"

using namespace llvm;
using namespace llvm::pdb;

namespace {

Error ErrorFromHResult(HRESULT Result) {
  switch (Result) {
  case E_PDB_NOT_FOUND:
    return make_error<GenericError>(generic_error_code::invalid_path);
  case E_PDB_FORMAT:
    return make_error<DIAError>(dia_error_code::invalid_file_format);
  case E_INVALIDARG:
    return make_error<DIAError>(dia_error_code::invalid_parameter);
  case E_UNEXPECTED:
    return make_error<DIAError>(dia_error_code::already_loaded);
  case E_PDB_INVALID_SIG:
  case E_PDB_INVALID_AGE:
    return make_error<DIAError>(dia_error_code::debug_info_mismatch);
  default:
    return make_error<DIAError>(dia_error_code::unspecified);
  }
}

Error LoadDIA(CComPtr<IDiaDataSource> &DiaDataSource) {
  if (SUCCEEDED(CoCreateInstance(CLSID_DiaSource, nullptr, CLSCTX_INPROC_SERVER,
                                 IID_IDiaDataSource,
                                 reinterpret_cast<LPVOID *>(&DiaDataSource))))
    return Error::success();

// If the CoCreateInstance call above failed, msdia*.dll is not registered.
// Try loading the DLL corresponding to the #included DIA SDK.
#if !defined(_MSC_VER)
  return llvm::make_error<GenericError>(
      "DIA is only supported when using MSVC.");
#endif

const wchar_t *msdia_dll = nullptr;
#if _MSC_VER == 1900
  msdia_dll = L"msdia140.dll"; // VS2015
#elif _MSC_VER == 1800
  msdia_dll = L"msdia120.dll"; // VS2013
#else
#error "Unknown Visual Studio version."
#endif

HRESULT HR;
  if (FAILED(HR = NoRegCoCreate(msdia_dll, CLSID_DiaSource, IID_IDiaDataSource,
                                reinterpret_cast<LPVOID *>(&DiaDataSource))))
    return ErrorFromHResult(HR);
  return Error::success();
}

}

DIASession::DIASession(CComPtr<IDiaSession> DiaSession) : Session(DiaSession) {}

Error DIASession::createFromPdb(StringRef Path,
                                std::unique_ptr<IPDBSession> &Session) {
  CComPtr<IDiaDataSource> DiaDataSource;
  CComPtr<IDiaSession> DiaSession;

// We assume that CoInitializeEx has already been called by the executable.
  if (auto E = LoadDIA(DiaDataSource))
    return E;

llvm::SmallVector<UTF16, 128> Path16;
  if (!llvm::convertUTF8ToUTF16String(Path, Path16))
    return make_error<GenericError>(generic_error_code::invalid_path);

const wchar_t *Path16Str = reinterpret_cast<const wchar_t*>(Path16.data());
  HRESULT HR;
  if (FAILED(HR = DiaDataSource->loadDataFromPdb(Path16Str)))
    return ErrorFromHResult(HR);

if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
    return ErrorFromHResult(HR);

Session.reset(new DIASession(DiaSession));
  return Error::success();
}

Error DIASession::createFromExe(StringRef Path,
                                std::unique_ptr<IPDBSession> &Session) {
  CComPtr<IDiaDataSource> DiaDataSource;
  CComPtr<IDiaSession> DiaSession;

// We assume that CoInitializeEx has already been called by the executable.
  if (auto EC = LoadDIA(DiaDataSource))
    return EC;

llvm::SmallVector<UTF16, 128> Path16;
  if (!llvm::convertUTF8ToUTF16String(Path, Path16))
    return make_error<GenericError>(generic_error_code::invalid_path, Path);

const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());
  HRESULT HR;
  if (FAILED(HR = DiaDataSource->loadDataForExe(Path16Str, nullptr, nullptr)))
    return ErrorFromHResult(HR);

if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
    return ErrorFromHResult(HR);

Session.reset(new DIASession(DiaSession));
  return Error::success();
}

uint64_t DIASession::getLoadAddress() const {
  uint64_t LoadAddress;
  bool success = (S_OK == Session->get_loadAddress(&LoadAddress));
  return (success) ? LoadAddress : 0;
}

void DIASession::setLoadAddress(uint64_t Address) {
  Session->put_loadAddress(Address);
}

std::unique_ptr<PDBSymbolExe> DIASession::getGlobalScope() const {
  CComPtr<IDiaSymbol> GlobalScope;
  if (S_OK != Session->get_globalScope(&GlobalScope))
    return nullptr;

auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, GlobalScope);
  auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
  std::unique_ptr<PDBSymbolExe> ExeSymbol(
      static_cast<PDBSymbolExe *>(PdbSymbol.release()));
  return ExeSymbol;
}

std::unique_ptr<PDBSymbol> DIASession::getSymbolById(uint32_t SymbolId) const {
  CComPtr<IDiaSymbol> LocatedSymbol;
  if (S_OK != Session->symbolById(SymbolId, &LocatedSymbol))
    return nullptr;

auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, LocatedSymbol);
  return PDBSymbol::create(*this, std::move(RawSymbol));
}

std::unique_ptr<PDBSymbol>
DIASession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
  enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);

CComPtr<IDiaSymbol> Symbol;
  if (S_OK != Session->findSymbolByVA(Address, EnumVal, &Symbol)) {
    ULONGLONG LoadAddr = 0;
    if (S_OK != Session->get_loadAddress(&LoadAddr))
      return nullptr;
    DWORD RVA = static_cast<DWORD>(Address - LoadAddr);
    if (S_OK != Session->findSymbolByRVA(RVA, EnumVal, &Symbol))
      return nullptr;
  }
  auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, Symbol);
  return PDBSymbol::create(*this, std::move(RawSymbol));
}

std::unique_ptr<IPDBEnumLineNumbers>
DIASession::findLineNumbers(const PDBSymbolCompiland &Compiland,
                            const IPDBSourceFile &File) const {
  const DIARawSymbol &RawCompiland =
      static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());
  const DIASourceFile &RawFile = static_cast<const DIASourceFile &>(File);

CComPtr<IDiaEnumLineNumbers> LineNumbers;
  if (S_OK !=
      Session->findLines(RawCompiland.getDiaSymbol(), RawFile.getDiaFile(),
                         &LineNumbers))
    return nullptr;

return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
}

std::unique_ptr<IPDBEnumLineNumbers>
DIASession::findLineNumbersByAddress(uint64_t Address, uint32_t Length) const {
  CComPtr<IDiaEnumLineNumbers> LineNumbers;
  if (S_OK != Session->findLinesByVA(Address, Length, &LineNumbers))
    return nullptr;

return llvm::make_unique<DIAEnumLineNumbers>(LineNumbers);
}

std::unique_ptr<IPDBEnumSourceFiles>
DIASession::findSourceFiles(const PDBSymbolCompiland *Compiland,
                            llvm::StringRef Pattern,
                            PDB_NameSearchFlags Flags) const {
  IDiaSymbol *DiaCompiland = nullptr;
  CComBSTR Utf16Pattern;
  if (!Pattern.empty())
    Utf16Pattern = CComBSTR(Pattern.data());

if (Compiland)
    DiaCompiland = static_cast<const DIARawSymbol &>(Compiland->getRawSymbol())
                       .getDiaSymbol();

Flags = static_cast<PDB_NameSearchFlags>(
      Flags | PDB_NameSearchFlags::NS_FileNameExtMatch);
  CComPtr<IDiaEnumSourceFiles> SourceFiles;
  if (S_OK !=
      Session->findFile(DiaCompiland, Utf16Pattern.m_str, Flags, &SourceFiles))
    return nullptr;
  return llvm::make_unique<DIAEnumSourceFiles>(*this, SourceFiles);
}

std::unique_ptr<IPDBSourceFile>
DIASession::findOneSourceFile(const PDBSymbolCompiland *Compiland,
                              llvm::StringRef Pattern,
                              PDB_NameSearchFlags Flags) const {
  auto SourceFiles = findSourceFiles(Compiland, Pattern, Flags);
  if (!SourceFiles || SourceFiles->getChildCount() == 0)
    return nullptr;
  return SourceFiles->getNext();
}

std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
DIASession::findCompilandsForSourceFile(llvm::StringRef Pattern,
                                        PDB_NameSearchFlags Flags) const {
  auto File = findOneSourceFile(nullptr, Pattern, Flags);
  if (!File)
    return nullptr;
  return File->getCompilands();
}

std::unique_ptr<PDBSymbolCompiland>
DIASession::findOneCompilandForSourceFile(llvm::StringRef Pattern,
                                          PDB_NameSearchFlags Flags) const {
  auto Compilands = findCompilandsForSourceFile(Pattern, Flags);
  if (!Compilands || Compilands->getChildCount() == 0)
    return nullptr;
  return Compilands->getNext();
}

std::unique_ptr<IPDBEnumSourceFiles> DIASession::getAllSourceFiles() const {
  CComPtr<IDiaEnumSourceFiles> Files;
  if (S_OK != Session->findFile(nullptr, nullptr, nsNone, &Files))
    return nullptr;

return llvm::make_unique<DIAEnumSourceFiles>(*this, Files);
}

std::unique_ptr<IPDBEnumSourceFiles> DIASession::getSourceFilesForCompiland(
    const PDBSymbolCompiland &Compiland) const {
  CComPtr<IDiaEnumSourceFiles> Files;

const DIARawSymbol &RawSymbol =
      static_cast<const DIARawSymbol &>(Compiland.getRawSymbol());
  if (S_OK !=
      Session->findFile(RawSymbol.getDiaSymbol(), nullptr, nsNone, &Files))
    return nullptr;

return llvm::make_unique<DIAEnumSourceFiles>(*this, Files);
}

std::unique_ptr<IPDBSourceFile>
DIASession::getSourceFileById(uint32_t FileId) const {
  CComPtr<IDiaSourceFile> LocatedFile;
  if (S_OK != Session->findFileById(FileId, &LocatedFile))
    return nullptr;

return llvm::make_unique<DIASourceFile>(*this, LocatedFile);
}

std::unique_ptr<IPDBEnumDataStreams> DIASession::getDebugStreams() const {
  CComPtr<IDiaEnumDebugStreams> DiaEnumerator;
  if (S_OK != Session->getEnumDebugStreams(&DiaEnumerator))
    return nullptr;

return llvm::make_unique<DIAEnumDebugStreams>(DiaEnumerator);
}

Texto modificado

Abrir archivo

using namespace llvm;
using namespace llvm::pdb;

namespace {

const wchar_t *msdia_dll = nullptr;
#if _MSC_VER >= 1900 && _MSC_VER < 2000
  msdia_dll = L"msdia140.dll"; // VS2015
#elif _MSC_VER == 1800
  msdia_dll = L"msdia120.dll"; // VS2013
#else
#error "Unknown Visual Studio version."
#endif