LLVM  4.0.0
Public Types | Public Member Functions | List of all members
llvm::DominatorTree Class Reference

Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree. More...

#include <Dominators.h>

Inheritance diagram for llvm::DominatorTree:
[legend]
Collaboration diagram for llvm::DominatorTree:
[legend]

Public Types

typedef DominatorTreeBase
< BasicBlock
Base
 

Public Member Functions

 DominatorTree ()
 
 DominatorTree (Function &F)
 
bool compare (const DominatorTree &Other) const
 Returns false if the other dominator tree matches this dominator tree. More...
 
bool dominates (const Instruction *Def, const Use &U) const
 Return true if Def dominates a use in User. More...
 
bool dominates (const Instruction *Def, const Instruction *User) const
 
bool dominates (const Instruction *Def, const BasicBlock *BB) const
 
bool dominates (const BasicBlockEdge &BBE, const Use &U) const
 
bool dominates (const BasicBlockEdge &BBE, const BasicBlock *BB) const
 
bool isReachableFromEntry (const Use &U) const
 Provide an overload for a Use. More...
 
void verifyDomTree () const
 Verify the correctness of the domtree by re-computing it. More...
 
- Public Member Functions inherited from llvm::DominatorTreeBase< BasicBlock >
 DominatorTreeBase (bool isPostDom)
 
 DominatorTreeBase (DominatorTreeBase &&Arg)
 
DominatorTreeBaseoperator= (DominatorTreeBase &&RHS)
 
bool compare (const DominatorTreeBase &Other) const
 compare - Return false if the other dominator tree base matches this dominator tree base. More...
 
void releaseMemory ()
 
DomTreeNodeBase< NodeT > * getNode (NodeT *BB) const
 getNode - return the (Post)DominatorTree node for the specified basic block. More...
 
DomTreeNodeBase< NodeT > * operator[] (NodeT *BB) const
 See getNode. More...
 
DomTreeNodeBase< NodeT > * getRootNode ()
 getRootNode - This returns the entry node for the CFG of the function. More...
 
const DomTreeNodeBase< NodeT > * getRootNode () const
 
void getDescendants (NodeT *R, SmallVectorImpl< NodeT * > &Result) const
 Get all nodes dominated by R, including R itself. More...
 
bool properlyDominates (const DomTreeNodeBase< NodeT > *A, const DomTreeNodeBase< NodeT > *B) const
 properlyDominates - Returns true iff A dominates B and A != B. More...
 
bool properlyDominates (const NodeT *A, const NodeT *B) const
 
bool isReachableFromEntry (const NodeT *A) const
 isReachableFromEntry - Return true if A is dominated by the entry block of the function containing it. More...
 
bool isReachableFromEntry (const DomTreeNodeBase< NodeT > *A) const
 
bool dominates (const DomTreeNodeBase< NodeT > *A, const DomTreeNodeBase< NodeT > *B) const
 dominates - Returns true iff A dominates B. More...
 
bool dominates (const NodeT *A, const NodeT *B) const
 
NodeT * getRoot () const
 
NodeT * findNearestCommonDominator (NodeT *A, NodeT *B)
 findNearestCommonDominator - Find nearest common dominator basic block for basic block A and B. More...
 
const NodeT * findNearestCommonDominator (const NodeT *A, const NodeT *B)
 
DomTreeNodeBase< NodeT > * addNewBlock (NodeT *BB, NodeT *DomBB)
 Add a new node to the dominator tree information. More...
 
DomTreeNodeBase< NodeT > * setNewRoot (NodeT *BB)
 Add a new node to the forward dominator tree and make it a new root. More...
 
void changeImmediateDominator (DomTreeNodeBase< NodeT > *BasicBlock, DomTreeNodeBase< NodeT > *NewIDom)
 changeImmediateDominator - This method is used to update the dominator tree information when a node's immediate dominator changes. More...
 
void changeImmediateDominator (NodeT *BB, NodeT *NewBB)
 
void eraseNode (NodeT *BB)
 eraseNode - Removes a node from the dominator tree. More...
 
void splitBlock (NodeT *NewBB)
 splitBlock - BB is split and now it has one successor. More...
 
void print (raw_ostream &o) const
 print - Convert to human readable form More...
 
void updateDFSNumbers () const
 updateDFSNumbers - Assign In and Out numbers to the nodes while walking dominator tree in dfs order. More...
 
void recalculate (FT &F)
 recalculate - compute a dominator tree for the given function More...
 
- Public Member Functions inherited from llvm::DominatorBase< NodeT >
const std::vector< NodeT * > & getRoots () const
 getRoots - Return the root blocks of the current CFG. More...
 
bool isPostDominator () const
 isPostDominator - Returns true if analysis based of postdoms More...
 

Additional Inherited Members

- Protected Types inherited from llvm::DominatorTreeBase< BasicBlock >
typedef DenseMap< NodeT
*, std::unique_ptr
< DomTreeNodeBase< NodeT > > > 
DomTreeNodeMapType
 
- Protected Member Functions inherited from llvm::DominatorTreeBase< BasicBlock >
void reset ()
 
void Split (DominatorTreeBaseByGraphTraits< GraphT > &DT, typename GraphT::NodeRef NewBB)
 
DomTreeNodeBase< NodeT > * getNodeForBlock (NodeT *BB)
 
