JIT tier-0: real specializing executor (gap-free, 3-way verified)

The tier-0 JIT now actually executes — it was an analysis-only seam before.

- `RegVm::run_jit`: a specializing executor for JIT-eligible functions (the
  numeric/control core). It reuses the interpreter's exact semantics — same
  `eval_numeric_binary` / `eval_numeric_compare` / `expect_int_ref` helpers and
  the same `reg`/`set_reg`/`take_reg` register methods — so it is gap-free by
  construction (no duplicated semantics).
- Integrated at the top of `drive`'s frame loop: a fresh JIT-eligible frame runs
  via `run_jit`, then completes exactly like the `Return` arm. Eligible functions
  never suspend, so this is safe. Non-eligible functions stay on the interpreter
  (fallback rule). Eligibility is cached per function (`Rc` identity).
- `eval_main_with_args_jit` enables it; `reg_vm_eval_source_main_jit` uses it.

Verification (interp == jit == compiled):
- the generative differential now puts its arithmetic in a JIT-eligible
  `compute()` helper, so the JIT path is actually exercised;
- hand-written 3-way tests cover parameters (DeepCopy), comparisons + branches
  (LessInt/JumpIfBool/JumpIfIntCompare), and a loop.

Whole workspace 1176 passing. Native machine-code generation (separate crate,
forbid(unsafe)) remains the next tier per docs/jit-roadmap.md; it plugs into the
same per-function dispatch and the same N-way gate.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Haofei

src/reg_vm.rs

@@ -65,12 +65,7 @@ pub fn reg_vm_eval_source_main_jit(
     source: &str,
     args: impl IntoIterator<Item = impl Into<String>>,
 ) -> Result<EvalOutput, EvalError> {
-    let executable = reg_vm_compile_source(file, source)?;
-    // Run the eligibility pass on the real program (the JIT "compile" step); its
-    // result drives native codegen in the next tier. Execution stays on the
-    // shared interpreter, so output is identical to `reg_vm_eval_source_main`.
-    let _plan = executable.jit_plan();
-    executable.eval_main_with_args(args)
+    reg_vm_compile_source(file, source)?.eval_main_with_args_jit(args)
 }
 
 /// Per-program JIT eligibility: how many functions are fully covered by the
@@ -242,6 +237,31 @@ impl RegVmExecutable {
         )
     }
 
