Enum sp1_recursion_compiler::asm::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),
    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),
    LoadE(i32, i32, i32, F, F),
    LoadEI(i32, i32, F, F, F),
    StoreE(i32, i32, i32, F, F),
    StoreEI(i32, i32, F, F, F),
    AddE(i32, i32, i32),
    AddEI(i32, i32, EF),
    SubE(i32, i32, i32),
    SubEI(i32, i32, EF),
    SubEIN(i32, EF, i32),
    MulE(i32, i32, i32),
    MulEI(i32, i32, EF),
    DivE(i32, i32, i32),
    DivEI(i32, i32, EF),
    DivEIN(i32, EF, i32),
    Jal(i32, F, F),
    JalR(i32, i32, i32),
    Bne(F, i32, i32),
    BneInc(F, i32, i32),
    BneI(F, i32, F),
    BneIInc(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),
    HintBits(i32, i32),
    Poseidon2Permute(i32, i32),
    Poseidon2Compress(i32, i32, i32),
    Poseidon2Absorb(i32, i32, i32),
    Poseidon2Finalize(i32, i32),
    PrintV(i32),
    PrintF(i32),
    PrintE(i32),
    HintExt2Felt(i32, i32),
    HintLen(i32),
    Hint(i32),
    FriFold(i32, i32),
    Commit(i32, i32),
    RegisterPublicValue(i32),
    LessThan(i32, i32, i32),
    CycleTracker(String),
    ExpReverseBitsLen(i32, i32, i32),
}

Variants

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

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

Load a value from the address stored at src(fp) into dstfp).

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

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

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

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

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

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.

LoadE(i32, i32, i32, F, F)

Load an ext value (dst, src, index, offset, size).

Load a value from the address stored at src(fp) into dst(fp).

LoadEI(i32, i32, F, F, F)

StoreE(i32, i32, i32, F, F)

Store an ext value (val, addr, index, offset, size).

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

StoreEI(i32, i32, F, F, F)

AddE(i32, i32, i32)

Add extension, dst = lhs + rhs.

AddEI(i32, i32, EF)

Add immediate extension, dst = lhs + rhs.

SubE(i32, i32, i32)

Subtract extension, dst = lhs - rhs.

SubEI(i32, i32, EF)

Subtract immediate extension, dst = lhs - rhs.

SubEIN(i32, EF, i32)

Subtract value from immediate extension, dst = lhs - rhs.

MulE(i32, i32, i32)

Multiply extension, dst = lhs * rhs.

MulEI(i32, i32, EF)

Multiply immediate extension.

DivE(i32, i32, i32)

Divide extension, dst = lhs / rhs.

DivEI(i32, i32, EF)

Divide immediate extension, dst = lhs / rhs.

DivEIN(i32, EF, i32)

Divide value from immediate extension, dst = lhs / rhs.

Jal(i32, F, F)

Jump and link.

JalR(i32, i32, i32)

Jump and link value.

Bne(F, i32, i32)

Branch not equal.

BneInc(F, i32, i32)

Branch not equal increment c by 1.

BneI(F, i32, F)

Branch not equal immediate.

BneIInc(F, i32, F)

Branch not equal immediate and increment c by 1.

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)

HintBits(i32, i32)

HintBits(dst, src).

Decompose the field element src into bits and write them to the array starting at the address stored at dst.

Poseidon2Permute(i32, i32)

Perform a permutation of the Poseidon2 hash function on the array specified by the ptr.

Poseidon2Compress(i32, i32, i32)

Perform a Poseidon2 compress.

Poseidon2Absorb(i32, i32, i32)

Performs a Posedion2 absorb.

Poseidon2Finalize(i32, i32)

Performs a Poseidon2 finalize.

PrintV(i32)

Print a variable.

PrintF(i32)

Print a felt.

PrintE(i32)

Print an extension element.

HintExt2Felt(i32, i32)

Convert an extension element to field elements.

HintLen(i32)

Hint the lenght of the next vector of blocks.

Hint(i32)

Hint a vector of blocks.

FriFold(i32, i32)

FRIFold(m, input).

Commit(i32, i32)

Commit(val, index).

RegisterPublicValue(i32)

RegisterPublicValue(val).

LessThan(i32, i32, i32)

CycleTracker(String)

ExpReverseBitsLen(i32, i32, i32)

ExpReverseBitsLen instruction: (mathematical description) given x, exp, len, bit-reverse the last len bits of exp and raise x to the power of the resulting value. The arguments are a pointer to the addresss at which x is located (will be written to with the result), a pointer to the address containing the bits of exp stored as a little-endian bit array, and len.

Implementations

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

pub fn j(label: F) -> Self

pub fn to_machine( self, pc: usize, label_to_pc: &BTreeMap<F, usize>, ) -> Instruction<F>

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.