Skip to main content

ExecutableInstruction

Trait ExecutableInstruction 

Source
pub trait ExecutableInstruction<Regs, Env, Memory, PC>{
    // Required method
    fn execute(
        self,
        rs1rs2_values: Rs1Rs2OperandValues<<<Self::Hart as HartConfig>::Reg as Register>::Type>,
        regs: &mut Regs,
        env: &mut Env,
        memory: &mut Memory,
        program_counter: &PC,
    ) -> ExecutionResult<<Self::Hart as HartConfig>::Reg>;
}
Expand description

Trait for executable instructions

Required Methods§

Source

fn execute( self, rs1rs2_values: Rs1Rs2OperandValues<<<Self::Hart as HartConfig>::Reg as Register>::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<<Self::Hart as HartConfig>::Reg>

Execute instruction.

Instructions might place additional constraints on Env to require additional registers, handlers (like SystemInstructionHandler) or other resources. If no such constraint is used, () can be used as a placeholder.

On success ExecutionResult::Continue { rd: rd, value: rd_value } is returned, which will be written into the register file. In most cases this is the only register that needs to be written. If no value needs to be written, ExecutionResult::ContinueNoWrite should be returned, which skips the register file write entirely.

program_counter is read-only. Instructions say where execution goes next with ExecutionResult::Branch or ExecutionResult::Jump.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types§

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32AInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, Env: ReservationSet<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32BInstruction<Hart>
where Reg: Register<Type = u32> + Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32Instruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Env: SystemInstructionHandler<Reg, Regs, Memory, PC>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32MInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZaamoInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZabhaInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZacasInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZalasrInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZalrscInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, Env: ReservationSet<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZbaInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZbbInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZbbZbkbSharedInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZbcInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZbkbInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZbkcInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZbkxInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZbsInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZcaInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>, Env: SystemInstructionHandler<Reg, Regs, Memory, PC>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZcbInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>, Env: SystemInstructionHandler<Reg, Regs, Memory, PC>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZcmpInstruction<Hart>
where Reg: ZcmpRegister<Type = u32> + Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>, Env: SystemInstructionHandler<Reg, Regs, Memory, PC>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZknInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZkndInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZkneInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZknhInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv32ZmmulInstruction<Hart>
where Reg: Register<Type = u32>, Hart: HartConfig<Reg = Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64AInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, Env: ReservationSet<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64BInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64Instruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Env: SystemInstructionHandler<Reg, Regs, Memory, PC>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64MInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZaamoInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZabhaInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZacasInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZalasrInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZalrscInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, Env: ReservationSet<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZbaInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZbbInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZbbZbkbSharedInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZbcInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZbkbInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZbkcInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZbkxInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZbsInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZcaInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>, Env: SystemInstructionHandler<Reg, Regs, Memory, PC>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZcbInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>, Env: SystemInstructionHandler<Reg, Regs, Memory, PC>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZcmpInstruction<Hart>
where Reg: ZcmpRegister<Type = u64> + Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>, Env: SystemInstructionHandler<Reg, Regs, Memory, PC>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZknInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZkndInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZkndZkneSharedInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZkneInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZknhInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for Rv64ZmmulInstruction<Hart>
where Reg: Register<Type = u64>, Hart: HartConfig<Reg = Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for ZawrsInstruction<Hart>
where Reg: Register, Hart: HartConfig<Reg = Reg>, Env: WrsHandler,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for ZicondInstruction<Hart>
where Reg: Register, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for ZicsrInstruction<Hart>
where Reg: Register, Hart: HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Env: Csrs<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for ZifenceiInstruction<Hart>
where Reg: Register, Hart: HartConfig<Reg = Reg>, Env: FenceIHandler,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for ZkrInstruction<Hart>
where Reg: Register + Register, Hart: HartConfig<Reg = Reg>, Env: ZkrSeedSource + Csrs<Reg>, Regs: RegisterFile<Reg>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for ZvbbInstruction<Hart>
where Reg: Register, Hart: VectorHartConfig<Reg = Reg> + HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Env: VectorRegistersExt<Hart = Hart> + Csrs<Reg>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for ZvbcInstruction<Hart>
where Reg: Register, Hart: VectorHartConfig<Reg = Reg> + HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Env: VectorRegistersExt<Hart = Hart> + Csrs<Reg>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for ZveXxInstruction<Hart>
where Reg: Register, Hart: VectorHartConfig<Reg = Reg> + HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Env: VectorRegistersExt<Hart = Hart> + Csrs<Reg>, PC: ProgramCounter<Reg::Type, Memory>, Memory: VirtualMemory,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

§

impl<Reg, Hart, Regs, Env, Memory, PC> ExecutableInstruction<Regs, Env, Memory, PC> for ZvkbInstruction<Hart>
where Reg: Register, Hart: VectorHartConfig<Reg = Reg> + HartConfig<Reg = Reg>, Regs: RegisterFile<Reg>, Env: VectorRegistersExt<Hart = Hart> + Csrs<Reg>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory>,

§

fn execute( self, _: Rs1Rs2OperandValues<Reg::Type>, regs: &mut Regs, env: &mut Env, memory: &mut Memory, program_counter: &PC, ) -> ExecutionResult<Reg>

Implementors§