Struct InstructionRef 

pub struct InstructionRef<'str, 'ctx, R = ModuleView<'ctx, 'str>> {
    pub id: InstructionId,
    /* private fields */
}

Fields

id: InstructionId

Implementations

impl<'s, 'ctx: 's, 'str: 'ctx, R> InstructionRef<'str, 'ctx, R>

where R: QCodeView<'ctx, 'str>,

pub fn name(&'s self) -> Option<&'ctx str>

The name of this instruction’s output value

pub fn type_id(&'s self) -> TypeId

The TypeId of this instruction’s result value.

pub fn size(&'s self) -> usize

The size in bytes of the instruction’s output value

pub fn parent(&'s self) -> Option<BlockRef<'str, 'ctx, R>>

The basic block that this instruction belongs to, if any.

pub fn block(&'s self) -> Option<BlockRef<'str, 'ctx, R>>

pub fn function(&'s self) -> Option<FunctionRef<'str, 'ctx, R>>

The function that this instruction belongs to, if any.

pub fn mnemonic(&'s self) -> &'ctx Mnemonic

The mnemonic of the instruction

pub fn operands(&'s self) -> SmallVec<[ValueId; 2]>

The operands consumed by this instruction, as qualified ValueIds.

This is the func-qualifying, pass-facing operand accessor (stage 6a §11, option b): it is the routing target for the insn.mnemonic().args() call sites. Today it forwards MnemonicKind::args verbatim; once in-body operand storage flips to LocalValueId, only this body changes — it qualifies each local operand with the owning function (self.id.func), which a bare &Mnemonic cannot do — so every caller keeps seeing qualified ValueIds unchanged.

pub fn address(&'s self) -> Option<u64>

The address of the corresponding instruction

pub fn space(&'s self) -> Option<SpaceRef<'ctx>>

The address-space provenance for this instruction’s result, if any.

Returns Some only for instructions whose result type is a pointer to a known memory space (e.g. StackAddress).

pub fn memory_space(&'s self) -> Option<MemorySpaceId>

Qualified address-space provenance, including body-local temporary spaces that cannot be represented by SpaceRef.

pub fn opcode(&'s self) -> &'static str

The opcode for this instruction

pub fn is_terminator(&'s self) -> bool

Is this instruction a terminator (i.e. does it end a basic block)?

impl<'str, 'ctx, R> InstructionRef<'str, 'ctx, R>

pub fn new(view: R, id: InstructionId) -> Self

pub fn id(&self) -> ValueId

pub fn as_statement(&self) -> InstructionStatement<'_, 'str, 'ctx, R>

Format this instruction as a string, with the mnemonic and operands.

impl<'str, 'ctx> InstructionRef<'str, 'ctx>

pub fn from_id(ctx: &'ctx Context<'str>, id: InstructionId) -> Self

pub fn from_mnemonic( ctx: &'ctx mut Context<'str>, func: FunctionId, mnemonic: Mnemonic, size: usize, ) -> Self

Creates an instruction with a plain Int(size) result type, born into func’s instruction arena. The result is detached (parent == None) until a block appends it.

pub fn from_mnemonic_with_type( ctx: &'ctx mut Context<'str>, func: FunctionId, mnemonic: Mnemonic, type_id: TypeId, ) -> Self

Creates an instruction with an explicit TypeId, born into func.

Pass a StackAddress type id when the result is a stack-space pointer. Register-space provenance is silently demoted to Int (pointer arithmetic on registers is not meaningful).

pub fn from_mnemonic_with_space( ctx: &'ctx mut Context<'str>, func: FunctionId, mnemonic: Mnemonic, size: usize, _space: Option<SpaceId>, ) -> Self

Creates an instruction, deriving the result type from an optional space tag.

This is a migration shim that types the result as Int(size) regardless of the space tag. New code should use from_mnemonic_with_type directly.

Trait Implementations

impl<'str, 'ctx, R: Clone> Clone for InstructionRef<'str, 'ctx, R>

fn clone(&self) -> InstructionRef<'str, 'ctx, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'str, 'ctx, R: Copy> Copy for InstructionRef<'str, 'ctx, R>

impl<'str: 'ctx, 'ctx, R> Display for InstructionRef<'str, 'ctx, R>

where R: QCodeView<'ctx, 'str>,

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

Formats the value using the given formatter.

impl<'str, 'ctx, R> From<InstructionRef<'str, 'ctx, R>> for ValueRef<'str, 'ctx, R>

fn from(insn_ref: InstructionRef<'str, 'ctx, R>) -> Self

Converts to this type from the input type.

impl<'str: 'ctx, 'ctx, R> Named for InstructionRef<'str, 'ctx, R>

where R: QCodeView<'ctx, 'str>,

fn name(&self) -> Option<&str>

impl<'str: 'ctx, 'ctx, R> Value<'str, 'ctx> for InstructionRef<'str, 'ctx, R>

where R: QCodeView<'ctx, 'str>,

fn id(&self) -> ValueId

The context-unique identifier for this value.

fn size(&self) -> usize

The size of this value’s output in bytes, or 0 for non-data values (terminators, blocks, functions).

impl<'s, 'ctx: 's, 'str: 'ctx> WithCtx<'s, 'ctx, 'str> for InstructionRef<'str, 'ctx>

fn ctx(&'s self) -> &'ctx Context<'str>