Enum alure::instr::MoveOp

pub enum MoveOp {
    MovA(RegA, Reg32, Reg32),
    DupA(RegA, Reg32, Reg32),
    SwpA(RegA, Reg32, Reg32),
    MovF(RegF, Reg32, Reg32),
    DupF(RegF, Reg32, Reg32),
    SwpF(RegF, Reg32, Reg32),
    MovR(RegR, Reg32, Reg32),
    DupR(RegR, Reg32, Reg32),
    CpyA(RegA, Reg32, RegA, Reg32),
    CnvA(RegA, Reg32, RegA, Reg32),
    CnvF(RegF, Reg32, RegF, Reg32),
    CpyR(RegR, Reg32, RegR, Reg32),
    SpyAR(RegA, Reg32, RegR, Reg32),
    CnvAF(RegA, Reg32, RegF, Reg32),
    CnvFA(RegF, Reg32, RegA, Reg32),
}

Instructions moving and swapping register values

Variants

MovA(RegA, Reg32, Reg32)

Move operation: moves value of one of the integer arithmetic registers into another integer arithmetic register of the same bit size, clearing its previous value and setting the source to None.

DupA(RegA, Reg32, Reg32)

Duplicate operation: duplicates value of one of the integer arithmetic registers into another integer arithmetic register of the same bit size, clearing its previous value.

SwpA(RegA, Reg32, Reg32)

Swap operation: swaps value of two integer arithmetic registers of the same bit size.

MovF(RegF, Reg32, Reg32)

Move operation: moves value of one of the float arithmetic registers into another float arithmetic register of the same bit size, clearing its previous value and setting the source to None.

DupF(RegF, Reg32, Reg32)

Duplicate operation: duplicates value of one of the float arithmetic registers into another float arithmetic register of the same bit size, clearing its previous value.

SwpF(RegF, Reg32, Reg32)

Swap operation: swaps value of two float arithmetic registers of the same bit size.

MovR(RegR, Reg32, Reg32)

Move operation: moves value of one of the general non-arithmetic registers into another general non- arithmetic register of the same bit size, clearing its previous value and setting the source to None.

DupR(RegR, Reg32, Reg32)

Duplicate operation: duplicates value of one of the general non-arithmetic registers into another general non-arithmetic register of the same bit size, clearing its previous value.

CpyA(RegA, Reg32, RegA, Reg32)

Copy operation: copies value from one of the integer arithmetic registers to a destination register treating value as unsigned: if the value does not fit destination bit dimension, truncates the most significant bits until they fit, setting st0 value to false. Otherwise, the operation sets st0 to true.

CnvA(RegA, Reg32, RegA, Reg32)

Conversion operation: copies value from one of the integer arithmetic registers to a destination register treating value as signed: if the value does not fit destination bit dimension, truncates the most significant non-sign bits until they fit, setting st0 value to false. Otherwise, fills the difference between source and destination bit length with the value taken from the most significant source bit (sign bit) and sets st0 to true.

CnvF(RegF, Reg32, RegF, Reg32)

Conversion operation: converts value from one of the float arithmetic registers to a destination register according to floating encoding rules. If the value does not fit destination bit dimension, truncates the most significant non-sign bits until they fit, setting st0 value to false. Otherwise sets st0 to true.

CpyR(RegR, Reg32, RegR, Reg32)

Copy operation: copies value from one of the general non-arithmetic registers to a destination register. If the value does not fit destination bit dimension, truncates the most significant bits until they fit, setting st0 value to false. Otherwise, extends most significant bits with zeros and sets st0 to true.

SpyAR(RegA, Reg32, RegR, Reg32)

Swap-copy operation: swaps value one of the integer arithmetic registers with a value of an general non-arithmetic register. If any of the values do not fit destination bit dimensions, truncates the most significant bits until they fit, setting st0 value to false. Otherwise, extends most significant bits with zeros and sets st0 to true.

CnvAF(RegA, Reg32, RegF, Reg32)

Conversion operation: converts value of an integer arithmetic register to a float register according to floating encoding rules. If the value does not fit destination bit dimension, truncates the most significant non-sign bits until they fit, setting st0 value to false. Otherwise sets st0 to true.

NB: operation always treats integers as signed integers.

CnvFA(RegF, Reg32, RegA, Reg32)

Conversion operation: converts value of a float arithmetic register to an integer register according to floating encoding rules. If the value does not fit destination bit dimension, truncates the most significant non-sign bits until they fit, setting st0 value to false. Otherwise sets st0 to true.

NB: operation always treats integers as signed integers.

Trait Implementations

impl Bytecode for MoveOp

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<(), EncodeError> where
    W: Write,
    EncodeError: From<<W as Write>::Error>, 

Writes instruction arguments as bytecode, omitting instruction code byte

fn read<R>(reader: &mut R) -> Result<Self, DecodeError> where
    R: Read,
    DecodeError: From<<R as Read>::Error>, 

Reads the instruction from bytecode

fn write<W>(&self, writer: &mut W) -> Result<(), EncodeError> where
    W: Write,
    EncodeError: From<<W as Write>::Error>, 

Writes the instruction as bytecode

impl Clone for MoveOp

fn clone(&self) -> MoveOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MoveOp

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

Formats the value using the given formatter.

impl Display for MoveOp

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

Formats the value using the given formatter.

impl Hash for MoveOp

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 MoveOp

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

Executes given instruction taking all registers as input and output. The method is provided with the current code position which may be used by the instruction for constructing call stack.

impl Ord for MoveOp

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

This method returns an Ordering between self and other.

#[must_use]

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

Compares and returns the maximum of two values.

#[must_use]

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

Compares and returns the minimum of two values.

#[must_use]

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

Restrict a value to a certain interval.

impl PartialEq<MoveOp> for MoveOp

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

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

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

This method tests for !=.

impl PartialOrd<MoveOp> for MoveOp

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

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

#[must_use]

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

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

#[must_use]

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

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

#[must_use]

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

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

#[must_use]

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

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

impl Copy for MoveOp

impl Eq for MoveOp

impl StructuralEq for MoveOp

impl StructuralPartialEq for MoveOp