[−][src]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`[src][−]

`pub fn perform(self, lhs: u8, rhs: u8, carry: &mut bool) -> u8`[src][−]

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

[+] Show hidden undocumented items

`fn clone(&self) -> AluOperation`[src][−]

`fn clone_from(&mut self, source: &Self)`1.0.0[src][−]

`impl Copy for AluOperation`[src]

`impl Debug for AluOperation`[src][+]

[+] Show hidden undocumented items

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

`impl Display for AluOperation`[src][+]

[+] Show hidden undocumented items

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

`impl Eq for AluOperation`[src]

`impl FromStr for AluOperation`[src][+]

`type Err = ParseInstructionError`

The associated error which can be returned from parsing.

`fn from_str(s: &str) -> Result<Self, Self::Err>`[src][−]

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