#include "llvm/Pass.h"
#include <set>
+#include "llvm/ADT/DenseMap.h"
namespace llvm {
const_iterator begin() const { return Children.begin(); }
const_iterator end() const { return Children.end(); }
- inline BasicBlock *getBlock() const { return TheBB; }
- inline DomTreeNode *getIDom() const { return IDom; }
- inline const std::vector<DomTreeNode*> &getChildren() const { return Children; }
+ BasicBlock *getBlock() const { return TheBB; }
+ DomTreeNode *getIDom() const { return IDom; }
+ const std::vector<DomTreeNode*> &getChildren() const { return Children; }
- inline DomTreeNode(BasicBlock *BB, DomTreeNode *iDom)
+ DomTreeNode(BasicBlock *BB, DomTreeNode *iDom)
: TheBB(BB), IDom(iDom), DFSNumIn(-1), DFSNumOut(-1) { }
- inline DomTreeNode *addChild(DomTreeNode *C) { Children.push_back(C); return C; }
+ DomTreeNode *addChild(DomTreeNode *C) { Children.push_back(C); return C; }
void setIDom(DomTreeNode *NewIDom);
+
+ /// getDFSNumIn/getDFSNumOut - These are an internal implementation detail, do
+ /// not call them.
+ unsigned getDFSNumIn() const { return DFSNumIn; }
+ unsigned getDFSNumOut() const { return DFSNumOut; }
private:
- // Return true if this node is dominated by other. Use this only if DFS info is valid.
+ // Return true if this node is dominated by other. Use this only if DFS info
+ // is valid.
bool DominatedBy(const DomTreeNode *other) const {
return this->DFSNumIn >= other->DFSNumIn &&
this->DFSNumOut <= other->DFSNumOut;
}
-
- /// assignDFSNumber - Assign In and Out numbers while walking dominator tree
- /// in dfs order.
- void assignDFSNumber(int num);
};
//===----------------------------------------------------------------------===//
/// DominatorTree - Calculate the immediate dominator tree for a function.
///
class DominatorTreeBase : public DominatorBase {
-
protected:
void reset();
- typedef std::map<BasicBlock*, DomTreeNode*> DomTreeNodeMapType;
+ typedef DenseMap<BasicBlock*, DomTreeNode*> DomTreeNodeMapType;
DomTreeNodeMapType DomTreeNodes;
DomTreeNode *RootNode;
std::vector<BasicBlock*> Bucket;
- InfoRec() : Semi(0), Size(0), Label(0), Parent(0), Child(0), Ancestor(0){}
+ InfoRec() : Semi(0), Size(0), Label(0), Parent(0), Child(0), Ancestor(0) {}
};
- std::map<BasicBlock*, BasicBlock*> IDoms;
+ DenseMap<BasicBlock*, BasicBlock*> IDoms;
// Vertex - Map the DFS number to the BasicBlock*
std::vector<BasicBlock*> Vertex;
// Info - Collection of information used during the computation of idoms.
- std::map<BasicBlock*, InfoRec> Info;
+ DenseMap<BasicBlock*, InfoRec> Info;
- void updateDFSNumbers();
-
- public:
+public:
DominatorTreeBase(intptr_t ID, bool isPostDom)
: DominatorBase(ID, isPostDom), DFSInfoValid(false), SlowQueries(0) {}
~DominatorTreeBase() { reset(); }
/// block. This is the same as using operator[] on this class.
///
inline DomTreeNode *getNode(BasicBlock *BB) const {
- DomTreeNodeMapType::const_iterator i = DomTreeNodes.find(BB);
- return (i != DomTreeNodes.end()) ? i->second : 0;
+ DomTreeNodeMapType::const_iterator I = DomTreeNodes.find(BB);
+ return I != DomTreeNodes.end() ? I->second : 0;
}
inline DomTreeNode *operator[](BasicBlock *BB) const {
return getNode(BB);
}
- /// getIDomBlock - return basic block BB's immediate dominator basic block.
- ///
- BasicBlock *getIDomBlock(BasicBlock *BB) {
- DomTreeNode *N = getNode(BB);
- assert (N && "Missing dominator tree node");
- DomTreeNode *I = N->getIDom();
- assert (N && "Missing immediate dominator");
- return I->getBlock();
- }
-
/// getRootNode - This returns the entry node for the CFG of the function. If
/// this tree represents the post-dominance relations for a function, however,
/// this root may be a node with the block == NULL. This is the case when
const DomTreeNode *B) const {
const DomTreeNode *IDom;
if (A == 0 || B == 0) return false;
- while ((IDom = B->getIDom()) != 0 && IDom != A)
+ while ((IDom = B->getIDom()) != 0 && IDom != A && IDom != B)
B = IDom; // Walk up the tree
return IDom != 0;
}
changeImmediateDominator(getNode(BB), getNode(NewBB));
}
+ /// eraseNode - Removes a node from the dominator tree. Block must not
+ /// domiante any other blocks. Removes node from its immediate dominator's
+ /// children list. Deletes dominator node associated with basic block BB.
+ void eraseNode(BasicBlock *BB);
+
/// removeNode - Removes a node from the dominator tree. Block must not
/// dominate any other blocks. Invalidates any node pointing to removed
/// block.
if (OS) print(*OS, M);
}
virtual void dump();
+
+protected:
+ /// updateDFSNumbers - Assign In and Out numbers to the nodes while walking
+ /// dominator tree in dfs order.
+ void updateDFSNumbers();
};
//===-------------------------------------
class DominatorTree : public DominatorTreeBase {
public:
static char ID; // Pass ID, replacement for typeid
- DominatorTree() : DominatorTreeBase((intptr_t)&ID, false) {}
+ DominatorTree() : DominatorTreeBase(intptr_t(&ID), false) {}
BasicBlock *getRoot() const {
assert(Roots.size() == 1 && "Should always have entry node!");
private:
void calculate(Function& F);
DomTreeNode *getNodeForBlock(BasicBlock *BB);
- unsigned DFSPass(BasicBlock *V, InfoRec &VInfo, unsigned N);
+ unsigned DFSPass(BasicBlock *V, unsigned N);
void Compress(BasicBlock *V);
BasicBlock *Eval(BasicBlock *v);
void Link(BasicBlock *V, BasicBlock *W, InfoRec &WInfo);
inline BasicBlock *getIDom(BasicBlock *BB) const {
- std::map<BasicBlock*, BasicBlock*>::const_iterator I = IDoms.find(BB);
- return I != IDoms.end() ? I->second : 0;
- }
+ DenseMap<BasicBlock*, BasicBlock*>::const_iterator I = IDoms.find(BB);
+ return I != IDoms.end() ? I->second : 0;
+ }
};
//===-------------------------------------
Frontiers.insert(std::make_pair(BB, frontier));
}
+ /// removeBlock - Remove basic block BB's frontier.
+ void removeBlock(BasicBlock *BB) {
+ assert(find(BB) != end() && "Block is not in DominanceFrontier!");
+ for (iterator I = begin(), E = end(); I != E; ++I)
+ I->second.erase(BB);
+ Frontiers.erase(BB);
+ }
+
void addToFrontier(iterator I, BasicBlock *Node) {
assert(I != end() && "BB is not in DominanceFrontier!");
I->second.insert(Node);
public:
static char ID; // Pass ID, replacement for typeid
DominanceFrontier() :
- DominanceFrontierBase((intptr_t)& ID, false) {}
+ DominanceFrontierBase(intptr_t(&ID), false) {}
BasicBlock *getRoot() const {
assert(Roots.size() == 1 && "Should always have entry node!");
AU.addRequired<DominatorTree>();
}
- /// splitBlock
- /// BB is split and now it has one successor. Update dominace frontier to
- /// reflect this change.
+ /// splitBlock - BB is split and now it has one successor. Update dominance
+ /// frontier to reflect this change.
void splitBlock(BasicBlock *BB);
+ /// BasicBlock BB's new dominator is NewBB. Update BB's dominance frontier
+ /// to reflect this change.
+ void changeImmediateDominator(BasicBlock *BB, BasicBlock *NewBB,
+ DominatorTree *DT) {
+ // NewBB is now dominating BB. Which means BB's dominance
+ // frontier is now part of NewBB's dominance frontier. However, BB
+ // itself is not member of NewBB's dominance frontier.
+ DominanceFrontier::iterator NewDFI = find(NewBB);
+ DominanceFrontier::iterator DFI = find(BB);
+ DominanceFrontier::DomSetType BBSet = DFI->second;
+ for (DominanceFrontier::DomSetType::iterator BBSetI = BBSet.begin(),
+ BBSetE = BBSet.end(); BBSetI != BBSetE; ++BBSetI) {
+ BasicBlock *DFMember = *BBSetI;
+ // Insert only if NewBB dominates DFMember.
+ if (!DT->dominates(NewBB, DFMember))
+ NewDFI->second.insert(DFMember);
+ }
+ NewDFI->second.erase(BB);
+ }
+
private:
const DomSetType &calculate(const DominatorTree &DT,
const DomTreeNode *Node);
projects / oota-llvm.git / blobdiff