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

[ORC] Move most ORC APIs to ExecutorAddr, introduce ExecutorSymbolDef.

Browse Source 
ExecutorAddr was introduced in b8e5f91816 as an eventual replacement for
JITTargetAddress. ExecutorSymbolDef is introduced in this patch as a
replacement for JITEvaluatedSymbol: ExecutorSymbolDef is an (ExecutorAddr,
JITSymbolFlags) pair, where JITEvaluatedSymbol was a (JITTargetAddress,
JITSymbolFlags) pair.

A number of APIs had already migrated from JITTargetAddress to ExecutorAddr,
but many of ORC's internals were still using the older type. This patch aims
to address that.

Some public APIs are affected as well. If you need to migrate your APIs you can
use the following operations:

* ExecutorAddr::toPtr replaces jitTargetAddressToPointer and
  jitTargetAddressToFunction.

* ExecutorAddr::fromPtr replace pointerToJITTargetAddress.

* ExecutorAddr(JITTargetAddress) creates an ExecutorAddr value from a
  JITTargetAddress.

* ExecutorAddr::getValue() creates a JITTargetAddress value from an
  ExecutorAddr.

JITTargetAddress and JITEvaluatedSymbol will remain in JITSymbol.h for now, but
the aim will be to eventually deprecate and remove these types (probably when
MCJIT and RuntimeDyld are deprecated).
This commit is contained in:
Lang Hames
2023-03-22 11:45:10 -07:00
parent 41a964cff0
commit 8b1771bd9f
61 changed files with 552 additions and 589 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
llvm/docs/ORCv2.rst
View File

