Struct PhiNode 

pub struct PhiNode { /* private fields */ }

A phi node that merges values from multiple control flow predecessors.

Placed at the beginning of basic blocks with multiple predecessors. Each phi node has one PhiOperand per predecessor, linking the predecessor block to the SSA variable providing the value along that edge.

Invariants

• Each phi has at most one operand per predecessor (enforced by set_operand)
• The result variable is defined by this phi node at the block entry
• Phi nodes appear before all regular instructions in a block

Examples

use analyssa::ir::{phi::{PhiNode, PhiOperand}, variable::{SsaVarId, VariableOrigin}};

let v1 = SsaVarId::from_index(0);
let v2 = SsaVarId::from_index(1);
let result = SsaVarId::from_index(2);
let mut phi = PhiNode::new(result, VariableOrigin::Local(0));
phi.add_operand(PhiOperand::new(v1, 1));
phi.add_operand(PhiOperand::new(v2, 2));
assert_eq!(phi.result(), result);
assert_eq!(phi.operand_count(), 2);

Implementations

impl PhiNode

pub fn new(result: SsaVarId, origin: VariableOrigin) -> PhiNode

Creates a new phi node for the given variable origin.

The phi node is created with no operands - they must be added during SSA construction as predecessor blocks are processed.

Arguments

• result - The SSA variable that this phi node defines
• origin - The original variable (Argument or Local) this phi merges

pub fn with_capacity( result: SsaVarId, origin: VariableOrigin, predecessor_count: usize, ) -> PhiNode

Creates a new phi node with pre-allocated operand capacity.

Use this when the number of predecessors is known in advance to avoid reallocations.

Arguments

• result - The SSA variable that this phi node defines
• origin - The original variable this phi merges
• predecessor_count - Expected number of predecessor blocks

pub const fn result(&self) -> SsaVarId

Returns the SSA variable defined by this phi node.

pub const fn origin(&self) -> VariableOrigin

Returns the original variable origin this phi merges.

pub fn set_result(&mut self, var: SsaVarId)

Sets the SSA variable defined by this phi node.

Used during SSA construction when renaming variables.

pub fn operands(&self) -> &[PhiOperand]

Returns the operands of this phi node.

pub fn operands_mut(&mut self) -> &mut Vec<PhiOperand>

Returns a mutable reference to the operands.

pub fn add_operand(&mut self, operand: PhiOperand)

Adds an operand to this phi node.

Unchecked: this does not verify that the operand’s predecessor is a real CFG predecessor, nor that no operand already names it. A phi with two operands on one edge has no defined meaning — Self::operand_from returns the first and discards the rest, while SCCP meets them all and yields Bottom — and the verifier reports it as VerifierError::DuplicatePhiOperand. Callers redirecting an existing edge should use SsaEditor::replace_phi_predecessor, which reconciles the collision instead of creating one.

Arguments

• operand - The phi operand to add

pub fn operand_count(&self) -> usize

Returns the number of operands.

pub fn is_empty(&self) -> bool

Returns true if this phi node has no operands.

A phi node with no operands is incomplete and should not appear in a fully-constructed SSA form.

pub fn operand_from(&self, predecessor: usize) -> Option<&PhiOperand>

Finds the operand coming from the specified predecessor block.

Arguments

• predecessor - The block index to look up

Returns

The phi operand if found, or None if no operand comes from that predecessor.

pub fn used_variables(&self) -> impl Iterator<Item = SsaVarId>

Returns all the SSA variables used by this phi node.

This is useful for building def-use chains and liveness analysis.

pub fn retain_operands<F>(&mut self, pred: F)

where F: Fn(usize) -> bool,

Retains only operands whose predecessor satisfies the predicate.

pub fn set_origin(&mut self, origin: VariableOrigin)

Sets the origin of this phi node.

This is used during local variable optimization to update indices after unused locals are removed.

pub fn set_operand(&mut self, predecessor: usize, value: SsaVarId)

Sets the operand value for a specific predecessor.

If an operand from that predecessor already exists, it is updated. Otherwise, a new operand is added.

Arguments

• predecessor - The predecessor block index
• value - The SSA variable value from that predecessor

Trait Implementations

impl Clone for PhiNode

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

Overwrites self from source, reusing the existing operands allocation.

Hand-written for the same reason as SsaFunction::clone_from: the derived Clone supplies only the default clone_from (*self = source.clone()), which drops and reallocates the operand vector on every call. Specializing here lets a whole-function snapshot’s capacity reuse reach each phi’s operand list rather than stopping at the owning block’s phi_nodes spine.

The exhaustive destructure is deliberate: adding a field makes this fail to compile rather than silently producing a stale-in-one-field clone.

fn clone(&self) -> PhiNode

Returns a duplicate of the value.

impl Debug for PhiNode

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

Formats the value using the given formatter.

impl Display for PhiNode

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

Formats the value using the given formatter.