RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-01-31 20:51:52 +01:00
Code Issues Projects Releases Wiki Activity

Revert "Implement some NativeSession functions" along with some

Browse Source 
followup fixes.

This reverts commits
a6d8a055e92eb4853805d1ad1be0b1a6523524ef
4927ae085807731eb4052e0a682443fe9399b512
1e1f5eb7c978da3b062daaf3c32c459704e65a55
This commit is contained in:
Amy Huang 2020-04-21 14:14:32 -07:00
parent 47b07ad5b9
commit 7487f3d198
8 changed files with 18 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/llvm/DebugInfo/PDB/Native/NativeSession.h
View File

@ -26,11 +26,6 @@ class PDBFile;
class NativeExeSymbol;
class NativeSession : public IPDBSession {
struct PdbSearchOptions {
StringRef ExePath;
// FIXME: Add other PDB search options (_NT_SYMBOL_PATH, symsrv)
};
public:
NativeSession(std::unique_ptr<PDBFile> PdbFile,
std::unique_ptr<BumpPtrAllocator> Allocator);
@ -38,11 +33,8 @@ public:
static Error createFromPdb(std::unique_ptr<MemoryBuffer> MB,
std::unique_ptr<IPDBSession> &Session);
static Error createFromPdbPath(StringRef PdbPath,
std::unique_ptr<IPDBSession> &Session);
static Error createFromExe(StringRef Path,
std::unique_ptr<IPDBSession> &Session);
static Expected<std::string> searchForPdb(const PdbSearchOptions &Opts);
uint64_t getLoadAddress() const override;
bool setLoadAddress(uint64_t Address) override;
@ -117,7 +109,6 @@ private:
SymbolCache Cache;
SymIndexId ExeSymbol = 0;
uint64_t LoadAddress = 0;
};
} // namespace pdb
} // namespace llvm

139
lib/DebugInfo/PDB/Native/NativeSession.cpp
View File

@ -12,7 +12,6 @@
#include "llvm/DebugInfo/CodeView/TypeIndex.h"
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
#include "llvm/DebugInfo/PDB/Native/NativeCompilandSymbol.h"
#include "llvm/DebugInfo/PDB/Native/NativeEnumInjectedSources.h"
#include "llvm/DebugInfo/PDB/Native/NativeEnumTypes.h"
@ -26,14 +25,11 @@
#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
#include "llvm/Object/COFF.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/BinaryByteStream.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include <algorithm>
#include <cassert>
@ -79,115 +75,14 @@ Error NativeSession::createFromPdb(std::unique_ptr<MemoryBuffer> Buffer,
return Error::success();
}
static Expected<std::unique_ptr<PDBFile>>
loadPdbFile(StringRef PdbPath, std::unique_ptr<BumpPtrAllocator> &Allocator) {
ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
MemoryBuffer::getFile(PdbPath, /*FileSize=*/-1,
/*RequiresNullTerminator=*/false);
if (!ErrorOrBuffer)
return make_error<RawError>(ErrorOrBuffer.getError());
std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
PdbPath = Buffer->getBufferIdentifier();
file_magic Magic;
auto EC = identify_magic(PdbPath, Magic);
if (EC || Magic != file_magic::pdb)
return make_error<RawError>(EC);
auto Stream = std::make_unique<MemoryBufferByteStream>(std::move(Buffer),
llvm::support::little);
auto File = std::make_unique<PDBFile>(PdbPath, std::move(Stream), *Allocator);
if (auto EC = File->parseFileHeaders())
return std::move(EC);
if (auto EC = File->parseStreamData())
return std::move(EC);
return std::move(File);
}
Error NativeSession::createFromPdbPath(StringRef PdbPath,
Error NativeSession::createFromExe(StringRef Path,
std::unique_ptr<IPDBSession> &Session) {
auto Allocator = std::make_unique<BumpPtrAllocator>();
auto PdbFile = loadPdbFile(PdbPath, Allocator);
if (!PdbFile)
return PdbFile.takeError();
Session = std::make_unique<NativeSession>(std::move(PdbFile.get()),
std::move(Allocator));
return Error::success();
return make_error<RawError>(raw_error_code::feature_unsupported);
}
static Expected<std::string> getPdbPathFromExe(StringRef ExePath) {
Expected<object::OwningBinary<object::Binary>> BinaryFile =
object::createBinary(ExePath);
if (!BinaryFile)
return BinaryFile.takeError();
uint64_t NativeSession::getLoadAddress() const { return 0; }
const object::COFFObjectFile *ObjFile =
dyn_cast<object::COFFObjectFile>(BinaryFile->getBinary());
if (!ObjFile)
return make_error<RawError>(raw_error_code::invalid_format);
StringRef PdbPath;
const llvm::codeview::DebugInfo *PdbInfo = nullptr;
if (auto EC = ObjFile->getDebugPDBInfo(PdbInfo, PdbPath))
return make_error<RawError>(EC);
return std::string(PdbPath);
}
Error NativeSession::createFromExe(StringRef ExePath,
std::unique_ptr<IPDBSession> &Session) {
Expected<std::string> PdbPath = getPdbPathFromExe(ExePath);
if (!PdbPath)
return PdbPath.takeError();
file_magic Magic;
auto EC = identify_magic(PdbPath.get(), Magic);
if (EC || Magic != file_magic::pdb)
return make_error<RawError>(EC);
auto Allocator = std::make_unique<BumpPtrAllocator>();
auto File = loadPdbFile(PdbPath.get(), Allocator);
if (!File)
return File.takeError();
Session = std::make_unique<NativeSession>(std::move(File.get()),
std::move(Allocator));
return Error::success();
}
Expected<std::string>
NativeSession::searchForPdb(const PdbSearchOptions &Opts) {
Expected<std::string> PathOrErr = getPdbPathFromExe(Opts.ExePath);
if (!PathOrErr)
return PathOrErr.takeError();
StringRef PdbName = sys::path::filename(PathOrErr.get());
// Check if pdb exists in the executable directory.
SmallString<128> PdbPath = StringRef(Opts.ExePath);
sys::path::remove_filename(PdbPath);
sys::path::append(PdbPath, PdbName);
auto Allocator = std::make_unique<BumpPtrAllocator>();
if (auto File = loadPdbFile(PdbPath, Allocator))
return std::string(PdbPath);
else
return File.takeError();
return make_error<RawError>("PDB not found");
}
uint64_t NativeSession::getLoadAddress() const { return LoadAddress; }
bool NativeSession::setLoadAddress(uint64_t Address) {
LoadAddress = Address;
return true;
}
bool NativeSession::setLoadAddress(uint64_t Address) { return false; }
std::unique_ptr<PDBSymbolExe> NativeSession::getGlobalScope() {
return PDBSymbol::createAs<PDBSymbolExe>(*this, getNativeGlobalScope());
@ -200,30 +95,12 @@ NativeSession::getSymbolById(SymIndexId SymbolId) const {
bool NativeSession::addressForVA(uint64_t VA, uint32_t &Section,
uint32_t &Offset) const {
uint32_t RVA = VA - getLoadAddress();
return addressForRVA(RVA, Section, Offset);
}
bool NativeSession::addressForRVA(uint32_t RVA, uint32_t &Section,
uint32_t &Offset) const {
auto Dbi = Pdb->getPDBDbiStream();
if (!Dbi)
return false;
Section = 0;
Offset = 0;
if ((int32_t)RVA < 0)
return true;
Offset = RVA;
for (; Section < Dbi->getSectionHeaders().size(); ++Section) {
auto &Sec = Dbi->getSectionHeaders()[Section];
if (RVA < Sec.VirtualAddress)
return true;
Offset = RVA - Sec.VirtualAddress;
}
return true;
bool NativeSession::addressForRVA(uint32_t VA, uint32_t &Section,
uint32_t &Offset) const {
return false;
}
std::unique_ptr<PDBSymbol>

24
lib/DebugInfo/PDB/PDB.cpp
View File

@ -23,8 +23,15 @@ using namespace llvm::pdb;
Error llvm::pdb::loadDataForPDB(PDB_ReaderType Type, StringRef Path,
std::unique_ptr<IPDBSession> &Session) {
// Create the correct concrete instance type based on the value of Type.
if (Type == PDB_ReaderType::Native)
return NativeSession::createFromPdbPath(Path, Session);
if (Type == PDB_ReaderType::Native) {
ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
/*RequiresNullTerminator=*/false);
if (!ErrorOrBuffer)
return errorCodeToError(ErrorOrBuffer.getError());
return NativeSession::createFromPdb(std::move(*ErrorOrBuffer), Session);
}
#if LLVM_ENABLE_DIA_SDK
return DIASession::createFromPdb(Path, Session);
@ -36,17 +43,8 @@ Error llvm::pdb::loadDataForPDB(PDB_ReaderType Type, StringRef Path,
Error llvm::pdb::loadDataForEXE(PDB_ReaderType Type, StringRef Path,
std::unique_ptr<IPDBSession> &Session) {
// Create the correct concrete instance type based on the value of Type.
if (Type == PDB_ReaderType::Native) {
if (auto Err = NativeSession::createFromExe(Path, Session)) {
consumeError(std::move(Err));
Expected<std::string> PdbPath = NativeSession::searchForPdb({Path});
if (!PdbPath)
return PdbPath.takeError();
return NativeSession::createFromPdbPath(PdbPath.get(), Session);
}
return Error::success();
}
if (Type == PDB_ReaderType::Native)
return NativeSession::createFromExe(Path, Session);
#if LLVM_ENABLE_DIA_SDK
return DIASession::createFromExe(Path, Session);

1
unittests/DebugInfo/PDB/CMakeLists.txt
View File

@ -6,7 +6,6 @@ set(LLVM_LINK_COMPONENTS
add_llvm_unittest_with_input_files(DebugInfoPDBTests
HashTableTest.cpp
NativeSessionTest.cpp
NativeSymbolReuseTest.cpp
StringTableBuilderTest.cpp
PDBApiTest.cpp

4
unittests/DebugInfo/PDB/Inputs/SimpleTest.cpp
View File

@ -1,4 +0,0 @@
// Compile with "cl /c /Zi SimpleTest.cpp"
// Link with "link SimpleTest.obj /debug /nodefaultlib /entry:main"
int main() { return 0; }

BIN
unittests/DebugInfo/PDB/Inputs/SimpleTest.exe
View File

Binary file not shown.

BIN
unittests/DebugInfo/PDB/Inputs/SimpleTest.pdb
View File

Binary file not shown.

93
unittests/DebugInfo/PDB/NativeSessionTest.cpp
View File

@ -1,93 +0,0 @@
//===- llvm/unittest/DebugInfo/PDB/NativeSessionTest.cpp ------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
#include "llvm/DebugInfo/PDB/IPDBSession.h"
#include "llvm/DebugInfo/PDB/PDB.h"
#include "llvm/Support/Path.h"
#include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h"
#include <vector>
using namespace llvm;
using namespace llvm::pdb;
extern const char *TestMainArgv0;
static std::string getExePath() {
SmallString<128> InputsDir = unittest::getInputFileDirectory(TestMainArgv0);
llvm::sys::path::append(InputsDir, "SimpleTest.exe");
return std::string(InputsDir);
}
TEST(NativeSessionTest, TestCreateFromExe) {
std::unique_ptr<IPDBSession> S;
Error E = pdb::loadDataForEXE(PDB_ReaderType::Native, getExePath(), S);
ASSERT_THAT_ERROR(std::move(E), Succeeded());
}
TEST(NativeSessionTest, TestSetLoadAddress) {
std::unique_ptr<IPDBSession> S;
Error E = pdb::loadDataForEXE(PDB_ReaderType::Native, getExePath(), S);
ASSERT_THAT_ERROR(std::move(E), Succeeded());
S->setLoadAddress(123);
EXPECT_EQ(S->getLoadAddress(), 123U);
}
TEST(NativeSessionTest, TestAddressForVA) {
std::unique_ptr<IPDBSession> S;
Error E = pdb::loadDataForEXE(PDB_ReaderType::Native, getExePath(), S);
ASSERT_THAT_ERROR(std::move(E), Succeeded());
uint64_t LoadAddr = S->getLoadAddress();
uint32_t Section;
uint32_t Offset;
ASSERT_TRUE(S->addressForVA(LoadAddr + 5000, Section, Offset));
EXPECT_EQ(1U, Section);
EXPECT_EQ(904U, Offset);
ASSERT_TRUE(S->addressForVA(-1, Section, Offset));
EXPECT_EQ(0U, Section);
EXPECT_EQ(0U, Offset);
ASSERT_TRUE(S->addressForVA(4, Section, Offset));
EXPECT_EQ(0U, Section);
EXPECT_EQ(4U, Offset);
ASSERT_TRUE(S->addressForVA(LoadAddr + 100000, Section, Offset));
EXPECT_EQ(3U, Section);
EXPECT_EQ(83616U, Offset);
}
TEST(NativeSessionTest, TestAddressForRVA) {
std::unique_ptr<IPDBSession> S;
Error E = pdb::loadDataForEXE(PDB_ReaderType::Native, getExePath(), S);
ASSERT_THAT_ERROR(std::move(E), Succeeded());
uint32_t Section;
uint32_t Offset;
ASSERT_TRUE(S->addressForVA(5000, Section, Offset));
EXPECT_EQ(1U, Section);
EXPECT_EQ(904U, Offset);
ASSERT_TRUE(S->addressForVA(-1, Section, Offset));
EXPECT_EQ(0U, Section);
EXPECT_EQ(0U, Offset);
ASSERT_TRUE(S->addressForVA(4, Section, Offset));
EXPECT_EQ(0U, Section);
EXPECT_EQ(4U, Offset);
ASSERT_TRUE(S->addressForVA(100000, Section, Offset));
EXPECT_EQ(3U, Section);
EXPECT_EQ(83616U, Offset);
}