Struct cranelift_codegen::dominator_tree::DominatorTree

source ·
pub struct DominatorTree { /* private fields */ }
Expand description

The dominator tree for a single function.

Implementations§

source§

impl DominatorTree

Methods for querying the dominator tree.

source

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

Is block reachable from the entry block?

source

pub fn cfg_postorder(&self) -> &[Block]

Get the CFG post-order of blocks that was used to compute the dominator tree.

Note that this post-order is not updated automatically when the CFG is modified. It is computed from scratch and cached by compute().

source

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

Returns the immediate dominator of block.

The immediate dominator of a basic block is a basic block which we represent by the branch or jump instruction at the end of the basic block. This does not have to be the terminator of its block.

A branch or jump is said to dominate block if all control flow paths from the function entry to block must go through the branch.

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

This returns None if block is not reachable from the entry block, or if it is the entry block which has no dominators.

source

pub fn rpo_cmp_block(&self, a: Block, b: Block) -> Ordering

Compare two blocks relative to the reverse post-order.

source

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

Compare two program points relative to a reverse post-order traversal of the control-flow graph.

Return Ordering::Less if a comes before b in the RPO.

If a and b belong to the same block, compare their relative position in the block.

source

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

Returns true if a dominates b.

This means that every control-flow path from the function entry to b must go through a.

Dominance is ill defined for unreachable blocks. This function can always determine dominance for instructions in the same block, but otherwise returns false if either block is unreachable.

An instruction is considered to dominate itself.

source

pub fn last_dominator<B>(&self, a: Block, b: B, layout: &Layout) -> Option<Inst>
where B: Into<ProgramPoint>,

Find the last instruction in a that dominates b. If no instructions in a dominate b, return None.

source

pub fn common_dominator( &self, a: BlockPredecessor, b: BlockPredecessor, layout: &Layout ) -> BlockPredecessor

Compute the common dominator of two basic blocks.

Both basic blocks are assumed to be reachable.

source§

impl DominatorTree

source

pub fn new() -> Self

Allocate a new blank dominator tree. Use compute to compute the dominator tree for a function.

source

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

Allocate and compute a dominator tree.

source

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

Reset and compute a CFG post-order and dominator tree.

source

pub fn clear(&mut self)

Clear the data structures used to represent the dominator tree. This will leave the tree in a state where is_valid() returns false.

source

pub fn is_valid(&self) -> bool

Check if the 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 dominator tree is consistent with the CFG.

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.