feat: Merge validation/analyzis with Bytecode

bins/revme/Cargo.toml

@@ -13,6 +13,8 @@ repository.workspace = true
 database.workspace = true
 revm = { workspace = true, features = ["std", "hashbrown", "c-kzg", "blst"] }
 inspector = { workspace = true, features = ["std", "serde-json"] }
+# enable parse std and parse feature. 
+bytecode = { workspace = true, features = ["std", "parse"] }
 
 hash-db = "0.15"
 hex = "0.4"

bins/revme/src/cmd/bench/analysis.rs

@@ -1,7 +1,6 @@
 use database::{BenchmarkDB, EthereumBenchmarkWiring};
 use revm::{
     bytecode::Bytecode,
-    interpreter::analysis::to_analysed,
     primitives::{address, bytes, Bytes, TxKind},
     Evm,
 };
@@ -11,7 +10,7 @@ pub fn run() {
     let contract_data : Bytes = hex::decode( "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").unwrap().into();
 
     let bytecode_raw = Bytecode::new_raw(contract_data.clone());
-    let bytecode_analysed = to_analysed(Bytecode::new_raw(contract_data));
+    let bytecode_analysed = Bytecode::new_raw(contract_data).into_analyzed();
 
     // BenchmarkDB is dummy state that implements Database trait.
     let mut evm = Evm::<EthereumBenchmarkWiring>::builder()

bins/revme/src/cmd/bench/snailtracer.rs

@@ -1,13 +1,12 @@
 use database::{BenchmarkDB, EthereumBenchmarkWiring};
 use revm::{
     bytecode::Bytecode,
-    interpreter::analysis::to_analysed,
     primitives::{address, bytes, Bytes, TxKind},
     Evm,
 };
 
 pub fn simple_example() {
-    let bytecode = to_analysed(Bytecode::new_raw(CONTRACT_DATA.clone()));
+    let bytecode = Bytecode::new_raw(CONTRACT_DATA.clone()).into_analyzed();
 
     // BenchmarkDB is dummy state that implements Database trait.
     let mut evm = Evm::<EthereumBenchmarkWiring>::builder()

bins/revme/src/cmd/bytecode.rs

@@ -1,10 +1,6 @@
 use clap::Parser;
 use revm::{
-    bytecode::Eof,
-    interpreter::{
-        analysis::{validate_eof_inner, CodeType, EofError},
-        opcode::eof_printer::print_eof_code,
-    },
+    bytecode::eof::{self, validate_eof_inner, CodeType, Eof, EofError},
     primitives::{Bytes, MAX_INITCODE_SIZE},
 };
 use std::io;
@@ -62,7 +58,7 @@ impl Cmd {
                     Err(e) => eprintln!("Decoding Error: {:#?}", e),
                 }
             } else {
-                print_eof_code(&bytes)
+                eof::printer::print(&bytes)
             }
             return;
         }

bins/revme/src/cmd/eofvalidation.rs

