[clang-repl] Support orc runtime and use it to enhance support of x86_64-windows-msvc target.

[sunho]

Summary

Support orc runtime and use it to enhance support of x86_64-windows-msvc target.

[v.g.vassilev]

clang/tools/clang-repl/ClangRepl.cpp

119

Do we want to sink this in clang::Interpreter::create. This way other users would just use it straight out of the box? Maybe we can add a default argument useOrcRuntimeIfSupported = true in case things are not yet very stable.

[glevner]

clang/lib/Interpreter/IncrementalExecutor.cpp

63–72

This code will never be executed. Or am I missing something?

[sgraenitz]

clang/lib/Interpreter/IncrementalExecutor.cpp

63–72

That's definitely a non-obvious one. The lambda ends up in the builder states' CreateObjectLinkingLayer member and gets called from LLJIT: https://github.com/llvm/llvm-project/blob/release/15.x/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp#L736

What's interesting is the EPC capture: In fact, it's a pointer so we wouldn't want the &. However, instead of capturing EPC, it might be easier to just obtain it inside the lambda via ES->getExecutorProcessControl().

clang/include/clang/Interpreter/Interpreter.h

public:
   create(std::vector<const char *> &ClangArgv);
 };
 
 /// Provides top-level interfaces for incremental compilation and execution.
 class Interpreter {
   std::unique_ptr<llvm::orc::ThreadSafeContext> TSCtx;
   std::unique_ptr<IncrementalParser> IncrParser;
   std::unique_ptr<IncrementalExecutor> IncrExecutor;
+  std::string OrcRuntimePath;
 
-  Interpreter(std::unique_ptr<CompilerInstance> CI, llvm::Error &Err);
+  Interpreter(std::unique_ptr<CompilerInstance> CI,
+              const std::string &OrcRuntimePath, llvm::Error &Err);
 
 public:
   ~Interpreter();
   static llvm::Expected<std::unique_ptr<Interpreter>>
-  create(std::unique_ptr<CompilerInstance> CI);
+  create(std::unique_ptr<CompilerInstance> CI,
+         const std::string &OrcRuntimePath = "");
+  static std::string
+  findOrcRuntimePath(const std::vector<const char *> &ClangArgv);
   const CompilerInstance *getCompilerInstance() const;
   const llvm::orc::LLJIT *getExecutionEngine() const;
   llvm::Expected<PartialTranslationUnit &> Parse(llvm::StringRef Code);
   llvm::Error Execute(PartialTranslationUnit &T);
   llvm::Error ParseAndExecute(llvm::StringRef Code) {
     auto PTU = Parse(Code);
     if (!PTU)
       return PTU.takeError();

clang/lib/Interpreter/IncrementalExecutor.h

class IncrementalExecutor {
 
   llvm::DenseMap<const PartialTranslationUnit *, llvm::orc::ResourceTrackerSP>
       ResourceTrackers;
 
 public:
   enum SymbolNameKind { IRName, LinkerName };
 
   IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC, llvm::Error &Err,
+                      const std::string &OrcRuntimePath,
                       const clang::TargetInfo &TI);
   ~IncrementalExecutor();
 
   llvm::Error addModule(PartialTranslationUnit &PTU);
   llvm::Error removeModule(PartialTranslationUnit &PTU);
   llvm::Error runCtors() const;
   llvm::Error cleanUp();
   llvm::Expected<llvm::JITTargetAddress>
   getSymbolAddress(llvm::StringRef Name, SymbolNameKind NameKind) const;
   llvm::orc::LLJIT *getExecutionEngine() const { return Jit.get(); }
 };
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_INTERPRETER_INCREMENTALEXECUTOR_H

clang/lib/Interpreter/IncrementalExecutor.cpp

 
 #include "IncrementalExecutor.h"
 
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
 #include "clang/Interpreter/PartialTranslationUnit.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
+#include "llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h"
+#include "llvm/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.h"
+#include "llvm/ExecutionEngine/Orc/EPCEHFrameRegistrar.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/TargetSelect.h"
 
 namespace clang {
 
 IncrementalExecutor::IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC,
                                          llvm::Error &Err,
+                                         const std::string &OrcRuntimePath,
                                          const clang::TargetInfo &TI)
     : TSCtx(TSC) {
   using namespace llvm::orc;
   llvm::ErrorAsOutParameter EAO(&Err);
 
   auto JTMB = JITTargetMachineBuilder(TI.getTriple());
   JTMB.addFeatures(TI.getTargetOpts().Features);
-  if (auto JitOrErr = LLJITBuilder().setJITTargetMachineBuilder(JTMB).create())
+  auto Builder = LLJITBuilder();
+  Builder.setJITTargetMachineBuilder(JTMB);
+
+  llvm::orc::ExecutorProcessControl *EPC = nullptr;
+  if (!OrcRuntimePath.empty()) {
+    auto EPCOrErr = llvm::orc::SelfExecutorProcessControl::Create(
+        std::make_shared<llvm::orc::SymbolStringPool>());
+    if (!EPCOrErr) {
+      Err = EPCOrErr.takeError();
+      return;
+    }
+    EPC = &**EPCOrErr;
+    Builder.setObjectLinkingLayerCreator(
+        [&EPC, OrcRuntimePath](llvm::orc::ExecutionSession &ES,
+                               const llvm::Triple &TT)
+            -> llvm::Expected<std::unique_ptr<llvm::orc::ObjectLayer>> {
+          auto L = std::make_unique<llvm::orc::ObjectLinkingLayer>(
+              ES, EPC->getMemMgr());
+          if (OrcRuntimePath.empty()) {
+            auto EHFrameRegistrar = llvm::orc::EPCEHFrameRegistrar::Create(ES);
+            if (!EHFrameRegistrar)
+              return EHFrameRegistrar.takeError();
+            auto GDBRegistrar = llvm::orc::createJITLoaderGDBRegistrar(ES);
+            if (!GDBRegistrar)
+              return GDBRegistrar.takeError();
+            L->addPlugin(std::make_unique<llvm::orc::EHFrameRegistrationPlugin>(
+                ES, std::move(*EHFrameRegistrar)));
+            L->addPlugin(std::make_unique<llvm::orc::DebugObjectManagerPlugin>(
+                ES, std::move(*GDBRegistrar)));
+          }
+          return L;
+        });
+    Builder.setExecutorProcessControl(std::move(*EPCOrErr));
+    Builder.setPlatformSetUp([OrcRuntimePath](llvm::orc::LLJIT &J) {
+      return setupOrcPlatform(OrcRuntimePath, J);
+    });
+  }
+
+  if (auto JitOrErr = Builder.create())
     Jit = std::move(*JitOrErr);
   else {
     Err = JitOrErr.takeError();
     return;
   }
 
   const char Pref = Jit->getDataLayout().getGlobalPrefix();
   // Discover symbols from the process as a fallback.

clang/lib/Interpreter/Interpreter.cpp

IncrementalCompilerBuilder::create(std::vector<const char *> &ClangArgv) {
   auto ErrOrCC1Args = GetCC1Arguments(&Diags, Compilation.get());
   if (auto Err = ErrOrCC1Args.takeError())
     return std::move(Err);
 
   return CreateCI(**ErrOrCC1Args);
 }
 
 Interpreter::Interpreter(std::unique_ptr<CompilerInstance> CI,
-                         llvm::Error &Err) {
+                         const std::string &OrcRuntimePath, llvm::Error &Err)
+    : OrcRuntimePath(OrcRuntimePath) {
   llvm::ErrorAsOutParameter EAO(&Err);
   auto LLVMCtx = std::make_unique<llvm::LLVMContext>();
   TSCtx = std::make_unique<llvm::orc::ThreadSafeContext>(std::move(LLVMCtx));
   IncrParser = std::make_unique<IncrementalParser>(std::move(CI),
                                                    *TSCtx->getContext(), Err);
 }
 
+static std::string buildOrcRTBasename(const llvm::Triple &TT, bool AddArch) {
+  bool IsITANMSVCWindows =
+      TT.isWindowsMSVCEnvironment() || TT.isWindowsItaniumEnvironment();
+  IsITANMSVCWindows = false;
+  const char *Prefix = IsITANMSVCWindows ? "" : "lib";
+  const char *Suffix = IsITANMSVCWindows ? ".lib" : ".a";
+  std::string ArchAndEnv;
+  if (AddArch)
+    ArchAndEnv = ("-" + llvm::Triple::getArchTypeName(TT.getArch())).str();
+  return (Prefix + Twine("orc_rt") + ArchAndEnv + Suffix).str();
+}
+
+std::string
+Interpreter::findOrcRuntimePath(const std::vector<const char *> &ClangArgv) {
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts =
+      CreateAndPopulateDiagOpts(ClangArgv);
+  TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
+  DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
+
+  driver::Driver Driver(/*MainBinaryName=*/ClangArgv[0],
+                        llvm::sys::getProcessTriple(), Diags);
+  Driver.setCheckInputsExist(false);
+  llvm::ArrayRef<const char *> RF = llvm::makeArrayRef(ClangArgv);
+  std::unique_ptr<driver::Compilation> Compilation(Driver.BuildCompilation(RF));
+
+  auto RuntimePaths = Compilation->getDefaultToolChain().getRuntimePaths();
+  auto &TC = Compilation->getDefaultToolChain();
+  auto TT = Compilation->getDefaultToolChain().getTriple();
+  for (const auto &LibPath : TC.getLibraryPaths()) {
+    SmallString<128> P(LibPath);
+    llvm::sys::path::append(P, buildOrcRTBasename(TT, false));
+    if (Driver.getVFS().exists(P))
+      return std::string(P.str());
+  }
+
+  if (!RuntimePaths.empty()) {
+    SmallString<256> Path(RuntimePaths.front());
+    llvm::sys::path::append(Path, buildOrcRTBasename(TT, true));
+    if (Driver.getVFS().exists(Path))
+      return Path.str().str();
+  }
+
+  return "";
+}
+
 Interpreter::~Interpreter() {
   if (IncrExecutor) {
     if (llvm::Error Err = IncrExecutor->cleanUp())
       llvm::report_fatal_error(
           llvm::Twine("Failed to clean up IncrementalExecutor: ") +
           toString(std::move(Err)));
   }
 }
 
 llvm::Expected<std::unique_ptr<Interpreter>>
-Interpreter::create(std::unique_ptr<CompilerInstance> CI) {
+Interpreter::create(std::unique_ptr<CompilerInstance> CI,
+                    const std::string &OrcRuntimePath) {
   llvm::Error Err = llvm::Error::success();
-  auto Interp =
-      std::unique_ptr<Interpreter>(new Interpreter(std::move(CI), Err));
+  auto Interp = std::unique_ptr<Interpreter>(
+      new Interpreter(std::move(CI), OrcRuntimePath, Err));
   if (Err)
     return std::move(Err);
   return std::move(Interp);
 }
 
 const CompilerInstance *Interpreter::getCompilerInstance() const {
   return IncrParser->getCI();
 }

 }
 
 llvm::Error Interpreter::Execute(PartialTranslationUnit &T) {
   assert(T.TheModule);
   if (!IncrExecutor) {
     const clang::TargetInfo &TI =
         getCompilerInstance()->getASTContext().getTargetInfo();
     llvm::Error Err = llvm::Error::success();
-    IncrExecutor = std::make_unique<IncrementalExecutor>(*TSCtx, Err, TI);
+    IncrExecutor =
+        std::make_unique<IncrementalExecutor>(*TSCtx, Err, OrcRuntimePath, TI);
 
     if (Err)
       return Err;
   }
   // FIXME: Add a callback to retain the llvm::Module once the JIT is done.
   if (auto Err = IncrExecutor->addModule(T))
     return Err;
 

clang/tools/clang-repl/ClangRepl.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Interpreter/Interpreter.h"
 
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/LineEditor/LineEditor.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Support/ManagedStatic.h" // llvm_shutdown
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h" // llvm::Initialize*
 
 static llvm::cl::list<std::string>
     ClangArgs("Xcc",
               llvm::cl::desc("Argument to pass to the CompilerInvocation"),
               llvm::cl::CommaSeparated);
if (CI->getDiagnosticOpts().VerifyDiagnostics) {
     Errs = Client->getNumErrors();
 
     // The interpreter expects BeginSourceFile/EndSourceFiles to be balanced.
     Client->BeginSourceFile(CI->getLangOpts(), &CI->getPreprocessor());
   }
   return (Errs || HasError) ? EXIT_FAILURE : EXIT_SUCCESS;
 }
 
+/// Returns true when it could find orc runtime archive from clang resource
+/// directory and using orc runtime is preferred.
+static bool isOrcRuntimeSupported(const std::vector<const char *> &ClangArgv) {
+  auto OrcRuntimePath = clang::Interpreter::findOrcRuntimePath(ClangArgv);
+  if (OrcRuntimePath.empty())
+    return false;
+  auto TT = llvm::Triple(llvm::sys::getProcessTriple());
+  return TT.isWindowsMSVCEnvironment() && TT.getArch() == llvm::Triple::x86_64;
+}
+
 llvm::ExitOnError ExitOnErr;
 int main(int argc, const char **argv) {
   ExitOnErr.setBanner("clang-repl: ");
   llvm::cl::ParseCommandLineOptions(argc, argv);
 
   llvm::llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   std::vector<const char *> ClangArgv(ClangArgs.size());
int main(int argc, const char **argv) {
   // Set an error handler, so that any LLVM backend diagnostics go through our
   // error handler.
   llvm::install_fatal_error_handler(LLVMErrorHandler,
                                     static_cast<void *>(&CI->getDiagnostics()));
 
   // Load any requested plugins.
   CI->LoadRequestedPlugins();
 
-  auto Interp = ExitOnErr(clang::Interpreter::create(std::move(CI)));
+  auto OrcRuntimePath = isOrcRuntimeSupported(ClangArgv)
+                            ? clang::Interpreter::findOrcRuntimePath(ClangArgv)
+                            : "";
+  auto Interp =
+      ExitOnErr(clang::Interpreter::create(std::move(CI), OrcRuntimePath));
   for (const std::string &input : OptInputs) {
     if (auto Err = Interp->ParseAndExecute(input))
       llvm::logAllUnhandledErrors(std::move(Err), llvm::errs(), "error: ");
   }
 
   bool HasError = false;
 
   if (OptInputs.empty()) {