Struct LiveVariables 

pub struct LiveVariables { /* private fields */ }

Data flow analysis types.

Generic data flow analysis framework including reaching definitions, live variables, and constant propagation. Provides lattice-based analysis with configurable direction. Live variable analysis.

Computes which variables are live at each program point. A variable is live if its value may be used on some path from that point forward.

Example

use analyssa::{
    analysis::{
        dataflow::{DataFlowSolver, LiveVariables},
        SsaCfg,
    },
    ir::SsaVarId,
    testing,
};

// Block 1 defines the loop counter phi; block 2 returns it.
let ssa = testing::loop_counter_fixture();
let graph = SsaCfg::from_ssa(&ssa);

let analysis = LiveVariables::new(&ssa);
let solver = DataFlowSolver::new(analysis);
let results = solver.solve(&ssa, &graph);

// The counter is live on entry to block 2, because block 2 returns it.
let counter = SsaVarId::from_index(1);
let live_in = results.in_state(2).unwrap();
assert!(live_in.variables().any(|var| var == counter));

// Nothing is live after the return terminator.
assert_eq!(results.out_state(2).unwrap().variables().count(), 0);

Implementations

impl LiveVariables

pub fn new<T>(ssa: &SsaFunction<T>) -> LiveVariables

where T: Target,

Creates a new live variables analysis for the given SSA function.

pub fn live_out( &self, block: usize, out_state: &LivenessResult, ) -> LivenessResult

Returns the values live on block’s outgoing edges.

Use this rather than the solver’s raw out_state. out_state is the meet of the successors’ IN sets, and a value consumed only by a successor’s phi never appears there: phi-operand uses are relocated into the predecessor’s USE set, which feeds IN[pred], not OUT[pred]. The value is genuinely live across the edge — the phi copy reads it — so raw out_state under-approximates liveness, which is the unsafe direction for a may-analysis and would let a register allocator reuse a live register.

This computes OUT[B] = out_state(B) ∪ PhiUses(B), where PhiUses(B) is every value some successor reads as a phi operand on an edge from B.

pub fn phi_out_set(&self, block: usize) -> Option<&BitSet>

Returns the values a successor’s phi reads on block’s outgoing edges.

pub const fn num_variables(&self) -> usize

Returns the number of variables being tracked.

pub fn use_set(&self, block: usize) -> Option<&BitSet>

Returns the USE set for a block.

pub fn def_set(&self, block: usize) -> Option<&BitSet>

Returns the DEF set for a block.

Trait Implementations

impl<T> DataFlowAnalysis<T> for LiveVariables

where T: Target,

const DIRECTION: Direction = Direction::Backward

The direction of this analysis.

type Lattice = LivenessResult

The lattice type for this analysis.

fn boundary( &self, _ssa: &SsaFunction<T>, ) -> <LiveVariables as DataFlowAnalysis<T>>::Lattice

Returns the initial value at the boundary of the function.

fn initial( &self, _ssa: &SsaFunction<T>, ) -> <LiveVariables as DataFlowAnalysis<T>>::Lattice

Returns the initial value for interior blocks (typically the lattice’s top).

fn transfer( &self, block_id: usize, _block: &SsaBlock<T>, output: &<LiveVariables as DataFlowAnalysis<T>>::Lattice, _ssa: &SsaFunction<T>, ) -> <LiveVariables as DataFlowAnalysis<T>>::Lattice

Computes the transfer function for a basic block. Given the input state to a block, returns the output state after flowing through the block.

fn widen( &self, _block_id: usize, _previous: &Self::Lattice, next: Self::Lattice, _visit: usize, ) -> Self::Lattice

Widens next against the value a block previously held, once it has been revisited enough times to look loop-carried.

fn finalize( &mut self, _in_states: &[Self::Lattice], _out_states: &[Self::Lattice], _ssa: &SsaFunction<T>, )

Called when analysis is complete. Default: no post-processing.