NodeT * getIDom (NodeT *BB) const
 
void addRoot (NodeT *BB)
 
- Protected Member Functions inherited from llvm::DominatorBase< NodeT >
 DominatorBase (bool isPostDom)
 
 DominatorBase (DominatorBase &&Arg)
 
DominatorBaseoperator= (DominatorBase &&RHS)
 
- Protected Attributes inherited from llvm::DominatorTreeBase< BasicBlock >
DomTreeNodeMapType DomTreeNodes
 
DomTreeNodeBase< NodeT > * RootNode
 
bool DFSInfoValid
 
unsigned int SlowQueries
 
DenseMap< NodeT *, NodeT * > IDoms
 
std::vector< NodeT * > Vertex
 
DenseMap< NodeT *, InfoRec > Info
 
- Protected Attributes inherited from llvm::DominatorBase< NodeT >
std::vector< NodeT * > Roots
 
bool IsPostDominators
 

Detailed Description

Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.

Definition: A block is said to be forward statically reachable if there is a path from the entry of the function to the block. A statically reachable block may become statically unreachable during optimization.

A forward unreachable block may appear in the dominator tree, or it may not. If it does, dominance queries will return results as if all reachable blocks dominate it. When asking for a Node corresponding to a potentially unreachable block, calling code must handle the case where the block was unreachable and the result of getNode() is nullptr.

Generally, a block known to be unreachable when the dominator tree is constructed will not be in the tree. One which becomes unreachable after the dominator tree is initially constructed may still exist in the tree, even if the tree is properly updated. Calling code should not rely on the preceding statements; this is stated only to assist human understanding.

Definition at line 96 of file Dominators.h.

Member Typedef Documentation

Definition at line 98 of file Dominators.h.

Constructor & Destructor Documentation

llvm::DominatorTree::DominatorTree ( )
inline

Definition at line 100 of file Dominators.h.

llvm::DominatorTree::DominatorTree ( Function F)
inlineexplicit

Member Function Documentation

bool llvm::DominatorTree::compare ( const DominatorTree Other) const
inline
bool DominatorTree::dominates ( const Instruction Def,
const Use U 
) const

Return true if Def dominates a use in User.

This performs the special checks necessary if Def and User are in the same basic block. Note that Def doesn't dominate a use in Def itself!

Definition at line 218 of file Dominators.cpp.

References E, llvm::Instruction::getParent(), llvm::Use::getUser(), I, and isReachableFromEntry().

Referenced by AllUsesDominatedByBlock(), blockDominatesAnExit(), llvm::LoopAccessInfo::blockNeedsPredication(), BrPHIToSelect(), checkBasicSSA(), containsUnconditionalCallSafepoint(), dominates(), llvm::MemorySSA::dominates(), findBasePointers(), findBBsToSinkInto(), llvm::formLCSSAForInstructions(), llvm::ScalarEvolution::getAddRecExpr(), getInsertPointForUses(), llvm::MemoryDependenceResults::getInvariantGroupPointerDependency(), getReductionValue(), insertParsePoints(), IsAcceptableTarget(), IsAvailableOnEntry(), llvm::RecurrenceDescriptor::isFirstOrderRecurrence(), isFullDominator(), llvm::isGuaranteedToExecute(), isKnownNonNullFromDominatingCondition(), llvm::ScalarEvolution::isLoopBackedgeGuardedByCond(), llvm::ScalarEvolution::isLoopEntryGuardedByCond(), llvm::isOverflowIntrinsicNoWrap(), llvm::isPotentiallyReachableFromMany(), llvm::isValidAssumeForContext(), IVUseShouldUsePostIncValue(), moveSpillUsesAfterCoroBegin(), nearest_common_dominatee(), llvm::slpvectorizer::BoUpSLP::optimizeGatherSequence(), PickMostRelevantLoop(), llvm::promoteLoopAccessesToScalars(), llvm::replaceDominatedUsesWith(), reportMayClobberedLoad(), rewriteSingleStoreAlloca(), separateNestedLoop(), and ValueDominatesPHI().

bool DominatorTree::dominates ( const Instruction Def,
const Instruction User 
) const
bool DominatorTree::dominates ( const Instruction Def,
const BasicBlock BB 
) const

Definition at line 116 of file Dominators.cpp.

References dominates(), E, llvm::Instruction::getParent(), and isReachableFromEntry().

bool DominatorTree::dominates ( const BasicBlockEdge BBE,
const Use U 
) const
bool DominatorTree::dominates ( const BasicBlockEdge BBE,
const BasicBlock BB 
) const
bool DominatorTree::isReachableFromEntry ( const Use U) const
void DominatorTree::verifyDomTree ( ) const

Verify the correctness of the domtree by re-computing it.

This should only be used for debugging as it aborts the program if the verification fails.

Definition at line 284 of file Dominators.cpp.

References compare(), llvm::errs(), F, llvm::DominatorTreeBase< BasicBlock >::getRoot(), llvm::DominatorTreeBase< N >::print(), llvm::DominatorTreeBase< BasicBlock >::print(), and llvm::DominatorTreeBase< N >::recalculate().

Referenced by llvm::UnrollLoop(), and llvm::DominatorTreeWrapperPass::verifyAnalysis().


The documentation for this class was generated from the following files: