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(ControlFlowOp)

Control-flow instructions. See ControlFlowOp for the details.

Put(PutOp)

Instructions setting register values. See PutOp for the details.

Move(MoveOp)

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

Cmp(CmpOp)

Instructions comparing register values. See CmpOp for the details.

Arithmetic(ArithmeticOp)

Arithmetic instructions. See ArithmeticOp for the details.

Bitwise(BitwiseOp)

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

Bytes(BytesOp)

Operations on byte strings. See BytesOp for the details.

Digest(DigestOp)

Cryptographic hashing functions. See DigestOp for the details.

ExtensionCodes(Extension)

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

ReservedInstruction(ReservedOp)

Reserved instruction for fututre use in core ALU ISA.

Currently equal to ControlFlowOp::Fail.

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

Writes instruction arguments as bytecode, omitting instruction code byte

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

Reads the instruction from bytecode

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

Writes the instruction as bytecode

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

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

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

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,
    Self: Sized,

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

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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

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