perf: elide some jumps in jump

Cargo.toml

@@ -169,9 +169,7 @@ strip = false
 
 # Make sure debug symbols are in the bench profile
 [profile.bench]
-debug = 2
-inherits = "release"
-strip = false
+inherits = "profiling"
 
 [profile.ethtests]
 inherits = "test"

crates/interpreter/src/instructions/control.rs

@@ -31,7 +31,7 @@ pub fn jumpi<WIRE: InterpreterTypes, H: ?Sized>(context: InstructionContext<'_,
 /// Validates jump target and performs the actual jump.
 #[inline(always)]
 fn jump_inner<WIRE: InterpreterTypes>(interpreter: &mut Interpreter<WIRE>, target: U256) {
-    let target = as_usize_or_fail!(interpreter, target, InstructionResult::InvalidJump);
+    let target = as_usize_saturated!(target);
     if !interpreter.bytecode.is_valid_legacy_jump(target) {
         interpreter.halt(InstructionResult::InvalidJump);
         return;

crates/interpreter/src/instructions/macros.rs

@@ -156,15 +156,7 @@ macro_rules! push {
 #[collapse_debuginfo(yes)]
 macro_rules! as_u64_saturated {
     ($v:expr) => {
-        match $v.as_limbs() {
-            x => {
-                if (x[1] == 0) & (x[2] == 0) & (x[3] == 0) {
-                    x[0]
-                } else {
-                    u64::MAX
-                }
-            }
-        }
+        u64::try_from($v).unwrap_or(u64::MAX)
     };
 }
 
@@ -173,7 +165,7 @@ macro_rules! as_u64_saturated {
 #[collapse_debuginfo(yes)]
 macro_rules! as_usize_saturated {
     ($v:expr) => {
-        usize::try_from($crate::as_u64_saturated!($v)).unwrap_or(usize::MAX)
+        usize::try_from($v).unwrap_or(usize::MAX)
     };
 }
 
@@ -182,9 +174,7 @@ macro_rules! as_usize_saturated {
 #[collapse_debuginfo(yes)]
 macro_rules! as_isize_saturated {
     ($v:expr) => {
-        // `isize_try_from(u64::MAX)`` will fail and return isize::MAX
-        // This is expected behavior as we are saturating the value.
-        isize::try_from($crate::as_u64_saturated!($v)).unwrap_or(isize::MAX)
+        isize::try_from($v).unwrap_or(isize::MAX)
     };
 }
 

crates/interpreter/src/instructions/system.rs

@@ -106,7 +106,7 @@ pub fn codecopy<WIRE: InterpreterTypes, H: Host + ?Sized>(
 pub fn calldataload<WIRE: InterpreterTypes, H: ?Sized>(context: InstructionContext<'_, H, WIRE>) {
     popn_top!([], offset_ptr, context.interpreter);
     let mut word = B256::ZERO;
-    let offset = as_usize_saturated!(offset_ptr);
+    let offset = as_usize_saturated!(*offset_ptr);
     let input = context.interpreter.input.input();
     let input_len = input.len();
     if offset < input_len {

crates/interpreter/src/instructions/tx_info.rs

@@ -32,6 +32,6 @@ pub fn blob_hash<WIRE: InterpreterTypes, H: Host + ?Sized>(
 ) {
     check!(context.interpreter, CANCUN);
     popn_top!([], index, context.interpreter);
-    let i = as_usize_saturated!(index);
+    let i = as_usize_saturated!(*index);
     *index = context.host.blob_hash(i).unwrap_or_default();
 }

crates/interpreter/src/interpreter/ext_bytecode.rs

@@ -140,15 +140,14 @@ impl Jumps for ExtBytecode {
 
     #[inline]
     fn is_valid_legacy_jump(&mut self, offset: usize) -> bool {
-        self.base
-            .legacy_jump_table()
-            .expect("Panic if not legacy")
-            .is_valid(offset)
+        let jt = self.base.legacy_jump_table();
+        // SAFETY: Only called by legacy bytecode. Panics in debug mode.
+        unsafe { jt.unwrap_unchecked() }.is_valid(offset)
     }
 
     #[inline]
     fn opcode(&self) -> u8 {
-        // SAFETY: `instruction_pointer` always point to bytecode.
+        // SAFETY: `instruction_pointer` always points to bytecode.
         unsafe { *self.instruction_pointer }
     }