Enum UsonicInstr

#[non_exhaustive]
pub enum UsonicInstr {
    CkNxIRo,
    CkNxIAo,
    CkNxORo,
    CkNxOAo,
    LdIRo,
    LdIAo,
    LdORo,
    LdOAo,
    RstIRo,
    RstIAo,
    RstORo,
    RstOAo,
}

The instruction set uses iterator semantics and not random access semantic to correspond to the RISC type of the machine and not to add assumptions about abilities to access the operation state in a random way. Operation state is always iterated, such that not a single state element can be missed (as long as iterator runs to the end).

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.

CkNxIRo

Checks whether there is a next destructible memory cell in the contract state listed in the operation input and sets CO register accordingly.

CkNxIAo

Checks whether there is a next immutable memory cell in the contract state listed in the operation input and sets CO register accordingly.

CkNxORo

Checks whether there is a next destructible memory cell defined by the operation and sets CO register accordingly.

CkNxOAo

Checks whether there is a next immutable memory cell defined by the operation and sets CO register accordingly.

LdIRo

Load next [StateValue] from the current input destructible memory cell to EA-ED registers.

If the next state value is absent, sets CO to a failed state. Otherwise, resets CO.

LdIAo

Load next [StateValue] from the current input immutable memory cell to EA-ED registers.

If the next state value is absent, sets CO to a failed state. Otherwise, resets CO.

LdORo

Load next [StateValue] from the current output destructible memory cell to EA-ED registers.

If the next state value is absent, sets CO to a failed state. Otherwise, resets CO.

LdOAo

Load next [StateValue] from the current output immutable memory cell to EA-ED registers.

If the next state value is absent, sets CO to a failed state. Otherwise, resets CO.

RstIRo

Resets iterator over input destructible memory cells by setting corresponding UI value to zero.

Does not affect the value of CO or CK registers.

RstIAo

Resets iterator over input immutable memory cells by setting corresponding UI value to zero.

Does not affect the value of CO or CK registers.

RstORo

Resets iterator over output destructible memory cells by setting corresponding UI value to zero.

Does not affect the value of CO or CK registers.

RstOAo

Resets iterator over output immutable memory cells by setting corresponding UI value to zero.

Does not affect the value of CO or CK registers.

Trait Implementations

impl<Id> Bytecode<Id> for UsonicInstr

where Id: SiteId,

fn op_range() -> RangeInclusive<u8>

Returns range of instruction bytecodes covered by a set of operations.

fn opcode_byte(&self) -> u8

Returns byte representing instruction code (without its arguments).

fn code_byte_len(&self) -> u16

Returns number of bytes used by the instruction and its arguments when serialized into the code segment.

fn external_ref(&self) -> Option<Id>

If the instruction call or references any external program, returns a reference to it.

fn encode_operands<W>( &self, _writer: &mut W, ) -> Result<(), <W as BytecodeWrite<Id>>::Error>

where W: BytecodeWrite<Id>,

Writes an instruction operands as bytecode, omitting opcode byte.

fn decode_operands<R>( _reader: &mut R, opcode: u8, ) -> Result<UsonicInstr, CodeEofError>

where UsonicInstr: Sized, R: BytecodeRead<Id>,

Reads an instruction operands from bytecode, provided the opcode byte.

fn encode_instr<W>( &self, writer: &mut W, ) -> Result<(), <W as BytecodeWrite<Id>>::Error>

where W: BytecodeWrite<Id>,

Write an instruction as bytecode.

fn decode_instr<R>(reader: &mut R) -> Result<Self, CodeEofError>

where Self: Sized, R: BytecodeRead<Id>,

Reads an instruction from bytecode.

impl Clone for UsonicInstr

fn clone(&self) -> UsonicInstr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UsonicInstr

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

Formats the value using the given formatter.

impl Display for UsonicInstr

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

Formats the value using the given formatter.

impl<Id> From<UsonicInstr> for Instr<Id>

where Id: SiteId,

fn from(v: UsonicInstr) -> Instr<Id>

Converts to this type from the input type.

impl Hash for UsonicInstr

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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<Id> Instruction<Id> for UsonicInstr

where Id: SiteId,

const ISA_EXT: &'static [&'static str]

type Core = UsonicCore

type Context<'ctx> = VmContext<'ctx>

Context: external data which are accessible to the ISA.

fn is_goto_target(&self) -> bool

fn local_goto_pos(&mut self) -> Option<&mut u16>

fn remote_goto_pos(&mut self) -> Option<&mut Site<Id>>

fn src_regs(&self) -> BTreeSet<RegE>

List of registers which value is taken into account by the instruction.

fn dst_regs(&self) -> BTreeSet<RegE>

List of registers which value may be changed by the instruction.

fn op_data_bytes(&self) -> u16

The size of the data coming as an instruction operand (i.e., except data coming from registers or read from outside the instruction operands).

fn ext_data_bytes(&self) -> u16

The size of the data read by the instruction from outside the registers (except data coming as a parameter).

fn exec( &self, _site: Site<Id>, core: &mut Core<Id, <UsonicInstr as Instruction<Id>>::Core>, context: &<UsonicInstr as Instruction<Id>>::Context<'_>, ) -> ExecStep<Site<Id>>

Executes the given instruction taking all registers as input and output.

fn isa_ext() -> Confined<BTreeSet<IsaId>, amplify::::collection::confinement::TinyOrdSet::{constant#0}, amplify::::collection::confinement::TinyOrdSet::{constant#1}>

fn regs(&self) -> BTreeSet<<Self::Core as CoreExt>::Reg>

Lists all registers which are used by the instruction.

fn src_reg_bytes(&self) -> u16

The number of bytes in the source registers.

fn dst_reg_bytes(&self) -> u16

The number of bytes in the destination registers.

fn base_complexity(&self) -> u64

fn complexity(&self) -> u64

Returns computational complexity of the instruction.

impl PartialEq for UsonicInstr

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for UsonicInstr

impl Eq for UsonicInstr

impl StructuralPartialEq for UsonicInstr