Enum pir_8_emu::micro::MicroOp

pub enum MicroOp {
    Nop,
    Halt,
    LoadInstruction,
    AdrWrite,
    AdrRead,
    StackPush,
    StackPop,
    Alu(AluOperation),
    PortIn,
    PortOut,
    Compare,
    MakeImmediate(u8),
    LoadImmediate,
    FetchAddress,
    WriteAddress,
    CheckJumpCondition(InstructionJumpCondition),
    Jump,
    ReadRegister(u8),
    WriteRegister(u8),
}

Actual μOps executable by the CPU

The approach is stack-based (think ComputerCraft or FORTH): bytes are individually pushed and popped onto the μstack (separate from the actual program stack), and there is no other storage.

Each high-level instruction deconstructs losslessly into up to six μOps, with the exception of reserved instructions, which are converted into 6 NOPs.

Variants

Nop

Do nothing

Also to pad out the returned instruction

Halt

Halt

LoadInstruction

Load the top of the stack into INS

AdrWrite

Write the address specified by the top two bytes of the μstack into ADR

AdrRead

Read both bytes of ADR onto the μstack

StackPush

Push a byte from the top of the μstack to the stack

StackPop

Pop a byte from the stack to the μstack

Alu(AluOperation)

Perform an ALU operation

PortIn

Read a byte from the port specified at the top of the μstack

PortOut

Write to the port specified at the top of the μstack a byte from the next byte on the μstack

Compare

Execute the compare instruction with S at the top and the specified register as the next byte on the μstack

MakeImmediate(u8)

Create an immediate value at the top of the μstack

LoadImmediate

Read a 1-byte immediate from memory at PC to the top of the μstack, incrementing PC

FetchAddress

Read the value from memory at ADR

WriteAddress

Write to memory at ADR the byte on top of the μstack

CheckJumpCondition(InstructionJumpCondition)

Check if the specified jump condition is satisfied by the top of the μstack

Jump

If the top of the μstack is 1, set PC to ADR. If it's 0, do nothing. Otherwise, error out.

ReadRegister(u8)

Read the specified register into the top of the μstack.

WriteRegister(u8)

Write the top of the μstack to the specified register.

Methods

impl MicroOp

pub fn from_instruction(instr: Instruction) -> (MicroOpBlock, usize)

Get μOps corresponding to the given instruction

The return type is (ops, len), where &ops[..len] are the actual μOps and the rest is padding. This was done to reduce allocations.

Examples

let ops = MicroOp::from_instruction(Instruction::Move { qqq: 0b100, rrr: 0b101 });
let ops = &ops.0[..ops.1];

assert_eq!(ops, &[MicroOp::ReadRegister(0b100), MicroOp::WriteRegister(0b101)]);

impl MicroOp

pub fn perform(
    self,
    stack: &mut Vec<u8>,
    memory: &mut Memory,
    ports: &mut Ports,
    registers: &mut GeneralPurposeRegisterBank,
    pc: &mut SpecialPurposeRegister<u16>,
    sp: &mut SpecialPurposeRegister<u16>,
    adr: &mut SpecialPurposeRegister<u16>,
    ins: &mut SpecialPurposeRegister<u8>
) -> Result<bool, MicroOpPerformError>

Perform this μOp

The Ok(..) return value indicates whether to continue execution (i.e. not halt)

Examples

memory[0x1A00] = 0x69;

let mut stack = vec![0x1A, 0x00];
assert_eq!(MicroOp::AdrWrite.perform(&mut stack, &mut memory, &mut ports, &mut registers,
                                     &mut pc, &mut sp, &mut adr, &mut ins),
           Ok(true));
assert_eq!(*adr, 0x1A00);
assert_eq!(stack, &[]);

assert_eq!(MicroOp::FetchAddress.perform(&mut stack, &mut memory, &mut ports, &mut registers,
                                         &mut pc, &mut sp, &mut adr, &mut ins),
           Ok(true));
assert_eq!(stack, &[0x69]);

assert_eq!(MicroOp::LoadInstruction.perform(&mut stack, &mut memory, &mut ports, &mut registers,
                                            &mut pc, &mut sp, &mut adr, &mut ins),
           Ok(true));
assert_eq!(stack, &[]);
assert_eq!(*ins, 0x69);

impl MicroOp

pub fn display<'r, 's: 'r>(
    &'s self,
    registers: &'r GeneralPurposeRegisterBank
) -> DisplayMicroOp<'r>

Get proxy object implementing Display for printing μOps in human-readable format

Examples

assert_eq!(MicroOp::WriteRegister(registers[1].address()).display(&registers).to_string(),
           "WriteRegister S");

assert_eq!(MicroOp::Alu(AluOperation::Or).display(&registers).to_string(),
           "Alu OR");

assert_eq!(MicroOp::CheckJumpCondition(InstructionJumpCondition::Jmpz).display(&registers).to_string(),
           "CheckJumpCondition JMPZ");

Trait Implementations

impl Clone for MicroOp

fn clone(&self) -> MicroOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for MicroOp

impl Debug for MicroOp

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

Formats the value using the given formatter.

impl Eq for MicroOp

impl Hash for MicroOp

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Ord for MicroOp

fn cmp(&self, other: &MicroOp) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<MicroOp> for MicroOp

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

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

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

This method tests for !=.

impl PartialOrd<MicroOp> for MicroOp

fn partial_cmp(&self, other: &MicroOp) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &MicroOp) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &MicroOp) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &MicroOp) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &MicroOp) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for MicroOp

impl StructuralPartialEq for MicroOp