Proposal: Make jump_table Optional in LegacyAnalyzedBytecode

[mlyknown]

I would like to make the jumptable constructible from static data, which can significantly reduce memory usage—especially when running in a zkVM environment.

To support this, I propose that the jump_table field in LegacyAnalyzedBytecode be made optional (Option<...>). This would allow users to provide their own jump check implementation if needed. Alternatively, if you have any suggestions for a better solution, I am open to feedback.

If this change is acceptable, I am happy to submit a pull request implementing it.

[rakita]

which can significantly reduce memory usage—especially when running in a zkVM environment. can you give me some data on this?

Jumptable is essential for consensus, without it, EVM will not function to the spec.

[mlyknown]

Reducing memory usage—especially RAM.Supporting static data for the jump table is likely a better approach for this, as it allows the table to be stored in ROM rather than taking up valuable RAM.
Currently, the jump table uses bitvec, which does not support construction from static data—so it always occupies RAM. By comparison, the bytecode uses the bytes type, which supports from_static and can be constructed from static data, allowing it to reside in ROM instead of RAM.
In zkVM environments—such as Jolt—ROM is generally more resource-friendly than RAM.

[rakita]

I asked for some data and measurements as I don't have a feel for zkVM performance, so I don't want to guess.

BitVec does support generating from a static slice. BitVec::from_slice does this.

[mlyknown]

I don't have concrete data yet—this is just my initial understanding.

As far as I know, BitVec::from_slice will reallocate memory. Would you consider supporting static slices in the future?

If you don’t plan to make this change, feel free to close the issue for now. I’ll reopen it if I gather more data or specific measurements later.

[rakita]

@mlyknown i see you are right, BitVec cloned the memory. I would definitely consider it, but I don't have a replacement for it rn,

[mlyknown]

use bitvec::{order::Lsb0, slice::BitSlice, vec::BitVec};
use once_cell::race::OnceBox;
use primitives::{bytes, hex};
use std::fmt::Debug;

/// A table of valid `jump` destinations. Cheap to clone and memory efficient, one bit per opcode.
#[derive(Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct JumpTable(bytes::Bytes, usize);

impl Debug for JumpTable {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("JumpTable")
            .field("map", &hex::encode(self.0.as_ref()))
            .field("bit_len", &self.1)
            .finish()
    }
}

impl Default for JumpTable {
    #[inline]
    fn default() -> Self {
        static DEFAULT: OnceBox<JumpTable> = OnceBox::new();
        DEFAULT
            .get_or_init(|| Box::new(Self(bytes::Bytes::new(), 0)))
            .clone()
    }
}

impl JumpTable {
    /// Gets the raw bytes of the jump map.
    #[inline]
    pub fn as_slice(&self) -> &[u8] {
        self.0.as_ref()
    }

    /// Returns number of valid bits stored in the map.
    #[inline]
    pub fn bit_len(&self) -> usize {
        self.1
    }

    /// Constructs a jump map from raw bytes and length.
    ///
    /// Bit length represents number of used bits inside slice.
    ///
    /// # Panics
    ///
    /// Panics if number of bits in slice is less than bit_len.
    #[inline]
    pub fn from_slice(slice: &[u8], bit_len: usize) -> Self {
        assert!(
            slice.len() * 8 >= bit_len,
            "slice bit length {} is less than bit_len {}",
            slice.len() * 8,
            bit_len
        );
        let mut bitvec: BitVec<u8, Lsb0> = BitVec::from_slice(slice);
        unsafe { bitvec.set_len(bit_len) };
        Self::from_bitvec(bitvec)
    }

    /// Checks if `pc` is a valid jump destination.
    #[inline]
    pub fn is_valid(&self, pc: usize) -> bool {
        if pc >= self.1 {
            return false;
        }
        // Interpret the underlying bytes as Lsb0 bits, matching construction
        let bits: &BitSlice<u8, Lsb0> = BitSlice::from_slice(self.0.as_ref());
        unsafe { *bits.get_unchecked(pc) }
    }

    /// Constructs a jump map directly from a BitVec.
    #[inline]
    pub fn from_bitvec(bits: BitVec<u8, Lsb0>) -> Self {
        let bit_len = bits.len();
        let backing = bits.into_vec();
        Self(bytes::Bytes::from(backing), bit_len)
    }

    /// Constructs a jump map from a static byte slice and bit length.
    ///
    /// Bit length represents number of used bits inside the slice.
    ///
    /// # Panics
    ///
    /// Panics if number of bits in slice is less than `bit_len`.
    #[inline]
    pub fn from_static(slice: &'static [u8], bit_len: usize) -> Self {
        assert!(
            slice.len() * 8 >= bit_len,
            "slice bit length {} is less than bit_len {}",
            slice.len() * 8,
            bit_len
        );
        Self(bytes::Bytes::from_static(slice), bit_len)
    }
}

Is this idea okay? If so, I can provide a complete pr

[rakita]

Hey @mlyknown, looking at the JumpTable, we can even remove BitVec and use Bytes in its place.

[rakita]

I should have taken more time to look into this. The solution in the end is simple. @mlyknown thank you for persisting!