Enum sway_ir::instruction::Instruction

pub enum Instruction {
    AsmBlock(AsmBlock, Vec<AsmArg>),
    UnaryOp {
        op: UnaryOpKind,
        arg: Value,
    },
    BinaryOp {
        op: BinaryOpKind,
        arg1: Value,
        arg2: Value,
    },
    BitCast(Value, Type),
    Branch(BranchToWithArgs),
    Call(Function, Vec<Value>),
    CastPtr(Value, Type),
    Cmp(Predicate, Value, Value),
    ConditionalBranch {
        cond_value: Value,
        true_block: BranchToWithArgs,
        false_block: BranchToWithArgs,
    },
    ContractCall {
        return_type: Type,
        name: String,
        params: Value,
        coins: Value,
        asset_id: Value,
        gas: Value,
    },
    FuelVm(FuelVmInstruction),
    GetLocal(LocalVar),
    GetElemPtr {
        base: Value,
        elem_ptr_ty: Type,
        indices: Vec<Value>,
    },
    IntToPtr(Value, Type),
    Load(Value),
    MemCopyBytes {
        dst_val_ptr: Value,
        src_val_ptr: Value,
        byte_len: u64,
    },
    MemCopyVal {
        dst_val_ptr: Value,
        src_val_ptr: Value,
    },
    Nop,
    PtrToInt(Value, Type),
    Ret(Value, Type),
    Store {
        dst_val_ptr: Value,
        stored_val: Value,
    },
}

Variants

AsmBlock(AsmBlock, Vec<AsmArg>)

An opaque list of ASM instructions passed directly to codegen.

UnaryOp

Fields

op: UnaryOpKind

arg: Value

Unary arithmetic operations

BinaryOp

Fields

op: BinaryOpKind

arg1: Value

arg2: Value

Binary arithmetic operations

BitCast(Value, Type)

Cast the type of a value without changing its actual content.

Branch(BranchToWithArgs)

An unconditional jump.

Call(Function, Vec<Value>)

A function call with a list of arguments.

CastPtr(Value, Type)

Cast a value’s type from one pointer to another.

Cmp(Predicate, Value, Value)

Comparison between two values using various comparators and returning a boolean.

ConditionalBranch

Fields

cond_value: Value

true_block: BranchToWithArgs

false_block: BranchToWithArgs

A conditional jump with the boolean condition value and true or false destinations.

ContractCall

Fields

return_type: Type

name: String

params: Value

coins: Value

asset_id: Value

gas: Value

A contract call with a list of arguments

FuelVm(FuelVmInstruction)

Umbrella instruction variant for FuelVM-specific instructions

GetLocal(LocalVar)

Return a local variable.

GetElemPtr

Fields

base: Value

elem_ptr_ty: Type

indices: Vec<Value>

Translate a pointer from a base to a nested element in an aggregate type.

IntToPtr(Value, Type)

Re-interpret an integer value as pointer of some type

Load(Value)

Read a value from a memory pointer.

MemCopyBytes

Fields

dst_val_ptr: Value

src_val_ptr: Value

byte_len: u64

Copy a specified number of bytes between pointers.

MemCopyVal

Fields

dst_val_ptr: Value

src_val_ptr: Value

Copy a value from one pointer to another.

Nop

No-op, handy as a placeholder instruction.

PtrToInt(Value, Type)

Cast a pointer to an integer.

Ret(Value, Type)

Return from a function.

Store

Fields

dst_val_ptr: Value

stored_val: Value

Write a value to a memory pointer.

Implementations

impl Instruction

pub fn get_type(&self, context: &Context<'_>) -> Option<Type>

Some Instructions can return a value, but for some a return value doesn’t make sense.

Those which perform side effects such as writing to memory and also terminators such as Ret do not have a type.

pub fn get_operands(&self) -> Vec<Value>

pub fn replace_values(&mut self, replace_map: &FxHashMap<Value, Value>)

Replace old_val with new_val if it is referenced by this instruction’s arguments.

pub fn may_have_side_effect(&self) -> bool

pub fn is_terminator(&self) -> bool

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

fn fmt_with_context<'a, 'c>( &'a self, formatter: &mut Formatter<'_>, context: &'c Context<'_> ) -> Result

fn with_context<'a, 'c, 'eng>( &'a self, context: &'c Context<'eng> ) -> WithContext<'a, 'c, 'eng, Self>