Enum fuel_asm::Instruction

pub enum Instruction {
    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),
    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),
    ECR(ECR),
    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),
    JI(JI),
    CFEI(CFEI),
    CFSI(CFSI),
}

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.

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)

Burn coins of the current contract’s asset ID.

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 a contract’s code as executable.

LOG(LOG)

Log an event.

LOGD(LOGD)

Log data.

MINT(MINT)

Mint coins of the current contract’s asset ID.

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.

ECR(ECR)

The 64-byte public key (x, y) recovered from 64-byte signature on 32-byte 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.

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.

Implementations

impl Instruction

pub fn opcode(&self) -> Opcode

This instruction’s opcode.

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

Unpacks all register IDs into a slice of options.

impl Instruction

pub const SIZE: usize = 4usize

Size of an instruction in bytes

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

Convenience method for converting to bytes

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

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

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

Deserialize this value from the given Serde deserializer.

impl From<ADD> for Instruction

fn from(op: ADD) -> Self

Converts to this type from the input type.

impl From<ADDI> for Instruction

fn from(op: ADDI) -> Self

Converts to this type from the input type.

impl From<ALOC> for Instruction

fn from(op: ALOC) -> Self

Converts to this type from the input type.

impl From<AND> for Instruction

fn from(op: AND) -> Self

Converts to this type from the input type.

impl From<ANDI> for Instruction

fn from(op: ANDI) -> Self

Converts to this type from the input type.

impl From<BAL> for Instruction

fn from(op: BAL) -> Self

Converts to this type from the input type.

impl From<BHEI> for Instruction

fn from(op: BHEI) -> Self

Converts to this type from the input type.

impl From<BHSH> for Instruction

fn from(op: BHSH) -> Self

Converts to this type from the input type.

impl From<BURN> for Instruction

fn from(op: BURN) -> Self

Converts to this type from the input type.

impl From<CALL> for Instruction

fn from(op: CALL) -> Self

Converts to this type from the input type.

impl From<CB> for Instruction

fn from(op: CB) -> Self

Converts to this type from the input type.

impl From<CCP> for Instruction

fn from(op: CCP) -> Self

Converts to this type from the input type.

impl From<CFEI> for Instruction

fn from(op: CFEI) -> Self

Converts to this type from the input type.

impl From<CFSI> for Instruction

fn from(op: CFSI) -> Self

Converts to this type from the input type.

impl From<CROO> for Instruction

fn from(op: CROO) -> Self

Converts to this type from the input type.

impl From<CSIZ> for Instruction

fn from(op: CSIZ) -> Self

Converts to this type from the input type.

impl From<DIV> for Instruction

fn from(op: DIV) -> Self

Converts to this type from the input type.

impl From<DIVI> for Instruction

fn from(op: DIVI) -> Self

Converts to this type from the input type.

impl From<ECR> for Instruction

fn from(op: ECR) -> Self

Converts to this type from the input type.

impl From<EQ> for Instruction

fn from(op: EQ) -> Self

Converts to this type from the input type.

impl From<EXP> for Instruction

fn from(op: EXP) -> Self

Converts to this type from the input type.

impl From<EXPI> for Instruction

fn from(op: EXPI) -> Self

Converts to this type from the input type.

impl From<FLAG> for Instruction

fn from(op: FLAG) -> Self

Converts to this type from the input type.

impl From<GM> for Instruction

fn from(op: GM) -> Self

Converts to this type from the input type.

impl From<GT> for Instruction

fn from(op: GT) -> Self

Converts to this type from the input type.

impl From<GTF> for Instruction

fn from(op: GTF) -> Self

Converts to this type from the input type.

impl From<Instruction> for [u8; 4]

fn from(inst: Instruction) -> Self

Converts to this type from the input type.

impl From<Instruction> for RawInstruction

fn from(inst: Instruction) -> Self

Converts to this type from the input type.

impl From<JI> for Instruction

fn from(op: JI) -> Self

Converts to this type from the input type.

impl From<JMP> for Instruction

fn from(op: JMP) -> Self

Converts to this type from the input type.

impl From<JNE> for Instruction

fn from(op: JNE) -> Self

Converts to this type from the input type.

impl From<JNEI> for Instruction

fn from(op: JNEI) -> Self

Converts to this type from the input type.

impl From<JNZI> for Instruction

fn from(op: JNZI) -> Self

Converts to this type from the input type.

impl From<K256> for Instruction

fn from(op: K256) -> Self

Converts to this type from the input type.

impl From<LB> for Instruction

fn from(op: LB) -> Self

Converts to this type from the input type.

impl From<LDC> for Instruction

fn from(op: LDC) -> Self

Converts to this type from the input type.

impl From<LOG> for Instruction

fn from(op: LOG) -> Self

Converts to this type from the input type.

impl From<LOGD> for Instruction

fn from(op: LOGD) -> Self

Converts to this type from the input type.

impl From<LT> for Instruction

fn from(op: LT) -> Self

Converts to this type from the input type.

impl From<LW> for Instruction

fn from(op: LW) -> Self

Converts to this type from the input type.

impl From<MCL> for Instruction

