adding test for remote execution

Author: kr-2003

clang/unittests/Interpreter/InterpreterTest.cpp

@@ -18,15 +18,19 @@
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Interpreter/Interpreter.h"
+#include "clang/Interpreter/RemoteJITUtils.h"
 #include "clang/Interpreter/Value.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Sema.h"
+#include "llvm/TargetParser/Host.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 
+static const llvm::ExitOnError ExitOnError;
+
 int Global = 42;
 // JIT reports symbol not found on Windows without the visibility attribute.
 REPL_EXTERNAL_VISIBILITY int getGlobal() { return Global; }
@@ -52,6 +56,99 @@ createInterpreter(const Args &ExtraArgs = {},
   return cantFail(clang::Interpreter::create(std::move(CI)));
 }
 
+static std::string getExecutorPath() {
+  llvm::SmallString<256> ExecutorPath(llvm::sys::fs::getMainExecutable(
+      nullptr, reinterpret_cast<void *>(&getExecutorPath)));
+  llvm::sys::path::remove_filename(ExecutorPath);
+
+  llvm::sys::path::remove_filename(ExecutorPath); // Remove "Interpreter"
+  llvm::sys::path::remove_filename(ExecutorPath); // Remove "unittests"
+  llvm::sys::path::remove_filename(ExecutorPath); // Remove "clang"
+  llvm::sys::path::remove_filename(ExecutorPath); // Remove "tools"
+
+  llvm::sys::path::append(ExecutorPath, "bin", "llvm-jitlink-executor");
+  return ExecutorPath.str().str();
+}
+
+static std::string getOrcRuntimePath() {
+  llvm::SmallString<256> RuntimePath(llvm::sys::fs::getMainExecutable(
+      nullptr, reinterpret_cast<void *>(&getOrcRuntimePath)));
+
+  llvm::sys::path::remove_filename(RuntimePath);
+
+  llvm::sys::path::remove_filename(RuntimePath); // Remove "Interpreter"
+  llvm::sys::path::remove_filename(RuntimePath); // Remove "unittests"
+  llvm::sys::path::remove_filename(RuntimePath); // Remove "clang"
+  llvm::sys::path::remove_filename(RuntimePath); // Remove "tools"
+
+  llvm::sys::path::append(RuntimePath, "lib", "clang", "21", "lib");
+
+  // Add platform-specific runtime library
+  llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
+  if (SystemTriple.isOSDarwin()) {
+    llvm::sys::path::append(RuntimePath, "darwin", "liborc_rt_osx.a");
+  } else if (SystemTriple.isOSLinux()) {
+    llvm::sys::path::append(RuntimePath, "linux", "liborc_rt.a");
+  } else {
+    // Add other platforms as needed
+    llvm::sys::path::append(RuntimePath, "liborc_rt.a");
+  }
+
+  return RuntimePath.str().str();
+}
+
+static std::unique_ptr<Interpreter>
+createInterpreterWithRemoteExecution(const Args &ExtraArgs = {},
+                                     DiagnosticConsumer *Client = nullptr) {
+  Args ClangArgs = {"-Xclang", "-emit-llvm-only"};
+  llvm::append_range(ClangArgs, ExtraArgs);
+  auto CB = clang::IncrementalCompilerBuilder();
+  CB.SetCompilerArgs(ClangArgs);
+  auto CI = cantFail(CB.CreateCpp());
+  if (Client)
+    CI->getDiagnostics().setClient(Client, /*ShouldOwnClient=*/false);
+
+  std::unique_ptr<llvm::orc::LLJITBuilder> JB;
+
+  llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
+
+  std::cout << "System Triple: " << SystemTriple.getTriple() << "\n";
+  std::cout << "Executor Path: " << getExecutorPath() << "\n";
+
+  if ((SystemTriple.isOSBinFormatELF() || SystemTriple.isOSBinFormatMachO())) {
+    std::string OOPExecutor = getExecutorPath();
+    bool UseSharedMemory = false;
+    std::string SlabAllocateSizeString = "";
+    std::unique_ptr<llvm::orc::ExecutorProcessControl> EPC;
+    EPC = ExitOnError(launchExecutor(OOPExecutor, UseSharedMemory,
+                                     SlabAllocateSizeString,
+                                     [=] { // Lambda defined inline
+                                       auto redirect = [](int from, int to) {
+                                         if (from != to) {
+                                           dup2(from, to);
+                                           close(from);
+                                         }
+                                       };
+
+                                       redirect(0, STDIN_FILENO);
+                                       redirect(1, STDOUT_FILENO);
+                                       redirect(2, STDERR_FILENO);
+
+                                       setvbuf(stdout, nullptr, _IONBF, 0);
+                                       setvbuf(stderr, nullptr, _IONBF, 0);
+                                     }));
+    std::string OrcRuntimePath = getOrcRuntimePath();
+
+    if (EPC) {
+      CB.SetTargetTriple(EPC->getTargetTriple().getTriple());
+      JB = ExitOnError(clang::Interpreter::createLLJITBuilder(std::move(EPC),
+                                                              OrcRuntimePath));
+    }
+  }
+
+  return cantFail(clang::Interpreter::create(std::move(CI), std::move(JB)));
+}
+
 static size_t DeclsSize(TranslationUnitDecl *PTUDecl) {
   return std::distance(PTUDecl->decls().begin(), PTUDecl->decls().end());
 }
@@ -68,6 +165,18 @@ TEST_F(InterpreterTest, Sanity) {
   EXPECT_EQ(1U, DeclsSize(R2.TUPart));
 }
 
+TEST_F(InterpreterTest, SanityWithRemoteExecution) {
+  std::unique_ptr<Interpreter> Interp = createInterpreterWithRemoteExecution();
+
+  using PTU = PartialTranslationUnit;
+
+  PTU &R1(cantFail(Interp->Parse("void g(); void g() {}")));
+  EXPECT_EQ(2U, DeclsSize(R1.TUPart));
+
+  PTU &R2(cantFail(Interp->Parse("int i;")));
+  EXPECT_EQ(1U, DeclsSize(R2.TUPart));
+}
+
 static std::string DeclToString(Decl *D) {
   return llvm::cast<NamedDecl>(D)->getQualifiedNameAsString();
 }