Skip to main content

ExecutableInstruction

ab_riscv_interpreter

Trait ExecutableInstruction 

Source 
pub trait ExecutableInstruction<State, CustomError = CustomErrorPlaceholder>
where
    Self: Instruction,
{
    // Required method
    fn execute(
        self,
        state: &mut State,
    ) -> Result<ControlFlow<()>, ExecutionError<<<Self as Instruction>::Reg as Register>::Type, CustomError>>;

    // Provided methods
    fn prepare_csr_read<C>(
        csrs: &C,
        csr_index: u16,
        raw_value: <<Self as Instruction>::Reg as Register>::Type,
        output_value: &mut <<Self as Instruction>::Reg as Register>::Type,
    ) -> Result<bool, CsrError<CustomError>>
       where C: Csrs<Self::Reg, CustomError> { ... }
    fn prepare_csr_write<C>(
        csrs: &mut C,
        csr_index: u16,
        write_value: <<Self as Instruction>::Reg as Register>::Type,
        output_value: &mut <<Self as Instruction>::Reg as Register>::Type,
    ) -> Result<bool, CsrError<CustomError>>
       where C: Csrs<Self::Reg, CustomError> { ... }
}
Expand description

Trait for executable instructions.

To make instructions composable, none of the methods must use the return statement. Err()? or similar workarounds can be used instead.

Required Methods§

Source

fn execute( self, state: &mut State, ) -> Result<ControlFlow<()>, ExecutionError<<<Self as Instruction>::Reg as Register>::Type, CustomError>>

Execute instruction

Provided Methods§

Source

fn prepare_csr_read<C>( csrs: &C, csr_index: u16, raw_value: <<Self as Instruction>::Reg as Register>::Type, output_value: &mut <<Self as Instruction>::Reg as Register>::Type, ) -> Result<bool, CsrError<CustomError>>
where C: Csrs<Self::Reg, CustomError>,

Prepare CSR read.

This method is called on each extension one by one with the raw_value (contents of the corresponding CSR register) and initially zero-initialized output_value. In return value every extension can accept (Ok(true)), ignore (Ok(false)) or reject (Err(CsrError)) read request. For accepted reads the extension must update output_value accordingly, which will be the value used by the Zicsr extension handler.

Some extensions will just copy raw_value to output value, others will copy only some bits or zero some bits of the raw_value, as required by the specification.

If no extension returns Ok(true), the read operation is implicitly rejected as illegal access.

Source

fn prepare_csr_write<C>( csrs: &mut C, csr_index: u16, write_value: <<Self as Instruction>::Reg as Register>::Type, output_value: &mut <<Self as Instruction>::Reg as Register>::Type, ) -> Result<bool, CsrError<CustomError>>
where C: Csrs<Self::Reg, CustomError>,

Prepare CSR write.

This method is called on each extension one by one with write_value being prepared by the Zicsr extension handler. In return value every extension can accept (Ok(true)), ignore (Ok(false)) or reject (Err(CsrError)) write request. For accepted writes the extension must update output_value accordingly, which will be written to the corresponding CSR register.

Some extensions will just copy write_value to output value, others will copy some bits or zero some bits of the write_value, as required by the specification.

If no extension returns Ok(true), the write operation is implicitly rejected as illegal access.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv32BInstruction<Reg>
where Reg: Register<Type = u32>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv32Instruction<Reg>
where Reg: Register<Type = u32>, [(); Reg::N]:, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory, CustomError>, InstructionHandler: SystemInstructionHandler<Reg, Memory, PC, CustomError>,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv32MInstruction<Reg>
where Reg: Register<Type = u32>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv32ZbaInstruction<Reg>
where Reg: Register<Type = u32>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv32ZbbInstruction<Reg>
where Reg: Register<Type = u32>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv32ZbcInstruction<Reg>
where Reg: Register<Type = u32>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv32ZbkcInstruction<Reg>
where Reg: Register<Type = u32>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv32ZbsInstruction<Reg>
where Reg: Register<Type = u32>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv32ZknhInstruction<Reg>
where Reg: Register<Type = u32>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv32ZmmulInstruction<Reg>
where Reg: Register<Type = u32>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv64BInstruction<Reg>
where Reg: Register<Type = u64>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv64Instruction<Reg>
where Reg: Register<Type = u64>, [(); Reg::N]:, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory, CustomError>, InstructionHandler: SystemInstructionHandler<Reg, Memory, PC, CustomError>,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv64MInstruction<Reg>
where Reg: Register<Type = u64>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv64ZbaInstruction<Reg>
where Reg: Register<Type = u64>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv64ZbbInstruction<Reg>
where Reg: Register<Type = u64>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv64ZbcInstruction<Reg>
where Reg: Register<Type = u64>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv64ZbkcInstruction<Reg>
where Reg: Register<Type = u64>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv64ZbsInstruction<Reg>
where Reg: Register<Type = u64>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv64ZknhInstruction<Reg>
where Reg: Register<Type = u64>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Rv64ZmmulInstruction<Reg>
where Reg: Register<Type = u64>, [(); Reg::N]:,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for ZicsrInstruction<Reg>
where Reg: Register, [(); Reg::N]:, ExtState: Csrs<Reg, CustomError>,

§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

§

impl<Reg, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, CustomError> for Zve64xInstruction<Reg>
where Reg: Register, [(); Reg::N]:, ExtState: VectorRegistersExt<Reg, CustomError> + Csrs<Reg, CustomError>, [(); { _ }]:, PC: ProgramCounter<Reg::Type, Memory, CustomError>, CustomError: Debug, Memory: VirtualMemory,

§

fn prepare_csr_read<C>( _csrs: &C, csr_index: u16, raw_value: Reg::Type, output_value: &mut Reg::Type, ) -> Result<bool, CsrError<CustomError>>
where C: Csrs<Self::Reg, CustomError>,

Validate reads to vector CSRs from Zicsr instructions.

All vector CSRs are accessible from unprivileged code (U-mode). Reads are pass-through: the raw value stored in the CSR is the output value.

§

fn prepare_csr_write<C>( csrs: &mut C, csr_index: u16, write_value: Reg::Type, output_value: &mut Reg::Type, ) -> Result<bool, CsrError<CustomError>>
where C: Csrs<Self::Reg, CustomError>,

Validate, sanitize, and mirror writes to vector CSRs from Zicsr instructions.

Enforces WARL semantics and vcsr mirroring:

  • vl, vtype, vlenb are read-only: writes are rejected
  • vxsat: only bit 0 is writable; mirrors into vcsr[0]
  • vxrm: only bits [1:0] are writable; mirrors into vcsr[2:1]
  • vcsr: only bits [2:0] are writable; mirrors into vxsat and vxrm
  • vstart: full XLEN write allowed (WARL, implementation may restrict range)
§

fn execute( self, state: &mut InterpreterState<Reg, ExtState, Memory, PC, InstructionHandler, CustomError>, ) -> Result<ControlFlow<()>, ExecutionError<Reg::Type, CustomError>>

Implementors§