// This file defines the following classes:
// 1. ImmediateDominators: Calculates and holds a mapping between BasicBlocks
// and their immediate dominator.
-// 2. DominatorTree: Represent the ImmediateDominator as an explicit tree
+// 2. DominatorSet: Calculates the [reverse] dominator set for a function
+// 3. DominatorTree: Represent the ImmediateDominator as an explicit tree
// structure.
// 4. ETForest: Efficient data structure for dominance comparisons and
// nearest-common-ancestor queries.
void Link(BasicBlock *V, BasicBlock *W, InfoRec &WInfo);
};
+
+
+//===----------------------------------------------------------------------===//
+/// DominatorSet - Maintain a set<BasicBlock*> for every basic block in a
+/// function, that represents the blocks that dominate the block. If the block
+/// is unreachable in this function, the set will be empty. This cannot happen
+/// for reachable code, because every block dominates at least itself.
+///
+class DominatorSetBase : public DominatorBase {
+public:
+ typedef std::set<BasicBlock*> DomSetType; // Dom set for a bb
+ // Map of dom sets
+ typedef std::map<BasicBlock*, DomSetType> DomSetMapType;
+protected:
+ DomSetMapType Doms;
+public:
+ DominatorSetBase(bool isPostDom) : DominatorBase(isPostDom) {}
+
+ virtual void releaseMemory() { Doms.clear(); }
+
+ // Accessor interface:
+ typedef DomSetMapType::const_iterator const_iterator;
+ typedef DomSetMapType::iterator iterator;
+ inline const_iterator begin() const { return Doms.begin(); }
+ inline iterator begin() { return Doms.begin(); }
+ inline const_iterator end() const { return Doms.end(); }
+ inline iterator end() { return Doms.end(); }
+ inline const_iterator find(BasicBlock* B) const { return Doms.find(B); }
+ inline iterator find(BasicBlock* B) { return Doms.find(B); }
+
+
+ /// getDominators - Return the set of basic blocks that dominate the specified
+ /// block.
+ ///
+ inline const DomSetType &getDominators(BasicBlock *BB) const {
+ const_iterator I = find(BB);
+ assert(I != end() && "BB not in function!");
+ return I->second;
+ }
+
+ /// isReachable - Return true if the specified basicblock is reachable. If
+ /// the block is reachable, we have dominator set information for it.
+ ///
+ bool isReachable(BasicBlock *BB) const {
+ return !getDominators(BB).empty();
+ }
+
+ /// dominates - Return true if A dominates B.
+ ///
+ inline bool dominates(BasicBlock *A, BasicBlock *B) const {
+ return getDominators(B).count(A) != 0;
+ }
+
+ /// properlyDominates - Return true if A dominates B and A != B.
+ ///
+ bool properlyDominates(BasicBlock *A, BasicBlock *B) const {
+ return dominates(A, B) && A != B;
+ }
+
+ /// print - Convert to human readable form
+ ///
+ virtual void print(std::ostream &OS, const Module* = 0) const;
+ void print(std::ostream *OS, const Module* M = 0) const {
+ if (OS) print(*OS, M);
+ }
+
+ /// dominates - Return true if A dominates B. This performs the special
+ /// checks necessary if A and B are in the same basic block.
+ ///
+ bool dominates(Instruction *A, Instruction *B) const;
+
+ //===--------------------------------------------------------------------===//
+ // API to update (Post)DominatorSet information based on modifications to
+ // the CFG...
+
+ /// addBasicBlock - Call to update the dominator set with information about a
+ /// new block that was inserted into the function.
+ ///
+ void addBasicBlock(BasicBlock *BB, const DomSetType &Dominators) {
+ assert(find(BB) == end() && "Block already in DominatorSet!");
+ Doms.insert(std::make_pair(BB, Dominators));
+ }
+
+ /// addDominator - If a new block is inserted into the CFG, then method may be
+ /// called to notify the blocks it dominates that it is in their set.
+ ///
+ void addDominator(BasicBlock *BB, BasicBlock *NewDominator) {
+ iterator I = find(BB);
+ assert(I != end() && "BB is not in DominatorSet!");
+ I->second.insert(NewDominator);
+ }
+};
+
+
+//===-------------------------------------
+/// DominatorSet Class - Concrete subclass of DominatorSetBase that is used to
+/// compute a normal dominator set.
+///
+class DominatorSet : public DominatorSetBase {
+public:
+ DominatorSet() : DominatorSetBase(false) {}
+
+ virtual bool runOnFunction(Function &F);
+
+ BasicBlock *getRoot() const {
+ assert(Roots.size() == 1 && "Should always have entry node!");
+ return Roots[0];
+ }
+
+ /// getAnalysisUsage - This simply provides a dominator set
+ ///
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.addRequired<ImmediateDominators>();
+ AU.setPreservesAll();
+ }
+
+ // stub - dummy function, just ignore it
+ static int stub;
+};
+
+
//===----------------------------------------------------------------------===//
/// DominatorTree - Calculate the immediate dominator tree for a function.
///
} // End llvm namespace
+// Make sure that any clients of this file link in Dominators.cpp
+FORCE_DEFINING_FILE_TO_BE_LINKED(DominatorSet)
+
#endif
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
// We need loop information to identify the loops...
AU.addRequired<LoopInfo>();
+ AU.addRequired<DominatorSet>();
AU.addRequired<DominatorTree>();
AU.addRequired<ETForest>();
AU.addPreserved<LoopInfo>();
+ AU.addPreserved<DominatorSet>();
AU.addPreserved<ImmediateDominators>();
AU.addPreserved<ETForest>();
AU.addPreserved<DominatorTree>();
// Can we eliminate this phi node now?
if (Value *V = PN->hasConstantValue(true)) {
if (!isa<Instruction>(V) ||
- getAnalysis<ETForest>().dominates(cast<Instruction>(V), PN)) {
+ getAnalysis<DominatorSet>().dominates(cast<Instruction>(V), PN)) {
PN->replaceAllUsesWith(V);
if (AA) AA->deleteValue(PN);
BB->getInstList().erase(PN);
// Determine which blocks should stay in L and which should be moved out to
// the Outer loop now.
+ DominatorSet &DS = getAnalysis<DominatorSet>();
std::set<BasicBlock*> BlocksInL;
for (pred_iterator PI = pred_begin(Header), E = pred_end(Header); PI!=E; ++PI)
- if (EF->dominates(Header, *PI))
+ if (DS.dominates(Header, *PI))
AddBlockAndPredsToSet(*PI, Header, BlocksInL);
++succ_begin(NewBB) == succ_end(NewBB) &&
"NewBB should have a single successor!");
BasicBlock *NewBBSucc = *succ_begin(NewBB);
- ETForest& ETF = getAnalysis<ETForest>();
-
+ DominatorSet &DS = getAnalysis<DominatorSet>();
+
+ // Update dominator information... The blocks that dominate NewBB are the
+ // intersection of the dominators of predecessors, plus the block itself.
+ //
+ DominatorSet::DomSetType NewBBDomSet = DS.getDominators(PredBlocks[0]);
+ {
+ unsigned i, e = PredBlocks.size();
+ // It is possible for some preds to not be reachable, and thus have empty
+ // dominator sets (all blocks must dom themselves, so no domset would
+ // otherwise be empty). If we see any of these, don't intersect with them,
+ // as that would certainly leave the resultant set empty.
+ for (i = 1; NewBBDomSet.empty(); ++i) {
+ assert(i != e && "Didn't find reachable pred?");
+ NewBBDomSet = DS.getDominators(PredBlocks[i]);
+ }
+
+ // Intersect the rest of the non-empty sets.
+ for (; i != e; ++i) {
+ const DominatorSet::DomSetType &PredDS = DS.getDominators(PredBlocks[i]);
+ if (!PredDS.empty())
+ set_intersect(NewBBDomSet, PredDS);
+ }
+ NewBBDomSet.insert(NewBB); // All blocks dominate themselves.
+ DS.addBasicBlock(NewBB, NewBBDomSet);
+ }
+
// The newly inserted basic block will dominate existing basic blocks iff the
// PredBlocks dominate all of the non-pred blocks. If all predblocks dominate
// the non-pred blocks, then they all must be the same block!
{
BasicBlock *OnePred = PredBlocks[0];
unsigned i, e = PredBlocks.size();
- for (i = 1; !ETF.dominates(&OnePred->getParent()->getEntryBlock(), OnePred); ++i) {
+ for (i = 1; !DS.isReachable(OnePred); ++i) {
assert(i != e && "Didn't find reachable pred?");
OnePred = PredBlocks[i];
}
for (; i != e; ++i)
- if (PredBlocks[i] != OnePred &&
- ETF.dominates(&PredBlocks[i]->getParent()->getEntryBlock(), OnePred)) {
+ if (PredBlocks[i] != OnePred && DS.isReachable(PredBlocks[i])) {
NewBBDominatesNewBBSucc = false;
break;
}
if (NewBBDominatesNewBBSucc)
for (pred_iterator PI = pred_begin(NewBBSucc), E = pred_end(NewBBSucc);
PI != E; ++PI)
- if (*PI != NewBB && !ETF.dominates(NewBBSucc, *PI)) {
+ if (*PI != NewBB && !DS.dominates(NewBBSucc, *PI)) {
NewBBDominatesNewBBSucc = false;
break;
}
NewBBDominatesNewBBSucc = true;
for (pred_iterator PI = pred_begin(NewBBSucc), E = pred_end(NewBBSucc);
PI != E; ++PI)
- if (*PI != NewBB && !ETF.dominates(NewBBSucc, *PI)) {
+ if (*PI != NewBB && !DS.dominates(NewBBSucc, *PI)) {
NewBBDominatesNewBBSucc = false;
break;
}
}
- BasicBlock *NewBBIDom = 0;
-
+ // If NewBB dominates some blocks, then it will dominate all blocks that
+ // NewBBSucc does.
+ if (NewBBDominatesNewBBSucc) {
+ Function *F = NewBB->getParent();
+ for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I)
+ if (DS.dominates(NewBBSucc, I))
+ DS.addDominator(I, NewBB);
+ }
+
// Update immediate dominator information if we have it.
+ BasicBlock *NewBBIDom = 0;
if (ImmediateDominators *ID = getAnalysisToUpdate<ImmediateDominators>()) {
- unsigned i = 0;
- for (i = 0; i < PredBlocks.size(); ++i)
- if (ETF.dominates(&PredBlocks[i]->getParent()->getEntryBlock(), PredBlocks[i])) {
- NewBBIDom = PredBlocks[i];
- break;
- }
- assert(i != PredBlocks.size() && "No reachable preds?");
- for (i = i + 1; i < PredBlocks.size(); ++i) {
- if (ETF.dominates(&PredBlocks[i]->getParent()->getEntryBlock(), PredBlocks[i]))
- NewBBIDom = ETF.nearestCommonDominator(NewBBIDom, PredBlocks[i]);
+ // To find the immediate dominator of the new exit node, we trace up the
+ // immediate dominators of a predecessor until we find a basic block that
+ // dominates the exit block.
+ //
+ BasicBlock *Dom = PredBlocks[0]; // Some random predecessor.
+
+ // Find a reachable pred.
+ for (unsigned i = 1; !DS.isReachable(Dom); ++i) {
+ assert(i != PredBlocks.size() && "Didn't find reachable pred!");
+ Dom = PredBlocks[i];
}
- assert(NewBBIDom && "No immediate dominator found??");
-
+
+ while (!NewBBDomSet.count(Dom)) { // Loop until we find a dominator.
+ assert(Dom != 0 && "No shared dominator found???");
+ Dom = ID->get(Dom);
+ }
+
// Set the immediate dominator now...
- ID->addNewBlock(NewBB, NewBBIDom);
+ ID->addNewBlock(NewBB, Dom);
+ NewBBIDom = Dom; // Reuse this if calculating DominatorTree info...
// If NewBB strictly dominates other blocks, we need to update their idom's
// now. The only block that need adjustment is the NewBBSucc block, whose
if (DominatorTree *DT = getAnalysisToUpdate<DominatorTree>()) {
// If we don't have ImmediateDominator info around, calculate the idom as
// above.
- if (!NewBBIDom) {
- unsigned i = 0;
- for (i = 0; i < PredBlocks.size(); ++i)
- if (ETF.dominates(&PredBlocks[i]->getParent()->getEntryBlock(), PredBlocks[i])) {
- NewBBIDom = PredBlocks[i];
- break;
- }
- assert(i != PredBlocks.size() && "No reachable preds?");
- for (i = i + 1; i < PredBlocks.size(); ++i) {
- if (ETF.dominates(&PredBlocks[i]->getParent()->getEntryBlock(), PredBlocks[i]))
- NewBBIDom = ETF.nearestCommonDominator(NewBBIDom, PredBlocks[i]);
+ DominatorTree::Node *NewBBIDomNode;
+ if (NewBBIDom) {
+ NewBBIDomNode = DT->getNode(NewBBIDom);
+ } else {
+ // Scan all the pred blocks that were pulled out. Any individual one may
+ // actually be unreachable, which would mean it doesn't have dom info.
+ NewBBIDomNode = 0;
+ for (unsigned i = 0; !NewBBIDomNode; ++i) {
+ assert(i != PredBlocks.size() && "No reachable preds?");
+ NewBBIDomNode = DT->getNode(PredBlocks[i]);
}
- assert(NewBBIDom && "No immediate dominator found??");
+
+ while (!NewBBDomSet.count(NewBBIDomNode->getBlock())) {
+ NewBBIDomNode = NewBBIDomNode->getIDom();
+ assert(NewBBIDomNode && "No shared dominator found??");
+ }
+ NewBBIDom = NewBBIDomNode->getBlock();
}
- DominatorTree::Node *NewBBIDomNode = DT->getNode(NewBBIDom);
// Create the new dominator tree node... and set the idom of NewBB.
DominatorTree::Node *NewBBNode = DT->createNewNode(NewBB, NewBBIDomNode);
bool DominatesPred = false;
for (pred_iterator PI = pred_begin(*SetI), E = pred_end(*SetI);
PI != E; ++PI)
- if (ETF.dominates(NewBB, *PI))
+ if (DS.dominates(NewBB, *PI))
DominatesPred = true;
if (!DominatesPred)
Set.erase(SetI++);
for (unsigned i = 0, e = PredBlocks.size(); i != e; ++i) {
BasicBlock *Pred = PredBlocks[i];
// Get all of the dominators of the predecessor...
- // FIXME: There's probably a better way to do this...
- std::vector<BasicBlock*> PredDoms;
- for (Function::iterator I = Pred->getParent()->begin(),
- E = Pred->getParent()->end(); I != E; ++I)
- if (ETF.dominates(&(*I), Pred))
- PredDoms.push_back(I);
-
- for (std::vector<BasicBlock*>::const_iterator PDI = PredDoms.begin(),
+ const DominatorSet::DomSetType &PredDoms = DS.getDominators(Pred);
+ for (DominatorSet::DomSetType::const_iterator PDI = PredDoms.begin(),
PDE = PredDoms.end(); PDI != PDE; ++PDI) {
BasicBlock *PredDom = *PDI;
// We remove it unless there is a predecessor of NewBBSucc that we
// dominate, but we don't strictly dominate NewBBSucc.
bool ShouldRemove = true;
- if (PredDom == NewBBSucc || !ETF.dominates(PredDom, NewBBSucc)) {
+ if (PredDom == NewBBSucc || !DS.dominates(PredDom, NewBBSucc)) {
// Okay, we know that PredDom does not strictly dominate NewBBSucc.
// Check to see if it dominates any predecessors of NewBBSucc.
for (pred_iterator PI = pred_begin(NewBBSucc),
E = pred_end(NewBBSucc); PI != E; ++PI)
- if (ETF.dominates(PredDom, *PI)) {
+ if (DS.dominates(PredDom, *PI)) {
ShouldRemove = false;
break;
}
o << "\n";
}
+
+
+//===----------------------------------------------------------------------===//
+// DominatorSet Implementation
+//===----------------------------------------------------------------------===//
+
+static RegisterPass<DominatorSet>
+B("domset", "Dominator Set Construction", true);
+
+// dominates - Return true if A dominates B. This performs the special checks
+// necessary if A and B are in the same basic block.
+//
+bool DominatorSetBase::dominates(Instruction *A, Instruction *B) const {
+ BasicBlock *BBA = A->getParent(), *BBB = B->getParent();
+ if (BBA != BBB) return dominates(BBA, BBB);
+
+ // It is not possible to determine dominance between two PHI nodes
+ // based on their ordering.
+ if (isa<PHINode>(A) && isa<PHINode>(B))
+ return false;
+
+ // Loop through the basic block until we find A or B.
+ BasicBlock::iterator I = BBA->begin();
+ for (; &*I != A && &*I != B; ++I) /*empty*/;
+
+ if(!IsPostDominators) {
+ // A dominates B if it is found first in the basic block.
+ return &*I == A;
+ } else {
+ // A post-dominates B if B is found first in the basic block.
+ return &*I == B;
+ }
+}
+
+
+// runOnFunction - This method calculates the forward dominator sets for the
+// specified function.
+//
+bool DominatorSet::runOnFunction(Function &F) {
+ BasicBlock *Root = &F.getEntryBlock();
+ Roots.clear();
+ Roots.push_back(Root);
+ assert(pred_begin(Root) == pred_end(Root) &&
+ "Root node has predecessors in function!");
+
+ ImmediateDominators &ID = getAnalysis<ImmediateDominators>();
+ Doms.clear();
+ if (Roots.empty()) return false;
+
+ // Root nodes only dominate themselves.
+ for (unsigned i = 0, e = Roots.size(); i != e; ++i)
+ Doms[Roots[i]].insert(Roots[i]);
+
+ // Loop over all of the blocks in the function, calculating dominator sets for
+ // each function.
+ for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
+ if (BasicBlock *IDom = ID[I]) { // Get idom if block is reachable
+ DomSetType &DS = Doms[I];
+ assert(DS.empty() && "Domset already filled in for this block?");
+ DS.insert(I); // Blocks always dominate themselves
+
+ // Insert all dominators into the set...
+ while (IDom) {
+ // If we have already computed the dominator sets for our immediate
+ // dominator, just use it instead of walking all the way up to the root.
+ DomSetType &IDS = Doms[IDom];
+ if (!IDS.empty()) {
+ DS.insert(IDS.begin(), IDS.end());
+ break;
+ } else {
+ DS.insert(IDom);
+ IDom = ID[IDom];
+ }
+ }
+ } else {
+ // Ensure that every basic block has at least an empty set of nodes. This
+ // is important for the case when there is unreachable blocks.
+ Doms[I];
+ }
+
+ return false;
+}
+
+namespace llvm {
+static std::ostream &operator<<(std::ostream &o,
+ const std::set<BasicBlock*> &BBs) {
+ for (std::set<BasicBlock*>::const_iterator I = BBs.begin(), E = BBs.end();
+ I != E; ++I)
+ if (*I)
+ WriteAsOperand(o, *I, false);
+ else
+ o << " <<exit node>>";
+ return o;
+}
+}
+
+void DominatorSetBase::print(std::ostream &o, const Module* ) const {
+ for (const_iterator I = begin(), E = end(); I != E; ++I) {
+ o << " DomSet For BB: ";
+ if (I->first)
+ WriteAsOperand(o, I->first, false);
+ else
+ o << " <<exit node>>";
+ o << " is:\t" << I->second << "\n";
+ }
+}
+
//===----------------------------------------------------------------------===//
// DominatorTree Implementation
//===----------------------------------------------------------------------===//
return *Result;
}
-namespace llvm {
-static std::ostream &operator<<(std::ostream &o,
- const std::set<BasicBlock*> &BBs) {
- for (std::set<BasicBlock*>::const_iterator I = BBs.begin(), E = BBs.end();
- I != E; ++I)
- if (*I)
- WriteAsOperand(o, *I, false);
- else
- o << " <<exit node>>";
- return o;
-}
-}
-
-
void DominanceFrontierBase::print(std::ostream &o, const Module* ) const {
for (const_iterator I = begin(), E = end(); I != E; ++I) {
o << " DomFrontier for BB";
}
o << "\n";
}
+
+DEFINING_FILE_FOR(DominatorSet)
projects / oota-llvm.git / commitdiff