[ORC] Extract MemoryAccess from ExecutorProcessControl, break up header. (llvm#145671)

This moves the MemoryAccess interface out of the ExecutorProcessControl
class and splits implementation classes InProcessMemoryManager and
SelfExecutorProcessControl out of ExecutorProcessControl.h and into
their own headers.

Author: lhames

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

@@ -21,6 +21,7 @@
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/SelfExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/DataLayout.h"

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

@@ -22,6 +22,7 @@
 #include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/SelfExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/DataLayout.h"

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

@@ -25,6 +25,7 @@
 #include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/SelfExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/DataLayout.h"

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

@@ -24,6 +24,7 @@
 #include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/SelfExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/DataLayout.h"

llvm/examples/Kaleidoscope/include/KaleidoscopeJIT.h

@@ -22,6 +22,7 @@
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/SelfExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/DataLayout.h"

llvm/examples/OrcV2Examples/LLJITWithExecutorProcessControl/LLJITWithExecutorProcessControl.cpp

@@ -27,6 +27,7 @@
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 #include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
+#include "llvm/ExecutionEngine/Orc/SelfExecutorProcessControl.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"

llvm/include/llvm/ExecutionEngine/Orc/EPCGenericMemoryAccess.h

@@ -23,7 +23,7 @@
 namespace llvm {
 namespace orc {
 
-class EPCGenericMemoryAccess : public ExecutorProcessControl::MemoryAccess {
+class EPCGenericMemoryAccess : public MemoryAccess {
 public:
   /// Function addresses for memory access.
   struct FuncAddrs {

llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h

@@ -16,22 +16,21 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/DylibManager.h"
+#include "llvm/ExecutionEngine/Orc/MemoryAccess.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 #include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
 #include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
 #include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/UnwindInfoManager.h"
 #include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/MSVCErrorWorkarounds.h"
 #include "llvm/TargetParser/Triple.h"
 
 #include <future>
 #include <mutex>
 #include <vector>
 
-namespace llvm {
-namespace orc {
+namespace llvm::orc {
 
 class ExecutionSession;
 
@@ -98,81 +97,6 @@ class LLVM_ABI ExecutorProcessControl {
     TaskDispatcher &D;
   };
 
-  /// APIs for manipulating memory in the target process.
-  class LLVM_ABI MemoryAccess {
-  public:
-    /// Callback function for asynchronous writes.
-    using WriteResultFn = unique_function<void(Error)>;
-
-    virtual ~MemoryAccess();
-
-    virtual void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
-                                  WriteResultFn OnWriteComplete) = 0;
-
-    virtual void writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws,
-                                   WriteResultFn OnWriteComplete) = 0;
-
-    virtual void writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws,
-                                   WriteResultFn OnWriteComplete) = 0;
-
-    virtual void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
-                                   WriteResultFn OnWriteComplete) = 0;
-
-    virtual void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
-                                   WriteResultFn OnWriteComplete) = 0;
-
-    virtual void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
-                                    WriteResultFn OnWriteComplete) = 0;
-
-    Error writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws) {
-      std::promise<MSVCPError> ResultP;
-      auto ResultF = ResultP.get_future();
-      writeUInt8sAsync(Ws,
-                       [&](Error Err) { ResultP.set_value(std::move(Err)); });
-      return ResultF.get();
-    }
-
-    Error writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws) {
-      std::promise<MSVCPError> ResultP;
-      auto ResultF = ResultP.get_future();
-      writeUInt16sAsync(Ws,
-                        [&](Error Err) { ResultP.set_value(std::move(Err)); });
-      return ResultF.get();
-    }
-
-    Error writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws) {
-      std::promise<MSVCPError> ResultP;
-      auto ResultF = ResultP.get_future();
-      writeUInt32sAsync(Ws,
-                        [&](Error Err) { ResultP.set_value(std::move(Err)); });
-      return ResultF.get();
-    }
-
-    Error writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws) {
-      std::promise<MSVCPError> ResultP;
-      auto ResultF = ResultP.get_future();
-      writeUInt64sAsync(Ws,
-                        [&](Error Err) { ResultP.set_value(std::move(Err)); });
-      return ResultF.get();
-    }
-
-    Error writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws) {
-      std::promise<MSVCPError> ResultP;
-      auto ResultF = ResultP.get_future();
-      writeBuffersAsync(Ws,
-                        [&](Error Err) { ResultP.set_value(std::move(Err)); });
-      return ResultF.get();
-    }
-
-    Error writePointers(ArrayRef<tpctypes::PointerWrite> Ws) {
-      std::promise<MSVCPError> ResultP;
-      auto ResultF = ResultP.get_future();
-      writePointersAsync(Ws,
-                         [&](Error Err) { ResultP.set_value(std::move(Err)); });
-      return ResultF.get();
-    }
-  };
-
   /// Contains the address of the dispatch function and context that the ORC
   /// runtime can use to call functions in the JIT.
   struct JITDispatchInfo {
@@ -398,83 +322,6 @@ class LLVM_ABI ExecutorProcessControl {
   StringMap<ExecutorAddr> BootstrapSymbols;
 };
 
-class LLVM_ABI InProcessMemoryAccess
-    : public ExecutorProcessControl::MemoryAccess {
-public:
-  InProcessMemoryAccess(bool IsArch64Bit) : IsArch64Bit(IsArch64Bit) {}
-  void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
-                        WriteResultFn OnWriteComplete) override;
-
-  void writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws,
-                         WriteResultFn OnWriteComplete) override;
-
-  void writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws,
-                         WriteResultFn OnWriteComplete) override;
-
-  void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
-                         WriteResultFn OnWriteComplete) override;
-
-  void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
-                         WriteResultFn OnWriteComplete) override;
-
-  void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
-                          WriteResultFn OnWriteComplete) override;
-
-private:
-  bool IsArch64Bit;
-};
-
-/// A ExecutorProcessControl implementation targeting the current process.
-class LLVM_ABI SelfExecutorProcessControl : public ExecutorProcessControl,
-                                            private InProcessMemoryAccess,
-                                            private DylibManager {
-public:
-  SelfExecutorProcessControl(
-      std::shared_ptr<SymbolStringPool> SSP, std::unique_ptr<TaskDispatcher> D,
-      Triple TargetTriple, unsigned PageSize,
-      std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr);
-
-  /// Create a SelfExecutorProcessControl 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 created and used by default.
-  static Expected<std::unique_ptr<SelfExecutorProcessControl>>
-  Create(std::shared_ptr<SymbolStringPool> SSP = nullptr,
-         std::unique_ptr<TaskDispatcher> D = nullptr,
-         std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr = nullptr);
-
-  Expected<int32_t> runAsMain(ExecutorAddr MainFnAddr,
-                              ArrayRef<std::string> Args) override;
-
-  Expected<int32_t> runAsVoidFunction(ExecutorAddr VoidFnAddr) override;
-
-  Expected<int32_t> runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) override;
-
-  void callWrapperAsync(ExecutorAddr WrapperFnAddr,
-                        IncomingWFRHandler OnComplete,
-                        ArrayRef<char> ArgBuffer) override;
-
-  Error disconnect() override;
-
-private:
-  static shared::CWrapperFunctionResult
-  jitDispatchViaWrapperFunctionManager(void *Ctx, const void *FnTag,
-                                       const char *Data, size_t Size);
-
-  Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override;
-
-  void lookupSymbolsAsync(ArrayRef<LookupRequest> Request,
-                          SymbolLookupCompleteFn F) override;
-
-  std::unique_ptr<jitlink::JITLinkMemoryManager> OwnedMemMgr;
-#ifdef __APPLE__
-  std::unique_ptr<UnwindInfoManager> UnwindInfoMgr;
-#endif // __APPLE__
-  char GlobalManglingPrefix = 0;
-};
-
-} // end namespace orc
-} // end namespace llvm
+} // namespace llvm::orc
 
 #endif // LLVM_EXECUTIONENGINE_ORC_EXECUTORPROCESSCONTROL_H

