perf: implement tail call table

Author: DaniPopes

crates/handler/src/instructions.rs

@@ -1,6 +1,6 @@
 use auto_impl::auto_impl;
 use interpreter::{
-    instructions::{instruction_table, InstructionTable},
+    instructions::{instruction_table_tail, InstructionTable},
     Host, Instruction, InterpreterTypes,
 };
 use std::boxed::Box;
@@ -42,7 +42,7 @@ where
 {
     /// Returns `EthInstructions` with mainnet spec.
     pub fn new_mainnet() -> Self {
-        Self::new(instruction_table::<WIRE, HOST>())
+        Self::new(instruction_table_tail::<WIRE, HOST>())
     }
 
     /// Rerurns new `EthInstructions` with custom instruction table.

crates/interpreter/src/instruction_context.rs

@@ -22,6 +22,15 @@ impl<H: ?Sized, ITy: InterpreterTypes> std::fmt::Debug for InstructionContext<'_
 }
 
 impl<H: ?Sized, ITy: InterpreterTypes> InstructionContext<'_, H, ITy> {
+    /// Reborrows the context.
+    #[inline]
+    pub fn reborrow<'b>(&'b mut self) -> InstructionContext<'b, H, ITy> {
+        InstructionContext {
+            interpreter: self.interpreter,
+            host: self.host,
+        }
+    }
+
     /// Executes the instruction at the current instruction pointer.
     ///
     /// Internally it will increment instruction pointer by one.

crates/interpreter/src/instructions.rs

@@ -27,7 +27,10 @@ pub mod tx_info;
 /// Utility functions and helpers for instruction implementation.
 pub mod utility;
 
-use crate::{interpreter_types::InterpreterTypes, Host, InstructionContext};
+use crate::{
+    interpreter_types::{InterpreterTypes, Jumps, LoopControl},
+    Host, InstructionContext,
+};
 
 /// EVM opcode function signature.
 pub type Instruction<W, H> = fn(InstructionContext<'_, H, W>);
@@ -211,6 +214,59 @@ const fn instruction_table_impl<WIRE: InterpreterTypes, H: Host + ?Sized>(
     table
 }
 
+/// Returns the tail call instruction table for the given interpreter types and host.
+#[inline]
+pub const fn instruction_table_tail<WIRE: InterpreterTypes, H: Host + ?Sized>(
+) -> [Instruction<WIRE, H>; 256] {
+    const {
+        macro_rules! wrap {
+            ($($idx:expr),* $(,)?) => {
+                [
+                    $(
+                        tail_call_instr::<$idx, H, WIRE>,
+                    )*
+                ]
+            };
+        }
+        #[rustfmt::skip]
+        let x = wrap!(
+            0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,
+            16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,
+            32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,
+            48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,
+            64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
+            80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,
+            96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+           112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+           128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+           144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+           160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+           176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+           192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+           208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+           224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
+           240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+        );
+        x
+    }
+}
+
+pub(crate) fn tail_call_instr<const OP: u8, H: Host + ?Sized, W: InterpreterTypes>(
+    mut context: InstructionContext<'_, H, W>,
+) {
+    (const { instruction_table::<W, H>()[OP as usize] })(context.reborrow());
+
+    if context.interpreter.bytecode.is_end() {
+        return;
+    }
+
+    let instruction_table = const { &instruction_table_tail::<W, H>() };
+    let opcode = context.interpreter.bytecode.opcode();
+    context.interpreter.bytecode.relative_jump(1);
+    /* become */
+    instruction_table[opcode as usize](context);
+}
+
 #[cfg(test)]
 mod tests {
     use super::instruction_table;

crates/interpreter/src/interpreter.rs

@@ -252,19 +252,7 @@ impl<IW: InterpreterTypes> Interpreter<IW> {
         host: &mut H,
     ) -> InterpreterAction {
         while self.bytecode.is_not_end() {
-            // Get current opcode.
-            let opcode = self.bytecode.opcode();
-
-            // SAFETY: In analysis we are doing padding of bytecode so that we are sure that last
-            // byte instruction is STOP so we are safe to just increment program_counter bcs on last instruction
-            // it will do noop and just stop execution of this contract
-            self.bytecode.relative_jump(1);
-            let context = InstructionContext {
-                interpreter: self,
-                host,
-            };
-            // Execute instruction.
-            instruction_table[opcode as usize](context);
+            self.step(instruction_table, host);
         }
         self.bytecode.revert_to_previous_pointer();