+    /// Run `main` with the tier-0 JIT enabled: JIT-eligible functions execute via
+    /// the specializing executor, the rest via the interpreter. Output is
+    /// identical to `eval_main_with_args` (verified by the N-way differential).
+    pub fn eval_main_with_args_jit(
+        &self,
+        args: impl IntoIterator<Item = impl Into<String>>,
+    ) -> Result<EvalOutput, EvalError> {
+        let mut vm = RegVm::new(
+            Rc::clone(&self.unit),
+            args.into_iter().map(Into::into).collect(),
+            HashMap::new(),
+        );
+        vm.jit_enabled = true;
+        let value = vm.run_program("main")?;
+        let display_value = value.display();
+        let native_value = value.native_value();
+        Ok(EvalOutput {
+            value: display_value.clone(),
+            display_value,
+            native_value,
+            stdout: vm.stdout,
+            stderr: vm.stderr,
+        })
+    }
+
     pub fn eval_main_with_args_and_native_bindings(
         &self,
         args: impl IntoIterator<Item = impl Into<String>>,
@@ -4716,6 +4736,12 @@ struct RegVm {
     websockets: HashMap<i64, TcpStream>,
     next_pool_id: i64,
     pools: HashMap<i64, VmResourcePool>,
+    /// Tier-0 JIT: when set, JIT-eligible functions run via the specializing
+    /// executor `run_jit` (which reuses the interpreter's value/register
+    /// semantics, so it is gap-free by construction).
+    jit_enabled: bool,
+    /// Cached JIT eligibility per function (keyed by `Rc` identity).
+    jit_eligibility: HashMap<*const RegFunction, bool>,
 }
 
 #[derive(Debug, Clone)]
@@ -4785,7 +4811,189 @@ impl RegVm {
             websockets: HashMap::new(),
             next_pool_id: 1,
             pools: HashMap::new(),
+            jit_enabled: false,
+            jit_eligibility: HashMap::new(),
+        }
+    }
+
+    /// Whether `func` is fully covered by the tier-0 JIT instruction subset
+    /// (cached by `Rc` identity).
+    fn is_jit_eligible(&mut self, func: &Rc<RegFunction>) -> bool {
+        let key = Rc::as_ptr(func);
+        if let Some(&eligible) = self.jit_eligibility.get(&key) {
+            return eligible;
+        }
+        let eligible = func.code.iter().all(jit_supported_instruction);
+        self.jit_eligibility.insert(key, eligible);
+        eligible
+    }
+
+    /// Tier-0 JIT executor for a JIT-eligible function. Runs the body via the
+    /// same shared helpers (`eval_numeric_binary`, `eval_numeric_compare`, …) and
+    /// register methods (`reg`/`set_reg`/`take_reg`) the interpreter uses, so its
+    /// result is identical to `drive` by construction. Eligible functions contain
+    /// no calls, awaits, or blocking ops, so this never suspends or pushes frames.
+    fn run_jit(&mut self, func: &RegFunction, base: usize) -> Result<VmValue, EvalError> {
+        let mut ip = 0usize;
+        while let Some(instr) = func.code.get(ip) {
+            ip += 1;
+            match instr {
+                RegInstr::LoadUnit { dst } => self.set_reg(base + *dst, VmValue::Unit),
+                RegInstr::LoadInt { dst, value } => self.set_reg(base + *dst, VmValue::Int(*value)),
+                RegInstr::LoadFloat { dst, value } => {
+                    self.set_reg(base + *dst, VmValue::Float(*value))
+                }
+                RegInstr::LoadBool { dst, value } => {
+                    self.set_reg(base + *dst, VmValue::Bool(*value))
+                }
+                RegInstr::Move { dst, src } => {
+                    let value = self.reg(base + *src).clone();
+                    self.set_reg(base + *dst, value);
+                }
+                RegInstr::DeepCopy { reg } => {
+                    let copied = deep_copy_value(self.reg(base + *reg));
+                    self.set_reg(base + *reg, copied);
+                }
+                RegInstr::AddInt { dst, lhs, rhs } => {
+                    let value = eval_numeric_binary(
+                        BinaryOp::Add,
+                        self.reg(base + *lhs),
+                        self.reg(base + *rhs),
+                    )?;
+                    self.set_reg(base + *dst, value);
+                }
+                RegInstr::SubInt { dst, lhs, rhs } => {
+                    let value = eval_numeric_binary(
+                        BinaryOp::Subtract,
+                        self.reg(base + *lhs),
+                        self.reg(base + *rhs),
+                    )?;
+                    self.set_reg(base + *dst, value);
+                }
+                RegInstr::MulInt { dst, lhs, rhs } => {
+                    let value = eval_numeric_binary(
+                        BinaryOp::Multiply,
+                        self.reg(base + *lhs),
+                        self.reg(base + *rhs),
+                    )?;
+                    self.set_reg(base + *dst, value);
+                }
+                RegInstr::DivInt { dst, lhs, rhs } => {
+                    let value = eval_numeric_binary(
+                        BinaryOp::Divide,
+                        self.reg(base + *lhs),
+                        self.reg(base + *rhs),
+                    )?;
+                    self.set_reg(base + *dst, value);
+                }
+                RegInstr::ModInt { dst, lhs, rhs } => {
+                    let value = eval_numeric_binary(
+                        BinaryOp::Modulo,
+                        self.reg(base + *lhs),
+                        self.reg(base + *rhs),
+                    )?;
+                    self.set_reg(base + *dst, value);
+                }
+                RegInstr::BitAndInt { dst, lhs, rhs } => {
+                    let l = expect_int_ref(self.reg(base + *lhs))?;
+                    let r = expect_int_ref(self.reg(base + *rhs))?;
+                    self.set_reg(base + *dst, VmValue::Int(l & r));
+                }
+                RegInstr::BitOrInt { dst, lhs, rhs } => {
+                    let l = expect_int_ref(self.reg(base + *lhs))?;
+                    let r = expect_int_ref(self.reg(base + *rhs))?;
+                    self.set_reg(base + *dst, VmValue::Int(l | r));
+                }
+                RegInstr::BitXorInt { dst, lhs, rhs } => {
+                    let l = expect_int_ref(self.reg(base + *lhs))?;
+                    let r = expect_int_ref(self.reg(base + *rhs))?;
+                    self.set_reg(base + *dst, VmValue::Int(l ^ r));
+                }
+                RegInstr::ShiftLeftInt { dst, lhs, rhs } => {
+                    let l = expect_int_ref(self.reg(base + *lhs))?;
+                    let r = expect_int_ref(self.reg(base + *rhs))?;
+                    self.set_reg(base + *dst, VmValue::Int(l.wrapping_shl(r.max(0) as u32)));
+                }
+                RegInstr::ShiftRightInt { dst, lhs, rhs } => {
+                    let l = expect_int_ref(self.reg(base + *lhs))?;
+                    let r = expect_int_ref(self.reg(base + *rhs))?;
+                    self.set_reg(base + *dst, VmValue::Int(l.wrapping_shr(r.max(0) as u32)));
+                }
+                RegInstr::LessInt { dst, lhs, rhs } => {
+                    let value = eval_numeric_compare(
+                        RegIntCompare::Less,
+                        self.reg(base + *lhs),
+                        self.reg(base + *rhs),
+                    )?;
+                    self.set_reg(base + *dst, VmValue::Bool(value));
+                }
+                RegInstr::LessEqualInt { dst, lhs, rhs } => {
+                    let value = eval_numeric_compare(
+                        RegIntCompare::LessEqual,
+                        self.reg(base + *lhs),
+                        self.reg(base + *rhs),
+                    )?;
+                    self.set_reg(base + *dst, VmValue::Bool(value));
+                }
+                RegInstr::GreaterInt { dst, lhs, rhs } => {
+                    let value = eval_numeric_compare(
+                        RegIntCompare::Greater,
+                        self.reg(base + *lhs),
+                        self.reg(base + *rhs),
+                    )?;
+                    self.set_reg(base + *dst, VmValue::Bool(value));
+                }
+                RegInstr::GreaterEqualInt { dst, lhs, rhs } => {
+                    let value = eval_numeric_compare(
+                        RegIntCompare::GreaterEqual,
+                        self.reg(base + *lhs),
+                        self.reg(base + *rhs),
+                    )?;
+                    self.set_reg(base + *dst, VmValue::Bool(value));
+                }
+                RegInstr::Equal { dst, lhs, rhs } => {
+                    let eq = self.reg(base + *lhs) == self.reg(base + *rhs);
+                    self.set_reg(base + *dst, VmValue::Bool(eq));
+                }
+                RegInstr::NotEqual { dst, lhs, rhs } => {
+                    let ne = self.reg(base + *lhs) != self.reg(base + *rhs);
+                    self.set_reg(base + *dst, VmValue::Bool(ne));
+                }
+                RegInstr::Jump { target } => ip = *target,
+                RegInstr::JumpIfBool {
+                    cond,
+                    expected,
+                    target,
+                } => {
+                    if expect_bool_ref(self.reg(base + *cond))? == *expected {
+                        ip = *target;
+                    }
+                }
+                RegInstr::JumpIfIntCompare {
+                    lhs,
+                    rhs,
+                    op,
+                    expected,
+                    target,
+                } => {
+                    let l = self.reg(base + *lhs);
+                    let r = self.reg(base + *rhs);
+                    if eval_numeric_compare(*op, l, r)? == *expected {
+                        ip = *target;
+                    }
+                }
+                RegInstr::Return { src } => return Ok(self.take_reg(base + *src)),
+                // Eligibility (`jit_supported_instruction`) guarantees only the
+                // instructions above reach here. A mismatch would be an internal
+                // bug; surface it instead of silently diverging.
+                other => {
+                    return Err(EvalError::Runtime(format!(
+                        "reg VM JIT reached non-eligible instruction `{other:?}`."
+                    )));
+                }
+            }
         }
+        Ok(VmValue::Unit)
     }
 
     /// Grow the shared register stack so that `stack[..upto]` is addressable.
