Struct RvCore 

pub struct RvCore {
    pub memory: Memory,
    pub instructions: Vec<Instruction>,
    pub registers: Registers,
    pub vec_engine: VectorEngine,
}

Fields

memory: Memory

instructions: Vec<Instruction>

registers: Registers

vec_engine: VectorEngine

Implementations

impl RvCore

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

pub fn run(&mut self) -> RunningRvCore<'_>

Examples found in repository

examples/memcpy/main.rs (line 76)

fn main() {
    // Important note: eeric as low-level back-end abstraction layer does not support pseudo-instructions
    // Burden of decoding pseudo-instructions is on the front-end layer
    // E.G: ret == I::Jalr (F::I { rd: ZERO, rs1: RA, imm: 0 }),

    use alias::*;

    let mut core = RvCoreBuilder::default()
        .instructions(vec![
            I::Vsetvli(F::Vsetvli {
                rd: T0,
                rs1: A2,
                vtypei: vtype!(e8, m8, ta, ma),
            }),
            I::Vlv {
                eew: BaseSew::E8,
                data: F::Vl {
                    vd: 0,
                    rs1: A1,
                    vm: false,
                },
            },
            I::Add(F::R {
                rd: A1,
                rs1: A1,
                rs2: T0,
            }),
            I::Sub(F::R {
                rd: A2,
                rs1: A2,
                rs2: T0,
            }),
            I::Vsv {
                eew: BaseSew::E8,
                data: F::Vs {
                    vs3: 0,
                    rs1: A3,
                    vm: false,
                },
            },
            I::Add(F::R {
                rd: A3,
                rs1: A3,
                rs2: T0,
            }),
            I::Bne(F::S {
                rs1: A2,
                rs2: ZERO,
                imm12: -24,
            }),
            I::Jalr(F::I {
                rd: ZERO,
                rs1: RA,
                imm12: 0,
            }),
        ])
        .build();

    for machine_state in core.run() {
        println!("{:?}", machine_state);
    }
}

Trait Implementations

impl Clone for RvCore

fn clone(&self) -> RvCore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RvCore

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

Formats the value using the given formatter.

impl Default for RvCore

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for RvCore

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RvCore