@@ -147,7 +147,7 @@ specified before the JIT instance is constructed. For example:
auto JIT = LLLazyJITBuilder()
.setNumCompileThreads(4)
.setLazyCompileFailureAddr(
toJITTargetAddress(&handleLazyCompileFailure))
ExecutorAddr::fromPtr(&handleLazyCompileFailure))
.create();
// ...
@@ -315,7 +315,7 @@ absolute symbols is allowing resolution of process symbols. E.g.
JD.define(absoluteSymbols(SymbolMap({
{ Mangle("printf"),
{ pointerToJITTargetAddress(&printf),
{ ExecutorAddr::fromPtr(&printf),
JITSymbolFlags::Callable } }
});
@@ -364,7 +364,7 @@ absolute symbol definition when the JIT is started:
JITStdLibJD.define(absoluteSymbols(SymbolMap({
{ Mangle("__MyJITInstance"),
{ pointerToJITTargetAddress(&J), JITSymbolFlags() } }
{ ExecutorAddr::fromPtr(&J), JITSymbolFlags() } }
});
Aliases and Reexports
@@ -819,8 +819,8 @@ absoluteSymbols function:
JD.define(
absoluteSymbols({
{ Mangle("puts"), pointerToJITTargetAddress(&puts)},
{ Mangle("gets"), pointerToJITTargetAddress(&getS)}
{ Mangle("puts"), ExecutorAddr::fromPtr(&puts)},
{ Mangle("gets"), ExecutorAddr::fromPtr(&getS)}
}));
Using absoluteSymbols is reasonable if the set of symbols to be reflected is

8
llvm/docs/tutorial/BuildingAJIT1.rst
View File

@@ -67,7 +67,7 @@ just two functions:
1. ``Error addModule(std::unique_ptr<Module> M)``: Make the given IR module
available for execution.
2. ``Expected<JITEvaluatedSymbol> lookup()``: Search for pointers to
2. ``Expected<ExecutorSymbolDef> lookup()``: Search for pointers to
symbols (functions or variables) that have been added to the JIT.
A basic use-case for this API, executing the 'main' function from a module,
@@ -110,7 +110,6 @@ usual include guards and #includes [2]_, we get to the definition of our class:
#define LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H
#include "llvm/ADT/StringRef.h"
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
#include "llvm/ExecutionEngine/Orc/Core.h"
#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
@@ -224,7 +223,7 @@ will build our IR modules.
ThreadSafeModule(std::move(M), Ctx)));
}
Expected<JITEvaluatedSymbol> lookup(StringRef Name) {
Expected<ExecutorSymbolDef> lookup(StringRef Name) {
return ES.lookup({&ES.getMainJITDylib()}, Mangle(Name.str()));
}
@@ -295,9 +294,6 @@ Here is the code:
.. [2] +-----------------------------+-----------------------------------------------+
| File | Reason for inclusion |
+=============================+===============================================+
| JITSymbol.h | Defines the lookup result type |
| | JITEvaluatedSymbol |
+-----------------------------+-----------------------------------------------+
| CompileUtils.h | Provides the SimpleCompiler class. |
+-----------------------------+-----------------------------------------------+
| Core.h | Core utilities such as ExecutionSession and |

4
llvm/docs/tutorial/BuildingAJIT3.rst
View File

@@ -119,8 +119,8 @@ to create the compile callback needed for each function.
Next we have to update our constructor to initialize the new members. To create
an appropriate compile callback manager we use the
createLocalCompileCallbackManager function, which takes a TargetMachine and a
JITTargetAddress to call if it receives a request to compile an unknown
createLocalCompileCallbackManager function, which takes a TargetMachine and an
ExecutorAddr to call if it receives a request to compile an unknown
function. In our simple JIT this situation is unlikely to come up, so we'll
cheat and just pass '0' here. In a production quality JIT you could give the
address of a function that throws an exception in order to unwind the JIT'd

3
llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h
View File

@@ -14,7 +14,6 @@
#define LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H
#include "llvm/ADT/StringRef.h"
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
#include "llvm/ExecutionEngine/Orc/Core.h"
#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
@@ -89,7 +88,7 @@ public:
return CompileLayer.add(RT, std::move(TSM));
}
Expected<JITEvaluatedSymbol> lookup(StringRef Name) {
Expected<ExecutorSymbolDef> lookup(StringRef Name) {
return ES->lookup({&MainJD}, Mangle(Name.str()));
}
};

2
llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp
View File

@@ -1159,7 +1159,7 @@ static void HandleTopLevelExpression() {
// Get the symbol's address and cast it to the right type (takes no
// arguments, returns a double) so we can call it as a native function.
auto *FP = (double (*)())(intptr_t)Sym.getAddress();
auto *FP = Sym.getAddress().toPtr<double (*)()>();
fprintf(stderr, "Evaluated to %f\n", FP());
// Delete the anonymous expression module from the JIT.

3
llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h
View File

@@ -14,7 +14,6 @@
#define LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H
#include "llvm/ADT/StringRef.h"
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
#include "llvm/ExecutionEngine/Orc/Core.h"
#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
@@ -97,7 +96,7 @@ public:
return OptimizeLayer.add(RT, std::move(TSM));
}
Expected<JITEvaluatedSymbol> lookup(StringRef Name) {
Expected<ExecutorSymbolDef> lookup(StringRef Name) {
return ES->lookup({&MainJD}, Mangle(Name.str()));
}

2
llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp
View File

@@ -1159,7 +1159,7 @@ static void HandleTopLevelExpression() {
// Get the symbol's address and cast it to the right type (takes no
// arguments, returns a double) so we can call it as a native function.
auto *FP = (double (*)())(intptr_t)Sym.getAddress();
auto *FP = Sym.getAddress().toPtr<double (*)()>();
fprintf(stderr, "Evaluated to %f\n", FP());
// Delete the anonymous expression module from the JIT.

5
llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h
View File

@@ -14,7 +14,6 @@
#define LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H
#include "llvm/ADT/StringRef.h"
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
#include "llvm/ExecutionEngine/Orc/Core.h"
@@ -96,7 +95,7 @@ public:
return EPCIU.takeError();
(*EPCIU)->createLazyCallThroughManager(
*ES, pointerToJITTargetAddress(&handleLazyCallThroughError));
*ES, ExecutorAddr::fromPtr(&handleLazyCallThroughError));
if (auto Err = setUpInProcessLCTMReentryViaEPCIU(**EPCIU))
return std::move(Err);
@@ -123,7 +122,7 @@ public:
return CODLayer.add(RT, std::move(TSM));
}
Expected<JITEvaluatedSymbol> lookup(StringRef Name) {
Expected<ExecutorSymbolDef> lookup(StringRef Name) {
return ES->lookup({&MainJD}, Mangle(Name.str()));
}

2
llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp
View File

@@ -1159,7 +1159,7 @@ static void HandleTopLevelExpression() {
// Get the symbol's address and cast it to the right type (takes no
// arguments, returns a double) so we can call it as a native function.
auto *FP = (double (*)())(intptr_t)Sym.getAddress();
auto *FP = Sym.getAddress().toPtr<double (*)()>();
fprintf(stderr, "Evaluated to %f\n", FP());
// Delete the anonymous expression module from the JIT.

5
llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h
View File

@@ -14,7 +14,6 @@
#define LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H
#include "llvm/ADT/StringRef.h"
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
#include "llvm/ExecutionEngine/Orc/Core.h"
@@ -181,7 +180,7 @@ public:
return EPCIU.takeError();
(*EPCIU)->createLazyCallThroughManager(
*ES, pointerToJITTargetAddress(&handleLazyCallThroughError));
*ES, ExecutorAddr::fromPtr(&handleLazyCallThroughError));
if (auto Err = setUpInProcessLCTMReentryViaEPCIU(**EPCIU))
return std::move(Err);
@@ -214,7 +213,7 @@ public:
return ASTLayer.add(RT, std::move(F));
}
Expected<JITEvaluatedSymbol> lookup(StringRef Name) {
Expected<ExecutorSymbolDef> lookup(StringRef Name) {
return ES->lookup({&MainJD}, Mangle(Name.str()));
}

2
llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp
View File

@@ -1157,7 +1157,7 @@ static void HandleTopLevelExpression() {
// Get the symbol's address and cast it to the right type (takes no
// arguments, returns a double) so we can call it as a native function.
auto *FP = (double (*)())(intptr_t)Sym.getAddress();
auto *FP = Sym.getAddress().toPtr<double (*)()>();
fprintf(stderr, "Evaluated to %f\n", FP());
// Delete the anonymous expression module from the JIT.

2
llvm/examples/Kaleidoscope/Chapter4/toy.cpp
View File

@@ -620,7 +620,7 @@ static void HandleTopLevelExpression() {
// Get the symbol's address and cast it to the right type (takes no
// arguments, returns a double) so we can call it as a native function.
double (*FP)() = (double (*)())(intptr_t)ExprSymbol.getAddress();
double (*FP)() = ExprSymbol.getAddress().toPtr<double (*)()>();
fprintf(stderr, "Evaluated to %f\n", FP());
// Delete the anonymous expression module from the JIT.

2
llvm/examples/Kaleidoscope/Chapter5/toy.cpp
View File

@@ -894,7 +894,7 @@ static void HandleTopLevelExpression() {
// Get the symbol's address and cast it to the right type (takes no
// arguments, returns a double) so we can call it as a native function.
double (*FP)() = (double (*)())(intptr_t)ExprSymbol.getAddress();
double (*FP)() = ExprSymbol.getAddress().toPtr<double (*)()>();
fprintf(stderr, "Evaluated to %f\n", FP());
// Delete the anonymous expression module from the JIT.

2
llvm/examples/Kaleidoscope/Chapter6/toy.cpp
View File

@@ -1013,7 +1013,7 @@ static void HandleTopLevelExpression() {
// Get the symbol's address and cast it to the right type (takes no
// arguments, returns a double) so we can call it as a native function.
double (*FP)() = (double (*)())(intptr_t)ExprSymbol.getAddress();
double (*FP)() = ExprSymbol.getAddress().toPtr<double (*)()>();
fprintf(stderr, "Evaluated to %f\n", FP());
// Delete the anonymous expression module from the JIT.

2
llvm/examples/Kaleidoscope/Chapter7/toy.cpp
View File

@@ -1184,7 +1184,7 @@ static void HandleTopLevelExpression() {
// Get the symbol's address and cast it to the right type (takes no
// arguments, returns a double) so we can call it as a native function.
double (*FP)() = (double (*)())(intptr_t)ExprSymbol.getAddress();
double (*FP)() = ExprSymbol.getAddress().toPtr<double (*)()>();
fprintf(stderr, "Evaluated to %f\n", FP());
// Delete the anonymous expression module from the JIT.

2
llvm/examples/Kaleidoscope/include/KaleidoscopeJIT.h
View File

@@ -93,7 +93,7 @@ public:
return CompileLayer.add(RT, std::move(TSM));
}
Expected<JITEvaluatedSymbol> lookup(StringRef Name) {
Expected<ExecutorSymbolDef> lookup(StringRef Name) {
return ES->lookup({&MainJD}, Mangle(Name.str()));
}
};

12
llvm/examples/OrcV2Examples/LLJITWithExecutorProcessControl/LLJITWithExecutorProcessControl.cpp
View File

@@ -107,10 +107,8 @@ static void *reenter(void *Ctx, void *TrampolineAddr) {
auto *EPCIU = static_cast<EPCIndirectionUtils *>(Ctx);
EPCIU->getLazyCallThroughManager().resolveTrampolineLandingAddress(
pointerToJITTargetAddress(TrampolineAddr),
[&](JITTargetAddress LandingAddress) {
LandingAddressP.set_value(
jitTargetAddressToPointer<void *>(LandingAddress));
ExecutorAddr::fromPtr(TrampolineAddr), [&](ExecutorAddr LandingAddress) {
LandingAddressP.set_value(LandingAddress.toPtr<void *>());
});
return LandingAddressF.get();
}
@@ -149,10 +147,10 @@ int main(int argc, char *argv[]) {
// (3) Create stubs and call-through managers:
auto EPCIU = ExitOnErr(EPCIndirectionUtils::Create(
J->getExecutionSession().getExecutorProcessControl()));
ExitOnErr(EPCIU->writeResolverBlock(pointerToJITTargetAddress(&reenter),
pointerToJITTargetAddress(EPCIU.get())));
ExitOnErr(EPCIU->writeResolverBlock(ExecutorAddr::fromPtr(&reenter),
ExecutorAddr::fromPtr(EPCIU.get())));
EPCIU->createLazyCallThroughManager(
J->getExecutionSession(), pointerToJITTargetAddress(&reportErrorAndExit));
J->getExecutionSession(), ExecutorAddr::fromPtr(&reportErrorAndExit));
auto ISM = EPCIU->createIndirectStubsManager();
J->getMainJITDylib().addGenerator(
ExitOnErr(EPCDynamicLibrarySearchGenerator::GetForTargetProcess(

12
llvm/examples/OrcV2Examples/LLJITWithInitializers/LLJITWithInitializers.cpp
View File

@@ -78,11 +78,13 @@ int main(int argc, char *argv[]) {
int32_t InitializersRunFlag = 0;
int32_t DeinitializersRunFlag = 0;
ExitOnErr(J->getMainJITDylib().define(absoluteSymbols(
{{J->mangleAndIntern("InitializersRunFlag"),
JITEvaluatedSymbol::fromPointer(&InitializersRunFlag)},
{J->mangleAndIntern("DeinitializersRunFlag"),
JITEvaluatedSymbol::fromPointer(&DeinitializersRunFlag)}})));
ExitOnErr(J->getMainJITDylib().define(
absoluteSymbols({{J->mangleAndIntern("InitializersRunFlag"),
{ExecutorAddr::fromPtr(&InitializersRunFlag),
JITSymbolFlags::Exported}},
{J->mangleAndIntern("DeinitializersRunFlag"),
{ExecutorAddr::fromPtr(&DeinitializersRunFlag),
JITSymbolFlags::Exported}}})));
// Run static initializers.
ExitOnErr(J->initialize(J->getMainJITDylib()));

2
llvm/examples/OrcV2Examples/LLJITWithLazyReexports/LLJITWithLazyReexports.cpp
View File

@@ -122,7 +122,7 @@ int main(int argc, char *argv[]) {
ISM = ISMBuilder();
}
auto LCTM = ExitOnErr(createLocalLazyCallThroughManager(
J->getTargetTriple(), J->getExecutionSession(), 0));
J->getTargetTriple(), J->getExecutionSession(), ExecutorAddr()));
// (4) Add modules.
ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(FooMod, "foo-mod"))));

7
llvm/examples/SpeculativeJIT/SpeculativeJIT.cpp
View File

@@ -57,7 +57,7 @@ public:
auto LCTMgr = createLocalLazyCallThroughManager(
JTMB->getTargetTriple(), *ES,
pointerToJITTargetAddress(explodeOnLazyCompileFailure));
ExecutorAddr::fromPtr(explodeOnLazyCompileFailure));
if (!LCTMgr)
return LCTMgr.takeError();
@@ -85,7 +85,7 @@ public:
return CODLayer.add(MainJD, std::move(TSM));
}
Expected<JITEvaluatedSymbol> lookup(StringRef UnmangledName) {
Expected<ExecutorSymbolDef> lookup(StringRef UnmangledName) {
return ES->lookup({&MainJD}, Mangle(UnmangledName));
}
@@ -183,8 +183,7 @@ int main(int argc, char *argv[]) {
}
auto MainSym = ExitOnErr(SJ->lookup("main"));
auto Main =
jitTargetAddressToFunction<int (*)(int, char *[])>(MainSym.getAddress());
auto Main = MainSym.getAddress().toPtr<int (*)(int, char *[])>();
return runAsMain(Main, InputArgv, StringRef(InputFiles.front()));

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

@@ -18,6 +18,8 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
#include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/BinaryStreamReader.h"
@@ -1731,7 +1733,7 @@ enum class SymbolLookupFlags { RequiredSymbol, WeaklyReferencedSymbol };
raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LF);
/// A map of symbol names to resolved addresses.
using AsyncLookupResult = DenseMap<StringRef, JITEvaluatedSymbol>;
using AsyncLookupResult = DenseMap<StringRef, orc::ExecutorSymbolDef>;
/// A function object to call with a resolved symbol map (See AsyncLookupResult)
/// or an error if resolution failed.

27
llvm/include/llvm/ExecutionEngine/Orc/Core.h
View File

@@ -20,6 +20,8 @@
#include "llvm/ExecutionEngine/JITLink/JITLinkDylib.h"
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
#include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
#include "llvm/Support/Debug.h"
@@ -115,7 +117,7 @@ using SymbolNameVector = std::vector<SymbolStringPtr>;
/// A map from symbol names (as SymbolStringPtrs) to JITSymbols
/// (address/flags pairs).
using SymbolMap = DenseMap<SymbolStringPtr, JITEvaluatedSymbol>;
using SymbolMap = DenseMap<SymbolStringPtr, ExecutorSymbolDef>;
/// A map from symbol names (as SymbolStringPtrs) to JITSymbolFlags.
using SymbolFlagsMap = DenseMap<SymbolStringPtr, JITSymbolFlags>;
@@ -762,7 +764,7 @@ private:
/// \code{.cpp}
/// JITDylib &JD = ...;
/// SymbolStringPtr Foo = ...;
/// JITEvaluatedSymbol FooSym = ...;
/// ExecutorSymbolDef FooSym = ...;
/// if (auto Err = JD.define(absoluteSymbols({{Foo, FooSym}})))
/// return Err;
/// \endcode
@@ -866,7 +868,7 @@ public:
/// Notify the query that a requested symbol has reached the required state.
void notifySymbolMetRequiredState(const SymbolStringPtr &Name,
JITEvaluatedSymbol Sym);
ExecutorSymbolDef Sym);
/// Returns true if all symbols covered by this query have been
/// resolved.
@@ -1234,9 +1236,7 @@ private:
this->PendingRemoval = PendingRemoval;
}
JITEvaluatedSymbol getSymbol() const {
return JITEvaluatedSymbol(Addr.getValue(), Flags);
}
ExecutorSymbolDef getSymbol() const { return {Addr, Flags}; }
private:
ExecutorAddr Addr;
@@ -1553,21 +1553,21 @@ public:
/// Convenience version of blocking lookup.
/// Searches each of the JITDylibs in the search order in turn for the given
/// symbol.
Expected<JITEvaluatedSymbol>
Expected<ExecutorSymbolDef>
lookup(const JITDylibSearchOrder &SearchOrder, SymbolStringPtr Symbol,
SymbolState RequiredState = SymbolState::Ready);
/// Convenience version of blocking lookup.
/// Searches each of the JITDylibs in the search order in turn for the given
/// symbol. The search will not find non-exported symbols.
Expected<JITEvaluatedSymbol>
Expected<ExecutorSymbolDef>
lookup(ArrayRef<JITDylib *> SearchOrder, SymbolStringPtr Symbol,
SymbolState RequiredState = SymbolState::Ready);
/// Convenience version of blocking lookup.
/// Searches each of the JITDylibs in the search order in turn for the given
/// symbol. The search will not find non-exported symbols.
Expected<JITEvaluatedSymbol>
Expected<ExecutorSymbolDef>
lookup(ArrayRef<JITDylib *> SearchOrder, StringRef Symbol,
SymbolState RequiredState = SymbolState::Ready);
@@ -1672,10 +1672,9 @@ public:
/// Run a registered jit-side wrapper function.
/// This should be called by the ExecutorProcessControl instance in response
/// to incoming jit-dispatch requests from the executor.
void
runJITDispatchHandler(SendResultFunction SendResult,
JITTargetAddress HandlerFnTagAddr,
ArrayRef<char> ArgBuffer);
void runJITDispatchHandler(SendResultFunction SendResult,
ExecutorAddr HandlerFnTagAddr,
ArrayRef<char> ArgBuffer);
/// Dump the state of all the JITDylibs in this session.
void dump(raw_ostream &OS);
@@ -1777,7 +1776,7 @@ private:
OutstandingMUs;
mutable std::mutex JITDispatchHandlersMutex;
DenseMap<JITTargetAddress, std::shared_ptr<JITDispatchHandlerFunction>>
DenseMap<ExecutorAddr, std::shared_ptr<JITDispatchHandlerFunction>>
JITDispatchHandlers;
};

50
llvm/include/llvm/ExecutionEngine/Orc/EPCIndirectionUtils.h
View File

@@ -54,20 +54,18 @@ public:
unsigned getResolverCodeSize() const { return ResolverCodeSize; }
virtual void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddr,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) const = 0;
ExecutorAddr ResolverTargetAddr,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) const = 0;
virtual void writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTragetAddr,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTragetAddr,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines) const = 0;
virtual void
writeIndirectStubsBlock(char *StubsBlockWorkingMem,
JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress,
unsigned NumStubs) const = 0;
virtual void writeIndirectStubsBlock(
char *StubsBlockWorkingMem, ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress, unsigned NumStubs) const = 0;
private:
unsigned PointerSize = 0;
@@ -99,13 +97,12 @@ public:
/// Write resolver code to the executor process and return its address.
/// This must be called before any call to createTrampolinePool or
/// createLazyCallThroughManager.
Expected<JITTargetAddress>
writeResolverBlock(JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr);
Expected<ExecutorAddr> writeResolverBlock(ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr);
/// Returns the address of the Resolver block. Returns zero if the
/// writeResolverBlock method has not previously been called.
JITTargetAddress getResolverBlockAddress() const { return ResolverBlockAddr; }
ExecutorAddr getResolverBlockAddress() const { return ResolverBlockAddr; }
/// Create an IndirectStubsManager for the executor process.
std::unique_ptr<IndirectStubsManager> createIndirectStubsManager();
@@ -117,7 +114,7 @@ public:
/// This function should only be called once.
LazyCallThroughManager &
createLazyCallThroughManager(ExecutionSession &ES,
JITTargetAddress ErrorHandlerAddr);
ExecutorAddr ErrorHandlerAddr);
/// Create a LazyCallThroughManager for the executor process.
LazyCallThroughManager &getLazyCallThroughManager() {
@@ -130,11 +127,10 @@ private:
struct IndirectStubInfo {
IndirectStubInfo() = default;
IndirectStubInfo(JITTargetAddress StubAddress,
JITTargetAddress PointerAddress)
IndirectStubInfo(ExecutorAddr StubAddress, ExecutorAddr PointerAddress)
: StubAddress(StubAddress), PointerAddress(PointerAddress) {}
JITTargetAddress StubAddress = 0;
JITTargetAddress PointerAddress = 0;
ExecutorAddr StubAddress;
ExecutorAddr PointerAddress;
};
using IndirectStubInfoVector = std::vector<IndirectStubInfo>;
@@ -148,7 +144,7 @@ private:
std::mutex EPCUIMutex;
ExecutorProcessControl &EPC;
std::unique_ptr<ABISupport> ABI;
JITTargetAddress ResolverBlockAddr = 0;
ExecutorAddr ResolverBlockAddr;
FinalizedAlloc ResolverBlock;
std::unique_ptr<TrampolinePool> TP;
std::unique_ptr<LazyCallThroughManager> LCTM;
@@ -181,16 +177,16 @@ public:
ORCABI::ResolverCodeSize) {}
void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddr,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) const override {
ExecutorAddr ResolverTargetAddr,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) const override {
ORCABI::writeResolverCode(ResolverWorkingMem, ResolverTargetAddr,
ReentryFnAddr, ReentryCtxAddr);
}
void writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddr,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTargetAddr,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines) const override {
ORCABI::writeTrampolines(TrampolineBlockWorkingMem,
TrampolineBlockTargetAddr, ResolverAddr,
@@ -198,8 +194,8 @@ public:
}
void writeIndirectStubsBlock(char *StubsBlockWorkingMem,
JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned NumStubs) const override {
ORCABI::writeIndirectStubsBlock(StubsBlockWorkingMem,
StubsBlockTargetAddress,

4
llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h
View File

@@ -180,10 +180,6 @@ public:
void runDestructors();
protected:
template <typename PtrTy> JITTargetAddress toTargetAddress(PtrTy *P) {
return static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(P));
}
using DestructorPtr = void (*)(void *);
using CXXDestructorDataPair = std::pair<DestructorPtr, void *>;
using CXXDestructorDataPairList = std::vector<CXXDestructorDataPair>;

108
llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
View File

@@ -63,17 +63,17 @@ namespace orc {
class TrampolinePool {
public:
using NotifyLandingResolvedFunction =
unique_function<void(JITTargetAddress) const>;
unique_function<void(ExecutorAddr) const>;
using ResolveLandingFunction = unique_function<void(
JITTargetAddress TrampolineAddr,
ExecutorAddr TrampolineAddr,
NotifyLandingResolvedFunction OnLandingResolved) const>;
virtual ~TrampolinePool();
/// Get an available trampoline address.
/// Returns an error if no trampoline can be created.
Expected<JITTargetAddress> getTrampoline() {
Expected<ExecutorAddr> getTrampoline() {
std::lock_guard<std::mutex> Lock(TPMutex);
if (AvailableTrampolines.empty()) {
if (auto Err = grow())
@@ -86,7 +86,7 @@ public:
}
/// Returns the given trampoline to the pool for re-use.
void releaseTrampoline(JITTargetAddress TrampolineAddr) {
void releaseTrampoline(ExecutorAddr TrampolineAddr) {
std::lock_guard<std::mutex> Lock(TPMutex);
AvailableTrampolines.push_back(TrampolineAddr);
}
@@ -95,7 +95,7 @@ protected:
virtual Error grow() = 0;
std::mutex TPMutex;
std::vector<JITTargetAddress> AvailableTrampolines;
std::vector<ExecutorAddr> AvailableTrampolines;
};
/// A trampoline pool for trampolines within the current process.
@@ -121,14 +121,14 @@ private:
LocalTrampolinePool<ORCABI> *TrampolinePool =
static_cast<LocalTrampolinePool *>(TrampolinePoolPtr);
std::promise<JITTargetAddress> LandingAddressP;
std::promise<ExecutorAddr> LandingAddressP;
auto LandingAddressF = LandingAddressP.get_future();
TrampolinePool->ResolveLanding(pointerToJITTargetAddress(TrampolineId),
[&](JITTargetAddress LandingAddress) {
TrampolinePool->ResolveLanding(ExecutorAddr::fromPtr(TrampolineId),
[&](ExecutorAddr LandingAddress) {
LandingAddressP.set_value(LandingAddress);
});
return LandingAddressF.get();
return LandingAddressF.get().getValue();
}
LocalTrampolinePool(ResolveLandingFunction ResolveLanding, Error &Err)
@@ -147,9 +147,9 @@ private:
}
ORCABI::writeResolverCode(static_cast<char *>(ResolverBlock.base()),
pointerToJITTargetAddress(ResolverBlock.base()),
pointerToJITTargetAddress(&reenter),
pointerToJITTargetAddress(this));
ExecutorAddr::fromPtr(ResolverBlock.base()),
ExecutorAddr::fromPtr(&reenter),
ExecutorAddr::fromPtr(this));
EC = sys::Memory::protectMappedMemory(ResolverBlock.getMemoryBlock(),
sys::Memory::MF_READ |
@@ -177,12 +177,12 @@ private:
char *TrampolineMem = static_cast<char *>(TrampolineBlock.base());
ORCABI::writeTrampolines(
TrampolineMem, pointerToJITTargetAddress(TrampolineMem),
pointerToJITTargetAddress(ResolverBlock.base()), NumTrampolines);
TrampolineMem, ExecutorAddr::fromPtr(TrampolineMem),
ExecutorAddr::fromPtr(ResolverBlock.base()), NumTrampolines);
for (unsigned I = 0; I < NumTrampolines; ++I)
AvailableTrampolines.push_back(pointerToJITTargetAddress(
TrampolineMem + (I * ORCABI::TrampolineSize)));
AvailableTrampolines.push_back(
ExecutorAddr::fromPtr(TrampolineMem + (I * ORCABI::TrampolineSize)));
if (auto EC = sys::Memory::protectMappedMemory(
TrampolineBlock.getMemoryBlock(),
@@ -202,22 +202,22 @@ private:
/// Target-independent base class for compile callback management.
class JITCompileCallbackManager {
public:
using CompileFunction = std::function<JITTargetAddress()>;
using CompileFunction = std::function<ExecutorAddr()>;
virtual ~JITCompileCallbackManager() = default;
/// Reserve a compile callback.
Expected<JITTargetAddress> getCompileCallback(CompileFunction Compile);
Expected<ExecutorAddr> getCompileCallback(CompileFunction Compile);
/// Execute the callback for the given trampoline id. Called by the JIT
/// to compile functions on demand.
JITTargetAddress executeCompileCallback(JITTargetAddress TrampolineAddr);
ExecutorAddr executeCompileCallback(ExecutorAddr TrampolineAddr);
protected:
/// Construct a JITCompileCallbackManager.
JITCompileCallbackManager(std::unique_ptr<TrampolinePool> TP,
ExecutionSession &ES,
JITTargetAddress ErrorHandlerAddress)
ExecutorAddr ErrorHandlerAddress)
: TP(std::move(TP)), ES(ES),
CallbacksJD(ES.createBareJITDylib("<Callbacks>")),
ErrorHandlerAddress(ErrorHandlerAddress) {}
@@ -231,8 +231,8 @@ private:
std::unique_ptr<TrampolinePool> TP;
ExecutionSession &ES;
JITDylib &CallbacksJD;
JITTargetAddress ErrorHandlerAddress;
std::map<JITTargetAddress, SymbolStringPtr> AddrToSymbol;
ExecutorAddr ErrorHandlerAddress;
std::map<ExecutorAddr, SymbolStringPtr> AddrToSymbol;
size_t NextCallbackId = 0;
};
@@ -242,7 +242,7 @@ class LocalJITCompileCallbackManager : public JITCompileCallbackManager {
public:
/// Create a new LocalJITCompileCallbackManager.
static Expected<std::unique_ptr<LocalJITCompileCallbackManager>>
Create(ExecutionSession &ES, JITTargetAddress ErrorHandlerAddress) {
Create(ExecutionSession &ES, ExecutorAddr ErrorHandlerAddress) {
Error Err = Error::success();
auto CCMgr = std::unique_ptr<LocalJITCompileCallbackManager>(
new LocalJITCompileCallbackManager(ES, ErrorHandlerAddress, Err));
@@ -256,15 +256,14 @@ private:
/// @param ErrorHandlerAddress The address of an error handler in the target
/// process to be used if a compile callback fails.
LocalJITCompileCallbackManager(ExecutionSession &ES,
JITTargetAddress ErrorHandlerAddress,
Error &Err)
ExecutorAddr ErrorHandlerAddress, Error &Err)
: JITCompileCallbackManager(nullptr, ES, ErrorHandlerAddress) {
using NotifyLandingResolvedFunction =
TrampolinePool::NotifyLandingResolvedFunction;
ErrorAsOutParameter _(&Err);
auto TP = LocalTrampolinePool<ORCABI>::Create(
[this](JITTargetAddress TrampolineAddr,
[this](ExecutorAddr TrampolineAddr,
NotifyLandingResolvedFunction NotifyLandingResolved) {
NotifyLandingResolved(executeCompileCallback(TrampolineAddr));
});
@@ -282,12 +281,12 @@ private:
class IndirectStubsManager {
public:
/// Map type for initializing the manager. See init.
using StubInitsMap = StringMap<std::pair<JITTargetAddress, JITSymbolFlags>>;
using StubInitsMap = StringMap<std::pair<ExecutorAddr, JITSymbolFlags>>;
virtual ~IndirectStubsManager() = default;
/// Create a single stub with the given name, target address and flags.
virtual Error createStub(StringRef StubName, JITTargetAddress StubAddr,
virtual Error createStub(StringRef StubName, ExecutorAddr StubAddr,
JITSymbolFlags StubFlags) = 0;
/// Create StubInits.size() stubs with the given names, target
@@ -297,13 +296,14 @@ public:
/// Find the stub with the given name. If ExportedStubsOnly is true,
/// this will only return a result if the stub's flags indicate that it
/// is exported.
virtual JITEvaluatedSymbol findStub(StringRef Name, bool ExportedStubsOnly) = 0;
virtual ExecutorSymbolDef findStub(StringRef Name,
bool ExportedStubsOnly) = 0;
/// Find the implementation-pointer for the stub.
virtual JITEvaluatedSymbol findPointer(StringRef Name) = 0;
virtual ExecutorSymbolDef findPointer(StringRef Name) = 0;
/// Change the value of the implementation pointer for the stub.
virtual Error updatePointer(StringRef Name, JITTargetAddress NewAddr) = 0;
virtual Error updatePointer(StringRef Name, ExecutorAddr NewAddr) = 0;
private:
virtual void anchor();
@@ -334,10 +334,10 @@ public:
sys::MemoryBlock StubsBlock(StubsAndPtrsMem.base(), ISAS.StubBytes);
auto StubsBlockMem = static_cast<char *>(StubsAndPtrsMem.base());
auto PtrBlockAddress =
pointerToJITTargetAddress(StubsBlockMem) + ISAS.StubBytes;
ExecutorAddr::fromPtr(StubsBlockMem) + ISAS.StubBytes;
ORCABI::writeIndirectStubsBlock(StubsBlockMem,
pointerToJITTargetAddress(StubsBlockMem),
ExecutorAddr::fromPtr(StubsBlockMem),
PtrBlockAddress, ISAS.NumStubs);
if (auto EC = sys::Memory::protectMappedMemory(
@@ -369,7 +369,7 @@ private:
template <typename TargetT>
class LocalIndirectStubsManager : public IndirectStubsManager {
public:
Error createStub(StringRef StubName, JITTargetAddress StubAddr,
Error createStub(StringRef StubName, ExecutorAddr StubAddr,
JITSymbolFlags StubFlags) override {
std::lock_guard<std::mutex> Lock(StubsMutex);
if (auto Err = reserveStubs(1))
@@ -392,36 +392,34 @@ public:
return Error::success();
}
JITEvaluatedSymbol findStub(StringRef Name, bool ExportedStubsOnly) override {
ExecutorSymbolDef findStub(StringRef Name, bool ExportedStubsOnly) override {
std::lock_guard<std::mutex> Lock(StubsMutex);
auto I = StubIndexes.find(Name);
if (I == StubIndexes.end())
return nullptr;
return ExecutorSymbolDef();
auto Key = I->second.first;
void *StubAddr = IndirectStubsInfos[Key.first].getStub(Key.second);
assert(StubAddr && "Missing stub address");
auto StubTargetAddr =
static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(StubAddr));
auto StubSymbol = JITEvaluatedSymbol(StubTargetAddr, I->second.second);
void *StubPtr = IndirectStubsInfos[Key.first].getStub(Key.second);
assert(StubPtr && "Missing stub address");
auto StubAddr = ExecutorAddr::fromPtr(StubPtr);
auto StubSymbol = ExecutorSymbolDef(StubAddr, I->second.second);
if (ExportedStubsOnly && !StubSymbol.getFlags().isExported())
return nullptr;
return ExecutorSymbolDef();
return StubSymbol;
}
JITEvaluatedSymbol findPointer(StringRef Name) override {
ExecutorSymbolDef findPointer(StringRef Name) override {
std::lock_guard<std::mutex> Lock(StubsMutex);
auto I = StubIndexes.find(Name);
if (I == StubIndexes.end())
return nullptr;
return ExecutorSymbolDef();
auto Key = I->second.first;
void *PtrAddr = IndirectStubsInfos[Key.first].getPtr(Key.second);
assert(PtrAddr && "Missing pointer address");
auto PtrTargetAddr =
static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(PtrAddr));
return JITEvaluatedSymbol(PtrTargetAddr, I->second.second);
void *PtrPtr = IndirectStubsInfos[Key.first].getPtr(Key.second);
assert(PtrPtr && "Missing pointer address");
auto PtrAddr = ExecutorAddr::fromPtr(PtrPtr);
return ExecutorSymbolDef(PtrAddr, I->second.second);
}
Error updatePointer(StringRef Name, JITTargetAddress NewAddr) override {
Error updatePointer(StringRef Name, ExecutorAddr NewAddr) override {
using AtomicIntPtr = std::atomic<uintptr_t>;
std::lock_guard<std::mutex> Lock(StubsMutex);
@@ -430,7 +428,7 @@ public:
auto Key = I->second.first;
AtomicIntPtr *AtomicStubPtr = reinterpret_cast<AtomicIntPtr *>(
IndirectStubsInfos[Key.first].getPtr(Key.second));
*AtomicStubPtr = static_cast<uintptr_t>(NewAddr);
*AtomicStubPtr = static_cast<uintptr_t>(NewAddr.getValue());
return Error::success();
}
@@ -451,12 +449,12 @@ private:
return Error::success();
}
void createStubInternal(StringRef StubName, JITTargetAddress InitAddr,
void createStubInternal(StringRef StubName, ExecutorAddr InitAddr,
JITSymbolFlags StubFlags) {
auto Key = FreeStubs.back();
FreeStubs.pop_back();
*IndirectStubsInfos[Key.first].getPtr(Key.second) =
jitTargetAddressToPointer<void *>(InitAddr);
InitAddr.toPtr<void *>();
StubIndexes[StubName] = std::make_pair(Key, StubFlags);
}
@@ -475,7 +473,7 @@ private:
/// manager if a compile callback fails.
Expected<std::unique_ptr<JITCompileCallbackManager>>
createLocalCompileCallbackManager(const Triple &T, ExecutionSession &ES,
JITTargetAddress ErrorHandlerAddress);
ExecutorAddr ErrorHandlerAddress);
/// Create a local indriect stubs manager builder.
///
@@ -488,7 +486,7 @@ createLocalIndirectStubsManagerBuilder(const Triple &T);
///
/// Usage example: Turn a trampoline address into a function pointer constant
/// for use in a stub.
Constant *createIRTypedAddress(FunctionType &FT, JITTargetAddress Addr);
Constant *createIRTypedAddress(FunctionType &FT, ExecutorAddr Addr);
/// Create a function pointer with the given type, name, and initializer
/// in the given Module.

33
llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h
View File

@@ -38,19 +38,19 @@ namespace orc {
class LazyCallThroughManager {
public:
using NotifyResolvedFunction =
unique_function<Error(JITTargetAddress ResolvedAddr)>;
unique_function<Error(ExecutorAddr ResolvedAddr)>;
LazyCallThroughManager(ExecutionSession &ES,
JITTargetAddress ErrorHandlerAddr, TrampolinePool *TP);
LazyCallThroughManager(ExecutionSession &ES, ExecutorAddr ErrorHandlerAddr,
TrampolinePool *TP);
// Return a free call-through trampoline and bind it to look up and call
// through to the given symbol.
Expected<JITTargetAddress>
Expected<ExecutorAddr>
getCallThroughTrampoline(JITDylib &SourceJD, SymbolStringPtr SymbolName,
NotifyResolvedFunction NotifyResolved);
void resolveTrampolineLandingAddress(
JITTargetAddress TrampolineAddr,
ExecutorAddr TrampolineAddr,
TrampolinePool::NotifyLandingResolvedFunction NotifyLandingResolved);
virtual ~LazyCallThroughManager() = default;
@@ -64,20 +64,19 @@ protected:
SymbolStringPtr SymbolName;
};
JITTargetAddress reportCallThroughError(Error Err);
Expected<ReexportsEntry> findReexport(JITTargetAddress TrampolineAddr);
Error notifyResolved(JITTargetAddress TrampolineAddr,
JITTargetAddress ResolvedAddr);
ExecutorAddr reportCallThroughError(Error Err);
Expected<ReexportsEntry> findReexport(ExecutorAddr TrampolineAddr);
Error notifyResolved(ExecutorAddr TrampolineAddr, ExecutorAddr ResolvedAddr);
void setTrampolinePool(TrampolinePool &TP) { this->TP = &TP; }
private:
using ReexportsMap = std::map<JITTargetAddress, ReexportsEntry>;
using ReexportsMap = std::map<ExecutorAddr, ReexportsEntry>;
using NotifiersMap = std::map<JITTargetAddress, NotifyResolvedFunction>;
using NotifiersMap = std::map<ExecutorAddr, NotifyResolvedFunction>;
std::mutex LCTMMutex;
ExecutionSession &ES;
JITTargetAddress ErrorHandlerAddr;
ExecutorAddr ErrorHandlerAddr;
TrampolinePool *TP = nullptr;
ReexportsMap Reexports;
NotifiersMap Notifiers;
@@ -86,15 +85,15 @@ private:
/// A lazy call-through manager that builds trampolines in the current process.
class LocalLazyCallThroughManager : public LazyCallThroughManager {
private:
using NotifyTargetResolved = unique_function<void(JITTargetAddress)>;
using NotifyTargetResolved = unique_function<void(ExecutorAddr)>;
LocalLazyCallThroughManager(ExecutionSession &ES,
JITTargetAddress ErrorHandlerAddr)
ExecutorAddr ErrorHandlerAddr)
: LazyCallThroughManager(ES, ErrorHandlerAddr, nullptr) {}
template <typename ORCABI> Error init() {
auto TP = LocalTrampolinePool<ORCABI>::Create(
[this](JITTargetAddress TrampolineAddr,
[this](ExecutorAddr TrampolineAddr,
TrampolinePool::NotifyLandingResolvedFunction
NotifyLandingResolved) {
resolveTrampolineLandingAddress(TrampolineAddr,
@@ -116,7 +115,7 @@ public:
/// createLocalLazyCallThroughManager.
template <typename ORCABI>
static Expected<std::unique_ptr<LocalLazyCallThroughManager>>
Create(ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr) {
Create(ExecutionSession &ES, ExecutorAddr ErrorHandlerAddr) {
auto LLCTM = std::unique_ptr<LocalLazyCallThroughManager>(
new LocalLazyCallThroughManager(ES, ErrorHandlerAddr));
@@ -131,7 +130,7 @@ public:
/// session.
Expected<std::unique_ptr<LazyCallThroughManager>>
createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES,
JITTargetAddress ErrorHandlerAddr);
ExecutorAddr ErrorHandlerAddr);
/// A materialization unit that builds lazy re-exports. These are callable
/// entry points that call through to the given symbols.

157
llvm/include/llvm/ExecutionEngine/Orc/OrcABISupport.h
View File

@@ -17,7 +17,7 @@
#ifndef LLVM_EXECUTIONENGINE_ORC_ORCABISUPPORT_H
#define LLVM_EXECUTIONENGINE_ORC_ORCABISUPPORT_H
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
@@ -61,24 +61,25 @@ public:
static constexpr unsigned ResolverCodeSize = 1;
static void writeResolverCode(char *ResolveWorkingMem,
JITTargetAddress ResolverTargetAddr,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
ExecutorAddr ResolverTargetAddr,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
llvm_unreachable("writeResolverCode is not supported by the generic host "
"support class");
}
static void writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddr,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTargetAddr,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines) {
llvm_unreachable("writeTrampolines is not supported by the generic host "
"support class");
}
static void writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs) {
static void writeIndirectStubsBlock(char *StubsBlockWorkingMem,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned NumStubs) {
llvm_unreachable(
"writeIndirectStubsBlock is not supported by the generic host "
"support class");
@@ -101,25 +102,26 @@ public:
/// argument of writeResolverCode will be passed as the second argument to
/// the function at ReentryFnAddr.
static void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress RentryCtxAddr);
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr RentryCtxAddr);
/// Write the requested number of trampolines into the given memory,
/// which must be big enough to hold 1 pointer, plus NumTrampolines
/// trampolines.
static void writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines);
/// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
/// Stubs will be written as if linked at StubsBlockTargetAddress, with the
/// Nth stub using the Nth pointer in memory starting at
/// PointersBlockTargetAddress.
static void writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned MinStubs);
static void writeIndirectStubsBlock(char *StubsBlockWorkingMem,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned MinStubs);
};
/// X86_64 code that's common to all ABIs.
@@ -136,17 +138,18 @@ public:
/// which must be big enough to hold 1 pointer, plus NumTrampolines
/// trampolines.
static void writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines);
/// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
/// Stubs will be written as if linked at StubsBlockTargetAddress, with the
/// Nth stub using the Nth pointer in memory starting at
/// PointersBlockTargetAddress.
static void writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs);
static void writeIndirectStubsBlock(char *StubsBlockWorkingMem,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned NumStubs);
};
/// X86_64 support for SysV ABI (Linux, MacOSX).
@@ -164,9 +167,9 @@ public:
/// argument of writeResolverCode will be passed as the second argument to
/// the function at ReentryFnAddr.
static void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr);
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr);
};
/// X86_64 support for Win32.
@@ -184,9 +187,9 @@ public:
/// argument of writeResolverCode will be passed as the second argument to
/// the function at ReentryFnAddr.
static void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr);
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr);
};
/// I386 support.
@@ -208,25 +211,26 @@ public:
/// argument of writeResolverCode will be passed as the second argument to
/// the function at ReentryFnAddr.
static void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr);
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr);
/// Write the requested number of trampolines into the given memory,
/// which must be big enough to hold 1 pointer, plus NumTrampolines
/// trampolines.
static void writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines);
/// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
/// Stubs will be written as if linked at StubsBlockTargetAddress, with the
/// Nth stub using the Nth pointer in memory starting at
/// PointersBlockTargetAddress.
static void writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs);
static void writeIndirectStubsBlock(char *StubsBlockWorkingMem,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned NumStubs);
};
// @brief Mips32 support.
@@ -244,8 +248,8 @@ public:
/// which must be big enough to hold 1 pointer, plus NumTrampolines
/// trampolines.
static void writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines);
/// Write the resolver code into the given memory. The user is
@@ -256,25 +260,25 @@ public:
/// argument of writeResolverCode will be passed as the second argument to
/// the function at ReentryFnAddr.
static void writeResolverCode(char *ResolverBlockWorkingMem,
JITTargetAddress ResolverBlockTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr,
bool isBigEndian);
ExecutorAddr ResolverBlockTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr, bool isBigEndian);
/// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
/// Stubs will be written as if linked at StubsBlockTargetAddress, with the
/// Nth stub using the Nth pointer in memory starting at
/// PointersBlockTargetAddress.
static void writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs);
static void writeIndirectStubsBlock(char *StubsBlockWorkingMem,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned NumStubs);
};
class OrcMips32Le : public OrcMips32_Base {
public:
static void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
OrcMips32_Base::writeResolverCode(ResolverWorkingMem, ResolverTargetAddress,
ReentryFnAddr, ReentryCtxAddr, false);
}
@@ -283,9 +287,9 @@ public:
class OrcMips32Be : public OrcMips32_Base {
public:
static void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
OrcMips32_Base::writeResolverCode(ResolverWorkingMem, ResolverTargetAddress,
ReentryFnAddr, ReentryCtxAddr, true);
}
@@ -310,24 +314,25 @@ public:
/// argument of writeResolverCode will be passed as the second argument to
/// the function at ReentryFnAddr.
static void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr);
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr);
/// Write the requested number of trampolines into the given memory,
/// which must be big enough to hold 1 pointer, plus NumTrampolines
/// trampolines.
static void writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverFnAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverFnAddr,
unsigned NumTrampolines);
/// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
/// Stubs will be written as if linked at StubsBlockTargetAddress, with the
/// Nth stub using the Nth pointer in memory starting at
/// PointersBlockTargetAddress.
static void writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs);
static void writeIndirectStubsBlock(char *StubsBlockWorkingMem,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned NumStubs);
};
// @brief riscv64 support.
@@ -349,24 +354,25 @@ public:
/// argument of writeResolverCode will be passed as the second argument to
/// the function at ReentryFnAddr.
static void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr);
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr);
/// Write the requested number of trampolines into the given memory,
/// which must be big enough to hold 1 pointer, plus NumTrampolines
/// trampolines.
static void writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverFnAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverFnAddr,
unsigned NumTrampolines);
/// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
/// Stubs will be written as if linked at StubsBlockTargetAddress, with the
/// Nth stub using the Nth pointer in memory starting at
/// PointersBlockTargetAddress.
static void writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs);
static void writeIndirectStubsBlock(char *StubsBlockWorkingMem,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned NumStubs);
};
// @brief loongarch64 support.
@@ -388,25 +394,26 @@ public:
/// argument of writeResolverCode will be passed as the second argument to
/// the function at ReentryFnAddr.
static void writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr);
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr);
/// Write the requested number of trampolines into the given memory,
/// which must be big enough to hold 1 pointer, plus NumTrampolines
/// trampolines.
static void writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverFnAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverFnAddr,
unsigned NumTrampolines);
/// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
/// Stubs will be written as if linked at StubsBlockTargetAddress, with the
/// Nth stub using the Nth pointer in memory starting at
/// PointersBlockTargetAddress.
static void writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs);
static void writeIndirectStubsBlock(char *StubsBlockWorkingMem,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned NumStubs);
};
} // end namespace orc