fn from(op: MCL) -> Self

Converts to this type from the input type.

impl From<MCLI> for Instruction

fn from(op: MCLI) -> Self

Converts to this type from the input type.

impl From<MCP> for Instruction

fn from(op: MCP) -> Self

Converts to this type from the input type.

impl From<MCPI> for Instruction

fn from(op: MCPI) -> Self

Converts to this type from the input type.

impl From<MEQ> for Instruction

fn from(op: MEQ) -> Self

Converts to this type from the input type.

impl From<MINT> for Instruction

fn from(op: MINT) -> Self

Converts to this type from the input type.

impl From<MLOG> for Instruction

fn from(op: MLOG) -> Self

Converts to this type from the input type.

impl From<MOD> for Instruction

fn from(op: MOD) -> Self

Converts to this type from the input type.

impl From<MODI> for Instruction

fn from(op: MODI) -> Self

Converts to this type from the input type.

impl From<MOVE> for Instruction

fn from(op: MOVE) -> Self

Converts to this type from the input type.

impl From<MOVI> for Instruction

fn from(op: MOVI) -> Self

Converts to this type from the input type.

impl From<MROO> for Instruction

fn from(op: MROO) -> Self

Converts to this type from the input type.

impl From<MUL> for Instruction

fn from(op: MUL) -> Self

Converts to this type from the input type.

impl From<MULI> for Instruction

fn from(op: MULI) -> Self

Converts to this type from the input type.

impl From<NOOP> for Instruction

fn from(op: NOOP) -> Self

Converts to this type from the input type.

impl From<NOT> for Instruction

fn from(op: NOT) -> Self

Converts to this type from the input type.

impl From<OR> for Instruction

fn from(op: OR) -> Self

Converts to this type from the input type.

impl From<ORI> for Instruction

fn from(op: ORI) -> Self

Converts to this type from the input type.

impl From<RET> for Instruction

fn from(op: RET) -> Self

Converts to this type from the input type.

impl From<RETD> for Instruction

fn from(op: RETD) -> Self

Converts to this type from the input type.

impl From<RVRT> for Instruction

fn from(op: RVRT) -> Self

Converts to this type from the input type.

impl From<S256> for Instruction

fn from(op: S256) -> Self

Converts to this type from the input type.

impl From<SB> for Instruction

fn from(op: SB) -> Self

Converts to this type from the input type.

impl From<SCWQ> for Instruction

fn from(op: SCWQ) -> Self

Converts to this type from the input type.

impl From<SLL> for Instruction

fn from(op: SLL) -> Self

Converts to this type from the input type.

impl From<SLLI> for Instruction

fn from(op: SLLI) -> Self

Converts to this type from the input type.

impl From<SMO> for Instruction

fn from(op: SMO) -> Self

Converts to this type from the input type.

impl From<SRL> for Instruction

fn from(op: SRL) -> Self

Converts to this type from the input type.

impl From<SRLI> for Instruction

fn from(op: SRLI) -> Self

Converts to this type from the input type.

impl From<SRW> for Instruction

fn from(op: SRW) -> Self

Converts to this type from the input type.

impl From<SRWQ> for Instruction

fn from(op: SRWQ) -> Self

Converts to this type from the input type.

impl From<SUB> for Instruction

fn from(op: SUB) -> Self

Converts to this type from the input type.

impl From<SUBI> for Instruction

fn from(op: SUBI) -> Self

Converts to this type from the input type.

impl From<SW> for Instruction

fn from(op: SW) -> Self

Converts to this type from the input type.

impl From<SWW> for Instruction

fn from(op: SWW) -> Self

Converts to this type from the input type.

impl From<SWWQ> for Instruction

fn from(op: SWWQ) -> Self

Converts to this type from the input type.

impl From<TIME> for Instruction

fn from(op: TIME) -> Self

Converts to this type from the input type.

impl From<TR> for Instruction

fn from(op: TR) -> Self

Converts to this type from the input type.

impl From<TRO> for Instruction

fn from(op: TRO) -> Self

Converts to this type from the input type.

impl From<XOR> for Instruction

fn from(op: XOR) -> Self

Converts to this type from the input type.

impl From<XORI> for Instruction

fn from(op: XORI) -> Self

Converts to this type from the input type.

impl FromIterator<Instruction> for Vec<u32>

Available on crate feature std only.

fn from_iter<I: IntoIterator<Item = Instruction>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Instruction> for Vec<u8>

Available on crate feature std only.

fn from_iter<I: IntoIterator<Item = Instruction>>(iter: I) -> Self

Creates a value from an iterator.

impl Hash for Instruction

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 PartialEq<Instruction> for Instruction

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Instruction

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

Serialize this value into the given Serde serializer.

impl TryFrom<[u8; 4]> for Instruction

type Error = InvalidOpcode

The type returned in the event of a conversion error.

fn try_from([op, a, b, c]: [u8; 4]) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u32> for Instruction

type Error = InvalidOpcode

The type returned in the event of a conversion error.

fn try_from(u: RawInstruction) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Instruction

impl Eq for Instruction

impl StructuralEq for Instruction

impl StructuralPartialEq for Instruction