fix(compiler): only force OOG on failure paths, not success exits

OutOfGas is a generic-failure placeholder. STOP/RETURN/REVERT are not
errors and must keep their original InstructionResult codes; only
genuine failure paths (stack under/overflow, invalid jump, real OOG,
invalid opcode, etc.) collapse to the OOG constant.

This restores observable correctness: success paths now match the
interpreter, and the strict equality assertion in sanity_check works
again. Drops the relaxed comparison and the PreparedBench plumbing
introduced in the previous commit.

Author: DaniPopes

crates/revmc-cli/src/fixture.rs

@@ -106,9 +106,6 @@ pub struct PreparedBench {
     cfg: CfgEnv,
     tx: TxEnv,
     functions: B256Map<RawEvmCompilerFn>,
-    /// Set when the JIT was compiled with [`EvmCompiler::force_out_of_gas`].
-    /// Sanity checks tolerate the resulting OOG halt instead of demanding result equality.
-    force_out_of_gas: bool,
 }
 
 /// Caller address used for synthetic bytecode benchmarks.
@@ -168,15 +165,7 @@ impl PreparedBench {
         }
         compiler.clear_ir().expect("clear_ir failed");
 
-        Self {
-            name: bench.name,
-            accounts,
-            block,
-            cfg,
-            tx,
-            functions,
-            force_out_of_gas: compiler.is_force_out_of_gas(),
-        }
+        Self { name: bench.name, accounts, block, cfg, tx, functions }
     }
 
     /// Load a benchmark from a pre-compiled shared library instead of JIT-compiling.
@@ -207,10 +196,7 @@ impl PreparedBench {
             functions.insert(acct.code_hash, (*f).into_inner());
         }
 
-        (
-            Self { name: bench.name, accounts, block, cfg, tx, functions, force_out_of_gas: false },
-            lib,
-        )
+        (Self { name: bench.name, accounts, block, cfg, tx, functions }, lib)
     }
 
     /// Convert a bytecode [`Bench`] into fixture state.
@@ -417,25 +403,9 @@ impl PreparedBench {
     }
 
     /// Sanity-check that interpreter and JIT produce matching results.
-    ///
-    /// When [`Self::force_out_of_gas`] is set, the JIT and interpreter routinely diverge
-    /// because every JIT exit is rewritten to `OutOfGas`. Sub-calls that succeed under the
-    /// interpreter can revert under the JIT, which then propagates to the caller. The check
-    /// is relaxed to "JIT must not claim success when the interpreter failed" — any other
-    /// divergence is expected.
     pub fn sanity_check(&self) {
         let interp = self.run_interpreter();
         let jit = self.run_jit();
-        if self.force_out_of_gas {
-            assert!(
-                interp.result.is_success() || !jit.result.is_success(),
-                "force_out_of_gas: JIT succeeded where the interpreter failed:\n  \
-                 interpreter: {:?}\n  JIT: {:?}",
-                interp.result,
-                jit.result,
-            );
-            return;
-        }
         assert_eq!(
             interp.result.is_success(),
             jit.result.is_success(),

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

@@ -414,26 +414,21 @@ impl<B: Backend> EvmCompiler<B> {
         self.config.gas_metering = yes;
     }
 
-    /// Sets whether all return paths in the JIT-compiled function should yield
-    /// [`OutOfGas`](crate::interpreter::InstructionResult::OutOfGas) instead of their normal
-    /// [`InstructionResult`](crate::interpreter::InstructionResult).
+    /// Sets whether to collapse every JIT failure path to a single
+    /// [`OutOfGas`](crate::interpreter::InstructionResult::OutOfGas) constant.
     ///
-    /// Useful for benchmarking the cost of return-value materialization and the phi node merging
-    /// every return path through.
+    /// Failures (stack under/overflow, invalid jump, real OOG, invalid opcode, etc.) are
+    /// semantically interchangeable for callers that only branch on success vs failure, so
+    /// this lets LLVM DCE the per-failure-site materialization and the failure-block phi.
+    /// Successful exits (`STOP`/`RETURN`/`REVERT`) keep their original codes.
     ///
-    /// Note that this changes program behavior: the function will report `OutOfGas` for every
-    /// exit, including normal `STOP`/`RETURN`/`REVERT`.
+    /// Useful for benchmarking the cost of failure-result materialization.
     ///
     /// Defaults to `false`.
     pub fn force_out_of_gas(&mut self, yes: bool) {
         self.config.force_out_of_gas = yes;
     }
 
-    /// Returns whether [`force_out_of_gas`](Self::force_out_of_gas) is enabled.
-    pub fn is_force_out_of_gas(&self) -> bool {
-        self.config.force_out_of_gas
-    }
-
     /// Sets custom gas parameters.
     ///
     /// Overrides the default gas schedule derived from the spec_id.

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

@@ -439,7 +439,14 @@ impl<'a, B: Backend> FunctionCx<'a, B> {
         // Finalize the failure block.
         fx.bcx.switch_to_block(fx.failure_block.unwrap());
         if !fx.incoming_failures.is_empty() {
-            let failure_value = fx.bcx.phi(fx.i8_type, &fx.incoming_failures);
+            // `force_out_of_gas` collapses every error path to a generic OOG; this is
+            // safe because failures are semantically interchangeable for callers that
+            // only branch on success vs failure.
+            let failure_value = if config.force_out_of_gas {
+                fx.bcx.iconst(fx.i8_type, InstructionResult::OutOfGas as i64)
+            } else {
+                fx.bcx.phi(fx.i8_type, &fx.incoming_failures)
+            };
             fx.bcx.set_current_block_cold();
             fx.build_return(failure_value);
         } else {
@@ -449,11 +456,7 @@ impl<'a, B: Backend> FunctionCx<'a, B> {
         // Finalize the return block.
         fx.bcx.switch_to_block(fx.return_block.unwrap());
         if !fx.incoming_returns.is_empty() {
-            let return_value = if config.force_out_of_gas {
-                fx.bcx.iconst(fx.i8_type, InstructionResult::OutOfGas as i64)
-            } else {
-                fx.bcx.phi(fx.i8_type, &fx.incoming_returns)
-            };
+            let return_value = fx.bcx.phi(fx.i8_type, &fx.incoming_returns);
             if config.inspect_stack {
                 fx.copy_stack_to_arg();
                 fx.save_stack_len();