[LLVM] Add ORC CompileLayer

Thanks to Stefan Gränitz for pointing out that this is indeed rather
simple.

Author: aengelke

tpde-llvm/CMakeLists.txt

@@ -43,12 +43,14 @@ target_sources(tpde_llvm PRIVATE
     src/JITMapper.cpp
     src/LLVMAdaptor.cpp
     src/LLVMCompiler.cpp
+    src/OrcCompiler.cpp
 
     PUBLIC
     FILE_SET HEADERS
     BASE_DIRS include
     FILES
         include/tpde-llvm/LLVMCompiler.hpp
+        include/tpde-llvm/OrcCompiler.hpp
 
     PRIVATE
     FILE_SET priv_headers TYPE HEADERS

tpde-llvm/include/tpde-llvm/OrcCompiler.hpp

@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: 2025 Contributors to TPDE <https://tpde.org>
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#pragma once
+
+#include <llvm/ExecutionEngine/Orc/IRCompileLayer.h>
+#include <llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h>
+#include <llvm/Support/Error.h>
+#include <llvm/Support/MemoryBuffer.h>
+#include <llvm/Target/TargetMachine.h>
+
+#include <memory>
+
+#include "tpde-llvm/LLVMCompiler.hpp"
+
+namespace tpde_llvm {
+
+/// ORC Compiler functor using TPDE-LLVM, which can transparently fall back to
+/// LLVM's SimpleCompiler (if a target machine is provided). Intended as a
+/// typical drop-in replacement for llvm::orc::SimpleCompiler.
+class OrcCompiler : public llvm::orc::IRCompileLayer::IRCompiler {
+  std::unique_ptr<LLVMCompiler> owned_compiler;
+  LLVMCompiler *compiler;
+  llvm::TargetMachine *tm;
+
+public:
+  /// Constructor. If the TargetMachine non-null, a failure within TPDE
+  /// (e.g., due to unsupported IR constructs) will fall back to LLVM.
+  OrcCompiler(LLVMCompiler *compiler, llvm::TargetMachine *tm = nullptr)
+      : IRCompiler({}), compiler(compiler), tm(tm) {}
+  /// Constructor. If the TargetMachine non-null, a failure within TPDE
+  /// (e.g., due to unsupported IR constructs) will fall back to LLVM.
+  OrcCompiler(const llvm::Triple &triple, llvm::TargetMachine *tm = nullptr)
+      : IRCompiler({}),
+        owned_compiler(LLVMCompiler::create(triple)),
+        compiler(owned_compiler.get()),
+        tm(tm) {}
+  /// Constructor, compatible with llvm::orc::SimpleCompiler.
+  OrcCompiler(llvm::TargetMachine &tm)
+      : IRCompiler({}),
+        owned_compiler(LLVMCompiler::create(tm.getTargetTriple())),
+        compiler(owned_compiler.get()),
+        tm(&tm) {}
+
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+      operator()(llvm::Module &) override;
+};
+
+/// A very simple thread-safe version of OrcCompiler, intended as a typical
+/// drop-in replacement for llvm::orc::ConcurrentIRCompiler. This is not the
+/// most efficient way, applications could (and probably should) cache a
+/// LLVMCompiler and TargetMachine in thread-local storage.
+class ConcurrentOrcCompiler : public llvm::orc::IRCompileLayer::IRCompiler {
+  llvm::orc::JITTargetMachineBuilder jtmb;
+
+public:
+  /// Constructor. For every compilation, a new LLVMCompiler is constructed
+  /// based on the target triple of the JITTargetMachineBuilder. Likewise, for
+  /// every fallback, a new TargetMachine is constructed.
+  ConcurrentOrcCompiler(llvm::orc::JITTargetMachineBuilder jtmb)
+      : IRCompiler({}), jtmb(std::move(jtmb)) {}
+
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+      operator()(llvm::Module &) override;
+};
+
+} // namespace tpde_llvm

tpde-llvm/src/OrcCompiler.cpp

@@ -0,0 +1,60 @@
+// SPDX-FileCopyrightText: 2025 Contributors to TPDE <https://tpde.org>
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "tpde-llvm/OrcCompiler.hpp"
+
+#include <llvm/ExecutionEngine/Orc/CompileUtils.h>
+#include <llvm/Support/Error.h>
+#include <llvm/Support/MemoryBuffer.h>
+#include <llvm/TargetParser/Triple.h>
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "tpde-llvm/LLVMCompiler.hpp"
+
+namespace tpde_llvm {
+
+namespace {
+
+class VectorMemoryBuffer : public llvm::MemoryBuffer {
+  std::vector<uint8_t> data;
+
+public:
+  VectorMemoryBuffer(std::vector<uint8_t> &&v) : data(std::move(v)) {
+    const char *ptr = reinterpret_cast<const char *>(data.data());
+    init(ptr, ptr + data.size(), /*RequiresNullTerminator=*/false);
+  }
+
+  llvm::MemoryBuffer::BufferKind getBufferKind() const override {
+    return llvm::MemoryBuffer::MemoryBuffer_Malloc;
+  }
+};
+
+} // anonymous namespace
+
+llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+    OrcCompiler::operator()(llvm::Module &mod) {
+  std::vector<uint8_t> buf;
+  if (compiler && compiler->compile_to_elf(mod, buf)) {
+    return std::make_unique<VectorMemoryBuffer>(std::move(buf));
+  }
+  if (tm) {
+    return llvm::orc::SimpleCompiler(*tm)(mod);
+  }
+  return llvm::createStringError("TPDE compilation failed");
+}
+
+llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+    ConcurrentOrcCompiler::operator()(llvm::Module &mod) {
+  std::vector<uint8_t> buf;
+  auto compiler = LLVMCompiler::create(jtmb.getTargetTriple());
+  if (compiler && compiler->compile_to_elf(mod, buf)) {
+    return std::make_unique<VectorMemoryBuffer>(std::move(buf));
+  }
+  auto tm = llvm::cantFail(jtmb.createTargetMachine());
+  return llvm::orc::SimpleCompiler(*tm)(mod);
+}
+
+} // namespace tpde_llvm

tpde-llvm/tools/tpde-lli.cpp

@@ -25,6 +25,7 @@
 #include <llvm/TargetParser/Triple.h>
 
 #include "tpde-llvm/LLVMCompiler.hpp"
+#include "tpde-llvm/OrcCompiler.hpp"
 
 #include <dlfcn.h>
 #include <iostream>
@@ -86,10 +87,10 @@ int main(int argc, char *argv[]) {
   }
 #endif
 
-  llvm::LLVMContext context;
+  auto context = std::make_unique<llvm::LLVMContext>();
   llvm::SMDiagnostic diag{};
 
-  auto mod = llvm::parseIRFile(ir_path.Get(), diag, context);
+  auto mod = llvm::parseIRFile(ir_path.Get(), diag, *context);
   if (!mod) {
     diag.print(argv[0], llvm::errs());
     return 1;
@@ -103,13 +104,13 @@ int main(int argc, char *argv[]) {
 
   std::string triple_str = llvm::sys::getProcessTriple();
   llvm::Triple triple(triple_str);
-  auto compiler = tpde_llvm::LLVMCompiler::create(triple);
-  if (!compiler) {
-    std::cerr << "Unknown architecture: " << triple_str << "\n";
-    return 1;
-  }
 
   if (!orc) {
+    auto compiler = tpde_llvm::LLVMCompiler::create(triple);
+    if (!compiler) {
+      std::cerr << "Unknown architecture: " << triple_str << "\n";
+      return 1;
+    }
     auto mapper = compiler->compile_and_map(*mod, [](std::string_view name) {
       return ::dlsym(RTLD_DEFAULT, std::string(name).c_str());
     });
@@ -121,29 +122,23 @@ int main(int argc, char *argv[]) {
     return ((int (*)(int, char **))main_addr)(0, nullptr);
   }
 
-  std::vector<uint8_t> buf;
-  if (!compiler->compile_to_elf(*mod, buf)) {
-    std::cerr << "Failed to compile\n";
-    return 1;
-  }
-  llvm::StringRef buf_strref(reinterpret_cast<char *>(buf.data()), buf.size());
-  auto obj_membuf = llvm::MemoryBuffer::getMemBuffer(buf_strref, "", false);
-  assert(obj_membuf->getBufferSize());
-
   size_t page_size = exit_on_err(llvm::sys::Process::getPageSize());
   llvm::orc::ExecutionSession es(
       exit_on_err(llvm::orc::SelfExecutorProcessControl::Create()));
   llvm::orc::MapperJITLinkMemoryManager memory_manager(
       page_size, std::make_unique<llvm::orc::InProcessMemoryMapper>(page_size));
   llvm::orc::ObjectLinkingLayer object_layer(es, memory_manager);
+  llvm::orc::IRCompileLayer compile_layer(
+      es, object_layer, std::make_unique<tpde_llvm::OrcCompiler>(triple));
   llvm::orc::JITDylib &dylib = exit_on_err(es.createJITDylib("<main>"));
 
   // TODO: correct global prefix for MachO/COFF platforms
   dylib.addGenerator(exit_on_err(
       llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
           /*GlobalPrefix=*/'\0')));
 
-  exit_on_err(object_layer.add(dylib, std::move(obj_membuf)));
+  llvm::orc::ThreadSafeModule tsm(std::move(mod), std::move(context));
+  exit_on_err(compile_layer.add(dylib, std::move(tsm)));
 
 #if LLVM_VERSION_MAJOR >= 21
   object_layer.addPlugin(