remote jit execution

include/CppInterOp/CppInterOp.h

@@ -609,7 +609,7 @@ CPPINTEROP_API void GetOperator(TCppScope_t scope, Operator op,
 ///\returns nullptr on failure.
 CPPINTEROP_API TInterp_t
 CreateInterpreter(const std::vector<const char*>& Args = {},
-                  const std::vector<const char*>& GpuArgs = {});
+                  const std::vector<const char*>& GpuArgs = {}, bool is_out_of_process = false);
 
 /// Deletes an instance of an interpreter.
 ///\param[in] I - the interpreter to be deleted, if nullptr, deletes the last.

lib/CppInterOp/Compatibility.h

@@ -200,10 +200,20 @@ inline void codeComplete(std::vector<std::string>& Results,
 
 #include "llvm/Support/Error.h"
 
+#include "clang/Interpreter/RemoteJITUtils.h"
+#include "clang/Basic/Version.h"
+#include "llvm/TargetParser/Host.h"
+
+#include "llvm/ExecutionEngine/Orc/Debugging/DebuggerSupport.h"
+
+#include "llvm/Support/CommandLine.h"
+
+static llvm::ExitOnError ExitOnError;
+
 namespace compat {
 
 inline std::unique_ptr<clang::Interpreter>
-createClangInterpreter(std::vector<const char*>& args) {
+createClangInterpreter(std::vector<const char*>& args, bool is_out_of_process) {
   auto has_arg = [](const char* x, llvm::StringRef match = "cuda") {
     llvm::StringRef Arg = x;
     Arg = Arg.trim().ltrim('-');
@@ -241,10 +251,31 @@ createClangInterpreter(std::vector<const char*>& args) {
   (*ciOrErr)->LoadRequestedPlugins();
   if (CudaEnabled)
     DeviceCI->LoadRequestedPlugins();
+
+  std::unique_ptr<llvm::orc::LLJITBuilder> JB;
+
+  if(is_out_of_process) {
+      std::string OOPExecutor = "/Users/abhinavkumar/Desktop/Coding/CERN_HSF_COMPILER_RESEARCH/llvm-project-test/build/bin/llvm-jitlink-executor";
+      bool UseSharedMemory = false;
+      std::string SlabAllocateSizeString = "";
+      std::unique_ptr<llvm::orc::ExecutorProcessControl> EPC;
+      EPC = ExitOnError(
+          launchExecutor(OOPExecutor, UseSharedMemory, SlabAllocateSizeString));
+
+
+      std::string OrcRuntimePath = "/Users/abhinavkumar/Desktop/Coding/CERN_HSF_COMPILER_RESEARCH/llvm-project-test/build/lib/clang/20/lib/darwin/liborc_rt_osx.a";
+      if (EPC) {
+
+        CB.SetTargetTriple(EPC->getTargetTriple().getTriple());
+        JB = ExitOnError(
+            clang::Interpreter::createLLJITBuilder(std::move(EPC), OrcRuntimePath));
+      }
+  }
+
   auto innerOrErr =
       CudaEnabled ? clang::Interpreter::createWithCUDA(std::move(*ciOrErr),
                                                        std::move(DeviceCI))
-                  : clang::Interpreter::create(std::move(*ciOrErr));
+                  : clang::Interpreter::create(std::move(*ciOrErr), std::move(JB));
 
   if (!innerOrErr) {
     llvm::logAllUnhandledErrors(innerOrErr.takeError(), llvm::errs(),

lib/CppInterOp/CppInterOp.cpp

@@ -2911,11 +2911,11 @@ static std::string MakeResourcesPath() {
 } // namespace
 
 TInterp_t CreateInterpreter(const std::vector<const char*>& Args /*={}*/,
-                            const std::vector<const char*>& GpuArgs /*={}*/) {
+                            const std::vector<const char*>& GpuArgs /*={}*/, bool is_out_of_process) {
   std::string MainExecutableName = sys::fs::getMainExecutable(nullptr, nullptr);
   std::string ResourceDir = MakeResourcesPath();
   std::vector<const char*> ClingArgv = {"-resource-dir", ResourceDir.c_str(),
-                                        "-std=c++14"};
+                                        "-std=c++14", "-gdwarf-4", "-O0"};
   ClingArgv.insert(ClingArgv.begin(), MainExecutableName.c_str());
 #ifdef _WIN32
   // FIXME : Workaround Sema::PushDeclContext assert on windows
@@ -2955,7 +2955,7 @@ TInterp_t CreateInterpreter(const std::vector<const char*>& Args /*={}*/,
   auto I = new compat::Interpreter(ClingArgv.size(), &ClingArgv[0]);
 #else
   auto Interp = compat::Interpreter::create(static_cast<int>(ClingArgv.size()),
-                                            ClingArgv.data());
+                                            ClingArgv.data(), nullptr, {}, nullptr, true, is_out_of_process);
   if (!Interp)
     return nullptr;
   auto* I = Interp.release();

lib/CppInterOp/CppInterOpInterpreter.h

@@ -150,15 +150,15 @@ class Interpreter {
   create(int argc, const char* const* argv, const char* llvmdir = nullptr,
          const std::vector<std::shared_ptr<clang::ModuleFileExtension>>&
              moduleExtensions = {},
-         void* extraLibHandle = nullptr, bool noRuntime = true) {
+         void* extraLibHandle = nullptr, bool noRuntime = true, bool is_out_of_process = false) {
     // Initialize all targets (required for device offloading)
     llvm::InitializeAllTargetInfos();
     llvm::InitializeAllTargets();
     llvm::InitializeAllTargetMCs();
     llvm::InitializeAllAsmPrinters();
 
     std::vector<const char*> vargs(argv + 1, argv + argc);
-    auto CI = compat::createClangInterpreter(vargs);
+    auto CI = compat::createClangInterpreter(vargs, is_out_of_process);
     if (!CI) {
       llvm::errs() << "Interpreter creation failed\n";
       return nullptr;