Struct PostDominatorTree 

pub struct PostDominatorTree { /* private fields */ }

The post-dominator tree for a single function.

Implementations

impl PostDominatorTree

pub fn new() -> Self

Allocate a new blank post-dominator tree.

Use compute to compute the post-dominator tree for a function.

pub fn with_function(func: &Function, cfg: &ControlFlowGraph) -> Self

Allocate and compute a post-dominator tree.

pub fn compute(&mut self, func: &Function, cfg: &ControlFlowGraph)

Reset and compute the post-dominator tree for func, using the control-flow graph cfg.

pub fn clear(&mut self)

Clear the data structures used to represent the post-dominator tree.

This will leave the tree in a state where is_valid() returns false.

pub fn is_valid(&self) -> bool

Check if the post-dominator tree is in a valid state.

Note that this doesn’t perform any kind of validity checks. It simply checks if the compute() method has been called since the last clear(). It does not check that the post-dominator tree is consistent with the CFG.

pub fn immediate_post_dominator(&self, block: Block) -> Option<Block>

Returns the immediate post-dominator of block.

block_a is said to post-dominate block_b if all control-flow paths from block_b out of this function (via return or trap) must go through block_a.

The immediate post-dominator is the post-dominator that is closest to block. All other post-dominators also post-dominate the immediate post-dominator.

This returns None if block diverges and cannot exit the function, or if block directly exits the function (returns or traps).

pub fn post_dominates<A, B>(&self, a: A, b: B, layout: &Layout) -> bool

where A: Into<ProgramPoint>, B: Into<ProgramPoint>,

Returns true if every path from b out of this function (via return or trap) must go through a.

pub fn block_post_dominates(&self, block_a: Block, block_b: Block) -> bool

Returns true if every path from b to a function exit (return or trap) must go through a.

pub fn children(&self, block: Block) -> ChildIter<'_>

Get an iterator over the direct children of block in the post-dominator tree.

These are the blocks whose immediate post-dominator is block.

pub fn diverges(&self, block: Block) -> bool

Is function exit (via return or trap) unreachable from the given block?

Trait Implementations

impl Default for PostDominatorTree

fn default() -> Self

Returns the “default value” for a type.