OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity

Revert r361842 as it breaks LLDB :: tools/lldb-mi/exec/exec-finish.test 

llvm-svn: 361876
This commit is contained in:
Alexandre Ganea 2019-05-28 20:57:56 +00:00
parent 6d7bf5e8df
commit ccc1fa5e1d
7 changed files with 141 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

213
lld/COFF/DebugTypes.cpp
View File

@ -7,15 +7,8 @@
//===----------------------------------------------------------------------===//
#include "DebugTypes.h"
#include "Driver.h"
#include "InputFiles.h"
#include "lld/Common/ErrorHandler.h"
#include "llvm/DebugInfo/CodeView/TypeRecord.h"
#include "llvm/DebugInfo/PDB/GenericError.h"
#include "llvm/DebugInfo/PDB/Native/InfoStream.h"
#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
#include "llvm/Support/Path.h"
using namespace lld;
using namespace lld::coff;
@ -23,44 +16,14 @@ using namespace llvm;
using namespace llvm::codeview;
namespace {
// The TypeServerSource class represents a PDB type server, a file referenced by
// OBJ files compiled with MSVC /Zi. A single PDB can be shared by several OBJ
// files, therefore there must be only once instance per OBJ lot. The file path
// is discovered from the dependent OBJ's debug type stream. The
// TypeServerSource object is then queued and loaded by the COFF Driver. The
// debug type stream for such PDB files will be merged first in the final PDB,
// before any dependent OBJ.
class TypeServerSource : public TpiSource {
public:
explicit TypeServerSource(MemoryBufferRef M, llvm::pdb::NativeSession *S)
: TpiSource(PDB, nullptr), Session(S), MB(M) {}
// Queue a PDB type server for loading in the COFF Driver
static void enqueue(const ObjFile *DependentFile,
const TypeServer2Record &TS);
// Create an instance
static Expected<TypeServerSource *> getInstance(MemoryBufferRef M);
// Fetch the PDB instance loaded for a corresponding dependent OBJ.
static Expected<TypeServerSource *>
findFromFile(const ObjFile *DependentFile);
static std::map<std::string, std::pair<std::string, TypeServerSource *>>
Instances;
// The interface to the PDB (if it was opened successfully)
std::unique_ptr<llvm::pdb::NativeSession> Session;
private:
MemoryBufferRef MB;
TypeServerSource(ObjFile *F) : TpiSource(PDB, F) {}
};
// This class represents the debug type stream of an OBJ file that depends on a
// PDB type server (see TypeServerSource).
class UseTypeServerSource : public TpiSource {
public:
UseTypeServerSource(const ObjFile *F, const TypeServer2Record *TS)
UseTypeServerSource(ObjFile *F, TypeServer2Record *TS)
: TpiSource(UsingPDB, F), TypeServerDependency(*TS) {}
// Information about the PDB type server dependency, that needs to be loaded
@ -68,20 +31,14 @@ public:
TypeServer2Record TypeServerDependency;
};
// This class represents the debug type stream of a Microsoft precompiled
// headers OBJ (PCH OBJ). This OBJ kind needs to be merged first in the output
// PDB, before any other OBJs that depend on this. Note that only MSVC generate
// such files, clang does not.
class PrecompSource : public TpiSource {
public:
PrecompSource(const ObjFile *F) : TpiSource(PCH, F) {}
PrecompSource(ObjFile *F) : TpiSource(PCH, F) {}
};
// This class represents the debug type stream of an OBJ file that depends on a
// Microsoft precompiled headers OBJ (see PrecompSource).
class UsePrecompSource : public TpiSource {
public:
UsePrecompSource(const ObjFile *F, const PrecompRecord *Precomp)
UsePrecompSource(ObjFile *F, PrecompRecord *Precomp)
: TpiSource(UsingPCH, F), PrecompDependency(*Precomp) {}
// Information about the Precomp OBJ dependency, that needs to be loaded in
@ -92,176 +49,40 @@ public:
static std::vector<std::unique_ptr<TpiSource>> GC;
TpiSource::TpiSource(TpiKind K, const ObjFile *F) : Kind(K), File(F) {
TpiSource::TpiSource(TpiKind K, ObjFile *F) : Kind(K), File(F) {
GC.push_back(std::unique_ptr<TpiSource>(this));
}
TpiSource *lld::coff::makeTpiSource(const ObjFile *F) {
TpiSource *coff::makeTpiSource(ObjFile *F) {
return new TpiSource(TpiSource::Regular, F);
}
TpiSource *lld::coff::makeUseTypeServerSource(const ObjFile *F,
const TypeServer2Record *TS) {
TypeServerSource::enqueue(F, *TS);
TpiSource *coff::makeTypeServerSource(ObjFile *F) {
return new TypeServerSource(F);
}
TpiSource *coff::makeUseTypeServerSource(ObjFile *F, TypeServer2Record *TS) {
return new UseTypeServerSource(F, TS);
}
TpiSource *lld::coff::makePrecompSource(const ObjFile *F) {
return new PrecompSource(F);
}
TpiSource *coff::makePrecompSource(ObjFile *F) { return new PrecompSource(F); }
TpiSource *lld::coff::makeUsePrecompSource(const ObjFile *F,
const PrecompRecord *Precomp) {
TpiSource *coff::makeUsePrecompSource(ObjFile *F, PrecompRecord *Precomp) {
return new UsePrecompSource(F, Precomp);
}
namespace lld {
namespace coff {
template <>
const PrecompRecord &retrieveDependencyInfo(const TpiSource *Source) {
const PrecompRecord &retrieveDependencyInfo(TpiSource *Source) {
assert(Source->Kind == TpiSource::UsingPCH);
return ((const UsePrecompSource *)Source)->PrecompDependency;
return ((UsePrecompSource *)Source)->PrecompDependency;
}
template <>
const TypeServer2Record &retrieveDependencyInfo(const TpiSource *Source) {
const TypeServer2Record &retrieveDependencyInfo(TpiSource *Source) {
assert(Source->Kind == TpiSource::UsingPDB);
return ((const UseTypeServerSource *)Source)->TypeServerDependency;
return ((UseTypeServerSource *)Source)->TypeServerDependency;
}
} // namespace coff
} // namespace lld
std::map<std::string, std::pair<std::string, TypeServerSource *>>
TypeServerSource::Instances;
// Make a PDB path assuming the PDB is in the same folder as the OBJ
static std::string getPdbBaseName(const ObjFile *File, StringRef TSPath) {
StringRef LocalPath =
!File->ParentName.empty() ? File->ParentName : File->getName();
std::string Path = sys::path::parent_path(LocalPath);
// Currently, type server PDBs are only created by MSVC cl, which only runs
// on Windows, so we can assume type server paths are Windows style.
return Path + sys::path::filename(TSPath, sys::path::Style::windows).str();
}
// The casing of the PDB path stamped in the OBJ can differ from the actual path
// on disk. With this, we ensure to always use lowercase as a key for the
// PDBInputFile::Instances map, at least on Windows.
static std::string normalizePdbPath(StringRef path) {
#if defined(_WIN32)
return path.lower();
#else // LINUX
return path;
#endif
}
// If existing, return the actual PDB path on disk.
static Optional<std::string> findPdbPath(StringRef PDBPath,
const ObjFile *DependentFile) {
// Ensure the file exists before anything else. In some cases, if the path
// points to a removable device, Driver::enqueuePath() would fail with an
// error (EAGAIN, "resource unavailable try again") which we want to skip
// silently.
if (llvm::sys::fs::exists(PDBPath))
return normalizePdbPath(PDBPath);
std::string Ret = getPdbBaseName(DependentFile, PDBPath);
if (llvm::sys::fs::exists(Ret))
return normalizePdbPath(Ret);
return None;
}
// Fetch the PDB instance that was already loaded by the COFF Driver.
Expected<TypeServerSource *>
TypeServerSource::findFromFile(const ObjFile *DependentFile) {
const TypeServer2Record &TS =
retrieveDependencyInfo<TypeServer2Record>(DependentFile->DebugTypesObj);
Optional<std::string> P = findPdbPath(TS.Name, DependentFile);
if (!P)
return createFileError(TS.Name, errorCodeToError(std::error_code(
ENOENT, std::generic_category())));
auto It = TypeServerSource::Instances.find(*P);
// The PDB file exists on disk, at this point we expect it to have been
// inserted in the map by TypeServerSource::loadPDB()
assert(It != TypeServerSource::Instances.end());
std::pair<std::string, TypeServerSource *> &PDB = It->second;
if (!PDB.second)
return createFileError(
*P, createStringError(inconvertibleErrorCode(), PDB.first.c_str()));
pdb::PDBFile &PDBFile = (PDB.second)->Session->getPDBFile();
pdb::InfoStream &Info = cantFail(PDBFile.getPDBInfoStream());
// Just because a file with a matching name was found doesn't mean it can be
// used. The GUID and Age must match between the PDB header and the OBJ
// TypeServer2 record. The 'Age' is used by MSVC incremental compilation.
if (Info.getGuid() != TS.getGuid() || Info.getAge() != TS.getAge())
return createFileError(
TS.Name,
make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date));
return PDB.second;
}
// FIXME: Temporary interface until PDBLinker::maybeMergeTypeServerPDB() is
// moved here.
Expected<llvm::pdb::NativeSession *>
lld::coff::findTypeServerSource(const ObjFile *F) {
Expected<TypeServerSource *> TS = TypeServerSource::findFromFile(F);
if (!TS)
return TS.takeError();
return TS.get()->Session.get();
}
// Queue a PDB type server for loading in the COFF Driver
void TypeServerSource::enqueue(const ObjFile *DependentFile,
const TypeServer2Record &TS) {
// Start by finding where the PDB is located (either the record path or next
// to the OBJ file)
Optional<std::string> P = findPdbPath(TS.Name, DependentFile);
if (!P)
return;
auto It = TypeServerSource::Instances.emplace(
*P, std::pair<std::string, TypeServerSource *>{});
if (!It.second)
return; // another OBJ already scheduled this PDB for load
Driver->enqueuePath(*P, false);
}
// Create an instance of TypeServerSource or an error string if the PDB couldn't
// be loaded. The error message will be displayed later, when the referring OBJ
// will be merged in. NOTE - a PDB load failure is not a link error: some
// debug info will simply be missing from the final PDB - that is the default
// accepted behavior.
void lld::coff::loadTypeServerSource(llvm::MemoryBufferRef M) {
std::string Path = normalizePdbPath(M.getBufferIdentifier());
Expected<TypeServerSource *> TS = TypeServerSource::getInstance(M);
if (!TS)
TypeServerSource::Instances[Path] = {toString(TS.takeError()), nullptr};
else
TypeServerSource::Instances[Path] = {{}, *TS};
}
Expected<TypeServerSource *> TypeServerSource::getInstance(MemoryBufferRef M) {
std::unique_ptr<llvm::pdb::IPDBSession> ISession;
Error Err = pdb::NativeSession::createFromPdb(
MemoryBuffer::getMemBuffer(M, false), ISession);
if (Err)
return std::move(Err);
std::unique_ptr<llvm::pdb::NativeSession> Session(
static_cast<pdb::NativeSession *>(ISession.release()));
pdb::PDBFile &PDBFile = Session->getPDBFile();
Expected<pdb::InfoStream &> Info = PDBFile.getPDBInfoStream();
// All PDB Files should have an Info stream.
if (!Info)
return Info.takeError();
return new TypeServerSource(M, Session.release());
}

29
lld/COFF/DebugTypes.h
View File

@ -10,16 +10,12 @@
#define LLD_COFF_DEBUGTYPES_H
#include "llvm/Support/Error.h"
#include "llvm/Support/MemoryBuffer.h"
namespace llvm {
namespace codeview {
class PrecompRecord;
class TypeServer2Record;
} // namespace codeview
namespace pdb {
class NativeSession;
}
} // namespace llvm
namespace lld {
@ -31,28 +27,23 @@ class TpiSource {
public:
enum TpiKind { Regular, PCH, UsingPCH, PDB, UsingPDB };
TpiSource(TpiKind K, const ObjFile *F);
TpiSource(TpiKind K, ObjFile *F);
virtual ~TpiSource() {}
const TpiKind Kind;
const ObjFile *File;
ObjFile *File;
};
TpiSource *makeTpiSource(const ObjFile *F);
TpiSource *makeUseTypeServerSource(const ObjFile *F,
const llvm::codeview::TypeServer2Record *TS);
TpiSource *makePrecompSource(const ObjFile *F);
TpiSource *makeUsePrecompSource(const ObjFile *F,
const llvm::codeview::PrecompRecord *Precomp);
void loadTypeServerSource(llvm::MemoryBufferRef M);
TpiSource *makeTpiSource(ObjFile *F);
TpiSource *makeTypeServerSource(ObjFile *F);
TpiSource *makeUseTypeServerSource(ObjFile *F,
llvm::codeview::TypeServer2Record *TS);
TpiSource *makePrecompSource(ObjFile *F);
TpiSource *makeUsePrecompSource(ObjFile *F,
llvm::codeview::PrecompRecord *Precomp);
// Temporary interface to get the dependency
template <typename T> const T &retrieveDependencyInfo(const TpiSource *Source);
// Temporary interface until we move PDBLinker::maybeMergeTypeServerPDB here
llvm::Expected<llvm::pdb::NativeSession *>
findTypeServerSource(const ObjFile *F);
template <typename T> const T &retrieveDependencyInfo(TpiSource *Source);
} // namespace coff
} // namespace lld

4
lld/COFF/Driver.cpp
View File

@ -6,7 +6,6 @@
//
//===----------------------------------------------------------------------===//
#include "DebugTypes.h"
#include "Driver.h"
#include "Config.h"
#include "ICF.h"
@ -182,9 +181,6 @@ void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> MB,
case file_magic::coff_import_library:
Symtab->addFile(make<ObjFile>(MBRef));
break;
case file_magic::pdb:
loadTypeServerSource(MBRef);
break;
case file_magic::coff_cl_gl_object:
error(Filename + ": is not a native COFF file. Recompile without /GL");
break;

4
lld/COFF/Driver.h
View File

@ -77,8 +77,6 @@ public:
MemoryBufferRef takeBuffer(std::unique_ptr<MemoryBuffer> MB);
void enqueuePath(StringRef Path, bool WholeArchive);
private:
std::unique_ptr<llvm::TarWriter> Tar; // for /linkrepro
@ -122,6 +120,8 @@ private:
void addArchiveBuffer(MemoryBufferRef MBRef, StringRef SymName,
StringRef ParentName, uint64_t OffsetInArchive);
void enqueuePath(StringRef Path, bool WholeArchive);
void enqueueTask(std::function<void()> Task);
bool run();

120
lld/COFF/PDB.cpp
View File

@ -175,6 +175,11 @@ private:
llvm::SmallString<128> NativePath;
/// A list of other PDBs which are loaded during the linking process and which
/// we need to keep around since the linking operation may reference pointers
/// inside of these PDBs.
llvm::SmallVector<std::unique_ptr<pdb::NativeSession>, 2> LoadedPDBs;
std::vector<pdb::SecMapEntry> SectionMap;
/// Type index mappings of type server PDBs that we've loaded so far.
@ -184,6 +189,10 @@ private:
/// far.
std::map<uint32_t, CVIndexMap> PrecompTypeIndexMappings;
/// List of TypeServer PDBs which cannot be loaded.
/// Cached to prevent repeated load attempts.
std::map<codeview::GUID, std::string> MissingTypeServerPDBs;
// For statistics
uint64_t GlobalSymbols = 0;
uint64_t ModuleSymbols = 0;
@ -407,26 +416,115 @@ PDBLinker::mergeDebugT(ObjFile *File, CVIndexMap *ObjectIndexMap) {
return *ObjectIndexMap;
}
static Expected<std::unique_ptr<pdb::NativeSession>>
tryToLoadPDB(const codeview::GUID &GuidFromObj, StringRef TSPath) {
// Ensure the file exists before anything else. We want to return ENOENT,
// "file not found", even if the path points to a removable device (in which
// case the return message would be EAGAIN, "resource unavailable try again")
if (!llvm::sys::fs::exists(TSPath))
return errorCodeToError(std::error_code(ENOENT, std::generic_category()));
ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(
TSPath, /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
if (!MBOrErr)
return errorCodeToError(MBOrErr.getError());
std::unique_ptr<pdb::IPDBSession> ThisSession;
if (auto EC = pdb::NativeSession::createFromPdb(
MemoryBuffer::getMemBuffer(Driver->takeBuffer(std::move(*MBOrErr)),
/*RequiresNullTerminator=*/false),
ThisSession))
return std::move(EC);
std::unique_ptr<pdb::NativeSession> NS(
static_cast<pdb::NativeSession *>(ThisSession.release()));
pdb::PDBFile &File = NS->getPDBFile();
auto ExpectedInfo = File.getPDBInfoStream();
// All PDB Files should have an Info stream.
if (!ExpectedInfo)
return ExpectedInfo.takeError();
// Just because a file with a matching name was found and it was an actual
// PDB file doesn't mean it matches. For it to match the InfoStream's GUID
// must match the GUID specified in the TypeServer2 record.
if (ExpectedInfo->getGuid() != GuidFromObj)
return make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date);
return std::move(NS);
}
Expected<const CVIndexMap &> PDBLinker::maybeMergeTypeServerPDB(ObjFile *File) {
Expected<llvm::pdb::NativeSession *> PDBSession = findTypeServerSource(File);
if (!PDBSession)
return PDBSession.takeError();
const TypeServer2Record &TS =
retrieveDependencyInfo<TypeServer2Record>(File->DebugTypesObj);
pdb::PDBFile &PDBFile = PDBSession.get()->getPDBFile();
pdb::InfoStream &Info = cantFail(PDBFile.getPDBInfoStream());
const codeview::GUID &TSId = TS.getGuid();
StringRef TSPath = TS.getName();
auto It = TypeServerIndexMappings.emplace(Info.getGuid(), CVIndexMap());
CVIndexMap &IndexMap = It.first->second;
if (!It.second)
return IndexMap; // already merged
// First, check if the PDB has previously failed to load.
auto PrevErr = MissingTypeServerPDBs.find(TSId);
if (PrevErr != MissingTypeServerPDBs.end())
return createFileError(
TSPath,
make_error<StringError>(PrevErr->second, inconvertibleErrorCode()));
// Second, check if we already loaded a PDB with this GUID. Return the type
// index mapping if we have it.
auto Insertion = TypeServerIndexMappings.insert({TSId, CVIndexMap()});
CVIndexMap &IndexMap = Insertion.first->second;
if (!Insertion.second)
return IndexMap;
// Mark this map as a type server map.
IndexMap.IsTypeServerMap = true;
Expected<pdb::TpiStream &> ExpectedTpi = PDBFile.getPDBTpiStream();
// Check for a PDB at:
// 1. The given file path
// 2. Next to the object file or archive file
auto ExpectedSession = handleExpected(
tryToLoadPDB(TSId, TSPath),
[&]() {
StringRef LocalPath =
!File->ParentName.empty() ? File->ParentName : File->getName();
SmallString<128> Path = sys::path::parent_path(LocalPath);
// Currently, type server PDBs are only created by cl, which only runs
// on Windows, so we can assume type server paths are Windows style.
sys::path::append(
Path, sys::path::filename(TSPath, sys::path::Style::windows));
return tryToLoadPDB(TSId, Path);
},
[&](std::unique_ptr<ECError> EC) -> Error {
auto SysErr = EC->convertToErrorCode();
// Only re-try loading if the previous error was "No such file or
// directory"
if (SysErr.category() == std::generic_category() &&
SysErr.value() == ENOENT)
return Error::success();
return Error(std::move(EC));
});
if (auto E = ExpectedSession.takeError()) {
TypeServerIndexMappings.erase(TSId);
// Flatten the error to a string, for later display, if the error occurs
// again on the same PDB.
std::string ErrMsg;
raw_string_ostream S(ErrMsg);
S << E;
MissingTypeServerPDBs.emplace(TSId, S.str());
return createFileError(TSPath, std::move(E));
}
pdb::NativeSession *Session = ExpectedSession->get();
// Keep a strong reference to this PDB, so that it's safe to hold pointers
// into the file.
LoadedPDBs.push_back(std::move(*ExpectedSession));
auto ExpectedTpi = Session->getPDBFile().getPDBTpiStream();
if (auto E = ExpectedTpi.takeError())
fatal("Type server does not have TPI stream: " + toString(std::move(E)));
Expected<pdb::TpiStream &> ExpectedIpi = PDBFile.getPDBIpiStream();
auto ExpectedIpi = Session->getPDBFile().getPDBIpiStream();
if (auto E = ExpectedIpi.takeError())
fatal("Type server does not have TPI stream: " + toString(std::move(E)));

2
lld/test/COFF/Inputs/pdb-type-server-valid-signature.yaml
View File

@ -69,7 +69,7 @@ sections:
- Kind: LF_TYPESERVER2
TypeServer2:
Guid: '{8DABD2A0-28FF-CB43-9BAF-175B77B76414}'
Age: 1
Age: 18
Name: 'pdb-diff-cl.pdb'
- Name: '.text$mn'
Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]

4
lld/test/COFF/pdb-type-server-invalid-signature.yaml
View File

@ -4,7 +4,7 @@
# RUN: lld-link %t.obj -out:%t.exe -debug -pdb:%t.pdb -nodefaultlib -entry:main 2>&1 | FileCheck %s
# RUN: cd %S
# CHECK: warning: Cannot use debug info for '{{.*}}.obj'
# CHECK: warning: Cannot use debug info for {{.*}}.obj
# CHECK-NEXT: The signature does not match; the file(s) might be out of date
# Also test a valid match
@ -14,7 +14,7 @@
# RUN: lld-link %t2.obj -out:%t2.exe -debug -pdb:%t2.pdb -nodefaultlib -entry:main 2>&1 | FileCheck %s -check-prefix=VALID-SIGNATURE -allow-empty
# RUN: cd %S
# VALID-SIGNATURE-NOT: warning: Cannot use debug info for '{{.*}}.obj'
# VALID-SIGNATURE-NOT: warning: Cannot use debug info for {{.*}}.obj
# VALID-SIGNATURE-NOT: The signature does not match; the file(s) might be out of date
--- !COFF