diff options
61 files changed, 552 insertions, 589 deletions
diff --git a/llvm/docs/ORCv2.rst b/llvm/docs/ORCv2.rst index 219600e..203f389 100644 --- a/llvm/docs/ORCv2.rst +++ b/llvm/docs/ORCv2.rst @@ -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 diff --git a/llvm/docs/tutorial/BuildingAJIT1.rst b/llvm/docs/tutorial/BuildingAJIT1.rst index e51acb48..8c82dbe 100644 --- a/llvm/docs/tutorial/BuildingAJIT1.rst +++ b/llvm/docs/tutorial/BuildingAJIT1.rst @@ -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 | diff --git a/llvm/docs/tutorial/BuildingAJIT3.rst b/llvm/docs/tutorial/BuildingAJIT3.rst index 36ec2e7..d4b3e6f 100644 --- a/llvm/docs/tutorial/BuildingAJIT3.rst +++ b/llvm/docs/tutorial/BuildingAJIT3.rst @@ -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 diff --git a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h index 18a4c11..017ba95 100644 --- a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h +++ b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h @@ -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())); } }; diff --git a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp index e29de19..1b35ba4 100644 --- a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp +++ b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp @@ -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. diff --git a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h index 23a6fd8..8553b72 100644 --- a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h +++ b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h @@ -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())); } diff --git a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp index e29de19..1b35ba4 100644 --- a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp +++ b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp @@ -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. diff --git a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h index de16980..2be9cde 100644 --- a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h +++ b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h @@ -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())); } diff --git a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp index e29de19..1b35ba4 100644 --- a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp +++ b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp @@ -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. diff --git a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h index c5fa183b..ecd05d5 100644 --- a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h +++ b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h @@ -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())); } diff --git a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp index 09f8ec8..2c8d494 100644 --- a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp +++ b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp @@ -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. diff --git a/llvm/examples/Kaleidoscope/Chapter4/toy.cpp b/llvm/examples/Kaleidoscope/Chapter4/toy.cpp index 20aec1a..fb443c7 100644 --- a/llvm/examples/Kaleidoscope/Chapter4/toy.cpp +++ b/llvm/examples/Kaleidoscope/Chapter4/toy.cpp @@ -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. diff --git a/llvm/examples/Kaleidoscope/Chapter5/toy.cpp b/llvm/examples/Kaleidoscope/Chapter5/toy.cpp index 51420a9..dc7174a 100644 --- a/llvm/examples/Kaleidoscope/Chapter5/toy.cpp +++ b/llvm/examples/Kaleidoscope/Chapter5/toy.cpp @@ -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. diff --git a/llvm/examples/Kaleidoscope/Chapter6/toy.cpp b/llvm/examples/Kaleidoscope/Chapter6/toy.cpp index 4ebae0f..f40eea3 100644 --- a/llvm/examples/Kaleidoscope/Chapter6/toy.cpp +++ b/llvm/examples/Kaleidoscope/Chapter6/toy.cpp @@ -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. diff --git a/llvm/examples/Kaleidoscope/Chapter7/toy.cpp b/llvm/examples/Kaleidoscope/Chapter7/toy.cpp index c106c5a..5bbab8d 100644 --- a/llvm/examples/Kaleidoscope/Chapter7/toy.cpp +++ b/llvm/examples/Kaleidoscope/Chapter7/toy.cpp @@ -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. diff --git a/llvm/examples/Kaleidoscope/include/KaleidoscopeJIT.h b/llvm/examples/Kaleidoscope/include/KaleidoscopeJIT.h index 457a2d4..6abbe6d 100644 --- a/llvm/examples/Kaleidoscope/include/KaleidoscopeJIT.h +++ b/llvm/examples/Kaleidoscope/include/KaleidoscopeJIT.h @@ -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())); } }; diff --git a/llvm/examples/OrcV2Examples/LLJITWithExecutorProcessControl/LLJITWithExecutorProcessControl.cpp b/llvm/examples/OrcV2Examples/LLJITWithExecutorProcessControl/LLJITWithExecutorProcessControl.cpp index 04c2c2e..d3ca7bf 100644 --- a/llvm/examples/OrcV2Examples/LLJITWithExecutorProcessControl/LLJITWithExecutorProcessControl.cpp +++ b/llvm/examples/OrcV2Examples/LLJITWithExecutorProcessControl/LLJITWithExecutorProcessControl.cpp @@ -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( diff --git a/llvm/examples/OrcV2Examples/LLJITWithInitializers/LLJITWithInitializers.cpp b/llvm/examples/OrcV2Examples/LLJITWithInitializers/LLJITWithInitializers.cpp index 4fd55c4..32b51c3 100644 --- a/llvm/examples/OrcV2Examples/LLJITWithInitializers/LLJITWithInitializers.cpp +++ b/llvm/examples/OrcV2Examples/LLJITWithInitializers/LLJITWithInitializers.cpp @@ -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())); diff --git a/llvm/examples/OrcV2Examples/LLJITWithLazyReexports/LLJITWithLazyReexports.cpp b/llvm/examples/OrcV2Examples/LLJITWithLazyReexports/LLJITWithLazyReexports.cpp index e53a195..4b987cd 100644 --- a/llvm/examples/OrcV2Examples/LLJITWithLazyReexports/LLJITWithLazyReexports.cpp +++ b/llvm/examples/OrcV2Examples/LLJITWithLazyReexports/LLJITWithLazyReexports.cpp @@ -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")))); diff --git a/llvm/examples/SpeculativeJIT/SpeculativeJIT.cpp b/llvm/examples/SpeculativeJIT/SpeculativeJIT.cpp index 7f334ea..fdd376d 100644 --- a/llvm/examples/SpeculativeJIT/SpeculativeJIT.cpp +++ b/llvm/examples/SpeculativeJIT/SpeculativeJIT.cpp @@ -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())); diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h b/llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h index b1ee8a6..365ca50 100644 --- a/llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h @@ -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. diff --git a/llvm/include/llvm/ExecutionEngine/Orc/Core.h b/llvm/include/llvm/ExecutionEngine/Orc/Core.h index 33aa2cf..6aab88f 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/Core.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/Core.h @@ -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; }; diff --git a/llvm/include/llvm/ExecutionEngine/Orc/EPCIndirectionUtils.h b/llvm/include/llvm/ExecutionEngine/Orc/EPCIndirectionUtils.h index 354984b..867a029 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/EPCIndirectionUtils.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/EPCIndirectionUtils.h @@ -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, diff --git a/llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h b/llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h index 6f3af2b..2f13560 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h @@ -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>; diff --git a/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h b/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h index d659d6a..71ece42 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h @@ -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. diff --git a/llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h b/llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h index f81cdce..4916460 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h @@ -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. diff --git a/llvm/include/llvm/ExecutionEngine/Orc/OrcABISupport.h b/llvm/include/llvm/ExecutionEngine/Orc/OrcABISupport.h index 3048547..5d25a3e 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/OrcABISupport.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/OrcABISupport.h @@ -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 diff --git a/llvm/include/llvm/ExecutionEngine/Orc/Speculation.h b/llvm/include/llvm/ExecutionEngine/Orc/Speculation.h index 0a309c1..88c90f5 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/Speculation.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/Speculation.h @@ -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()); }; diff --git a/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp b/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp index b09dc76..b74164e 100644 --- a/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp @@ -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) { diff --git a/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp b/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp index 4ef3c3a..feaa0fb 100644 --- a/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp @@ -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 diff --git a/llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp b/llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp index dfafc42..6910fda 100644 --- a/llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp +++ b/llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp @@ -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); diff --git a/llvm/lib/ExecutionEngine/Orc/Core.cpp b/llvm/lib/ExecutionEngine/Orc/Core.cpp index 9b67128..9e99fa1 100644 --- a/llvm/lib/ExecutionEngine/Orc/Core.cpp +++ b/llvm/lib/ExecutionEngine/Orc/Core.cpp @@ -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; { diff --git a/llvm/lib/ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp b/llvm/lib/ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp index 02c3e61..75d3344 100644 --- a/llvm/lib/ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp +++ b/llvm/lib/ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp @@ -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); } diff --git a/llvm/lib/ExecutionEngine/Orc/DebugUtils.cpp b/llvm/lib/ExecutionEngine/Orc/DebugUtils.cpp index 028bd24..3404adf 100644 --- a/llvm/lib/ExecutionEngine/Orc/DebugUtils.cpp +++ b/llvm/lib/ExecutionEngine/Orc/DebugUtils.cpp @@ -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) { diff --git a/llvm/lib/ExecutionEngine/Orc/DebuggerSupportPlugin.cpp b/llvm/lib/ExecutionEngine/Orc/DebuggerSupportPlugin.cpp index 15e7ffb..5c7348a 100644 --- a/llvm/lib/ExecutionEngine/Orc/DebuggerSupportPlugin.cpp +++ b/llvm/lib/ExecutionEngine/Orc/DebuggerSupportPlugin.cpp @@ -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( diff --git a/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp b/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp index cd78105..6128cfe 100644 --- a/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp +++ b/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp @@ -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 diff --git a/llvm/lib/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.cpp b/llvm/lib/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.cpp index 1adcc91..46e16a5 100644 --- a/llvm/lib/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.cpp +++ b/llvm/lib/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.cpp @@ -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; } diff --git a/llvm/lib/ExecutionEngine/Orc/EPCIndirectionUtils.cpp b/llvm/lib/ExecutionEngine/Orc/EPCIndirectionUtils.cpp index ddfb305..0101a46 100644 --- a/llvm/lib/ExecutionEngine/Orc/EPCIndirectionUtils.cpp +++ b/llvm/lib/ExecutionEngine/Orc/EPCIndirectionUtils.cpp @@ -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(); } diff --git a/llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp b/llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp index 7795bac..6a10bbe 100644 --- a/llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp +++ b/llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp @@ -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()) diff --git a/llvm/lib/ExecutionEngine/Orc/ExecutorProcessControl.cpp b/llvm/lib/ExecutionEngine/Orc/ExecutorProcessControl.cpp index d877e22..b8b013f 100644 --- a/llvm/lib/ExecutionEngine/Orc/ExecutorProcessControl.cpp +++ b/llvm/lib/ExecutionEngine/Orc/ExecutorProcessControl.cpp @@ -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(); } diff --git a/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp b/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp index 9606d8e..8f2537d 100644 --- a/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp +++ b/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp @@ -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)); diff --git a/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp b/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp index 7bd2b17..8bc03a9 100644 --- a/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp +++ b/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp @@ -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(); diff --git a/llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp b/llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp index f94305c..d95a642 100644 --- a/llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp +++ b/llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp @@ -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); }); diff --git a/llvm/lib/ExecutionEngine/Orc/LookupAndRecordAddrs.cpp b/llvm/lib/ExecutionEngine/Orc/LookupAndRecordAddrs.cpp index 59c63d3..75075c5 100644 --- a/llvm/lib/ExecutionEngine/Orc/LookupAndRecordAddrs.cpp +++ b/llvm/lib/ExecutionEngine/Orc/LookupAndRecordAddrs.cpp @@ -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()); }, diff --git a/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp b/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp index abc1e0a..bc6194d 100644 --- a/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp +++ b/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp @@ -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()); } diff --git a/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp b/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp index 9103c62..03dd6b5 100644 --- a/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp +++ b/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp @@ -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?"); diff --git a/llvm/lib/ExecutionEngine/Orc/OrcABISupport.cpp b/llvm/lib/ExecutionEngine/Orc/OrcABISupport.cpp index 48dd0df..c84b54fb 100644 --- a/llvm/lib/ExecutionEngine/Orc/OrcABISupport.cpp +++ b/llvm/lib/ExecutionEngine/Orc/OrcABISupport.cpp @@ -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 diff --git a/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp b/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp index 98b784b..a73aec6 100644 --- a/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp +++ b/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp @@ -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()); diff --git a/llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp b/llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp index 07b19b2..9ef3332 100644 --- a/llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp +++ b/llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp @@ -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()) { diff --git a/llvm/lib/ExecutionEngine/Orc/SimpleRemoteEPC.cpp b/llvm/lib/ExecutionEngine/Orc/SimpleRemoteEPC.cpp index 1bd10c9..624408e 100644 --- a/llvm/lib/ExecutionEngine/Orc/SimpleRemoteEPC.cpp +++ b/llvm/lib/ExecutionEngine/Orc/SimpleRemoteEPC.cpp @@ -402,7 +402,7 @@ void SimpleRemoteEPC::handleCallWrapper( ExecutorAddr(), {WFR.data(), WFR.size()})) getExecutionSession().reportError(std::move(Err)); }, - TagAddr.getValue(), ArgBytes); + TagAddr, ArgBytes); }, "callWrapper task")); } diff --git a/llvm/lib/ExecutionEngine/Orc/Speculation.cpp b/llvm/lib/ExecutionEngine/Orc/Speculation.cpp index b52d013..d4cbd19 100644 --- a/llvm/lib/ExecutionEngine/Orc/Speculation.cpp +++ b/llvm/lib/ExecutionEngine/Orc/Speculation.cpp @@ -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 diff --git a/llvm/tools/lli/ExecutionUtils.h b/llvm/tools/lli/ExecutionUtils.h index fcd1db0..6bf9cd5 100644 --- a/llvm/tools/lli/ExecutionUtils.h +++ b/llvm/tools/lli/ExecutionUtils.h @@ -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(); diff --git a/llvm/tools/lli/lli.cpp b/llvm/tools/lli/lli.cpp index 3a5135c..d6baa7a 100644 --- a/llvm/tools/lli/lli.cpp +++ b/llvm/tools/lli/lli.cpp @@ -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)); } diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp index b2b0c70..5f057cd 100644 --- a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp +++ b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp @@ -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); } diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp index d094bd3..9064e0c 100644 --- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp @@ -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 { diff --git a/llvm/unittests/ExecutionEngine/Orc/ExecutionSessionWrapperFunctionCallsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/ExecutionSessionWrapperFunctionCallsTest.cpp index 784896f..1b79e12 100644 --- a/llvm/unittests/ExecutionEngine/Orc/ExecutionSessionWrapperFunctionCallsTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/ExecutionSessionWrapperFunctionCallsTest.cpp @@ -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; diff --git a/llvm/unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp index a5afd82..22762b7 100644 --- a/llvm/unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp @@ -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(); diff --git a/llvm/unittests/ExecutionEngine/Orc/LookupAndRecordAddrsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/LookupAndRecordAddrsTest.cpp index 4109321..05ea919 100644 --- a/llvm/unittests/ExecutionEngine/Orc/LookupAndRecordAddrsTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/LookupAndRecordAddrsTest.cpp @@ -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 diff --git a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp index 2a3223a..bc87df1 100644 --- a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp @@ -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, diff --git a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h index c2db65d..ce7da76 100644 --- a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h +++ b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h @@ -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 diff --git a/llvm/unittests/ExecutionEngine/Orc/ResourceTrackerTest.cpp b/llvm/unittests/ExecutionEngine/Orc/ResourceTrackerTest.cpp index fa0c374..9f13167 100644 --- a/llvm/unittests/ExecutionEngine/Orc/ResourceTrackerTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/ResourceTrackerTest.cpp @@ -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) { |