Struct BytecodeMapped

pub struct BytecodeMapped<Op, Bytes = Vec<u8>> { /* private fields */ }

A memory efficient representation of a sequence of operations parsed from bytecode.

Executing certain control flow operations can require the ability to jump back to a previous operation.

One simple solution might be to use a Vec<Op>, however it is important to consider that the size of each element within a Vec<Op> will be equal to the size of the discriminant plus the largest Op variant size (today, this is Push(Word), but this may change as new operations are added). This can have memory requirement implications for programs with large numbers of ops.

To avoid this issue, we instead store the raw “packed” bytecode alongside a list of indices into the bytecode representing the location of each operation.

Implementations

impl<Op> BytecodeMapped<Op, Vec<u8>>

pub fn push_op(&mut self, op: Op)

where Op: ToBytes,

Push a single operation onto the bytecode mapping.

impl<Op, Bytes> BytecodeMapped<Op, Bytes>

where Bytes: Deref<Target = [u8]>,

pub fn try_from_bytes( bytes: Bytes, ) -> Result<BytecodeMapped<Op, Bytes>, Op::Error>

where Op: ToOpcode + TryFromBytes, Op::Opcode: ParseOp<Op = Op> + TryFrom<u8>, Op::Error: From<<Op::Opcode as TryFrom<u8>>::Error> + From<<Op::Opcode as ParseOp>::Error>,

Attempt to construct a BytecodeMapped from an existing slice of bytes.

bytes may be any type that dereferences to a slice of bytes, e.g. &[u8], Arc<[u8]>, Vec<u8>, etc.

pub fn as_slice(&self) -> BytecodeMappedSlice<'_, Op>

Borrow the inner bytecode and op_indices slices and return a BytecodeMappedSlice.

pub fn bytecode(&self) -> &[u8]

The inner slice of bytecode that has been mapped.

pub fn ops_from(&self, start: usize) -> Option<BytecodeMappedSlice<'_, Op>>

Slice the op indices from the given index.

The returned slice represents the remainder of the program from the given op.

Returns None if start is out of range of the op_indices slice.

pub fn op(&self, ix: usize) -> Option<Op>

where Op: TryFromBytes,

The operation at the given index.

pub fn ops(&self) -> impl '_ + Iterator<Item = Op>

where Op: TryFromBytes,

An iterator yielding all mapped operations.

impl<Op, Bytes> BytecodeMapped<Op, Bytes>

pub fn op_indices(&self) -> &[usize]

The slice of operation indices within the mapped bytecode.

Trait Implementations

impl<Op: Clone, Bytes: Clone> Clone for BytecodeMapped<Op, Bytes>

fn clone(&self) -> BytecodeMapped<Op, Bytes>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Op: Debug, Bytes: Debug> Debug for BytecodeMapped<Op, Bytes>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Op> Default for BytecodeMapped<Op>

Manually implement Default to avoid requiring that Op: Default as is assumed by derive(Default).

fn default() -> Self

Returns the “default value” for a type.

impl<Op> FromIterator<Op> for BytecodeMapped<Op>

where Op: ToBytes,

fn from_iter<T: IntoIterator<Item = Op>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a, Op, Bytes> OpAccess for &'a BytecodeMapped<Op, Bytes>

where Op: TryFromBytes, Bytes: Deref<Target = [u8]>,

type Op = Op

The operation type being accessed.

type Error = Infallible

Any error that might occur during access.

fn op_access(&mut self, index: usize) -> Option<Result<Self::Op, Self::Error>>

Access the operation at the given index.

impl<Op: PartialEq, Bytes: PartialEq> PartialEq for BytecodeMapped<Op, Bytes>

fn eq(&self, other: &BytecodeMapped<Op, Bytes>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, Op> TryFrom<&'a [u8]> for BytecodeMapped<Op, &'a [u8]>

where Op: ToOpcode + TryFromBytes, Op::Opcode: ParseOp<Op = Op> + TryFrom<u8>, Op::Error: From<<Op::Opcode as TryFrom<u8>>::Error> + From<<Op::Opcode as ParseOp>::Error>,

Allow for consuming and mapping an existing &[u8].

type Error = <Op as TryFromBytes>::Error

The type returned in the event of a conversion error.

fn try_from(bytecode: &'a [u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl<Op> TryFrom<Vec<u8>> for BytecodeMapped<Op>

where Op: ToOpcode + TryFromBytes, Op::Opcode: ParseOp<Op = Op> + TryFrom<u8>, Op::Error: From<<Op::Opcode as TryFrom<u8>>::Error> + From<<Op::Opcode as ParseOp>::Error>,

Allow for taking ownership over and mapping an existing Vec<u8>.

type Error = <Op as TryFromBytes>::Error

The type returned in the event of a conversion error.

fn try_from(bytecode: Vec<u8>) -> Result<Self, Self::Error>

Performs the conversion.

impl<Op, Bytes> StructuralPartialEq for BytecodeMapped<Op, Bytes>