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

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

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

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

* ExecutorAddr::toPtr replaces jitTargetAddressToPointer and
  jitTargetAddressToFunction.

* ExecutorAddr::fromPtr replace pointerToJITTargetAddress.

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

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

JITTargetAddress and JITEvaluatedSymbol will remain in JITSymbol.h for now, but
the aim will be to eventually deprecate and remove these types (probably when
MCJIT and RuntimeDyld are deprecated).

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) {