Enum Instruction

source

pub enum Instruction {
Show 111 variants
    ADD(ADD),
    AND(AND),
    DIV(DIV),
    EQ(EQ),
    EXP(EXP),
    GT(GT),
    LT(LT),
    MLOG(MLOG),
    MROO(MROO),
    MOD(MOD),
    MOVE(MOVE),
    MUL(MUL),
    NOT(NOT),
    OR(OR),
    SLL(SLL),
    SRL(SRL),
    SUB(SUB),
    XOR(XOR),
    MLDV(MLDV),
    RET(RET),
    RETD(RETD),
    ALOC(ALOC),
    MCL(MCL),
    MCP(MCP),
    MEQ(MEQ),
    BHSH(BHSH),
    BHEI(BHEI),
    BURN(BURN),
    CALL(CALL),
    CCP(CCP),
    CROO(CROO),
    CSIZ(CSIZ),
    CB(CB),
    LDC(LDC),
    LOG(LOG),
    LOGD(LOGD),
    MINT(MINT),
    RVRT(RVRT),
    SCWQ(SCWQ),
    SRW(SRW),
    SRWQ(SRWQ),
    SWW(SWW),
    SWWQ(SWWQ),
    TR(TR),
    TRO(TRO),
    ECK1(ECK1),
    ECR1(ECR1),
    ED19(ED19),
    K256(K256),
    S256(S256),
    TIME(TIME),
    NOOP(NOOP),
    FLAG(FLAG),
    BAL(BAL),
    JMP(JMP),
    JNE(JNE),
    SMO(SMO),
    ADDI(ADDI),
    ANDI(ANDI),
    DIVI(DIVI),
    EXPI(EXPI),
    MODI(MODI),
    MULI(MULI),
    ORI(ORI),
    SLLI(SLLI),
    SRLI(SRLI),
    SUBI(SUBI),
    XORI(XORI),
    JNEI(JNEI),
    LB(LB),
    LW(LW),
    SB(SB),
    SW(SW),
    MCPI(MCPI),
    GTF(GTF),
    MCLI(MCLI),
    GM(GM),
    MOVI(MOVI),
    JNZI(JNZI),
    JMPF(JMPF),
    JMPB(JMPB),
    JNZF(JNZF),
    JNZB(JNZB),
    JNEF(JNEF),
    JNEB(JNEB),
    JI(JI),
    CFEI(CFEI),
    CFSI(CFSI),
    CFE(CFE),
    CFS(CFS),
    PSHL(PSHL),
    PSHH(PSHH),
    POPL(POPL),
    POPH(POPH),
    WDCM(WDCM),
    WQCM(WQCM),
    WDOP(WDOP),
    WQOP(WQOP),
    WDML(WDML),
    WQML(WQML),
    WDDV(WDDV),
    WQDV(WQDV),
    WDMD(WDMD),
    WQMD(WQMD),
    WDAM(WDAM),
    WQAM(WQAM),
    WDMM(WDMM),
    WQMM(WQMM),
    ECAL(ECAL),
    BSIZ(BSIZ),
    BLDD(BLDD),
}

Expand description

Representation of a single instruction for the interpreter.

The opcode is represented in the tag (variant), or may be retrieved in the form of an Opcode byte using the opcode method.

The register and immediate data associated with the instruction is represented within an inner unit type wrapper around the 3 remaining bytes.

Variants§

§

ADD(ADD)

Adds two registers.

§

AND(AND)

Bitwise ANDs two registers.

§

DIV(DIV)

Divides two registers.

§

EQ(EQ)

Compares two registers for equality.

§

EXP(EXP)

Raises one register to the power of another.

§

GT(GT)

Compares two registers for greater-than.

§

LT(LT)

Compares two registers for less-than.

§

MLOG(MLOG)

The integer logarithm of a register.

§

MROO(MROO)

The integer root of a register.

§

MOD(MOD)

Modulo remainder of two registers.

§

MOVE(MOVE)

Copy from one register to another.

§

MUL(MUL)

Multiplies two registers.

§

NOT(NOT)

Bitwise NOT a register.

§

OR(OR)

Bitwise ORs two registers.

§

SLL(SLL)

Left shifts a register by a register.

§

SRL(SRL)

Right shifts a register by a register.

§

SUB(SUB)

Subtracts two registers.

§

XOR(XOR)

Bitwise XORs two registers.

§

MLDV(MLDV)

Fused multiply-divide with arbitrary precision intermediate step.

§

RET(RET)

Return from context.

§

RETD(RETD)

Return from context with data.

§

ALOC(ALOC)

Allocate a number of bytes from the heap.

§

MCL(MCL)

Clear a variable number of bytes in memory.

§

MCP(MCP)

Copy a variable number of bytes in memory.

§

MEQ(MEQ)

Compare bytes in memory.

§

BHSH(BHSH)

Get block header hash for height.

§

BHEI(BHEI)

Get current block height.

§

BURN(BURN)

Burns amount coins of the asset ID created from sub_id for the current contract.

§

CALL(CALL)

Call a contract.

§

CCP(CCP)

Copy contract code for a contract.

§

CROO(CROO)

Get code root of a contract.

§

CSIZ(CSIZ)

Get code size of a contract.

§

CB(CB)

Get current block proposer’s address.

§

LDC(LDC)

Load code as executable either from contract, blob, or memory.

§

LOG(LOG)

Log an event.

§

LOGD(LOGD)

Log data.

§

MINT(MINT)

Mints amount coins of the asset ID created from sub_id for the current contract.

§

RVRT(RVRT)

Halt execution, reverting state changes and returning a value.

§

SCWQ(SCWQ)

Clear a series of slots from contract storage.

§

SRW(SRW)