@@ -4,7 +4,7 @@ pub use test_suite::{PragueTestResult, TestResult, TestSuite, TestUnit, TestVect
 
 use crate::{cmd::Error, dir_utils::find_all_json_tests};
 use clap::Parser;
-use revm::interpreter::analysis::{validate_raw_eof_inner, CodeType, EofError};
+use revm::bytecode::eof::{validate_raw_eof_inner, CodeType, EofError};
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 

bins/revme/src/cmd/statetest/runner.rs

@@ -9,7 +9,6 @@ use inspector::{inspector_handle_register, inspectors::TracerEip3155};
 use revm::{
     bytecode::Bytecode,
     database_interface::EmptyDB,
-    interpreter::analysis::to_analysed,
     primitives::{keccak256, Bytes, TxKind, B256},
     specification::{eip7702::AuthorizationList, hardfork::SpecId},
     wiring::{
@@ -278,7 +277,7 @@ pub fn execute_test_suite(
         let mut cache_state = database::CacheState::new(false);
         for (address, info) in unit.pre {
             let code_hash = keccak256(&info.code);
-            let bytecode = to_analysed(Bytecode::new_raw(info.code));
+            let bytecode = Bytecode::new_raw(info.code).into_analyzed();
             let acc_info = revm::state::AccountInfo {
                 balance: info.balance,
                 code_hash,

crates/bytecode/Cargo.toml

@@ -24,6 +24,7 @@ all = "warn"
 [dependencies]
 # revm
 primitives.workspace = true
+specification.workspace = true
 
 # Jumpmap
 bitvec = { version = "1", default-features = false, features = ["alloc"] }
@@ -34,9 +35,16 @@ serde = { version = "1.0", default-features = false, features = [
     "rc",
 ], optional = true }
 
+# parse opcode feature
+paste = { version = "1.0", optional = true }
+phf = { version = "0.11", default-features = false, optional = true, features = [
+    "macros",
+] }
+
 [features]
-default = ["std"]
+default = ["std", "parse"]
 std = ["serde?/std", "primitives/std"]
 hashbrown = ["primitives/hashbrown"]
 serde = ["dep:serde", "primitives/serde", "bitvec/serde"]
 serde-json = ["serde"]
+parse = ["phf", "paste"]

crates/bytecode/src/bytecode.rs

@@ -0,0 +1,246 @@
+use crate::{
+    eip7702::{Eip7702Bytecode, EIP7702_MAGIC_BYTES},
+    BytecodeDecodeError, Eof, JumpTable, LegacyAnalyzedBytecode, LegacyRawBytecode,
+    EOF_MAGIC_BYTES,
+};
+use core::fmt::Debug;
+use primitives::{keccak256, Address, Bytes, B256, KECCAK_EMPTY};
+use std::sync::Arc;
+
+/// State of the [`Bytecode`] analysis.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum Bytecode {
+    /// No analysis has been performed.
+    LegacyRaw(LegacyRawBytecode),
+    /// The bytecode has been analyzed for valid jump destinations.
+    LegacyAnalyzed(LegacyAnalyzedBytecode),
+    /// Ethereum Object Format
+    Eof(Arc<Eof>),
+    /// EIP-7702 delegated bytecode
+    Eip7702(Eip7702Bytecode),
+}
+
+impl Default for Bytecode {
+    #[inline]
+    fn default() -> Self {
+        // Creates a new legacy analyzed [`Bytecode`] with exactly one STOP opcode.
+        Self::new()
+    }
+}
+
+impl Bytecode {
+    // Creates a new legacy analyzed [`Bytecode`] with exactly one STOP opcode.
+    #[inline]
+    pub fn new() -> Self {
+        Self::LegacyAnalyzed(LegacyAnalyzedBytecode::default())
+    }
+
+    /// Return jump table if bytecode is analyzed
+    #[inline]
+    pub fn legacy_jump_table(&self) -> Option<&JumpTable> {
+        match &self {
+            Self::LegacyAnalyzed(analyzed) => Some(analyzed.jump_table()),
+            _ => None,
+        }
+    }
+
+    /// Calculate hash of the bytecode.
+    pub fn hash_slow(&self) -> B256 {
+        if self.is_empty() {
+            KECCAK_EMPTY
+        } else {
+            keccak256(self.original_byte_slice())
+        }
+    }
+
+    /// Return reference to the EOF if bytecode is EOF.
+    #[inline]
+    pub const fn eof(&self) -> Option<&Arc<Eof>> {
+        match self {
+            Self::Eof(eof) => Some(eof),
+            _ => None,
+        }
+    }
+
+    /// Returns true if bytecode is EOF.
+    #[inline]
+    pub const fn is_eof(&self) -> bool {
+        matches!(self, Self::Eof(_))
+    }
+
+    /// Returns true if bytecode is EIP-7702.
+    pub const fn is_eip7702(&self) -> bool {
+        matches!(self, Self::Eip7702(_))
+    }
+
+    /// Creates a new legacy [`Bytecode`].
+    #[inline]
+    pub fn new_legacy(raw: Bytes) -> Self {
+        Self::LegacyRaw(raw.into())
+    }
+
+    /// Creates a new raw [`Bytecode`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if bytecode is in incorrect format.
+    #[inline]
+    pub fn new_raw(bytecode: Bytes) -> Self {
+        Self::new_raw_checked(bytecode).expect("Expect correct EOF bytecode")
+    }
+
+    /// Creates a new EIP-7702 [`Bytecode`] from [`Address`].
+    #[inline]
+    pub fn new_eip7702(address: Address) -> Self {
+        Self::Eip7702(Eip7702Bytecode::new(address))
+    }
+
+    /// Creates a new raw [`Bytecode`].
+    ///
+    /// Returns an error on incorrect Bytecode format.
+    #[inline]
+    pub fn new_raw_checked(bytecode: Bytes) -> Result<Self, BytecodeDecodeError> {
+        let prefix = bytecode.get(..2);
+        match prefix {
+            Some(prefix) if prefix == &EOF_MAGIC_BYTES => {
+                let eof = Eof::decode(bytecode)?;
+                Ok(Self::Eof(Arc::new(eof)))
+            }
+            Some(prefix) if prefix == &EIP7702_MAGIC_BYTES => {
+                let eip7702 = Eip7702Bytecode::new_raw(bytecode)?;
+                Ok(Self::Eip7702(eip7702))
+            }
+            _ => Ok(Self::LegacyRaw(bytecode.into())),
+        }
+    }
+
+    /// Perform bytecode analysis.
+    ///
+    /// The analysis finds and caches valid jump destinations for later execution as an optimization step.
+    ///
+    /// If the bytecode is already analyzed, it is returned as-is.
+    #[inline]
+    pub fn into_analyzed(self) -> Bytecode {
+        let Bytecode::LegacyRaw(bytecode) = self else {
+            return self;
+        };
+
+        Bytecode::LegacyAnalyzed(bytecode.into_analyzed())
+    }
+
+    /// Create new checked bytecode.
+    ///
+    /// # Safety
+    ///
+    /// Bytecode needs to end with STOP (0x00) opcode as checked bytecode assumes
+    /// that it is safe to iterate over bytecode without checking lengths.
+    pub unsafe fn new_analyzed(
+        bytecode: Bytes,
+        original_len: usize,
+        jump_table: JumpTable,
+    ) -> Self {
+        Self::LegacyAnalyzed(LegacyAnalyzedBytecode::new(
+            bytecode,
+            original_len,
+            jump_table,
+        ))
+    }
+
+    /// Returns a reference to the bytecode.
+    ///
+    /// In case of EOF this will be the first code section.
+    #[inline]
+    pub fn bytecode(&self) -> &Bytes {
+        match self {
+            Self::LegacyRaw(bytes) => bytes,
+            Self::LegacyAnalyzed(analyzed) => analyzed.bytecode(),
+            Self::Eof(eof) => eof
+                .body
+                .code(0)
+                .expect("Valid EOF has at least one code section"),
+            Self::Eip7702(code) => code.raw(),
+        }
+    }
+
+    /// Returns false if bytecode can't be executed in Interpreter.
+    pub fn is_execution_ready(&self) -> bool {
+        !matches!(self, Self::LegacyRaw(_))
+    }
+
+    /// Returns bytes
+    #[inline]
+    pub fn bytes(&self) -> Bytes {
+        match self {
+            Self::LegacyAnalyzed(analyzed) => analyzed.bytecode().clone(),
+            _ => self.original_bytes(),
+        }
+    }
+
+    /// Returns bytes slice
+    #[inline]
+    pub fn bytes_slice(&self) -> &[u8] {
+        match self {
+            Self::LegacyAnalyzed(analyzed) => analyzed.bytecode(),
+            _ => self.original_byte_slice(),
+        }
+    }
+
+    /// Returns a reference to the original bytecode.
+    #[inline]
+    pub fn original_bytes(&self) -> Bytes {
+        match self {
+            Self::LegacyRaw(bytes) => bytes.0.clone(),
+            Self::LegacyAnalyzed(analyzed) => analyzed.original_bytes(),
+            Self::Eof(eof) => eof.raw().clone(),
+            Self::Eip7702(eip7702) => eip7702.raw().clone(),
+        }
+    }
+
+    /// Returns the original bytecode as a byte slice.
+    #[inline]
+    pub fn original_byte_slice(&self) -> &[u8] {
+        match self {
+            Self::LegacyRaw(bytes) => bytes,
+            Self::LegacyAnalyzed(analyzed) => analyzed.original_byte_slice(),
+            Self::Eof(eof) => eof.raw(),
+            Self::Eip7702(eip7702) => eip7702.raw(),
+        }
+    }
+
+    /// Returns the length of the original bytes.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.original_byte_slice().len()
+    }
+
+    /// Returns whether the bytecode is empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Bytecode, Eof};
+    use std::sync::Arc;
+
+    #[test]
+    fn eof_arc_clone() {
+        let eof = Arc::new(Eof::default());
+        let bytecode = Bytecode::Eof(Arc::clone(&eof));
+
+        // Cloning the Bytecode should not clone the underlying Eof
+        let cloned_bytecode = bytecode.clone();
+        if let Bytecode::Eof(original_arc) = bytecode {
+            if let Bytecode::Eof(cloned_arc) = cloned_bytecode {
+                assert!(Arc::ptr_eq(&original_arc, &cloned_arc));
+            } else {
+                panic!("Cloned bytecode is not Eof");
+            }
+        } else {
+            panic!("Original bytecode is not Eof");
+        }
+    }
+}