Enum midenc_hir::Instruction

pub enum Instruction {
    GlobalValue(GlobalValueOp),
    LocalVar(LocalVarOp),
    BinaryOp(BinaryOp),
    BinaryOpImm(BinaryOpImm),
    UnaryOp(UnaryOp),
    UnaryOpImm(UnaryOpImm),
    Call(Call),
    Br(Br),
    CondBr(CondBr),
    Switch(Switch),
    Ret(Ret),
    RetImm(RetImm),
    Load(LoadOp),
    PrimOp(PrimOp),
    PrimOpImm(PrimOpImm),
    Test(Test),
    InlineAsm(InlineAsm),
}

Represents the type of instruction associated with a particular opcode

Variants

GlobalValue(GlobalValueOp)

LocalVar(LocalVarOp)

BinaryOp(BinaryOp)

BinaryOpImm(BinaryOpImm)

UnaryOp(UnaryOp)

UnaryOpImm(UnaryOpImm)

Call(Call)

Br(Br)

CondBr(CondBr)

Switch(Switch)

Ret(Ret)

RetImm(RetImm)

Load(LoadOp)

PrimOp(PrimOp)

PrimOpImm(PrimOpImm)

Test(Test)

InlineAsm(InlineAsm)

Implementations

impl Instruction

pub fn deep_clone(&self, value_lists: &mut ValueListPool) -> Self

pub fn opcode(&self) -> Opcode

pub fn has_side_effects(&self) -> bool

Returns true if this instruction has side effects, or may have side effects

Side effects are defined as control flow, writing memory, trapping execution, I/O, etc.

pub fn is_binary(&self) -> bool

Returns true if this instruction is a binary operator requiring two operands

NOTE: Binary operators with immediate operands are not considered binary for this purpose, as they only require a single operand to be provided to the instruction, the immediate being the other one provided by the instruction itself.

pub fn is_commutative(&self) -> bool

Returns true if this instruction is a binary operator whose operands may appear in any order.

pub fn overflow(&self) -> Option<Overflow>

Get the Overflow flag for this instruction, if applicable

pub fn arguments<'a>(&'a self, pool: &'a ValueListPool) -> &[Value]

pub fn arguments_mut<'a>( &'a mut self, pool: &'a mut ValueListPool, ) -> &mut [Value]

pub fn analyze_branch<'a>(&'a self, pool: &'a ValueListPool) -> BranchInfo<'a>

pub fn analyze_call<'a>(&'a self, pool: &'a ValueListPool) -> CallInfo<'a>

Trait Implementations

impl AsMut<Instruction> for InstNode

fn as_mut(&mut self) -> &mut Instruction

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Instruction> for InstNode

fn as_ref(&self) -> &Instruction

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for Instruction

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

Formats the value using the given formatter.