Struct rsim::processor::elements::cheri::CheriAggregateMemory

pub struct CheriAggregateMemory {
    base_mem: AggregateMemory,
    tag_mem: TagMemory,
}

Wrapper for AggregateMemory64 that keeps tags, supports MemoryOf for reading/writing capabilities. All other Memory variants clear associated tag bits on write.

Fields

base_mem: AggregateMemory

tag_mem: TagMemory

Implementations

impl CheriAggregateMemory

pub fn from_base(base_mem: AggregateMemory) -> CheriAggregateMemory

pub fn fetch_inst_u32(&mut self, cap: Cc128Cap) -> MemoryResult<u32>

pub fn get_full_range_cap(&self) -> Cc128Cap

pub fn get_io_values(&self) -> Vec<Option<u64>>

Trait Implementations

impl CheriMemory<CcxCap<Cc128>> for CheriAggregateMemory

Combine MemoryOf<u8,u16,u32,u64> with MemoryOf

fn load_maybe_cap(&mut self, addr: TAddr) -> MemoryResult<SafeTaggedCap>

fn store_maybe_cap(
    &mut self,
    addr: TAddr,
    val: SafeTaggedCap
) -> MemoryResult<()>

fn store_cap(&mut self, addr: TAddr, val: Cc128Cap) -> MemoryResult<()>

impl Memory<CcxCap<Cc128>> for CheriAggregateMemory

Now we’ve defined MemoryOf<u8,u16,u32,u64>, combine them into a single Memory trait

fn range(&self) -> Range<usize>

The mapped address range for this Memory. All addresses passed to read,write must be within this range. Guaranteed to be at least 4 bytes in size, both ends will be 4-byte aligned.

fn as_any(&self) -> &dyn Any

fn load_u8(&mut self, addr: TAddr) -> MemoryResult<u8>

fn load_u16(&mut self, addr: TAddr) -> MemoryResult<u16>

fn load_u32(&mut self, addr: TAddr) -> MemoryResult<u32>

fn load_u64(&mut self, addr: TAddr) -> MemoryResult<u64>

fn store_u8(&mut self, addr: TAddr, val: u8) -> MemoryResult<()>

fn store_u16(&mut self, addr: TAddr, val: u16) -> MemoryResult<()>

fn store_u32(&mut self, addr: TAddr, val: u32) -> MemoryResult<()>

fn store_u64(&mut self, addr: TAddr, val: u64) -> MemoryResult<()>

impl MemoryOf<SafeTaggedCap, CcxCap<Cc128>> for CheriAggregateMemory

Impl a capability-aware view of memory for CHERI instructions e.g. a CHERI Load instruction, which is allowed to load capabilities, would use this version.

fn read(&mut self, cap: Cc128Cap) -> MemoryResult<SafeTaggedCap>

fn write(&mut self, cap: Cc128Cap, val: SafeTaggedCap) -> MemoryResult<()>

impl<TData> MemoryOf<TData, CcxCap<Cc128>> for CheriAggregateMemory where
    AggregateMemory: MemoryOf<TData, u64>, 

Implement MemoryOf addressed by Cc128Cap, which does all necessary validity checks, for every TData in {u8,u16,u32,u64}

fn read(&mut self, cap: Cc128Cap) -> MemoryResult<TData>

fn write(&mut self, cap: Cc128Cap, val: TData) -> MemoryResult<()>

impl<'a> VecMemInterface<u64, SafeTaggedCap> for CheriAggregateMemory

fn load_from_memory(
    &mut self,
    eew: Sew,
    addr_provenance: (u64, Provenance)
) -> Result<SafeTaggedCap>

Use an address, provenance pair to read a vector element from memory

fn store_to_memory(
    &mut self,
    eew: Sew,
    val: SafeTaggedCap,
    addr_provenance: (u64, Provenance)
) -> Result<()>

Use an address, provenance pair to write a vector element to memory