caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[JITLink] Switch to SymbolStringPtr for Symbol names (#115796)

Browse Source 
Use SymbolStringPtr for Symbol names in LinkGraph. This reduces string interning
on the boundary between JITLink and ORC, and allows pointer comparisons (rather
than string comparisons) between Symbol names. This should improve the
performance and readability of code that bridges between JITLink and ORC (e.g.
ObjectLinkingLayer and ObjectLinkingLayer::Plugins).

To enable use of SymbolStringPtr a std::shared_ptr<SymbolStringPool> is added to
LinkGraph and threaded through to its construction sites in LLVM and Bolt. All
LinkGraphs that are to have symbol names compared by pointer equality must point
to the same SymbolStringPool instance, which in ORC sessions should be the pool
attached to the ExecutionSession.
---------

Co-authored-by: Lang Hames <lhames@gmail.com>
This commit is contained in:
Jared Wyles
2024-12-06 10:22:09 +11:00
committed by GitHub
parent e6cf5d2863
commit 2ccf7ed277
81 changed files with 667 additions and 494 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@@ -59,6 +59,8 @@ autoconf/autom4te.cache
# VS2017 and VSCode config files. # VS2017 and VSCode config files.
.vscode .vscode
.vs .vs
#zed config files
.zed
# pythonenv for github Codespaces # pythonenv for github Codespaces
pythonenv* pythonenv*
# clangd index. (".clangd" is a config file now, thus trailing slash) # clangd index. (".clangd" is a config file now, thus trailing slash)

19
bolt/include/bolt/Core/BinaryContext.h
View File

@@ -28,6 +28,7 @@
#include "llvm/ADT/iterator.h" #include "llvm/ADT/iterator.h"
#include "llvm/BinaryFormat/Dwarf.h" #include "llvm/BinaryFormat/Dwarf.h"
#include "llvm/BinaryFormat/MachO.h" #include "llvm/BinaryFormat/MachO.h"
#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
#include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCCodeEmitter.h" #include "llvm/MC/MCCodeEmitter.h"
#include "llvm/MC/MCContext.h" #include "llvm/MC/MCContext.h"
@@ -276,11 +277,10 @@ class BinaryContext {
void deregisterSectionName(const BinarySection &Section); void deregisterSectionName(const BinarySection &Section);
public: public:
static Expected<std::unique_ptr<BinaryContext>> static Expected<std::unique_ptr<BinaryContext>> createBinaryContext(
createBinaryContext(Triple TheTriple, StringRef InputFileName, Triple TheTriple, std::shared_ptr<orc::SymbolStringPool> SSP,
SubtargetFeatures *Features, bool IsPIC, StringRef InputFileName, SubtargetFeatures *Features, bool IsPIC,
std::unique_ptr<DWARFContext> DwCtx, std::unique_ptr<DWARFContext> DwCtx, JournalingStreams Logger);
JournalingStreams Logger);
/// Superset of compiler units that will contain overwritten code that needs /// Superset of compiler units that will contain overwritten code that needs
/// new debug info. In a few cases, functions may end up not being /// new debug info. In a few cases, functions may end up not being
@@ -372,6 +372,7 @@ public:
bool hasSymbolsWithFileName() const { return HasSymbolsWithFileName; } bool hasSymbolsWithFileName() const { return HasSymbolsWithFileName; }
void setHasSymbolsWithFileName(bool Value) { HasSymbolsWithFileName = Value; } void setHasSymbolsWithFileName(bool Value) { HasSymbolsWithFileName = Value; }
std::shared_ptr<orc::SymbolStringPool> getSymbolStringPool() { return SSP; }
/// Return true if relocations against symbol with a given name /// Return true if relocations against symbol with a given name
/// must be created. /// must be created.
bool forceSymbolRelocations(StringRef SymbolName) const; bool forceSymbolRelocations(StringRef SymbolName) const;
@@ -631,6 +632,8 @@ public:
std::unique_ptr<Triple> TheTriple; std::unique_ptr<Triple> TheTriple;
std::shared_ptr<orc::SymbolStringPool> SSP;
const Target *TheTarget; const Target *TheTarget;
std::string TripleName; std::string TripleName;
@@ -807,8 +810,10 @@ public:
BinaryContext(std::unique_ptr<MCContext> Ctx, BinaryContext(std::unique_ptr<MCContext> Ctx,
std::unique_ptr<DWARFContext> DwCtx, std::unique_ptr<DWARFContext> DwCtx,
std::unique_ptr<Triple> TheTriple, const Target *TheTarget, std::unique_ptr<Triple> TheTriple,
std::string TripleName, std::unique_ptr<MCCodeEmitter> MCE, std::shared_ptr<orc::SymbolStringPool> SSP,
const Target *TheTarget, std::string TripleName,
std::unique_ptr<MCCodeEmitter> MCE,
std::unique_ptr<MCObjectFileInfo> MOFI, std::unique_ptr<MCObjectFileInfo> MOFI,
std::unique_ptr<const MCAsmInfo> AsmInfo, std::unique_ptr<const MCAsmInfo> AsmInfo,
std::unique_ptr<const MCInstrInfo> MII, std::unique_ptr<const MCInstrInfo> MII,

22
bolt/lib/Core/BinaryContext.cpp
View File

@@ -123,6 +123,7 @@ void BinaryContext::logBOLTErrorsAndQuitOnFatal(Error E) {
BinaryContext::BinaryContext(std::unique_ptr<MCContext> Ctx, BinaryContext::BinaryContext(std::unique_ptr<MCContext> Ctx,
std::unique_ptr<DWARFContext> DwCtx, std::unique_ptr<DWARFContext> DwCtx,
std::unique_ptr<Triple> TheTriple, std::unique_ptr<Triple> TheTriple,
std::shared_ptr<orc::SymbolStringPool> SSP,
const Target *TheTarget, std::string TripleName, const Target *TheTarget, std::string TripleName,
std::unique_ptr<MCCodeEmitter> MCE, std::unique_ptr<MCCodeEmitter> MCE,
std::unique_ptr<MCObjectFileInfo> MOFI, std::unique_ptr<MCObjectFileInfo> MOFI,
@@ -136,12 +137,12 @@ BinaryContext::BinaryContext(std::unique_ptr<MCContext> Ctx,
std::unique_ptr<MCDisassembler> DisAsm, std::unique_ptr<MCDisassembler> DisAsm,
JournalingStreams Logger) JournalingStreams Logger)
: Ctx(std::move(Ctx)), DwCtx(std::move(DwCtx)), : Ctx(std::move(Ctx)), DwCtx(std::move(DwCtx)),
TheTriple(std::move(TheTriple)), TheTarget(TheTarget), TheTriple(std::move(TheTriple)), SSP(std::move(SSP)),
TripleName(TripleName), MCE(std::move(MCE)), MOFI(std::move(MOFI)), TheTarget(TheTarget), TripleName(TripleName), MCE(std::move(MCE)),
AsmInfo(std::move(AsmInfo)), MII(std::move(MII)), STI(std::move(STI)), MOFI(std::move(MOFI)), AsmInfo(std::move(AsmInfo)), MII(std::move(MII)),
InstPrinter(std::move(InstPrinter)), MIA(std::move(MIA)), STI(std::move(STI)), InstPrinter(std::move(InstPrinter)),
MIB(std::move(MIB)), MRI(std::move(MRI)), DisAsm(std::move(DisAsm)), MIA(std::move(MIA)), MIB(std::move(MIB)), MRI(std::move(MRI)),
Logger(Logger), InitialDynoStats(isAArch64()) { DisAsm(std::move(DisAsm)), Logger(Logger), InitialDynoStats(isAArch64()) {
RegularPageSize = isAArch64() ? RegularPageSizeAArch64 : RegularPageSizeX86; RegularPageSize = isAArch64() ? RegularPageSizeAArch64 : RegularPageSizeX86;
PageAlign = opts::NoHugePages ? RegularPageSize : HugePageSize; PageAlign = opts::NoHugePages ? RegularPageSize : HugePageSize;
} }
@@ -159,8 +160,9 @@ BinaryContext::~BinaryContext() {
/// Create BinaryContext for a given architecture \p ArchName and /// Create BinaryContext for a given architecture \p ArchName and
/// triple \p TripleName. /// triple \p TripleName.
Expected<std::unique_ptr<BinaryContext>> BinaryContext::createBinaryContext( Expected<std::unique_ptr<BinaryContext>> BinaryContext::createBinaryContext(
Triple TheTriple, StringRef InputFileName, SubtargetFeatures *Features, Triple TheTriple, std::shared_ptr<orc::SymbolStringPool> SSP,
bool IsPIC, std::unique_ptr<DWARFContext> DwCtx, JournalingStreams Logger) { StringRef InputFileName, SubtargetFeatures *Features, bool IsPIC,
std::unique_ptr<DWARFContext> DwCtx, JournalingStreams Logger) {
StringRef ArchName = ""; StringRef ArchName = "";
std::string FeaturesStr = ""; std::string FeaturesStr = "";
switch (TheTriple.getArch()) { switch (TheTriple.getArch()) {
@@ -283,8 +285,8 @@ Expected<std::unique_ptr<BinaryContext>> BinaryContext::createBinaryContext(
auto BC = std::make_unique<BinaryContext>( auto BC = std::make_unique<BinaryContext>(
std::move(Ctx), std::move(DwCtx), std::make_unique<Triple>(TheTriple), std::move(Ctx), std::move(DwCtx), std::make_unique<Triple>(TheTriple),
TheTarget, std::string(TripleName), std::move(MCE), std::move(MOFI), std::move(SSP), TheTarget, std::string(TripleName), std::move(MCE),
std::move(AsmInfo), std::move(MII), std::move(STI), std::move(MOFI), std::move(AsmInfo), std::move(MII), std::move(STI),
std::move(InstructionPrinter), std::move(MIA), nullptr, std::move(MRI), std::move(InstructionPrinter), std::move(MIA), nullptr, std::move(MRI),
std::move(DisAsm), Logger); std::move(DisAsm), Logger);

3
bolt/lib/Rewrite/DWARFRewriter.cpp
View File

@@ -1691,7 +1691,8 @@ namespace {
std::unique_ptr<BinaryContext> std::unique_ptr<BinaryContext>
createDwarfOnlyBC(const object::ObjectFile &File) { createDwarfOnlyBC(const object::ObjectFile &File) {
return cantFail(BinaryContext::createBinaryContext( return cantFail(BinaryContext::createBinaryContext(
File.makeTriple(), File.getFileName(), nullptr, false, File.makeTriple(), std::make_shared<orc::SymbolStringPool>(),
File.getFileName(), nullptr, false,
DWARFContext::create(File, DWARFContext::ProcessDebugRelocations::Ignore, DWARFContext::create(File, DWARFContext::ProcessDebugRelocations::Ignore,
nullptr, "", WithColor::defaultErrorHandler, nullptr, "", WithColor::defaultErrorHandler,
WithColor::defaultWarningHandler), WithColor::defaultWarningHandler),

8
bolt/lib/Rewrite/JITLinkLinker.cpp
View File

@@ -122,7 +122,7 @@ struct JITLinkLinker::Context : jitlink::JITLinkContext {
jitlink::AsyncLookupResult AllResults; jitlink::AsyncLookupResult AllResults;
for (const auto &Symbol : Symbols) { for (const auto &Symbol : Symbols) {
std::string SymName = Symbol.first.str(); std::string SymName = (*Symbol.first).str();
LLVM_DEBUG(dbgs() << "BOLT: looking for " << SymName << "\n"); LLVM_DEBUG(dbgs() << "BOLT: looking for " << SymName << "\n");
if (auto Address = Linker.lookupSymbol(SymName)) { if (auto Address = Linker.lookupSymbol(SymName)) {
@@ -167,7 +167,9 @@ struct JITLinkLinker::Context : jitlink::JITLinkContext {
Error notifyResolved(jitlink::LinkGraph &G) override { Error notifyResolved(jitlink::LinkGraph &G) override {
for (auto *Symbol : G.defined_symbols()) { for (auto *Symbol : G.defined_symbols()) {
SymbolInfo Info{Symbol->getAddress().getValue(), Symbol->getSize()}; SymbolInfo Info{Symbol->getAddress().getValue(), Symbol->getSize()};
Linker.Symtab.insert({Symbol->getName().str(), Info}); auto Name =
Symbol->hasName() ? (*Symbol->getName()).str() : std::string();
Linker.Symtab.insert({std::move(Name), Info});
} }
return Error::success(); return Error::success();
@@ -189,7 +191,7 @@ JITLinkLinker::~JITLinkLinker() { cantFail(MM->deallocate(std::move(Allocs))); }
void JITLinkLinker::loadObject(MemoryBufferRef Obj, void JITLinkLinker::loadObject(MemoryBufferRef Obj,
SectionsMapper MapSections) { SectionsMapper MapSections) {
auto LG = jitlink::createLinkGraphFromObject(Obj); auto LG = jitlink::createLinkGraphFromObject(Obj, BC.getSymbolStringPool());
if (auto E = LG.takeError()) { if (auto E = LG.takeError()) {
errs() << "BOLT-ERROR: JITLink failed: " << E << '\n'; errs() << "BOLT-ERROR: JITLink failed: " << E << '\n';
exit(1); exit(1);

3
bolt/lib/Rewrite/MachORewriteInstance.cpp
View File

@@ -74,7 +74,8 @@ MachORewriteInstance::MachORewriteInstance(object::MachOObjectFile *InputFile,
ErrorAsOutParameter EAO(&Err); ErrorAsOutParameter EAO(&Err);
Relocation::Arch = InputFile->makeTriple().getArch(); Relocation::Arch = InputFile->makeTriple().getArch();
auto BCOrErr = BinaryContext::createBinaryContext( auto BCOrErr = BinaryContext::createBinaryContext(
InputFile->makeTriple(), InputFile->getFileName(), nullptr, InputFile->makeTriple(), std::make_shared<orc::SymbolStringPool>(),
InputFile->getFileName(), nullptr,
/* IsPIC */ true, DWARFContext::create(*InputFile), /* IsPIC */ true, DWARFContext::create(*InputFile),
{llvm::outs(), llvm::errs()}); {llvm::outs(), llvm::errs()});
if (Error E = BCOrErr.takeError()) { if (Error E = BCOrErr.takeError()) {

3
bolt/lib/Rewrite/RewriteInstance.cpp
View File

@@ -356,7 +356,8 @@ RewriteInstance::RewriteInstance(ELFObjectFileBase *File, const int Argc,
Relocation::Arch = TheTriple.getArch(); Relocation::Arch = TheTriple.getArch();
auto BCOrErr = BinaryContext::createBinaryContext( auto BCOrErr = BinaryContext::createBinaryContext(
TheTriple, File->getFileName(), Features.get(), IsPIC, TheTriple, std::make_shared<orc::SymbolStringPool>(), File->getFileName(),
Features.get(), IsPIC,
DWARFContext::create(*File, DWARFContext::ProcessDebugRelocations::Ignore, DWARFContext::create(*File, DWARFContext::ProcessDebugRelocations::Ignore,
nullptr, opts::DWPPathName, nullptr, opts::DWPPathName,
WithColor::defaultErrorHandler, WithColor::defaultErrorHandler,

5
bolt/unittests/Core/BinaryContext.cpp
View File

@@ -48,7 +48,8 @@ protected:
void initializeBOLT() { void initializeBOLT() {
Relocation::Arch = ObjFile->makeTriple().getArch(); Relocation::Arch = ObjFile->makeTriple().getArch();
BC = cantFail(BinaryContext::createBinaryContext( BC = cantFail(BinaryContext::createBinaryContext(
ObjFile->makeTriple(), ObjFile->getFileName(), nullptr, true, ObjFile->makeTriple(), std::make_shared<orc::SymbolStringPool>(),
ObjFile->getFileName(), nullptr, true,
DWARFContext::create(*ObjFile.get()), {llvm::outs(), llvm::errs()})); DWARFContext::create(*ObjFile.get()), {llvm::outs(), llvm::errs()}));
ASSERT_FALSE(!BC); ASSERT_FALSE(!BC);
} }
@@ -216,4 +217,4 @@ TEST_P(BinaryContextTester, BaseAddressSegmentsSmallerThanAlignment) {
BC->getBaseAddressForMapping(0xaaaaaaab1000, 0x1000); BC->getBaseAddressForMapping(0xaaaaaaab1000, 0x1000);
ASSERT_TRUE(BaseAddress.has_value()); ASSERT_TRUE(BaseAddress.has_value());
ASSERT_EQ(*BaseAddress, 0xaaaaaaaa0000ULL); ASSERT_EQ(*BaseAddress, 0xaaaaaaaa0000ULL);
} }

3
bolt/unittests/Core/MCPlusBuilder.cpp
View File

@@ -58,7 +58,8 @@ protected:
void initializeBolt() { void initializeBolt() {
Relocation::Arch = ObjFile->makeTriple().getArch(); Relocation::Arch = ObjFile->makeTriple().getArch();
BC = cantFail(BinaryContext::createBinaryContext( BC = cantFail(BinaryContext::createBinaryContext(
ObjFile->makeTriple(), ObjFile->getFileName(), nullptr, true, ObjFile->makeTriple(), std::make_shared<orc::SymbolStringPool>(),
ObjFile->getFileName(), nullptr, true,
DWARFContext::create(*ObjFile.get()), {llvm::outs(), llvm::errs()})); DWARFContext::create(*ObjFile.get()), {llvm::outs(), llvm::errs()}));
ASSERT_FALSE(!BC); ASSERT_FALSE(!BC);
BC->initializeTarget(std::unique_ptr<MCPlusBuilder>( BC->initializeTarget(std::unique_ptr<MCPlusBuilder>(

3
bolt/unittests/Core/MemoryMaps.cpp
View File

@@ -59,7 +59,8 @@ protected:
void initializeBOLT() { void initializeBOLT() {
Relocation::Arch = ObjFile->makeTriple().getArch(); Relocation::Arch = ObjFile->makeTriple().getArch();
BC = cantFail(BinaryContext::createBinaryContext( BC = cantFail(BinaryContext::createBinaryContext(
ObjFile->makeTriple(), ObjFile->getFileName(), nullptr, true, ObjFile->makeTriple(), std::make_shared<orc::SymbolStringPool>(),
ObjFile->getFileName(), nullptr, true,
DWARFContext::create(*ObjFile.get()), {llvm::outs(), llvm::errs()})); DWARFContext::create(*ObjFile.get()), {llvm::outs(), llvm::errs()}));
ASSERT_FALSE(!BC); ASSERT_FALSE(!BC);
} }

3
llvm/include/llvm/ExecutionEngine/JITLink/COFF.h
View File

@@ -24,7 +24,8 @@ namespace jitlink {
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer); createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP);
/// Link the given graph. /// Link the given graph.
/// ///

4
llvm/include/llvm/ExecutionEngine/JITLink/COFF_x86_64.h
View File

@@ -23,8 +23,8 @@ namespace jitlink {
/// Note: The graph does not take ownership of the underlying buffer, nor copy /// Note: The graph does not take ownership of the underlying buffer, nor copy
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromCOFFObject_x86_64(
createLinkGraphFromCOFFObject_x86_64(MemoryBufferRef ObjectBuffer); MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given object buffer, which must be a COFF x86-64 object file. /// jit-link the given object buffer, which must be a COFF x86-64 object file.
void link_COFF_x86_64(std::unique_ptr<LinkGraph> G, void link_COFF_x86_64(std::unique_ptr<LinkGraph> G,

3
llvm/include/llvm/ExecutionEngine/JITLink/ELF.h
View File

@@ -24,7 +24,8 @@ namespace jitlink {
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer); createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP);
/// Link the given graph. /// Link the given graph.
/// ///

4
llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch32.h
View File

@@ -24,8 +24,8 @@ namespace jitlink {
/// Note: The graph does not take ownership of the underlying buffer, nor copy /// Note: The graph does not take ownership of the underlying buffer, nor copy
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_aarch32(
createLinkGraphFromELFObject_aarch32(MemoryBufferRef ObjectBuffer); MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given object buffer, which must be an ELF arm/thumb object /// jit-link the given object buffer, which must be an ELF arm/thumb object
/// file. /// file.

4
llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch64.h
View File

@@ -25,8 +25,8 @@ namespace jitlink {
/// Note: The graph does not take ownership of the underlying buffer, nor copy /// Note: The graph does not take ownership of the underlying buffer, nor copy
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_aarch64(
createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer); MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given object buffer, which must be a ELF aarch64 relocatable /// jit-link the given object buffer, which must be a ELF aarch64 relocatable
/// object file. /// object file.

3
llvm/include/llvm/ExecutionEngine/JITLink/ELF_i386.h
View File

@@ -26,7 +26,8 @@ namespace jitlink {
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer); createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given object buffer, which must be a ELF i386 relocatable /// jit-link the given object buffer, which must be a ELF i386 relocatable
/// object file. /// object file.

4
llvm/include/llvm/ExecutionEngine/JITLink/ELF_loongarch.h
View File

@@ -25,8 +25,8 @@ namespace jitlink {
/// Note: The graph does not take ownership of the underlying buffer, nor copy /// Note: The graph does not take ownership of the underlying buffer, nor copy
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_loongarch(
createLinkGraphFromELFObject_loongarch(MemoryBufferRef ObjectBuffer); MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given object buffer, which must be an ELF loongarch object /// jit-link the given object buffer, which must be an ELF loongarch object
/// file. /// file.

7
llvm/include/llvm/ExecutionEngine/JITLink/ELF_ppc64.h
View File

@@ -25,15 +25,16 @@ namespace llvm::jitlink {
/// ///
/// WARNING: The big-endian backend has not been tested yet. /// WARNING: The big-endian backend has not been tested yet.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer); createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP);
/// Create a LinkGraph from an ELF/ppc64le relocatable object. /// Create a LinkGraph from an ELF/ppc64le relocatable object.
/// ///
/// Note: The graph does not take ownership of the underlying buffer, nor copy /// Note: The graph does not take ownership of the underlying buffer, nor copy
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_ppc64le(
createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer); MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given object buffer, which must be a ELF ppc64le object file. /// jit-link the given object buffer, which must be a ELF ppc64le object file.
/// ///

3
llvm/include/llvm/ExecutionEngine/JITLink/ELF_riscv.h
View File

@@ -26,7 +26,8 @@ namespace jitlink {
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer); createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given object buffer, which must be a ELF riscv object file. /// jit-link the given object buffer, which must be a ELF riscv object file.
void link_ELF_riscv(std::unique_ptr<LinkGraph> G, void link_ELF_riscv(std::unique_ptr<LinkGraph> G,

3
llvm/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h
View File

@@ -24,7 +24,8 @@ namespace jitlink {
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer); createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given object buffer, which must be a ELF x86-64 object file. /// jit-link the given object buffer, which must be a ELF x86-64 object file.
void link_ELF_x86_64(std::unique_ptr<LinkGraph> G, void link_ELF_x86_64(std::unique_ptr<LinkGraph> G,

161
llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h
View File

@@ -23,6 +23,7 @@
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h" #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h" #include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
#include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h" #include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h"
#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
#include "llvm/Support/Allocator.h" #include "llvm/Support/Allocator.h"
#include "llvm/Support/BinaryStreamReader.h" #include "llvm/Support/BinaryStreamReader.h"
#include "llvm/Support/BinaryStreamWriter.h" #include "llvm/Support/BinaryStreamWriter.h"
@@ -396,12 +397,7 @@ const char *getLinkageName(Linkage L);
/// SideEffectsOnly -- Like hidden, but symbol can only be looked up once /// SideEffectsOnly -- Like hidden, but symbol can only be looked up once
/// to trigger materialization of the containing graph. /// to trigger materialization of the containing graph.
/// Local -- Visible only within the LinkGraph. /// Local -- Visible only within the LinkGraph.
enum class Scope : uint8_t { enum class Scope : uint8_t { Default, Hidden, SideEffectsOnly, Local };
Default,
Hidden,
SideEffectsOnly,
Local
};
/// For debugging output. /// For debugging output.
const char *getScopeName(Scope S); const char *getScopeName(Scope S);
@@ -425,10 +421,11 @@ class Symbol {
friend class LinkGraph; friend class LinkGraph;
private: private:
Symbol(Addressable &Base, orc::ExecutorAddrDiff Offset, StringRef Name, Symbol(Addressable &Base, orc::ExecutorAddrDiff Offset,
orc::ExecutorAddrDiff Size, Linkage L, Scope S, bool IsLive, orc::SymbolStringPtr &&Name, orc::ExecutorAddrDiff Size, Linkage L,
bool IsCallable) Scope S, bool IsLive, bool IsCallable)
: Name(Name), Base(&Base), Offset(Offset), WeakRef(0), Size(Size) { : Name(std::move(Name)), Base(&Base), Offset(Offset), WeakRef(0),
Size(Size) {
assert(Offset <= MaxOffset && "Offset out of range"); assert(Offset <= MaxOffset && "Offset out of range");
setLinkage(L); setLinkage(L);
setScope(S); setScope(S);
@@ -438,26 +435,29 @@ private:
} }
static Symbol &constructExternal(BumpPtrAllocator &Allocator, static Symbol &constructExternal(BumpPtrAllocator &Allocator,
Addressable &Base, StringRef Name, Addressable &Base,
orc::SymbolStringPtr &&Name,
orc::ExecutorAddrDiff Size, Linkage L, orc::ExecutorAddrDiff Size, Linkage L,
bool WeaklyReferenced) { bool WeaklyReferenced) {
assert(!Base.isDefined() && assert(!Base.isDefined() &&
"Cannot create external symbol from defined block"); "Cannot create external symbol from defined block");
assert(!Name.empty() && "External symbol name cannot be empty"); assert(Name && "External symbol name cannot be empty");
auto *Sym = Allocator.Allocate<Symbol>(); auto *Sym = Allocator.Allocate<Symbol>();
new (Sym) Symbol(Base, 0, Name, Size, L, Scope::Default, false, false); new (Sym)
Symbol(Base, 0, std::move(Name), Size, L, Scope::Default, false, false);
Sym->setWeaklyReferenced(WeaklyReferenced); Sym->setWeaklyReferenced(WeaklyReferenced);
return *Sym; return *Sym;
} }
static Symbol &constructAbsolute(BumpPtrAllocator &Allocator, static Symbol &constructAbsolute(BumpPtrAllocator &Allocator,
Addressable &Base, StringRef Name, Addressable &Base,
orc::SymbolStringPtr &&Name,
orc::ExecutorAddrDiff Size, Linkage L, orc::ExecutorAddrDiff Size, Linkage L,
Scope S, bool IsLive) { Scope S, bool IsLive) {
assert(!Base.isDefined() && assert(!Base.isDefined() &&
"Cannot create absolute symbol from a defined block"); "Cannot create absolute symbol from a defined block");
auto *Sym = Allocator.Allocate<Symbol>(); auto *Sym = Allocator.Allocate<Symbol>();
new (Sym) Symbol(Base, 0, Name, Size, L, S, IsLive, false); new (Sym) Symbol(Base, 0, std::move(Name), Size, L, S, IsLive, false);
return *Sym; return *Sym;
} }
@@ -468,20 +468,22 @@ private:
assert((Offset + Size) <= Base.getSize() && assert((Offset + Size) <= Base.getSize() &&
"Symbol extends past end of block"); "Symbol extends past end of block");
auto *Sym = Allocator.Allocate<Symbol>(); auto *Sym = Allocator.Allocate<Symbol>();
new (Sym) Symbol(Base, Offset, StringRef(), Size, Linkage::Strong, new (Sym) Symbol(Base, Offset, nullptr, Size, Linkage::Strong, Scope::Local,
Scope::Local, IsLive, IsCallable); IsLive, IsCallable);
return *Sym; return *Sym;
} }
static Symbol &constructNamedDef(BumpPtrAllocator &Allocator, Block &Base, static Symbol &constructNamedDef(BumpPtrAllocator &Allocator, Block &Base,
orc::ExecutorAddrDiff Offset, StringRef Name, orc::ExecutorAddrDiff Offset,
orc::SymbolStringPtr Name,
orc::ExecutorAddrDiff Size, Linkage L, orc::ExecutorAddrDiff Size, Linkage L,
Scope S, bool IsLive, bool IsCallable) { Scope S, bool IsLive, bool IsCallable) {
assert((Offset + Size) <= Base.getSize() && assert((Offset + Size) <= Base.getSize() &&
"Symbol extends past end of block"); "Symbol extends past end of block");
assert(!Name.empty() && "Name cannot be empty"); assert(Name && "Name cannot be empty");
auto *Sym = Allocator.Allocate<Symbol>(); auto *Sym = Allocator.Allocate<Symbol>();
new (Sym) Symbol(Base, Offset, Name, Size, L, S, IsLive, IsCallable); new (Sym)
Symbol(Base, Offset, std::move(Name), Size, L, S, IsLive, IsCallable);
return *Sym; return *Sym;
} }
@@ -498,18 +500,19 @@ public:
Symbol &operator=(Symbol &&) = delete; Symbol &operator=(Symbol &&) = delete;
/// Returns true if this symbol has a name. /// Returns true if this symbol has a name.
bool hasName() const { return !Name.empty(); } bool hasName() const { return Name != nullptr; }
/// Returns the name of this symbol (empty if the symbol is anonymous). /// Returns the name of this symbol (empty if the symbol is anonymous).
StringRef getName() const { const orc::SymbolStringPtr &getName() const {
assert((!Name.empty() || getScope() == Scope::Local) && assert((hasName() || getScope() == Scope::Local) &&
"Anonymous symbol has non-local scope"); "Anonymous symbol has non-local scope");
return Name; return Name;
} }
/// Rename this symbol. The client is responsible for updating scope and /// Rename this symbol. The client is responsible for updating scope and
/// linkage if this name-change requires it. /// linkage if this name-change requires it.
void setName(StringRef Name) { this->Name = Name; } void setName(const orc::SymbolStringPtr Name) { this->Name = Name; }
/// Returns true if this Symbol has content (potentially) defined within this /// Returns true if this Symbol has content (potentially) defined within this
/// object file (i.e. is anything but an external or absolute symbol). /// object file (i.e. is anything but an external or absolute symbol).
@@ -616,7 +619,7 @@ public:
/// Set the linkage for this Symbol. /// Set the linkage for this Symbol.
void setLinkage(Linkage L) { void setLinkage(Linkage L) {
assert((L == Linkage::Strong || (!Base->isAbsolute() && !Name.empty())) && assert((L == Linkage::Strong || (!Base->isAbsolute() && Name)) &&
"Linkage can only be applied to defined named symbols"); "Linkage can only be applied to defined named symbols");
this->L = static_cast<uint8_t>(L); this->L = static_cast<uint8_t>(L);
} }
@@ -626,7 +629,7 @@ public:
/// Set the visibility for this Symbol. /// Set the visibility for this Symbol.
void setScope(Scope S) { void setScope(Scope S) {
assert((!Name.empty() || S == Scope::Local) && assert((hasName() || S == Scope::Local) &&
"Can not set anonymous symbol to non-local scope"); "Can not set anonymous symbol to non-local scope");
assert((S != Scope::Local || Base->isDefined() || Base->isAbsolute()) && assert((S != Scope::Local || Base->isDefined() || Base->isAbsolute()) &&
"Invalid visibility for symbol type"); "Invalid visibility for symbol type");
@@ -678,8 +681,7 @@ private:
static constexpr uint64_t MaxOffset = (1ULL << 59) - 1; static constexpr uint64_t MaxOffset = (1ULL << 59) - 1;
// FIXME: A char* or SymbolStringPtr may pack better. orc::SymbolStringPtr Name = nullptr;
StringRef Name;
Addressable *Base = nullptr; Addressable *Base = nullptr;
uint64_t Offset : 57; uint64_t Offset : 57;
uint64_t L : 1; uint64_t L : 1;
@@ -1004,22 +1006,23 @@ public:
using GetEdgeKindNameFunction = const char *(*)(Edge::Kind); using GetEdgeKindNameFunction = const char *(*)(Edge::Kind);
LinkGraph(std::string Name, const Triple &TT, SubtargetFeatures Features, LinkGraph(std::string Name, std::shared_ptr<orc::SymbolStringPool> SSP,
unsigned PointerSize, llvm::endianness Endianness, const Triple &TT, SubtargetFeatures Features, unsigned PointerSize,
GetEdgeKindNameFunction GetEdgeKindName)
: Name(std::move(Name)), TT(TT), Features(std::move(Features)),
PointerSize(PointerSize), Endianness(Endianness),
GetEdgeKindName(std::move(GetEdgeKindName)) {}
LinkGraph(std::string Name, const Triple &TT, unsigned PointerSize,
llvm::endianness Endianness, llvm::endianness Endianness,
GetEdgeKindNameFunction GetEdgeKindName) GetEdgeKindNameFunction GetEdgeKindName)
: LinkGraph(std::move(Name), TT, SubtargetFeatures(), PointerSize, : Name(std::move(Name)), SSP(std::move(SSP)), TT(TT),
Endianness, GetEdgeKindName) {} Features(std::move(Features)), PointerSize(PointerSize),
Endianness(Endianness), GetEdgeKindName(std::move(GetEdgeKindName)) {}
LinkGraph(std::string Name, const Triple &TT, LinkGraph(std::string Name, std::shared_ptr<orc::SymbolStringPool> SSP,
const Triple &TT, unsigned PointerSize, llvm::endianness Endianness,
GetEdgeKindNameFunction GetEdgeKindName) GetEdgeKindNameFunction GetEdgeKindName)
: LinkGraph(std::move(Name), TT, SubtargetFeatures(), : LinkGraph(std::move(Name), std::move(SSP), TT, SubtargetFeatures(),
PointerSize, Endianness, GetEdgeKindName) {}
LinkGraph(std::string Name, std::shared_ptr<orc::SymbolStringPool> SSP,
const Triple &TT, GetEdgeKindNameFunction GetEdgeKindName)
: LinkGraph(std::move(Name), std::move(SSP), TT, SubtargetFeatures(),
Triple::getArchPointerBitWidth(TT.getArch()) / 8, Triple::getArchPointerBitWidth(TT.getArch()) / 8,
TT.isLittleEndian() ? endianness::little : endianness::big, TT.isLittleEndian() ? endianness::little : endianness::big,
GetEdgeKindName) { GetEdgeKindName) {
@@ -1031,6 +1034,7 @@ public:
LinkGraph &operator=(const LinkGraph &) = delete; LinkGraph &operator=(const LinkGraph &) = delete;
LinkGraph(LinkGraph &&) = delete; LinkGraph(LinkGraph &&) = delete;
LinkGraph &operator=(LinkGraph &&) = delete; LinkGraph &operator=(LinkGraph &&) = delete;
~LinkGraph();
/// Returns the name of this graph (usually the name of the original /// Returns the name of this graph (usually the name of the original
/// underlying MemoryBuffer). /// underlying MemoryBuffer).
@@ -1050,6 +1054,8 @@ public:
const char *getEdgeKindName(Edge::Kind K) const { return GetEdgeKindName(K); } const char *getEdgeKindName(Edge::Kind K) const { return GetEdgeKindName(K); }
std::shared_ptr<orc::SymbolStringPool> getSymbolStringPool() { return SSP; }
/// Allocate a mutable buffer of the given size using the LinkGraph's /// Allocate a mutable buffer of the given size using the LinkGraph's
/// allocator. /// allocator.
MutableArrayRef<char> allocateBuffer(size_t Size) { MutableArrayRef<char> allocateBuffer(size_t Size) {
@@ -1263,6 +1269,10 @@ public:
return splitBlockImpl(std::move(Blocks), Cache); return splitBlockImpl(std::move(Blocks), Cache);
} }
//
orc::SymbolStringPtr intern(StringRef SymbolName) {
return SSP->intern(SymbolName);
}
/// Add an external symbol. /// Add an external symbol.
/// Some formats (e.g. ELF) allow Symbols to have sizes. For Symbols whose /// Some formats (e.g. ELF) allow Symbols to have sizes. For Symbols whose
/// size is not known, you should substitute '0'. /// size is not known, you should substitute '0'.
@@ -1271,18 +1281,25 @@ public:
/// found or an error will be emitted. Externals that are weakly referenced /// found or an error will be emitted. Externals that are weakly referenced
/// are permitted to be undefined, in which case they are assigned an address /// are permitted to be undefined, in which case they are assigned an address
/// of 0. /// of 0.
Symbol &addExternalSymbol(StringRef Name, orc::ExecutorAddrDiff Size, Symbol &addExternalSymbol(orc::SymbolStringPtr Name,
orc::ExecutorAddrDiff Size,
bool IsWeaklyReferenced) { bool IsWeaklyReferenced) {
assert(!ExternalSymbols.contains(Name) && "Duplicate external symbol"); assert(!ExternalSymbols.contains(*Name) && "Duplicate external symbol");
auto &Sym = Symbol::constructExternal( auto &Sym = Symbol::constructExternal(
Allocator, createAddressable(orc::ExecutorAddr(), false), Name, Size, Allocator, createAddressable(orc::ExecutorAddr(), false),
Linkage::Strong, IsWeaklyReferenced); std::move(Name), Size, Linkage::Strong, IsWeaklyReferenced);
ExternalSymbols.insert({Sym.getName(), &Sym}); ExternalSymbols.insert({*Sym.getName(), &Sym});
return Sym; return Sym;
} }
Symbol &addExternalSymbol(StringRef Name, orc::ExecutorAddrDiff Size,
bool IsWeaklyReferenced) {
return addExternalSymbol(SSP->intern(Name), Size, IsWeaklyReferenced);
}
/// Add an absolute symbol. /// Add an absolute symbol.
Symbol &addAbsoluteSymbol(StringRef Name, orc::ExecutorAddr Address, Symbol &addAbsoluteSymbol(orc::SymbolStringPtr Name,
orc::ExecutorAddr Address,
orc::ExecutorAddrDiff Size, Linkage L, Scope S, orc::ExecutorAddrDiff Size, Linkage L, Scope S,
bool IsLive) { bool IsLive) {
assert((S == Scope::Local || llvm::count_if(AbsoluteSymbols, assert((S == Scope::Local || llvm::count_if(AbsoluteSymbols,
@@ -1291,11 +1308,18 @@ public:
}) == 0) && }) == 0) &&
"Duplicate absolute symbol"); "Duplicate absolute symbol");
auto &Sym = Symbol::constructAbsolute(Allocator, createAddressable(Address), auto &Sym = Symbol::constructAbsolute(Allocator, createAddressable(Address),
Name, Size, L, S, IsLive); std::move(Name), Size, L, S, IsLive);
AbsoluteSymbols.insert(&Sym); AbsoluteSymbols.insert(&Sym);
return Sym; return Sym;
} }
Symbol &addAbsoluteSymbol(StringRef Name, orc::ExecutorAddr Address,
orc::ExecutorAddrDiff Size, Linkage L, Scope S,
bool IsLive) {
return addAbsoluteSymbol(SSP->intern(Name), Address, Size, L, S, IsLive);
}
/// Add an anonymous symbol. /// Add an anonymous symbol.
Symbol &addAnonymousSymbol(Block &Content, orc::ExecutorAddrDiff Offset, Symbol &addAnonymousSymbol(Block &Content, orc::ExecutorAddrDiff Offset,
orc::ExecutorAddrDiff Size, bool IsCallable, orc::ExecutorAddrDiff Size, bool IsCallable,
@@ -1310,13 +1334,22 @@ public:
Symbol &addDefinedSymbol(Block &Content, orc::ExecutorAddrDiff Offset, Symbol &addDefinedSymbol(Block &Content, orc::ExecutorAddrDiff Offset,
StringRef Name, orc::ExecutorAddrDiff Size, StringRef Name, orc::ExecutorAddrDiff Size,
Linkage L, Scope S, bool IsCallable, bool IsLive) { Linkage L, Scope S, bool IsCallable, bool IsLive) {
return addDefinedSymbol(Content, Offset, SSP->intern(Name), Size, L, S,
IsCallable, IsLive);
}
Symbol &addDefinedSymbol(Block &Content, orc::ExecutorAddrDiff Offset,
orc::SymbolStringPtr Name,
orc::ExecutorAddrDiff Size, Linkage L, Scope S,
bool IsCallable, bool IsLive) {
assert((S == Scope::Local || llvm::count_if(defined_symbols(), assert((S == Scope::Local || llvm::count_if(defined_symbols(),
[&](const Symbol *Sym) { [&](const Symbol *Sym) {
return Sym->getName() == Name; return Sym->getName() == Name;
}) == 0) && }) == 0) &&
"Duplicate defined symbol"); "Duplicate defined symbol");
auto &Sym = Symbol::constructNamedDef(Allocator, Content, Offset, Name, auto &Sym =
Size, L, S, IsLive, IsCallable); Symbol::constructNamedDef(Allocator, Content, Offset, std::move(Name),
Size, L, S, IsLive, IsCallable);
Content.getSection().addSymbol(Sym); Content.getSection().addSymbol(Sym);
return Sym; return Sym;
} }
@@ -1401,7 +1434,7 @@ public:
Sec.removeSymbol(Sym); Sec.removeSymbol(Sym);
Sym.makeExternal(createAddressable(orc::ExecutorAddr(), false)); Sym.makeExternal(createAddressable(orc::ExecutorAddr(), false));
} }
ExternalSymbols.insert({Sym.getName(), &Sym}); ExternalSymbols.insert({*Sym.getName(), &Sym});
} }
/// Make the given symbol an absolute with the given address (must not already /// Make the given symbol an absolute with the given address (must not already
@@ -1415,10 +1448,10 @@ public:
void makeAbsolute(Symbol &Sym, orc::ExecutorAddr Address) { void makeAbsolute(Symbol &Sym, orc::ExecutorAddr Address) {
assert(!Sym.isAbsolute() && "Symbol is already absolute"); assert(!Sym.isAbsolute() && "Symbol is already absolute");
if (Sym.isExternal()) { if (Sym.isExternal()) {
assert(ExternalSymbols.contains(Sym.getName()) && assert(ExternalSymbols.contains(*Sym.getName()) &&
"Sym is not in the absolute symbols set"); "Sym is not in the absolute symbols set");
assert(Sym.getOffset() == 0 && "External is not at offset 0"); assert(Sym.getOffset() == 0 && "External is not at offset 0");
ExternalSymbols.erase(Sym.getName()); ExternalSymbols.erase(*Sym.getName());
auto &A = Sym.getAddressable(); auto &A = Sym.getAddressable();
A.setAbsolute(true); A.setAbsolute(true);
A.setAddress(Address); A.setAddress(Address);
@@ -1443,9 +1476,9 @@ public:
"Symbol is not in the absolutes set"); "Symbol is not in the absolutes set");
AbsoluteSymbols.erase(&Sym); AbsoluteSymbols.erase(&Sym);
} else { } else {
assert(ExternalSymbols.contains(Sym.getName()) && assert(ExternalSymbols.contains(*Sym.getName()) &&
"Symbol is not in the externals set"); "Symbol is not in the externals set");
ExternalSymbols.erase(Sym.getName()); ExternalSymbols.erase(*Sym.getName());
} }
Addressable &OldBase = *Sym.Base; Addressable &OldBase = *Sym.Base;
Sym.setBlock(Content); Sym.setBlock(Content);
@@ -1530,9 +1563,9 @@ public:
void removeExternalSymbol(Symbol &Sym) { void removeExternalSymbol(Symbol &Sym) {
assert(!Sym.isDefined() && !Sym.isAbsolute() && assert(!Sym.isDefined() && !Sym.isAbsolute() &&
"Sym is not an external symbol"); "Sym is not an external symbol");
assert(ExternalSymbols.contains(Sym.getName()) && assert(ExternalSymbols.contains(*Sym.getName()) &&
"Symbol is not in the externals set"); "Symbol is not in the externals set");
ExternalSymbols.erase(Sym.getName()); ExternalSymbols.erase(*Sym.getName());
Addressable &Base = *Sym.Base; Addressable &Base = *Sym.Base;
assert(llvm::none_of(external_symbols(), assert(llvm::none_of(external_symbols(),
[&](Symbol *AS) { return AS->Base == &Base; }) && [&](Symbol *AS) { return AS->Base == &Base; }) &&
@@ -1603,12 +1636,14 @@ private:
BumpPtrAllocator Allocator; BumpPtrAllocator Allocator;
std::string Name; std::string Name;
std::shared_ptr<orc::SymbolStringPool> SSP;
Triple TT; Triple TT;
SubtargetFeatures Features; SubtargetFeatures Features;
unsigned PointerSize; unsigned PointerSize;
llvm::endianness Endianness; llvm::endianness Endianness;
GetEdgeKindNameFunction GetEdgeKindName = nullptr; GetEdgeKindNameFunction GetEdgeKindName = nullptr;
DenseMap<StringRef, std::unique_ptr<Section>> Sections; DenseMap<StringRef, std::unique_ptr<Section>> Sections;
// FIXME(jared): these should become dense maps
ExternalSymbolMap ExternalSymbols; ExternalSymbolMap ExternalSymbols;
AbsoluteSymbolSet AbsoluteSymbols; AbsoluteSymbolSet AbsoluteSymbols;
orc::shared::AllocActions AAs; orc::shared::AllocActions AAs;
@@ -1831,7 +1866,8 @@ enum class SymbolLookupFlags { RequiredSymbol, WeaklyReferencedSymbol };
raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LF); raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LF);
/// A map of symbol names to resolved addresses. /// A map of symbol names to resolved addresses.
using AsyncLookupResult = DenseMap<StringRef, orc::ExecutorSymbolDef>; using AsyncLookupResult =
DenseMap<orc::SymbolStringPtr, orc::ExecutorSymbolDef>;
/// A function object to call with a resolved symbol map (See AsyncLookupResult) /// A function object to call with a resolved symbol map (See AsyncLookupResult)
/// or an error if resolution failed. /// or an error if resolution failed.
@@ -1864,7 +1900,7 @@ createLookupContinuation(Continuation Cont) {
/// Holds context for a single jitLink invocation. /// Holds context for a single jitLink invocation.
class JITLinkContext { class JITLinkContext {
public: public:
using LookupMap = DenseMap<StringRef, SymbolLookupFlags>; using LookupMap = DenseMap<orc::SymbolStringPtr, SymbolLookupFlags>;
/// Create a JITLinkContext. /// Create a JITLinkContext.
JITLinkContext(const JITLinkDylib *JD) : JD(JD) {} JITLinkContext(const JITLinkDylib *JD) : JD(JD) {}
@@ -1997,11 +2033,14 @@ void visitExistingEdges(LinkGraph &G, VisitorTs &&...Vs) {
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromObject(MemoryBufferRef ObjectBuffer); createLinkGraphFromObject(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP);
/// Create a \c LinkGraph defining the given absolute symbols. /// Create a \c LinkGraph defining the given absolute symbols.
std::unique_ptr<LinkGraph> absoluteSymbolsLinkGraph(const Triple &TT, std::unique_ptr<LinkGraph>
orc::SymbolMap Symbols); absoluteSymbolsLinkGraph(const Triple &TT,
std::shared_ptr<orc::SymbolStringPool> SSP,
orc::SymbolMap Symbols);
/// Link the given graph. /// Link the given graph.
void link(std::unique_ptr<LinkGraph> G, std::unique_ptr<JITLinkContext> Ctx); void link(std::unique_ptr<LinkGraph> G, std::unique_ptr<JITLinkContext> Ctx);

14
llvm/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h
View File

@@ -19,6 +19,7 @@
#include "llvm/ExecutionEngine/Orc/Shared/AllocationActions.h" #include "llvm/ExecutionEngine/Orc/Shared/AllocationActions.h"
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h" #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
#include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h" #include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h"
#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
#include "llvm/Support/Allocator.h" #include "llvm/Support/Allocator.h"
#include "llvm/Support/Error.h" #include "llvm/Support/Error.h"
#include "llvm/Support/MSVCErrorWorkarounds.h" #include "llvm/Support/MSVCErrorWorkarounds.h"
@@ -320,12 +321,15 @@ public:
using OnFinalizedFunction = using OnFinalizedFunction =
JITLinkMemoryManager::InFlightAlloc::OnFinalizedFunction; JITLinkMemoryManager::InFlightAlloc::OnFinalizedFunction;
static void Create(JITLinkMemoryManager &MemMgr, const JITLinkDylib *JD, static void Create(JITLinkMemoryManager &MemMgr,
SegmentMap Segments, OnCreatedFunction OnCreated); std::shared_ptr<orc::SymbolStringPool> SSP,
const JITLinkDylib *JD, SegmentMap Segments,
OnCreatedFunction OnCreated);
static Expected<SimpleSegmentAlloc> Create(JITLinkMemoryManager &MemMgr, static Expected<SimpleSegmentAlloc>
const JITLinkDylib *JD, Create(JITLinkMemoryManager &MemMgr,
SegmentMap Segments); std::shared_ptr<orc::SymbolStringPool> SSP, const JITLinkDylib *JD,
SegmentMap Segments);
SimpleSegmentAlloc(SimpleSegmentAlloc &&); SimpleSegmentAlloc(SimpleSegmentAlloc &&);
SimpleSegmentAlloc &operator=(SimpleSegmentAlloc &&); SimpleSegmentAlloc &operator=(SimpleSegmentAlloc &&);

3
llvm/include/llvm/ExecutionEngine/JITLink/MachO.h
View File

@@ -25,7 +25,8 @@ namespace jitlink {
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer); createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given ObjBuffer, which must be a MachO object file. /// jit-link the given ObjBuffer, which must be a MachO object file.
/// ///

4
llvm/include/llvm/ExecutionEngine/JITLink/MachO_arm64.h
View File

@@ -23,8 +23,8 @@ namespace jitlink {
/// Note: The graph does not take ownership of the underlying buffer, nor copy /// Note: The graph does not take ownership of the underlying buffer, nor copy
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromMachOObject_arm64(
createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer); MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given object buffer, which must be a MachO arm64 object file. /// jit-link the given object buffer, which must be a MachO arm64 object file.
/// ///

4
llvm/include/llvm/ExecutionEngine/JITLink/MachO_x86_64.h
View File

@@ -23,8 +23,8 @@ namespace jitlink {
/// Note: The graph does not take ownership of the underlying buffer, nor copy /// Note: The graph does not take ownership of the underlying buffer, nor copy
/// its contents. The caller is responsible for ensuring that the object buffer /// its contents. The caller is responsible for ensuring that the object buffer
/// outlives the graph. /// outlives the graph.
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromMachOObject_x86_64(
createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer); MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
/// jit-link the given LinkGraph. /// jit-link the given LinkGraph.
/// ///

2
llvm/include/llvm/ExecutionEngine/JITLink/TableManager.h
View File

@@ -69,7 +69,7 @@ public:
private: private:
TableManagerImplT &impl() { return static_cast<TableManagerImplT &>(*this); } TableManagerImplT &impl() { return static_cast<TableManagerImplT &>(*this); }
DenseMap<StringRef, Symbol *> Entries; DenseMap<orc::SymbolStringPtr, Symbol *> Entries;
}; };
} // namespace jitlink } // namespace jitlink

2
llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h
View File

@@ -181,7 +181,7 @@ public:
ExecutorProcessControl(std::shared_ptr<SymbolStringPool> SSP, ExecutorProcessControl(std::shared_ptr<SymbolStringPool> SSP,
std::unique_ptr<TaskDispatcher> D) std::unique_ptr<TaskDispatcher> D)
: SSP(std::move(SSP)), D(std::move(D)) {} : SSP(std::move(SSP)), D(std::move(D)) {}
virtual ~ExecutorProcessControl(); virtual ~ExecutorProcessControl();

1
llvm/include/llvm/ExecutionEngine/RuntimeDyldChecker.h
View File

@@ -10,6 +10,7 @@
#define LLVM_EXECUTIONENGINE_RUNTIMEDYLDCHECKER_H #define LLVM_EXECUTIONENGINE_RUNTIMEDYLDCHECKER_H
#include "llvm/ExecutionEngine/JITSymbol.h" #include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
#include "llvm/Support/Endian.h" #include "llvm/Support/Endian.h"
#include "llvm/TargetParser/SubtargetFeature.h" #include "llvm/TargetParser/SubtargetFeature.h"
#include "llvm/TargetParser/Triple.h" #include "llvm/TargetParser/Triple.h"

5
llvm/lib/ExecutionEngine/JITLink/COFF.cpp
View File

@@ -40,7 +40,8 @@ static StringRef getMachineName(uint16_t Machine) {
} }
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer) { createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP) {
StringRef Data = ObjectBuffer.getBuffer(); StringRef Data = ObjectBuffer.getBuffer();
// Check magic // Check magic
@@ -108,7 +109,7 @@ createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer) {
switch (Machine) { switch (Machine) {
case COFF::IMAGE_FILE_MACHINE_AMD64: case COFF::IMAGE_FILE_MACHINE_AMD64:
return createLinkGraphFromCOFFObject_x86_64(ObjectBuffer); return createLinkGraphFromCOFFObject_x86_64(ObjectBuffer, std::move(SSP));
default: default:
return make_error<JITLinkError>( return make_error<JITLinkError>(
"Unsupported target machine architecture in COFF object " + "Unsupported target machine architecture in COFF object " +

79
llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp
View File

@@ -11,6 +11,8 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "COFFLinkGraphBuilder.h" #include "COFFLinkGraphBuilder.h"
#include <memory>
#define DEBUG_TYPE "jitlink" #define DEBUG_TYPE "jitlink"
static const char *CommonSectionName = "__common"; static const char *CommonSectionName = "__common";
@@ -24,12 +26,16 @@ static Triple createTripleWithCOFFFormat(Triple T) {
} }
COFFLinkGraphBuilder::COFFLinkGraphBuilder( COFFLinkGraphBuilder::COFFLinkGraphBuilder(
const object::COFFObjectFile &Obj, Triple TT, SubtargetFeatures Features, const object::COFFObjectFile &Obj,
std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
SubtargetFeatures Features,
LinkGraph::GetEdgeKindNameFunction GetEdgeKindName) LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
: Obj(Obj), G(std::make_unique<LinkGraph>( : Obj(Obj),
Obj.getFileName().str(), createTripleWithCOFFFormat(TT), G(std::make_unique<LinkGraph>(Obj.getFileName().str(), std::move(SSP),
std::move(Features), getPointerSize(Obj), createTripleWithCOFFFormat(TT),
getEndianness(Obj), std::move(GetEdgeKindName))) { std::move(Features), getPointerSize(Obj),
getEndianness(Obj),
std::move(GetEdgeKindName))) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << "Created COFFLinkGraphBuilder for \"" << Obj.getFileName() dbgs() << "Created COFFLinkGraphBuilder for \"" << Obj.getFileName()
<< "\"\n"; << "\"\n";
@@ -226,18 +232,19 @@ Error COFFLinkGraphBuilder::graphifySymbols() {
" (" + toString(SecOrErr.takeError()) + ")"); " (" + toString(SecOrErr.takeError()) + ")");
Sec = *SecOrErr; Sec = *SecOrErr;
} }
auto InternedSymbolName = G->intern(std::move(SymbolName));
// Create jitlink symbol // Create jitlink symbol
jitlink::Symbol *GSym = nullptr; jitlink::Symbol *GSym = nullptr;
if (Sym->isFileRecord()) if (Sym->isFileRecord())
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << " " << SymIndex << ": Skipping FileRecord symbol \"" dbgs() << " " << SymIndex << ": Skipping FileRecord symbol \""
<< SymbolName << "\" in " << InternedSymbolName << "\" in "
<< getCOFFSectionName(SectionIndex, Sec, *Sym) << getCOFFSectionName(SectionIndex, Sec, *Sym)
<< " (index: " << SectionIndex << ") \n"; << " (index: " << SectionIndex << ") \n";
}); });
else if (Sym->isUndefined()) { else if (Sym->isUndefined()) {
GSym = createExternalSymbol(SymIndex, SymbolName, *Sym, Sec); GSym = createExternalSymbol(SymIndex, InternedSymbolName, *Sym, Sec);
} else if (Sym->isWeakExternal()) { } else if (Sym->isWeakExternal()) {
auto *WeakExternal = Sym->getAux<object::coff_aux_weak_external>(); auto *WeakExternal = Sym->getAux<object::coff_aux_weak_external>();
COFFSymbolIndex TagIndex = WeakExternal->TagIndex; COFFSymbolIndex TagIndex = WeakExternal->TagIndex;
@@ -246,7 +253,7 @@ Error COFFLinkGraphBuilder::graphifySymbols() {
{SymIndex, TagIndex, Characteristics, SymbolName}); {SymIndex, TagIndex, Characteristics, SymbolName});
} else { } else {
Expected<jitlink::Symbol *> NewGSym = Expected<jitlink::Symbol *> NewGSym =
createDefinedSymbol(SymIndex, SymbolName, *Sym, Sec); createDefinedSymbol(SymIndex, InternedSymbolName, *Sym, Sec);
if (!NewGSym) if (!NewGSym)
return NewGSym.takeError(); return NewGSym.takeError();
GSym = *NewGSym; GSym = *NewGSym;
@@ -254,7 +261,7 @@ Error COFFLinkGraphBuilder::graphifySymbols() {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << " " << SymIndex dbgs() << " " << SymIndex
<< ": Creating defined graph symbol for COFF symbol \"" << ": Creating defined graph symbol for COFF symbol \""
<< SymbolName << "\" in " << InternedSymbolName << "\" in "
<< getCOFFSectionName(SectionIndex, Sec, *Sym) << getCOFFSectionName(SectionIndex, Sec, *Sym)
<< " (index: " << SectionIndex << ") \n"; << " (index: " << SectionIndex << ") \n";
dbgs() << " " << *GSym << "\n"; dbgs() << " " << *GSym << "\n";
@@ -293,14 +300,13 @@ Error COFFLinkGraphBuilder::handleDirectiveSection(StringRef Str) {
if (From.empty() || To.empty()) if (From.empty() || To.empty())
return make_error<JITLinkError>( return make_error<JITLinkError>(
"Invalid COFF /alternatename directive"); "Invalid COFF /alternatename directive");
AlternateNames[From] = To; AlternateNames[G->intern(From)] = G->intern(To);
break; break;
} }
case COFF_OPT_incl: { case COFF_OPT_incl: {
auto DataCopy = G->allocateContent(S); auto Symbol = &G->addExternalSymbol(S, 0, false);
StringRef StrCopy(DataCopy.data(), DataCopy.size()); Symbol->setLive(true);
ExternalSymbols[StrCopy] = &G->addExternalSymbol(StrCopy, 0, false); ExternalSymbols[Symbol->getName()] = Symbol;
ExternalSymbols[StrCopy]->setLive(true);
break; break;
} }
case COFF_OPT_export: case COFF_OPT_export:
@@ -332,8 +338,8 @@ Error COFFLinkGraphBuilder::flushWeakAliasRequests() {
? Scope::Default ? Scope::Default
: Scope::Local; : Scope::Local;
auto NewSymbol = auto NewSymbol = createAliasSymbol(G->intern(WeakExternal.SymbolName),
createAliasSymbol(WeakExternal.SymbolName, Linkage::Weak, S, *Target); Linkage::Weak, S, *Target);
if (!NewSymbol) if (!NewSymbol)
return NewSymbol.takeError(); return NewSymbol.takeError();
setGraphSymbol(AliasSymbol->getSectionNumber(), WeakExternal.Alias, setGraphSymbol(AliasSymbol->getSectionNumber(), WeakExternal.Alias,
@@ -354,37 +360,44 @@ Error COFFLinkGraphBuilder::flushWeakAliasRequests() {
} }
Error COFFLinkGraphBuilder::handleAlternateNames() { Error COFFLinkGraphBuilder::handleAlternateNames() {
for (auto &KeyValue : AlternateNames) for (auto &KeyValue : AlternateNames) {
if (DefinedSymbols.count(KeyValue.second) && auto DefinedSymbolName = KeyValue.second;
ExternalSymbols.count(KeyValue.first)) { auto ExternalSymbolsName = KeyValue.first;
auto *Target = DefinedSymbols[KeyValue.second]; if (DefinedSymbols.count(DefinedSymbolName) &&
auto *Alias = ExternalSymbols[KeyValue.first]; ExternalSymbols.count(ExternalSymbolsName)) {
auto *Target = DefinedSymbols[DefinedSymbolName];
auto *Alias = ExternalSymbols[ExternalSymbolsName];
G->makeDefined(*Alias, Target->getBlock(), Target->getOffset(), G->makeDefined(*Alias, Target->getBlock(), Target->getOffset(),
Target->getSize(), Linkage::Weak, Scope::Local, false); Target->getSize(), Linkage::Weak, Scope::Local, false);
} }
}
return Error::success(); return Error::success();
} }
Symbol *COFFLinkGraphBuilder::createExternalSymbol( Symbol *COFFLinkGraphBuilder::createExternalSymbol(
COFFSymbolIndex SymIndex, StringRef SymbolName, COFFSymbolIndex SymIndex, orc::SymbolStringPtr SymbolName,
object::COFFSymbolRef Symbol, const object::coff_section *Section) { object::COFFSymbolRef Symbol, const object::coff_section *Section) {
if (!ExternalSymbols.count(SymbolName)) llvm::jitlink::Symbol *Sym = nullptr;
ExternalSymbols[SymbolName] = if (!ExternalSymbols.count(SymbolName)) {
&G->addExternalSymbol(SymbolName, Symbol.getValue(), false); Sym = &G->addExternalSymbol(*SymbolName, Symbol.getValue(), false);
ExternalSymbols[Sym->getName()] = Sym;
} else {
Sym = ExternalSymbols[SymbolName];
}
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << " " << SymIndex dbgs() << " " << SymIndex
<< ": Creating external graph symbol for COFF symbol \"" << ": Creating external graph symbol for COFF symbol \""
<< SymbolName << "\" in " << Sym->getName() << "\" in "
<< getCOFFSectionName(Symbol.getSectionNumber(), Section, Symbol) << getCOFFSectionName(Symbol.getSectionNumber(), Section, Symbol)
<< " (index: " << Symbol.getSectionNumber() << ") \n"; << " (index: " << Symbol.getSectionNumber() << ") \n";
}); });
return ExternalSymbols[SymbolName]; return Sym;
} }
Expected<Symbol *> COFFLinkGraphBuilder::createAliasSymbol(StringRef SymbolName, Expected<Symbol *>
Linkage L, Scope S, COFFLinkGraphBuilder::createAliasSymbol(orc::SymbolStringPtr SymbolName,
Symbol &Target) { Linkage L, Scope S, Symbol &Target) {
if (!Target.isDefined()) { if (!Target.isDefined()) {
// FIXME: Support this when there's a way to handle this. // FIXME: Support this when there's a way to handle this.
return make_error<JITLinkError>("Weak external symbol with external " return make_error<JITLinkError>("Weak external symbol with external "
@@ -460,8 +473,9 @@ Error COFFLinkGraphBuilder::calculateImplicitSizeOfSymbols() {
} }
Expected<Symbol *> COFFLinkGraphBuilder::createDefinedSymbol( Expected<Symbol *> COFFLinkGraphBuilder::createDefinedSymbol(
COFFSymbolIndex SymIndex, StringRef SymbolName, COFFSymbolIndex SymIndex, orc::SymbolStringPtr SymbolName,
object::COFFSymbolRef Symbol, const object::coff_section *Section) { object::COFFSymbolRef Symbol, const object::coff_section *Section) {
if (Symbol.isCommon()) { if (Symbol.isCommon()) {
// FIXME: correct alignment // FIXME: correct alignment
return &G->addDefinedSymbol( return &G->addDefinedSymbol(
@@ -470,6 +484,7 @@ Expected<Symbol *> COFFLinkGraphBuilder::createDefinedSymbol(
0, SymbolName, Symbol.getValue(), Linkage::Weak, Scope::Default, 0, SymbolName, Symbol.getValue(), Linkage::Weak, Scope::Default,
false, false); false, false);
} }
if (Symbol.isAbsolute()) if (Symbol.isAbsolute())
return &G->addAbsoluteSymbol(SymbolName, return &G->addAbsoluteSymbol(SymbolName,
orc::ExecutorAddr(Symbol.getValue()), 0, orc::ExecutorAddr(Symbol.getValue()), 0,
@@ -603,7 +618,7 @@ Expected<Symbol *> COFFLinkGraphBuilder::createCOMDATExportRequest(
// Process the second symbol of COMDAT sequence. // Process the second symbol of COMDAT sequence.
Expected<Symbol *> Expected<Symbol *>
COFFLinkGraphBuilder::exportCOMDATSymbol(COFFSymbolIndex SymIndex, COFFLinkGraphBuilder::exportCOMDATSymbol(COFFSymbolIndex SymIndex,
StringRef SymbolName, orc::SymbolStringPtr SymbolName,
object::COFFSymbolRef Symbol) { object::COFFSymbolRef Symbol) {
Block *B = getGraphBlock(Symbol.getSectionNumber()); Block *B = getGraphBlock(Symbol.getSectionNumber());
auto &PendingComdatExport = PendingComdatExports[Symbol.getSectionNumber()]; auto &PendingComdatExport = PendingComdatExports[Symbol.getSectionNumber()];

20
llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h
View File

@@ -37,7 +37,8 @@ protected:
using COFFSectionIndex = int32_t; using COFFSectionIndex = int32_t;
using COFFSymbolIndex = int32_t; using COFFSymbolIndex = int32_t;
COFFLinkGraphBuilder(const object::COFFObjectFile &Obj, Triple TT, COFFLinkGraphBuilder(const object::COFFObjectFile &Obj,
std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
SubtargetFeatures Features, SubtargetFeatures Features,
LinkGraph::GetEdgeKindNameFunction GetEdgeKindName); LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
@@ -134,20 +135,21 @@ private:
Section &getCommonSection(); Section &getCommonSection();
Symbol *createExternalSymbol(COFFSymbolIndex SymIndex, StringRef SymbolName, Symbol *createExternalSymbol(COFFSymbolIndex SymIndex,
orc::SymbolStringPtr SymbolName,
object::COFFSymbolRef Symbol, object::COFFSymbolRef Symbol,
const object::coff_section *Section); const object::coff_section *Section);
Expected<Symbol *> createAliasSymbol(StringRef SymbolName, Linkage L, Scope S, Expected<Symbol *> createAliasSymbol(orc::SymbolStringPtr SymbolName,
Symbol &Target); Linkage L, Scope S, Symbol &Target);
Expected<Symbol *> createDefinedSymbol(COFFSymbolIndex SymIndex, Expected<Symbol *> createDefinedSymbol(COFFSymbolIndex SymIndex,
StringRef SymbolName, orc::SymbolStringPtr SymbolName,
object::COFFSymbolRef Symbol, object::COFFSymbolRef Symbol,
const object::coff_section *Section); const object::coff_section *Section);
Expected<Symbol *> createCOMDATExportRequest( Expected<Symbol *> createCOMDATExportRequest(
COFFSymbolIndex SymIndex, object::COFFSymbolRef Symbol, COFFSymbolIndex SymIndex, object::COFFSymbolRef Symbol,
const object::coff_aux_section_definition *Definition); const object::coff_aux_section_definition *Definition);
Expected<Symbol *> exportCOMDATSymbol(COFFSymbolIndex SymIndex, Expected<Symbol *> exportCOMDATSymbol(COFFSymbolIndex SymIndex,
StringRef SymbolName, orc::SymbolStringPtr SymbolName,
object::COFFSymbolRef Symbol); object::COFFSymbolRef Symbol);
Error handleDirectiveSection(StringRef Str); Error handleDirectiveSection(StringRef Str);
@@ -176,9 +178,9 @@ private:
std::vector<Block *> GraphBlocks; std::vector<Block *> GraphBlocks;
std::vector<Symbol *> GraphSymbols; std::vector<Symbol *> GraphSymbols;
DenseMap<StringRef, StringRef> AlternateNames; DenseMap<orc::SymbolStringPtr, orc::SymbolStringPtr> AlternateNames;
DenseMap<StringRef, Symbol *> ExternalSymbols; DenseMap<orc::SymbolStringPtr, Symbol *> ExternalSymbols;
DenseMap<StringRef, Symbol *> DefinedSymbols; DenseMap<orc::SymbolStringPtr, Symbol *> DefinedSymbols;
}; };
template <typename RelocHandlerFunction> template <typename RelocHandlerFunction>

29
llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp
View File

@@ -148,6 +148,7 @@ private:
SectionIdx = getObject().getNumberOfSections() + 1; SectionIdx = getObject().getNumberOfSections() + 1;
else else
SectionIdx = COFFSymbol.getSectionNumber(); SectionIdx = COFFSymbol.getSectionNumber();
auto *AbsSym = &getGraph().addAbsoluteSymbol( auto *AbsSym = &getGraph().addAbsoluteSymbol(
"secidx", orc::ExecutorAddr(SectionIdx), 2, Linkage::Strong, "secidx", orc::ExecutorAddr(SectionIdx), 2, Linkage::Strong,
Scope::Local, false); Scope::Local, false);
@@ -181,14 +182,20 @@ private:
} }
public: public:
COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, const Triple T, COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj,
const SubtargetFeatures Features) std::shared_ptr<orc::SymbolStringPool> SSP,
: COFFLinkGraphBuilder(Obj, std::move(T), std::move(Features), const Triple T, const SubtargetFeatures Features)
: COFFLinkGraphBuilder(Obj, std::move(SSP), std::move(T),
std::move(Features),
getCOFFX86RelocationKindName) {} getCOFFX86RelocationKindName) {}
}; };
class COFFLinkGraphLowering_x86_64 { class COFFLinkGraphLowering_x86_64 {
public: public:
COFFLinkGraphLowering_x86_64(std::shared_ptr<orc::SymbolStringPool> SSP)
: SSP(std::move(SSP)) {
ImageBaseName = this->SSP->intern("__ImageBase");
}
// Lowers COFF x86_64 specific edges to generic x86_64 edges. // Lowers COFF x86_64 specific edges to generic x86_64 edges.
Error lowerCOFFRelocationEdges(LinkGraph &G, JITLinkContext &Ctx) { Error lowerCOFFRelocationEdges(LinkGraph &G, JITLinkContext &Ctx) {
for (auto *B : G.blocks()) { for (auto *B : G.blocks()) {
@@ -230,7 +237,9 @@ public:
} }
private: private:
static StringRef getImageBaseSymbolName() { return "__ImageBase"; } const orc::SymbolStringPtr &getImageBaseSymbolName() const {
return this->ImageBaseName;
}
orc::ExecutorAddr getSectionStart(Section &Sec) { orc::ExecutorAddr getSectionStart(Section &Sec) {
if (!SectionStartCache.count(&Sec)) { if (!SectionStartCache.count(&Sec)) {
@@ -271,12 +280,13 @@ private:
DenseMap<Section *, orc::ExecutorAddr> SectionStartCache; DenseMap<Section *, orc::ExecutorAddr> SectionStartCache;
orc::ExecutorAddr ImageBase; orc::ExecutorAddr ImageBase;
std::shared_ptr<orc::SymbolStringPool> SSP;
orc::SymbolStringPtr ImageBaseName = nullptr;
}; };
Error lowerEdges_COFF_x86_64(LinkGraph &G, JITLinkContext *Ctx) { Error lowerEdges_COFF_x86_64(LinkGraph &G, JITLinkContext *Ctx) {
LLVM_DEBUG(dbgs() << "Lowering COFF x86_64 edges:\n"); LLVM_DEBUG(dbgs() << "Lowering COFF x86_64 edges:\n");
COFFLinkGraphLowering_x86_64 GraphLowering; COFFLinkGraphLowering_x86_64 GraphLowering(G.getSymbolStringPool());
if (auto Err = GraphLowering.lowerCOFFRelocationEdges(G, *Ctx)) if (auto Err = GraphLowering.lowerCOFFRelocationEdges(G, *Ctx))
return Err; return Err;
@@ -305,8 +315,8 @@ const char *getCOFFX86RelocationKindName(Edge::Kind R) {
} }
} }
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromCOFFObject_x86_64(
createLinkGraphFromCOFFObject_x86_64(MemoryBufferRef ObjectBuffer) { MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << "Building jitlink graph for new input " dbgs() << "Building jitlink graph for new input "
<< ObjectBuffer.getBufferIdentifier() << "...\n"; << ObjectBuffer.getBufferIdentifier() << "...\n";
@@ -320,7 +330,8 @@ createLinkGraphFromCOFFObject_x86_64(MemoryBufferRef ObjectBuffer) {
if (!Features) if (!Features)
return Features.takeError(); return Features.takeError();
return COFFLinkGraphBuilder_x86_64(**COFFObj, (*COFFObj)->makeTriple(), return COFFLinkGraphBuilder_x86_64(**COFFObj, std::move(SSP),
(*COFFObj)->makeTriple(),
std::move(*Features)) std::move(*Features))
.buildGraph(); .buildGraph();
} }

18
llvm/lib/ExecutionEngine/JITLink/DefineExternalSectionStartAndEndSymbols.h
View File

@@ -112,13 +112,13 @@ identifyELFSectionStartAndEndSymbols(LinkGraph &G, Symbol &Sym) {
constexpr StringRef EndSymbolPrefix = "__stop_"; constexpr StringRef EndSymbolPrefix = "__stop_";
auto SymName = Sym.getName(); auto SymName = Sym.getName();
if (SymName.starts_with(StartSymbolPrefix)) { if ((*SymName).starts_with(StartSymbolPrefix)) {
if (auto *Sec = if (auto *Sec = G.findSectionByName(
G.findSectionByName(SymName.drop_front(StartSymbolPrefix.size()))) (*SymName).drop_front(StartSymbolPrefix.size())))
return {*Sec, true}; return {*Sec, true};
} else if (SymName.starts_with(EndSymbolPrefix)) { } else if ((*SymName).starts_with(EndSymbolPrefix)) {
if (auto *Sec = if (auto *Sec =
G.findSectionByName(SymName.drop_front(EndSymbolPrefix.size()))) G.findSectionByName((*SymName).drop_front(EndSymbolPrefix.size())))
return {*Sec, false}; return {*Sec, false};
} }
return {}; return {};
@@ -131,15 +131,15 @@ identifyMachOSectionStartAndEndSymbols(LinkGraph &G, Symbol &Sym) {
constexpr StringRef EndSymbolPrefix = "section$end$"; constexpr StringRef EndSymbolPrefix = "section$end$";
auto SymName = Sym.getName(); auto SymName = Sym.getName();
if (SymName.starts_with(StartSymbolPrefix)) { if ((*SymName).starts_with(StartSymbolPrefix)) {
auto [SegName, SecName] = auto [SegName, SecName] =
SymName.drop_front(StartSymbolPrefix.size()).split('$'); (*SymName).drop_front(StartSymbolPrefix.size()).split('$');
std::string SectionName = (SegName + "," + SecName).str(); std::string SectionName = (SegName + "," + SecName).str();
if (auto *Sec = G.findSectionByName(SectionName)) if (auto *Sec = G.findSectionByName(SectionName))
return {*Sec, true}; return {*Sec, true};
} else if (SymName.starts_with(EndSymbolPrefix)) { } else if ((*SymName).starts_with(EndSymbolPrefix)) {
auto [SegName, SecName] = auto [SegName, SecName] =
SymName.drop_front(EndSymbolPrefix.size()).split('$'); (*SymName).drop_front(EndSymbolPrefix.size()).split('$');
std::string SectionName = (SegName + "," + SecName).str(); std::string SectionName = (SegName + "," + SecName).str();
if (auto *Sec = G.findSectionByName(SectionName)) if (auto *Sec = G.findSectionByName(SectionName))
return {*Sec, false}; return {*Sec, false};

21
llvm/lib/ExecutionEngine/JITLink/ELF.cpp
View File

@@ -69,7 +69,8 @@ Expected<uint16_t> readTargetMachineArch(StringRef Buffer) {
} }
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer) { createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP) {
StringRef Buffer = ObjectBuffer.getBuffer(); StringRef Buffer = ObjectBuffer.getBuffer();
if (Buffer.size() < ELF::EI_NIDENT) if (Buffer.size() < ELF::EI_NIDENT)
return make_error<JITLinkError>("Truncated ELF buffer"); return make_error<JITLinkError>("Truncated ELF buffer");
@@ -84,23 +85,23 @@ createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer) {
switch (*TargetMachineArch) { switch (*TargetMachineArch) {
case ELF::EM_AARCH64: case ELF::EM_AARCH64:
return createLinkGraphFromELFObject_aarch64(ObjectBuffer); return createLinkGraphFromELFObject_aarch64(ObjectBuffer, std::move(SSP));
case ELF::EM_ARM: case ELF::EM_ARM:
return createLinkGraphFromELFObject_aarch32(ObjectBuffer); return createLinkGraphFromELFObject_aarch32(ObjectBuffer, std::move(SSP));
case ELF::EM_LOONGARCH:
return createLinkGraphFromELFObject_loongarch(ObjectBuffer);
case ELF::EM_PPC64: { case ELF::EM_PPC64: {
if (DataEncoding == ELF::ELFDATA2LSB) if (DataEncoding == ELF::ELFDATA2LSB)
return createLinkGraphFromELFObject_ppc64le(ObjectBuffer); return createLinkGraphFromELFObject_ppc64le(ObjectBuffer, std::move(SSP));
else else
return createLinkGraphFromELFObject_ppc64(ObjectBuffer); return createLinkGraphFromELFObject_ppc64(ObjectBuffer, std::move(SSP));
} }
case ELF::EM_LOONGARCH:
return createLinkGraphFromELFObject_loongarch(ObjectBuffer, std::move(SSP));
case ELF::EM_RISCV: case ELF::EM_RISCV:
return createLinkGraphFromELFObject_riscv(ObjectBuffer); return createLinkGraphFromELFObject_riscv(ObjectBuffer, std::move(SSP));
case ELF::EM_X86_64: case ELF::EM_X86_64:
return createLinkGraphFromELFObject_x86_64(ObjectBuffer); return createLinkGraphFromELFObject_x86_64(ObjectBuffer, std::move(SSP));
case ELF::EM_386: case ELF::EM_386:
return createLinkGraphFromELFObject_i386(ObjectBuffer); return createLinkGraphFromELFObject_i386(ObjectBuffer, std::move(SSP));
default: default:
return make_error<JITLinkError>( return make_error<JITLinkError>(
"Unsupported target machine architecture in ELF object " + "Unsupported target machine architecture in ELF object " +

14
llvm/lib/ExecutionEngine/JITLink/ELFLinkGraphBuilder.h
View File

@@ -58,7 +58,8 @@ class ELFLinkGraphBuilder : public ELFLinkGraphBuilderBase {
using ELFFile = object::ELFFile<ELFT>; using ELFFile = object::ELFFile<ELFT>;
public: public:
ELFLinkGraphBuilder(const object::ELFFile<ELFT> &Obj, Triple TT, ELFLinkGraphBuilder(const object::ELFFile<ELFT> &Obj,
std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
SubtargetFeatures Features, StringRef FileName, SubtargetFeatures Features, StringRef FileName,
LinkGraph::GetEdgeKindNameFunction GetEdgeKindName); LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
@@ -189,12 +190,13 @@ protected:
template <typename ELFT> template <typename ELFT>
ELFLinkGraphBuilder<ELFT>::ELFLinkGraphBuilder( ELFLinkGraphBuilder<ELFT>::ELFLinkGraphBuilder(
const ELFFile &Obj, Triple TT, SubtargetFeatures Features, const ELFFile &Obj, std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
StringRef FileName, LinkGraph::GetEdgeKindNameFunction GetEdgeKindName) SubtargetFeatures Features, StringRef FileName,
LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
: ELFLinkGraphBuilderBase(std::make_unique<LinkGraph>( : ELFLinkGraphBuilderBase(std::make_unique<LinkGraph>(
FileName.str(), Triple(std::move(TT)), std::move(Features), FileName.str(), std::move(SSP), Triple(std::move(TT)),
ELFT::Is64Bits ? 8 : 4, llvm::endianness(ELFT::Endianness), std::move(Features), ELFT::Is64Bits ? 8 : 4,
std::move(GetEdgeKindName))), llvm::endianness(ELFT::Endianness), std::move(GetEdgeKindName))),
Obj(Obj) { Obj(Obj) {
LLVM_DEBUG( LLVM_DEBUG(
{ dbgs() << "Created ELFLinkGraphBuilder for \"" << FileName << "\""; }); { dbgs() << "Created ELFLinkGraphBuilder for \"" << FileName << "\""; });

22
llvm/lib/ExecutionEngine/JITLink/ELF_aarch32.cpp
View File

@@ -219,11 +219,13 @@ protected:
public: public:
ELFLinkGraphBuilder_aarch32(StringRef FileName, ELFLinkGraphBuilder_aarch32(StringRef FileName,
const llvm::object::ELFFile<ELFT> &Obj, Triple TT, const llvm::object::ELFFile<ELFT> &Obj,
SubtargetFeatures Features, std::shared_ptr<orc::SymbolStringPool> SSP,
Triple TT, SubtargetFeatures Features,
aarch32::ArmConfig ArmCfg) aarch32::ArmConfig ArmCfg)
: ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features), : ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT),
FileName, getELFAArch32EdgeKindName), std::move(Features), FileName,
getELFAArch32EdgeKindName),
ArmCfg(std::move(ArmCfg)) {} ArmCfg(std::move(ArmCfg)) {}
}; };
@@ -239,8 +241,8 @@ Error buildTables_ELF_aarch32(LinkGraph &G) {
return Error::success(); return Error::success();
} }
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_aarch32(
createLinkGraphFromELFObject_aarch32(MemoryBufferRef ObjectBuffer) { MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << "Building jitlink graph for new input " dbgs() << "Building jitlink graph for new input "
<< ObjectBuffer.getBufferIdentifier() << "...\n"; << ObjectBuffer.getBufferIdentifier() << "...\n";
@@ -273,16 +275,16 @@ createLinkGraphFromELFObject_aarch32(MemoryBufferRef ObjectBuffer) {
case Triple::thumb: { case Triple::thumb: {
auto &ELFFile = cast<ELFObjectFile<ELF32LE>>(**ELFObj).getELFFile(); auto &ELFFile = cast<ELFObjectFile<ELF32LE>>(**ELFObj).getELFFile();
return ELFLinkGraphBuilder_aarch32<llvm::endianness::little>( return ELFLinkGraphBuilder_aarch32<llvm::endianness::little>(
(*ELFObj)->getFileName(), ELFFile, TT, std::move(*Features), (*ELFObj)->getFileName(), ELFFile, std::move(SSP), TT,
ArmCfg) std::move(*Features), ArmCfg)
.buildGraph(); .buildGraph();
} }
case Triple::armeb: case Triple::armeb:
case Triple::thumbeb: { case Triple::thumbeb: {
auto &ELFFile = cast<ELFObjectFile<ELF32BE>>(**ELFObj).getELFFile(); auto &ELFFile = cast<ELFObjectFile<ELF32BE>>(**ELFObj).getELFFile();
return ELFLinkGraphBuilder_aarch32<llvm::endianness::big>( return ELFLinkGraphBuilder_aarch32<llvm::endianness::big>(
(*ELFObj)->getFileName(), ELFFile, TT, std::move(*Features), (*ELFObj)->getFileName(), ELFFile, std::move(SSP), TT,
ArmCfg) std::move(*Features), ArmCfg)
.buildGraph(); .buildGraph();
} }
default: default:

31
llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp
View File

@@ -52,10 +52,13 @@ private:
} }
Error getOrCreateGOTSymbol(LinkGraph &G) { Error getOrCreateGOTSymbol(LinkGraph &G) {
auto InteredGOTSymbolName =
G.getSymbolStringPool()->intern(ELFGOTSymbolName);
auto DefineExternalGOTSymbolIfPresent = auto DefineExternalGOTSymbolIfPresent =
createDefineExternalSectionStartAndEndSymbolsPass( createDefineExternalSectionStartAndEndSymbolsPass(
[&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc { [&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc {
if (Sym.getName() == ELFGOTSymbolName) if (*Sym.getName() == ELFGOTSymbolName)
if (auto *GOTSection = G.findSectionByName( if (auto *GOTSection = G.findSectionByName(
aarch64::GOTTableManager::getSectionName())) { aarch64::GOTTableManager::getSectionName())) {
GOTSymbol = &Sym; GOTSymbol = &Sym;
@@ -81,7 +84,7 @@ private:
// Check for an existing defined symbol. // Check for an existing defined symbol.
for (auto *Sym : GOTSection->symbols()) for (auto *Sym : GOTSection->symbols())
if (Sym->getName() == ELFGOTSymbolName) { if (Sym->getName() == InteredGOTSymbolName) {
GOTSymbol = Sym; GOTSymbol = Sym;
return Error::success(); return Error::success();
} }
@@ -90,11 +93,12 @@ private:
SectionRange SR(*GOTSection); SectionRange SR(*GOTSection);
if (SR.empty()) if (SR.empty())
GOTSymbol = GOTSymbol =
&G.addAbsoluteSymbol(ELFGOTSymbolName, orc::ExecutorAddr(), 0, // FIXME: we should only do this once
&G.addAbsoluteSymbol(InteredGOTSymbolName, orc::ExecutorAddr(), 0,
Linkage::Strong, Scope::Local, true); Linkage::Strong, Scope::Local, true);
else else
GOTSymbol = GOTSymbol =
&G.addDefinedSymbol(*SR.getFirstBlock(), 0, ELFGOTSymbolName, 0, &G.addDefinedSymbol(*SR.getFirstBlock(), 0, InteredGOTSymbolName, 0,
Linkage::Strong, Scope::Local, false, true); Linkage::Strong, Scope::Local, false, true);
} }
@@ -103,7 +107,7 @@ private:
// we just need to point the GOT symbol at some address in this graph. // we just need to point the GOT symbol at some address in this graph.
if (!GOTSymbol) { if (!GOTSymbol) {
for (auto *Sym : G.external_symbols()) { for (auto *Sym : G.external_symbols()) {
if (Sym->getName() == ELFGOTSymbolName) { if (*Sym->getName() == ELFGOTSymbolName) {
auto Blocks = G.blocks(); auto Blocks = G.blocks();
if (!Blocks.empty()) { if (!Blocks.empty()) {
G.makeAbsolute(*Sym, (*Blocks.begin())->getAddress()); G.makeAbsolute(*Sym, (*Blocks.begin())->getAddress());
@@ -525,10 +529,13 @@ private:
public: public:
ELFLinkGraphBuilder_aarch64(StringRef FileName, ELFLinkGraphBuilder_aarch64(StringRef FileName,
const object::ELFFile<ELFT> &Obj, Triple TT, const object::ELFFile<ELFT> &Obj,
SubtargetFeatures Features) std::shared_ptr<orc::SymbolStringPool> SSP,
: ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features), Triple TT, SubtargetFeatures Features)
FileName, aarch64::getEdgeKindName) {}
: ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT),
std::move(Features), FileName,
aarch64::getEdgeKindName) {}
}; };
// TLS Info Builder. // TLS Info Builder.
@@ -665,8 +672,8 @@ Error buildTables_ELF_aarch64(LinkGraph &G) {
namespace llvm { namespace llvm {
namespace jitlink { namespace jitlink {
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_aarch64(
createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer) { MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << "Building jitlink graph for new input " dbgs() << "Building jitlink graph for new input "
<< ObjectBuffer.getBufferIdentifier() << "...\n"; << ObjectBuffer.getBufferIdentifier() << "...\n";
@@ -685,7 +692,7 @@ createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer) {
auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj); auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
return ELFLinkGraphBuilder_aarch64<object::ELF64LE>( return ELFLinkGraphBuilder_aarch64<object::ELF64LE>(
(*ELFObj)->getFileName(), ELFObjFile.getELFFile(), (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), std::move(SSP),
(*ELFObj)->makeTriple(), std::move(*Features)) (*ELFObj)->makeTriple(), std::move(*Features))
.buildGraph(); .buildGraph();
} }

17
llvm/lib/ExecutionEngine/JITLink/ELF_i386.cpp
View File

@@ -56,7 +56,8 @@ private:
auto DefineExternalGOTSymbolIfPresent = auto DefineExternalGOTSymbolIfPresent =
createDefineExternalSectionStartAndEndSymbolsPass( createDefineExternalSectionStartAndEndSymbolsPass(
[&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc { [&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc {
if (Sym.getName() == ELFGOTSymbolName) if (Sym.getName() != nullptr &&
*Sym.getName() == ELFGOTSymbolName)
if (auto *GOTSection = G.findSectionByName( if (auto *GOTSection = G.findSectionByName(
i386::GOTTableManager::getSectionName())) { i386::GOTTableManager::getSectionName())) {
GOTSymbol = &Sym; GOTSymbol = &Sym;
@@ -82,7 +83,7 @@ private:
// Check for an existing defined symbol. // Check for an existing defined symbol.
for (auto *Sym : GOTSection->symbols()) for (auto *Sym : GOTSection->symbols())
if (Sym->getName() == ELFGOTSymbolName) { if (Sym->getName() != nullptr && *Sym->getName() == ELFGOTSymbolName) {
GOTSymbol = Sym; GOTSymbol = Sym;
return Error::success(); return Error::success();
} }
@@ -224,13 +225,16 @@ private:
public: public:
ELFLinkGraphBuilder_i386(StringRef FileName, const object::ELFFile<ELFT> &Obj, ELFLinkGraphBuilder_i386(StringRef FileName, const object::ELFFile<ELFT> &Obj,
std::shared_ptr<orc::SymbolStringPool> SSP,
Triple TT, SubtargetFeatures Features) Triple TT, SubtargetFeatures Features)
: ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features), : ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT),
FileName, i386::getEdgeKindName) {} std::move(Features), FileName,
i386::getEdgeKindName) {}
}; };
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer) { createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << "Building jitlink graph for new input " dbgs() << "Building jitlink graph for new input "
<< ObjectBuffer.getBufferIdentifier() << "...\n"; << ObjectBuffer.getBufferIdentifier() << "...\n";
@@ -248,8 +252,9 @@ createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer) {
"Only i386 (little endian) is supported for now"); "Only i386 (little endian) is supported for now");
auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj); auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
return ELFLinkGraphBuilder_i386<object::ELF32LE>( return ELFLinkGraphBuilder_i386<object::ELF32LE>(
(*ELFObj)->getFileName(), ELFObjFile.getELFFile(), (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), std::move(SSP),
(*ELFObj)->makeTriple(), std::move(*Features)) (*ELFObj)->makeTriple(), std::move(*Features))
.buildGraph(); .buildGraph();
} }

18
llvm/lib/ExecutionEngine/JITLink/ELF_loongarch.cpp
View File

@@ -131,10 +131,12 @@ private:
public: public:
ELFLinkGraphBuilder_loongarch(StringRef FileName, ELFLinkGraphBuilder_loongarch(StringRef FileName,
const object::ELFFile<ELFT> &Obj, Triple TT, const object::ELFFile<ELFT> &Obj,
SubtargetFeatures Features) std::shared_ptr<orc::SymbolStringPool> SSP,
: ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features), Triple TT, SubtargetFeatures Features)
FileName, loongarch::getEdgeKindName) {} : ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT),
std::move(Features), FileName,
loongarch::getEdgeKindName) {}
}; };
Error buildTables_ELF_loongarch(LinkGraph &G) { Error buildTables_ELF_loongarch(LinkGraph &G) {
@@ -151,8 +153,8 @@ Error buildTables_ELF_loongarch(LinkGraph &G) {
namespace llvm { namespace llvm {
namespace jitlink { namespace jitlink {
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_loongarch(
createLinkGraphFromELFObject_loongarch(MemoryBufferRef ObjectBuffer) { MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << "Building jitlink graph for new input " dbgs() << "Building jitlink graph for new input "
<< ObjectBuffer.getBufferIdentifier() << "...\n"; << ObjectBuffer.getBufferIdentifier() << "...\n";
@@ -170,7 +172,7 @@ createLinkGraphFromELFObject_loongarch(MemoryBufferRef ObjectBuffer) {
auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj); auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
return ELFLinkGraphBuilder_loongarch<object::ELF64LE>( return ELFLinkGraphBuilder_loongarch<object::ELF64LE>(
(*ELFObj)->getFileName(), ELFObjFile.getELFFile(), (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
(*ELFObj)->makeTriple(), std::move(*Features)) std::move(SSP), (*ELFObj)->makeTriple(), std::move(*Features))
.buildGraph(); .buildGraph();
} }
@@ -178,7 +180,7 @@ createLinkGraphFromELFObject_loongarch(MemoryBufferRef ObjectBuffer) {
"Invalid triple for LoongArch ELF object file"); "Invalid triple for LoongArch ELF object file");
auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj); auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
return ELFLinkGraphBuilder_loongarch<object::ELF32LE>( return ELFLinkGraphBuilder_loongarch<object::ELF32LE>(
(*ELFObj)->getFileName(), ELFObjFile.getELFFile(), (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), std::move(SSP),
(*ELFObj)->makeTriple(), std::move(*Features)) (*ELFObj)->makeTriple(), std::move(*Features))
.buildGraph(); .buildGraph();
} }

35
llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp
View File

@@ -106,14 +106,14 @@ Symbol &createELFGOTHeader(LinkGraph &G,
Symbol *TOCSymbol = nullptr; Symbol *TOCSymbol = nullptr;
for (Symbol *Sym : G.defined_symbols()) for (Symbol *Sym : G.defined_symbols())
if (LLVM_UNLIKELY(Sym->getName() == ELFTOCSymbolName)) { if (LLVM_UNLIKELY(Sym->hasName() && *Sym->getName() == ELFTOCSymbolName)) {
TOCSymbol = Sym; TOCSymbol = Sym;
break; break;
} }
if (LLVM_LIKELY(TOCSymbol == nullptr)) { if (LLVM_LIKELY(TOCSymbol == nullptr)) {
for (Symbol *Sym : G.external_symbols()) for (Symbol *Sym : G.external_symbols())
if (Sym->getName() == ELFTOCSymbolName) { if (Sym->hasName() && *Sym->getName() == ELFTOCSymbolName) {
TOCSymbol = Sym; TOCSymbol = Sym;
break; break;
} }
@@ -393,10 +393,12 @@ private:
public: public:
ELFLinkGraphBuilder_ppc64(StringRef FileName, ELFLinkGraphBuilder_ppc64(StringRef FileName,
const object::ELFFile<ELFT> &Obj, Triple TT, const object::ELFFile<ELFT> &Obj,
SubtargetFeatures Features) std::shared_ptr<orc::SymbolStringPool> SSP,
: ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features), Triple TT, SubtargetFeatures Features)
FileName, ppc64::getEdgeKindName) {} : ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT),
std::move(Features), FileName,
ppc64::getEdgeKindName) {}
}; };
template <llvm::endianness Endianness> template <llvm::endianness Endianness>
@@ -417,7 +419,8 @@ private:
Error defineTOCBase(LinkGraph &G) { Error defineTOCBase(LinkGraph &G) {
for (Symbol *Sym : G.defined_symbols()) { for (Symbol *Sym : G.defined_symbols()) {
if (LLVM_UNLIKELY(Sym->getName() == ELFTOCSymbolName)) { if (LLVM_UNLIKELY(Sym->hasName() &&
*Sym->getName() == ELFTOCSymbolName)) {
TOCSymbol = Sym; TOCSymbol = Sym;
return Error::success(); return Error::success();
} }
@@ -427,7 +430,7 @@ private:
"TOCSymbol should not be defined at this point"); "TOCSymbol should not be defined at this point");
for (Symbol *Sym : G.external_symbols()) { for (Symbol *Sym : G.external_symbols()) {
if (Sym->getName() == ELFTOCSymbolName) { if (Sym->hasName() && *Sym->getName() == ELFTOCSymbolName) {
TOCSymbol = Sym; TOCSymbol = Sym;
break; break;
} }
@@ -463,7 +466,8 @@ private:
template <llvm::endianness Endianness> template <llvm::endianness Endianness>
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) { createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << "Building jitlink graph for new input " dbgs() << "Building jitlink graph for new input "
<< ObjectBuffer.getBufferIdentifier() << "...\n"; << ObjectBuffer.getBufferIdentifier() << "...\n";
@@ -480,7 +484,7 @@ createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) {
using ELFT = object::ELFType<Endianness, true>; using ELFT = object::ELFType<Endianness, true>;
auto &ELFObjFile = cast<object::ELFObjectFile<ELFT>>(**ELFObj); auto &ELFObjFile = cast<object::ELFObjectFile<ELFT>>(**ELFObj);
return ELFLinkGraphBuilder_ppc64<Endianness>( return ELFLinkGraphBuilder_ppc64<Endianness>(
(*ELFObj)->getFileName(), ELFObjFile.getELFFile(), (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), std::move(SSP),
(*ELFObj)->makeTriple(), std::move(*Features)) (*ELFObj)->makeTriple(), std::move(*Features))
.buildGraph(); .buildGraph();
} }
@@ -517,15 +521,16 @@ void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
} }
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) { createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP) {
return createLinkGraphFromELFObject_ppc64<llvm::endianness::big>( return createLinkGraphFromELFObject_ppc64<llvm::endianness::big>(
std::move(ObjectBuffer)); std::move(ObjectBuffer), std::move(SSP));
} }
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_ppc64le(
createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer) { MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
return createLinkGraphFromELFObject_ppc64<llvm::endianness::little>( return createLinkGraphFromELFObject_ppc64<llvm::endianness::little>(
std::move(ObjectBuffer)); std::move(ObjectBuffer), std::move(SSP));
} }
/// jit-link the given object buffer, which must be a ELF ppc64 object file. /// jit-link the given object buffer, which must be a ELF ppc64 object file.

17
llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp
View File

@@ -927,14 +927,17 @@ private:
public: public:
ELFLinkGraphBuilder_riscv(StringRef FileName, ELFLinkGraphBuilder_riscv(StringRef FileName,
const object::ELFFile<ELFT> &Obj, Triple TT, const object::ELFFile<ELFT> &Obj,
SubtargetFeatures Features) std::shared_ptr<orc::SymbolStringPool> SSP,
: ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features), Triple TT, SubtargetFeatures Features)
FileName, riscv::getEdgeKindName) {} : ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT),
std::move(Features), FileName,
riscv::getEdgeKindName) {}
}; };
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer) { createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << "Building jitlink graph for new input " dbgs() << "Building jitlink graph for new input "
<< ObjectBuffer.getBufferIdentifier() << "...\n"; << ObjectBuffer.getBufferIdentifier() << "...\n";
@@ -952,7 +955,7 @@ createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer) {
auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj); auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
return ELFLinkGraphBuilder_riscv<object::ELF64LE>( return ELFLinkGraphBuilder_riscv<object::ELF64LE>(
(*ELFObj)->getFileName(), ELFObjFile.getELFFile(), (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
(*ELFObj)->makeTriple(), std::move(*Features)) std::move(SSP), (*ELFObj)->makeTriple(), std::move(*Features))
.buildGraph(); .buildGraph();
} else { } else {
assert((*ELFObj)->getArch() == Triple::riscv32 && assert((*ELFObj)->getArch() == Triple::riscv32 &&
@@ -960,7 +963,7 @@ createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer) {
auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj); auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
return ELFLinkGraphBuilder_riscv<object::ELF32LE>( return ELFLinkGraphBuilder_riscv<object::ELF32LE>(
(*ELFObj)->getFileName(), ELFObjFile.getELFFile(), (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
(*ELFObj)->makeTriple(), std::move(*Features)) std::move(SSP), (*ELFObj)->makeTriple(), std::move(*Features))
.buildGraph(); .buildGraph();
} }
} }

17
llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp
View File

@@ -238,9 +238,10 @@ private:
public: public:
ELFLinkGraphBuilder_x86_64(StringRef FileName, ELFLinkGraphBuilder_x86_64(StringRef FileName,
std::shared_ptr<orc::SymbolStringPool> SSP,
const object::ELFFile<object::ELF64LE> &Obj, const object::ELFFile<object::ELF64LE> &Obj,
SubtargetFeatures Features) SubtargetFeatures Features)
: ELFLinkGraphBuilder(Obj, Triple("x86_64-unknown-linux"), : ELFLinkGraphBuilder(Obj, std::move(SSP), Triple("x86_64-unknown-linux"),
std::move(Features), FileName, std::move(Features), FileName,
x86_64::getEdgeKindName) {} x86_64::getEdgeKindName) {}
}; };
@@ -261,12 +262,12 @@ public:
private: private:
Symbol *GOTSymbol = nullptr; Symbol *GOTSymbol = nullptr;
Error getOrCreateGOTSymbol(LinkGraph &G) { Error getOrCreateGOTSymbol(LinkGraph &G) {
auto DefineExternalGOTSymbolIfPresent = auto DefineExternalGOTSymbolIfPresent =
createDefineExternalSectionStartAndEndSymbolsPass( createDefineExternalSectionStartAndEndSymbolsPass(
[&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc { [&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc {
if (Sym.getName() == ELFGOTSymbolName) if (Sym.getName() != nullptr &&
*Sym.getName() == ELFGOTSymbolName)
if (auto *GOTSection = G.findSectionByName( if (auto *GOTSection = G.findSectionByName(
x86_64::GOTTableManager::getSectionName())) { x86_64::GOTTableManager::getSectionName())) {
GOTSymbol = &Sym; GOTSymbol = &Sym;
@@ -292,7 +293,7 @@ private:
// Check for an existing defined symbol. // Check for an existing defined symbol.
for (auto *Sym : GOTSection->symbols()) for (auto *Sym : GOTSection->symbols())
if (Sym->getName() == ELFGOTSymbolName) { if (Sym->getName() != nullptr && *Sym->getName() == ELFGOTSymbolName) {
GOTSymbol = Sym; GOTSymbol = Sym;
return Error::success(); return Error::success();
} }
@@ -314,7 +315,7 @@ private:
// we just need to point the GOT symbol at some address in this graph. // we just need to point the GOT symbol at some address in this graph.
if (!GOTSymbol) { if (!GOTSymbol) {
for (auto *Sym : G.external_symbols()) { for (auto *Sym : G.external_symbols()) {
if (Sym->getName() == ELFGOTSymbolName) { if (*Sym->getName() == ELFGOTSymbolName) {
auto Blocks = G.blocks(); auto Blocks = G.blocks();
if (!Blocks.empty()) { if (!Blocks.empty()) {
G.makeAbsolute(*Sym, (*Blocks.begin())->getAddress()); G.makeAbsolute(*Sym, (*Blocks.begin())->getAddress());
@@ -333,8 +334,8 @@ private:
} }
}; };
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_x86_64(
createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer) { MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << "Building jitlink graph for new input " dbgs() << "Building jitlink graph for new input "
<< ObjectBuffer.getBufferIdentifier() << "...\n"; << ObjectBuffer.getBufferIdentifier() << "...\n";
@@ -349,7 +350,7 @@ createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer) {
return Features.takeError(); return Features.takeError();
auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj); auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
return ELFLinkGraphBuilder_x86_64((*ELFObj)->getFileName(), return ELFLinkGraphBuilder_x86_64((*ELFObj)->getFileName(), std::move(SSP),
ELFObjFile.getELFFile(), ELFObjFile.getELFFile(),
std::move(*Features)) std::move(*Features))
.buildGraph(); .buildGraph();

31
llvm/lib/ExecutionEngine/JITLink/JITLink.cpp
View File

@@ -125,7 +125,7 @@ raw_ostream &operator<<(raw_ostream &OS, const Symbol &Sym) {
<< ", linkage: " << formatv("{0:6}", getLinkageName(Sym.getLinkage())) << ", linkage: " << formatv("{0:6}", getLinkageName(Sym.getLinkage()))
<< ", scope: " << formatv("{0:8}", getScopeName(Sym.getScope())) << ", " << ", scope: " << formatv("{0:8}", getScopeName(Sym.getScope())) << ", "
<< (Sym.isLive() ? "live" : "dead") << " - " << (Sym.isLive() ? "live" : "dead") << " - "
<< (Sym.hasName() ? Sym.getName() : "<anonymous symbol>"); << (Sym.hasName() ? *Sym.getName() : "<anonymous symbol>");
return OS; return OS;
} }
@@ -167,6 +167,16 @@ Section::~Section() {
B->~Block(); B->~Block();
} }
LinkGraph::~LinkGraph() {
for (auto *Sym : AbsoluteSymbols) {
Sym->~Symbol();
}
for (auto *Sym : external_symbols()) {
Sym->~Symbol();
}
ExternalSymbols.clear();
}
std::vector<Block *> LinkGraph::splitBlockImpl(std::vector<Block *> Blocks, std::vector<Block *> LinkGraph::splitBlockImpl(std::vector<Block *> Blocks,
SplitBlockCache *Cache) { SplitBlockCache *Cache) {
assert(!Blocks.empty() && "Blocks must at least contain the original block"); assert(!Blocks.empty() && "Blocks must at least contain the original block");
@@ -481,22 +491,25 @@ PointerJumpStubCreator getPointerJumpStubCreator(const Triple &TT) {
} }
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromObject(MemoryBufferRef ObjectBuffer) { createLinkGraphFromObject(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP) {
auto Magic = identify_magic(ObjectBuffer.getBuffer()); auto Magic = identify_magic(ObjectBuffer.getBuffer());
switch (Magic) { switch (Magic) {
case file_magic::macho_object: case file_magic::macho_object:
return createLinkGraphFromMachOObject(ObjectBuffer); return createLinkGraphFromMachOObject(ObjectBuffer, std::move(SSP));
case file_magic::elf_relocatable: case file_magic::elf_relocatable:
return createLinkGraphFromELFObject(ObjectBuffer); return createLinkGraphFromELFObject(ObjectBuffer, std::move(SSP));
case file_magic::coff_object: case file_magic::coff_object:
return createLinkGraphFromCOFFObject(ObjectBuffer); return createLinkGraphFromCOFFObject(ObjectBuffer, std::move(SSP));
default: default:
return make_error<JITLinkError>("Unsupported file format"); return make_error<JITLinkError>("Unsupported file format");
}; };
} }
std::unique_ptr<LinkGraph> absoluteSymbolsLinkGraph(const Triple &TT, std::unique_ptr<LinkGraph>
orc::SymbolMap Symbols) { absoluteSymbolsLinkGraph(const Triple &TT,
std::shared_ptr<orc::SymbolStringPool> SSP,
orc::SymbolMap Symbols) {
unsigned PointerSize; unsigned PointerSize;
endianness Endianness = endianness Endianness =
TT.isLittleEndian() ? endianness::little : endianness::big; TT.isLittleEndian() ? endianness::little : endianness::big;
@@ -518,8 +531,8 @@ std::unique_ptr<LinkGraph> absoluteSymbolsLinkGraph(const Triple &TT,
static std::atomic<uint64_t> Counter = {0}; static std::atomic<uint64_t> Counter = {0};
auto Index = Counter.fetch_add(1, std::memory_order_relaxed); auto Index = Counter.fetch_add(1, std::memory_order_relaxed);
auto G = std::make_unique<LinkGraph>( auto G = std::make_unique<LinkGraph>(
"<Absolute Symbols " + std::to_string(Index) + ">", TT, PointerSize, "<Absolute Symbols " + std::to_string(Index) + ">", std::move(SSP), TT,
Endianness, /*GetEdgeKindName=*/nullptr); PointerSize, Endianness, /*GetEdgeKindName=*/nullptr);
for (auto &[Name, Def] : Symbols) { for (auto &[Name, Def] : Symbols) {
auto &Sym = auto &Sym =
G->addAbsoluteSymbol(*Name, Def.getAddress(), /*Size=*/0, G->addAbsoluteSymbol(*Name, Def.getAddress(), /*Size=*/0,

3
llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp
View File

@@ -211,8 +211,7 @@ JITLinkContext::LookupMap JITLinkerBase::getExternalSymbolNames() const {
for (auto *Sym : G->external_symbols()) { for (auto *Sym : G->external_symbols()) {
assert(!Sym->getAddress() && assert(!Sym->getAddress() &&
"External has already been assigned an address"); "External has already been assigned an address");
assert(Sym->getName() != StringRef() && Sym->getName() != "" && assert(Sym->hasName() && "Externals must be named");
"Externals must be named");
SymbolLookupFlags LookupFlags = SymbolLookupFlags LookupFlags =
Sym->isWeaklyReferenced() ? SymbolLookupFlags::WeaklyReferencedSymbol Sym->isWeaklyReferenced() ? SymbolLookupFlags::WeaklyReferencedSymbol
: SymbolLookupFlags::RequiredSymbol; : SymbolLookupFlags::RequiredSymbol;

10
llvm/lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp
View File

@@ -144,6 +144,7 @@ orc::shared::AllocActions &BasicLayout::graphAllocActions() {
} }
void SimpleSegmentAlloc::Create(JITLinkMemoryManager &MemMgr, void SimpleSegmentAlloc::Create(JITLinkMemoryManager &MemMgr,
std::shared_ptr<orc::SymbolStringPool> SSP,
const JITLinkDylib *JD, SegmentMap Segments, const JITLinkDylib *JD, SegmentMap Segments,
OnCreatedFunction OnCreated) { OnCreatedFunction OnCreated) {
@@ -155,7 +156,7 @@ void SimpleSegmentAlloc::Create(JITLinkMemoryManager &MemMgr,
"__---.finalize", "__R--.finalize", "__-W-.finalize", "__RW-.finalize", "__---.finalize", "__R--.finalize", "__-W-.finalize", "__RW-.finalize",
"__--X.finalize", "__R-X.finalize", "__-WX.finalize", "__RWX.finalize"}; "__--X.finalize", "__R-X.finalize", "__-WX.finalize", "__RWX.finalize"};
auto G = std::make_unique<LinkGraph>("", Triple(), 0, auto G = std::make_unique<LinkGraph>("", std::move(SSP), Triple(), 0,
llvm::endianness::native, nullptr); llvm::endianness::native, nullptr);
orc::AllocGroupSmallMap<Block *> ContentBlocks; orc::AllocGroupSmallMap<Block *> ContentBlocks;
@@ -201,11 +202,12 @@ void SimpleSegmentAlloc::Create(JITLinkMemoryManager &MemMgr,
} }
Expected<SimpleSegmentAlloc> Expected<SimpleSegmentAlloc>
SimpleSegmentAlloc::Create(JITLinkMemoryManager &MemMgr, const JITLinkDylib *JD, SimpleSegmentAlloc::Create(JITLinkMemoryManager &MemMgr,
SegmentMap Segments) { std::shared_ptr<orc::SymbolStringPool> SSP,
const JITLinkDylib *JD, SegmentMap Segments) {
std::promise<MSVCPExpected<SimpleSegmentAlloc>> AllocP; std::promise<MSVCPExpected<SimpleSegmentAlloc>> AllocP;
auto AllocF = AllocP.get_future(); auto AllocF = AllocP.get_future();
Create(MemMgr, JD, std::move(Segments), Create(MemMgr, std::move(SSP), JD, std::move(Segments),
[&](Expected<SimpleSegmentAlloc> Result) { [&](Expected<SimpleSegmentAlloc> Result) {
AllocP.set_value(std::move(Result)); AllocP.set_value(std::move(Result));
}); });

8
llvm/lib/ExecutionEngine/JITLink/MachO.cpp
View File

@@ -25,7 +25,8 @@ namespace llvm {
namespace jitlink { namespace jitlink {
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer) { createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer,
std::shared_ptr<orc::SymbolStringPool> SSP) {
StringRef Data = ObjectBuffer.getBuffer(); StringRef Data = ObjectBuffer.getBuffer();
if (Data.size() < 4) if (Data.size() < 4)
return make_error<JITLinkError>("Truncated MachO buffer \"" + return make_error<JITLinkError>("Truncated MachO buffer \"" +
@@ -61,9 +62,10 @@ createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer) {
switch (CPUType) { switch (CPUType) {
case MachO::CPU_TYPE_ARM64: case MachO::CPU_TYPE_ARM64:
return createLinkGraphFromMachOObject_arm64(ObjectBuffer); return createLinkGraphFromMachOObject_arm64(ObjectBuffer, std::move(SSP));
case MachO::CPU_TYPE_X86_64: case MachO::CPU_TYPE_X86_64:
return createLinkGraphFromMachOObject_x86_64(ObjectBuffer); return createLinkGraphFromMachOObject_x86_64(ObjectBuffer,
std::move(SSP));
} }
return make_error<JITLinkError>("MachO-64 CPU type not valid"); return make_error<JITLinkError>("MachO-64 CPU type not valid");
} else } else

26
llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp
View File

@@ -49,13 +49,14 @@ Expected<std::unique_ptr<LinkGraph>> MachOLinkGraphBuilder::buildGraph() {
} }
MachOLinkGraphBuilder::MachOLinkGraphBuilder( MachOLinkGraphBuilder::MachOLinkGraphBuilder(
const object::MachOObjectFile &Obj, Triple TT, SubtargetFeatures Features, const object::MachOObjectFile &Obj,
std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
SubtargetFeatures Features,
LinkGraph::GetEdgeKindNameFunction GetEdgeKindName) LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
: Obj(Obj), : Obj(Obj), G(std::make_unique<LinkGraph>(
G(std::make_unique<LinkGraph>(std::string(Obj.getFileName()), std::string(Obj.getFileName()), std::move(SSP),
std::move(TT), std::move(Features), std::move(TT), std::move(Features), getPointerSize(Obj),
getPointerSize(Obj), getEndianness(Obj), getEndianness(Obj), std::move(GetEdgeKindName))) {
std::move(GetEdgeKindName))) {
auto &MachHeader = Obj.getHeader64(); auto &MachHeader = Obj.getHeader64();
SubsectionsViaSymbols = MachHeader.flags & MachO::MH_SUBSECTIONS_VIA_SYMBOLS; SubsectionsViaSymbols = MachHeader.flags & MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
} }
@@ -319,9 +320,8 @@ Error MachOLinkGraphBuilder::createNormalizedSymbols() {
} }
} }
IndexToSymbol[SymbolIndex] = IndexToSymbol[SymbolIndex] = &createNormalizedSymbol(
&createNormalizedSymbol(*Name, Value, Type, Sect, Desc, Name, Value, Type, Sect, Desc, getLinkage(Desc), getScope(*Name, Type));
getLinkage(Desc), getScope(*Name, Type));
} }
return Error::success(); return Error::success();
@@ -587,7 +587,7 @@ Symbol &MachOLinkGraphBuilder::createStandardGraphSymbol(NormalizedSymbol &NSym,
if (!NSym.Name) if (!NSym.Name)
dbgs() << "<anonymous symbol>"; dbgs() << "<anonymous symbol>";
else else
dbgs() << NSym.Name; dbgs() << *NSym.Name;
if (IsText) if (IsText)
dbgs() << " [text]"; dbgs() << " [text]";
if (IsNoDeadStrip) if (IsNoDeadStrip)
@@ -726,7 +726,7 @@ Error MachOLinkGraphBuilder::graphifyCStringSection(
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << " Adding symbol for c-string block " << B.getRange() dbgs() << " Adding symbol for c-string block " << B.getRange()
<< ": " << ": "
<< (Sym.hasName() ? Sym.getName() : "<anonymous symbol>") << (Sym.hasName() ? *Sym.getName() : "<anonymous symbol>")
<< " at offset " << formatv("{0:x}", Sym.getOffset()) << "\n"; << " at offset " << formatv("{0:x}", Sym.getOffset()) << "\n";
}); });
@@ -826,7 +826,7 @@ Error CompactUnwindSplitter::operator()(LinkGraph &G) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << " Updating compact unwind record at " dbgs() << " Updating compact unwind record at "
<< CURec->getAddress() << " to point to " << CURec->getAddress() << " to point to "
<< (E.getTarget().hasName() ? E.getTarget().getName() << (E.getTarget().hasName() ? *E.getTarget().getName()
: StringRef()) : StringRef())
<< " (at " << E.getTarget().getAddress() << ")\n"; << " (at " << E.getTarget().getAddress() << ")\n";
}); });
@@ -835,7 +835,7 @@ Error CompactUnwindSplitter::operator()(LinkGraph &G) {
return make_error<JITLinkError>( return make_error<JITLinkError>(
"Error adding keep-alive edge for compact unwind record at " + "Error adding keep-alive edge for compact unwind record at " +
formatv("{0:x}", CURec->getAddress()) + ": target " + formatv("{0:x}", CURec->getAddress()) + ": target " +
E.getTarget().getName() + " is an external symbol"); *E.getTarget().getName() + " is an external symbol");
auto &TgtBlock = E.getTarget().getBlock(); auto &TgtBlock = E.getTarget().getBlock();
auto &CURecSym = auto &CURecSym =
G.addAnonymousSymbol(*CURec, 0, CURecordSize, false, false); G.addAnonymousSymbol(*CURec, 0, CURecordSize, false, false);

4
llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.h
View File

@@ -83,10 +83,10 @@ protected:
using SectionParserFunction = std::function<Error(NormalizedSection &S)>; using SectionParserFunction = std::function<Error(NormalizedSection &S)>;
MachOLinkGraphBuilder(const object::MachOObjectFile &Obj, Triple TT, MachOLinkGraphBuilder(const object::MachOObjectFile &Obj,
std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
SubtargetFeatures Features, SubtargetFeatures Features,
LinkGraph::GetEdgeKindNameFunction GetEdgeKindName); LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
LinkGraph &getGraph() const { return *G; } LinkGraph &getGraph() const { return *G; }
const object::MachOObjectFile &getObject() const { return Obj; } const object::MachOObjectFile &getObject() const { return Obj; }

12
llvm/lib/ExecutionEngine/JITLink/MachO_arm64.cpp
View File

@@ -27,9 +27,10 @@ namespace {
class MachOLinkGraphBuilder_arm64 : public MachOLinkGraphBuilder { class MachOLinkGraphBuilder_arm64 : public MachOLinkGraphBuilder {
public: public:
MachOLinkGraphBuilder_arm64(const object::MachOObjectFile &Obj, MachOLinkGraphBuilder_arm64(const object::MachOObjectFile &Obj,
std::shared_ptr<orc::SymbolStringPool> SSP,
SubtargetFeatures Features) SubtargetFeatures Features)
: MachOLinkGraphBuilder(Obj, getObjectTriple(Obj), std::move(Features), : MachOLinkGraphBuilder(Obj, std::move(SSP), getObjectTriple(Obj),
aarch64::getEdgeKindName), std::move(Features), aarch64::getEdgeKindName),
NumSymbols(Obj.getSymtabLoadCommand().nsyms) {} NumSymbols(Obj.getSymtabLoadCommand().nsyms) {}
private: private:
@@ -580,8 +581,8 @@ private:
uint64_t NullValue = 0; uint64_t NullValue = 0;
}; };
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromMachOObject_arm64(
createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer) { MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer); auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer);
if (!MachOObj) if (!MachOObj)
return MachOObj.takeError(); return MachOObj.takeError();
@@ -590,7 +591,8 @@ createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer) {
if (!Features) if (!Features)
return Features.takeError(); return Features.takeError();
return MachOLinkGraphBuilder_arm64(**MachOObj, std::move(*Features)) return MachOLinkGraphBuilder_arm64(**MachOObj, std::move(SSP),
std::move(*Features))
.buildGraph(); .buildGraph();
} }

11
llvm/lib/ExecutionEngine/JITLink/MachO_x86_64.cpp
View File

@@ -27,8 +27,10 @@ namespace {
class MachOLinkGraphBuilder_x86_64 : public MachOLinkGraphBuilder { class MachOLinkGraphBuilder_x86_64 : public MachOLinkGraphBuilder {
public: public:
MachOLinkGraphBuilder_x86_64(const object::MachOObjectFile &Obj, MachOLinkGraphBuilder_x86_64(const object::MachOObjectFile &Obj,
std::shared_ptr<orc::SymbolStringPool> SSP,
SubtargetFeatures Features) SubtargetFeatures Features)
: MachOLinkGraphBuilder(Obj, Triple("x86_64-apple-darwin"), : MachOLinkGraphBuilder(Obj, std::move(SSP),
Triple("x86_64-apple-darwin"),
std::move(Features), x86_64::getEdgeKindName) {} std::move(Features), x86_64::getEdgeKindName) {}
private: private:
@@ -483,8 +485,8 @@ private:
} }
}; };
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromMachOObject_x86_64(
createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer) { MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer); auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer);
if (!MachOObj) if (!MachOObj)
return MachOObj.takeError(); return MachOObj.takeError();
@@ -493,7 +495,8 @@ createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer) {
if (!Features) if (!Features)
return Features.takeError(); return Features.takeError();
return MachOLinkGraphBuilder_x86_64(**MachOObj, std::move(*Features)) return MachOLinkGraphBuilder_x86_64(**MachOObj, std::move(SSP),
std::move(*Features))
.buildGraph(); .buildGraph();
} }

4
llvm/lib/ExecutionEngine/JITLink/PerGraphGOTAndPLTStubsBuilder.h
View File

@@ -114,8 +114,8 @@ protected:
private: private:
BuilderImplT &impl() { return static_cast<BuilderImplT &>(*this); } BuilderImplT &impl() { return static_cast<BuilderImplT &>(*this); }
DenseMap<StringRef, Symbol *> GOTEntries; DenseMap<orc::SymbolStringPtr, Symbol *> GOTEntries;
DenseMap<StringRef, Symbol *> PLTStubs; DenseMap<orc::SymbolStringPtr, Symbol *> PLTStubs;
}; };
} // end namespace jitlink } // end namespace jitlink

4
llvm/lib/ExecutionEngine/JITLink/aarch32.cpp
View File

@@ -852,7 +852,7 @@ bool StubsManager_prev7::visitEdge(LinkGraph &G, Block *B, Edge &E) {
Symbol &Target = E.getTarget(); Symbol &Target = E.getTarget();
assert(Target.hasName() && "Edge cannot point to anonymous target"); assert(Target.hasName() && "Edge cannot point to anonymous target");
auto [Slot, NewStub] = getStubMapSlot(Target.getName()); auto [Slot, NewStub] = getStubMapSlot(*Target.getName());
if (NewStub) { if (NewStub) {
if (!StubsSection) if (!StubsSection)
@@ -896,7 +896,7 @@ bool StubsManager_v7::visitEdge(LinkGraph &G, Block *B, Edge &E) {
Symbol &Target = E.getTarget(); Symbol &Target = E.getTarget();
assert(Target.hasName() && "Edge cannot point to anonymous target"); assert(Target.hasName() && "Edge cannot point to anonymous target");
Symbol *&StubSymbol = getStubSymbolSlot(Target.getName(), MakeThumb); Symbol *&StubSymbol = getStubSymbolSlot(*Target.getName(), MakeThumb);
if (!StubSymbol) { if (!StubSymbol) {
if (!StubsSection) if (!StubsSection)

6
llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp
View File

@@ -68,8 +68,8 @@ public:
} }
auto G = std::make_unique<jitlink::LinkGraph>( auto G = std::make_unique<jitlink::LinkGraph>(
"<COFFHeaderMU>", TT, PointerSize, Endianness, "<COFFHeaderMU>", CP.getExecutionSession().getSymbolStringPool(), TT,
jitlink::getGenericEdgeKindName); PointerSize, Endianness, jitlink::getGenericEdgeKindName);
auto &HeaderSection = G->createSection("__header", MemProt::Read); auto &HeaderSection = G->createSection("__header", MemProt::Read);
auto &HeaderBlock = createHeaderBlock(*G, HeaderSection); auto &HeaderBlock = createHeaderBlock(*G, HeaderSection);
@@ -792,7 +792,7 @@ Error COFFPlatform::COFFPlatformPlugin::associateJITDylibHeaderSymbol(
jitlink::LinkGraph &G, MaterializationResponsibility &MR, jitlink::LinkGraph &G, MaterializationResponsibility &MR,
bool IsBootstraping) { bool IsBootstraping) {
auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) { auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) {
return Sym->getName() == *CP.COFFHeaderStartSymbol; return *Sym->getName() == *CP.COFFHeaderStartSymbol;
}); });
assert(I != G.defined_symbols().end() && "Missing COFF header start symbol"); assert(I != G.defined_symbols().end() && "Missing COFF header start symbol");

7
llvm/lib/ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp
View File

@@ -149,9 +149,9 @@ protected:
JITLinkMemoryManager &MemMgr; JITLinkMemoryManager &MemMgr;
const JITLinkDylib *JD = nullptr; const JITLinkDylib *JD = nullptr;
ExecutionSession &ES;
private: private:
ExecutionSession &ES;
DebugObjectFlags Flags; DebugObjectFlags Flags;
FinalizedAlloc Alloc; FinalizedAlloc Alloc;
}; };
@@ -331,8 +331,9 @@ Expected<SimpleSegmentAlloc> ELFDebugObject::finalizeWorkingMemory() {
size_t Size = Buffer->getBufferSize(); size_t Size = Buffer->getBufferSize();
// Allocate working memory for debug object in read-only segment. // Allocate working memory for debug object in read-only segment.
auto Alloc = SimpleSegmentAlloc::Create( auto Alloc =
MemMgr, JD, {{MemProt::Read, {Size, Align(PageSize)}}}); SimpleSegmentAlloc::Create(MemMgr, ES.getSymbolStringPool(), JD,
{{MemProt::Read, {Size, Align(PageSize)}}});
if (!Alloc) if (!Alloc)
return Alloc; return Alloc;

4
llvm/lib/ExecutionEngine/Orc/Debugging/DebuggerSupportPlugin.cpp
View File

@@ -214,8 +214,8 @@ public:
Builder.addSymbol("", MachO::N_BNSYM, 1, 0, 0); Builder.addSymbol("", MachO::N_BNSYM, 1, 0, 0);
StabSymbols.push_back( StabSymbols.push_back(
{*Sym, Builder.addSymbol(Sym->getName(), SymType, 1, 0, 0), {*Sym, Builder.addSymbol(*Sym->getName(), SymType, 1, 0, 0),
Builder.addSymbol(Sym->getName(), SymType, 0, 0, 0)}); Builder.addSymbol(*Sym->getName(), SymType, 0, 0, 0)});
Builder.addSymbol("", MachO::N_ENSYM, 1, 0, 0); Builder.addSymbol("", MachO::N_ENSYM, 1, 0, 0);
} }
} }

2
llvm/lib/ExecutionEngine/Orc/Debugging/PerfSupportPlugin.cpp
View File

@@ -86,7 +86,7 @@ constexpr StringRef RegisterPerfImplSymbolName =
static PerfJITCodeLoadRecord static PerfJITCodeLoadRecord
getCodeLoadRecord(const Symbol &Sym, std::atomic<uint64_t> &CodeIndex) { getCodeLoadRecord(const Symbol &Sym, std::atomic<uint64_t> &CodeIndex) {
PerfJITCodeLoadRecord Record; PerfJITCodeLoadRecord Record;
auto Name = Sym.getName(); auto Name = *Sym.getName();
auto Addr = Sym.getAddress(); auto Addr = Sym.getAddress();
auto Size = Sym.getSize(); auto Size = Sym.getSize();
Record.Prefix.Id = PerfJITRecordType::JIT_CODE_LOAD; Record.Prefix.Id = PerfJITRecordType::JIT_CODE_LOAD;

2
llvm/lib/ExecutionEngine/Orc/Debugging/VTuneSupportPlugin.cpp
View File

@@ -56,7 +56,7 @@ static VTuneMethodBatch getMethodBatch(LinkGraph &G, bool EmitDebugInfo) {
Method.ParentMI = 0; Method.ParentMI = 0;
Method.LoadAddr = Sym->getAddress(); Method.LoadAddr = Sym->getAddress();
Method.LoadSize = Sym->getSize(); Method.LoadSize = Sym->getSize();
Method.NameSI = GetStringIdx(Sym->getName()); Method.NameSI = GetStringIdx(*Sym->getName());
Method.ClassFileSI = 0; Method.ClassFileSI = 0;
Method.SourceFileSI = 0; Method.SourceFileSI = 0;

31
llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp
View File

@@ -65,9 +65,9 @@ std::unique_ptr<jitlink::LinkGraph> createPlatformGraph(ELFNixPlatform &MOP,
llvm_unreachable("Unrecognized architecture"); llvm_unreachable("Unrecognized architecture");
} }
return std::make_unique<jitlink::LinkGraph>(std::move(Name), TT, PointerSize, return std::make_unique<jitlink::LinkGraph>(
Endianness, std::move(Name), MOP.getExecutionSession().getSymbolStringPool(), TT,
jitlink::getGenericEdgeKindName); PointerSize, Endianness, jitlink::getGenericEdgeKindName);
} }
// Creates a Bootstrap-Complete LinkGraph to run deferred actions. // Creates a Bootstrap-Complete LinkGraph to run deferred actions.
@@ -188,8 +188,8 @@ public:
// void *__dso_handle = &__dso_handle; // void *__dso_handle = &__dso_handle;
auto G = std::make_unique<jitlink::LinkGraph>( auto G = std::make_unique<jitlink::LinkGraph>(
"<DSOHandleMU>", TT, PointerSize, Endianness, "<DSOHandleMU>", ENP.getExecutionSession().getSymbolStringPool(), TT,
jitlink::getGenericEdgeKindName); PointerSize, Endianness, jitlink::getGenericEdgeKindName);
auto &DSOHandleSection = auto &DSOHandleSection =
G->createSection(".data.__dso_handle", MemProt::Read); G->createSection(".data.__dso_handle", MemProt::Read);
auto &DSOHandleBlock = G->createContentBlock( auto &DSOHandleBlock = G->createContentBlock(
@@ -663,14 +663,14 @@ Error ELFNixPlatform::ELFNixPlatformPlugin::
for (auto *Sym : G.defined_symbols()) { for (auto *Sym : G.defined_symbols()) {
for (auto &RTSym : RuntimeSymbols) { for (auto &RTSym : RuntimeSymbols) {
if (Sym->hasName() && Sym->getName() == RTSym.first) { if (Sym->hasName() && *Sym->getName() == RTSym.first) {
if (*RTSym.second) if (*RTSym.second)
return make_error<StringError>( return make_error<StringError>(
"Duplicate " + RTSym.first + "Duplicate " + RTSym.first +
" detected during ELFNixPlatform bootstrap", " detected during ELFNixPlatform bootstrap",
inconvertibleErrorCode()); inconvertibleErrorCode());
if (Sym->getName() == *MP.DSOHandleSymbol) if (*Sym->getName() == *MP.DSOHandleSymbol)
RegisterELFNixHeader = true; RegisterELFNixHeader = true;
*RTSym.second = Sym->getAddress(); *RTSym.second = Sym->getAddress();
@@ -798,7 +798,7 @@ void ELFNixPlatform::ELFNixPlatformPlugin::addDSOHandleSupportPasses(
Config.PostAllocationPasses.push_back([this, &JD = MR.getTargetJITDylib()]( Config.PostAllocationPasses.push_back([this, &JD = MR.getTargetJITDylib()](
jitlink::LinkGraph &G) -> Error { jitlink::LinkGraph &G) -> Error {
auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) { auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) {
return Sym->getName() == *MP.DSOHandleSymbol; return Sym->getName() == MP.DSOHandleSymbol;
}); });
assert(I != G.defined_symbols().end() && "Missing DSO handle symbol"); assert(I != G.defined_symbols().end() && "Missing DSO handle symbol");
{ {
@@ -997,12 +997,17 @@ Error ELFNixPlatform::ELFNixPlatformPlugin::registerInitSections(
Error ELFNixPlatform::ELFNixPlatformPlugin::fixTLVSectionsAndEdges( Error ELFNixPlatform::ELFNixPlatformPlugin::fixTLVSectionsAndEdges(
jitlink::LinkGraph &G, JITDylib &JD) { jitlink::LinkGraph &G, JITDylib &JD) {
auto TLSGetAddrSymbolName = G.intern("__tls_get_addr");
auto TLSDescResolveSymbolName = G.intern("__tlsdesc_resolver");
for (auto *Sym : G.external_symbols()) { for (auto *Sym : G.external_symbols()) {
if (Sym->getName() == "__tls_get_addr") { if (Sym->getName() == TLSGetAddrSymbolName) {
Sym->setName("___orc_rt_elfnix_tls_get_addr"); auto TLSGetAddr =
} else if (Sym->getName() == "__tlsdesc_resolver") { MP.getExecutionSession().intern("___orc_rt_elfnix_tls_get_addr");
Sym->setName("___orc_rt_elfnix_tlsdesc_resolver"); Sym->setName(std::move(TLSGetAddr));
} else if (Sym->getName() == TLSDescResolveSymbolName) {
auto TLSGetAddr =
MP.getExecutionSession().intern("___orc_rt_elfnix_tlsdesc_resolver");
Sym->setName(std::move(TLSGetAddr));
} }
} }

12
llvm/lib/ExecutionEngine/Orc/EPCIndirectionUtils.cpp
View File

@@ -110,7 +110,7 @@ Error EPCTrampolinePool::grow() {
auto &EPC = EPCIU.getExecutorProcessControl(); auto &EPC = EPCIU.getExecutorProcessControl();
auto PageSize = EPC.getPageSize(); auto PageSize = EPC.getPageSize();
auto Alloc = SimpleSegmentAlloc::Create( auto Alloc = SimpleSegmentAlloc::Create(
EPC.getMemMgr(), nullptr, EPC.getMemMgr(), EPC.getSymbolStringPool(), nullptr,
{{MemProt::Read | MemProt::Exec, {PageSize, Align(PageSize)}}}); {{MemProt::Read | MemProt::Exec, {PageSize, Align(PageSize)}}});
if (!Alloc) if (!Alloc)
return Alloc.takeError(); return Alloc.takeError();
@@ -294,10 +294,10 @@ EPCIndirectionUtils::writeResolverBlock(ExecutorAddr ReentryFnAddr,
assert(ABI && "ABI can not be null"); assert(ABI && "ABI can not be null");
auto ResolverSize = ABI->getResolverCodeSize(); auto ResolverSize = ABI->getResolverCodeSize();
auto Alloc = auto Alloc = SimpleSegmentAlloc::Create(
SimpleSegmentAlloc::Create(EPC.getMemMgr(), nullptr, EPC.getMemMgr(), EPC.getSymbolStringPool(), nullptr,
{{MemProt::Read | MemProt::Exec, {{MemProt::Read | MemProt::Exec,
{ResolverSize, Align(EPC.getPageSize())}}}); {ResolverSize, Align(EPC.getPageSize())}}});
if (!Alloc) if (!Alloc)
return Alloc.takeError(); return Alloc.takeError();
@@ -363,7 +363,7 @@ EPCIndirectionUtils::getIndirectStubs(unsigned NumStubs) {
auto PtrProt = MemProt::Read | MemProt::Write; auto PtrProt = MemProt::Read | MemProt::Write;
auto Alloc = SimpleSegmentAlloc::Create( auto Alloc = SimpleSegmentAlloc::Create(
EPC.getMemMgr(), nullptr, EPC.getMemMgr(), EPC.getSymbolStringPool(), nullptr,
{{StubProt, {static_cast<size_t>(StubBytes), Align(PageSize)}}, {{StubProt, {static_cast<size_t>(StubBytes), Align(PageSize)}},
{PtrProt, {static_cast<size_t>(PtrBytes), Align(PageSize)}}}); {PtrProt, {static_cast<size_t>(PtrBytes), Align(PageSize)}}});

10
llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp
View File

@@ -13,6 +13,7 @@
#include "llvm/ExecutionEngine/Orc/LoadLinkableFile.h" #include "llvm/ExecutionEngine/Orc/LoadLinkableFile.h"
#include "llvm/ExecutionEngine/Orc/MachO.h" #include "llvm/ExecutionEngine/Orc/MachO.h"
#include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h" #include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h"
#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
#include "llvm/IR/Constants.h" #include "llvm/IR/Constants.h"
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/GlobalVariable.h" #include "llvm/IR/GlobalVariable.h"
@@ -559,8 +560,8 @@ DLLImportDefinitionGenerator::createStubsGraph(const SymbolMap &Resolved) {
return Endianness.takeError(); return Endianness.takeError();
auto G = std::make_unique<jitlink::LinkGraph>( auto G = std::make_unique<jitlink::LinkGraph>(
"<DLLIMPORT_STUBS>", TT, *PointerSize, *Endianness, "<DLLIMPORT_STUBS>", ES.getSymbolStringPool(), TT, *PointerSize,
jitlink::getGenericEdgeKindName); *Endianness, jitlink::getGenericEdgeKindName);
jitlink::Section &Sec = jitlink::Section &Sec =
G->createSection(getSectionName(), MemProt::Read | MemProt::Exec); G->createSection(getSectionName(), MemProt::Read | MemProt::Exec);
@@ -572,9 +573,8 @@ DLLImportDefinitionGenerator::createStubsGraph(const SymbolMap &Resolved) {
// Create __imp_ symbol // Create __imp_ symbol
jitlink::Symbol &Ptr = jitlink::Symbol &Ptr =
jitlink::x86_64::createAnonymousPointer(*G, Sec, &Target); jitlink::x86_64::createAnonymousPointer(*G, Sec, &Target);
auto NameCopy = G->allocateContent(Twine(getImpPrefix()) + *KV.first); auto name = getImpPrefix() + *KV.first;
StringRef NameCopyRef = StringRef(NameCopy.data(), NameCopy.size()); Ptr.setName(G->intern((Twine(getImpPrefix()) + *KV.first).str()));
Ptr.setName(NameCopyRef);
Ptr.setLinkage(jitlink::Linkage::Strong); Ptr.setLinkage(jitlink::Linkage::Strong);
Ptr.setScope(jitlink::Scope::Default); Ptr.setScope(jitlink::Scope::Default);

8
llvm/lib/ExecutionEngine/Orc/JITLinkRedirectableSymbolManager.cpp
View File

@@ -27,8 +27,8 @@ void JITLinkRedirectableSymbolManager::emitRedirectableSymbols(
Triple TT = ES.getTargetTriple(); Triple TT = ES.getTargetTriple();
auto G = std::make_unique<jitlink::LinkGraph>( auto G = std::make_unique<jitlink::LinkGraph>(
("<indirect stubs graph #" + Twine(++StubGraphIdx) + ">").str(), TT, ("<indirect stubs graph #" + Twine(++StubGraphIdx) + ">").str(),
TT.isArch64Bit() ? 8 : 4, ES.getSymbolStringPool(), TT, TT.isArch64Bit() ? 8 : 4,
TT.isLittleEndian() ? endianness::little : endianness::big, TT.isLittleEndian() ? endianness::little : endianness::big,
jitlink::getGenericEdgeKindName); jitlink::getGenericEdgeKindName);
auto &PointerSection = auto &PointerSection =
@@ -46,10 +46,10 @@ void JITLinkRedirectableSymbolManager::emitRedirectableSymbols(
auto PtrName = ES.intern((*Name + StubSuffix).str()); auto PtrName = ES.intern((*Name + StubSuffix).str());
auto &Ptr = AnonymousPtrCreator(*G, PointerSection, TargetSym, 0); auto &Ptr = AnonymousPtrCreator(*G, PointerSection, TargetSym, 0);
Ptr.setName(*PtrName); Ptr.setName(PtrName);
Ptr.setScope(jitlink::Scope::Hidden); Ptr.setScope(jitlink::Scope::Hidden);
auto &Stub = PtrJumpStubCreator(*G, StubsSection, Ptr); auto &Stub = PtrJumpStubCreator(*G, StubsSection, Ptr);
Stub.setName(*Name); Stub.setName(Name);
Stub.setScope(jitlink::Scope::Default); Stub.setScope(jitlink::Scope::Default);
NewSymbols[std::move(PtrName)] = JITSymbolFlags(); NewSymbols[std::move(PtrName)] = JITSymbolFlags();
} }

4
llvm/lib/ExecutionEngine/Orc/LazyObjectLinkingLayer.cpp
View File

@@ -60,10 +60,10 @@ private:
for (auto *Sym : G.defined_symbols()) { for (auto *Sym : G.defined_symbols()) {
if (!Sym->hasName()) if (!Sym->hasName())
continue; continue;
auto I = SymsToRename.find(Sym->getName()); auto I = SymsToRename.find(*Sym->getName());
if (I == SymsToRename.end()) if (I == SymsToRename.end())
continue; continue;
Sym->setName(G.allocateName(*I->second)); Sym->setName(G.intern(G.allocateName(*I->second)));
} }
return Error::success(); return Error::success();

32
llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp
View File

@@ -108,9 +108,9 @@ std::unique_ptr<jitlink::LinkGraph> createPlatformGraph(MachOPlatform &MOP,
llvm_unreachable("Unrecognized architecture"); llvm_unreachable("Unrecognized architecture");
} }
return std::make_unique<jitlink::LinkGraph>(std::move(Name), TT, PointerSize, return std::make_unique<jitlink::LinkGraph>(
Endianness, std::move(Name), MOP.getExecutionSession().getSymbolStringPool(), TT,
jitlink::getGenericEdgeKindName); PointerSize, Endianness, jitlink::getGenericEdgeKindName);
} }
// Creates a Bootstrap-Complete LinkGraph to run deferred actions. // Creates a Bootstrap-Complete LinkGraph to run deferred actions.
@@ -893,14 +893,14 @@ Error MachOPlatform::MachOPlatformPlugin::
for (auto *Sym : G.defined_symbols()) { for (auto *Sym : G.defined_symbols()) {
for (auto &RTSym : RuntimeSymbols) { for (auto &RTSym : RuntimeSymbols) {
if (Sym->hasName() && Sym->getName() == RTSym.first) { if (Sym->hasName() && *Sym->getName() == RTSym.first) {
if (*RTSym.second) if (*RTSym.second)
return make_error<StringError>( return make_error<StringError>(
"Duplicate " + RTSym.first + "Duplicate " + RTSym.first +
" detected during MachOPlatform bootstrap", " detected during MachOPlatform bootstrap",
inconvertibleErrorCode()); inconvertibleErrorCode());
if (Sym->getName() == *MP.MachOHeaderStartSymbol) if (Sym->getName() == MP.MachOHeaderStartSymbol)
RegisterMachOHeader = true; RegisterMachOHeader = true;
*RTSym.second = Sym->getAddress(); *RTSym.second = Sym->getAddress();
@@ -936,7 +936,7 @@ Error MachOPlatform::MachOPlatformPlugin::bootstrapPipelineEnd(
Error MachOPlatform::MachOPlatformPlugin::associateJITDylibHeaderSymbol( Error MachOPlatform::MachOPlatformPlugin::associateJITDylibHeaderSymbol(
jitlink::LinkGraph &G, MaterializationResponsibility &MR) { jitlink::LinkGraph &G, MaterializationResponsibility &MR) {
auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) { auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) {
return Sym->getName() == *MP.MachOHeaderStartSymbol; return Sym->getName() == MP.MachOHeaderStartSymbol;
}); });
assert(I != G.defined_symbols().end() && "Missing MachO header start symbol"); assert(I != G.defined_symbols().end() && "Missing MachO header start symbol");
@@ -1175,11 +1175,13 @@ Error MachOPlatform::MachOPlatformPlugin::mergeImageInfoFlags(
Error MachOPlatform::MachOPlatformPlugin::fixTLVSectionsAndEdges( Error MachOPlatform::MachOPlatformPlugin::fixTLVSectionsAndEdges(
jitlink::LinkGraph &G, JITDylib &JD) { jitlink::LinkGraph &G, JITDylib &JD) {
auto TLVBootStrapSymbolName = G.intern("__tlv_bootstrap");
// Rename external references to __tlv_bootstrap to ___orc_rt_tlv_get_addr. // Rename external references to __tlv_bootstrap to ___orc_rt_tlv_get_addr.
for (auto *Sym : G.external_symbols()) for (auto *Sym : G.external_symbols())
if (Sym->getName() == "__tlv_bootstrap") { if (Sym->getName() == TLVBootStrapSymbolName) {
Sym->setName("___orc_rt_macho_tlv_get_addr"); auto TLSGetADDR =
MP.getExecutionSession().intern("___orc_rt_macho_tlv_get_addr");
Sym->setName(std::move(TLSGetADDR));
break; break;
} }
@@ -1499,19 +1501,19 @@ Error MachOPlatform::MachOPlatformPlugin::populateObjCRuntimeObject(
// Look for an existing __objc_imageinfo symbol. // Look for an existing __objc_imageinfo symbol.
jitlink::Symbol *ObjCImageInfoSym = nullptr; jitlink::Symbol *ObjCImageInfoSym = nullptr;
for (auto *Sym : G.external_symbols()) for (auto *Sym : G.external_symbols())
if (Sym->getName() == ObjCImageInfoSymbolName) { if (Sym->hasName() && *Sym->getName() == ObjCImageInfoSymbolName) {
ObjCImageInfoSym = Sym; ObjCImageInfoSym = Sym;
break; break;
} }
if (!ObjCImageInfoSym) if (!ObjCImageInfoSym)
for (auto *Sym : G.absolute_symbols()) for (auto *Sym : G.absolute_symbols())
if (Sym->getName() == ObjCImageInfoSymbolName) { if (Sym->hasName() && *Sym->getName() == ObjCImageInfoSymbolName) {
ObjCImageInfoSym = Sym; ObjCImageInfoSym = Sym;
break; break;
} }
if (!ObjCImageInfoSym) if (!ObjCImageInfoSym)
for (auto *Sym : G.defined_symbols()) for (auto *Sym : G.defined_symbols())
if (Sym->hasName() && Sym->getName() == ObjCImageInfoSymbolName) { if (Sym->hasName() && *Sym->getName() == ObjCImageInfoSymbolName) {
ObjCImageInfoSym = Sym; ObjCImageInfoSym = Sym;
std::optional<uint32_t> Flags; std::optional<uint32_t> Flags;
{ {
@@ -1652,11 +1654,11 @@ Error MachOPlatform::MachOPlatformPlugin::prepareSymbolTableRegistration(
if (!Sym->hasName()) if (!Sym->hasName())
continue; continue;
auto I = ExistingStrings.find(Sym->getName()); auto I = ExistingStrings.find(*Sym->getName());
if (I == ExistingStrings.end()) { if (I == ExistingStrings.end()) {
auto &NameBlock = G.createMutableContentBlock( auto &NameBlock = G.createMutableContentBlock(
*CStringSec, G.allocateCString(Sym->getName()), orc::ExecutorAddr(), *CStringSec, G.allocateCString(*Sym->getName()),
1, 0); orc::ExecutorAddr(), 1, 0);
auto &SymbolNameSym = G.addAnonymousSymbol( auto &SymbolNameSym = G.addAnonymousSymbol(
NameBlock, 0, NameBlock.getSize(), false, true); NameBlock, 0, NameBlock.getSize(), false, true);
JITSymTabInfo.push_back({Sym, &SymbolNameSym}); JITSymTabInfo.push_back({Sym, &SymbolNameSym});

2
llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp
View File

@@ -129,7 +129,7 @@ getELFObjectFileSymbolInfo(ExecutionSession &ES,
if (Sym.getBinding() == ELF::STB_GNU_UNIQUE) if (Sym.getBinding() == ELF::STB_GNU_UNIQUE)
*SymFlags |= JITSymbolFlags::Weak; *SymFlags |= JITSymbolFlags::Weak;
I.SymbolFlags[ES.intern(*Name)] = std::move(*SymFlags); I.SymbolFlags[ES.intern(std::move(*Name))] = std::move(*SymFlags);
} }
SymbolStringPtr InitSymbol; SymbolStringPtr InitSymbol;

57
llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp
View File

@@ -100,8 +100,7 @@ private:
return; return;
assert(Sym->hasName() && "Anonymous non-local symbol?"); assert(Sym->hasName() && "Anonymous non-local symbol?");
LGI.SymbolFlags[ES.intern(Sym->getName())] = LGI.SymbolFlags[Sym->getName()] = getJITSymbolFlagsForSymbol(*Sym);
getJITSymbolFlagsForSymbol(*Sym);
}; };
for (auto *Sym : G.defined_symbols()) for (auto *Sym : G.defined_symbols())
@@ -129,7 +128,7 @@ private:
void discard(const JITDylib &JD, const SymbolStringPtr &Name) override { void discard(const JITDylib &JD, const SymbolStringPtr &Name) override {
for (auto *Sym : G->defined_symbols()) for (auto *Sym : G->defined_symbols())
if (Sym->getName() == *Name) { if (Sym->getName() == Name) {
assert(Sym->getLinkage() == Linkage::Weak && assert(Sym->getLinkage() == Linkage::Weak &&
"Discarding non-weak definition"); "Discarding non-weak definition");
G->makeExternal(*Sym); G->makeExternal(*Sym);
@@ -204,7 +203,7 @@ public:
LookupFlags = orc::SymbolLookupFlags::WeaklyReferencedSymbol; LookupFlags = orc::SymbolLookupFlags::WeaklyReferencedSymbol;
break; break;
} }
LookupSet.add(ES.intern(KV.first), LookupFlags); LookupSet.add(KV.first, LookupFlags);
} }
// OnResolve -- De-intern the symbols and pass the result to the linker. // OnResolve -- De-intern the symbols and pass the result to the linker.
@@ -215,7 +214,7 @@ public:
else { else {
AsyncLookupResult LR; AsyncLookupResult LR;
for (auto &KV : *Result) for (auto &KV : *Result)
LR[*KV.first] = KV.second; LR[KV.first] = KV.second;
LookupContinuation->run(std::move(LR)); LookupContinuation->run(std::move(LR));
} }
}; };
@@ -231,7 +230,6 @@ public:
} }
Error notifyResolved(LinkGraph &G) override { Error notifyResolved(LinkGraph &G) override {
auto &ES = Layer.getExecutionSession();
SymbolFlagsMap ExtraSymbolsToClaim; SymbolFlagsMap ExtraSymbolsToClaim;
bool AutoClaim = Layer.AutoClaimObjectSymbols; bool AutoClaim = Layer.AutoClaimObjectSymbols;
@@ -239,27 +237,25 @@ public:
SymbolMap InternedResult; SymbolMap InternedResult;
for (auto *Sym : G.defined_symbols()) for (auto *Sym : G.defined_symbols())
if (Sym->getScope() < Scope::SideEffectsOnly) { if (Sym->getScope() < Scope::SideEffectsOnly) {
auto InternedName = ES.intern(Sym->getName());
auto Ptr = getJITSymbolPtrForSymbol(*Sym, G.getTargetTriple()); auto Ptr = getJITSymbolPtrForSymbol(*Sym, G.getTargetTriple());
auto Flags = getJITSymbolFlagsForSymbol(*Sym); auto Flags = getJITSymbolFlagsForSymbol(*Sym);
InternedResult[InternedName] = {Ptr, Flags}; InternedResult[Sym->getName()] = {Ptr, Flags};
if (AutoClaim && !MR->getSymbols().count(InternedName)) { if (AutoClaim && !MR->getSymbols().count(Sym->getName())) {
assert(!ExtraSymbolsToClaim.count(InternedName) && assert(!ExtraSymbolsToClaim.count(Sym->getName()) &&
"Duplicate symbol to claim?"); "Duplicate symbol to claim?");
ExtraSymbolsToClaim[InternedName] = Flags; ExtraSymbolsToClaim[Sym->getName()] = Flags;
} }
} }
for (auto *Sym : G.absolute_symbols()) for (auto *Sym : G.absolute_symbols())
if (Sym->getScope() < Scope::SideEffectsOnly) { if (Sym->getScope() < Scope::SideEffectsOnly) {
auto InternedName = ES.intern(Sym->getName());
auto Ptr = getJITSymbolPtrForSymbol(*Sym, G.getTargetTriple()); auto Ptr = getJITSymbolPtrForSymbol(*Sym, G.getTargetTriple());
auto Flags = getJITSymbolFlagsForSymbol(*Sym); auto Flags = getJITSymbolFlagsForSymbol(*Sym);
InternedResult[InternedName] = {Ptr, Flags}; InternedResult[Sym->getName()] = {Ptr, Flags};
if (AutoClaim && !MR->getSymbols().count(InternedName)) { if (AutoClaim && !MR->getSymbols().count(Sym->getName())) {
assert(!ExtraSymbolsToClaim.count(InternedName) && assert(!ExtraSymbolsToClaim.count(Sym->getName()) &&
"Duplicate symbol to claim?"); "Duplicate symbol to claim?");
ExtraSymbolsToClaim[InternedName] = Flags; ExtraSymbolsToClaim[Sym->getName()] = Flags;
} }
} }
@@ -379,19 +375,16 @@ public:
private: private:
Error claimOrExternalizeWeakAndCommonSymbols(LinkGraph &G) { Error claimOrExternalizeWeakAndCommonSymbols(LinkGraph &G) {
auto &ES = Layer.getExecutionSession();
SymbolFlagsMap NewSymbolsToClaim; SymbolFlagsMap NewSymbolsToClaim;
std::vector<std::pair<SymbolStringPtr, Symbol *>> NameToSym; std::vector<std::pair<SymbolStringPtr, Symbol *>> NameToSym;
auto ProcessSymbol = [&](Symbol *Sym) { auto ProcessSymbol = [&](Symbol *Sym) {
if (Sym->hasName() && Sym->getLinkage() == Linkage::Weak && if (Sym->hasName() && Sym->getLinkage() == Linkage::Weak &&
Sym->getScope() != Scope::Local) { Sym->getScope() != Scope::Local) {
auto Name = ES.intern(Sym->getName()); if (!MR->getSymbols().count(Sym->getName())) {
if (!MR->getSymbols().count(ES.intern(Sym->getName()))) { NewSymbolsToClaim[Sym->getName()] =
NewSymbolsToClaim[Name] =
getJITSymbolFlagsForSymbol(*Sym) | JITSymbolFlags::Weak; getJITSymbolFlagsForSymbol(*Sym) | JITSymbolFlags::Weak;
NameToSym.push_back(std::make_pair(std::move(Name), Sym)); NameToSym.push_back(std::make_pair(Sym->getName(), Sym));
} }
} }
}; };
@@ -421,9 +414,8 @@ private:
} }
Error markResponsibilitySymbolsLive(LinkGraph &G) const { Error markResponsibilitySymbolsLive(LinkGraph &G) const {
auto &ES = Layer.getExecutionSession();
for (auto *Sym : G.defined_symbols()) for (auto *Sym : G.defined_symbols())
if (Sym->hasName() && MR->getSymbols().count(ES.intern(Sym->getName()))) if (Sym->hasName() && MR->getSymbols().count(Sym->getName()))
Sym->setLive(true); Sym->setLive(true);
return Error::success(); return Error::success();
} }
@@ -558,15 +550,6 @@ private:
// SymbolDependenceGroups (in the SymbolDepGroups member), ready for use in // SymbolDependenceGroups (in the SymbolDepGroups member), ready for use in
// the upcoming notifyFinalized call. // the upcoming notifyFinalized call.
auto &TargetJD = MR->getTargetJITDylib(); auto &TargetJD = MR->getTargetJITDylib();
auto &ES = TargetJD.getExecutionSession();
DenseMap<Symbol *, SymbolStringPtr> InternedNames;
auto GetInternedName = [&](Symbol *S) {
auto &Name = InternedNames[S];
if (!Name)
Name = ES.intern(S->getName());
return Name;
};
for (auto &[B, BI] : BlockInfos) { for (auto &[B, BI] : BlockInfos) {
if (!BI.Defs.empty()) { if (!BI.Defs.empty()) {
@@ -574,10 +557,10 @@ private:
auto &SDG = SymbolDepGroups.back(); auto &SDG = SymbolDepGroups.back();
for (auto *Def : BI.Defs) for (auto *Def : BI.Defs)
SDG.Symbols.insert(GetInternedName(Def)); SDG.Symbols.insert(Def->getName());
for (auto *Dep : BI.SymbolDeps) { for (auto *Dep : BI.SymbolDeps) {
auto DepName = GetInternedName(Dep); auto DepName = Dep->getName();
if (Dep->isDefined()) if (Dep->isDefined())
SDG.Dependencies[&TargetJD].insert(std::move(DepName)); SDG.Dependencies[&TargetJD].insert(std::move(DepName));
else { else {
@@ -643,8 +626,8 @@ void ObjectLinkingLayer::emit(std::unique_ptr<MaterializationResponsibility> R,
auto Ctx = std::make_unique<ObjectLinkingLayerJITLinkContext>( auto Ctx = std::make_unique<ObjectLinkingLayerJITLinkContext>(
*this, std::move(R), std::move(O)); *this, std::move(R), std::move(O));
if (auto G = createLinkGraphFromObject(
if (auto G = createLinkGraphFromObject(ObjBuffer)) { ObjBuffer, getExecutionSession().getSymbolStringPool())) {
Ctx->notifyMaterializing(**G); Ctx->notifyMaterializing(**G);
link(std::move(*G), std::move(Ctx)); link(std::move(*G), std::move(Ctx));
} else { } else {

1
llvm/lib/ExecutionEngine/Orc/SectCreate.cpp
View File

@@ -18,6 +18,7 @@ void SectCreateMaterializationUnit::materialize(
std::unique_ptr<MaterializationResponsibility> R) { std::unique_ptr<MaterializationResponsibility> R) {
auto G = std::make_unique<LinkGraph>( auto G = std::make_unique<LinkGraph>(
"orc_sectcreate_" + SectName, "orc_sectcreate_" + SectName,
ObjLinkingLayer.getExecutionSession().getSymbolStringPool(),
ObjLinkingLayer.getExecutionSession().getTargetTriple(), ObjLinkingLayer.getExecutionSession().getTargetTriple(),
getGenericEdgeKindName); getGenericEdgeKindName);

1
llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
View File

@@ -14,6 +14,7 @@
#include "Targets/RuntimeDyldELFMips.h" #include "Targets/RuntimeDyldELFMips.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/BinaryFormat/ELF.h" #include "llvm/BinaryFormat/ELF.h"
#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
#include "llvm/Object/ELFObjectFile.h" #include "llvm/Object/ELFObjectFile.h"
#include "llvm/Object/ObjectFile.h" #include "llvm/Object/ObjectFile.h"
#include "llvm/Support/Endian.h" #include "llvm/Support/Endian.h"

1
llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
View File

@@ -15,6 +15,7 @@
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringMap.h"
#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
#include "llvm/ExecutionEngine/RTDyldMemoryManager.h" #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
#include "llvm/ExecutionEngine/RuntimeDyld.h" #include "llvm/ExecutionEngine/RuntimeDyld.h"
#include "llvm/ExecutionEngine/RuntimeDyldChecker.h" #include "llvm/ExecutionEngine/RuntimeDyldChecker.h"

42
llvm/tools/llvm-jitlink/llvm-jitlink.cpp
View File

@@ -365,7 +365,7 @@ static raw_ostream &
operator<<(raw_ostream &OS, const Session::SymbolInfoMap &SIM) { operator<<(raw_ostream &OS, const Session::SymbolInfoMap &SIM) {
OS << "Symbols:\n"; OS << "Symbols:\n";
for (auto &SKV : SIM) for (auto &SKV : SIM)
OS << " \"" << SKV.first() << "\" " << SKV.second << "\n"; OS << " \"" << SKV.first << "\" " << SKV.second << "\n";
return OS; return OS;
} }
@@ -416,8 +416,8 @@ static Error applyHarnessPromotions(Session &S, LinkGraph &G) {
continue; continue;
if (Sym->getLinkage() == Linkage::Weak) { if (Sym->getLinkage() == Linkage::Weak) {
if (!S.CanonicalWeakDefs.count(Sym->getName()) || if (!S.CanonicalWeakDefs.count(*Sym->getName()) ||
S.CanonicalWeakDefs[Sym->getName()] != G.getName()) { S.CanonicalWeakDefs[*Sym->getName()] != G.getName()) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << " Externalizing weak symbol " << Sym->getName() << "\n"; dbgs() << " Externalizing weak symbol " << Sym->getName() << "\n";
}); });
@@ -426,18 +426,18 @@ static Error applyHarnessPromotions(Session &S, LinkGraph &G) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << " Making weak symbol " << Sym->getName() << " strong\n"; dbgs() << " Making weak symbol " << Sym->getName() << " strong\n";
}); });
if (S.HarnessExternals.count(Sym->getName())) if (S.HarnessExternals.count(*Sym->getName()))
Sym->setScope(Scope::Default); Sym->setScope(Scope::Default);
else else
Sym->setScope(Scope::Hidden); Sym->setScope(Scope::Hidden);
Sym->setLinkage(Linkage::Strong); Sym->setLinkage(Linkage::Strong);
} }
} else if (S.HarnessExternals.count(Sym->getName())) { } else if (S.HarnessExternals.count(*Sym->getName())) {
LLVM_DEBUG(dbgs() << " Promoting " << Sym->getName() << "\n"); LLVM_DEBUG(dbgs() << " Promoting " << Sym->getName() << "\n");
Sym->setScope(Scope::Default); Sym->setScope(Scope::Default);
Sym->setLive(true); Sym->setLive(true);
continue; continue;
} else if (S.HarnessDefinitions.count(Sym->getName())) { } else if (S.HarnessDefinitions.count(*Sym->getName())) {
LLVM_DEBUG(dbgs() << " Externalizing " << Sym->getName() << "\n"); LLVM_DEBUG(dbgs() << " Externalizing " << Sym->getName() << "\n");
DefinitionsToRemove.push_back(Sym); DefinitionsToRemove.push_back(Sym);
} }
@@ -1306,9 +1306,9 @@ Error Session::FileInfo::registerGOTEntry(
auto TS = GetSymbolTarget(G, Sym.getBlock()); auto TS = GetSymbolTarget(G, Sym.getBlock());
if (!TS) if (!TS)
return TS.takeError(); return TS.takeError();
GOTEntryInfos[TS->getName()] = {Sym.getSymbolContent(), GOTEntryInfos[*TS->getName()] = {Sym.getSymbolContent(),
Sym.getAddress().getValue(), Sym.getAddress().getValue(),
Sym.getTargetFlags()}; Sym.getTargetFlags()};
return Error::success(); return Error::success();
} }
@@ -1322,7 +1322,7 @@ Error Session::FileInfo::registerStubEntry(
if (!TS) if (!TS)
return TS.takeError(); return TS.takeError();
SmallVectorImpl<MemoryRegionInfo> &Entry = StubInfos[TS->getName()]; SmallVectorImpl<MemoryRegionInfo> &Entry = StubInfos[*TS->getName()];
Entry.insert(Entry.begin(), Entry.insert(Entry.begin(),
{Sym.getSymbolContent(), Sym.getAddress().getValue(), {Sym.getSymbolContent(), Sym.getAddress().getValue(),
Sym.getTargetFlags()}); Sym.getTargetFlags()});
@@ -1340,7 +1340,7 @@ Error Session::FileInfo::registerMultiStubEntry(
if (!Target) if (!Target)
return Target.takeError(); return Target.takeError();
SmallVectorImpl<MemoryRegionInfo> &Entry = StubInfos[Target->getName()]; SmallVectorImpl<MemoryRegionInfo> &Entry = StubInfos[*Target->getName()];
Entry.emplace_back(Sym.getSymbolContent(), Sym.getAddress().getValue(), Entry.emplace_back(Sym.getSymbolContent(), Sym.getAddress().getValue(),
Sym.getTargetFlags()); Sym.getTargetFlags());
@@ -1485,15 +1485,16 @@ Session::findGOTEntryInfo(StringRef FileName, StringRef TargetName) {
return GOTInfoItr->second; return GOTInfoItr->second;
} }
bool Session::isSymbolRegistered(StringRef SymbolName) { bool Session::isSymbolRegistered(const orc::SymbolStringPtr &SymbolName) {
return SymbolInfos.count(SymbolName); return SymbolInfos.count(SymbolName);
} }
Expected<Session::MemoryRegionInfo &> Expected<Session::MemoryRegionInfo &>
Session::findSymbolInfo(StringRef SymbolName, Twine ErrorMsgStem) { Session::findSymbolInfo(const orc::SymbolStringPtr &SymbolName,
Twine ErrorMsgStem) {
auto SymInfoItr = SymbolInfos.find(SymbolName); auto SymInfoItr = SymbolInfos.find(SymbolName);
if (SymInfoItr == SymbolInfos.end()) if (SymInfoItr == SymbolInfos.end())
return make_error<StringError>(ErrorMsgStem + ": symbol " + SymbolName + return make_error<StringError>(ErrorMsgStem + ": symbol " + *SymbolName +
" not found", " not found",
inconvertibleErrorCode()); inconvertibleErrorCode());
return SymInfoItr->second; return SymInfoItr->second;
@@ -1719,12 +1720,13 @@ static Error addAbsoluteSymbols(Session &S,
AbsDefStmt + "\"", AbsDefStmt + "\"",
inconvertibleErrorCode()); inconvertibleErrorCode());
ExecutorSymbolDef AbsDef(ExecutorAddr(Addr), JITSymbolFlags::Exported); ExecutorSymbolDef AbsDef(ExecutorAddr(Addr), JITSymbolFlags::Exported);
if (auto Err = JD.define(absoluteSymbols({{S.ES.intern(Name), AbsDef}}))) auto InternedName = S.ES.intern(Name);
if (auto Err = JD.define(absoluteSymbols({{InternedName, AbsDef}})))
return Err; return Err;
// Register the absolute symbol with the session symbol infos. // Register the absolute symbol with the session symbol infos.
S.SymbolInfos[Name] = {ArrayRef<char>(), Addr, S.SymbolInfos[InternedName] = {ArrayRef<char>(), Addr,
AbsDef.getFlags().getTargetFlags()}; AbsDef.getFlags().getTargetFlags()};
} }
return Error::success(); return Error::success();
@@ -2330,11 +2332,13 @@ static Error runChecks(Session &S, Triple TT, SubtargetFeatures Features) {
LLVM_DEBUG(dbgs() << "Running checks...\n"); LLVM_DEBUG(dbgs() << "Running checks...\n");
auto IsSymbolValid = [&S](StringRef Symbol) { auto IsSymbolValid = [&S](StringRef Symbol) {
return S.isSymbolRegistered(Symbol); auto InternedSymbol = S.ES.getSymbolStringPool()->intern(Symbol);
return S.isSymbolRegistered(InternedSymbol);
}; };
auto GetSymbolInfo = [&S](StringRef Symbol) { auto GetSymbolInfo = [&S](StringRef Symbol) {
return S.findSymbolInfo(Symbol, "Can not get symbol info"); auto InternedSymbol = S.ES.getSymbolStringPool()->intern(Symbol);
return S.findSymbolInfo(InternedSymbol, "Can not get symbol info");
}; };
auto GetSectionInfo = [&S](StringRef FileName, StringRef SectionName) { auto GetSectionInfo = [&S](StringRef FileName, StringRef SectionName) {

7
llvm/tools/llvm-jitlink/llvm-jitlink.h
View File

@@ -78,7 +78,6 @@ struct Session {
using LinkGraph = jitlink::LinkGraph; using LinkGraph = jitlink::LinkGraph;
using GetSymbolTargetFunction = using GetSymbolTargetFunction =
unique_function<Expected<Symbol &>(LinkGraph &G, jitlink::Block &)>; unique_function<Expected<Symbol &>(LinkGraph &G, jitlink::Block &)>;
Error registerGOTEntry(LinkGraph &G, Symbol &Sym, Error registerGOTEntry(LinkGraph &G, Symbol &Sym,
GetSymbolTargetFunction GetSymbolTarget); GetSymbolTargetFunction GetSymbolTarget);
Error registerStubEntry(LinkGraph &G, Symbol &Sym, Error registerStubEntry(LinkGraph &G, Symbol &Sym,
@@ -88,7 +87,7 @@ struct Session {
}; };
using DynLibJDMap = std::map<std::string, orc::JITDylib *, std::less<>>; using DynLibJDMap = std::map<std::string, orc::JITDylib *, std::less<>>;
using SymbolInfoMap = StringMap<MemoryRegionInfo>; using SymbolInfoMap = DenseMap<orc::SymbolStringPtr, MemoryRegionInfo>;
using FileInfoMap = StringMap<FileInfo>; using FileInfoMap = StringMap<FileInfo>;
Expected<orc::JITDylib *> getOrLoadDynamicLibrary(StringRef LibPath); Expected<orc::JITDylib *> getOrLoadDynamicLibrary(StringRef LibPath);
@@ -111,8 +110,8 @@ struct Session {
Expected<MemoryRegionInfo &> findGOTEntryInfo(StringRef FileName, Expected<MemoryRegionInfo &> findGOTEntryInfo(StringRef FileName,
StringRef TargetName); StringRef TargetName);
bool isSymbolRegistered(StringRef Name); bool isSymbolRegistered(const orc::SymbolStringPtr &Name);
Expected<MemoryRegionInfo &> findSymbolInfo(StringRef SymbolName, Expected<MemoryRegionInfo &> findSymbolInfo(const orc::SymbolStringPtr &Name,
Twine ErrorMsgStem); Twine ErrorMsgStem);
DynLibJDMap DynLibJDs; DynLibJDMap DynLibJDs;

18
llvm/unittests/ExecutionEngine/JITLink/AArch32ErrorTests.cpp
View File

@@ -6,10 +6,10 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <llvm/ExecutionEngine/JITLink/aarch32.h> #include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
#include "llvm/Testing/Support/Error.h" #include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <llvm/ExecutionEngine/JITLink/aarch32.h>
using namespace llvm; using namespace llvm;
using namespace llvm::jitlink; using namespace llvm::jitlink;
@@ -18,9 +18,10 @@ using namespace llvm::support;
using namespace llvm::support::endian; using namespace llvm::support::endian;
constexpr unsigned PointerSize = 4; constexpr unsigned PointerSize = 4;
auto G = std::make_unique<LinkGraph>("foo", Triple("armv7-linux-gnueabi"), auto G = std::make_unique<LinkGraph>(
PointerSize, endianness::little, "foo", std::make_shared<orc::SymbolStringPool>(),
aarch32::getEdgeKindName); Triple("armv7-linux-gnueabi"), PointerSize, endianness::little,
aarch32::getEdgeKindName);
auto &Sec = auto &Sec =
G->createSection("__data", orc::MemProt::Read | orc::MemProt::Write); G->createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
@@ -46,9 +47,10 @@ public:
static void SetUpTestCase() {} static void SetUpTestCase() {}
void SetUp() override { void SetUp() override {
G = std::make_unique<LinkGraph>("foo", Triple("armv7-linux-gnueabi"), G = std::make_unique<LinkGraph>(
PointerSize, endianness::little, "foo", std::make_shared<orc::SymbolStringPool>(),
aarch32::getEdgeKindName); Triple("armv7-linux-gnueabi"), PointerSize, endianness::little,
aarch32::getEdgeKindName);
S = &G->createSection("__data", orc::MemProt::Read | orc::MemProt::Write); S = &G->createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
} }

10
llvm/unittests/ExecutionEngine/JITLink/EHFrameSupportTests.cpp
View File

@@ -172,7 +172,8 @@ TEST(EHFrameCFIBlockInspector, BasicSuccessCase) {
// (3) Each FDE has an edge pointing to the CIE at the correct offset. // (3) Each FDE has an edge pointing to the CIE at the correct offset.
// (4) Each function has exactly one FDE pointing at it. // (4) Each function has exactly one FDE pointing at it.
auto G = cantFail(createLinkGraphFromMachOObject_arm64(TestObject)); auto G = cantFail(createLinkGraphFromMachOObject_arm64(
TestObject, std::make_shared<orc::SymbolStringPool>()));
cantFail(createEHFrameSplitterPass_MachO_arm64()(*G)); cantFail(createEHFrameSplitterPass_MachO_arm64()(*G));
cantFail(createEHFrameEdgeFixerPass_MachO_arm64()(*G)); cantFail(createEHFrameEdgeFixerPass_MachO_arm64()(*G));
@@ -211,7 +212,7 @@ TEST(EHFrameCFIBlockInspector, BasicSuccessCase) {
ASSERT_TRUE(!!CFIBI.getPCBeginEdge()); ASSERT_TRUE(!!CFIBI.getPCBeginEdge());
auto &PCBeginTarget = CFIBI.getPCBeginEdge()->getTarget(); auto &PCBeginTarget = CFIBI.getPCBeginEdge()->getTarget();
ASSERT_TRUE(PCBeginTarget.hasName()); ASSERT_TRUE(PCBeginTarget.hasName());
Targets.insert(PCBeginTarget.getName()); Targets.insert(*PCBeginTarget.getName());
// If the FDE points at CIEs[0] (the CIE without a personality) then it // If the FDE points at CIEs[0] (the CIE without a personality) then it
// should not have an LSDA. If it points to CIEs[1] then it should have // should not have an LSDA. If it points to CIEs[1] then it should have
@@ -232,11 +233,12 @@ TEST(EHFrameCFIBlockInspector, BasicSuccessCase) {
TEST(EHFrameCFIBlockInspector, ExternalPCBegin) { TEST(EHFrameCFIBlockInspector, ExternalPCBegin) {
// Check that we don't crash if we transform the target of an FDE into an // Check that we don't crash if we transform the target of an FDE into an
// external symbol before running edge-fixing. // external symbol before running edge-fixing.
auto G = cantFail(createLinkGraphFromMachOObject_arm64(TestObject)); auto G = cantFail(createLinkGraphFromMachOObject_arm64(
TestObject, std::make_shared<orc::SymbolStringPool>()));
// Make '_a' external. // Make '_a' external.
for (auto *Sym : G->defined_symbols()) for (auto *Sym : G->defined_symbols())
if (Sym->hasName() && Sym->getName() == "_a") { if (Sym->hasName() && *Sym->getName() == "_a") {
G->makeExternal(*Sym); G->makeExternal(*Sym);
break; break;
} }

7
llvm/unittests/ExecutionEngine/JITLink/JITLinkTestUtils.cpp
View File

@@ -92,9 +92,10 @@ void defaultCtxSetup(MockJITLinkContext &) {}
TEST(JITLinkMocks, SmokeTest) { TEST(JITLinkMocks, SmokeTest) {
// Check that the testing infrastructure defaults can "link" a graph // Check that the testing infrastructure defaults can "link" a graph
// successfully. // successfully.
auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8, auto G = std::make_unique<LinkGraph>(
llvm::endianness::little, "foo", std::make_shared<orc::SymbolStringPool>(),
getGenericEdgeKindName); Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName);
ArrayRef<char> Content = "hello, world!"; ArrayRef<char> Content = "hello, world!";
auto &Sec = auto &Sec =

49
llvm/unittests/ExecutionEngine/JITLink/LinkGraphTests.cpp
View File

@@ -21,7 +21,8 @@ using namespace llvm::jitlink;
TEST(LinkGraphTest, Construction) { TEST(LinkGraphTest, Construction) {
// Check that LinkGraph construction works as expected. // Check that LinkGraph construction works as expected.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
EXPECT_EQ(G.getName(), "foo"); EXPECT_EQ(G.getName(), "foo");
EXPECT_EQ(G.getTargetTriple().str(), "x86_64-apple-darwin"); EXPECT_EQ(G.getTargetTriple().str(), "x86_64-apple-darwin");
@@ -35,7 +36,8 @@ TEST(LinkGraphTest, Construction) {
TEST(LinkGraphTest, AddressAccess) { TEST(LinkGraphTest, AddressAccess) {
// Check that we can get addresses for blocks, symbols, and edges. // Check that we can get addresses for blocks, symbols, and edges.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec1 = auto &Sec1 =
@@ -54,7 +56,8 @@ TEST(LinkGraphTest, AddressAccess) {
TEST(LinkGraphTest, SectionEmpty) { TEST(LinkGraphTest, SectionEmpty) {
// Check that Section::empty behaves as expected. // Check that Section::empty behaves as expected.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec1 = auto &Sec1 =
G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
@@ -72,7 +75,8 @@ TEST(LinkGraphTest, SectionEmpty) {
TEST(LinkGraphTest, BlockAndSymbolIteration) { TEST(LinkGraphTest, BlockAndSymbolIteration) {
// Check that we can iterate over blocks within Sections and across sections. // Check that we can iterate over blocks within Sections and across sections.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec1 = auto &Sec1 =
G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
@@ -125,7 +129,8 @@ TEST(LinkGraphTest, BlockAndSymbolIteration) {
TEST(LinkGraphTest, ContentAccessAndUpdate) { TEST(LinkGraphTest, ContentAccessAndUpdate) {
// Check that we can make a defined symbol external. // Check that we can make a defined symbol external.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec = auto &Sec =
G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
@@ -214,7 +219,8 @@ TEST(LinkGraphTest, ContentAccessAndUpdate) {
TEST(LinkGraphTest, MakeExternal) { TEST(LinkGraphTest, MakeExternal) {
// Check that we can make defined and absolute symbols external. // Check that we can make defined and absolute symbols external.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec = auto &Sec =
G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
@@ -284,7 +290,8 @@ TEST(LinkGraphTest, MakeExternal) {
TEST(LinkGraphTest, MakeAbsolute) { TEST(LinkGraphTest, MakeAbsolute) {
// Check that we can make defined and external symbols absolute. // Check that we can make defined and external symbols absolute.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec = auto &Sec =
G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
@@ -353,7 +360,8 @@ TEST(LinkGraphTest, MakeAbsolute) {
TEST(LinkGraphTest, MakeDefined) { TEST(LinkGraphTest, MakeDefined) {
// Check that we can make an external symbol defined. // Check that we can make an external symbol defined.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec = auto &Sec =
G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
@@ -401,7 +409,8 @@ TEST(LinkGraphTest, MakeDefined) {
TEST(LinkGraphTest, TransferDefinedSymbol) { TEST(LinkGraphTest, TransferDefinedSymbol) {
// Check that we can transfer a defined symbol from one block to another. // Check that we can transfer a defined symbol from one block to another.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec = auto &Sec =
G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
@@ -436,7 +445,8 @@ TEST(LinkGraphTest, TransferDefinedSymbol) {
TEST(LinkGraphTest, TransferDefinedSymbolAcrossSections) { TEST(LinkGraphTest, TransferDefinedSymbolAcrossSections) {
// Check that we can transfer a defined symbol from an existing block in one // Check that we can transfer a defined symbol from an existing block in one
// section to another. // section to another.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec1 = auto &Sec1 =
G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
@@ -470,7 +480,8 @@ TEST(LinkGraphTest, TransferDefinedSymbolAcrossSections) {
TEST(LinkGraphTest, TransferBlock) { TEST(LinkGraphTest, TransferBlock) {
// Check that we can transfer a block (and all associated symbols) from one // Check that we can transfer a block (and all associated symbols) from one
// section to another. // section to another.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec1 = auto &Sec1 =
G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
@@ -518,7 +529,8 @@ TEST(LinkGraphTest, TransferBlock) {
TEST(LinkGraphTest, MergeSections) { TEST(LinkGraphTest, MergeSections) {
// Check that we can transfer a block (and all associated symbols) from one // Check that we can transfer a block (and all associated symbols) from one
// section to another. // section to another.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec1 = auto &Sec1 =
G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
@@ -604,7 +616,8 @@ TEST(LinkGraphTest, MergeSections) {
TEST(LinkGraphTest, SplitBlock) { TEST(LinkGraphTest, SplitBlock) {
// Check that the LinkGraph::splitBlock test works as expected. // Check that the LinkGraph::splitBlock test works as expected.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec = auto &Sec =
G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
@@ -716,7 +729,8 @@ TEST(LinkGraphTest, SplitBlock) {
} }
TEST(LinkGraphTest, GraphAllocationMethods) { TEST(LinkGraphTest, GraphAllocationMethods) {
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
// Test allocation of sized, uninitialized buffer. // Test allocation of sized, uninitialized buffer.
@@ -737,7 +751,8 @@ TEST(LinkGraphTest, GraphAllocationMethods) {
TEST(LinkGraphTest, IsCStringBlockTest) { TEST(LinkGraphTest, IsCStringBlockTest) {
// Check that the LinkGraph::splitBlock test works as expected. // Check that the LinkGraph::splitBlock test works as expected.
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Sec = auto &Sec =
G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
@@ -761,8 +776,8 @@ TEST(LinkGraphTest, IsCStringBlockTest) {
} }
TEST(LinkGraphTest, BasicLayoutHonorsNoAlloc) { TEST(LinkGraphTest, BasicLayoutHonorsNoAlloc) {
// Check that BasicLayout honors NoAlloc. LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
// Create a regular section and block. // Create a regular section and block.

4
llvm/unittests/ExecutionEngine/JITLink/MachOLinkGraphTests.cpp
View File

@@ -11,6 +11,7 @@
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ExecutionEngine/JITLink/JITLink.h" #include "llvm/ExecutionEngine/JITLink/JITLink.h"
#include "llvm/ExecutionEngine/JITLink/MachO.h" #include "llvm/ExecutionEngine/JITLink/MachO.h"
#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
#include "llvm/Testing/Support/Error.h" #include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
@@ -20,7 +21,8 @@ using namespace llvm::jitlink;
TEST(MachOLinkGraphTest, GetStandardSections) { TEST(MachOLinkGraphTest, GetStandardSections) {
// Check that LinkGraph construction works as expected. // Check that LinkGraph construction works as expected.
LinkGraph G("foo", Triple("arm64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("arm64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto &Data = getMachODefaultRWDataSection(G); auto &Data = getMachODefaultRWDataSection(G);

7
llvm/unittests/ExecutionEngine/JITLink/MemoryManagerErrorTests.cpp
View File

@@ -18,9 +18,10 @@ using namespace llvm::jitlink;
TEST(MemoryManagerErrorTest, ErrorOnFirstAllocate) { TEST(MemoryManagerErrorTest, ErrorOnFirstAllocate) {
// Check that we can get addresses for blocks, symbols, and edges. // Check that we can get addresses for blocks, symbols, and edges.
auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8, auto G = std::make_unique<LinkGraph>(
llvm::endianness::little, "foo", std::make_shared<orc::SymbolStringPool>(),
getGenericEdgeKindName); Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName);
ArrayRef<char> Content = "hello, world!"; ArrayRef<char> Content = "hello, world!";
auto &Sec = auto &Sec =

17
llvm/unittests/ExecutionEngine/JITLink/StubsTests.cpp
View File

@@ -57,7 +57,8 @@ GenerateStub(LinkGraph &G, size_t PointerSize, Edge::Kind PointerEdgeKind) {
TEST(StubsTest, StubsGeneration_x86_64) { TEST(StubsTest, StubsGeneration_x86_64) {
const char PointerJumpStubContent[6] = { const char PointerJumpStubContent[6] = {
static_cast<char>(0xFFu), 0x25, 0x00, 0x00, 0x00, 0x00}; static_cast<char>(0xFFu), 0x25, 0x00, 0x00, 0x00, 0x00};
LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto [PointerSym, StubSym] = GenerateStub(G, 8U, x86_64::Pointer64); auto [PointerSym, StubSym] = GenerateStub(G, 8U, x86_64::Pointer64);
@@ -77,7 +78,8 @@ TEST(StubsTest, StubsGeneration_aarch64) {
0x10, 0x02, 0x40, (char)0xf9u, // LDR x16, [x16, <imm>@pageoff12] 0x10, 0x02, 0x40, (char)0xf9u, // LDR x16, [x16, <imm>@pageoff12]
0x00, 0x02, 0x1f, (char)0xd6u // BR x16 0x00, 0x02, 0x1f, (char)0xd6u // BR x16
}; };
LinkGraph G("foo", Triple("aarch64-linux-gnu"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("aarch64-linux-gnu"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto [PointerSym, StubSym] = GenerateStub(G, 8U, aarch64::Pointer64); auto [PointerSym, StubSym] = GenerateStub(G, 8U, aarch64::Pointer64);
@@ -97,8 +99,9 @@ TEST(StubsTest, StubsGeneration_aarch64) {
TEST(StubsTest, StubsGeneration_i386) { TEST(StubsTest, StubsGeneration_i386) {
const char PointerJumpStubContent[6] = { const char PointerJumpStubContent[6] = {
static_cast<char>(0xFFu), 0x25, 0x00, 0x00, 0x00, 0x00}; static_cast<char>(0xFFu), 0x25, 0x00, 0x00, 0x00, 0x00};
LinkGraph G("foo", Triple("i386-unknown-linux-gnu"), 4, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
llvm::endianness::little, getGenericEdgeKindName); Triple("i386-unknown-linux-gnu"), 8, llvm::endianness::little,
getGenericEdgeKindName);
auto [PointerSym, StubSym] = GenerateStub(G, 4U, i386::Pointer32); auto [PointerSym, StubSym] = GenerateStub(G, 4U, i386::Pointer32);
EXPECT_EQ(std::distance(StubSym.getBlock().edges().begin(), EXPECT_EQ(std::distance(StubSym.getBlock().edges().begin(),
@@ -126,7 +129,8 @@ TEST(StubsTest, StubsGeneration_loongarch32) {
0x00, 0x00,
0x4c // jr $t8 0x4c // jr $t8
}; };
LinkGraph G("foo", Triple("loongarch32"), 4, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("loongarch32"), 4, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto [PointerSym, StubSym] = GenerateStub(G, 4U, loongarch::Pointer32); auto [PointerSym, StubSym] = GenerateStub(G, 4U, loongarch::Pointer32);
@@ -158,7 +162,8 @@ TEST(StubsTest, StubsGeneration_loongarch64) {
0x00, 0x00,
0x4c // jr $t8 0x4c // jr $t8
}; };
LinkGraph G("foo", Triple("loongarch64"), 8, llvm::endianness::little, LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
Triple("loongarch64"), 8, llvm::endianness::little,
getGenericEdgeKindName); getGenericEdgeKindName);
auto [PointerSym, StubSym] = GenerateStub(G, 8U, loongarch::Pointer64); auto [PointerSym, StubSym] = GenerateStub(G, 8U, loongarch::Pointer64);

4
llvm/unittests/ExecutionEngine/Orc/EPCGenericJITLinkMemoryManagerTest.cpp
View File

@@ -114,10 +114,10 @@ TEST(EPCGenericJITLinkMemoryManagerTest, AllocFinalizeFree) {
SAs.Deallocate = ExecutorAddr::fromPtr(&testDeallocate); SAs.Deallocate = ExecutorAddr::fromPtr(&testDeallocate);
auto MemMgr = std::make_unique<EPCGenericJITLinkMemoryManager>(*SelfEPC, SAs); auto MemMgr = std::make_unique<EPCGenericJITLinkMemoryManager>(*SelfEPC, SAs);
StringRef Hello = "hello"; StringRef Hello = "hello";
auto SSA = jitlink::SimpleSegmentAlloc::Create( auto SSA = jitlink::SimpleSegmentAlloc::Create(
*MemMgr, nullptr, {{MemProt::Read, {Hello.size(), Align(1)}}}); *MemMgr, std::make_shared<orc::SymbolStringPool>(), nullptr,
{{MemProt::Read, {Hello.size(), Align(1)}}});
EXPECT_THAT_EXPECTED(SSA, Succeeded()); EXPECT_THAT_EXPECTED(SSA, Succeeded());
auto SegInfo = SSA->getSegInfo(MemProt::Read); auto SegInfo = SSA->getSegInfo(MemProt::Read);
memcpy(SegInfo.WorkingMem.data(), Hello.data(), Hello.size()); memcpy(SegInfo.WorkingMem.data(), Hello.data(), Hello.size());

2
llvm/unittests/ExecutionEngine/Orc/JITLinkRedirectionManagerTest.cpp
View File

@@ -81,8 +81,8 @@ TEST_F(JITLinkRedirectionManagerTest, BasicRedirectionOperation) {
JD->getDefaultResourceTracker(), JD->getDefaultResourceTracker(),
{{RedirectableSymbol, MakeTarget(initialTarget)}}), {{RedirectableSymbol, MakeTarget(initialTarget)}}),
Succeeded()); Succeeded());
auto RTDef = cantFail(ES->lookup({JD}, RedirectableSymbol));
auto RTDef = cantFail(ES->lookup({JD}, RedirectableSymbol));
auto RTPtr = RTDef.getAddress().toPtr<int (*)()>(); auto RTPtr = RTDef.getAddress().toPtr<int (*)()>();
auto Result = RTPtr(); auto Result = RTPtr();
EXPECT_EQ(Result, 42) << "Failed to call initial target"; EXPECT_EQ(Result, 42) << "Failed to call initial target";

13
llvm/unittests/ExecutionEngine/Orc/MapperJITLinkMemoryManagerTest.cpp
View File

@@ -76,7 +76,8 @@ TEST(MapperJITLinkMemoryManagerTest, InProcess) {
StringRef Hello = "hello"; StringRef Hello = "hello";
auto SSA1 = jitlink::SimpleSegmentAlloc::Create( auto SSA1 = jitlink::SimpleSegmentAlloc::Create(
*MemMgr, nullptr, {{MemProt::Read, {Hello.size(), Align(1)}}}); *MemMgr, std::make_shared<orc::SymbolStringPool>(), nullptr,
{{MemProt::Read, {Hello.size(), Align(1)}}});
EXPECT_THAT_EXPECTED(SSA1, Succeeded()); EXPECT_THAT_EXPECTED(SSA1, Succeeded());
EXPECT_EQ(Counter->ReserveCount, 1); EXPECT_EQ(Counter->ReserveCount, 1);
@@ -92,7 +93,8 @@ TEST(MapperJITLinkMemoryManagerTest, InProcess) {
EXPECT_EQ(Counter->InitCount, 1); EXPECT_EQ(Counter->InitCount, 1);
auto SSA2 = jitlink::SimpleSegmentAlloc::Create( auto SSA2 = jitlink::SimpleSegmentAlloc::Create(
*MemMgr, nullptr, {{MemProt::Read, {Hello.size(), Align(1)}}}); *MemMgr, std::make_shared<orc::SymbolStringPool>(), nullptr,
{{MemProt::Read, {Hello.size(), Align(1)}}});
EXPECT_THAT_EXPECTED(SSA2, Succeeded()); EXPECT_THAT_EXPECTED(SSA2, Succeeded());
// last reservation should be reused // last reservation should be reused
@@ -135,9 +137,10 @@ TEST(MapperJITLinkMemoryManagerTest, Coalescing) {
auto Mapper = cantFail(InProcessMemoryMapper::Create()); auto Mapper = cantFail(InProcessMemoryMapper::Create());
auto MemMgr = std::make_unique<MapperJITLinkMemoryManager>(16 * 1024 * 1024, auto MemMgr = std::make_unique<MapperJITLinkMemoryManager>(16 * 1024 * 1024,
std::move(Mapper)); std::move(Mapper));
auto SSP = std::make_shared<orc::SymbolStringPool>();
auto SSA1 = jitlink::SimpleSegmentAlloc::Create( auto SSA1 = jitlink::SimpleSegmentAlloc::Create(
*MemMgr, nullptr, {{MemProt::Read, {1024, Align(1)}}}); *MemMgr, SSP, nullptr, {{MemProt::Read, {1024, Align(1)}}});
EXPECT_THAT_EXPECTED(SSA1, Succeeded()); EXPECT_THAT_EXPECTED(SSA1, Succeeded());
auto SegInfo1 = SSA1->getSegInfo(MemProt::Read); auto SegInfo1 = SSA1->getSegInfo(MemProt::Read);
ExecutorAddr TargetAddr1(SegInfo1.Addr); ExecutorAddr TargetAddr1(SegInfo1.Addr);
@@ -145,7 +148,7 @@ TEST(MapperJITLinkMemoryManagerTest, Coalescing) {
EXPECT_THAT_EXPECTED(FA1, Succeeded()); EXPECT_THAT_EXPECTED(FA1, Succeeded());
auto SSA2 = jitlink::SimpleSegmentAlloc::Create( auto SSA2 = jitlink::SimpleSegmentAlloc::Create(
*MemMgr, nullptr, {{MemProt::Read, {1024, Align(1)}}}); *MemMgr, SSP, nullptr, {{MemProt::Read, {1024, Align(1)}}});
EXPECT_THAT_EXPECTED(SSA2, Succeeded()); EXPECT_THAT_EXPECTED(SSA2, Succeeded());
auto FA2 = SSA2->finalize(); auto FA2 = SSA2->finalize();
EXPECT_THAT_EXPECTED(FA2, Succeeded()); EXPECT_THAT_EXPECTED(FA2, Succeeded());
@@ -157,7 +160,7 @@ TEST(MapperJITLinkMemoryManagerTest, Coalescing) {
EXPECT_THAT_ERROR(std::move(Err3), Succeeded()); EXPECT_THAT_ERROR(std::move(Err3), Succeeded());
auto SSA3 = jitlink::SimpleSegmentAlloc::Create( auto SSA3 = jitlink::SimpleSegmentAlloc::Create(
*MemMgr, nullptr, {{MemProt::Read, {2048, Align(1)}}}); *MemMgr, SSP, nullptr, {{MemProt::Read, {2048, Align(1)}}});
EXPECT_THAT_EXPECTED(SSA3, Succeeded()); EXPECT_THAT_EXPECTED(SSA3, Succeeded());
auto SegInfo3 = SSA3->getSegInfo(MemProt::Read); auto SegInfo3 = SSA3->getSegInfo(MemProt::Read);

45
llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp
View File

@@ -15,6 +15,7 @@
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h" #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h" #include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h" #include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
#include "llvm/Testing/Support/Error.h" #include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
@@ -44,9 +45,9 @@ protected:
}; };
TEST_F(ObjectLinkingLayerTest, AddLinkGraph) { TEST_F(ObjectLinkingLayerTest, AddLinkGraph) {
auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8, auto G = std::make_unique<LinkGraph>(
llvm::endianness::little, "foo", ES.getSymbolStringPool(), Triple("x86_64-apple-darwin"), 8,
x86_64::getEdgeKindName); llvm::endianness::little, x86_64::getEdgeKindName);
auto &Sec1 = G->createSection("__data", MemProt::Read | MemProt::Write); auto &Sec1 = G->createSection("__data", MemProt::Read | MemProt::Write);
auto &B1 = G->createContentBlock(Sec1, BlockContent, auto &B1 = G->createContentBlock(Sec1, BlockContent,
@@ -71,9 +72,9 @@ TEST_F(ObjectLinkingLayerTest, ResourceTracker) {
// may invalidate some iterators internally. // may invalidate some iterators internally.
std::vector<ResourceTrackerSP> Trackers; std::vector<ResourceTrackerSP> Trackers;
for (unsigned I = 0; I < 64; I++) { for (unsigned I = 0; I < 64; I++) {
auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), auto G = std::make_unique<LinkGraph>(
8, llvm::endianness::little, "foo", ES.getSymbolStringPool(), Triple("x86_64-apple-darwin"), 8,
x86_64::getEdgeKindName); llvm::endianness::little, x86_64::getEdgeKindName);
auto &Sec1 = G->createSection("__data", MemProt::Read | MemProt::Write); auto &Sec1 = G->createSection("__data", MemProt::Read | MemProt::Write);
auto &B1 = G->createContentBlock(Sec1, BlockContent, auto &B1 = G->createContentBlock(Sec1, BlockContent,
@@ -138,10 +139,9 @@ TEST_F(ObjectLinkingLayerTest, ClaimLateDefinedWeakSymbols) {
}; };
ObjLinkingLayer.addPlugin(std::make_unique<TestPlugin>()); ObjLinkingLayer.addPlugin(std::make_unique<TestPlugin>());
auto G = std::make_unique<LinkGraph>(
auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8, "foo", ES.getSymbolStringPool(), Triple("x86_64-apple-darwin"), 8,
llvm::endianness::little, llvm::endianness::little, getGenericEdgeKindName);
x86_64::getEdgeKindName);
auto &DataSec = G->createSection("__data", MemProt::Read | MemProt::Write); auto &DataSec = G->createSection("__data", MemProt::Read | MemProt::Write);
auto &DataBlock = G->createContentBlock(DataSec, BlockContent, auto &DataBlock = G->createContentBlock(DataSec, BlockContent,
@@ -192,10 +192,9 @@ TEST_F(ObjectLinkingLayerTest, HandleErrorDuringPostAllocationPass) {
ES.setErrorReporter(consumeError); ES.setErrorReporter(consumeError);
ObjLinkingLayer.addPlugin(std::make_unique<TestPlugin>()); ObjLinkingLayer.addPlugin(std::make_unique<TestPlugin>());
auto G = std::make_unique<LinkGraph>(
auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8, "foo", ES.getSymbolStringPool(), Triple("x86_64-apple-darwin"), 8,
llvm::endianness::little, llvm::endianness::little, getGenericEdgeKindName);
x86_64::getEdgeKindName);
auto &DataSec = G->createSection("__data", MemProt::Read | MemProt::Write); auto &DataSec = G->createSection("__data", MemProt::Read | MemProt::Write);
auto &DataBlock = G->createContentBlock(DataSec, BlockContent, auto &DataBlock = G->createContentBlock(DataSec, BlockContent,
@@ -247,9 +246,9 @@ TEST_F(ObjectLinkingLayerTest, AddAndRemovePlugins) {
ObjLinkingLayer.addPlugin(P); ObjLinkingLayer.addPlugin(P);
{ {
auto G1 = std::make_unique<LinkGraph>("G1", Triple("x86_64-apple-darwin"), auto G1 = std::make_unique<LinkGraph>(
8, llvm::endianness::little, "G1", ES.getSymbolStringPool(), Triple("x86_64-apple-darwin"), 8,
x86_64::getEdgeKindName); llvm::endianness::little, x86_64::getEdgeKindName);
auto &DataSec = G1->createSection("__data", MemProt::Read | MemProt::Write); auto &DataSec = G1->createSection("__data", MemProt::Read | MemProt::Write);
auto &DataBlock = G1->createContentBlock(DataSec, BlockContent, auto &DataBlock = G1->createContentBlock(DataSec, BlockContent,
@@ -265,9 +264,9 @@ TEST_F(ObjectLinkingLayerTest, AddAndRemovePlugins) {
ObjLinkingLayer.removePlugin(*P); ObjLinkingLayer.removePlugin(*P);
{ {
auto G2 = std::make_unique<LinkGraph>("G2", Triple("x86_64-apple-darwin"), auto G2 = std::make_unique<LinkGraph>(
8, llvm::endianness::little, "G2", ES.getSymbolStringPool(), Triple("x86_64-apple-darwin"), 8,
x86_64::getEdgeKindName); llvm::endianness::little, x86_64::getEdgeKindName);
auto &DataSec = G2->createSection("__data", MemProt::Read | MemProt::Write); auto &DataSec = G2->createSection("__data", MemProt::Read | MemProt::Write);
auto &DataBlock = G2->createContentBlock(DataSec, BlockContent, auto &DataBlock = G2->createContentBlock(DataSec, BlockContent,
@@ -325,8 +324,8 @@ TEST(ObjectLinkingLayerSearchGeneratorTest, AbsoluteSymbolsObjectLayer) {
auto G = EPCDynamicLibrarySearchGenerator::GetForTargetProcess( auto G = EPCDynamicLibrarySearchGenerator::GetForTargetProcess(
ES, {}, [&](JITDylib &JD, SymbolMap Syms) { ES, {}, [&](JITDylib &JD, SymbolMap Syms) {
auto G = auto G = absoluteSymbolsLinkGraph(
absoluteSymbolsLinkGraph(ES.getTargetTriple(), std::move(Syms)); ES.getTargetTriple(), ES.getSymbolStringPool(), std::move(Syms));
return ObjLinkingLayer.add(JD, std::move(G)); return ObjLinkingLayer.add(JD, std::move(G));
}); });
ASSERT_THAT_EXPECTED(G, Succeeded()); ASSERT_THAT_EXPECTED(G, Succeeded());
@@ -347,7 +346,7 @@ TEST(ObjectLinkingLayerSearchGeneratorTest, AbsoluteSymbolsObjectLayer) {
ADD_FAILURE() << "unexpected unnamed symbol"; ADD_FAILURE() << "unexpected unnamed symbol";
continue; continue;
} }
if (Sym->getName() == "_testFunc") if (*Sym->getName() == "_testFunc")
SawSymbolDef = true; SawSymbolDef = true;
else else
ADD_FAILURE() << "unexpected symbol " << Sym->getName(); ADD_FAILURE() << "unexpected symbol " << Sym->getName();