llvm/include/llvm/ExecutionEngine/Orc/InProcessMemoryAccess.h

@@ -0,0 +1,47 @@
+//===-- InProcessMemoryAccess.h - Direct, in-process mem access -*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Accesses memory in the current process.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_INPROCESSMEMORYACCESS_H
+#define LLVM_EXECUTIONENGINE_ORC_INPROCESSMEMORYACCESS_H
+
+#include "llvm/ExecutionEngine/Orc/MemoryAccess.h"
+
+namespace llvm::orc {
+
+class LLVM_ABI InProcessMemoryAccess : public MemoryAccess {
+public:
+  InProcessMemoryAccess(bool IsArch64Bit) : IsArch64Bit(IsArch64Bit) {}
+  void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
+                        WriteResultFn OnWriteComplete) override;
+
+  void writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws,
+                         WriteResultFn OnWriteComplete) override;
+
+  void writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws,
+                         WriteResultFn OnWriteComplete) override;
+
+  void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
+                         WriteResultFn OnWriteComplete) override;
+
+  void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
+                         WriteResultFn OnWriteComplete) override;
+
+  void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
+                          WriteResultFn OnWriteComplete) override;
+
+private:
+  bool IsArch64Bit;
+};
+
+} // namespace llvm::orc
+
+#endif // LLVM_EXECUTIONENGINE_ORC_INPROCESSMEMORYACCESS_H

