Struct ReachingDefinitions 

pub struct ReachingDefinitions {
    pub reach_in: HashMap<BlockId, HashSet<VarId>>,
    pub reach_out: HashMap<BlockId, HashSet<VarId>>,
    pub def_use_chains: HashMap<VarId, HashSet<BlockId>>,
    pub precise_def_use: HashMap<Definition, HashSet<ProgramPoint>>,
    pub use_def_chains: HashMap<Use, HashSet<Definition>>,
    pub all_definitions: Vec<Definition>,
    pub all_uses: Vec<Use>,
}

Reaching definitions analysis (forward data flow analysis).

Tracks which variable definitions reach each program point. This enables def-use chain construction and SSA-like analysis.

Example

let cfg = ControlFlowGraph::from_block(&block);
let reaching = ReachingDefinitions::analyze(&cfg);

// Check which definitions of x reach a specific block
let var_id = VarId { name_id: 0, version: 0 };
if let Some(defs) = reaching.reach_in.get(&block_id) {
    if defs.contains(&var_id) {
        println!("Definition of x.0 reaches this block");
    }
}

// Statement-level: check if a specific definition is dead
for def in &reaching.all_definitions {
    if reaching.is_dead_definition(def) {
        println!("Dead store at {:?}", def.point);
    }
}

Fields

reach_in: HashMap<BlockId, HashSet<VarId>>

Definitions that reach the entry of each block

reach_out: HashMap<BlockId, HashSet<VarId>>

Definitions that reach the exit of each block

def_use_chains: HashMap<VarId, HashSet<BlockId>>

Def-use chains at block level (backward compatibility)

precise_def_use: HashMap<Definition, HashSet<ProgramPoint>>

Precise def-use chains: definition point → use points

use_def_chains: HashMap<Use, HashSet<Definition>>

Use-def chains (inverse): use point → reaching definitions

all_definitions: Vec<Definition>

All definitions in the program

all_uses: Vec<Use>

All uses in the program

Implementations

impl ReachingDefinitions

pub fn analyze(cfg: &ControlFlowGraph) -> Self

Compute reaching definitions for a CFG using forward data flow analysis.

This performs both block-level analysis (for backward compatibility) and statement-level analysis for precise def-use chains.

pub fn get_uses_of(&self, def: &Definition) -> Option<&HashSet<ProgramPoint>>

Get all uses of a specific definition (statement-level).

pub fn get_defs_of(&self, use_point: &Use) -> Option<&HashSet<Definition>>

Get all definitions that reach a specific use (statement-level).

pub fn is_dead_definition(&self, def: &Definition) -> bool

Check if a definition is dead (no uses).

pub fn find_same_block_dead_stores(&self) -> Vec<Definition>

Find same-block dead stores: defs with no uses at all.

pub fn get_unique_def(&self, use_point: &Use) -> Option<Definition>

Get the single reaching definition for a use (if unique).

Trait Implementations

impl Clone for ReachingDefinitions

fn clone(&self) -> ReachingDefinitions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReachingDefinitions

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

Formats the value using the given formatter.

impl Default for ReachingDefinitions

fn default() -> ReachingDefinitions

Returns the “default value” for a type.