Load a word from contract storage.

§

SRWQ(SRWQ)

Load a series of 32 byte slots from contract storage.

§

SWW(SWW)

Store a word in contract storage.

§

SWWQ(SWWQ)

Store a series of 32 byte slots in contract storage.

§

TR(TR)

Transfer coins to a contract unconditionally.

§

TRO(TRO)

Transfer coins to a variable output.

§

ECK1(ECK1)

The 64-byte public key (x, y) recovered from 64-byte signature on 32-byte message hash.

§

ECR1(ECR1)

The 64-byte Secp256r1 public key (x, y) recovered from 64-byte signature on 32-byte message hash.

§

ED19(ED19)

Verify ED25519 public key and signature match a message.

§

K256(K256)

The keccak-256 hash of a slice.

§

S256(S256)

The SHA-2-256 hash of a slice.

§

TIME(TIME)

Get timestamp of block at given height.

§

NOOP(NOOP)

Performs no operation.

§

FLAG(FLAG)

Set flag register to a register.

§

BAL(BAL)

Get the balance of contract of an asset ID.

§

JMP(JMP)

Dynamic jump.

§

JNE(JNE)

Conditional dynamic jump.

§

SMO(SMO)

Send a message to recipient address with call abi, coins, and output.

§

ADDI(ADDI)

Adds a register and an immediate value.

§

ANDI(ANDI)

Bitwise ANDs a register and an immediate value.

§

DIVI(DIVI)

Divides a register and an immediate value.

§

EXPI(EXPI)

Raises one register to the power of an immediate value.

§

MODI(MODI)

Modulo remainder of a register and an immediate value.

§

MULI(MULI)

Multiplies a register and an immediate value.

§

ORI(ORI)

Bitwise ORs a register and an immediate value.

§

SLLI(SLLI)

Left shifts a register by an immediate value.

§

SRLI(SRLI)

Right shifts a register by an immediate value.

§

SUBI(SUBI)

Subtracts a register and an immediate value.

§

XORI(XORI)

Bitwise XORs a register and an immediate value.

§

JNEI(JNEI)

Conditional jump.

§

LB(LB)

A byte is loaded from the specified address offset by an immediate value.

§

LW(LW)

A word is loaded from the specified address offset by an immediate value.

§

SB(SB)

Write the least significant byte of a register to memory.

§

SW(SW)

Write a register to memory.

§

MCPI(MCPI)

Copy an immediate number of bytes in memory.

§

GTF(GTF)

Get transaction fields.

§

MCLI(MCLI)

Clear an immediate number of bytes in memory.

§

GM(GM)

Get metadata from memory.

§

MOVI(MOVI)

Copy immediate value into a register

§

JNZI(JNZI)

Conditional jump against zero.

§

JMPF(JMPF)

Unconditional dynamic relative jump forwards, with a constant offset.

§

JMPB(JMPB)

Unconditional dynamic relative jump backwards, with a constant offset.

§

JNZF(JNZF)

Dynamic relative jump forwards, conditional against zero, with a constant offset.

§

JNZB(JNZB)

Dynamic relative jump backwards, conditional against zero, with a constant offset.

§

JNEF(JNEF)

Dynamic relative jump forwards, conditional on comparsion, with a constant offset.

§

JNEB(JNEB)

Dynamic relative jump backwards, conditional on comparsion, with a constant offset.

§

JI(JI)

Jump.

§

CFEI(CFEI)

Extend the current call frame’s stack by an immediate value.

§

CFSI(CFSI)

Shrink the current call frame’s stack by an immediate value.

§

CFE(CFE)

Extend the current call frame’s stack

§

CFS(CFS)

Shrink the current call frame’s stack

§

PSHL(PSHL)

Push a bitmask-selected set of registers in range 16..40 to the stack.

§

PSHH(PSHH)

Push a bitmask-selected set of registers in range 40..64 to the stack.

§

POPL(POPL)

Pop a bitmask-selected set of registers in range 16..40 to the stack.

§

POPH(POPH)

Pop a bitmask-selected set of registers in range 40..64 to the stack.

§

WDCM(WDCM)

Compare 128bit integers

§

WQCM(WQCM)

Compare 256bit integers

§

WDOP(WDOP)

Simple 128bit operations

§

WQOP(WQOP)

Simple 256bit operations

§

WDML(WDML)

Multiply 128bit

§

WQML(WQML)

Multiply 256bit

§

WDDV(WDDV)

Divide 128bit

§

WQDV(WQDV)

Divide 256bit

§

WDMD(WDMD)

Fused multiply-divide 128bit

§

WQMD(WQMD)

Fused multiply-divide 256bit

§

WDAM(WDAM)

AddMod 128bit

§

WQAM(WQAM)

AddMod 256bit

§

WDMM(WDMM)

MulMod 128bit

§

WQMM(WQMM)

MulMod 256bit

§

ECAL(ECAL)

Call external function

§

BSIZ(BSIZ)

Get blob size

§

BLDD(BLDD)

Load blob as data

Implementations§

source §

impl Instruction

source

pub fn opcode(&self) -> Opcode

This instruction’s opcode.

source

pub fn reg_ids(&self) -> [Option<RegId>; 4]

Unpacks all register IDs into a slice of options.

source §

impl Instruction

source

pub const SIZE: usize = 4usize

Size of an instruction in bytes

source

pub fn to_bytes(self) -> [u8; 4]

Convenience method for converting to bytes

Trait Implementations§

source §

impl Clone for Instruction

source §

fn clone(&self) -> Instruction

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

source §

impl Debug for Instruction

source §

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

Formats the value using the given formatter. Read more

source §

impl<'de> Deserialize<'de> for Instruction

source §

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

source §