llvm/include/llvm/ExecutionEngine/Orc/MemoryAccess.h

@@ -0,0 +1,101 @@
+//===------- MemoryAccess.h - Executor memory access APIs -------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for accessing memory in the executor processes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_MEMORYACCESS_H
+#define LLVM_EXECUTIONENGINE_ORC_MEMORYACCESS_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
+#include "llvm/Support/MSVCErrorWorkarounds.h"
+
+#include <future>
+
+namespace llvm::orc {
+
+/// APIs for manipulating memory in the target process.
+class LLVM_ABI MemoryAccess {
+public:
+  /// Callback function for asynchronous writes.
+  using WriteResultFn = unique_function<void(Error)>;
+
+  virtual ~MemoryAccess();
+
+  virtual void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
+                                WriteResultFn OnWriteComplete) = 0;
+
+  virtual void writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws,
+                                 WriteResultFn OnWriteComplete) = 0;
+
+  virtual void writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws,
+                                 WriteResultFn OnWriteComplete) = 0;
+
+  virtual void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
+                                 WriteResultFn OnWriteComplete) = 0;
+
+  virtual void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
+                                 WriteResultFn OnWriteComplete) = 0;
+
+  virtual void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
+                                  WriteResultFn OnWriteComplete) = 0;
+
+  Error writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws) {
+    std::promise<MSVCPError> ResultP;
+    auto ResultF = ResultP.get_future();
+    writeUInt8sAsync(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
+    return ResultF.get();
+  }
+
+  Error writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws) {
+    std::promise<MSVCPError> ResultP;
+    auto ResultF = ResultP.get_future();
+    writeUInt16sAsync(Ws,
+                      [&](Error Err) { ResultP.set_value(std::move(Err)); });
+    return ResultF.get();
+  }
+
+  Error writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws) {
+    std::promise<MSVCPError> ResultP;
+    auto ResultF = ResultP.get_future();
+    writeUInt32sAsync(Ws,
+                      [&](Error Err) { ResultP.set_value(std::move(Err)); });
+    return ResultF.get();
+  }
+
+  Error writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws) {
+    std::promise<MSVCPError> ResultP;
+    auto ResultF = ResultP.get_future();
+    writeUInt64sAsync(Ws,
+                      [&](Error Err) { ResultP.set_value(std::move(Err)); });
+    return ResultF.get();
+  }
+
+  Error writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws) {
+    std::promise<MSVCPError> ResultP;
+    auto ResultF = ResultP.get_future();
+    writeBuffersAsync(Ws,
+                      [&](Error Err) { ResultP.set_value(std::move(Err)); });
+    return ResultF.get();
+  }
+
+  Error writePointers(ArrayRef<tpctypes::PointerWrite> Ws) {
+    std::promise<MSVCPError> ResultP;
+    auto ResultF = ResultP.get_future();
+    writePointersAsync(Ws,
+                       [&](Error Err) { ResultP.set_value(std::move(Err)); });
+    return ResultF.get();
+  }
+};
+
+} // namespace llvm::orc
+
+#endif // LLVM_EXECUTIONENGINE_ORC_MEMORYACCESS_H