8
llvm/include/llvm/ExecutionEngine/Orc/Speculation.h
View File

@@ -59,7 +59,7 @@ private:
// Defines Speculator Concept,
class Speculator {
public:
using TargetFAddr = JITTargetAddress;
using TargetFAddr = ExecutorAddr;
using FunctionCandidatesMap = DenseMap<SymbolStringPtr, SymbolNameSet>;
using StubAddrLikelies = DenseMap<TargetFAddr, SymbolNameSet>;
@@ -70,7 +70,7 @@ private:
GlobalSpecMap.insert({ImplAddr, std::move(likelySymbols)});
}
void launchCompile(JITTargetAddress FAddr) {
void launchCompile(ExecutorAddr FAddr) {
SymbolNameSet CandidateSet;
// Copy CandidateSet is necessary, to avoid unsynchronized access to
// the datastructure.
@@ -144,8 +144,8 @@ public:
auto OnReadyFixUp = [Likely, Target,
this](Expected<SymbolMap> ReadySymbol) {
if (ReadySymbol) {
auto RAddr = (*ReadySymbol)[Target].getAddress();
registerSymbolsWithAddr(RAddr, std::move(Likely));
auto RDef = (*ReadySymbol)[Target];
registerSymbolsWithAddr(RDef.getAddress(), std::move(Likely));
} else
this->getES().reportError(ReadySymbol.takeError());
};

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

@@ -196,7 +196,7 @@ public:
auto ImageBase = getImageBaseAddress(G, Ctx);
if (!ImageBase)
return ImageBase.takeError();
E.setAddend(E.getAddend() - *ImageBase);
E.setAddend(E.getAddend() - ImageBase->getValue());
E.setKind(x86_64::Pointer32);
break;
}
@@ -238,19 +238,19 @@ private:
return SectionStartCache[&Sec];
}
Expected<JITTargetAddress> getImageBaseAddress(LinkGraph &G,
JITLinkContext &Ctx) {
Expected<orc::ExecutorAddr> getImageBaseAddress(LinkGraph &G,
JITLinkContext &Ctx) {
if (this->ImageBase)
return this->ImageBase;
for (auto *S : G.defined_symbols())
if (S->getName() == getImageBaseSymbolName()) {
this->ImageBase = S->getAddress().getValue();
this->ImageBase = S->getAddress();
return this->ImageBase;
}
JITLinkContext::LookupMap Symbols;
Symbols[getImageBaseSymbolName()] = SymbolLookupFlags::RequiredSymbol;
JITTargetAddress ImageBase;
orc::ExecutorAddr ImageBase;
Error Err = Error::success();
Ctx.lookup(Symbols,
createLookupContinuation([&](Expected<AsyncLookupResult> LR) {
@@ -259,8 +259,7 @@ private:
Err = LR.takeError();
return;
}
auto &ImageBaseSymbol = LR->begin()->second;
ImageBase = ImageBaseSymbol.getAddress();
ImageBase = LR->begin()->second.getAddress();
}));
if (Err)
return std::move(Err);
@@ -269,7 +268,7 @@ private:
}
DenseMap<Section *, orc::ExecutorAddr> SectionStartCache;
JITTargetAddress ImageBase = 0;
orc::ExecutorAddr ImageBase;
};
Error lowerEdges_COFF_x86_64(LinkGraph &G, JITLinkContext *Ctx) {

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

@@ -218,8 +218,7 @@ void JITLinkerBase::applyLookupResult(AsyncLookupResult Result) {
assert(!Sym->isDefined() && "Symbol being resolved is already defined");
auto ResultI = Result.find(Sym->getName());
if (ResultI != Result.end()) {
Sym->getAddressable().setAddress(
orc::ExecutorAddr(ResultI->second.getAddress()));
Sym->getAddressable().setAddress(ResultI->second.getAddress());
Sym->setLinkage(ResultI->second.getFlags().isWeak() ? Linkage::Weak
: Linkage::Strong);
Sym->setScope(ResultI->second.getFlags().isExported() ? Scope::Default

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

@@ -185,13 +185,13 @@ COFFPlatform::Create(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
auto &HostFuncJD = ES.createBareJITDylib("$<PlatformRuntimeHostFuncJD>");
// Add JIT-dispatch function support symbols.
if (auto Err = HostFuncJD.define(absoluteSymbols(
{{ES.intern("__orc_rt_jit_dispatch"),
{EPC.getJITDispatchInfo().JITDispatchFunction.getValue(),
JITSymbolFlags::Exported}},
{ES.intern("__orc_rt_jit_dispatch_ctx"),
{EPC.getJITDispatchInfo().JITDispatchContext.getValue(),
JITSymbolFlags::Exported}}})))
if (auto Err = HostFuncJD.define(
absoluteSymbols({{ES.intern("__orc_rt_jit_dispatch"),
{EPC.getJITDispatchInfo().JITDispatchFunction,
JITSymbolFlags::Exported}},
{ES.intern("__orc_rt_jit_dispatch_ctx"),
{EPC.getJITDispatchInfo().JITDispatchContext,
JITSymbolFlags::Exported}}})))
return std::move(Err);
PlatformJD.addToLinkOrder(HostFuncJD);

28
llvm/lib/ExecutionEngine/Orc/Core.cpp
View File

@@ -167,15 +167,16 @@ AsynchronousSymbolQuery::AsynchronousSymbolQuery(
OutstandingSymbolsCount = Symbols.size();
for (auto &KV : Symbols)
ResolvedSymbols[KV.first] = nullptr;
ResolvedSymbols[KV.first] = ExecutorSymbolDef();
}
void AsynchronousSymbolQuery::notifySymbolMetRequiredState(
const SymbolStringPtr &Name, JITEvaluatedSymbol Sym) {
const SymbolStringPtr &Name, ExecutorSymbolDef Sym) {
auto I = ResolvedSymbols.find(Name);
assert(I != ResolvedSymbols.end() &&
"Resolving symbol outside the requested set");
assert(I->second.getAddress() == 0 && "Redundantly resolving symbol Name");
assert(I->second == ExecutorSymbolDef() &&
"Redundantly resolving symbol Name");
// If this is a materialization-side-effects-only symbol then drop it,
// otherwise update its map entry with its resolved address.
@@ -447,8 +448,8 @@ void ReExportsMaterializationUnit::materialize(
if (KV.second.AliasFlags.hasMaterializationSideEffectsOnly())
continue;
ResolutionMap[KV.first] = JITEvaluatedSymbol(
(*Result)[KV.second.Aliasee].getAddress(), KV.second.AliasFlags);
ResolutionMap[KV.first] = {(*Result)[KV.second.Aliasee].getAddress(),
KV.second.AliasFlags};
}
if (auto Err = QueryInfo->R->notifyResolved(ResolutionMap)) {
ES.reportError(std::move(Err));
@@ -945,7 +946,7 @@ Error JITDylib::resolve(MaterializationResponsibility &MR,
struct WorklistEntry {
SymbolTable::iterator SymI;
JITEvaluatedSymbol ResolvedSym;
ExecutorSymbolDef ResolvedSym;
};
SymbolNameSet SymbolsInErrorState;
@@ -977,8 +978,7 @@ Error JITDylib::resolve(MaterializationResponsibility &MR,
(SymI->second.getFlags() & ~JITSymbolFlags::Common) &&
"Resolved flags should match the declared flags");
Worklist.push_back(
{SymI, JITEvaluatedSymbol(KV.second.getAddress(), Flags)});
Worklist.push_back({SymI, {KV.second.getAddress(), Flags}});
}
}
@@ -2164,7 +2164,7 @@ ExecutionSession::lookup(const JITDylibSearchOrder &SearchOrder,
#endif
}
Expected<JITEvaluatedSymbol>
Expected<ExecutorSymbolDef>
ExecutionSession::lookup(const JITDylibSearchOrder &SearchOrder,
SymbolStringPtr Name, SymbolState RequiredState) {
SymbolLookupSet Names({Name});
@@ -2178,13 +2178,13 @@ ExecutionSession::lookup(const JITDylibSearchOrder &SearchOrder,
return ResultMap.takeError();
}
Expected<JITEvaluatedSymbol>
Expected<ExecutorSymbolDef>
ExecutionSession::lookup(ArrayRef<JITDylib *> SearchOrder, SymbolStringPtr Name,
SymbolState RequiredState) {
return lookup(makeJITDylibSearchOrder(SearchOrder), Name, RequiredState);
}
Expected<JITEvaluatedSymbol>
Expected<ExecutorSymbolDef>
ExecutionSession::lookup(ArrayRef<JITDylib *> SearchOrder, StringRef Name,
SymbolState RequiredState) {
return lookup(SearchOrder, intern(Name), RequiredState);
@@ -2221,9 +2221,9 @@ Error ExecutionSession::registerJITDispatchHandlers(
return Error::success();
}
void ExecutionSession::runJITDispatchHandler(
SendResultFunction SendResult, JITTargetAddress HandlerFnTagAddr,
ArrayRef<char> ArgBuffer) {
void ExecutionSession::runJITDispatchHandler(SendResultFunction SendResult,
ExecutorAddr HandlerFnTagAddr,
ArrayRef<char> ArgBuffer) {
std::shared_ptr<JITDispatchHandlerFunction> F;
{

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

@@ -106,8 +106,8 @@ Error ELFDebugObjectSection<ELFT>::validateInBounds(StringRef Buffer,
template <typename ELFT>
void ELFDebugObjectSection<ELFT>::dump(raw_ostream &OS, StringRef Name) {
if (auto Addr = static_cast<JITTargetAddress>(Header->sh_addr)) {
OS << formatv(" {0:x16} {1}\n", Addr, Name);
if (Header->sh_addr) {
OS << formatv(" {0:x16} {1}\n", Header->sh_addr, Name);
} else {
OS << formatv(" {0}\n", Name);
}

5
llvm/lib/ExecutionEngine/Orc/DebugUtils.cpp
View File

@@ -172,9 +172,8 @@ raw_ostream &operator<<(raw_ostream &OS, const JITSymbolFlags &Flags) {
return OS;
}
raw_ostream &operator<<(raw_ostream &OS, const JITEvaluatedSymbol &Sym) {
return OS << format("0x%016" PRIx64, Sym.getAddress()) << " "
<< Sym.getFlags();
raw_ostream &operator<<(raw_ostream &OS, const ExecutorSymbolDef &Sym) {
return OS << Sym.getAddress() << " " << Sym.getFlags();
}
raw_ostream &operator<<(raw_ostream &OS, const SymbolFlagsMap::value_type &KV) {

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

@@ -377,11 +377,11 @@ GDBJITDebugInfoRegistrationPlugin::Create(ExecutionSession &ES,
? ES.intern("_llvm_orc_registerJITLoaderGDBAllocAction")
: ES.intern("llvm_orc_registerJITLoaderGDBAllocAction");
if (auto Addr = ES.lookup({&ProcessJD}, RegisterActionAddr))
if (auto RegisterSym = ES.lookup({&ProcessJD}, RegisterActionAddr))
return std::make_unique<GDBJITDebugInfoRegistrationPlugin>(
ExecutorAddr(Addr->getAddress()));
RegisterSym->getAddress());
else
return Addr.takeError();
return RegisterSym.takeError();
}
Error GDBJITDebugInfoRegistrationPlugin::notifyFailed(

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

@@ -127,13 +127,13 @@ Expected<std::unique_ptr<ELFNixPlatform>> ELFNixPlatform::Create(
return std::move(Err);
// Add JIT-dispatch function support symbols.
if (auto Err = PlatformJD.define(absoluteSymbols(
{{ES.intern("__orc_rt_jit_dispatch"),
{EPC.getJITDispatchInfo().JITDispatchFunction.getValue(),
JITSymbolFlags::Exported}},
{ES.intern("__orc_rt_jit_dispatch_ctx"),
{EPC.getJITDispatchInfo().JITDispatchContext.getValue(),
JITSymbolFlags::Exported}}})))
if (auto Err = PlatformJD.define(
absoluteSymbols({{ES.intern("__orc_rt_jit_dispatch"),
{EPC.getJITDispatchInfo().JITDispatchFunction,
JITSymbolFlags::Exported}},
{ES.intern("__orc_rt_jit_dispatch_ctx"),
{EPC.getJITDispatchInfo().JITDispatchContext,
JITSymbolFlags::Exported}}})))
return std::move(Err);
// Create the instance.
@@ -492,7 +492,7 @@ void ELFNixPlatform::rt_lookupSymbol(SendSymbolAddressFn SendResult,
void operator()(Expected<SymbolMap> Result) {
if (Result) {
assert(Result->size() == 1 && "Unexpected result map count");
SendResult(ExecutorAddr(Result->begin()->second.getAddress()));
SendResult(Result->begin()->second.getAddress());
} else {
SendResult(Result.takeError());
}
@@ -534,7 +534,7 @@ Error ELFNixPlatform::bootstrapELFNixRuntime(JITDylib &PlatformJD) {
for (const auto &KV : AddrsToRecord) {
auto &Name = KV.first;
assert(RuntimeSymbolAddrs->count(Name) && "Missing runtime symbol?");
KV.second->setValue((*RuntimeSymbolAddrs)[Name].getAddress());
*KV.second = (*RuntimeSymbolAddrs)[Name].getAddress();
}
auto PJDDSOHandle = ES.lookup(
@@ -543,7 +543,8 @@ Error ELFNixPlatform::bootstrapELFNixRuntime(JITDylib &PlatformJD) {
return PJDDSOHandle.takeError();
if (auto Err = ES.callSPSWrapper<void(uint64_t)>(
orc_rt_elfnix_platform_bootstrap, PJDDSOHandle->getAddress()))
orc_rt_elfnix_platform_bootstrap,
PJDDSOHandle->getAddress().getValue()))
return Err;
// FIXME: Ordering is fuzzy here. We're probably best off saying

3
llvm/lib/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.cpp
View File

@@ -53,8 +53,7 @@ Error EPCDynamicLibrarySearchGenerator::tryToGenerate(
auto ResultI = Result->front().begin();
for (auto &KV : LookupSymbols) {
if (*ResultI)
NewSymbols[KV.first] =
JITEvaluatedSymbol(ResultI->getValue(), JITSymbolFlags::Exported);
NewSymbols[KV.first] = {*ResultI, JITSymbolFlags::Exported};
++ResultI;
}

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

@@ -58,16 +58,16 @@ public:
Error deallocateStubs();
Error createStub(StringRef StubName, JITTargetAddress StubAddr,
Error createStub(StringRef StubName, ExecutorAddr StubAddr,
JITSymbolFlags StubFlags) override;
Error createStubs(const StubInitsMap &StubInits) override;
JITEvaluatedSymbol findStub(StringRef Name, bool ExportedStubsOnly) override;
ExecutorSymbolDef findStub(StringRef Name, bool ExportedStubsOnly) override;
JITEvaluatedSymbol findPointer(StringRef Name) override;
ExecutorSymbolDef findPointer(StringRef Name) override;
Error updatePointer(StringRef Name, JITTargetAddress NewAddr) override;
Error updatePointer(StringRef Name, ExecutorAddr NewAddr) override;
private:
using StubInfo = std::pair<IndirectStubInfo, JITSymbolFlags>;
@@ -118,12 +118,10 @@ Error EPCTrampolinePool::grow() {
unsigned NumTrampolines = TrampolinesPerPage;
auto SegInfo = Alloc->getSegInfo(MemProt::Read | MemProt::Exec);
EPCIU.getABISupport().writeTrampolines(SegInfo.WorkingMem.data(),
SegInfo.Addr.getValue(),
ResolverAddress, NumTrampolines);
EPCIU.getABISupport().writeTrampolines(
SegInfo.WorkingMem.data(), SegInfo.Addr, ResolverAddress, NumTrampolines);
for (unsigned I = 0; I < NumTrampolines; ++I)
AvailableTrampolines.push_back(SegInfo.Addr.getValue() +
(I * TrampolineSize));
AvailableTrampolines.push_back(SegInfo.Addr + (I * TrampolineSize));
auto FA = Alloc->finalize();
if (!FA)
@@ -135,7 +133,7 @@ Error EPCTrampolinePool::grow() {
}
Error EPCIndirectStubsManager::createStub(StringRef StubName,
JITTargetAddress StubAddr,
ExecutorAddr StubAddr,
JITSymbolFlags StubFlags) {
StubInitsMap SIM;
SIM[StubName] = std::make_pair(StubAddr, StubFlags);
@@ -164,7 +162,7 @@ Error EPCIndirectStubsManager::createStubs(const StubInitsMap &StubInits) {
for (auto &SI : StubInits)
PtrUpdates.push_back(
{ExecutorAddr((*AvailableStubInfos)[ASIdx++].PointerAddress),
static_cast<uint32_t>(SI.second.first)});
static_cast<uint32_t>(SI.second.first.getValue())});
return MemAccess.writeUInt32s(PtrUpdates);
}
case 8: {
@@ -173,7 +171,7 @@ Error EPCIndirectStubsManager::createStubs(const StubInitsMap &StubInits) {
for (auto &SI : StubInits)
PtrUpdates.push_back(
{ExecutorAddr((*AvailableStubInfos)[ASIdx++].PointerAddress),
static_cast<uint64_t>(SI.second.first)});
static_cast<uint64_t>(SI.second.first.getValue())});
return MemAccess.writeUInt64s(PtrUpdates);
}
default:
@@ -182,27 +180,27 @@ Error EPCIndirectStubsManager::createStubs(const StubInitsMap &StubInits) {
}
}
JITEvaluatedSymbol EPCIndirectStubsManager::findStub(StringRef Name,
bool ExportedStubsOnly) {
ExecutorSymbolDef EPCIndirectStubsManager::findStub(StringRef Name,
bool ExportedStubsOnly) {
std::lock_guard<std::mutex> Lock(ISMMutex);
auto I = StubInfos.find(Name);
if (I == StubInfos.end())
return nullptr;
return ExecutorSymbolDef();
return {I->second.first.StubAddress, I->second.second};
}
JITEvaluatedSymbol EPCIndirectStubsManager::findPointer(StringRef Name) {
ExecutorSymbolDef EPCIndirectStubsManager::findPointer(StringRef Name) {
std::lock_guard<std::mutex> Lock(ISMMutex);
auto I = StubInfos.find(Name);
if (I == StubInfos.end())
return nullptr;
return ExecutorSymbolDef();
return {I->second.first.PointerAddress, I->second.second};
}
Error EPCIndirectStubsManager::updatePointer(StringRef Name,
JITTargetAddress NewAddr) {
ExecutorAddr NewAddr) {
JITTargetAddress PtrAddr = 0;
ExecutorAddr PtrAddr;
{
std::lock_guard<std::mutex> Lock(ISMMutex);
auto I = StubInfos.find(Name);
@@ -215,11 +213,11 @@ Error EPCIndirectStubsManager::updatePointer(StringRef Name,
auto &MemAccess = EPCIU.getExecutorProcessControl().getMemoryAccess();
switch (EPCIU.getABISupport().getPointerSize()) {
case 4: {
tpctypes::UInt32Write PUpdate(ExecutorAddr(PtrAddr), NewAddr);
tpctypes::UInt32Write PUpdate(PtrAddr, NewAddr.getValue());
return MemAccess.writeUInt32s(PUpdate);
}
case 8: {
tpctypes::UInt64Write PUpdate(ExecutorAddr(PtrAddr), NewAddr);
tpctypes::UInt64Write PUpdate(PtrAddr, NewAddr.getValue());
return MemAccess.writeUInt64s(PUpdate);
}
default:
@@ -290,9 +288,9 @@ Error EPCIndirectionUtils::cleanup() {
return Err;
}
Expected<JITTargetAddress>
EPCIndirectionUtils::writeResolverBlock(JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
Expected<ExecutorAddr>
EPCIndirectionUtils::writeResolverBlock(ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
using namespace jitlink;
assert(ABI && "ABI can not be null");
@@ -307,7 +305,7 @@ EPCIndirectionUtils::writeResolverBlock(JITTargetAddress ReentryFnAddr,
return Alloc.takeError();
auto SegInfo = Alloc->getSegInfo(MemProt::Read | MemProt::Exec);
ResolverBlockAddr = SegInfo.Addr.getValue();
ResolverBlockAddr = SegInfo.Addr;
ABI->writeResolverCode(SegInfo.WorkingMem.data(), ResolverBlockAddr,
ReentryFnAddr, ReentryCtxAddr);
@@ -331,7 +329,7 @@ TrampolinePool &EPCIndirectionUtils::getTrampolinePool() {
}
LazyCallThroughManager &EPCIndirectionUtils::createLazyCallThroughManager(
ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr) {
ExecutionSession &ES, ExecutorAddr ErrorHandlerAddr) {
assert(!LCTM &&
"createLazyCallThroughManager can not have been called before");
LCTM = std::make_unique<LazyCallThroughManager>(ES, ErrorHandlerAddr,
@@ -377,9 +375,8 @@ EPCIndirectionUtils::getIndirectStubs(unsigned NumStubs) {
auto StubSeg = Alloc->getSegInfo(StubProt);
auto PtrSeg = Alloc->getSegInfo(PtrProt);
ABI->writeIndirectStubsBlock(StubSeg.WorkingMem.data(),
StubSeg.Addr.getValue(),
PtrSeg.Addr.getValue(), NumStubsToAllocate);
ABI->writeIndirectStubsBlock(StubSeg.WorkingMem.data(), StubSeg.Addr,
PtrSeg.Addr, NumStubsToAllocate);
auto FA = Alloc->finalize();
if (!FA)
@@ -390,8 +387,8 @@ EPCIndirectionUtils::getIndirectStubs(unsigned NumStubs) {
auto StubExecutorAddr = StubSeg.Addr;
auto PtrExecutorAddr = PtrSeg.Addr;
for (unsigned I = 0; I != NumStubsToAllocate; ++I) {
AvailableIndirectStubs.push_back(IndirectStubInfo(
StubExecutorAddr.getValue(), PtrExecutorAddr.getValue()));
AvailableIndirectStubs.push_back(
IndirectStubInfo(StubExecutorAddr, PtrExecutorAddr));
StubExecutorAddr += ABI->getStubSize();
PtrExecutorAddr += ABI->getPointerSize();
}
@@ -412,19 +409,19 @@ EPCIndirectionUtils::getIndirectStubs(unsigned NumStubs) {
static JITTargetAddress reentry(JITTargetAddress LCTMAddr,
JITTargetAddress TrampolineAddr) {
auto &LCTM = *jitTargetAddressToPointer<LazyCallThroughManager *>(LCTMAddr);
std::promise<JITTargetAddress> LandingAddrP;
std::promise<ExecutorAddr> LandingAddrP;
auto LandingAddrF = LandingAddrP.get_future();
LCTM.resolveTrampolineLandingAddress(
TrampolineAddr,
[&](JITTargetAddress Addr) { LandingAddrP.set_value(Addr); });
return LandingAddrF.get();
ExecutorAddr(TrampolineAddr),
[&](ExecutorAddr Addr) { LandingAddrP.set_value(Addr); });
return LandingAddrF.get().getValue();
}
Error setUpInProcessLCTMReentryViaEPCIU(EPCIndirectionUtils &EPCIU) {
auto &LCTM = EPCIU.getLazyCallThroughManager();
return EPCIU
.writeResolverBlock(pointerToJITTargetAddress(&reentry),
pointerToJITTargetAddress(&LCTM))
.writeResolverBlock(ExecutorAddr::fromPtr(&reentry),
ExecutorAddr::fromPtr(&LCTM))
.takeError();
}

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

@@ -156,8 +156,7 @@ Error CtorDtorRunner::run() {
for (auto &KV : CtorDtorsByPriority) {
for (auto &Name : KV.second) {
assert(CtorDtorMap->count(Name) && "No entry for Name");
auto CtorDtor = reinterpret_cast<CtorDtorTy>(
static_cast<uintptr_t>((*CtorDtorMap)[Name].getAddress()));
auto CtorDtor = (*CtorDtorMap)[Name].getAddress().toPtr<CtorDtorTy>();
CtorDtor();
}
}
@@ -186,12 +185,10 @@ int LocalCXXRuntimeOverridesBase::CXAAtExitOverride(DestructorPtr Destructor,
Error LocalCXXRuntimeOverrides::enable(JITDylib &JD,
MangleAndInterner &Mangle) {
SymbolMap RuntimeInterposes;
RuntimeInterposes[Mangle("__dso_handle")] =
JITEvaluatedSymbol(toTargetAddress(&DSOHandleOverride),
JITSymbolFlags::Exported);
RuntimeInterposes[Mangle("__cxa_atexit")] =
JITEvaluatedSymbol(toTargetAddress(&CXAAtExitOverride),
JITSymbolFlags::Exported);
RuntimeInterposes[Mangle("__dso_handle")] = {
ExecutorAddr::fromPtr(&DSOHandleOverride), JITSymbolFlags::Exported};
RuntimeInterposes[Mangle("__cxa_atexit")] = {
ExecutorAddr::fromPtr(&CXAAtExitOverride), JITSymbolFlags::Exported};
return JD.define(absoluteSymbols(std::move(RuntimeInterposes)));
}
@@ -257,11 +254,8 @@ Error DynamicLibrarySearchGenerator::tryToGenerate(
std::string Tmp((*Name).data() + HasGlobalPrefix,
(*Name).size() - HasGlobalPrefix);
if (void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str())) {
NewSymbols[Name] = JITEvaluatedSymbol(
static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)),
JITSymbolFlags::Exported);
}
if (void *P = Dylib.getAddressOfSymbol(Tmp.c_str()))
NewSymbols[Name] = {ExecutorAddr::fromPtr(P), JITSymbolFlags::Exported};
}
if (NewSymbols.empty())

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

@@ -192,7 +192,7 @@ SelfExecutorProcessControl::jitDispatchViaWrapperFunctionManager(
shared::WrapperFunctionResult Result) mutable {
ResultP.set_value(std::move(Result));
},
pointerToJITTargetAddress(FnTag), {Data, Size});
ExecutorAddr::fromPtr(FnTag), {Data, Size});
return ResultF.get().release();
}

24
llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp
View File

@@ -40,7 +40,7 @@ public:
private:
void materialize(std::unique_ptr<MaterializationResponsibility> R) override {
SymbolMap Result;
Result[Name] = JITEvaluatedSymbol(Compile(), JITSymbolFlags::Exported);
Result[Name] = {Compile(), JITSymbolFlags::Exported};
// No dependencies, so these calls cannot fail.
cantFail(R->notifyResolved(Result));
cantFail(R->notifyEmitted());
@@ -62,7 +62,7 @@ namespace orc {
TrampolinePool::~TrampolinePool() = default;
void IndirectStubsManager::anchor() {}
Expected<JITTargetAddress>
Expected<ExecutorAddr>
JITCompileCallbackManager::getCompileCallback(CompileFunction Compile) {
if (auto TrampolineAddr = TP->getTrampoline()) {
auto CallbackName =
@@ -78,8 +78,8 @@ JITCompileCallbackManager::getCompileCallback(CompileFunction Compile) {
return TrampolineAddr.takeError();
}
JITTargetAddress JITCompileCallbackManager::executeCompileCallback(
JITTargetAddress TrampolineAddr) {
ExecutorAddr
JITCompileCallbackManager::executeCompileCallback(ExecutorAddr TrampolineAddr) {
SymbolStringPtr Name;
{
@@ -91,14 +91,10 @@ JITTargetAddress JITCompileCallbackManager::executeCompileCallback(
// callee.
if (I == AddrToSymbol.end()) {
Lock.unlock();
std::string ErrMsg;
{
raw_string_ostream ErrMsgStream(ErrMsg);
ErrMsgStream << "No compile callback for trampoline at "
<< format("0x%016" PRIx64, TrampolineAddr);
}
ES.reportError(
make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode()));
make_error<StringError>("No compile callback for trampoline at " +
formatv("{0:x}", TrampolineAddr),
inconvertibleErrorCode()));
return ErrorHandlerAddress;
} else
Name = I->second;
@@ -120,7 +116,7 @@ JITTargetAddress JITCompileCallbackManager::executeCompileCallback(
Expected<std::unique_ptr<JITCompileCallbackManager>>
createLocalCompileCallbackManager(const Triple &T, ExecutionSession &ES,
JITTargetAddress ErrorHandlerAddress) {
ExecutorAddr ErrorHandlerAddress) {
switch (T.getArch()) {
default:
return make_error<StringError>(
@@ -244,9 +240,9 @@ createLocalIndirectStubsManagerBuilder(const Triple &T) {
}
}
Constant* createIRTypedAddress(FunctionType &FT, JITTargetAddress Addr) {
Constant* createIRTypedAddress(FunctionType &FT, ExecutorAddr Addr) {
Constant *AddrIntVal =
ConstantInt::get(Type::getInt64Ty(FT.getContext()), Addr);
ConstantInt::get(Type::getInt64Ty(FT.getContext()), Addr.getValue());
Constant *AddrPtrVal =
ConstantExpr::getCast(Instruction::IntToPtr, AddrIntVal,
PointerType::get(&FT, 0));

37
llvm/lib/ExecutionEngine/Orc/LLJIT.cpp
View File

@@ -189,12 +189,10 @@ public:
SymbolMap StdInterposes;
StdInterposes[J.mangleAndIntern("__lljit.platform_support_instance")] =
JITEvaluatedSymbol(pointerToJITTargetAddress(this),
JITSymbolFlags::Exported);
StdInterposes[J.mangleAndIntern("__lljit.cxa_atexit_helper")] =
JITEvaluatedSymbol(pointerToJITTargetAddress(registerCxaAtExitHelper),
JITSymbolFlags());
StdInterposes[J.mangleAndIntern("__lljit.platform_support_instance")] = {
ExecutorAddr::fromPtr(this), JITSymbolFlags::Exported};
StdInterposes[J.mangleAndIntern("__lljit.cxa_atexit_helper")] = {
ExecutorAddr::fromPtr(registerCxaAtExitHelper), JITSymbolFlags()};
cantFail(
J.getMainJITDylib().define(absoluteSymbols(std::move(StdInterposes))));
@@ -209,12 +207,10 @@ public:
// Add per-jitdylib standard interposes.
SymbolMap PerJDInterposes;
PerJDInterposes[J.mangleAndIntern("__lljit.run_atexits_helper")] =
JITEvaluatedSymbol(pointerToJITTargetAddress(runAtExitsHelper),
JITSymbolFlags());
PerJDInterposes[J.mangleAndIntern("__lljit.atexit_helper")] =
JITEvaluatedSymbol(pointerToJITTargetAddress(registerAtExitHelper),
JITSymbolFlags());
PerJDInterposes[J.mangleAndIntern("__lljit.run_atexits_helper")] = {
ExecutorAddr::fromPtr(runAtExitsHelper), JITSymbolFlags()};
PerJDInterposes[J.mangleAndIntern("__lljit.atexit_helper")] = {
ExecutorAddr::fromPtr(registerAtExitHelper), JITSymbolFlags()};
cantFail(JD.define(absoluteSymbols(std::move(PerJDInterposes))));
auto Ctx = std::make_unique<LLVMContext>();
@@ -228,7 +224,7 @@ public:
"__dso_handle");
DSOHandle->setVisibility(GlobalValue::DefaultVisibility);
DSOHandle->setInitializer(
ConstantInt::get(Int64Ty, pointerToJITTargetAddress(&JD)));
ConstantInt::get(Int64Ty, ExecutorAddr::fromPtr(&JD).getValue()));
auto *GenericIRPlatformSupportTy =
StructType::create(*Ctx, "lljit.GenericLLJITIRPlatformSupport");
@@ -288,7 +284,7 @@ public:
dbgs() << " Running init " << formatv("{0:x16}", InitFnAddr)
<< "...\n";
});
auto *InitFn = jitTargetAddressToFunction<void (*)()>(InitFnAddr);
auto *InitFn = InitFnAddr.toPtr<void (*)()>();
InitFn();
}
} else
@@ -309,7 +305,7 @@ public:
dbgs() << " Running deinit " << formatv("{0:x16}", DeinitFnAddr)
<< "...\n";
});
auto *DeinitFn = jitTargetAddressToFunction<void (*)()>(DeinitFnAddr);
auto *DeinitFn = DeinitFnAddr.toPtr<void (*)()>();
DeinitFn();
}
} else
@@ -330,8 +326,7 @@ public:
}
private:
Expected<std::vector<JITTargetAddress>> getInitializers(JITDylib &JD) {
Expected<std::vector<ExecutorAddr>> getInitializers(JITDylib &JD) {
if (auto Err = issueInitLookups(JD))
return std::move(Err);
@@ -371,7 +366,7 @@ private:
if (!LookupResult)
return LookupResult.takeError();
std::vector<JITTargetAddress> Initializers;
std::vector<ExecutorAddr> Initializers;
while (!DFSLinkOrder.empty()) {
auto &NextJD = *DFSLinkOrder.back();
DFSLinkOrder.pop_back();
@@ -385,7 +380,7 @@ private:
return Initializers;
}
Expected<std::vector<JITTargetAddress>> getDeinitializers(JITDylib &JD) {
Expected<std::vector<ExecutorAddr>> getDeinitializers(JITDylib &JD) {
auto &ES = getExecutionSession();
auto LLJITRunAtExits = J.mangleAndIntern("__lljit_run_atexits");
@@ -428,7 +423,7 @@ private:
if (!LookupResult)
return LookupResult.takeError();
std::vector<JITTargetAddress> DeInitializers;
std::vector<ExecutorAddr> DeInitializers;
for (auto &NextJD : DFSLinkOrder) {
auto DeInitsItr = LookupResult->find(NextJD.get());
assert(DeInitsItr != LookupResult->end() &&
@@ -1031,7 +1026,7 @@ LLLazyJIT::LLLazyJIT(LLLazyJITBuilderState &S, Error &Err) : LLJIT(S, Err) {
LCTMgr = std::move(S.LCTMgr);
else {
if (auto LCTMgrOrErr = createLocalLazyCallThroughManager(
S.TT, *ES, S.LazyCompileFailureAddr.getValue()))
S.TT, *ES, S.LazyCompileFailureAddr))
LCTMgr = std::move(*LCTMgrOrErr);
else {
Err = LCTMgrOrErr.takeError();

27
llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp
View File

@@ -16,11 +16,12 @@
namespace llvm {
namespace orc {
LazyCallThroughManager::LazyCallThroughManager(
ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr, TrampolinePool *TP)
LazyCallThroughManager::LazyCallThroughManager(ExecutionSession &ES,
ExecutorAddr ErrorHandlerAddr,
TrampolinePool *TP)
: ES(ES), ErrorHandlerAddr(ErrorHandlerAddr), TP(TP) {}
Expected<JITTargetAddress> LazyCallThroughManager::getCallThroughTrampoline(
Expected<ExecutorAddr> LazyCallThroughManager::getCallThroughTrampoline(
JITDylib &SourceJD, SymbolStringPtr SymbolName,
NotifyResolvedFunction NotifyResolved) {
assert(TP && "TrampolinePool not set");
@@ -36,24 +37,24 @@ Expected<JITTargetAddress> LazyCallThroughManager::getCallThroughTrampoline(
return *Trampoline;
}
JITTargetAddress LazyCallThroughManager::reportCallThroughError(Error Err) {
ExecutorAddr LazyCallThroughManager::reportCallThroughError(Error Err) {
ES.reportError(std::move(Err));
return ErrorHandlerAddr;
}
Expected<LazyCallThroughManager::ReexportsEntry>
LazyCallThroughManager::findReexport(JITTargetAddress TrampolineAddr) {
LazyCallThroughManager::findReexport(ExecutorAddr TrampolineAddr) {
std::lock_guard<std::mutex> Lock(LCTMMutex);
auto I = Reexports.find(TrampolineAddr);
if (I == Reexports.end())
return createStringError(inconvertibleErrorCode(),
"Missing reexport for trampoline address %p",
TrampolineAddr);
"Missing reexport for trampoline address %p" +
formatv("{0:x}", TrampolineAddr));
return I->second;
}
Error LazyCallThroughManager::notifyResolved(JITTargetAddress TrampolineAddr,
JITTargetAddress ResolvedAddr) {
Error LazyCallThroughManager::notifyResolved(ExecutorAddr TrampolineAddr,
ExecutorAddr ResolvedAddr) {
NotifyResolvedFunction NotifyResolved;
{
std::lock_guard<std::mutex> Lock(LCTMMutex);
@@ -68,7 +69,7 @@ Error LazyCallThroughManager::notifyResolved(JITTargetAddress TrampolineAddr,
}
void LazyCallThroughManager::resolveTrampolineLandingAddress(
JITTargetAddress TrampolineAddr,
ExecutorAddr TrampolineAddr,
NotifyLandingResolvedFunction NotifyLandingResolved) {
auto Entry = findReexport(TrampolineAddr);
@@ -84,7 +85,7 @@ void LazyCallThroughManager::resolveTrampolineLandingAddress(
if (Result) {
assert(Result->size() == 1 && "Unexpected result size");
assert(Result->count(SymbolName) && "Unexpected result value");
JITTargetAddress LandingAddr = (*Result)[SymbolName].getAddress();
ExecutorAddr LandingAddr = (*Result)[SymbolName].getAddress();
if (auto Err = notifyResolved(TrampolineAddr, LandingAddr))
NotifyLandingResolved(reportCallThroughError(std::move(Err)));
@@ -104,7 +105,7 @@ void LazyCallThroughManager::resolveTrampolineLandingAddress(
Expected<std::unique_ptr<LazyCallThroughManager>>
createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES,
JITTargetAddress ErrorHandlerAddr) {
ExecutorAddr ErrorHandlerAddr) {
switch (T.getArch()) {
default:
return make_error<StringError>(
@@ -187,7 +188,7 @@ void LazyReexportsMaterializationUnit::materialize(
auto CallThroughTrampoline = LCTManager.getCallThroughTrampoline(
SourceJD, Alias.second.Aliasee,
[&ISManager = this->ISManager,
StubSym = Alias.first](JITTargetAddress ResolvedAddr) -> Error {
StubSym = Alias.first](ExecutorAddr ResolvedAddr) -> Error {
return ISManager.updatePointer(*StubSym, ResolvedAddr);
});

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

@@ -31,8 +31,8 @@ void lookupAndRecordAddrs(
return OnRec(Result.takeError());
for (auto &KV : Pairs) {
auto I = Result->find(KV.first);
KV.second->setValue((I != Result->end()) ? I->second.getAddress()
: 0);
*KV.second =
I != Result->end() ? I->second.getAddress() : orc::ExecutorAddr();
}
OnRec(Error::success());
},

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

@@ -274,13 +274,13 @@ MachOPlatform::Create(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
return std::move(Err);
// Add JIT-dispatch function support symbols.
if (auto Err = PlatformJD.define(absoluteSymbols(
{{ES.intern("___orc_rt_jit_dispatch"),
{EPC.getJITDispatchInfo().JITDispatchFunction.getValue(),
JITSymbolFlags::Exported}},
{ES.intern("___orc_rt_jit_dispatch_ctx"),
{EPC.getJITDispatchInfo().JITDispatchContext.getValue(),
JITSymbolFlags::Exported}}})))
if (auto Err = PlatformJD.define(
absoluteSymbols({{ES.intern("___orc_rt_jit_dispatch"),
{EPC.getJITDispatchInfo().JITDispatchFunction,
JITSymbolFlags::Exported}},
{ES.intern("___orc_rt_jit_dispatch_ctx"),
{EPC.getJITDispatchInfo().JITDispatchContext,
JITSymbolFlags::Exported}}})))
return std::move(Err);
// Create the instance.
@@ -681,7 +681,7 @@ void MachOPlatform::rt_lookupSymbol(SendSymbolAddressFn SendResult,
void operator()(Expected<SymbolMap> Result) {
if (Result) {
assert(Result->size() == 1 && "Unexpected result map count");
SendResult(ExecutorAddr(Result->begin()->second.getAddress()));
SendResult(Result->begin()->second.getAddress());
} else {
SendResult(Result.takeError());
}

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

@@ -40,7 +40,7 @@ bool hasInitializerSection(jitlink::LinkGraph &G) {
return false;
}
JITTargetAddress getJITSymbolPtrForSymbol(Symbol &Sym, const Triple &TT) {
ExecutorAddr getJITSymbolPtrForSymbol(Symbol &Sym, const Triple &TT) {
uint64_t CallableAddr = Sym.getAddress().getValue();
switch (TT.getArch()) {
case Triple::arm:
@@ -53,7 +53,7 @@ JITTargetAddress getJITSymbolPtrForSymbol(Symbol &Sym, const Triple &TT) {
default:
break;
}
return CallableAddr;
return ExecutorAddr(CallableAddr);
}
JITSymbolFlags getJITSymbolFlagsForSymbol(Symbol &Sym) {
@@ -234,7 +234,7 @@ public:
auto InternedName = ES.intern(Sym->getName());
auto Ptr = getJITSymbolPtrForSymbol(*Sym, G.getTargetTriple());
auto Flags = getJITSymbolFlagsForSymbol(*Sym);
InternedResult[InternedName] = JITEvaluatedSymbol(Ptr, Flags);
InternedResult[InternedName] = {Ptr, Flags};
if (AutoClaim && !MR->getSymbols().count(InternedName)) {
assert(!ExtraSymbolsToClaim.count(InternedName) &&
"Duplicate symbol to claim?");
@@ -247,7 +247,7 @@ public:
auto InternedName = ES.intern(Sym->getName());
auto Ptr = getJITSymbolPtrForSymbol(*Sym, G.getTargetTriple());
auto Flags = getJITSymbolFlagsForSymbol(*Sym);
InternedResult[InternedName] = JITEvaluatedSymbol(Ptr, Flags);
InternedResult[InternedName] = {Ptr, Flags};
if (AutoClaim && !MR->getSymbols().count(InternedName)) {
assert(!ExtraSymbolsToClaim.count(InternedName) &&
"Duplicate symbol to claim?");

200
llvm/lib/ExecutionEngine/Orc/OrcABISupport.cpp
View File

@@ -14,17 +14,17 @@
#define DEBUG_TYPE "orc"
using namespace llvm;
using namespace llvm::orc;
template <typename ORCABI>
bool stubAndPointerRangesOk(JITTargetAddress StubBlockAddr,
JITTargetAddress PointerBlockAddr,
unsigned NumStubs) {
static bool stubAndPointerRangesOk(ExecutorAddr StubBlockAddr,
ExecutorAddr PointerBlockAddr,
unsigned NumStubs) {
constexpr unsigned MaxDisp = ORCABI::StubToPointerMaxDisplacement;
JITTargetAddress FirstStub = StubBlockAddr;
JITTargetAddress LastStub = FirstStub + ((NumStubs - 1) * ORCABI::StubSize);
JITTargetAddress FirstPointer = PointerBlockAddr;
JITTargetAddress LastPointer =
FirstPointer + ((NumStubs - 1) * ORCABI::StubSize);
ExecutorAddr FirstStub = StubBlockAddr;
ExecutorAddr LastStub = FirstStub + ((NumStubs - 1) * ORCABI::StubSize);
ExecutorAddr FirstPointer = PointerBlockAddr;
ExecutorAddr LastPointer = FirstPointer + ((NumStubs - 1) * ORCABI::StubSize);
if (FirstStub < FirstPointer) {
if (LastStub >= FirstPointer)
@@ -44,9 +44,9 @@ namespace llvm {
namespace orc {
void OrcAArch64::writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
const uint32_t ResolverCode[] = {
// resolver_entry:
@@ -135,8 +135,8 @@ void OrcAArch64::writeResolverCode(char *ResolverWorkingMem,
}
void OrcAArch64::writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines) {
unsigned OffsetToPtr = alignTo(NumTrampolines * TrampolineSize, 8);
@@ -159,8 +159,8 @@ void OrcAArch64::writeTrampolines(char *TrampolineBlockWorkingMem,
}
void OrcAArch64::writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs) {
char *StubsBlockWorkingMem, ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress, unsigned NumStubs) {
// Stub format is:
//
// .section __orc_stubs
@@ -195,10 +195,10 @@ void OrcAArch64::writeIndirectStubsBlock(
Stub[I] = 0xd61f020058000010 | PtrOffsetField;
}
void OrcX86_64_Base::writeTrampolines(
char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr, unsigned NumTrampolines) {
void OrcX86_64_Base::writeTrampolines(char *TrampolineBlockWorkingMem,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines) {
unsigned OffsetToPtr = NumTrampolines * TrampolineSize;
@@ -214,8 +214,8 @@ void OrcX86_64_Base::writeTrampolines(
}
void OrcX86_64_Base::writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs) {
char *StubsBlockWorkingMem, ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress, unsigned NumStubs) {
// Stub format is:
//
// .section __orc_stubs
@@ -250,9 +250,9 @@ void OrcX86_64_Base::writeIndirectStubsBlock(
}
void OrcX86_64_SysV::writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
LLVM_DEBUG({
dbgs() << "Writing resolver code to "
@@ -324,9 +324,9 @@ void OrcX86_64_SysV::writeResolverCode(char *ResolverWorkingMem,
}
void OrcX86_64_Win32::writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
// resolverCode is similar to OrcX86_64 with differences specific to windows
// x64 calling convention: arguments go into rcx, rdx and come in reverse
@@ -402,12 +402,13 @@ void OrcX86_64_Win32::writeResolverCode(char *ResolverWorkingMem,
}
void OrcI386::writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
assert((ReentryFnAddr >> 32) == 0 && "ReentryFnAddr out of range");
assert((ReentryCtxAddr >> 32) == 0 && "ReentryCtxAddr out of range");
assert((ReentryFnAddr.getValue() >> 32) == 0 && "ReentryFnAddr out of range");
assert((ReentryCtxAddr.getValue() >> 32) == 0 &&
"ReentryCtxAddr out of range");
const uint8_t ResolverCode[] = {
// resolver_entry:
@@ -455,10 +456,10 @@ void OrcI386::writeResolverCode(char *ResolverWorkingMem,
}
void OrcI386::writeTrampolines(char *TrampolineWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines) {
assert((ResolverAddr >> 32) == 0 && "ResolverAddr out of range");
assert((ResolverAddr.getValue() >> 32) == 0 && "ResolverAddr out of range");
uint64_t CallRelImm = 0xF1C4C400000000e8;
uint64_t ResolverRel = ResolverAddr - TrampolineBlockTargetAddress - 5;
@@ -468,12 +469,13 @@ void OrcI386::writeTrampolines(char *TrampolineWorkingMem,
Trampolines[I] = CallRelImm | (ResolverRel << 8);
}
void OrcI386::writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs) {
assert((StubsBlockTargetAddress >> 32) == 0 &&
void OrcI386::writeIndirectStubsBlock(char *StubsBlockWorkingMem,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned NumStubs) {
assert((StubsBlockTargetAddress.getValue() >> 32) == 0 &&
"StubsBlockTargetAddress is out of range");
assert((PointersBlockTargetAddress >> 32) == 0 &&
assert((PointersBlockTargetAddress.getValue() >> 32) == 0 &&
"PointersBlockTargetAddress is out of range");
// Stub format is:
@@ -501,15 +503,15 @@ void OrcI386::writeIndirectStubsBlock(
"PointersBlock is out of range");
uint64_t *Stub = reinterpret_cast<uint64_t *>(StubsBlockWorkingMem);
uint64_t PtrAddr = PointersBlockTargetAddress;
uint64_t PtrAddr = PointersBlockTargetAddress.getValue();
for (unsigned I = 0; I < NumStubs; ++I, PtrAddr += 4)
Stub[I] = 0xF1C40000000025ff | (PtrAddr << 16);
}
void OrcMips32_Base::writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr,
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr,
bool isBigEndian) {
const uint32_t ResolverCode[] = {
@@ -596,32 +598,32 @@ void OrcMips32_Base::writeResolverCode(char *ResolverWorkingMem,
memcpy(ResolverWorkingMem + Offsett, &MoveVxT9, sizeof(MoveVxT9));
uint32_t ReentryCtxLUi =
0x3c040000 | (((ReentryCtxAddr + 0x8000) >> 16) & 0xFFFF);
uint32_t ReentryCtxADDiu = 0x24840000 | ((ReentryCtxAddr)&0xFFFF);
0x3c040000 | (((ReentryCtxAddr.getValue() + 0x8000) >> 16) & 0xFFFF);
uint32_t ReentryCtxADDiu = 0x24840000 | (ReentryCtxAddr.getValue() & 0xFFFF);
memcpy(ResolverWorkingMem + ReentryCtxAddrOffset, &ReentryCtxLUi,
sizeof(ReentryCtxLUi));
memcpy(ResolverWorkingMem + ReentryCtxAddrOffset + 4, &ReentryCtxADDiu,
sizeof(ReentryCtxADDiu));
uint32_t ReentryFnLUi =
0x3c190000 | (((ReentryFnAddr + 0x8000) >> 16) & 0xFFFF);
uint32_t ReentryFnADDiu = 0x27390000 | ((ReentryFnAddr)&0xFFFF);
0x3c190000 | (((ReentryFnAddr.getValue() + 0x8000) >> 16) & 0xFFFF);
uint32_t ReentryFnADDiu = 0x27390000 | (ReentryFnAddr.getValue() & 0xFFFF);
memcpy(ResolverWorkingMem + ReentryFnAddrOffset, &ReentryFnLUi,
sizeof(ReentryFnLUi));
memcpy(ResolverWorkingMem + ReentryFnAddrOffset + 4, &ReentryFnADDiu,
sizeof(ReentryFnADDiu));
}
void OrcMips32_Base::writeTrampolines(
char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr, unsigned NumTrampolines) {
void OrcMips32_Base::writeTrampolines(char *TrampolineBlockWorkingMem,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines) {
assert((ResolverAddr >> 32) == 0 && "ResolverAddr out of range");
assert((ResolverAddr.getValue() >> 32) == 0 && "ResolverAddr out of range");
uint32_t *Trampolines =
reinterpret_cast<uint32_t *>(TrampolineBlockWorkingMem);
uint32_t RHiAddr = ((ResolverAddr + 0x8000) >> 16);
uint32_t RHiAddr = ((ResolverAddr.getValue() + 0x8000) >> 16);
for (unsigned I = 0; I < NumTrampolines; ++I) {
// move $t8,$ra
@@ -631,16 +633,16 @@ void OrcMips32_Base::writeTrampolines(
// nop
Trampolines[5 * I + 0] = 0x03e0c025;
Trampolines[5 * I + 1] = 0x3c190000 | (RHiAddr & 0xFFFF);
Trampolines[5 * I + 2] = 0x27390000 | (ResolverAddr & 0xFFFF);
Trampolines[5 * I + 2] = 0x27390000 | (ResolverAddr.getValue() & 0xFFFF);
Trampolines[5 * I + 3] = 0x0320f809;
Trampolines[5 * I + 4] = 0x00000000;
}
}
void OrcMips32_Base::writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs) {
assert((StubsBlockTargetAddress >> 32) == 0 &&
char *StubsBlockWorkingMem, ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress, unsigned NumStubs) {
assert((StubsBlockTargetAddress.getValue() >> 32) == 0 &&
"InitialPtrVal is out of range");
// Stub format is:
@@ -671,7 +673,7 @@ void OrcMips32_Base::writeIndirectStubsBlock(
// Populate the stubs page stubs and mark it executable.
uint32_t *Stub = reinterpret_cast<uint32_t *>(StubsBlockWorkingMem);
uint64_t PtrAddr = PointersBlockTargetAddress;
uint64_t PtrAddr = PointersBlockTargetAddress.getValue();
for (unsigned I = 0; I < NumStubs; ++I) {
uint32_t HiAddr = ((PtrAddr + 0x8000) >> 16);
@@ -684,9 +686,9 @@ void OrcMips32_Base::writeIndirectStubsBlock(
}
void OrcMips64::writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
const uint32_t ResolverCode[] = {
//resolver_entry:
@@ -775,14 +777,16 @@ void OrcMips64::writeResolverCode(char *ResolverWorkingMem,
memcpy(ResolverWorkingMem, ResolverCode, sizeof(ResolverCode));
uint32_t ReentryCtxLUi =
0x3c040000 | (((ReentryCtxAddr + 0x800080008000) >> 48) & 0xFFFF);
0x3c040000 |
(((ReentryCtxAddr.getValue() + 0x800080008000) >> 48) & 0xFFFF);
uint32_t ReentryCtxDADDiu =
0x64840000 | (((ReentryCtxAddr + 0x80008000) >> 32) & 0xFFFF);
0x64840000 | (((ReentryCtxAddr.getValue() + 0x80008000) >> 32) & 0xFFFF);
uint32_t ReentryCtxDSLL = 0x00042438;
uint32_t ReentryCtxDADDiu2 =
0x64840000 | ((((ReentryCtxAddr + 0x8000) >> 16) & 0xFFFF));
0x64840000 | ((((ReentryCtxAddr.getValue() + 0x8000) >> 16) & 0xFFFF));
uint32_t ReentryCtxDSLL2 = 0x00042438;
uint32_t ReentryCtxDADDiu3 = 0x64840000 | ((ReentryCtxAddr)&0xFFFF);
uint32_t ReentryCtxDADDiu3 =
0x64840000 | (ReentryCtxAddr.getValue() & 0xFFFF);
memcpy(ResolverWorkingMem + ReentryCtxAddrOffset, &ReentryCtxLUi,
sizeof(ReentryCtxLUi));
@@ -798,19 +802,20 @@ void OrcMips64::writeResolverCode(char *ResolverWorkingMem,
sizeof(ReentryCtxDADDiu3));
uint32_t ReentryFnLUi =
0x3c190000 | (((ReentryFnAddr + 0x800080008000) >> 48) & 0xFFFF);
0x3c190000 |
(((ReentryFnAddr.getValue() + 0x800080008000) >> 48) & 0xFFFF);
uint32_t ReentryFnDADDiu =
0x67390000 | (((ReentryFnAddr + 0x80008000) >> 32) & 0xFFFF);
0x67390000 | (((ReentryFnAddr.getValue() + 0x80008000) >> 32) & 0xFFFF);
uint32_t ReentryFnDSLL = 0x0019cc38;
uint32_t ReentryFnDADDiu2 =
0x67390000 | (((ReentryFnAddr + 0x8000) >> 16) & 0xFFFF);
0x67390000 | (((ReentryFnAddr.getValue() + 0x8000) >> 16) & 0xFFFF);
uint32_t ReentryFnDSLL2 = 0x0019cc38;
uint32_t ReentryFnDADDiu3 = 0x67390000 | ((ReentryFnAddr)&0xFFFF);
uint32_t ReentryFnDADDiu3 = 0x67390000 | (ReentryFnAddr.getValue() & 0xFFFF);
memcpy(ResolverWorkingMem + ReentryFnAddrOffset, &ReentryFnLUi,
sizeof(ReentryFnLUi));
@@ -827,16 +832,16 @@ void OrcMips64::writeResolverCode(char *ResolverWorkingMem,
}
void OrcMips64::writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines) {
uint32_t *Trampolines =
reinterpret_cast<uint32_t *>(TrampolineBlockWorkingMem);
uint64_t HeighestAddr = ((ResolverAddr + 0x800080008000) >> 48);
uint64_t HeigherAddr = ((ResolverAddr + 0x80008000) >> 32);
uint64_t HiAddr = ((ResolverAddr + 0x8000) >> 16);
uint64_t HeighestAddr = ((ResolverAddr.getValue() + 0x800080008000) >> 48);
uint64_t HeigherAddr = ((ResolverAddr.getValue() + 0x80008000) >> 32);
uint64_t HiAddr = ((ResolverAddr.getValue() + 0x8000) >> 16);
for (unsigned I = 0; I < NumTrampolines; ++I) {
Trampolines[10 * I + 0] = 0x03e0c025; // move $t8,$ra
@@ -845,17 +850,18 @@ void OrcMips64::writeTrampolines(char *TrampolineBlockWorkingMem,
Trampolines[10 * I + 3] = 0x0019cc38; // dsll $t9,$t9,16
Trampolines[10 * I + 4] = 0x67390000 | (HiAddr & 0xFFFF); // daddiu $t9,$t9,%hi(ptr)
Trampolines[10 * I + 5] = 0x0019cc38; // dsll $t9,$t9,16
Trampolines[10 * I + 6] =
0x67390000 | (ResolverAddr & 0xFFFF); // daddiu $t9,$t9,%lo(ptr)
Trampolines[10 * I + 6] = 0x67390000 | (ResolverAddr.getValue() &
0xFFFF); // daddiu $t9,$t9,%lo(ptr)
Trampolines[10 * I + 7] = 0x0320f809; // jalr $t9
Trampolines[10 * I + 8] = 0x00000000; // nop
Trampolines[10 * I + 9] = 0x00000000; // nop
}
}
void OrcMips64::writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs) {
void OrcMips64::writeIndirectStubsBlock(char *StubsBlockWorkingMem,
ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress,
unsigned NumStubs) {
// Stub format is:
//
// .section __orc_stubs
@@ -890,7 +896,7 @@ void OrcMips64::writeIndirectStubsBlock(
// Populate the stubs page stubs and mark it executable.
uint32_t *Stub = reinterpret_cast<uint32_t *>(StubsBlockWorkingMem);
uint64_t PtrAddr = PointersBlockTargetAddress;
uint64_t PtrAddr = PointersBlockTargetAddress.getValue();
for (unsigned I = 0; I < NumStubs; ++I, PtrAddr += 8) {
uint64_t HeighestAddr = ((PtrAddr + 0x800080008000) >> 48);
@@ -908,9 +914,9 @@ void OrcMips64::writeIndirectStubsBlock(
}
void OrcRiscv64::writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
const uint32_t ResolverCode[] = {
0xef810113, // 0x00: addi sp,sp,-264
@@ -1008,8 +1014,8 @@ void OrcRiscv64::writeResolverCode(char *ResolverWorkingMem,
}
void OrcRiscv64::writeTrampolines(char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines) {
unsigned OffsetToPtr = alignTo(NumTrampolines * TrampolineSize, 8);
@@ -1031,8 +1037,8 @@ void OrcRiscv64::writeTrampolines(char *TrampolineBlockWorkingMem,
}
void OrcRiscv64::writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs) {
char *StubsBlockWorkingMem, ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress, unsigned NumStubs) {
// Stub format is:
//
// .section __orc_stubs
@@ -1078,9 +1084,9 @@ void OrcRiscv64::writeIndirectStubsBlock(
}
void OrcLoongArch64::writeResolverCode(char *ResolverWorkingMem,
JITTargetAddress ResolverTargetAddress,
JITTargetAddress ReentryFnAddr,
JITTargetAddress ReentryCtxAddr) {
ExecutorAddr ResolverTargetAddress,
ExecutorAddr ReentryFnAddr,
ExecutorAddr ReentryCtxAddr) {
LLVM_DEBUG({
dbgs() << "Writing resolver code to "
@@ -1150,10 +1156,10 @@ void OrcLoongArch64::writeResolverCode(char *ResolverWorkingMem,
sizeof(uint64_t));
}
void OrcLoongArch64::writeTrampolines(
char *TrampolineBlockWorkingMem,
JITTargetAddress TrampolineBlockTargetAddress,
JITTargetAddress ResolverAddr, unsigned NumTrampolines) {
void OrcLoongArch64::writeTrampolines(char *TrampolineBlockWorkingMem,
ExecutorAddr TrampolineBlockTargetAddress,
ExecutorAddr ResolverAddr,
unsigned NumTrampolines) {
LLVM_DEBUG({
dbgs() << "Writing trampoline code to "
@@ -1181,8 +1187,8 @@ void OrcLoongArch64::writeTrampolines(
}
void OrcLoongArch64::writeIndirectStubsBlock(
char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs) {
char *StubsBlockWorkingMem, ExecutorAddr StubsBlockTargetAddress,
ExecutorAddr PointersBlockTargetAddress, unsigned NumStubs) {
// Stub format is:
//
// .section __orc_stubs

14
llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp
View File

@@ -184,8 +184,8 @@ static SymbolMap toSymbolMap(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) {
SymbolMap SM;
for (size_t I = 0; I != NumPairs; ++I) {
JITSymbolFlags Flags = toJITSymbolFlags(Syms[I].Sym.Flags);
SM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] =
JITEvaluatedSymbol(Syms[I].Sym.Address, Flags);
SM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] = {
ExecutorAddr(Syms[I].Sym.Address), Flags};
}
return SM;
}
@@ -269,8 +269,8 @@ static LLVMOrcSymbolLookupFlags fromSymbolLookupFlags(SymbolLookupFlags SLF) {
}
static LLVMJITEvaluatedSymbol
fromJITEvaluatedSymbol(const JITEvaluatedSymbol &S) {
return {S.getAddress(), fromJITSymbolFlags(S.getFlags())};
fromExecutorSymbolDef(const ExecutorSymbolDef &S) {
return {S.getAddress().getValue(), fromJITSymbolFlags(S.getFlags())};
}
} // end anonymous namespace
@@ -385,7 +385,7 @@ void LLVMOrcExecutionSessionLookup(
for (auto &KV : *Result)
CResult.push_back(LLVMOrcCSymbolMapPair{
wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(KV.first)),
fromJITEvaluatedSymbol(KV.second)});
fromExecutorSymbolDef(KV.second)});
HandleResult(LLVMErrorSuccess, CResult.data(), CResult.size(), Ctx);
} else
HandleResult(wrap(Result.takeError()), nullptr, 0, Ctx);
@@ -1198,8 +1198,8 @@ LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager(
const char *TargetTriple, LLVMOrcExecutionSessionRef ES,
LLVMOrcJITTargetAddress ErrorHandlerAddr,
LLVMOrcLazyCallThroughManagerRef *Result) {
auto LCTM = createLocalLazyCallThroughManager(Triple(TargetTriple),
*unwrap(ES), ErrorHandlerAddr);
auto LCTM = createLocalLazyCallThroughManager(
Triple(TargetTriple), *unwrap(ES), ExecutorAddr(ErrorHandlerAddr));
if (!LCTM)
return wrap(LCTM.takeError());

5
llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp
View File

@@ -38,7 +38,8 @@ public:
LookupResult Result;
for (auto &KV : *InternedResult)
Result[*KV.first] = std::move(KV.second);
Result[*KV.first] = {KV.second.getAddress().getValue(),
KV.second.getFlags()};
OnResolved(Result);
};
@@ -326,7 +327,7 @@ Error RTDyldObjectLinkingLayer::onObjLoad(
} else if (AutoClaimObjectSymbols)
ExtraSymbolsToClaim[InternedName] = Flags;
Symbols[InternedName] = JITEvaluatedSymbol(KV.second.getAddress(), Flags);
Symbols[InternedName] = {ExecutorAddr(KV.second.getAddress()), Flags};
}
if (!ExtraSymbolsToClaim.empty()) {

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

@@ -402,7 +402,7 @@ void SimpleRemoteEPC::handleCallWrapper(
ExecutorAddr(), {WFR.data(), WFR.size()}))
getExecutionSession().reportError(std::move(Err));
},
TagAddr.getValue(), ArgBytes);
TagAddr, ArgBytes);
},
"callWrapper task"));
}

11
llvm/lib/ExecutionEngine/Orc/Speculation.cpp
View File

@@ -36,16 +36,15 @@ void ImplSymbolMap::trackImpls(SymbolAliasMap ImplMaps, JITDylib *SrcJD) {
// Trigger Speculative Compiles.
void Speculator::speculateForEntryPoint(Speculator *Ptr, uint64_t StubId) {
assert(Ptr && " Null Address Received in orc_speculate_for ");
Ptr->speculateFor(StubId);
Ptr->speculateFor(ExecutorAddr(StubId));
}
Error Speculator::addSpeculationRuntime(JITDylib &JD,
MangleAndInterner &Mangle) {
JITEvaluatedSymbol ThisPtr(pointerToJITTargetAddress(this),
JITSymbolFlags::Exported);
JITEvaluatedSymbol SpeculateForEntryPtr(
pointerToJITTargetAddress(&speculateForEntryPoint),
JITSymbolFlags::Exported);
ExecutorSymbolDef ThisPtr(ExecutorAddr::fromPtr(this),
JITSymbolFlags::Exported);
ExecutorSymbolDef SpeculateForEntryPtr(
ExecutorAddr::fromPtr(&speculateForEntryPoint), JITSymbolFlags::Exported);
return JD.define(absoluteSymbols({
{Mangle("__orc_speculator"), ThisPtr}, // Data Symbol
{Mangle("__orc_speculate_for"), SpeculateForEntryPtr} // Callable Symbol

4
llvm/tools/lli/ExecutionUtils.h
View File

@@ -48,8 +48,8 @@ private:
std::unique_ptr<ToolOutputFile> TestOut;
template <typename T> void expose(orc::SymbolStringPtr Name, T *Handler) {
BuiltinFunctions[Name] = JITEvaluatedSymbol(
pointerToJITTargetAddress(Handler), JITSymbolFlags::Exported);
BuiltinFunctions[Name] = {orc::ExecutorAddr::fromPtr(Handler),
JITSymbolFlags::Exported};
}
static std::unique_ptr<ToolOutputFile> createToolOutput();

3
llvm/tools/lli/lli.cpp
View File

@@ -871,7 +871,8 @@ int runOrcJIT(const char *ProgName) {
auto ES = std::make_unique<orc::ExecutionSession>(
ExitOnErr(orc::SelfExecutorProcessControl::Create()));
Builder.setLazyCallthroughManager(
std::make_unique<orc::LazyCallThroughManager>(*ES, 0, nullptr));
std::make_unique<orc::LazyCallThroughManager>(*ES, orc::ExecutorAddr(),
nullptr));
Builder.setExecutionSession(std::move(ES));
}

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

@@ -888,7 +888,7 @@ public:
const SymbolLookupSet &LookupSet) override {
SymbolMap PhonySymbols;
for (auto &KV : LookupSet)
PhonySymbols[KV.first] = JITEvaluatedSymbol(0, JITSymbolFlags::Exported);
PhonySymbols[KV.first] = {ExecutorAddr(), JITSymbolFlags::Exported};
return JD.define(absoluteSymbols(std::move(PhonySymbols)));
}
};
@@ -976,7 +976,7 @@ Session::Session(std::unique_ptr<ExecutorProcessControl> EPC, Error &Err)
auto &TestResultJD = ES.createBareJITDylib("<TestResultJD>");
ExitOnErr(TestResultJD.define(absoluteSymbols(
{{ES.intern("llvm_jitlink_setTestResultOverride"),
{pointerToJITTargetAddress(llvm_jitlink_setTestResultOverride),
{ExecutorAddr::fromPtr(llvm_jitlink_setTestResultOverride),
JITSymbolFlags::Exported}}})));
MainJD->addToLinkOrder(TestResultJD);
}
@@ -1401,7 +1401,7 @@ static Error addAbsoluteSymbols(Session &S,
"\" in absolute symbol definition \"" +
AbsDefStmt + "\"",
inconvertibleErrorCode());
JITEvaluatedSymbol AbsDef(Addr, JITSymbolFlags::Exported);
ExecutorSymbolDef AbsDef(ExecutorAddr(Addr), JITSymbolFlags::Exported);
if (auto Err = JD.define(absoluteSymbols({{S.ES.intern(Name), AbsDef}})))
return Err;
@@ -1940,19 +1940,19 @@ static void dumpSessionStats(Session &S) {
<< "\n";
}
static Expected<JITEvaluatedSymbol> getMainEntryPoint(Session &S) {
static Expected<ExecutorSymbolDef> getMainEntryPoint(Session &S) {
return S.ES.lookup(S.JDSearchOrder, S.ES.intern(EntryPointName));
}
static Expected<JITEvaluatedSymbol> getOrcRuntimeEntryPoint(Session &S) {
static Expected<ExecutorSymbolDef> getOrcRuntimeEntryPoint(Session &S) {
std::string RuntimeEntryPoint = "__orc_rt_run_program_wrapper";
if (S.ES.getTargetTriple().getObjectFormat() == Triple::MachO)
RuntimeEntryPoint = '_' + RuntimeEntryPoint;
return S.ES.lookup(S.JDSearchOrder, S.ES.intern(RuntimeEntryPoint));
}
static Expected<JITEvaluatedSymbol> getEntryPoint(Session &S) {
JITEvaluatedSymbol EntryPoint;
static Expected<ExecutorSymbolDef> getEntryPoint(Session &S) {
ExecutorSymbolDef EntryPoint;
// Find the entry-point function unconditionally, since we want to force
// it to be materialized to collect stats.
@@ -2041,9 +2041,9 @@ int main(int argc, char *argv[]) {
if (ShowInitialExecutionSessionState)
S->ES.dump(outs());
Expected<JITEvaluatedSymbol> EntryPoint(nullptr);
Expected<ExecutorSymbolDef> EntryPoint((ExecutorSymbolDef()));
{
ExpectedAsOutParameter<JITEvaluatedSymbol> _(&EntryPoint);
ExpectedAsOutParameter<ExecutorSymbolDef> _(&EntryPoint);
TimeRegion TR(Timers ? &Timers->LinkTimer : nullptr);
EntryPoint = getEntryPoint(*S);
}

6
llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
View File

@@ -260,7 +260,7 @@ TEST_F(CoreAPIsStandardTest, DiscardInitSymbol) {
TEST_F(CoreAPIsStandardTest, LookupWithHiddenSymbols) {
auto BarHiddenFlags = BarSym.getFlags() & ~JITSymbolFlags::Exported;
auto BarHiddenSym = JITEvaluatedSymbol(BarSym.getAddress(), BarHiddenFlags);
auto BarHiddenSym = ExecutorSymbolDef(BarSym.getAddress(), BarHiddenFlags);
cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarHiddenSym}})));
@@ -1084,8 +1084,8 @@ TEST_F(CoreAPIsStandardTest, DefineMaterializingSymbol) {
}
TEST_F(CoreAPIsStandardTest, GeneratorTest) {
JITEvaluatedSymbol BazHiddenSym(
BazSym.getAddress(), BazSym.getFlags() & ~JITSymbolFlags::Exported);
ExecutorSymbolDef BazHiddenSym(BazSym.getAddress(),
BazSym.getFlags() & ~JITSymbolFlags::Exported);
cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Baz, BazHiddenSym}})));
class TestGenerator : public DefinitionGenerator {

5
llvm/unittests/ExecutionEngine/Orc/ExecutionSessionWrapperFunctionCallsTest.cpp
View File

@@ -78,15 +78,14 @@ TEST(ExecutionSessionWrapperFunctionCalls, RunNonVoidWrapperAsyncTemplate) {
TEST(ExecutionSessionWrapperFunctionCalls, RegisterAsyncHandlerAndRun) {
constexpr JITTargetAddress AddAsyncTagAddr = 0x01;
constexpr ExecutorAddr AddAsyncTagAddr(0x01);
ExecutionSession ES(cantFail(SelfExecutorProcessControl::Create()));
auto &JD = ES.createBareJITDylib("JD");
auto AddAsyncTag = ES.intern("addAsync_tag");
cantFail(JD.define(absoluteSymbols(
{{AddAsyncTag,
JITEvaluatedSymbol(AddAsyncTagAddr, JITSymbolFlags::Exported)}})));
{{AddAsyncTag, {AddAsyncTagAddr, JITSymbolFlags::Exported}}})));
ExecutionSession::JITDispatchHandlerAssociationMap Associations;

16
llvm/unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp
View File

@@ -27,7 +27,8 @@ TEST_F(LazyReexportsTest, BasicLocalCallThroughManagerOperation) {
}
// Bail out if we can not build a local call-through manager.
auto LCTM = createLocalLazyCallThroughManager(JTMB->getTargetTriple(), ES, 0);
auto LCTM = createLocalLazyCallThroughManager(JTMB->getTargetTriple(), ES,
ExecutorAddr());
if (!LCTM) {
consumeError(LCTM.takeError());
GTEST_SKIP();
@@ -42,16 +43,14 @@ TEST_F(LazyReexportsTest, BasicLocalCallThroughManagerOperation) {
[&](std::unique_ptr<MaterializationResponsibility> R) {
DummyTargetMaterialized = true;
// No dependencies registered, can't fail.
cantFail(R->notifyResolved(
{{DummyTarget,
JITEvaluatedSymbol(static_cast<JITTargetAddress>(
reinterpret_cast<uintptr_t>(&dummyTarget)),
JITSymbolFlags::Exported)}}));
cantFail(R->notifyResolved({{DummyTarget,
{ExecutorAddr::fromPtr(&dummyTarget),
JITSymbolFlags::Exported}}}));
cantFail(R->notifyEmitted());
})));
unsigned NotifyResolvedCount = 0;
auto NotifyResolved = [&](JITTargetAddress ResolvedAddr) {
auto NotifyResolved = [&](ExecutorAddr ResolvedAddr) {
++NotifyResolvedCount;
return Error::success();
};
@@ -59,8 +58,7 @@ TEST_F(LazyReexportsTest, BasicLocalCallThroughManagerOperation) {
auto CallThroughTrampoline = cantFail((*LCTM)->getCallThroughTrampoline(
JD, DummyTarget, std::move(NotifyResolved)));
auto CTTPtr = reinterpret_cast<int (*)()>(
static_cast<uintptr_t>(CallThroughTrampoline));
auto CTTPtr = CallThroughTrampoline.toPtr<int (*)()>();
// Call twice to verify nothing unexpected happens on redundant calls.
auto Result = CTTPtr();

40
llvm/unittests/ExecutionEngine/Orc/LookupAndRecordAddrsTest.cpp
View File

@@ -24,27 +24,27 @@ namespace {
TEST_F(LookupAndRecordAddrsTest, AsyncRequiredSuccess) {
cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
ExecutorAddr FooAddress, BarAddress;
ExecutorAddr ReturnedFooAddr, ReturnedBarAddr;
std::promise<MSVCPError> ErrP;
lookupAndRecordAddrs([&](Error Err) { ErrP.set_value(std::move(Err)); }, ES,
LookupKind::Static, makeJITDylibSearchOrder(&JD),
{{Foo, &FooAddress}, {Bar, &BarAddress}});
{{Foo, &ReturnedFooAddr}, {Bar, &ReturnedBarAddr}});
Error Err = ErrP.get_future().get();
EXPECT_THAT_ERROR(std::move(Err), Succeeded());
EXPECT_EQ(FooAddress.getValue(), FooAddr);
EXPECT_EQ(BarAddress.getValue(), BarAddr);
EXPECT_EQ(ReturnedFooAddr, FooAddr);
EXPECT_EQ(ReturnedBarAddr, BarAddr);
}
TEST_F(LookupAndRecordAddrsTest, AsyncRequiredFailure) {
ExecutorAddr FooAddress, BarAddress;
ExecutorAddr RecordedFooAddr, RecordedBarAddr;
std::promise<MSVCPError> ErrP;
lookupAndRecordAddrs([&](Error Err) { ErrP.set_value(std::move(Err)); }, ES,
LookupKind::Static, makeJITDylibSearchOrder(&JD),
{{Foo, &FooAddress}, {Bar, &BarAddress}});
{{Foo, &RecordedFooAddr}, {Bar, &RecordedBarAddr}});
Error Err = ErrP.get_future().get();
@@ -54,39 +54,39 @@ TEST_F(LookupAndRecordAddrsTest, AsyncRequiredFailure) {
TEST_F(LookupAndRecordAddrsTest, AsyncWeakReference) {
cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
ExecutorAddr FooAddress, BarAddress;
ExecutorAddr RecordedFooAddr, RecordedBarAddr;
std::promise<MSVCPError> ErrP;
lookupAndRecordAddrs([&](Error Err) { ErrP.set_value(std::move(Err)); }, ES,
LookupKind::Static, makeJITDylibSearchOrder(&JD),
{{Foo, &FooAddress}, {Bar, &BarAddress}},
{{Foo, &RecordedFooAddr}, {Bar, &RecordedBarAddr}},
SymbolLookupFlags::WeaklyReferencedSymbol);
Error Err = ErrP.get_future().get();
EXPECT_THAT_ERROR(std::move(Err), Succeeded());
EXPECT_EQ(FooAddress.getValue(), FooAddr);
EXPECT_EQ(BarAddress.getValue(), 0U);
EXPECT_EQ(RecordedFooAddr, FooAddr);
EXPECT_EQ(RecordedBarAddr, ExecutorAddr());
}
TEST_F(LookupAndRecordAddrsTest, BlockingRequiredSuccess) {
cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
ExecutorAddr FooAddress, BarAddress;
ExecutorAddr RecordedFooAddr, RecordedBarAddr;
auto Err =
lookupAndRecordAddrs(ES, LookupKind::Static, makeJITDylibSearchOrder(&JD),
{{Foo, &FooAddress}, {Bar, &BarAddress}});
{{Foo, &RecordedFooAddr}, {Bar, &RecordedBarAddr}});
EXPECT_THAT_ERROR(std::move(Err), Succeeded());
EXPECT_EQ(FooAddress.getValue(), FooAddr);
EXPECT_EQ(BarAddress.getValue(), BarAddr);
EXPECT_EQ(RecordedFooAddr, FooAddr);
EXPECT_EQ(RecordedBarAddr, BarAddr);
}
TEST_F(LookupAndRecordAddrsTest, BlockingRequiredFailure) {
ExecutorAddr FooAddress, BarAddress;
ExecutorAddr RecordedFooAddr, RecordedBarAddr;
auto Err =
lookupAndRecordAddrs(ES, LookupKind::Static, makeJITDylibSearchOrder(&JD),
{{Foo, &FooAddress}, {Bar, &BarAddress}});
{{Foo, &RecordedFooAddr}, {Bar, &RecordedBarAddr}});
EXPECT_THAT_ERROR(std::move(Err), Failed());
}
@@ -94,15 +94,15 @@ TEST_F(LookupAndRecordAddrsTest, BlockingRequiredFailure) {
TEST_F(LookupAndRecordAddrsTest, BlockingWeakReference) {
cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
ExecutorAddr FooAddress, BarAddress;
ExecutorAddr RecordedFooAddr, RecordedBarAddr;
auto Err =
lookupAndRecordAddrs(ES, LookupKind::Static, makeJITDylibSearchOrder(&JD),
{{Foo, &FooAddress}, {Bar, &BarAddress}},
{{Foo, &RecordedFooAddr}, {Bar, &RecordedBarAddr}},
SymbolLookupFlags::WeaklyReferencedSymbol);
EXPECT_THAT_ERROR(std::move(Err), Succeeded());
EXPECT_EQ(FooAddress.getValue(), FooAddr);
EXPECT_EQ(BarAddress.getValue(), 0U);
EXPECT_EQ(RecordedFooAddr, FooAddr);
EXPECT_EQ(RecordedBarAddr, ExecutorAddr());
}
} // namespace

5
llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp
View File

@@ -14,11 +14,6 @@
using namespace llvm;
const JITTargetAddress llvm::orc::CoreAPIsBasedStandardTest::FooAddr;
const JITTargetAddress llvm::orc::CoreAPIsBasedStandardTest::BarAddr;
const JITTargetAddress llvm::orc::CoreAPIsBasedStandardTest::BazAddr;
const JITTargetAddress llvm::orc::CoreAPIsBasedStandardTest::QuxAddr;
bool OrcNativeTarget::NativeTargetInitialized = false;
ModuleBuilder::ModuleBuilder(LLVMContext &Context, StringRef Triple,

20
llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
View File

@@ -59,18 +59,14 @@ protected:
SymbolStringPtr Bar = ES.intern("bar");
SymbolStringPtr Baz = ES.intern("baz");
SymbolStringPtr Qux = ES.intern("qux");
static const JITTargetAddress FooAddr = 1U;
static const JITTargetAddress BarAddr = 2U;
static const JITTargetAddress BazAddr = 3U;
static const JITTargetAddress QuxAddr = 4U;
JITEvaluatedSymbol FooSym =
JITEvaluatedSymbol(FooAddr, JITSymbolFlags::Exported);
JITEvaluatedSymbol BarSym =
JITEvaluatedSymbol(BarAddr, JITSymbolFlags::Exported);
JITEvaluatedSymbol BazSym =
JITEvaluatedSymbol(BazAddr, JITSymbolFlags::Exported);
JITEvaluatedSymbol QuxSym =
JITEvaluatedSymbol(QuxAddr, JITSymbolFlags::Exported);
static constexpr ExecutorAddr FooAddr{1};
static constexpr ExecutorAddr BarAddr{2};
static constexpr ExecutorAddr BazAddr{3};
static constexpr ExecutorAddr QuxAddr{4};
ExecutorSymbolDef FooSym{FooAddr, JITSymbolFlags::Exported};
ExecutorSymbolDef BarSym{BarAddr, JITSymbolFlags::Exported};
ExecutorSymbolDef BazSym{BazAddr, JITSymbolFlags::Exported};
ExecutorSymbolDef QuxSym{QuxAddr, JITSymbolFlags::Exported};
};
} // end namespace orc

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

@@ -298,7 +298,7 @@ TEST_F(ResourceTrackerStandardTest,
EXPECT_EQ(RR.size(), 0U) << "Expected no resources recorded yet";
});
auto MakeMU = [&](SymbolStringPtr Name, JITEvaluatedSymbol Sym) {
auto MakeMU = [&](SymbolStringPtr Name, ExecutorSymbolDef Sym) {
return std::make_unique<SimpleMaterializationUnit>(
SymbolFlagsMap({{Name, Sym.getFlags()}}),
[=, &SRM](std::unique_ptr<MaterializationResponsibility> R) {
@@ -348,7 +348,7 @@ TEST_F(ResourceTrackerStandardTest,
SRM.transferResources(JD, DstKey, SrcKey);
});
auto MakeMU = [&](SymbolStringPtr Name, JITEvaluatedSymbol Sym) {
auto MakeMU = [&](SymbolStringPtr Name, ExecutorSymbolDef Sym) {
return std::make_unique<SimpleMaterializationUnit>(
SymbolFlagsMap({{Name, Sym.getFlags()}}),
[=, &SRM](std::unique_ptr<MaterializationResponsibility> R) {