Enum aluvm::isa::ArithmeticOp

pub enum ArithmeticOp {
    AddA(IntFlags, RegA, Reg32, Reg32),
    AddF(RoundingFlag, RegF, Reg32, Reg32),
    SubA(IntFlags, RegA, Reg32, Reg32),
    SubF(RoundingFlag, RegF, Reg32, Reg32),
    MulA(IntFlags, RegA, Reg32, Reg32),
    MulF(RoundingFlag, RegF, Reg32, Reg32),
    DivA(IntFlags, RegA, Reg32, Reg32),
    DivF(RoundingFlag, RegF, Reg32, Reg32),
    Rem(RegA, Reg32, RegA, Reg32),
    Stp(RegA, Reg32, Step),
    Neg(RegAF, Reg16),
    Abs(RegAF, Reg16),
}

Arithmetic instructions.

All operations modify the value of st0 register, setting it to false if the destination is set to None. Otherwise, st0 value is true, even if the overflow has occurred (when wrap flag is provided).

Variants

AddA(IntFlags, RegA, Reg32, Reg32)

Adds values from two integer arithmetic registers and puts result into destination.

AddF(RoundingFlag, RegF, Reg32, Reg32)

Adds values from two float arithmetic registers and puts result into destination.

SubA(IntFlags, RegA, Reg32, Reg32)

Subtracts values from two integer arithmetic registers and puts result into destination.

SubF(RoundingFlag, RegF, Reg32, Reg32)

Subtracts values from two float arithmetic registers and puts result into destination.

MulA(IntFlags, RegA, Reg32, Reg32)

Multiplies values from two integer arithmetic registers and puts result into destination.

MulF(RoundingFlag, RegF, Reg32, Reg32)

Multiplies values from two float arithmetic registers and puts result into destination.

DivA(IntFlags, RegA, Reg32, Reg32)

Divides values from two integer arithmetic registers and puts result into destination.

Since the division operation may not result in overflow, the overflow flag is used to indicate rounding of the result:

Overflow flag is also defines behaviour for zero division (x/0 if x > 0): whether the destination must be set to 0 (true) or to None (false).

NB: Impossible arithmetic operation 0/0 always sets destination to None.

DivF(RoundingFlag, RegF, Reg32, Reg32)

Divides values from two float arithmetic registers and puts result into destination.

Rem(RegA, Reg32, RegA, Reg32)

Modulo division.

Puts a reminder of the division of source register on destination register into the destination.

Stp(RegA, Reg32, Step)

Increment/decrement register value on a given signed step.

Sets the destination to None and st0 to false in case of overflow.

Neg(RegAF, Reg16)

Negates most significant bit

Abs(RegAF, Reg16)

Replaces the register value with its absolute value

Trait Implementations

impl Bytecode for ArithmeticOp

fn byte_count(&self) -> u16

Returns number of bytes which instruction and its argument occupies

fn instr_range() -> RangeInclusive<u8>

Returns range of instruction btecodes covered by a set of operations

fn instr_byte(&self) -> u8

Returns byte representing instruction code (without its arguments)

fn write_args<W>(&self, writer: &mut W) -> Result<(), BytecodeError> where
    W: Write, 

Writes instruction arguments as bytecode, omitting instruction code byte

fn read<R>(reader: &mut R) -> Result<Self, CodeEofError> where
    R: Read, 

Reads the instruction from bytecode

fn call_site(&self) -> Option<LibSite>

If the instruction call or references any external library, returns the call site in that library.

fn write<W>(&self, writer: &mut W) -> Result<(), BytecodeError> where
    W: Write, 

Writes the instruction as bytecode

impl Clone for ArithmeticOp

fn clone(&self) -> ArithmeticOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ArithmeticOp

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

Formats the value using the given formatter.

impl Display for ArithmeticOp

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

Formats the value using the given formatter.

impl Hash for ArithmeticOp

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 InstructionSet for ArithmeticOp

fn isa_ids() -> BTreeSet<&'static str>

ISA Extensions used by the provided instruction set.

fn complexity(&self) -> u32

Returns computational complexity of the instruction

fn exec(&self, regs: &mut CoreRegs, _: LibSite) -> ExecStep

Executes given instruction taking all registers as input and output.

fn isa_string() -> String

ISA Extension IDs represented as a standard string (space-separated)

fn isa_id() -> Box<[u8]>

ISA Extension IDs encoded in a standard way (space-separated)

fn is_supported(id: &str) -> bool

Checks whether provided ISA extension ID is supported by the current instruction set

impl PartialEq<ArithmeticOp> for ArithmeticOp

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

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

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

This method tests for !=.

impl Copy for ArithmeticOp

impl Eq for ArithmeticOp

impl StructuralEq for ArithmeticOp

impl StructuralPartialEq for ArithmeticOp