Enum aluvm::isa::Instr

#[non_exhaustive]
pub enum Instr<Extension = ReservedOp> where
    Extension: InstructionSet,  {
    ControlFlow(ControlFlowOp),
    Put(PutOp),
    Move(MoveOp),
    Cmp(CmpOp),
    Arithmetic(ArithmeticOp),
    Bitwise(BitwiseOp),
    Bytes(BytesOp),
    Digest(DigestOp),
    ExtensionCodes(Extension),
    ReservedInstruction(ReservedOp),
    Nop,
}

Full set of instructions

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ControlFlow

Control-flow instructions. See ControlFlowOp for the details.

Tuple Fields of ControlFlow

0: ControlFlowOp

Put

Instructions setting register values. See PutOp for the details.

Tuple Fields of Put

0: PutOp

Move

Instructions moving and swapping register values. See PutOp for the details.

Tuple Fields of Move

0: MoveOp

Cmp

Instructions comparing register values. See CmpOp for the details.

Tuple Fields of Cmp

0: CmpOp

Arithmetic

Arithmetic instructions. See ArithmeticOp for the details.

Tuple Fields of Arithmetic

0: ArithmeticOp

Bitwise

Bit operations & boolean algebra instructions. See BitwiseOp for the details.

Tuple Fields of Bitwise

0: BitwiseOp

Bytes

Operations on byte strings. See BytesOp for the details.

Tuple Fields of Bytes

0: BytesOp

Digest

Cryptographic hashing functions. See DigestOp for the details.

Tuple Fields of Digest

0: DigestOp

ExtensionCodes

Extension operations which can be provided by a host environment provided via generic parameter

Tuple Fields of ExtensionCodes

0: Extension

ReservedInstruction

Reserved instruction for fututre use in core ALU ISA.

Currently equal to ControlFlowOp::Fail.

Tuple Fields of ReservedInstruction

0: ReservedOp

Nop

No-operation instruction.

Trait Implementations

impl<Extension> Bytecode for Instr<Extension> where
    Extension: InstructionSet, 

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 call_site(&self) -> Option<LibSite>

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

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 write<W>(&self, writer: &mut W) -> Result<(), BytecodeError> where
    W: Write, 

Writes the instruction as bytecode

impl<Extension: Clone> Clone for Instr<Extension> where
    Extension: InstructionSet, 

fn clone(&self) -> Instr<Extension>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Extension: Debug> Debug for Instr<Extension> where
    Extension: InstructionSet, 

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

Formats the value using the given formatter.

impl<Extension> Display for Instr<Extension> where
    Extension: InstructionSet, 

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

Formats the value using the given formatter.

impl<Extension: Hash> Hash for Instr<Extension> where
    Extension: InstructionSet, 

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<Extension> InstructionSet for Instr<Extension> where
    Extension: InstructionSet, 

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

ISA Extensions used by the provided instruction set.

fn exec(&self, regs: &mut CoreRegs, site: 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

fn complexity(&self) -> u64

Returns computational complexity of the instruction

impl<Extension: PartialEq> PartialEq<Instr<Extension>> for Instr<Extension> where
    Extension: InstructionSet, 

fn eq(&self, other: &Instr<Extension>) -> bool

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

fn ne(&self, other: &Instr<Extension>) -> bool

This method tests for !=.

impl<Extension: Eq> Eq for Instr<Extension> where
    Extension: InstructionSet, 

impl<Extension> StructuralEq for Instr<Extension> where
    Extension: InstructionSet, 

impl<Extension> StructuralPartialEq for Instr<Extension> where
    Extension: InstructionSet,