perf(jit): expose singleton lists to MIR cons optimization

Lower List(0) to nil and List(1) to an explicit cons with nil cdr, so
temporary singleton lists use existing escape analysis and precise
reconstruction. Keep wider lists on the adapter and retain real objects
when identity, mutation, callbacks or outgoing edges require them.

Cover zero-allocation loops, heap-valued deopt frames and AOT sidecars.
Core suite: 10,331 passed, 54 skipped; all 46 MIR tests pass under GC
stress and partition verification. The singleton loop improves 4.67x
against the preceding build; whole-workload and compilation controls
show no material regression. Benchmark artifacts are in tmp.

Author: eval-exec

crates/neovm-core/src/emacs_core/runtime/jit/aot.rs

@@ -1876,6 +1876,12 @@ pub fn is_d0_aot_candidate(
 #[cfg(target_os = "linux")]
 #[doc(hidden)]
 pub fn testkit_mir_cons_reconstruction_selftest(dir: &std::path::Path) {
+    testkit_mir_cons_reconstruction_case(dir, false);
+    testkit_mir_cons_reconstruction_case(dir, true);
+}
+
+#[cfg(target_os = "linux")]
+fn testkit_mir_cons_reconstruction_case(dir: &std::path::Path, singleton: bool) {
     use crate::emacs_core::bytecode::{ByteCodeFunction, Vm};
     use crate::emacs_core::eval::Context;
     use crate::emacs_core::jit::compile::{DeoptResume, LoadedUnit, NativeRun};
@@ -1911,6 +1917,9 @@ pub fn testkit_mir_cons_reconstruction_selftest(dir: &std::path::Path) {
         Op::Car,
         Op::Return,
     ];
+    if singleton {
+        f.ops.splice(5..7, [Op::List(1)]);
+    }
     f.seal_hand_assembled_ops();
     let m = mir::build_mir(&f.ops, &f.constants, 2).unwrap();
     assert_eq!(
@@ -1924,7 +1933,11 @@ pub fn testkit_mir_cons_reconstruction_selftest(dir: &std::path::Path) {
     let (obj, hash) = compile_leaf_to_object(&f.ops, &f.constants, 2, None)
         .unwrap()
         .unwrap();
-    let path = dir.join("cons-reconstruction.so");
+    let path = dir.join(if singleton {
+        "singleton-reconstruction.so"
+    } else {
+        "cons-reconstruction.so"
+    });
     link_object_to_so(&obj, &path).unwrap();
     // SAFETY: this is the object just emitted by our compiler; its runtime
     // imports are the same exported shims used by the JIT.
@@ -1939,10 +1952,13 @@ pub fn testkit_mir_cons_reconstruction_selftest(dir: &std::path::Path) {
     let NativeRun::DeoptAt(resume) = result else {
         panic!("precise AOT deopt expected: {result:?}")
     };
-    assert_eq!(resume.pc, 9);
+    assert_eq!(resume.pc, if singleton { 8 } else { 9 });
     assert_eq!(resume.stack[2], resume.stack[3]);
     assert_eq!(resume.stack[2].cons_car(), Value::make_int(8));
-    assert_eq!(resume.stack[2].cons_cdr(), float);
+    assert_eq!(
+        resume.stack[2].cons_cdr(),
+        if singleton { Value::NIL } else { float }
+    );
     let DeoptResume {
         pc,
         stack,

crates/neovm-core/src/emacs_core/runtime/jit/compile/lowering.rs

@@ -3172,14 +3172,11 @@ pub(crate) fn build_mir_leaf_fn<M: Module>(
                     // leave cval[r]=None — every use is a CarCdr that forwards to the
                     // operands.
                     MirOp::Cons(..) if cons_repl[r].is_some() => {}
-                    // An ESCAPING cons is heap-allocated via the neovm_jit_cons shim —
-                    // a GC SAFEPOINT, but NOT an observable side effect (a fresh
-                    // unshared object), so it needs NO precise deopt: rerun-from-start
-                    // (pure body) re-allocates a fresh cons the caller never saw, and a
-                    // call-bearing body spills the allocated cons (a real Value) into
-                    // its precise framestate normally. Force-tag car+cdr (no raw fixnum
-                    // into the heap pair / across the safepoint; the shim self-roots
-                    // them) + gc-root the live-across-allocation residual, like a call.
+                    // An escaping cons uses the non-collecting neovm_jit_cons shim.
+                    // A pure body may rerun from the start: a fresh unshared object
+                    // is not observable yet. A precise body spills the real Value
+                    // normally. Tag both fields before storing them in the heap;
+                    // no root publication is needed across this allocation.
                     MirOp::Cons(car, cdr) => {
                         let rt = rt
                             .as_ref()

crates/neovm-core/src/emacs_core/runtime/jit/mir.rs

@@ -606,7 +606,7 @@ fn lower_value_op(
             let r = emit(b, MirOp::Const(v), LispType::of_value(v), Effect::PURE);
             stack.push(r);
         }
-        Op::Nil => {
+        Op::Nil | Op::List(0) => {
             let r = emit(b, MirOp::Const(Value::NIL), LispType::Nil, Effect::PURE);
             stack.push(r);
         }
@@ -726,6 +726,16 @@ fn lower_value_op(
             let r = emit(b, MirOp::Cons(car, cdr), LispType::Cons, Effect::ALLOCATES);
             stack.push(r);
         }
+        Op::List(1) => {
+            // The byte compiler also uses list1 for (cons x nil). Expose the
+            // pair to ordinary cons escape analysis and cold reconstruction.
+            // Both allocation shims are non-collecting; neither can run Lisp.
+            // Wider lists remain opaque until nested virtual objects qualify.
+            let car = pop!();
+            let cdr = emit(b, MirOp::Const(Value::NIL), LispType::Nil, Effect::PURE);
+            let r = emit(b, MirOp::Cons(car, cdr), LispType::Cons, Effect::ALLOCATES);
+            stack.push(r);
+        }
         // Pure operand-stack shuffles — modelled as stack manipulation, no inst.
         Op::Pop => {
             pop!();

crates/neovm-core/src/emacs_core/runtime/jit/tests/mir_cons_deopt.rs

@@ -107,30 +107,40 @@ fn mir_cons_precise_frames_preserve_aliases_and_completed_effects() {
 
 #[test]
 fn mir_cons_block_local_loop_allocation_count() {
+    assert_block_local_loop_allocation_count(false);
+}
+
+#[test]
+fn mir_singleton_block_local_loop_allocation_count() {
+    assert_block_local_loop_allocation_count(true);
+}
+
+fn assert_block_local_loop_allocation_count(singleton: bool) {
     let mut ev = Context::new();
-    let f = function(
-        vec![
-            Op::Constant(0),
-            Op::StackRef(1),
-            Op::Constant(0),
-            Op::Gtr,
-            Op::GotoIfNil(16),
-            Op::StackRef(0),
-            Op::StackRef(2),
-            Op::Nil,
-            Op::Cons,
-            Op::Car,
-            Op::Add,
-            Op::StackSet(1),
-            Op::StackRef(1),
-            Op::Sub1,
-            Op::StackSet(2),
-            Op::Goto(1),
-            Op::Return,
-        ],
-        vec![Value::make_int(0)],
-        1,
-    );
+    let mut ops = vec![
+        Op::Constant(0),
+        Op::StackRef(1),
+        Op::Constant(0),
+        Op::Gtr,
+        Op::GotoIfNil(16),
+        Op::StackRef(0),
+        Op::StackRef(2),
+        Op::Nil,
+        Op::Cons,
+        Op::Car,
+        Op::Add,
+        Op::StackSet(1),
+        Op::StackRef(1),
+        Op::Sub1,
+        Op::StackSet(2),
+        Op::Goto(1),
+        Op::Return,
+    ];
+    if singleton {
+        ops.splice(7..9, [Op::List(1)]);
+        ops[4] = Op::GotoIfNil(15);
+    }
+    let f = function(ops, vec![Value::make_int(0)], 1);
     let leaf = compile_bytecode_function_with(&f, Some(&ev.obarray)).unwrap();
     assert_eq!(leaf.tier, leaf::LeafTier::Mir);
     // Fewer than 255 back edges avoids a service poll, so the allocation
@@ -170,6 +180,11 @@ fn mir_singleton_precise_frames_preserve_aliases_and_completed_effects() {
         2,
     );
     let m = mir::build_mir(&f.ops, &f.constants, 2).unwrap();
+    assert_eq!(
+        plan_mir_leaf(&m).cons_repl.iter().flatten().count(),
+        2,
+        "both singleton lists are reconstructed only on a cold exit"
+    );
     let leaf = lower_mir_pure(&m).unwrap();
     let float = ev.eval_str("1.5").unwrap();
     let result = leaf.call(
@@ -253,10 +268,49 @@ fn mir_empty_list_preserves_the_residual_stack() {
         (vec![Op::List(0), Op::Pop, Op::Return], element),
     ] {
         let m = mir::build_mir(&ops, &[], 1).unwrap();
+        assert!(!plan_mir_leaf(&m).needs_rt);
         let leaf = lower_mir_pure(&m).unwrap();
         assert_eq!(
             leaf.call(&mut ev as *mut Context as *mut u8, &[element]),
             NativeRun::Ok(expected.bits())
         );
     }
 }
+
+#[test]
+fn mir_singleton_precise_frame_preserves_a_heap_element() {
+    let mut ev = Context::new();
+    ev.eval_str("(setq mir-list-heap-v 0)").unwrap();
+    let f = function(
+        vec![
+            Op::Constant(0),
+            Op::VarSet(1),
+            Op::StackRef(0),
+            Op::List(1),
+            Op::StackRef(1),
+            Op::Add1,
+            Op::Pop,
+            Op::Car,
+            Op::Return,
+        ],
+        vec![Value::make_int(7), Value::symbol("mir-list-heap-v")],
+        1,
+    );
+    let m = mir::build_mir(&f.ops, &f.constants, 1).unwrap();
+    assert_eq!(plan_mir_leaf(&m).cons_repl.iter().flatten().count(), 1);
+    let leaf = lower_mir_pure(&m).unwrap();
+    let float = ev.eval_str("1.5").unwrap();
+    let result = leaf.call(&mut ev as *mut Context as *mut u8, &[float]);
+    let NativeRun::DeoptAt(ref resume) = result else {
+        panic!("expected precise float deopt: {result:?}")
+    };
+    assert_eq!(resume.pc, 5);
+    assert_eq!(resume.stack.len(), 3);
+    assert_eq!(resume.stack[1].cons_car().bits(), float.bits());
+    assert!(resume.stack[1].cons_cdr().is_nil());
+    assert_eq!(
+        mir_inline_guards::resume(&mut ev, &f, result).bits(),
+        float.bits()
+    );
+    assert_eq!(ev.jit_root_stack_top, 0);
+}