[ORC] Require TargetProcessControl instance when constructing ExecutionSession.

[lhames]

Summary

This will...

1. Simplify ES+TPC-based utilities, which will now only need an ExecutionSession

instance.

2. Simplify call and handle operations for wrapper functions, which will now be

able to be implemented on ExecutionSession.

3. Simplify termination, since TargetProcessControl::disconnect can now be called automatically from ExecutionSession::endSession.

This patch updates all in-tree code and examples except for
LLJITWithRemoteDebugging, which I'm still looking in to.

[sgraenitz]

Hi Lang

I think ES taking ownership of TPC makes a lot of sense. Sessions usually have a unique target process. I am not yet sure how it affects RPC scenarios, where clients might want to run multiple sessions subsequently or in parallel over one RPC connection. Separating the RPC parts from the TPC parts in OrcRPCTargetProcessControlBase? I didn't look into it, but it doesn't sound too bad on the first glance.

Simplify termination, since TargetProcessControl::disconnect can now be called automatically from ExecutionSession::endSession.

Does "can" mean it's a todo for a follow-up patch or was it supposed to be part of this review? ExecutionSession::endSession() hasn't changed (yet) and llvm-jitlink still calls TargetProcessControl::disconnect() manually.

This patch updates all in-tree code and examples except for LLJITWithRemoteDebugging

I will disable the example build+test for the moment and adjust+re-enable it once this patch landed.

+ a few minor details inline

llvm/include/llvm/ExecutionEngine/Orc/TargetProcessControl.h

190

is -> in?

198

The null check moved here from the ExecutionSession constructor. Is there a reason why it can't go to the TargetProcessControl constructor right away?

llvm/lib/ExecutionEngine/Orc/TargetProcessControl.cpp

49

Another null check here. Add one more in OrcRPCTargetProcessControlBase?

llvm/tools/lli/lli.cpp

1075

Maybe auto &TPC = J->getExecutionSession().getTargetProcessControl() would aid readability here as well?

[lhames]

In D104694#2844306, @sgraenitz wrote:

Hi Lang

Hi Stefan. Thank you for taking the time to take a look at this, and for the helpful feedback.

I think ES taking ownership of TPC makes a lot of sense. Sessions usually have a unique target process. I am not yet sure how it affects RPC scenarios, where clients might want to run multiple sessions subsequently or in parallel over one RPC connection. Separating the RPC parts from the TPC parts in OrcRPCTargetProcessControlBase? I didn't look into it, but it doesn't sound too bad on the first glance.

I think we can require a one-to-one correspondence between TargetProcessControl and ExecutionSession instances. TargetProcessControl authors can handle multiplexing multiple TargetProcessControl instances over one RPC connection if they care to.

Simplify termination, since TargetProcessControl::disconnect can now be called automatically from ExecutionSession::endSession.

Does "can" mean it's a todo for a follow-up patch or was it supposed to be part of this review? ExecutionSession::endSession() hasn't changed (yet) and llvm-jitlink still calls TargetProcessControl::disconnect() manually.

"can" is a todo for a follow-up patch.

This patch updates all in-tree code and examples except for LLJITWithRemoteDebugging

I will disable the example build+test for the moment and adjust+re-enable it once this patch landed.

That would be great if you could. I think you'll have an easier time updating it than I would.

llvm/include/llvm/ExecutionEngine/Orc/TargetProcessControl.h

190

Good catch -- I'll fix this and update the patch.

198

You're right -- I think this would be better done in the TargetProcessControl constructor. I'll fix that when I update the patch.

llvm/lib/ExecutionEngine/Orc/TargetProcessControl.cpp

49

You're right -- Thanks!

llvm/tools/lli/lli.cpp

1075

Yes -- I think that would be an improvement. I'll update that.

[sgraenitz]

LGTM!

I prepared a patch for the LLJITWithRemoteDebugging example: https://github.com/weliveindetail/llvm-project/commits/arcpatch-D104694 It's still unix-only and I need to double-check that it doesn't break Windows bots, but otherwise this should work. Build and test are currently disabled on main, so landing the change from this review should not break it.

[lhames]

