Enum pir_8_emu::isa::instruction::AluOperation

pub enum AluOperation {
    Add,
    Sub,
    AddC,
    SubC,
    Or,
    Xor,
    And,
    Not,
    ShiftOrRotate {
        d: AluOperationShiftOrRotateDirection,
        tt: AluOperationShiftOrRotateType,
    },
}

Any CPU instruction of the pattern 0011 FFFF will invoke some function of the ALU.

The four bits FFFF are the actual operation being performed by the ALU.

The registers X and Y are used as inputs to the ALU (only X for unary operations), and the S register is used to store the result.

ALU operations will also update the F register as noted.

All will set the ZERO flag if the output (register S) is 0000 0000.

All will set the PARITY flag if the number of high bits are even in the S register.

The ADD, SUB, ADDC, and SUBC operations will set the carry bit in F to carry out value from the adders.

FFFF	Name	Count	Description
0000	ADD	1	Addition of register X and register Y
0001	SUB	1	Subtraction of register Y from register X (X-Y)
0010	ADDC	1	Addition of register X and register Y, using the carry bit from F (X+Y+C)
0011	SUBC	1	Subtraction of register Y from register X (X-Y), using the carry bit from F (X-Y-C)
0100	OR	1	Bitwise OR
0101	XOR	1	Bitwise XOR
0110	AND	1	Bitwise AND
0111	NOT	1	Bitwise NOT (unary operation)
1DTT		8	Shift or Rotate, see section below (unary operation)

Variants

Add

Addition of register X and register Y

Sub

Subtraction of register Y from register X (X-Y)

AddC

Addition of register X and register Y, using the carry bit from F

SubC

Subtraction of register Y from register X (X-Y), using the carry bit from F

Or

Bitwise OR

Xor

Bitwise XOR

And

Bitwise AND

Not

Bitwise NOT

ShiftOrRotate

Shift or Rotate, see member doc

Fields of ShiftOrRotate

d: AluOperationShiftOrRotateDirectiontt: AluOperationShiftOrRotateType

Methods

impl AluOperation

pub fn perform(self, lhs: u8, rhs: u8, carry: &mut bool) -> u8

Perform the ALU operation on the specified operands

Returns 0 and sets carry for reserved ops.

Examples

assert_eq!(AluOperation::Or.perform(0b0001, 0b0100, &mut false), 0b0101);

let mut carry = true;
assert_eq!(AluOperation::ShiftOrRotate {
               d: AluOperationShiftOrRotateDirection::Left,
               tt: AluOperationShiftOrRotateType::Rtc,
           }.perform(0b0101_0000, 0, &mut carry),
           0b1010_0001);
assert_eq!(carry, false);

let mut carry = false;
assert_eq!(AluOperation::Add.perform(0b1001_0000, 0b1010_0101, &mut carry),
           0b0011_0101);
assert_eq!(carry, true);

Trait Implementations

impl Clone for AluOperation

fn clone(&self) -> AluOperation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for AluOperation

impl Debug for AluOperation

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

Formats the value using the given formatter.

impl Display for AluOperation

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

Formats the value using the given formatter.

impl Eq for AluOperation

impl FromStr for AluOperation

type Err = ParseInstructionError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse ALU operation in assembly instruction format

The input string must be ASCII and contain no vertical whitespace

Examples

assert_eq!(AluOperation::from_str("XOR"),
           Ok(AluOperation::Xor));

assert_eq!(AluOperation::from_str("SOR RIGHT ASF"),
           Ok(AluOperation::ShiftOrRotate {
               d: AluOperationShiftOrRotateDirection::Right,
               tt: AluOperationShiftOrRotateType::Asf,
           }));

impl Hash for AluOperation

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 Into<u8> for AluOperation

fn into(self) -> u8

Performs the conversion.

impl Ord for AluOperation

fn cmp(&self, other: &AluOperation) -> 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<AluOperation> for AluOperation

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

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

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

This method tests for !=.

impl PartialOrd<AluOperation> for AluOperation

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

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

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

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

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

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

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

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

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

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

impl StructuralEq for AluOperation

impl StructuralPartialEq for AluOperation

impl TryFrom<u8> for AluOperation

type Error = ()

The type returned in the event of a conversion error.

fn try_from(raw: u8) -> Result<AluOperation, ()>

Performs the conversion.