@@ -5203,6 +5411,21 @@ impl RegVm {
             let base = self.frames.last().expect("active frame").base;
             let next_base = base + func.regs;
             let mut ip = self.frames.last().expect("active frame").ip;
+
+            // Tier-0 JIT: a fresh JIT-eligible frame runs via the specializing
+            // executor (which reuses the interpreter's semantics), then completes
+            // exactly like the `Return` arm. Eligible functions never suspend, so
+            // they are always entered at `ip == 0`.
+            if self.jit_enabled && ip == 0 && self.is_jit_eligible(&func) {
+                let value = self.run_jit(&func, base)?;
+                let frame = self.frames.pop().expect("active frame");
+                if self.frames.len() == floor {
+                    return Ok(Outcome::Completed(value));
+                }
+                self.set_reg(frame.ret_dst, value);
+                continue 'frames;
+            }
+
             while let Some(instr) = func.code.get(ip) {
                 ip += 1;
                 match instr {

tests/backend_differential.rs

@@ -139,16 +139,87 @@ fn render_expr(expr: &Expr) -> String {
 }
 
 fn render(program: &Program) -> String {
-    let mut source = String::from("fn main() -> Unit {\n");
+    // The arithmetic lives in `compute()`, a pure integer/control function that
+    // is JIT-eligible, so the JIT executor actually runs it; `main` calls it and
+    // prints, so it stays on the interpreter. This makes the 3-way differential
+    // exercise the JIT path, not just interp vs compiled.
+    let mut source = String::from("fn compute() -> Int {\n");
     for (index, binding) in program.bindings.iter().enumerate() {
         source.push_str(&format!("    let x{index} = {}\n", render_expr(binding)));
     }
     source.push_str(&format!("    let result = {}\n", render_expr(&program.result)));
-    source.push_str("    Log.write(message: read String.from_int(value: result))\n");
+    source.push_str("    return result\n}\n\n");
+    source.push_str("fn main() -> Unit {\n");
+    source.push_str("    Log.write(message: read String.from_int(value: compute()))\n");
     source.push_str("    return Unit\n}\n");
     source
 }
 
+/// Eligible function with parameters (exercises DeepCopy + integer arithmetic in
+/// the JIT) — interp == jit == compiled.
+#[test]
+fn backends_agree_on_parameterized_arithmetic() {
+    let source = "\
+fn combine(a: Int, b: Int, c: Int) -> Int {
+    let scaled = a * 3 - b
+    return scaled + c * 2
+}
+
+fn main() -> Unit {
+    Log.write(message: read String.from_int(value: combine(a: read 7, b: read 4, c: read 5)))
+    return Unit
+}
+";
+    common::differential::assert_backends_agree("jit-params.rss", source, &[]);
+}
+
+/// Eligible function with comparisons and branches (LessInt / JumpIfBool /
+/// JumpIfIntCompare in the JIT).
+#[test]
+fn backends_agree_on_comparison_and_branches() {
+    let source = "\
+fn classify(n: Int) -> Int {
+    if n < 10 {
+        return 0
+    }
+    if n <= 100 {
+        return 1
+    }
+    return 2
+}
+
+fn main() -> Unit {
+    Log.write(message: read String.from_int(value: classify(n: read 3)))
+    Log.write(message: read String.from_int(value: classify(n: read 42)))
+    Log.write(message: read String.from_int(value: classify(n: read 999)))
+    return Unit
+}
+";
+    common::differential::assert_backends_agree("jit-branches.rss", source, &[]);
+}
+
+/// Eligible function with a loop (jumps + reassignment in the JIT).
+#[test]
+fn backends_agree_on_loop() {
+    let source = "\
+fn sum_to(n: Int) -> Int {
+    let mut total = 0
+    let mut i = 1
+    while i <= n {
+        total = total + i
+        i = i + 1
+    }
+    return total
+}
+
+fn main() -> Unit {
+    Log.write(message: read String.from_int(value: sum_to(n: read 10)))
+    return Unit
+}
+";
+    common::differential::assert_backends_agree("jit-loop.rss", source, &[]);
+}
+
 proptest! {
     // Each case compiles a crate, so keep the count modest. Raise for a longer
     // differential-fuzz session (e.g. PROPTEST_CASES=200).