This landed in 2487db1f286222e2501c2fa8e8244eda13f6afc3 (https://github.com/llvm/llvm-project/commit/2487db1f286222e2501c2fa8e8244eda13f6afc3).

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h

 #include "llvm/IR/LLVMContext.h"
 #include <memory>
 
 namespace llvm {
 namespace orc {
 
 class KaleidoscopeJIT {
 private:
-  std::unique_ptr<TargetProcessControl> TPC;
   std::unique_ptr<ExecutionSession> ES;
 
   DataLayout DL;
   MangleAndInterner Mangle;
 
   RTDyldObjectLinkingLayer ObjectLayer;
   IRCompileLayer CompileLayer;
 
   JITDylib &MainJD;
 
 public:
-  KaleidoscopeJIT(std::unique_ptr<TargetProcessControl> TPC,
-                  std::unique_ptr<ExecutionSession> ES,
+  KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
                   JITTargetMachineBuilder JTMB, DataLayout DL)
-      : TPC(std::move(TPC)), ES(std::move(ES)), DL(std::move(DL)),
-        Mangle(*this->ES, this->DL),
+      : ES(std::move(ES)), DL(std::move(DL)), Mangle(*this->ES, this->DL),
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
                      std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())
       ES->reportError(std::move(Err));
   }
 
   static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
-    auto SSP = std::make_shared<SymbolStringPool>();
-    auto TPC = SelfTargetProcessControl::Create(SSP);
+    auto TPC = SelfTargetProcessControl::Create();
     if (!TPC)
       return TPC.takeError();
 
-    auto ES = std::make_unique<ExecutionSession>(std::move(SSP));
+    auto ES = std::make_unique<ExecutionSession>(std::move(*TPC));
 
-    JITTargetMachineBuilder JTMB((*TPC)->getTargetTriple());
+    JITTargetMachineBuilder JTMB(
+        ES->getTargetProcessControl().getTargetTriple());
 
     auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
-    return std::make_unique<KaleidoscopeJIT>(std::move(*TPC), std::move(ES),
-                                             std::move(JTMB), std::move(*DL));
+    return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(JTMB),
+                                             std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   JITDylib &getMainJITDylib() { return MainJD; }
 
   Error addModule(ThreadSafeModule TSM, ResourceTrackerSP RT = nullptr) {
     if (!RT)

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h

 #include "llvm/Transforms/Scalar/GVN.h"
 #include <memory>
 
 namespace llvm {
 namespace orc {
 
 class KaleidoscopeJIT {
 private:
-  std::unique_ptr<TargetProcessControl> TPC;
   std::unique_ptr<ExecutionSession> ES;
 
   DataLayout DL;
   MangleAndInterner Mangle;
 
   RTDyldObjectLinkingLayer ObjectLayer;
   IRCompileLayer CompileLayer;
   IRTransformLayer OptimizeLayer;
 
   JITDylib &MainJD;
 
 public:
-  KaleidoscopeJIT(std::unique_ptr<TargetProcessControl> TPC,
-                  std::unique_ptr<ExecutionSession> ES,
+  KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
                   JITTargetMachineBuilder JTMB, DataLayout DL)
-      : TPC(std::move(TPC)), ES(std::move(ES)), DL(std::move(DL)),
-        Mangle(*this->ES, this->DL),
+      : ES(std::move(ES)), DL(std::move(DL)), Mangle(*this->ES, this->DL),
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
                      std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
         OptimizeLayer(*this->ES, CompileLayer, optimizeModule),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())
       ES->reportError(std::move(Err));
   }
 
   static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
-    auto SSP = std::make_shared<SymbolStringPool>();
-    auto TPC = SelfTargetProcessControl::Create(SSP);
+    auto TPC = SelfTargetProcessControl::Create();
     if (!TPC)
       return TPC.takeError();
 
-    auto ES = std::make_unique<ExecutionSession>(std::move(SSP));
+    auto ES = std::make_unique<ExecutionSession>(std::move(*TPC));
 
-    JITTargetMachineBuilder JTMB((*TPC)->getTargetTriple());
+    JITTargetMachineBuilder JTMB(
+        ES->getTargetProcessControl().getTargetTriple());
 
     auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
-    return std::make_unique<KaleidoscopeJIT>(std::move(*TPC), std::move(ES),
-                                             std::move(JTMB), std::move(*DL));
+    return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(JTMB),
+                                             std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   JITDylib &getMainJITDylib() { return MainJD; }
 
   Error addModule(ThreadSafeModule TSM, ResourceTrackerSP RT = nullptr) {
     if (!RT)

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h

 #include "llvm/Transforms/Scalar/GVN.h"
 #include <memory>
 
 namespace llvm {
 namespace orc {
 
 class KaleidoscopeJIT {
 private:
-  std::unique_ptr<TargetProcessControl> TPC;
   std::unique_ptr<ExecutionSession> ES;
   std::unique_ptr<TPCIndirectionUtils> TPCIU;
 
   DataLayout DL;
   MangleAndInterner Mangle;
 
   RTDyldObjectLinkingLayer ObjectLayer;
   IRCompileLayer CompileLayer;
   IRTransformLayer OptimizeLayer;
   CompileOnDemandLayer CODLayer;
 
   JITDylib &MainJD;
 
   static void handleLazyCallThroughError() {
     errs() << "LazyCallThrough error: Could not find function body";
     exit(1);
   }
 
 public:
-  KaleidoscopeJIT(std::unique_ptr<TargetProcessControl> TPC,
-                  std::unique_ptr<ExecutionSession> ES,
+  KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
                   std::unique_ptr<TPCIndirectionUtils> TPCIU,
                   JITTargetMachineBuilder JTMB, DataLayout DL)
-      : TPC(std::move(TPC)), ES(std::move(ES)), TPCIU(std::move(TPCIU)),
-        DL(std::move(DL)), Mangle(*this->ES, this->DL),
+      : ES(std::move(ES)), TPCIU(std::move(TPCIU)), DL(std::move(DL)),
+        Mangle(*this->ES, this->DL),
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
                      std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
         OptimizeLayer(*this->ES, CompileLayer, optimizeModule),
         CODLayer(*this->ES, OptimizeLayer,
                  this->TPCIU->getLazyCallThroughManager(),
                  [this] { return this->TPCIU->createIndirectStubsManager(); }),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())
       ES->reportError(std::move(Err));
     if (auto Err = TPCIU->cleanup())
       ES->reportError(std::move(Err));
   }
 
   static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
-    auto SSP = std::make_shared<SymbolStringPool>();
-    auto TPC = SelfTargetProcessControl::Create(SSP);
+    auto TPC = SelfTargetProcessControl::Create();
     if (!TPC)
       return TPC.takeError();
 
-    auto ES = std::make_unique<ExecutionSession>(std::move(SSP));
+    auto ES = std::make_unique<ExecutionSession>(std::move(*TPC));
 
-    auto TPCIU = TPCIndirectionUtils::Create(**TPC);
+    auto TPCIU = TPCIndirectionUtils::Create(ES->getTargetProcessControl());
     if (!TPCIU)
       return TPCIU.takeError();
 
     (*TPCIU)->createLazyCallThroughManager(
         *ES, pointerToJITTargetAddress(&handleLazyCallThroughError));
 
     if (auto Err = setUpInProcessLCTMReentryViaTPCIU(**TPCIU))
       return std::move(Err);
 
-    JITTargetMachineBuilder JTMB((*TPC)->getTargetTriple());
+    JITTargetMachineBuilder JTMB(
+        ES->getTargetProcessControl().getTargetTriple());
 
     auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
-    return std::make_unique<KaleidoscopeJIT>(std::move(*TPC), std::move(ES),
-                                             std::move(*TPCIU), std::move(JTMB),
-                                             std::move(*DL));
+    return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(*TPCIU),
+                                             std::move(JTMB), std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   JITDylib &getMainJITDylib() { return MainJD; }
 
   Error addModule(ThreadSafeModule TSM, ResourceTrackerSP RT = nullptr) {
     if (!RT)

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h

 
 void KaleidoscopeASTMaterializationUnit::materialize(
     std::unique_ptr<MaterializationResponsibility> R) {
   L.emit(std::move(R), std::move(F));
 }
 
 class KaleidoscopeJIT {
 private:
-  std::unique_ptr<TargetProcessControl> TPC;
   std::unique_ptr<ExecutionSession> ES;
   std::unique_ptr<TPCIndirectionUtils> TPCIU;
 
   DataLayout DL;
   MangleAndInterner Mangle;
 
   RTDyldObjectLinkingLayer ObjectLayer;
   IRCompileLayer CompileLayer;
   IRTransformLayer OptimizeLayer;
   KaleidoscopeASTLayer ASTLayer;
 
   JITDylib &MainJD;
 
   static void handleLazyCallThroughError() {
     errs() << "LazyCallThrough error: Could not find function body";
     exit(1);
   }
 
 public:
-  KaleidoscopeJIT(std::unique_ptr<TargetProcessControl> TPC,
-                  std::unique_ptr<ExecutionSession> ES,
+  KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
                   std::unique_ptr<TPCIndirectionUtils> TPCIU,
                   JITTargetMachineBuilder JTMB, DataLayout DL)
-      : TPC(std::move(TPC)), ES(std::move(ES)), TPCIU(std::move(TPCIU)),
-        DL(std::move(DL)), Mangle(*this->ES, this->DL),
+      : ES(std::move(ES)), TPCIU(std::move(TPCIU)), DL(std::move(DL)),
+        Mangle(*this->ES, this->DL),
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
                      std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
         OptimizeLayer(*this->ES, CompileLayer, optimizeModule),
         ASTLayer(OptimizeLayer, this->DL),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())
       ES->reportError(std::move(Err));
     if (auto Err = TPCIU->cleanup())
       ES->reportError(std::move(Err));
   }
 
   static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
-    auto SSP = std::make_shared<SymbolStringPool>();
-    auto TPC = SelfTargetProcessControl::Create(SSP);
+    auto TPC = SelfTargetProcessControl::Create();
     if (!TPC)
       return TPC.takeError();
 
-    auto ES = std::make_unique<ExecutionSession>(std::move(SSP));
+    auto ES = std::make_unique<ExecutionSession>(std::move(*TPC));
 
-    auto TPCIU = TPCIndirectionUtils::Create(**TPC);
+    auto TPCIU = TPCIndirectionUtils::Create(ES->getTargetProcessControl());
     if (!TPCIU)
       return TPCIU.takeError();
 
     (*TPCIU)->createLazyCallThroughManager(
         *ES, pointerToJITTargetAddress(&handleLazyCallThroughError));
 
     if (auto Err = setUpInProcessLCTMReentryViaTPCIU(**TPCIU))
       return std::move(Err);
 
     JITTargetMachineBuilder JTMB((*TPC)->getTargetTriple());
 
     auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
-    return std::make_unique<KaleidoscopeJIT>(std::move(*TPC), std::move(ES),
-                                             std::move(*TPCIU), std::move(JTMB),
-                                             std::move(*DL));
+    return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(*TPCIU),
+                                             std::move(JTMB), std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   JITDylib &getMainJITDylib() { return MainJD; }
 
   Error addModule(ThreadSafeModule TSM, ResourceTrackerSP RT = nullptr) {
     if (!RT)

llvm/examples/Kaleidoscope/include/KaleidoscopeJIT.h

 #include "llvm/IR/LLVMContext.h"
 #include <memory>
 
 namespace llvm {
 namespace orc {
 
 class KaleidoscopeJIT {
 private:
-  std::unique_ptr<TargetProcessControl> TPC;
   std::unique_ptr<ExecutionSession> ES;
 
   DataLayout DL;
   MangleAndInterner Mangle;
 
   RTDyldObjectLinkingLayer ObjectLayer;
   IRCompileLayer CompileLayer;
 
   JITDylib &MainJD;
 
 public:
-  KaleidoscopeJIT(std::unique_ptr<TargetProcessControl> TPC,
-                  std::unique_ptr<ExecutionSession> ES,
+  KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
                   JITTargetMachineBuilder JTMB, DataLayout DL)
-      : TPC(std::move(TPC)), ES(std::move(ES)), DL(std::move(DL)),
-        Mangle(*this->ES, this->DL),
+      : ES(std::move(ES)), DL(std::move(DL)), Mangle(*this->ES, this->DL),
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
                      std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())
       ES->reportError(std::move(Err));
   }
 
   static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
-    auto SSP = std::make_shared<SymbolStringPool>();
-    auto TPC = SelfTargetProcessControl::Create(SSP);
+    auto TPC = SelfTargetProcessControl::Create();
     if (!TPC)
       return TPC.takeError();
 
-    auto ES = std::make_unique<ExecutionSession>(std::move(SSP));
+    auto ES = std::make_unique<ExecutionSession>(std::move(*TPC));
 
-    JITTargetMachineBuilder JTMB((*TPC)->getTargetTriple());
+    JITTargetMachineBuilder JTMB(
+        ES->getTargetProcessControl().getTargetTriple());
 
     auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
-    return std::make_unique<KaleidoscopeJIT>(std::move(*TPC), std::move(ES),
-                                             std::move(JTMB), std::move(*DL));
+    return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(JTMB),
+                                             std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   JITDylib &getMainJITDylib() { return MainJD; }
 
   Error addModule(ThreadSafeModule TSM, ResourceTrackerSP RT = nullptr) {
     if (!RT)

llvm/include/llvm/ExecutionEngine/Orc/Core.h

 #define LLVM_EXECUTIONENGINE_ORC_CORE_H
 
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ExecutionEngine/JITLink/JITLinkDylib.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
-#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
 #include "llvm/ExecutionEngine/OrcV1Deprecation.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ExtensibleRTTI.h"
 
 #include <atomic>
 #include <memory>
 #include <vector>
 

 
 public:
   /// For reporting errors.
   using ErrorReporter = std::function<void(Error)>;
 
   /// For dispatching ORC tasks (typically materialization tasks).
   using DispatchTaskFunction = unique_function<void(std::unique_ptr<Task> T)>;
 
-  /// Construct an ExecutionSession.
-  ///
-  /// SymbolStringPools may be shared between ExecutionSessions.
-  ExecutionSession(std::shared_ptr<SymbolStringPool> SSP = nullptr);
+  /// Construct an ExecutionSession with the given TargetProcessControl object.
+  ExecutionSession(std::unique_ptr<TargetProcessControl> TPC);
 
   /// End the session. Closes all JITDylibs.
   Error endSession();
 
-  /// Add a symbol name to the SymbolStringPool and return a pointer to it.
-  SymbolStringPtr intern(StringRef SymName) { return SSP->intern(SymName); }
+  /// Get the TargetProcessControl object associated with this ExecutionSession.
+  TargetProcessControl &getTargetProcessControl() { return *TPC; }
 
-  /// Returns a shared_ptr to the SymbolStringPool for this ExecutionSession.
-  std::shared_ptr<SymbolStringPool> getSymbolStringPool() const { return SSP; }
+  /// Add a symbol name to the SymbolStringPool and return a pointer to it.
+  SymbolStringPtr intern(StringRef SymName) { return TPC->intern(SymName); }
 
   /// Set the Platform for this ExecutionSession.
   void setPlatform(std::unique_ptr<Platform> P) { this->P = std::move(P); }
 
   /// Get the Platform for this session.
   /// Will return null if no Platform has been set for this ExecutionSession.
   Platform *getPlatform() { return P.get(); }
 
void OL_addDependenciesForAll(MaterializationResponsibility &MR,
                                 const SymbolDependenceMap &Dependencies);
 
 #ifndef NDEBUG
   void dumpDispatchInfo(Task &T);
 #endif // NDEBUG
 
   mutable std::recursive_mutex SessionMutex;
   bool SessionOpen = true;
-  std::shared_ptr<SymbolStringPool> SSP;
+  std::unique_ptr<TargetProcessControl> TPC;
   std::unique_ptr<Platform> P;
   ErrorReporter ReportError = logErrorsToStdErr;
   DispatchTaskFunction DispatchTask = runOnCurrentThread;
 
   std::vector<ResourceManager *> ResourceManagers;
 
   std::vector<JITDylibSP> JDs;
 

llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h

using ObjectLinkingLayerCreator =
                                                            const Triple &)>;
 
   using CompileFunctionCreator =
       std::function<Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>(
           JITTargetMachineBuilder JTMB)>;
 
   using PlatformSetupFunction = std::function<Error(LLJIT &J)>;
 
+  std::unique_ptr<TargetProcessControl> TPC;
   std::unique_ptr<ExecutionSession> ES;
   Optional<JITTargetMachineBuilder> JTMB;
   Optional<DataLayout> DL;
   ObjectLinkingLayerCreator CreateObjectLinkingLayer;
   CompileFunctionCreator CreateCompileFunction;
   PlatformSetupFunction SetUpPlatform;
   unsigned NumCompileThreads = 0;
-  TargetProcessControl *TPC = nullptr;
 
   /// Called prior to JIT class construcion to fix up defaults.
   Error prepareForConstruction();
 };
 
 template <typename JITType, typename SetterImpl, typename State>
 class LLJITBuilderSetters {
 public:
-
+  /// Set a TargetProcessControl for this instance.
+  /// This should not be called if ExecutionSession has already been set.
+  SetterImpl &
+  setTargetProcessControl(std::unique_ptr<TargetProcessControl> TPC) {
+    assert(
+        !impl().ES &&
+        "setTargetProcessControl should not be called if an ExecutionSession "
+        "has already been set");
+    impl().TPC = std::move(TPC);
+    return impl();
+  }
   /// Set an ExecutionSession for this instance.
   SetterImpl &setExecutionSession(std::unique_ptr<ExecutionSession> ES) {
     impl().ES = std::move(ES);
     return impl();
   }
 
   /// Set the JITTargetMachineBuilder for this instance.
   ///
public:
   ///
   /// If this method is not called, behavior will be as if it were called with
   /// a zero argument.
   SetterImpl &setNumCompileThreads(unsigned NumCompileThreads) {
     impl().NumCompileThreads = NumCompileThreads;
     return impl();
   }
 
-  /// Set a TargetProcessControl object.
-  ///
-  /// If the platform uses ObjectLinkingLayer by default and no
-  /// ObjectLinkingLayerCreator has been set then the TargetProcessControl
-  /// object will be used to supply the memory manager for the
-  /// ObjectLinkingLayer.
-  SetterImpl &setTargetProcessControl(TargetProcessControl &TPC) {
-    impl().TPC = &TPC;
-    return impl();
-  }
-
   /// Create an instance of the JIT.
   Expected<std::unique_ptr<JITType>> create() {
     if (auto Err = impl().prepareForConstruction())
       return std::move(Err);
 
     Error Err = Error::success();
     std::unique_ptr<JITType> J(new JITType(impl(), Err));
     if (Err)

llvm/include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h

public:
     getSyntheticSymbolLocalDependencies(MaterializationResponsibility &MR) {
       return LocalDependenciesMap();
     }
   };
 
   using ReturnObjectBufferFunction =
       std::function<void(std::unique_ptr<MemoryBuffer>)>;
 
-  /// Construct an ObjectLinkingLayer.
+  /// Construct an ObjectLinkingLayer using the TargetProcessControl
+  /// instance's memory manager.
+  ObjectLinkingLayer(ExecutionSession &ES);
+
+  /// Construct an ObjectLinkingLayer using a custom memory manager.
   ObjectLinkingLayer(ExecutionSession &ES,
                      jitlink::JITLinkMemoryManager &MemMgr);
 
   /// Construct an ObjectLinkingLayer. Takes ownership of the given
   /// JITLinkMemoryManager. This method is a temporary hack to simplify
   /// co-existence with RTDyldObjectLinkingLayer (which also owns its
   /// allocators).
   ObjectLinkingLayer(ExecutionSession &ES,

llvm/include/llvm/ExecutionEngine/Orc/TPCDebugObjectRegistrar.h

 //===- TPCDebugObjectRegistrar.h - TPC-based debug registration -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // TargetProcessControl based registration of debug objects.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_TPCDEBUGOBJECTREGISTRAR_H
 #define LLVM_EXECUTIONENGINE_ORC_TPCDEBUGOBJECTREGISTRAR_H
 
 #include "llvm/ExecutionEngine/JITSymbol.h"
-#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
+#include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Memory.h"
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
 using namespace llvm::orc::shared;
 
 namespace llvm {
 namespace orc {
 
+class ExecutionSession;
+class TargetProcessControl;
+
 /// Abstract interface for registering debug objects in the target process.
 class DebugObjectRegistrar {
 public:
   virtual Error registerDebugObject(sys::MemoryBlock) = 0;
   virtual ~DebugObjectRegistrar() {}
 };
 
 /// Use TargetProcessControl to register debug objects locally or in a remote
 /// target process.
 class TPCDebugObjectRegistrar : public DebugObjectRegistrar {
 public:
-  TPCDebugObjectRegistrar(TargetProcessControl &TPC,
-                          JITTargetAddress RegisterFn)
-      : TPC(TPC), RegisterFn(RegisterFn) {}
-
-  Error registerDebugObject(sys::MemoryBlock TargetMem) override {
-    return WrapperFunction<void(SPSTargetAddress, uint64_t)>::call(
-        TPCCaller(TPC, RegisterFn), pointerToJITTargetAddress(TargetMem.base()),
-        static_cast<uint64_t>(TargetMem.allocatedSize()));
-  }
+  TPCDebugObjectRegistrar(ExecutionSession &ES, JITTargetAddress RegisterFn)
+      : ES(ES), RegisterFn(RegisterFn) {}
+
+  Error registerDebugObject(sys::MemoryBlock TargetMem) override;
 
 private:
-  TargetProcessControl &TPC;
+  ExecutionSession &ES;
   JITTargetAddress RegisterFn;
 };
 
 /// Create a TargetProcessControl-based DebugObjectRegistrar that emits debug
 /// objects to the GDB JIT interface.
 Expected<std::unique_ptr<TPCDebugObjectRegistrar>>
-createJITLoaderGDBRegistrar(TargetProcessControl &TPC);
+createJITLoaderGDBRegistrar(ExecutionSession &ES);
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_TDEBUGOBJECTREGISTRAR_H

llvm/include/llvm/ExecutionEngine/Orc/TPCDynamicLibrarySearchGenerator.h

 // the TargetProcessControl class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_TPCDYNAMICLIBRARYSEARCHGENERATOR_H
 #define LLVM_EXECUTIONENGINE_ORC_TPCDYNAMICLIBRARYSEARCHGENERATOR_H
 
 #include "llvm/ADT/FunctionExtras.h"
-#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
 
 namespace llvm {
 namespace orc {
 
+class TargetProcessControl;
+
 class TPCDynamicLibrarySearchGenerator : public DefinitionGenerator {
 public:
   using SymbolPredicate = unique_function<bool(const SymbolStringPtr &)>;
 
   /// Create a DynamicLibrarySearchGenerator that searches for symbols in the
   /// library with the given handle.
   ///
   /// If the Allow predicate is given then only symbols matching the predicate
   /// will be searched for. If the predicate is not given then all symbols will
   /// be searched for.
-  TPCDynamicLibrarySearchGenerator(TargetProcessControl &TPC,
+  TPCDynamicLibrarySearchGenerator(ExecutionSession &ES,
                                    tpctypes::DylibHandle H,
                                    SymbolPredicate Allow = SymbolPredicate())
-      : TPC(TPC), H(H), Allow(std::move(Allow)) {}
+      : TPC(ES.getTargetProcessControl()), H(H), Allow(std::move(Allow)) {}
 
   /// Permanently loads the library at the given path and, on success, returns
   /// a DynamicLibrarySearchGenerator that will search it for symbol definitions
   /// in the library. On failure returns the reason the library failed to load.
   static Expected<std::unique_ptr<TPCDynamicLibrarySearchGenerator>>
-  Load(TargetProcessControl &TPC, const char *LibraryPath,
+  Load(ExecutionSession &ES, const char *LibraryPath,
        SymbolPredicate Allow = SymbolPredicate());
 
   /// Creates a TPCDynamicLibrarySearchGenerator that searches for symbols in
   /// the target process.
   static Expected<std::unique_ptr<TPCDynamicLibrarySearchGenerator>>
-  GetForTargetProcess(TargetProcessControl &TPC,
+  GetForTargetProcess(ExecutionSession &ES,
                       SymbolPredicate Allow = SymbolPredicate()) {
-    return Load(TPC, nullptr, std::move(Allow));
+    return Load(ES, nullptr, std::move(Allow));
   }
 
   Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
                       JITDylibLookupFlags JDLookupFlags,
                       const SymbolLookupSet &Symbols) override;
 
 private:
   TargetProcessControl &TPC;
   tpctypes::DylibHandle H;
   SymbolPredicate Allow;
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_TPCDYNAMICLIBRARYSEARCHGENERATOR_H

llvm/include/llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h

 //===-- TPCEHFrameRegistrar.h - TPC based eh-frame registration -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // TargetProcessControl based eh-frame registration.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_TPCEHFRAMEREGISTRAR_H
 #define LLVM_EXECUTIONENGINE_ORC_TPCEHFRAMEREGISTRAR_H
 
 #include "llvm/ExecutionEngine/JITLink/EHFrameSupport.h"
-#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
 
 namespace llvm {
 namespace orc {
 
+class ExecutionSession;
+
 /// Register/Deregisters EH frames in a remote process via a
 /// TargetProcessControl instance.
 class TPCEHFrameRegistrar : public jitlink::EHFrameRegistrar {
 public:
   /// Create from a TargetProcessControl instance alone. This will use
   /// the TPC's lookupSymbols method to find the registration/deregistration
   /// funciton addresses by name.
   static Expected<std::unique_ptr<TPCEHFrameRegistrar>>
-  Create(TargetProcessControl &TPC);
+  Create(ExecutionSession &ES);
 
   /// Create a TPCEHFrameRegistrar with the given TargetProcessControl
   /// object and registration/deregistration function addresses.
-  TPCEHFrameRegistrar(TargetProcessControl &TPC,
+  TPCEHFrameRegistrar(ExecutionSession &ES,
                       JITTargetAddress RegisterEHFrameWrapperFnAddr,
                       JITTargetAddress DeregisterEHFRameWrapperFnAddr)
-      : TPC(TPC), RegisterEHFrameWrapperFnAddr(RegisterEHFrameWrapperFnAddr),
+      : ES(ES), RegisterEHFrameWrapperFnAddr(RegisterEHFrameWrapperFnAddr),
         DeregisterEHFrameWrapperFnAddr(DeregisterEHFRameWrapperFnAddr) {}
 
   Error registerEHFrames(JITTargetAddress EHFrameSectionAddr,
                          size_t EHFrameSectionSize) override;
   Error deregisterEHFrames(JITTargetAddress EHFrameSectionAddr,
                            size_t EHFrameSectionSize) override;
 
 private:
-  TargetProcessControl &TPC;
+  ExecutionSession &ES;
   JITTargetAddress RegisterEHFrameWrapperFnAddr;
   JITTargetAddress DeregisterEHFrameWrapperFnAddr;
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_TPCEHFRAMEREGISTRAR_H

llvm/include/llvm/ExecutionEngine/Orc/TargetProcessControl.h

 
 #ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESSCONTROL_H
 #define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESSCONTROL_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
-#include "llvm/ExecutionEngine/Orc/Core.h"
 #include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
 #include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
+#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/MSVCErrorWorkarounds.h"
 
 #include <future>
 #include <vector>
 
 namespace llvm {
 namespace orc {
 
+class SymbolLookupSet;
+
 /// TargetProcessControl supports interaction with a JIT target process.
 class TargetProcessControl {
 public:
   /// APIs for manipulating memory in the target process.
   class MemoryAccess {
   public:
     /// Callback function for asynchronous writes.
     using WriteResultFn = unique_function<void(Error)>;
public:
 
   /// Return the Triple for the target process.
   const Triple &getTargetTriple() const { return TargetTriple; }
 
   /// Get the page size for the target process.
   unsigned getPageSize() const { return PageSize; }
 
   /// Return a MemoryAccess object for the target process.
-  MemoryAccess &getMemoryAccess() const { return *MemAccess; }
+  MemoryAccess &getMemoryAccess() const {
+    assert(MemAccess && "No MemAccess object set.");
+    return *MemAccess;
+  }
 
   /// Return a JITLinkMemoryManager for the target process.
-  jitlink::JITLinkMemoryManager &getMemMgr() const { return *MemMgr; }
+  jitlink::JITLinkMemoryManager &getMemMgr() const {
+    assert(MemMgr && "No MemMgr object set");
+    return *MemMgr;
+  }
 
   /// Load the dynamic library at the given path and return a handle to it.
   /// If LibraryPath is null this function will return the global handle for
   /// the target process.
   virtual Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) = 0;
 
   /// Search for symbols in the target process.
   ///
Expected<shared::WrapperFunctionResult> operator()(const char *ArgData,
     return TPC.runWrapper(WrapperFnAddr, ArrayRef<char>(ArgData, ArgSize));
   }
 
 private:
   TargetProcessControl &TPC;
   JITTargetAddress WrapperFnAddr;
 };
 
+/// A TargetProcessControl instance that asserts if any of its methods are used.
+/// Suitable for use is unit tests, and by ORC clients who haven't moved to
+/// TargetProcessControl-based APIs yet.
+class UnsupportedTargetProcessControl : public TargetProcessControl {
+public:
+  UnsupportedTargetProcessControl(
+      std::shared_ptr<SymbolStringPool> SSP = nullptr,
+      const std::string &TT = "", unsigned PageSize = 0)
+      : TargetProcessControl(SSP ? std::move(SSP)
+                                 : std::make_shared<SymbolStringPool>()) {
+    this->TargetTriple = Triple(TT);
+    this->PageSize = PageSize;
+  }
+
+  Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override {
+    llvm_unreachable("Unsupported");
+  }
+
+  Expected<std::vector<tpctypes::LookupResult>>
+  lookupSymbols(ArrayRef<LookupRequest> Request) override {
+    llvm_unreachable("Unsupported");
+  }
+
+  Expected<int32_t> runAsMain(JITTargetAddress MainFnAddr,
+                              ArrayRef<std::string> Args) override {
+    llvm_unreachable("Unsupported");
+  }
+
+  Expected<shared::WrapperFunctionResult>
+  runWrapper(JITTargetAddress WrapperFnAddr,
+             ArrayRef<char> ArgBuffer) override {
+    llvm_unreachable("Unsupported");
+  }
+
+  Error disconnect() override { llvm_unreachable("Unsupported"); }
+};
+
 /// A TargetProcessControl implementation targeting the current process.
 class SelfTargetProcessControl : public TargetProcessControl,
                                  private TargetProcessControl::MemoryAccess {
 public:
   SelfTargetProcessControl(
       std::shared_ptr<SymbolStringPool> SSP, Triple TargetTriple,
       unsigned PageSize, std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr);
 
-  /// Create a SelfTargetProcessControl with the given memory manager.
+  /// Create a SelfTargetProcessControl with the given symbol string pool and
+  /// memory manager.
+  /// If no symbol string pool is given then one will be created.
   /// If no memory manager is given a jitlink::InProcessMemoryManager will
-  /// be used by default.
+  /// be created and used by default.
   static Expected<std::unique_ptr<SelfTargetProcessControl>>
-  Create(std::shared_ptr<SymbolStringPool> SSP,
+  Create(std::shared_ptr<SymbolStringPool> SSP = nullptr,
          std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr = nullptr);
 
   Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override;
 
   Expected<std::vector<tpctypes::LookupResult>>
   lookupSymbols(ArrayRef<LookupRequest> Request) override;
 
   Expected<int32_t> runAsMain(JITTargetAddress MainFnAddr,

llvm/lib/ExecutionEngine/Orc/Core.cpp

 
 void MaterializationTask::printDescription(raw_ostream &OS) {
   OS << "Materialization task: " << MU->getName() << " in "
      << MR->getTargetJITDylib().getName();
 }
 
 void MaterializationTask::run() { MU->materialize(std::move(MR)); }
 
-ExecutionSession::ExecutionSession(std::shared_ptr<SymbolStringPool> SSP)
-    : SSP(SSP ? std::move(SSP) : std::make_shared<SymbolStringPool>()) {}
+ExecutionSession::ExecutionSession(std::unique_ptr<TargetProcessControl> TPC)
+    : TPC(std::move(TPC)) {}
 
 Error ExecutionSession::endSession() {
   LLVM_DEBUG(dbgs() << "Ending ExecutionSession " << this << "\n");
 
   std::vector<JITDylibSP> JITDylibsToClose = runSessionLocked([&] {
     SessionOpen = false;
     return std::move(JDs);
   });

llvm/lib/ExecutionEngine/Orc/LLJIT.cpp

Error LLJITBuilderState::prepareForConstruction() {
   if (!CreateObjectLinkingLayer) {
     auto &TT = JTMB->getTargetTriple();
     if (TT.isOSBinFormatMachO() &&
         (TT.getArch() == Triple::aarch64 || TT.getArch() == Triple::x86_64)) {
 
       JTMB->setRelocationModel(Reloc::PIC_);
       JTMB->setCodeModel(CodeModel::Small);
       CreateObjectLinkingLayer =
-          [TPC = this->TPC](
-              ExecutionSession &ES,
-              const Triple &) -> Expected<std::unique_ptr<ObjectLayer>> {
-        std::unique_ptr<ObjectLinkingLayer> ObjLinkingLayer;
-        if (TPC)
-          ObjLinkingLayer =
-              std::make_unique<ObjectLinkingLayer>(ES, TPC->getMemMgr());
-        else
-          ObjLinkingLayer = std::make_unique<ObjectLinkingLayer>(
-              ES, std::make_unique<jitlink::InProcessMemoryManager>());
+          [](ExecutionSession &ES,
+        auto ObjLinkingLayer = std::make_unique<ObjectLinkingLayer>(ES);
         ObjLinkingLayer->addPlugin(std::make_unique<EHFrameRegistrationPlugin>(
             ES, std::make_unique<jitlink::InProcessEHFrameRegistrar>()));
         return std::move(ObjLinkingLayer);
       };
     }
   }
 
   return Error::success();
LLJIT::createCompileFunction(LLJITBuilderState &S,
   auto TM = JTMB.createTargetMachine();
   if (!TM)
     return TM.takeError();
 
   return std::make_unique<TMOwningSimpleCompiler>(std::move(*TM));
 }
 
 LLJIT::LLJIT(LLJITBuilderState &S, Error &Err)
-    : ES(S.ES ? std::move(S.ES) : std::make_unique<ExecutionSession>()), Main(),
-      DL(""), TT(S.JTMB->getTargetTriple()) {
+    : DL(""), TT(S.JTMB->getTargetTriple()) {
 
   ErrorAsOutParameter _(&Err);
 
+  assert(!(S.TPC && S.ES) && "TPC and ES should not both be set");
+
+  if (S.TPC) {
+    ES = std::make_unique<ExecutionSession>(std::move(S.TPC));
+  } else if (S.ES)
+    ES = std::move(S.ES);
+  else {
+    if (auto TPC = SelfTargetProcessControl::Create()) {
+      ES = std::make_unique<ExecutionSession>(std::move(*TPC));
+    } else {
+      Err = TPC.takeError();
+      return;
+    }
+  }
+
   if (auto MainOrErr = this->ES->createJITDylib("main"))
     Main = &*MainOrErr;
   else {
     Err = MainOrErr.takeError();
     return;
   }
 
   if (S.DL)

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

 };
 
 ObjectLinkingLayer::Plugin::~Plugin() {}
 
 char ObjectLinkingLayer::ID;
 
 using BaseT = RTTIExtends<ObjectLinkingLayer, ObjectLayer>;
 
+ObjectLinkingLayer::ObjectLinkingLayer(ExecutionSession &ES)
+    : BaseT(ES), MemMgr(ES.getTargetProcessControl().getMemMgr()) {
+  ES.registerResourceManager(*this);
+}
+
 ObjectLinkingLayer::ObjectLinkingLayer(ExecutionSession &ES,
                                        JITLinkMemoryManager &MemMgr)
     : BaseT(ES), MemMgr(MemMgr) {
   ES.registerResourceManager(*this);
 }
 
 ObjectLinkingLayer::ObjectLinkingLayer(
     ExecutionSession &ES, std::unique_ptr<JITLinkMemoryManager> MemMgr)

llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

void LLVMOrcExecutionSessionSetErrorReporter(
     LLVMOrcExecutionSessionRef ES, LLVMOrcErrorReporterFunction ReportError,
     void *Ctx) {
   unwrap(ES)->setErrorReporter(
       [=](Error Err) { ReportError(Ctx, wrap(std::move(Err))); });
 }
 
 LLVMOrcSymbolStringPoolRef
 LLVMOrcExecutionSessionGetSymbolStringPool(LLVMOrcExecutionSessionRef ES) {
-  return wrap(unwrap(ES)->getSymbolStringPool().get());
+  return wrap(
+      unwrap(ES)->getTargetProcessControl().getSymbolStringPool().get());
 }
 
 void LLVMOrcSymbolStringPoolClearDeadEntries(LLVMOrcSymbolStringPoolRef SSP) {
   unwrap(SSP)->clearDeadEntries();
 }
 
 LLVMOrcSymbolStringPoolEntryRef
 LLVMOrcExecutionSessionIntern(LLVMOrcExecutionSessionRef ES, const char *Name) {

llvm/lib/ExecutionEngine/Orc/TPCDebugObjectRegistrar.cpp

 #include "llvm/ExecutionEngine/Orc/Core.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 
 namespace llvm {
 namespace orc {
 
 Expected<std::unique_ptr<TPCDebugObjectRegistrar>>
-createJITLoaderGDBRegistrar(TargetProcessControl &TPC) {
+createJITLoaderGDBRegistrar(ExecutionSession &ES) {
+  auto &TPC = ES.getTargetProcessControl();
   auto ProcessHandle = TPC.loadDylib(nullptr);
   if (!ProcessHandle)
     return ProcessHandle.takeError();
 
   SymbolStringPtr RegisterFn =
       TPC.getTargetTriple().isOSBinFormatMachO()
           ? TPC.intern("_llvm_orc_registerJITLoaderGDBWrapper")
           : TPC.intern("llvm_orc_registerJITLoaderGDBWrapper");
 
   SymbolLookupSet RegistrationSymbols;
   RegistrationSymbols.add(RegisterFn);
 
   auto Result = TPC.lookupSymbols({{*ProcessHandle, RegistrationSymbols}});
   if (!Result)
     return Result.takeError();
 
   assert(Result->size() == 1 && "Unexpected number of dylibs in result");
   assert((*Result)[0].size() == 1 &&
          "Unexpected number of addresses in result");
 
-  return std::make_unique<TPCDebugObjectRegistrar>(TPC, (*Result)[0][0]);
+  return std::make_unique<TPCDebugObjectRegistrar>(ES, (*Result)[0][0]);
+}
+
+Error TPCDebugObjectRegistrar::registerDebugObject(sys::MemoryBlock TargetMem) {
+  return WrapperFunction<void(SPSTargetAddress, uint64_t)>::call(
+      TPCCaller(ES.getTargetProcessControl(), RegisterFn),
+      pointerToJITTargetAddress(TargetMem.base()),
+      static_cast<uint64_t>(TargetMem.allocatedSize()));
 }
 
 } // namespace orc
 } // namespace llvm

llvm/lib/ExecutionEngine/Orc/TPCDynamicLibrarySearchGenerator.cpp

 //===---------------- TPCDynamicLibrarySearchGenerator.cpp ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Orc/TPCDynamicLibrarySearchGenerator.h"
 
 namespace llvm {
 namespace orc {
 
 Expected<std::unique_ptr<TPCDynamicLibrarySearchGenerator>>
-TPCDynamicLibrarySearchGenerator::Load(TargetProcessControl &TPC,
+TPCDynamicLibrarySearchGenerator::Load(ExecutionSession &ES,
                                        const char *LibraryPath,
                                        SymbolPredicate Allow) {
-  auto Handle = TPC.loadDylib(LibraryPath);
+  auto Handle = ES.getTargetProcessControl().loadDylib(LibraryPath);
   if (!Handle)
     return Handle.takeError();
 
-  return std::make_unique<TPCDynamicLibrarySearchGenerator>(TPC, *Handle,
+  return std::make_unique<TPCDynamicLibrarySearchGenerator>(ES, *Handle,
                                                             std::move(Allow));
 }
 
 Error TPCDynamicLibrarySearchGenerator::tryToGenerate(
     LookupState &LS, LookupKind K, JITDylib &JD,
     JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) {
 
   if (Symbols.empty())

llvm/lib/ExecutionEngine/Orc/TPCEHFrameRegistrar.cpp

 //===------ TPCEHFrameRegistrar.cpp - TPC-based eh-frame registration -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h"
+
+#include "llvm/ExecutionEngine/Orc/Core.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 
 using namespace llvm::orc::shared;
 
 namespace llvm {
 namespace orc {
 
 Expected<std::unique_ptr<TPCEHFrameRegistrar>>
-TPCEHFrameRegistrar::Create(TargetProcessControl &TPC) {
+TPCEHFrameRegistrar::Create(ExecutionSession &ES) {
   // FIXME: Proper mangling here -- we really need to decouple linker mangling
   // from DataLayout.
 
   // Find the addresses of the registration/deregistration functions in the
   // target process.
+  auto &TPC = ES.getTargetProcessControl();
+
   auto ProcessHandle = TPC.loadDylib(nullptr);
   if (!ProcessHandle)
     return ProcessHandle.takeError();
 
   std::string RegisterWrapperName, DeregisterWrapperName;
   if (TPC.getTargetTriple().isOSBinFormatMachO()) {
     RegisterWrapperName += '_';
     DeregisterWrapperName += '_';
TPCEHFrameRegistrar::Create(ExecutionSession &ES) {
 
   assert(Result->size() == 1 && "Unexpected number of dylibs in result");
   assert((*Result)[0].size() == 2 &&
          "Unexpected number of addresses in result");
 
   auto RegisterEHFrameWrapperFnAddr = (*Result)[0][0];
   auto DeregisterEHFrameWrapperFnAddr = (*Result)[0][1];
 
-  return std::make_unique<TPCEHFrameRegistrar>(
-      TPC, RegisterEHFrameWrapperFnAddr, DeregisterEHFrameWrapperFnAddr);
+  return std::make_unique<TPCEHFrameRegistrar>(ES, RegisterEHFrameWrapperFnAddr,
+                                               DeregisterEHFrameWrapperFnAddr);
 }
 
 Error TPCEHFrameRegistrar::registerEHFrames(JITTargetAddress EHFrameSectionAddr,
                                             size_t EHFrameSectionSize) {
 
   return WrapperFunction<void(SPSTargetAddress, uint64_t)>::call(
-      TPCCaller(TPC, RegisterEHFrameWrapperFnAddr), EHFrameSectionAddr,
-      static_cast<uint64_t>(EHFrameSectionSize));
+      TPCCaller(ES.getTargetProcessControl(), RegisterEHFrameWrapperFnAddr),
+      EHFrameSectionAddr, static_cast<uint64_t>(EHFrameSectionSize));
 }
 
 Error TPCEHFrameRegistrar::deregisterEHFrames(
     JITTargetAddress EHFrameSectionAddr, size_t EHFrameSectionSize) {
   return WrapperFunction<void(SPSTargetAddress, uint64_t)>::call(
-      TPCCaller(TPC, DeregisterEHFrameWrapperFnAddr), EHFrameSectionAddr,
-      static_cast<uint64_t>(EHFrameSectionSize));
+      TPCCaller(ES.getTargetProcessControl(), DeregisterEHFrameWrapperFnAddr),
+      EHFrameSectionAddr, static_cast<uint64_t>(EHFrameSectionSize));
 }
 
 } // end namespace orc
 } // end namespace llvm

llvm/lib/ExecutionEngine/Orc/TargetProcessControl.cpp

SelfTargetProcessControl::SelfTargetProcessControl(
   if (this->TargetTriple.isOSBinFormatMachO())
     GlobalManglingPrefix = '_';
 }
 
 Expected<std::unique_ptr<SelfTargetProcessControl>>
 SelfTargetProcessControl::Create(
     std::shared_ptr<SymbolStringPool> SSP,
     std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr) {
+
+  if (!SSP)
+    SSP = std::make_shared<SymbolStringPool>();
+
   auto PageSize = sys::Process::getPageSize();
   if (!PageSize)
     return PageSize.takeError();
 
   Triple TT(sys::getProcessTriple());
 
   return std::make_unique<SelfTargetProcessControl>(
       std::move(SSP), std::move(TT), *PageSize, std::move(MemMgr));

llvm/tools/lli/lli.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/CodeGen/LinkAllCodegenComponents.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/ExecutionEngine/GenericValue.h"
 #include "llvm/ExecutionEngine/Interpreter.h"
-#include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/JITEventListener.h"
+#include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/MCJIT.h"
 #include "llvm/ExecutionEngine/ObjectCache.h"
 #include "llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h"
 #include "llvm/ExecutionEngine/Orc/DebugUtils.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
 #include "llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
 #include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
 #include "llvm/ExecutionEngine/Orc/TPCDebugObjectRegistrar.h"
 #include "llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Object/Archive.h"
if (!RemoteMCJIT) {
     // Lanch the remote process and get a channel to it.
     std::unique_ptr<orc::shared::FDRawByteChannel> C = launchRemote();
     if (!C) {
       WithColor::error(errs(), argv[0]) << "failed to launch remote JIT.\n";
       exit(1);
     }
 
     // Create a remote target client running over the channel.
-    llvm::orc::ExecutionSession ES;
+    llvm::orc::ExecutionSession ES(
+        std::make_unique<orc::UnsupportedTargetProcessControl>());
     ES.setErrorReporter([&](Error Err) { ExitOnErr(std::move(Err)); });
     typedef orc::remote::OrcRemoteTargetClient MyRemote;
     auto R = ExitOnErr(MyRemote::Create(*C, ES));
 
     // Create a remote memory manager.
     auto RemoteMM = ExitOnErr(R->createRemoteMemoryManager());
 
     // Forward MCJIT's memory manager calls to the remote memory manager.
Builder.getJITTargetMachineBuilder()
       .addFeatures(codegen::getFeatureList())
       .setRelocationModel(codegen::getExplicitRelocModel())
       .setCodeModel(codegen::getExplicitCodeModel());
 
   // FIXME: Setting a dummy call-through manager in non-lazy mode prevents the
   // JIT builder to instantiate a default (which would fail with an error for
   // unsupported architectures).
   if (UseJITKind != JITKind::OrcLazy) {
-    auto ES = std::make_unique<orc::ExecutionSession>();
+    auto TPC = ExitOnErr(orc::SelfTargetProcessControl::Create());
+    auto ES = std::make_unique<orc::ExecutionSession>(std::move(TPC));
     Builder.setLazyCallthroughManager(
         std::make_unique<orc::LazyCallThroughManager>(*ES, 0, nullptr));
     Builder.setExecutionSession(std::move(ES));
   }
 
   Builder.setLazyCompileFailureAddr(
       pointerToJITTargetAddress(exitOnLazyCallThroughFailure));
   Builder.setNumCompileThreads(LazyJITCompileThreads);
// Set up LLJIT platform.
     case LLJITPlatform::Inactive:
       Builder.setPlatformSetUp(orc::setUpInactivePlatform);
       break;
     default:
       llvm_unreachable("Unrecognized platform value");
     }
   }
 
-  std::unique_ptr<orc::TargetProcessControl> TPC = nullptr;
   if (JITLinker == JITLinkerKind::JITLink) {
-    TPC = ExitOnErr(orc::SelfTargetProcessControl::Create(
-        std::make_shared<orc::SymbolStringPool>()));
-
-    Builder.setObjectLinkingLayerCreator([&TPC](orc::ExecutionSession &ES,
-                                                const Triple &) {
-      auto L = std::make_unique<orc::ObjectLinkingLayer>(ES, TPC->getMemMgr());
+    Builder.setObjectLinkingLayerCreator(
+        [](orc::ExecutionSession &ES, const Triple &) {
+          auto L = std::make_unique<orc::ObjectLinkingLayer>(ES);
           L->addPlugin(std::make_unique<orc::EHFrameRegistrationPlugin>(
-          ES, ExitOnErr(orc::TPCEHFrameRegistrar::Create(*TPC))));
+              ES, ExitOnErr(orc::TPCEHFrameRegistrar::Create(ES))));
           L->addPlugin(std::make_unique<orc::DebugObjectManagerPlugin>(
-          ES, ExitOnErr(orc::createJITLoaderGDBRegistrar(*TPC))));
+              ES, ExitOnErr(orc::createJITLoaderGDBRegistrar(ES))));
           return L;
         });
   }
 
   auto J = ExitOnErr(Builder.create());
 
   auto *ObjLayer = &J->getObjLinkingLayer();
   if (auto *RTDyldObjLayer = dyn_cast<orc::RTDyldObjectLinkingLayer>(ObjLayer))
     RTDyldObjLayer->registerJITEventListener(
         *JITEventListener::createGDBRegistrationListener());
auto EntryPoint =
       reinterpret_cast<EntryPointPtr>(static_cast<uintptr_t>(EntryPointSym.getAddress()));
     AltEntryThreads.push_back(std::thread([EntryPoint]() { EntryPoint(); }));
   }
 
   // Resolve and run the main function.
   JITEvaluatedSymbol MainSym = ExitOnErr(J->lookup(EntryFunc));
   int Result;
 
-  if (TPC) {
+  if (JITLinker == JITLinkerKind::JITLink) {
     // TargetProcessControl-based execution with JITLink.
-    Result = ExitOnErr(TPC->runAsMain(MainSym.getAddress(), InputArgv));
+    Result =
+        ExitOnErr(J->getExecutionSession().getTargetProcessControl().runAsMain(
+            MainSym.getAddress(), InputArgv));
   } else {
     // Manual in-process execution with RuntimeDyld.
     using MainFnTy = int(int, char *[]);
     auto MainFn = jitTargetAddressToFunction<MainFnTy *>(MainSym.getAddress());
     Result = orc::runAsMain(MainFn, InputArgv, StringRef(InputFile));
   }
 
   // Wait for -entry-point threads.

llvm/tools/llvm-jitlink/llvm-jitlink.h

private:
   std::unique_ptr<LLVMJITLinkRPCEndpoint> Endpoint;
   std::unique_ptr<TargetProcessControl::MemoryAccess> OwnedMemAccess;
   std::unique_ptr<jitlink::JITLinkMemoryManager> OwnedMemMgr;
   std::atomic<bool> Finished{false};
   std::thread ListenerThread;
 };
 
 struct Session {
-  std::unique_ptr<orc::TargetProcessControl> TPC;
   orc::ExecutionSession ES;
   orc::JITDylib *MainJD;
   LLVMJITLinkObjectLinkingLayer ObjLayer;
   std::vector<orc::JITDylib *> JDSearchOrder;
 
   ~Session();
 
   static Expected<std::unique_ptr<Session>> Create(Triple TT);

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

 Session::~Session() {
   if (auto Err = ES.endSession())
     ES.reportError(std::move(Err));
 }
 
 // FIXME: Move to createJITDylib if/when we start using Platform support in
 // llvm-jitlink.
 Session::Session(std::unique_ptr<TargetProcessControl> TPC, Error &Err)
-    : TPC(std::move(TPC)), ObjLayer(*this, this->TPC->getMemMgr()) {
+    : ES(std::move(TPC)),
+      ObjLayer(*this, ES.getTargetProcessControl().getMemMgr()) {
 
   /// Local ObjectLinkingLayer::Plugin class to forward modifyPassConfig to the
   /// Session.
   class JITLinkSessionPlugin : public ObjectLinkingLayer::Plugin {
   public:
     JITLinkSessionPlugin(Session &S) : S(S) {}
     void modifyPassConfig(MaterializationResponsibility &MR, LinkGraph &G,
                           PassConfiguration &PassConfig) override {
Session::Session(std::unique_ptr<TargetProcessControl> TPC, Error &Err)
 
   if (auto MainJDOrErr = ES.createJITDylib("main"))
     MainJD = &*MainJDOrErr;
   else {
     Err = MainJDOrErr.takeError();
     return;
   }
 
-  if (!NoExec && !this->TPC->getTargetTriple().isOSWindows()) {
+  if (!NoExec &&
+      !ES.getTargetProcessControl().getTargetTriple().isOSWindows()) {
     ObjLayer.addPlugin(std::make_unique<EHFrameRegistrationPlugin>(
-        ES, ExitOnErr(TPCEHFrameRegistrar::Create(*this->TPC))));
+        ES, ExitOnErr(TPCEHFrameRegistrar::Create(this->ES))));
     ObjLayer.addPlugin(std::make_unique<DebugObjectManagerPlugin>(
-        ES, ExitOnErr(createJITLoaderGDBRegistrar(*this->TPC))));
+        ES, ExitOnErr(createJITLoaderGDBRegistrar(this->ES))));
   }
 
   ObjLayer.addPlugin(std::make_unique<JITLinkSessionPlugin>(*this));
 
   // Process any harness files.
   for (auto &HarnessFile : TestHarnesses) {
     HarnessFiles.insert(HarnessFile);
 

 void Session::dumpSessionInfo(raw_ostream &OS) {
   OS << "Registered addresses:\n" << SymbolInfos << FileInfos;
 }
 
 void Session::modifyPassConfig(const Triple &TT,
                                PassConfiguration &PassConfig) {
   if (!CheckFiles.empty())
     PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) {
-      if (TPC->getTargetTriple().getObjectFormat() == Triple::ELF)
+      auto &TPC = ES.getTargetProcessControl();
+      if (TPC.getTargetTriple().getObjectFormat() == Triple::ELF)
         return registerELFGraphInfo(*this, G);
 
-      if (TPC->getTargetTriple().getObjectFormat() == Triple::MachO)
+      if (TPC.getTargetTriple().getObjectFormat() == Triple::MachO)
         return registerMachOGraphInfo(*this, G);
 
       return make_error<StringError>("Unsupported object format for GOT/stub "
                                      "registration",
                                      inconvertibleErrorCode());
     });
 
   if (ShowLinkGraph)

 
 static Error loadProcessSymbols(Session &S) {
   auto FilterMainEntryPoint =
       [EPName = S.ES.intern(EntryPointName)](SymbolStringPtr Name) {
         return Name != EPName;
       };
   S.MainJD->addGenerator(
       ExitOnErr(orc::TPCDynamicLibrarySearchGenerator::GetForTargetProcess(
-          *S.TPC, std::move(FilterMainEntryPoint))));
+          S.ES, std::move(FilterMainEntryPoint))));
 
   return Error::success();
 }
 
 static Error loadDylibs(Session &S) {
   for (const auto &Dylib : Dylibs) {
-    auto G = orc::TPCDynamicLibrarySearchGenerator::Load(*S.TPC, Dylib.c_str());
+    auto G = orc::TPCDynamicLibrarySearchGenerator::Load(S.ES, Dylib.c_str());
     if (!G)
       return G.takeError();
     S.MainJD->addGenerator(std::move(*G));
   }
 
   return Error::success();
 }
 
LLVM_DEBUG(dbgs() << "  " << InputFileArgIdx << ": \"" << InputFile
                       << "\" to " << JD.getName() << "\n";);
     auto ObjBuffer =
         ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(InputFile)));
 
     auto Magic = identify_magic(ObjBuffer->getBuffer());
     if (Magic == file_magic::archive ||
         Magic == file_magic::macho_universal_binary)
       JD.addGenerator(ExitOnErr(StaticLibraryDefinitionGenerator::Load(
-          S.ObjLayer, InputFile.c_str(), S.TPC->getTargetTriple())));
+          S.ObjLayer, InputFile.c_str(),
+          S.ES.getTargetProcessControl().getTargetTriple())));
     else
       ExitOnErr(S.ObjLayer.add(JD, std::move(ObjBuffer)));
   }
 
   // Define absolute symbols.
   LLVM_DEBUG(dbgs() << "Defining absolute symbols...\n");
   for (auto AbsDefItr = AbsoluteDefs.begin(), AbsDefEnd = AbsoluteDefs.end();
        AbsDefItr != AbsDefEnd; ++AbsDefItr) {
for (auto *JD : S.JDSearchOrder)
       dbgs() << JD->getName() << " ";
     dbgs() << "]\n";
   });
 
   return Error::success();
 }
 
 static Error runChecks(Session &S) {
+  auto &TPC = S.ES.getTargetProcessControl();
 
-  auto TripleName = S.TPC->getTargetTriple().str();
+  auto TripleName = TPC.getTargetTriple().str();
   std::string ErrorStr;
   const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, ErrorStr);
   if (!TheTarget)
     ExitOnErr(make_error<StringError>("Error accessing target '" + TripleName +
                                           "': " + ErrorStr,
                                       inconvertibleErrorCode()));
 
   std::unique_ptr<MCSubtargetInfo> STI(
static Error runChecks(Session &S) {
   };
 
   auto GetGOTInfo = [&S](StringRef FileName, StringRef SectionName) {
     return S.findGOTEntryInfo(FileName, SectionName);
   };
 
   RuntimeDyldChecker Checker(
       IsSymbolValid, GetSymbolInfo, GetSectionInfo, GetStubInfo, GetGOTInfo,
-      S.TPC->getTargetTriple().isLittleEndian() ? support::little
-                                                : support::big,
+      TPC.getTargetTriple().isLittleEndian() ? support::little : support::big,
       Disassembler.get(), InstPrinter.get(), dbgs());
 
   std::string CheckLineStart = "# " + CheckName + ":";
   for (auto &CheckFile : CheckFiles) {
     auto CheckerFileBuf =
         ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(CheckFile)));
     if (!Checker.checkAllRulesInBuffer(CheckLineStart, &*CheckerFileBuf))
       ExitOnErr(make_error<StringError>(
int main(int argc, char *argv[]) {
   dumpSessionStats(*S);
 
   if (NoExec)
     return 0;
 
   int Result = 0;
   {
     TimeRegion TR(Timers ? &Timers->RunTimer : nullptr);
-    Result = ExitOnErr(S->TPC->runAsMain(EntryPoint.getAddress(), InputArgv));
+    auto &TPC = S->ES.getTargetProcessControl();
+    Result = ExitOnErr(TPC.runAsMain(EntryPoint.getAddress(), InputArgv));
   }
 
   ExitOnErr(S->ES.endSession());
-  ExitOnErr(S->TPC->disconnect());
+  ExitOnErr(S->ES.getTargetProcessControl().disconnect());
 
   return Result;
 }

llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp

else
       ++RHSE;
   return true;
 }
 
 TEST(JITDylibTest, GetDFSLinkOrderTree) {
   // Test that DFS ordering behaves as expected when the linkage relationships
   // form a tree.
 
-  ExecutionSession ES;
+  ExecutionSession ES{std::make_unique<UnsupportedTargetProcessControl>()};
 
   auto &LibA = ES.createBareJITDylib("A");
   auto &LibB = ES.createBareJITDylib("B");
   auto &LibC = ES.createBareJITDylib("C");
   auto &LibD = ES.createBareJITDylib("D");
   auto &LibE = ES.createBareJITDylib("E");
   auto &LibF = ES.createBareJITDylib("F");
 
EXPECT_TRUE(linkOrdersEqual(DFSOrderFromBA,
                               {&LibB, &LibD, &LibE, &LibA, &LibC, &LibF}))
       << "Incorrect DFS link order for { libB, libA }";
 }
 
 TEST(JITDylibTest, GetDFSLinkOrderDiamond) {
   // Test that DFS ordering behaves as expected when the linkage relationships
   // contain a diamond.
 
-  ExecutionSession ES;
+  ExecutionSession ES{std::make_unique<UnsupportedTargetProcessControl>()};
   auto &LibA = ES.createBareJITDylib("A");
   auto &LibB = ES.createBareJITDylib("B");
   auto &LibC = ES.createBareJITDylib("C");
   auto &LibD = ES.createBareJITDylib("D");
 
   // Linkage relationships:
   // A -- B --- D
   //  \-- C --/
   LibA.setLinkOrder(makeJITDylibSearchOrder({&LibB, &LibC}));
   LibB.setLinkOrder(makeJITDylibSearchOrder({&LibD}));
   LibC.setLinkOrder(makeJITDylibSearchOrder({&LibD}));
 
   auto DFSOrderFromA = JITDylib::getDFSLinkOrder({&LibA});
   EXPECT_TRUE(linkOrdersEqual(DFSOrderFromA, {&LibA, &LibB, &LibD, &LibC}))
       << "Incorrect DFS link order for libA";
 }
 
 TEST(JITDylibTest, GetDFSLinkOrderCycle) {
   // Test that DFS ordering behaves as expected when the linkage relationships
   // contain a cycle.
 
-  ExecutionSession ES;
+  ExecutionSession ES{std::make_unique<UnsupportedTargetProcessControl>()};
   auto &LibA = ES.createBareJITDylib("A");
   auto &LibB = ES.createBareJITDylib("B");
   auto &LibC = ES.createBareJITDylib("C");
 
   // Linkage relationships:
   // A -- B --- C -- A
   LibA.setLinkOrder(makeJITDylibSearchOrder({&LibB}));
   LibB.setLinkOrder(makeJITDylibSearchOrder({&LibC}));

llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp

 class ObjectLinkingLayerTest : public testing::Test {
 public:
   ~ObjectLinkingLayerTest() {
     if (auto Err = ES.endSession())
       ES.reportError(std::move(Err));
   }
 
 protected:
-  ExecutionSession ES;
+  ExecutionSession ES{std::make_unique<UnsupportedTargetProcessControl>()};
   JITDylib &JD = ES.createBareJITDylib("main");
   ObjectLinkingLayer ObjLinkingLayer{
       ES, std::make_unique<InProcessMemoryManager>()};
 };
 
 TEST_F(ObjectLinkingLayerTest, AddLinkGraph) {
   auto G =
       std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8,

llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h

 //===------ OrcTestCommon.h - Utilities for Orc Unit Tests ------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Common utilities for the Orc unit tests.
 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef LLVM_UNITTESTS_EXECUTIONENGINE_ORC_ORCTESTCOMMON_H
 #define LLVM_UNITTESTS_EXECUTIONENGINE_ORC_ORCTESTCOMMON_H
 
-#include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
 #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "gtest/gtest.h"

 public:
   ~CoreAPIsBasedStandardTest() {
     if (auto Err = ES.endSession())
       ES.reportError(std::move(Err));
   }
 
 protected:
   std::shared_ptr<SymbolStringPool> SSP = std::make_shared<SymbolStringPool>();
-  ExecutionSession ES{SSP};
+  ExecutionSession ES{std::make_unique<UnsupportedTargetProcessControl>(SSP)};
   JITDylib &JD = ES.createBareJITDylib("JD");
   SymbolStringPtr Foo = ES.intern("foo");
   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;

llvm/unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp

public:
     }
 
   private:
     bool &NonAllocSeen;
   };
 
   bool NonAllocSectionSeen = false;
 
-  ExecutionSession ES;
+  ExecutionSession ES(std::make_unique<UnsupportedTargetProcessControl>());
   auto &JD = ES.createBareJITDylib("main");
   auto Foo = ES.intern("foo");
 
   RTDyldObjectLinkingLayer ObjLayer(ES, [&NonAllocSectionSeen]() {
     return std::make_unique<MemoryManagerWrapper>(NonAllocSectionSeen);
   });
 
   auto OnResolveDoNothing = [](Expected<SymbolMap> R) {
BasicBlock *BarEntry =
         BasicBlock::Create(*TSCtx.getContext(), "entry", BarImpl);
     IRBuilder<> B2(BarEntry);
     B2.CreateRetVoid();
 
     M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
   }
 
   // Create a simple stack and set the override flags option.
-  ExecutionSession ES;
+  ExecutionSession ES{std::make_unique<UnsupportedTargetProcessControl>()};
   auto &JD = ES.createBareJITDylib("main");
   auto Foo = ES.intern("foo");
   RTDyldObjectLinkingLayer ObjLayer(
       ES, []() { return std::make_unique<SectionMemoryManager>(); });
   IRCompileLayer CompileLayer(ES, ObjLayer,
                               std::make_unique<FunkySimpleCompiler>(*TM));
 
   ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
BasicBlock *FooEntry =
         BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl);
     IRBuilder<> B(FooEntry);
     B.CreateRetVoid();
 
     M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
   }
 
   // Create a simple stack and set the override flags option.
-  ExecutionSession ES;
+  ExecutionSession ES{std::make_unique<UnsupportedTargetProcessControl>()};
   auto &JD = ES.createBareJITDylib("main");
   auto Foo = ES.intern("foo");
   RTDyldObjectLinkingLayer ObjLayer(
       ES, []() { return std::make_unique<SectionMemoryManager>(); });
   IRCompileLayer CompileLayer(ES, ObjLayer,
                               std::make_unique<FunkySimpleCompiler>(*TM));
 
   ObjLayer.setAutoClaimResponsibilityForObjectSymbols(true);