Enum AsmInstruction

pub enum AsmInstruction<F, EF> {
    LoadF(i32, i32, i32, F, F),
    LoadFI(i32, i32, F, F, F),
    StoreF(i32, i32, i32, F, F),
    StoreFI(i32, i32, F, F, F),
    ImmF(i32, F),
    CopyF(i32, i32),
    AddF(i32, i32, i32),
    AddFI(i32, i32, F),
    SubF(i32, i32, i32),
    SubFI(i32, i32, F),
    SubFIN(i32, F, i32),
    MulF(i32, i32, i32),
    MulFI(i32, i32, F),
    DivF(i32, i32, i32),
    DivFI(i32, i32, F),
    DivFIN(i32, F, i32),
    AddE(i32, i32, i32),
    SubE(i32, i32, i32),
    MulE(i32, i32, i32),
    DivE(i32, i32, i32),
    Jump(i32, F),
    Bne(F, i32, i32),
    BneI(F, i32, F),
    Beq(F, i32, i32),
    BeqI(F, i32, F),
    BneE(F, i32, i32),
    BneEI(F, i32, EF),
    BeqE(F, i32, i32),
    BeqEI(F, i32, EF),
    Trap,
    Halt,
    Break(F),
    Poseidon2Permute(i32, i32),
    Poseidon2Compress(i32, i32, i32),
    FriReducedOpening(i32, i32, i32, i32, i32, i32),
    PrintV(i32),
    PrintF(i32),
    PrintE(i32),
    HintInputVec(),
    HintBits(i32, u32),
    StoreHintWordI(i32, F),
    Publish(i32, i32),
    CycleTrackerStart(),
    CycleTrackerEnd(),
}

Variants

LoadF(i32, i32, i32, F, F)

Load word (dst, src, var_index, size, offset).

Load a value from the address stored at src(fp) into dst(fp) with given index and offset.

LoadFI(i32, i32, F, F, F)

StoreF(i32, i32, i32, F, F)

Store word (val, addr, var_index, size, offset)

Store a value from val(fp) into the address stored at addr(fp) with given index and offset.

StoreFI(i32, i32, F, F, F)

ImmF(i32, F)

Set dst = imm.

CopyF(i32, i32)

Copy, dst = src.

AddF(i32, i32, i32)

Add, dst = lhs + rhs.

AddFI(i32, i32, F)

Add immediate, dst = lhs + rhs.

SubF(i32, i32, i32)

Subtract, dst = lhs - rhs.

SubFI(i32, i32, F)

Subtract immediate, dst = lhs - rhs.

SubFIN(i32, F, i32)

Subtract value from immediate, dst = lhs - rhs.

MulF(i32, i32, i32)

Multiply, dst = lhs * rhs.

MulFI(i32, i32, F)

Multiply immediate.

DivF(i32, i32, i32)

Divide, dst = lhs / rhs.

DivFI(i32, i32, F)

Divide immediate, dst = lhs / rhs.

DivFIN(i32, F, i32)

Divide value from immediate, dst = lhs / rhs.

AddE(i32, i32, i32)

Add extension, dst = lhs + rhs.

SubE(i32, i32, i32)

Subtract extension, dst = lhs - rhs.

MulE(i32, i32, i32)

Multiply extension, dst = lhs * rhs.

DivE(i32, i32, i32)

Divide extension, dst = lhs / rhs.

Jump(i32, F)

Jump.

Bne(F, i32, i32)

Branch not equal.

BneI(F, i32, F)

Branch not equal immediate.

Beq(F, i32, i32)

Branch equal.

BeqI(F, i32, F)

Branch equal immediate.

BneE(F, i32, i32)

Branch not equal extension.

BneEI(F, i32, EF)

Branch not equal immediate extension.

BeqE(F, i32, i32)

Branch equal extension.

BeqEI(F, i32, EF)

Branch equal immediate extension.

Trap

Trap.

Halt

Halt.

Break(F)

Break(label)

Poseidon2Permute(i32, i32)

Perform a Poseidon2 permutation on state starting at address lhs and store new state at rhs. (a, b) are pointers to (lhs, rhs).

Poseidon2Compress(i32, i32, i32)

Perform 2-to-1 cryptographic compression using Poseidon2. (a, b, c) are memory pointers to (dst, lhs, rhs)

FriReducedOpening(i32, i32, i32, i32, i32, i32)

(a, b, res, len, alpha, alpha_pow)

PrintV(i32)

Print a variable.

PrintF(i32)

Print a felt.

PrintE(i32)

Print an extension element.

HintInputVec()

Add next input vector to hint stream.

HintBits(i32, u32)

HintBits(src, len).

Bit decompose the field element at pointer src to the first len little endian bits and add to hint stream.

StoreHintWordI(i32, F)

Stores the next hint stream word into value stored at addr + value.

Publish(i32, i32)

Publish(val, index).

CycleTrackerStart()

CycleTrackerEnd()

Implementations

impl<F: PrimeField32, EF: ExtensionField<F>> AsmInstruction<F, EF>

pub fn j(label: F) -> Self

pub fn fmt(&self, labels: &BTreeMap<F, String>, f: &mut Formatter<'_>) -> Result

Trait Implementations

impl<F: Clone, EF: Clone> Clone for AsmInstruction<F, EF>

fn clone(&self) -> AsmInstruction<F, EF>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug, EF: Debug> Debug for AsmInstruction<F, EF>

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

Formats the value using the given formatter.