Enum pir_8_emu::micro::MicroOp

[−] Show declaration

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),
}

[−] Expand description

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

[−] Expand description

Do nothing

Also to pad out the returned instruction

Halt

[−] Expand description

Halt

LoadInstruction

[−] Expand description

Load the top of the stack into INS

AdrWrite

[−] Expand description

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

AdrRead

[−] Expand description

Read both bytes of ADR onto the μstack

StackPush

[−] Expand description

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

StackPop

[−] Expand description

Pop a byte from the stack to the μstack

Alu(AluOperation)

[−] Expand description

Perform an ALU operation

PortIn

[−] Expand description

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

PortOut

[−] Expand description

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

Compare

[−] Expand description

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

MakeImmediate(u8)

[−] Expand description

Create an immediate value at the top of the μstack

LoadImmediate

[−] Expand description

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

FetchAddress

[−] Expand description

Read the value from memory at ADR

WriteAddress

[−] Expand description

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

CheckJumpCondition(InstructionJumpCondition)

[−] Expand description

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

Jump

[−] Expand description

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

ReadRegister(u8)

[−] Expand description

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

WriteRegister(u8)

[−] Expand description

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[+]

[+] Show hidden undocumented items

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[+]

[+] Show hidden undocumented items

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

Formats the value using the given formatter.

impl Eq for MicroOp

impl Hash for MicroOp[+]

[+] Show hidden undocumented items

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[+]

[+] Show hidden undocumented items

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[+]

[+] Show hidden undocumented items

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[+]

[+] Show hidden undocumented items

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