Struct InstructionExecutor

pub struct InstructionExecutor<'a, M: Memory> {
    pub mem: &'a mut M,
    pub hart_state: &'a mut HartState,
}

An InstructionProcessor that execute instructions, updating hart_state as appropriate.

Fields

mem: &'a mut M

Memory used by load and store instructions

hart_state: &'a mut HartState

Implementations

impl<'a, M: Memory> InstructionExecutor<'a, M>

pub fn step(&mut self) -> Result<(), InstructionException>

Execute instruction pointed to by hart_state.pc

Returns Ok where instruction execution was successful. Err with the relevant InstructionException is returned when the instruction execution causes an exception.

Trait Implementations

impl<'a, M: Memory> InstructionProcessor for InstructionExecutor<'a, M>

type InstructionResult = Result<bool, InstructionException>

Result is Ok when instruction execution is successful. `Ok(true) indicates the instruction updated the PC and Ok(false) indicates it did not (so the PC must be incremented to execute the next instruction).

fn process_add(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_addi(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_sub(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_slt(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_slti(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_sltu(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_sltui(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_or(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_ori(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_and(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_andi(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_xor(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_xori(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_sll(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_slli(&mut self, dec_insn: ITypeShamt) -> Self::InstructionResult

fn process_srl(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_srli(&mut self, dec_insn: ITypeShamt) -> Self::InstructionResult

fn process_sra(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_srai(&mut self, dec_insn: ITypeShamt) -> Self::InstructionResult

fn process_lui(&mut self, dec_insn: UType) -> Self::InstructionResult

fn process_auipc(&mut self, dec_insn: UType) -> Self::InstructionResult

fn process_beq(&mut self, dec_insn: BType) -> Self::InstructionResult

fn process_bne(&mut self, dec_insn: BType) -> Self::InstructionResult

fn process_blt(&mut self, dec_insn: BType) -> Self::InstructionResult

fn process_bltu(&mut self, dec_insn: BType) -> Self::InstructionResult

fn process_bge(&mut self, dec_insn: BType) -> Self::InstructionResult

fn process_bgeu(&mut self, dec_insn: BType) -> Self::InstructionResult

fn process_lb(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_lbu(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_lh(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_lhu(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_lw(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_sb(&mut self, dec_insn: SType) -> Self::InstructionResult

fn process_sh(&mut self, dec_insn: SType) -> Self::InstructionResult

fn process_sw(&mut self, dec_insn: SType) -> Self::InstructionResult

fn process_jal(&mut self, dec_insn: JType) -> Self::InstructionResult

fn process_jalr(&mut self, dec_insn: IType) -> Self::InstructionResult

fn process_mul(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_mulh(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_mulhu(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_mulhsu(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_div(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_divu(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_rem(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_remu(&mut self, dec_insn: RType) -> Self::InstructionResult

fn process_fence(&mut self, _dec_insn: IType) -> Self::InstructionResult