perf(jit): defer call-free fusion after confirmed search regressions

Author: eval-exec

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

@@ -3620,15 +3620,6 @@ fn build_leaf_fn<M: Module>(
     // param instead of baking. 0 = plain function / AOT.
     dynamic_prefix: usize,
 ) -> Result<cranelift_module::FuncId, CompileError> {
-    // Predicate fusion improves arithmetic loops, but measured call-containing
-    // bodies can regress under the altered branch form. Keep their established
-    // lowering until that tradeoff is resolved independently.
-    let fuse_integer_predicates = !ops.iter().any(|op| {
-        matches!(
-            op,
-            Op::Call(_) | Op::Apply(_) | Op::CallBuiltin(..) | Op::CallBuiltinSym(..)
-        )
-    });
     lowering::imm_pool_reset();
     LAST_IR_STATS.with(|c| c.set((0, 0, 0, 0)));
     let frontend_config = module.target_config();
@@ -4067,29 +4058,21 @@ fn build_leaf_fn<M: Module>(
                     Op::GotoIfNil(t) | Op::GotoIfNotNil(t) => {
                         let cond = stack.pop().ok_or(CompileError::StackUnderflow)?;
                         write_stack_to_vars(&mut fb, &vars, &stack);
+                        let is_nil =
+                            fb.ins()
+                                .icmp_imm_u(IntCC::Equal, cond, Value::NIL.bits() as i64);
                         let tu = *t as usize;
                         let mut target = block_for[&tu];
                         let fallthrough = block_for[&(i + 1)];
                         let backedge = (tu <= i).then(|| fb.create_block());
                         if let Some(tramp) = backedge {
                             target = tramp;
                         }
+                        // brif takes the `then` block when the condition is true.
                         if matches!(op, Op::GotoIfNil(_)) {
-                            emit_nil_branch(
-                                &mut fb,
-                                cond,
-                                fuse_integer_predicates,
-                                target,
-                                fallthrough,
-                            );
+                            fb.ins().brif(is_nil, target, &[], fallthrough, &[]);
                         } else {
-                            emit_nil_branch(
-                                &mut fb,
-                                cond,
-                                fuse_integer_predicates,
-                                fallthrough,
-                                target,
-                            );
+                            fb.ins().brif(is_nil, fallthrough, &[], target, &[]);
                         }
                         if let Some(tramp) = backedge {
                             // Taken-edge trampoline carrying the back-edge poll.
@@ -4121,6 +4104,9 @@ fn build_leaf_fn<M: Module>(
                         // top slot — implementing the "ElsePop".
                         let cond = *stack.last().ok_or(CompileError::StackUnderflow)?;
                         write_stack_to_vars(&mut fb, &vars, &stack);
+                        let is_nil =
+                            fb.ins()
+                                .icmp_imm_u(IntCC::Equal, cond, Value::NIL.bits() as i64);
                         let tu = *t as usize;
                         let mut target = block_for[&tu];
                         let fallthrough = block_for[&(i + 1)];
@@ -4129,21 +4115,9 @@ fn build_leaf_fn<M: Module>(
                             target = tramp;
                         }
                         if matches!(op, Op::GotoIfNilElsePop(_)) {
-                            emit_nil_branch(
-                                &mut fb,
-                                cond,
-                                fuse_integer_predicates,
-                                target,
-                                fallthrough,
-                            );
+                            fb.ins().brif(is_nil, target, &[], fallthrough, &[]);
                         } else {
-                            emit_nil_branch(
-                                &mut fb,
-                                cond,
-                                fuse_integer_predicates,
-                                fallthrough,
-                                target,
-                            );
+                            fb.ins().brif(is_nil, fallthrough, &[], target, &[]);
                         }
                         if let Some(tramp) = backedge {
                             fb.switch_to_block(tramp);

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

@@ -82,43 +82,6 @@ pub(crate) fn iconst_bits(fb: &FunctionBuilder, v: ClifValue) -> Option<i64> {
     }
 }
 
-/// Branch on a tagged Lisp value, reusing an integer predicate with T/NIL arms.
-/// Complement the comparison to preserve nil/non-nil successor ordering without
-/// materializing the Lisp boolean. Other consumers retain the tagged value.
-/// The caller opts in only for bodies without explicit Lisp-call bytecodes.
-pub(crate) fn emit_nil_branch(
-    fb: &mut FunctionBuilder,
-    value: ClifValue,
-    fuse_predicate: bool,
-    if_nil: Block,
-    if_non_nil: Block,
-) {
-    use cranelift_codegen::ir::{InstructionData, Opcode, ValueDef, condcodes::CondCode};
-    if fuse_predicate
-        && let ValueDef::Result(inst, _) = fb.func.dfg.value_def(value)
-        && let InstructionData::Ternary {
-            opcode: Opcode::Select,
-            args,
-        } = fb.func.dfg.insts[inst]
-        && iconst_bits(fb, args[1]) == Some(Value::T.bits() as i64)
-        && iconst_bits(fb, args[2]) == Some(Value::NIL.bits() as i64)
-        && let ValueDef::Result(predicate, _) = fb.func.dfg.value_def(args[0])
-        && let InstructionData::IntCompare {
-            opcode: Opcode::Icmp,
-            args,
-            cond,
-        } = fb.func.dfg.insts[predicate]
-    {
-        let is_nil = fb.ins().icmp(cond.complement(), args[0], args[1]);
-        fb.ins().brif(is_nil, if_nil, &[], if_non_nil, &[]);
-    } else {
-        let is_nil = fb
-            .ins()
-            .icmp_imm_u(IntCC::Equal, value, Value::NIL.bits() as i64);
-        fb.ins().brif(is_nil, if_nil, &[], if_non_nil, &[]);
-    }
-}
-
 /// Return `(value, immediate)` for a binary instruction whose right operand is
 /// an `iconst`. This is the 0.134 IR shape produced by helpers such as
 /// `bor_imm_u` and `ishl_imm_u`.