feat(runtime): add out-of-process JIT mode

Cargo.toml

@@ -63,6 +63,7 @@ revm-statetest-types = { version = "17.0.0", default-features = false }
 
 crossbeam-channel = "0.5"
 crossbeam-queue = "0.3"
+libc = "0.2"
 rayon = "1.10"
 color-eyre = "0.6"
 criterion = { package = "codspeed-criterion-compat", version = "4", default-features = false, features = ["cargo_bench_support"] }
@@ -72,6 +73,8 @@ tracing-subscriber = "0.3"
 tracing-tracy = "0.11"
 paste = "1.0"
 quanta = "0.12"
+wait-timeout = "0.2"
+wincode = { version = "0.5.4", features = ["derive"] }
 
 [profile.dev]
 opt-level = 3

crates/revmc-builtins/src/ir.rs

@@ -126,6 +126,7 @@ macro_rules! builtins {
         #[allow(unused_variables)]
         impl Builtin {
             pub const COUNT: usize = builtins!(@count $($ident),*);
+            pub const ALL: &[Self; Self::COUNT] = &[$(Self::$ident),*];
 
             pub const fn name(self) -> &'static str {
                 match self {
@@ -139,6 +140,13 @@ macro_rules! builtins {
                 }
             }
 
+            pub fn parse(name: &str) -> Option<Self> {
+                match name {
+                    $(stringify!($name) => Some(Self::$ident),)*
+                    _ => None,
+                }
+            }
+
             pub fn ret<B: TypeMethods>(self, $bcx: &mut B) -> Option<B::Type> {
                 $($types_init)*
                 match self {

crates/revmc-cli/src/main.rs

@@ -21,6 +21,9 @@ enum Command {
 }
 
 fn main() -> Result<()> {
+    if revmc::runtime::maybe_run_jit_helper()?.is_break() {
+        return Ok(());
+    }
     if std::env::var_os("RUST_BACKTRACE").is_none() {
         // SAFETY: This is called at the very beginning of main, before any other threads are
         // spawned.

crates/revmc-codegen/src/compiler/mod.rs

@@ -502,9 +502,8 @@ impl<B: Backend> EvmCompiler<B> {
         Ok(())
     }
 
-    /// (AOT) Finalizes the module and writes the compiled object to the given writer.
+    /// Finalizes the module and writes the compiled object to the given writer.
     pub fn write_object<W: io::Write>(&mut self, w: W) -> Result<()> {
-        ensure!(self.is_aot(), "cannot write AOT object during JIT compilation");
         self.finalize()?;
         {
             let _t = self.remarks.time(|r| &r.codegen);

crates/revmc-llvm/src/lib.rs

@@ -36,7 +36,7 @@ use revmc_backend::{
 };
 use std::{
     cell::Cell,
-    ffi::CString,
+    ffi::{CStr, CString},
     fmt::{self, Write},
     iter,
     mem::ManuallyDrop,
@@ -453,6 +453,20 @@ impl OrcJitState {
     }
 }
 
+fn link_jit_object_in_dylib(
+    orc: &OrcJitState,
+    jd: orc::JITDylibRef,
+    symbol_name: &CStr,
+    object: &[u8],
+    symbols: &[(CString, usize)],
+) -> Result<(usize, orc::ResourceTracker)> {
+    orc.global.define_builtins(symbols);
+    let tracker = jd.create_resource_tracker();
+    orc.global.jit.add_object_with_rt(symbol_name, object, &tracker).map_err(error_msg)?;
+    let addr = orc.global.jit.lookup_in(jd, symbol_name).map_err(error_msg)?;
+    Ok((addr, tracker))
+}
+
 /// Wraps a module in a [`orc::ThreadSafeModule`] for transfer to LLJIT.
 ///
 /// Uses a raw pointer cast to work around `Module<'ctx>` invariance — the module's
@@ -738,6 +752,44 @@ impl EvmLlvmBackend {
         Ok(())
     }
 
+    /// Returns pending absolute symbols collected while translating the current JIT module.
+    pub fn pending_symbol_names(&self) -> Vec<CString> {
+        self.orc
+            .as_ref()
+            .map(|orc| orc.pending_symbols.iter().map(|(name, _)| name.clone()).collect())
+            .unwrap_or_default()
+    }
+
+    /// Links a relocatable object into this backend's JITDylib and returns the function address
+    /// and resource tracker that owns the linked code.
+    pub fn link_jit_object(
+        &mut self,
+        symbol_name: &CStr,
+        object: &[u8],
+        symbols: &[(CString, usize)],
+    ) -> Result<(usize, orc::ResourceTracker)> {
+        let orc = self.ensure_orc()?;
+        let (addr, tracker) =
+            link_jit_object_in_dylib(orc, orc.jd(), symbol_name, object, symbols)?;
+        orc.loaded_trackers.push(tracker);
+        Ok((addr, orc.loaded_trackers.pop().unwrap()))
+    }
+
+    /// Links a relocatable object into a fresh JITDylib and returns the function address,
+    /// resource tracker, and guard for the JITDylib that owns the linked code.
+    pub fn link_jit_object_in_fresh_dylib(
+        &mut self,
+        symbol_name: &CStr,
+        object: &[u8],
+        symbols: &[(CString, usize)],
+    ) -> Result<(usize, orc::ResourceTracker, Arc<JitDylibGuard>)> {
+        let orc = self.ensure_orc()?;
+        let jd = orc.global.create_jit_dylib();
+        let jd_guard = Arc::new(JitDylibGuard { global: orc.global, jd });
+        let (addr, tracker) = link_jit_object_in_dylib(orc, jd, symbol_name, object, symbols)?;
+        Ok((addr, tracker, jd_guard))
+    }
+
     /// Pops and returns the [`ResourceTracker`](orc::ResourceTracker) for the last committed
     /// JIT module.
     ///

crates/revmc-llvm/src/orc.rs

@@ -17,7 +17,10 @@ use crate::llvm_string;
 use inkwell::{
     context::Context,
     llvm_sys::{
-        core::{LLVMContextCreate, LLVMModuleCreateWithNameInContext},
+        core::{
+            LLVMContextCreate, LLVMCreateMemoryBufferWithMemoryRangeCopy,
+            LLVMModuleCreateWithNameInContext,
+        },
         error::*,
         orc2::{lljit::*, *},
         prelude::*,
@@ -1398,6 +1401,23 @@ impl LLJIT {
         })
     }
 
+    /// Add a relocatable object file to the given ResourceTracker's JITDylib.
+    pub fn add_object_with_rt(
+        &self,
+        name: &CStr,
+        object: &[u8],
+        rt: &ResourceTracker,
+    ) -> Result<(), LLVMString> {
+        let buf = unsafe {
+            LLVMCreateMemoryBufferWithMemoryRangeCopy(
+                object.as_ptr().cast(),
+                object.len(),
+                name.as_ptr(),
+            )
+        };
+        cvt(unsafe { LLVMOrcLLJITAddObjectFileWithRT(self.as_inner(), rt.as_inner(), buf) })
+    }
+
     /// Gets the execution session.
     pub fn get_execution_session(&self) -> ExecutionSessionRef<'_> {
         unsafe { ExecutionSessionRef::from_inner(LLVMOrcLLJITGetExecutionSession(self.as_inner())) }

crates/revmc-runtime/Cargo.toml

@@ -25,6 +25,7 @@ revmc-backend.workspace = true
 revmc-codegen.workspace = true
 revmc-context = { workspace = true, features = ["evm"] }
 revmc-llvm = { workspace = true, optional = true }
+revmc-builtins = { workspace = true, features = ["ir"] }
 
 alloy-primitives = { workspace = true, features = ["std", "map-fxhash"] }
 alloy-evm = { workspace = true, optional = true }
@@ -45,11 +46,14 @@ crossbeam-queue.workspace = true
 dashmap = "6"
 derive_more = { version = "2", default-features = false, features = ["debug"] }
 eyre.workspace = true
+libc.workspace = true
 libloading = "0.9"
 tempfile = "3.10"
 quanta.workspace = true
 rayon.workspace = true
 tracing.workspace = true
+wait-timeout.workspace = true
+wincode.workspace = true
 
 [dev-dependencies]
 revmc-statetest = { path = "../revmc-statetest" }