Struct AddressMap

#[repr(C)]
pub struct AddressMap<M: LinearMemory = MemoryBackend> {
    pub mem: Vec<M>,
    pub config: Vec<AddressSpaceHostConfig>,
}

Map from address space to linear memory. The underlying memory is typeless, stored as raw bytes, but usage implicitly assumes that each address space has memory cells of a fixed type (e.g., u8, F). We do not use a typemap for performance reasons, and it is up to the user to enforce types. Needless to say, this is a very unsafe API.

Fields

mem: Vec<M>

Underlying memory data.

config: Vec<AddressSpaceHostConfig>

Host configuration for each address space.

Implementations

impl<M: LinearMemory> AddressMap<M>

pub fn new(config: Vec<AddressSpaceHostConfig>) -> Self

pub fn from_mem_config(mem_config: &MemoryConfig) -> Self

pub fn get_memory(&self) -> &Vec<M>

pub fn get_memory_mut(&mut self) -> &mut Vec<M>

pub fn fill_zero(&mut self)

Fill each address space memory with zeros. Does not change the config.

pub unsafe fn get_f<F: PrimeField32>(&self, addr_space: u32, ptr: u32) -> F

Safety

• Assumes addr_space is within the configured memory and not out of bounds

pub unsafe fn get<T: Copy>(&self, (addr_space, ptr): Address) -> T

Safety

• T must be the correct type for a single memory cell for addr_space
• Assumes addr_space is within the configured memory and not out of bounds

pub unsafe fn get_slice<T: Copy + Debug>( &self, (addr_space, ptr): Address, len: usize, ) -> &[T]

Panics or segfaults if ptr..ptr + len is out of bounds

Safety

• T must be the correct type for a single memory cell for addr_space
• Assumes addr_space is within the configured memory and not out of bounds

pub unsafe fn get_u8_slice( &self, addr_space: u32, start: usize, len: usize, ) -> &[u8]

Reads the slice at byte addresses start..start + len from address space addr_space linear memory. Panics or segfaults if start..start + len is out of bounds

Safety

• Assumes addr_space is within the configured memory and not out of bounds

pub unsafe fn copy_slice_nonoverlapping<T: Copy>( &mut self, (addr_space, ptr): Address, data: &[T], )

Copies data into the memory at (addr_space, ptr).

Panics or segfaults if ptr + size_of_val(data) is out of bounds.

Safety

• T must be the correct type for a single memory cell for addr_space
• The linear memory in addr_space is aligned to T.

pub fn set_from_sparse(&mut self, sparse_map: &SparseMemoryImage)

Safety

• T must be the correct type for a single memory cell for addr_space
• Assumes addr_space is within the configured memory and not out of bounds

Trait Implementations

impl<M: Clone + LinearMemory> Clone for AddressMap<M>

fn clone(&self) -> AddressMap<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug + LinearMemory> Debug for AddressMap<M>

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

Formats the value using the given formatter.

impl Default for AddressMap

fn default() -> Self

Returns the “default value” for a type.