Enum AnInstruction

pub enum AnInstruction<Dest: PartialEq + Default> {
    Pop(NumberOfWords),
    Push(BFieldElement),
    Divine(NumberOfWords),
    Pick(OpStackElement),
    Place(OpStackElement),
    Dup(OpStackElement),
    Swap(OpStackElement),
    Halt,
    Nop,
    Skiz,
    Call(Dest),
    Return,
    Recurse,
    RecurseOrReturn,
    Assert,
    ReadMem(NumberOfWords),
    WriteMem(NumberOfWords),
    Hash,
    AssertVector,
    SpongeInit,
    SpongeAbsorb,
    SpongeAbsorbMem,
    SpongeSqueeze,
    Add,
    AddI(BFieldElement),
    Mul,
    Invert,
    Eq,
    Split,
    Lt,
    And,
    Xor,
    Log2Floor,
    Pow,
    DivMod,
    PopCount,
    XxAdd,
    XxMul,
    XInvert,
    XbMul,
    ReadIo(NumberOfWords),
    WriteIo(NumberOfWords),
    MerkleStep,
    MerkleStepMem,
    XxDotStep,
    XbDotStep,
}

A Triton VM instruction. See the Instruction Set Architecture for more details.

The type parameter Dest describes the type of addresses (absolute or labels).

Variants

Pop(NumberOfWords)

Push(BFieldElement)

Divine(NumberOfWords)

Pick(OpStackElement)

Place(OpStackElement)

Dup(OpStackElement)

Swap(OpStackElement)

Halt

Nop

Skiz

Call(Dest)

Return

Recurse

RecurseOrReturn

Assert

ReadMem(NumberOfWords)

WriteMem(NumberOfWords)

Hash

AssertVector

SpongeInit

SpongeAbsorb

SpongeAbsorbMem

SpongeSqueeze

Add

AddI(BFieldElement)

Mul

Invert

Eq

Split

Lt

And

Xor

Log2Floor

Pow

DivMod

PopCount

XxAdd

XxMul

XInvert

XbMul

ReadIo(NumberOfWords)

WriteIo(NumberOfWords)

MerkleStep

MerkleStepMem

XxDotStep

XbDotStep

Implementations

impl<Dest: PartialEq + Default> AnInstruction<Dest>

pub const fn opcode(&self) -> u32

Assign a unique positive integer to each Instruction.

pub const fn name(&self) -> &'static str

pub const fn opcode_b(&self) -> BFieldElement

pub fn size(&self) -> usize

Number of words required to represent the instruction.

pub fn ib(&self, arg: InstructionBit) -> BFieldElement

Get the i’th instruction bit

pub fn map_call_address<F, NewDest>(&self, f: F) -> AnInstruction<NewDest>

where F: FnOnce(&Dest) -> NewDest, NewDest: PartialEq + Default,

pub const fn op_stack_size_influence(&self) -> i32

pub fn is_u32_instruction(&self) -> bool

Indicates whether the instruction operates on base field elements that are also u32s.

impl AnInstruction<BFieldElement>

pub fn arg(&self) -> Option<BFieldElement>

Get the argument of the instruction, if it has one.

pub fn change_arg( self, new_arg: BFieldElement, ) -> Result<Self, InstructionError>

Change the argument of the instruction, if it has one. Returns an Err if the instruction does not have an argument or if the argument is out of range.

Trait Implementations

impl<'arbitrary, Dest: PartialEq + Default + Arbitrary<'arbitrary>> Arbitrary<'arbitrary> for AnInstruction<Dest>

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<Dest: Clone + PartialEq + Default> Clone for AnInstruction<Dest>

fn clone(&self) -> AnInstruction<Dest>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Dest: Debug + PartialEq + Default> Debug for AnInstruction<Dest>

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

Formats the value using the given formatter.

impl<'de, Dest> Deserialize<'de> for AnInstruction<Dest>

where Dest: Deserialize<'de> + PartialEq + Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Dest: Display + PartialEq + Default> Display for AnInstruction<Dest>

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

Formats the value using the given formatter.

impl<Dest: PartialEq + Default> EnumCount for AnInstruction<Dest>

const COUNT: usize = 46usize

impl<Dest: PartialEq + Default + GetSize> GetSize for AnInstruction<Dest>

fn get_heap_size(&self) -> usize

Determines how many bytes this object occupies inside the heap.

fn get_stack_size() -> usize

Determines how may bytes this object occupies inside the stack.

fn get_size(&self) -> usize

Determines the total size of the object.

impl<Dest: Hash + PartialEq + Default> Hash for AnInstruction<Dest>

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<Dest: PartialEq + Default> IntoEnumIterator for AnInstruction<Dest>

type Iterator = AnInstructionIter<Dest>

fn iter() -> AnInstructionIter<Dest>

impl<Dest: PartialEq + PartialEq + Default> PartialEq for AnInstruction<Dest>

fn eq(&self, other: &AnInstruction<Dest>) -> 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<Dest> Serialize for AnInstruction<Dest>

where Dest: Serialize + PartialEq + Default,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Dest: Copy + PartialEq + Default> Copy for AnInstruction<Dest>

impl<Dest: Eq + PartialEq + Default> Eq for AnInstruction<Dest>

impl<Dest: PartialEq + Default> StructuralPartialEq for AnInstruction<Dest>