Enum rsim::processor::elements::cheri::SafeTaggedCap

pub enum SafeTaggedCap {
    RawData {
        top: u64,
        bot: u64,
    },
    ValidCap(Cc128Cap),
}

Enumeration that stores either raw data or a valid capability. The capability inside ValidCap(Cc128Cap) will always have its tag bit = True as long as SafeTaggedCap::ValidCap is not created manually.

Variants

RawData

Fields of RawData

top: u64bot: u64

ValidCap(Cc128Cap)

Implementations

impl SafeTaggedCap

pub fn from_integer(data: u128) -> Self

pub fn to_integer(&self) -> u128

pub fn from_tagged_mem(top: u64, bot: u64, tag: bool) -> Self

pub fn from_cap(cap: Cc128Cap) -> Self

Converts a capability into a SafeTaggedCap. If the capability is valid (has tag bit set), returns ValidCap If the capability is invalid, returns RawData containing the compressed-raw representation

pub fn to_cap(&self) -> Cc128Cap

Converts a SafeTaggedCap to a Cc128Cap. If ValidCap, just returns the cap. If RawData, decompresses using raw representation and tag=false.

pub fn unwrap_cap(&self) -> Cc128Cap

Converts a SafeTaggedCap to a Cc128Cap with tag bit = true. Panics if the SafeTaggedCap is not a ValidCap.

Trait Implementations

impl Clone for SafeTaggedCap

fn clone(&self) -> SafeTaggedCap

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SafeTaggedCap

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

Formats the value using the given formatter.

impl Default for SafeTaggedCap

fn default() -> Self

Returns the “default value” for a type.

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 PartialEq<SafeTaggedCap> for SafeTaggedCap

fn eq(&self, other: &SafeTaggedCap) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl RegisterFile<SafeTaggedCap> for CheriRV64RegisterFile

fn read(&mut self, idx: u8) -> Result<SafeTaggedCap, RegisterFileError>

fn write(
    &mut self,
    idx: u8,
    val: SafeTaggedCap
) -> Result<(), RegisterFileError>

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

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

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

impl VectorRegisterFile<SafeTaggedCap> for CheriVectorRegisterFile

fn load_vreg(&mut self, vs: u8) -> Result<SafeTaggedCap>

fn load_vreg_int(&mut self, vs: u8) -> Result<u128>

fn store_vreg(&mut self, vd: u8, val: SafeTaggedCap) -> Result<()>

fn store_vreg_int(&mut self, vd: u8, val: u128) -> Result<()>

fn load_vreg_elem(
    &self,
    eew: Sew,
    vd_base: u8,
    idx_from_base: u32
) -> Result<SafeTaggedCap>

Load a value from an element in a vertex register group, with specified EEW Requires the type of the value to store matches the EEW.

fn load_vreg_elem_int(
    &self,
    eew: Sew,
    vd_base: u8,
    idx_from_base: u32
) -> Result<u128>

fn store_vreg_elem(
    &mut self,
    eew: Sew,
    vd_base: u8,
    idx_from_base: u32,
    val: SafeTaggedCap
) -> Result<()>

Store a value in an element in a vertex register group, with specified EEW. Requires the type of the value to store matches the EEW.

fn store_vreg_elem_int(
    &mut self,
    eew: Sew,
    vd_base: u8,
    idx_from_base: u32,
    val: u128
) -> Result<()>

fn seg_masked_out(&self, vm: bool, i: u32) -> bool

Returns true if the mask is enabled and element i has been masked out, e.g. that it should not be touched.

fn dump(&self)

fn reset(&mut self)

impl Copy for SafeTaggedCap

impl Eq for SafeTaggedCap

impl StructuralEq for SafeTaggedCap

impl StructuralPartialEq for SafeTaggedCap