Struct midenc_hir::InstNode

pub struct InstNode {
    pub link: LinkedListLink,
    pub key: Inst,
    pub block: Block,
    pub data: Span<Instruction>,
}

Represents the data associated with an Inst.

Specifically, this represents a leaf node in the control flow graph of a function, i.e. it links a specific instruction in to the sequence of instructions belonging to a specific block.

Fields

link: LinkedListLink

key: Inst

block: Block

data: Span<Instruction>

Implementations

impl InstNode

pub fn new(key: Inst, block: Block, data: Span<Instruction>) -> Self

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

pub fn replace(&mut self, data: Span<Instruction>)

Methods from Deref<Target = 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 InstNode

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

Formats the value using the given formatter.

impl Deref for InstNode

type Target = Instruction

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for InstNode

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Spanned for InstNode

fn span(&self) -> SourceSpan