mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-17 05:29:24 +00:00
s/DominatorTreeBase::Node/DominatorTreeBase:DomTreeNode/g
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@37403 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
10ac137d0b
commit
bec7647f98
@ -61,13 +61,13 @@ public:
|
|||||||
///
|
///
|
||||||
class DominatorTreeBase : public DominatorBase {
|
class DominatorTreeBase : public DominatorBase {
|
||||||
public:
|
public:
|
||||||
class Node;
|
class DomTreeNode;
|
||||||
protected:
|
protected:
|
||||||
std::map<BasicBlock*, Node*> Nodes;
|
std::map<BasicBlock*, DomTreeNode*> DomTreeNodes;
|
||||||
void reset();
|
void reset();
|
||||||
typedef std::map<BasicBlock*, Node*> NodeMapType;
|
typedef std::map<BasicBlock*, DomTreeNode*> DomTreeNodeMapType;
|
||||||
|
|
||||||
Node *RootNode;
|
DomTreeNode *RootNode;
|
||||||
|
|
||||||
struct InfoRec {
|
struct InfoRec {
|
||||||
unsigned Semi;
|
unsigned Semi;
|
||||||
@ -88,16 +88,16 @@ protected:
|
|||||||
std::map<BasicBlock*, InfoRec> Info;
|
std::map<BasicBlock*, InfoRec> Info;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
class Node {
|
class DomTreeNode {
|
||||||
friend class DominatorTree;
|
friend class DominatorTree;
|
||||||
friend struct PostDominatorTree;
|
friend struct PostDominatorTree;
|
||||||
friend class DominatorTreeBase;
|
friend class DominatorTreeBase;
|
||||||
BasicBlock *TheBB;
|
BasicBlock *TheBB;
|
||||||
Node *IDom;
|
DomTreeNode *IDom;
|
||||||
std::vector<Node*> Children;
|
std::vector<DomTreeNode*> Children;
|
||||||
public:
|
public:
|
||||||
typedef std::vector<Node*>::iterator iterator;
|
typedef std::vector<DomTreeNode*>::iterator iterator;
|
||||||
typedef std::vector<Node*>::const_iterator const_iterator;
|
typedef std::vector<DomTreeNode*>::const_iterator const_iterator;
|
||||||
|
|
||||||
iterator begin() { return Children.begin(); }
|
iterator begin() { return Children.begin(); }
|
||||||
iterator end() { return Children.end(); }
|
iterator end() { return Children.end(); }
|
||||||
@ -105,14 +105,14 @@ public:
|
|||||||
const_iterator end() const { return Children.end(); }
|
const_iterator end() const { return Children.end(); }
|
||||||
|
|
||||||
inline BasicBlock *getBlock() const { return TheBB; }
|
inline BasicBlock *getBlock() const { return TheBB; }
|
||||||
inline Node *getIDom() const { return IDom; }
|
inline DomTreeNode *getIDom() const { return IDom; }
|
||||||
inline const std::vector<Node*> &getChildren() const { return Children; }
|
inline const std::vector<DomTreeNode*> &getChildren() const { return Children; }
|
||||||
|
|
||||||
/// properlyDominates - Returns true iff this dominates N and this != N.
|
/// properlyDominates - Returns true iff this dominates N and this != N.
|
||||||
/// Note that this is not a constant time operation!
|
/// Note that this is not a constant time operation!
|
||||||
///
|
///
|
||||||
bool properlyDominates(const Node *N) const {
|
bool properlyDominates(const DomTreeNode *N) const {
|
||||||
const Node *IDom;
|
const DomTreeNode *IDom;
|
||||||
if (this == 0 || N == 0) return false;
|
if (this == 0 || N == 0) return false;
|
||||||
while ((IDom = N->getIDom()) != 0 && IDom != this)
|
while ((IDom = N->getIDom()) != 0 && IDom != this)
|
||||||
N = IDom; // Walk up the tree
|
N = IDom; // Walk up the tree
|
||||||
@ -122,16 +122,16 @@ public:
|
|||||||
/// dominates - Returns true iff this dominates N. Note that this is not a
|
/// dominates - Returns true iff this dominates N. Note that this is not a
|
||||||
/// constant time operation!
|
/// constant time operation!
|
||||||
///
|
///
|
||||||
inline bool dominates(const Node *N) const {
|
inline bool dominates(const DomTreeNode *N) const {
|
||||||
if (N == this) return true; // A node trivially dominates itself.
|
if (N == this) return true; // A node trivially dominates itself.
|
||||||
return properlyDominates(N);
|
return properlyDominates(N);
|
||||||
}
|
}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
inline Node(BasicBlock *BB, Node *iDom) : TheBB(BB), IDom(iDom) {}
|
inline DomTreeNode(BasicBlock *BB, DomTreeNode *iDom) : TheBB(BB), IDom(iDom) {}
|
||||||
inline Node *addChild(Node *C) { Children.push_back(C); return C; }
|
inline DomTreeNode *addChild(DomTreeNode *C) { Children.push_back(C); return C; }
|
||||||
|
|
||||||
void setIDom(Node *NewIDom);
|
void setIDom(DomTreeNode *NewIDom);
|
||||||
};
|
};
|
||||||
|
|
||||||
public:
|
public:
|
||||||
@ -144,12 +144,12 @@ public:
|
|||||||
/// getNode - return the (Post)DominatorTree node for the specified basic
|
/// getNode - return the (Post)DominatorTree node for the specified basic
|
||||||
/// block. This is the same as using operator[] on this class.
|
/// block. This is the same as using operator[] on this class.
|
||||||
///
|
///
|
||||||
inline Node *getNode(BasicBlock *BB) const {
|
inline DomTreeNode *getNode(BasicBlock *BB) const {
|
||||||
NodeMapType::const_iterator i = Nodes.find(BB);
|
DomTreeNodeMapType::const_iterator i = DomTreeNodes.find(BB);
|
||||||
return (i != Nodes.end()) ? i->second : 0;
|
return (i != DomTreeNodes.end()) ? i->second : 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
inline Node *operator[](BasicBlock *BB) const {
|
inline DomTreeNode *operator[](BasicBlock *BB) const {
|
||||||
return getNode(BB);
|
return getNode(BB);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -160,8 +160,8 @@ public:
|
|||||||
/// post-dominance information must be capable of dealing with this
|
/// post-dominance information must be capable of dealing with this
|
||||||
/// possibility.
|
/// possibility.
|
||||||
///
|
///
|
||||||
Node *getRootNode() { return RootNode; }
|
DomTreeNode *getRootNode() { return RootNode; }
|
||||||
const Node *getRootNode() const { return RootNode; }
|
const DomTreeNode *getRootNode() const { return RootNode; }
|
||||||
|
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
// API to update (Post)DominatorTree information based on modifications to
|
// API to update (Post)DominatorTree information based on modifications to
|
||||||
@ -171,16 +171,16 @@ public:
|
|||||||
/// creates a new node as a child of IDomNode, linking it into the children
|
/// creates a new node as a child of IDomNode, linking it into the children
|
||||||
/// list of the immediate dominator.
|
/// list of the immediate dominator.
|
||||||
///
|
///
|
||||||
Node *createNewNode(BasicBlock *BB, Node *IDomNode) {
|
DomTreeNode *createNewNode(BasicBlock *BB, DomTreeNode *IDomNode) {
|
||||||
assert(getNode(BB) == 0 && "Block already in dominator tree!");
|
assert(getNode(BB) == 0 && "Block already in dominator tree!");
|
||||||
assert(IDomNode && "Not immediate dominator specified for block!");
|
assert(IDomNode && "Not immediate dominator specified for block!");
|
||||||
return Nodes[BB] = IDomNode->addChild(new Node(BB, IDomNode));
|
return DomTreeNodes[BB] = IDomNode->addChild(new DomTreeNode(BB, IDomNode));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// changeImmediateDominator - This method is used to update the dominator
|
/// changeImmediateDominator - This method is used to update the dominator
|
||||||
/// tree information when a node's immediate dominator changes.
|
/// tree information when a node's immediate dominator changes.
|
||||||
///
|
///
|
||||||
void changeImmediateDominator(Node *N, Node *NewIDom) {
|
void changeImmediateDominator(DomTreeNode *N, DomTreeNode *NewIDom) {
|
||||||
assert(N && NewIDom && "Cannot change null node pointers!");
|
assert(N && NewIDom && "Cannot change null node pointers!");
|
||||||
N->setIDom(NewIDom);
|
N->setIDom(NewIDom);
|
||||||
}
|
}
|
||||||
@ -190,7 +190,7 @@ public:
|
|||||||
/// block.
|
/// block.
|
||||||
void removeNode(BasicBlock *BB) {
|
void removeNode(BasicBlock *BB) {
|
||||||
assert(getNode(BB) && "Removing node that isn't in dominator tree.");
|
assert(getNode(BB) && "Removing node that isn't in dominator tree.");
|
||||||
Nodes.erase(BB);
|
DomTreeNodes.erase(BB);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// print - Convert to human readable form
|
/// print - Convert to human readable form
|
||||||
@ -223,7 +223,7 @@ public:
|
|||||||
}
|
}
|
||||||
private:
|
private:
|
||||||
void calculate(Function& F);
|
void calculate(Function& F);
|
||||||
Node *getNodeForBlock(BasicBlock *BB);
|
DomTreeNode *getNodeForBlock(BasicBlock *BB);
|
||||||
unsigned DFSPass(BasicBlock *V, InfoRec &VInfo, unsigned N);
|
unsigned DFSPass(BasicBlock *V, InfoRec &VInfo, unsigned N);
|
||||||
void Compress(BasicBlock *V);
|
void Compress(BasicBlock *V);
|
||||||
BasicBlock *Eval(BasicBlock *v);
|
BasicBlock *Eval(BasicBlock *v);
|
||||||
@ -238,8 +238,8 @@ private:
|
|||||||
/// DominatorTree GraphTraits specialization so the DominatorTree can be
|
/// DominatorTree GraphTraits specialization so the DominatorTree can be
|
||||||
/// iterable by generic graph iterators.
|
/// iterable by generic graph iterators.
|
||||||
///
|
///
|
||||||
template <> struct GraphTraits<DominatorTree::Node*> {
|
template <> struct GraphTraits<DominatorTree::DomTreeNode*> {
|
||||||
typedef DominatorTree::Node NodeType;
|
typedef DominatorTree::DomTreeNode NodeType;
|
||||||
typedef NodeType::iterator ChildIteratorType;
|
typedef NodeType::iterator ChildIteratorType;
|
||||||
|
|
||||||
static NodeType *getEntryNode(NodeType *N) {
|
static NodeType *getEntryNode(NodeType *N) {
|
||||||
@ -254,7 +254,7 @@ template <> struct GraphTraits<DominatorTree::Node*> {
|
|||||||
};
|
};
|
||||||
|
|
||||||
template <> struct GraphTraits<DominatorTree*>
|
template <> struct GraphTraits<DominatorTree*>
|
||||||
: public GraphTraits<DominatorTree::Node*> {
|
: public GraphTraits<DominatorTree::DomTreeNode*> {
|
||||||
static NodeType *getEntryNode(DominatorTree *DT) {
|
static NodeType *getEntryNode(DominatorTree *DT) {
|
||||||
return DT->getRootNode();
|
return DT->getRootNode();
|
||||||
}
|
}
|
||||||
@ -503,7 +503,7 @@ public:
|
|||||||
}
|
}
|
||||||
private:
|
private:
|
||||||
const DomSetType &calculate(const DominatorTree &DT,
|
const DomSetType &calculate(const DominatorTree &DT,
|
||||||
const DominatorTree::Node *Node);
|
const DominatorTree::DomTreeNode *Node);
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
||||||
|
@ -38,7 +38,7 @@ struct PostDominatorTree : public DominatorTreeBase {
|
|||||||
}
|
}
|
||||||
private:
|
private:
|
||||||
void calculate(Function &F);
|
void calculate(Function &F);
|
||||||
Node *getNodeForBlock(BasicBlock *BB);
|
DomTreeNode *getNodeForBlock(BasicBlock *BB);
|
||||||
unsigned DFSPass(BasicBlock *V, InfoRec &VInfo,unsigned N);
|
unsigned DFSPass(BasicBlock *V, InfoRec &VInfo,unsigned N);
|
||||||
void Compress(BasicBlock *V, InfoRec &VInfo);
|
void Compress(BasicBlock *V, InfoRec &VInfo);
|
||||||
BasicBlock *Eval(BasicBlock *V);
|
BasicBlock *Eval(BasicBlock *V);
|
||||||
@ -87,7 +87,7 @@ struct PostDominanceFrontier : public DominanceFrontierBase {
|
|||||||
Frontiers.clear();
|
Frontiers.clear();
|
||||||
PostDominatorTree &DT = getAnalysis<PostDominatorTree>();
|
PostDominatorTree &DT = getAnalysis<PostDominatorTree>();
|
||||||
Roots = DT.getRoots();
|
Roots = DT.getRoots();
|
||||||
if (const DominatorTree::Node *Root = DT.getRootNode())
|
if (const DominatorTree::DomTreeNode *Root = DT.getRootNode())
|
||||||
calculate(DT, Root);
|
calculate(DT, Root);
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
@ -99,7 +99,7 @@ struct PostDominanceFrontier : public DominanceFrontierBase {
|
|||||||
|
|
||||||
private:
|
private:
|
||||||
const DomSetType &calculate(const PostDominatorTree &DT,
|
const DomSetType &calculate(const PostDominatorTree &DT,
|
||||||
const DominatorTree::Node *Node);
|
const DominatorTree::DomTreeNode *Node);
|
||||||
};
|
};
|
||||||
|
|
||||||
} // End llvm namespace
|
} // End llvm namespace
|
||||||
|
@ -165,19 +165,19 @@ void PostDominatorTree::calculate(Function &F) {
|
|||||||
// one exit block, or it may be the virtual exit (denoted by (BasicBlock *)0)
|
// one exit block, or it may be the virtual exit (denoted by (BasicBlock *)0)
|
||||||
// which postdominates all real exits if there are multiple exit blocks.
|
// which postdominates all real exits if there are multiple exit blocks.
|
||||||
BasicBlock *Root = Roots.size() == 1 ? Roots[0] : 0;
|
BasicBlock *Root = Roots.size() == 1 ? Roots[0] : 0;
|
||||||
Nodes[Root] = RootNode = new Node(Root, 0);
|
DomTreeNodes[Root] = RootNode = new DomTreeNode(Root, 0);
|
||||||
|
|
||||||
// Loop over all of the reachable blocks in the function...
|
// Loop over all of the reachable blocks in the function...
|
||||||
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
|
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
|
||||||
if (BasicBlock *ImmPostDom = getIDom(I)) { // Reachable block.
|
if (BasicBlock *ImmPostDom = getIDom(I)) { // Reachable block.
|
||||||
Node *&BBNode = Nodes[I];
|
DomTreeNode *&BBNode = DomTreeNodes[I];
|
||||||
if (!BBNode) { // Haven't calculated this node yet?
|
if (!BBNode) { // Haven't calculated this node yet?
|
||||||
// Get or calculate the node for the immediate dominator
|
// Get or calculate the node for the immediate dominator
|
||||||
Node *IPDomNode = getNodeForBlock(ImmPostDom);
|
DomTreeNode *IPDomNode = getNodeForBlock(ImmPostDom);
|
||||||
|
|
||||||
// Add a new tree node for this BasicBlock, and link it as a child of
|
// Add a new tree node for this BasicBlock, and link it as a child of
|
||||||
// IDomNode
|
// IDomNode
|
||||||
BBNode = IPDomNode->addChild(new Node(I, IPDomNode));
|
BBNode = IPDomNode->addChild(new DomTreeNode(I, IPDomNode));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -188,18 +188,18 @@ void PostDominatorTree::calculate(Function &F) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
DominatorTreeBase::Node *PostDominatorTree::getNodeForBlock(BasicBlock *BB) {
|
DominatorTreeBase::DomTreeNode *PostDominatorTree::getNodeForBlock(BasicBlock *BB) {
|
||||||
Node *&BBNode = Nodes[BB];
|
DomTreeNode *&BBNode = DomTreeNodes[BB];
|
||||||
if (BBNode) return BBNode;
|
if (BBNode) return BBNode;
|
||||||
|
|
||||||
// Haven't calculated this node yet? Get or calculate the node for the
|
// Haven't calculated this node yet? Get or calculate the node for the
|
||||||
// immediate postdominator.
|
// immediate postdominator.
|
||||||
BasicBlock *IPDom = getIDom(BB);
|
BasicBlock *IPDom = getIDom(BB);
|
||||||
Node *IPDomNode = getNodeForBlock(IPDom);
|
DomTreeNode *IPDomNode = getNodeForBlock(IPDom);
|
||||||
|
|
||||||
// Add a new tree node for this BasicBlock, and link it as a child of
|
// Add a new tree node for this BasicBlock, and link it as a child of
|
||||||
// IDomNode
|
// IDomNode
|
||||||
return BBNode = IPDomNode->addChild(new Node(BB, IPDomNode));
|
return BBNode = IPDomNode->addChild(new DomTreeNode(BB, IPDomNode));
|
||||||
}
|
}
|
||||||
|
|
||||||
//===----------------------------------------------------------------------===//
|
//===----------------------------------------------------------------------===//
|
||||||
@ -215,7 +215,7 @@ ETNode *PostETForest::getNodeForBlock(BasicBlock *BB) {
|
|||||||
|
|
||||||
// Haven't calculated this node yet? Get or calculate the node for the
|
// Haven't calculated this node yet? Get or calculate the node for the
|
||||||
// immediate dominator.
|
// immediate dominator.
|
||||||
PostDominatorTree::Node *node = getAnalysis<PostDominatorTree>().getNode(BB);
|
PostDominatorTree::DomTreeNode *node = getAnalysis<PostDominatorTree>().getNode(BB);
|
||||||
|
|
||||||
// If we are unreachable, we may not have an immediate dominator.
|
// If we are unreachable, we may not have an immediate dominator.
|
||||||
if (!node)
|
if (!node)
|
||||||
@ -245,7 +245,7 @@ void PostETForest::calculate(const PostDominatorTree &DT) {
|
|||||||
ETNode *&BBNode = Nodes[BB];
|
ETNode *&BBNode = Nodes[BB];
|
||||||
if (!BBNode) {
|
if (!BBNode) {
|
||||||
ETNode *IDomNode = NULL;
|
ETNode *IDomNode = NULL;
|
||||||
PostDominatorTree::Node *node = DT.getNode(BB);
|
PostDominatorTree::DomTreeNode *node = DT.getNode(BB);
|
||||||
if (node && node->getIDom())
|
if (node && node->getIDom())
|
||||||
IDomNode = getNodeForBlock(node->getIDom()->getBlock());
|
IDomNode = getNodeForBlock(node->getIDom()->getBlock());
|
||||||
|
|
||||||
@ -277,7 +277,7 @@ H("postdomfrontier", "Post-Dominance Frontier Construction", true);
|
|||||||
|
|
||||||
const DominanceFrontier::DomSetType &
|
const DominanceFrontier::DomSetType &
|
||||||
PostDominanceFrontier::calculate(const PostDominatorTree &DT,
|
PostDominanceFrontier::calculate(const PostDominatorTree &DT,
|
||||||
const DominatorTree::Node *Node) {
|
const DominatorTree::DomTreeNode *Node) {
|
||||||
// Loop over CFG successors to calculate DFlocal[Node]
|
// Loop over CFG successors to calculate DFlocal[Node]
|
||||||
BasicBlock *BB = Node->getBlock();
|
BasicBlock *BB = Node->getBlock();
|
||||||
DomSetType &S = Frontiers[BB]; // The new set to fill in...
|
DomSetType &S = Frontiers[BB]; // The new set to fill in...
|
||||||
@ -287,7 +287,7 @@ PostDominanceFrontier::calculate(const PostDominatorTree &DT,
|
|||||||
for (pred_iterator SI = pred_begin(BB), SE = pred_end(BB);
|
for (pred_iterator SI = pred_begin(BB), SE = pred_end(BB);
|
||||||
SI != SE; ++SI) {
|
SI != SE; ++SI) {
|
||||||
// Does Node immediately dominate this predecessor?
|
// Does Node immediately dominate this predecessor?
|
||||||
DominatorTree::Node *SINode = DT[*SI];
|
DominatorTree::DomTreeNode *SINode = DT[*SI];
|
||||||
if (SINode && SINode->getIDom() != Node)
|
if (SINode && SINode->getIDom() != Node)
|
||||||
S.insert(*SI);
|
S.insert(*SI);
|
||||||
}
|
}
|
||||||
@ -296,9 +296,9 @@ PostDominanceFrontier::calculate(const PostDominatorTree &DT,
|
|||||||
// Loop through and visit the nodes that Node immediately dominates (Node's
|
// Loop through and visit the nodes that Node immediately dominates (Node's
|
||||||
// children in the IDomTree)
|
// children in the IDomTree)
|
||||||
//
|
//
|
||||||
for (PostDominatorTree::Node::const_iterator
|
for (PostDominatorTree::DomTreeNode::const_iterator
|
||||||
NI = Node->begin(), NE = Node->end(); NI != NE; ++NI) {
|
NI = Node->begin(), NE = Node->end(); NI != NE; ++NI) {
|
||||||
DominatorTree::Node *IDominee = *NI;
|
DominatorTree::DomTreeNode *IDominee = *NI;
|
||||||
const DomSetType &ChildDF = calculate(DT, IDominee);
|
const DomSetType &ChildDF = calculate(DT, IDominee);
|
||||||
|
|
||||||
DomSetType::const_iterator CDFI = ChildDF.begin(), CDFE = ChildDF.end();
|
DomSetType::const_iterator CDFI = ChildDF.begin(), CDFE = ChildDF.end();
|
||||||
|
@ -387,8 +387,8 @@ bool ADCE::doADCE() {
|
|||||||
// postdominator that is alive, and the last postdominator that is
|
// postdominator that is alive, and the last postdominator that is
|
||||||
// dead...
|
// dead...
|
||||||
//
|
//
|
||||||
PostDominatorTree::Node *LastNode = DT[TI->getSuccessor(i)];
|
PostDominatorTree::DomTreeNode *LastNode = DT[TI->getSuccessor(i)];
|
||||||
PostDominatorTree::Node *NextNode = 0;
|
PostDominatorTree::DomTreeNode *NextNode = 0;
|
||||||
|
|
||||||
if (LastNode) {
|
if (LastNode) {
|
||||||
NextNode = LastNode->getIDom();
|
NextNode = LastNode->getIDom();
|
||||||
|
@ -94,7 +94,7 @@ bool GCSE::runOnFunction(Function &F) {
|
|||||||
|
|
||||||
// Traverse the CFG of the function in dominator order, so that we see each
|
// Traverse the CFG of the function in dominator order, so that we see each
|
||||||
// instruction after we see its operands.
|
// instruction after we see its operands.
|
||||||
for (df_iterator<DominatorTree::Node*> DI = df_begin(DT.getRootNode()),
|
for (df_iterator<DominatorTree::DomTreeNode*> DI = df_begin(DT.getRootNode()),
|
||||||
E = df_end(DT.getRootNode()); DI != E; ++DI) {
|
E = df_end(DT.getRootNode()); DI != E; ++DI) {
|
||||||
BasicBlock *BB = DI->getBlock();
|
BasicBlock *BB = DI->getBlock();
|
||||||
|
|
||||||
|
@ -87,7 +87,7 @@ namespace {
|
|||||||
// For a given block, calculate the generated expressions, temporaries,
|
// For a given block, calculate the generated expressions, temporaries,
|
||||||
// and the AVAIL_OUT set
|
// and the AVAIL_OUT set
|
||||||
void CalculateAvailOut(ValueTable& VN, std::set<Value*, ExprLT>& MS,
|
void CalculateAvailOut(ValueTable& VN, std::set<Value*, ExprLT>& MS,
|
||||||
DominatorTree::Node* DI,
|
DominatorTree::DomTreeNode* DI,
|
||||||
std::set<Value*, ExprLT>& currExps,
|
std::set<Value*, ExprLT>& currExps,
|
||||||
std::set<PHINode*>& currPhis,
|
std::set<PHINode*>& currPhis,
|
||||||
std::set<Value*, ExprLT>& currTemps,
|
std::set<Value*, ExprLT>& currTemps,
|
||||||
@ -262,7 +262,7 @@ void GVNPRE::dump(GVNPRE::ValueTable& VN, std::set<Value*, ExprLT>& s) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
void GVNPRE::CalculateAvailOut(GVNPRE::ValueTable& VN, std::set<Value*, ExprLT>& MS,
|
void GVNPRE::CalculateAvailOut(GVNPRE::ValueTable& VN, std::set<Value*, ExprLT>& MS,
|
||||||
DominatorTree::Node* DI,
|
DominatorTree::DomTreeNode* DI,
|
||||||
std::set<Value*, ExprLT>& currExps,
|
std::set<Value*, ExprLT>& currExps,
|
||||||
std::set<PHINode*>& currPhis,
|
std::set<PHINode*>& currPhis,
|
||||||
std::set<Value*, ExprLT>& currTemps,
|
std::set<Value*, ExprLT>& currTemps,
|
||||||
@ -324,7 +324,7 @@ bool GVNPRE::runOnFunction(Function &F) {
|
|||||||
// First Phase of BuildSets - calculate AVAIL_OUT
|
// First Phase of BuildSets - calculate AVAIL_OUT
|
||||||
|
|
||||||
// Top-down walk of the dominator tree
|
// Top-down walk of the dominator tree
|
||||||
for (df_iterator<DominatorTree::Node*> DI = df_begin(DT.getRootNode()),
|
for (df_iterator<DominatorTree::DomTreeNode*> DI = df_begin(DT.getRootNode()),
|
||||||
E = df_end(DT.getRootNode()); DI != E; ++DI) {
|
E = df_end(DT.getRootNode()); DI != E; ++DI) {
|
||||||
|
|
||||||
// Get the sets to update for this block
|
// Get the sets to update for this block
|
||||||
@ -350,7 +350,7 @@ bool GVNPRE::runOnFunction(Function &F) {
|
|||||||
std::set<Value*, ExprLT> anticOut;
|
std::set<Value*, ExprLT> anticOut;
|
||||||
|
|
||||||
// Top-down walk of the postdominator tree
|
// Top-down walk of the postdominator tree
|
||||||
for (df_iterator<PostDominatorTree::Node*> PDI =
|
for (df_iterator<PostDominatorTree::DomTreeNode*> PDI =
|
||||||
df_begin(PDT.getRootNode()), E = df_end(DT.getRootNode());
|
df_begin(PDT.getRootNode()), E = df_end(DT.getRootNode());
|
||||||
PDI != E; ++PDI) {
|
PDI != E; ++PDI) {
|
||||||
BasicBlock* BB = PDI->getBlock();
|
BasicBlock* BB = PDI->getBlock();
|
||||||
|
@ -107,7 +107,7 @@ namespace {
|
|||||||
/// visit uses before definitions, allowing us to sink a loop body in one
|
/// visit uses before definitions, allowing us to sink a loop body in one
|
||||||
/// pass without iteration.
|
/// pass without iteration.
|
||||||
///
|
///
|
||||||
void SinkRegion(DominatorTree::Node *N);
|
void SinkRegion(DominatorTree::DomTreeNode *N);
|
||||||
|
|
||||||
/// HoistRegion - Walk the specified region of the CFG (defined by all
|
/// HoistRegion - Walk the specified region of the CFG (defined by all
|
||||||
/// blocks dominated by the specified block, and that are in the current
|
/// blocks dominated by the specified block, and that are in the current
|
||||||
@ -115,7 +115,7 @@ namespace {
|
|||||||
/// visit definitions before uses, allowing us to hoist a loop body in one
|
/// visit definitions before uses, allowing us to hoist a loop body in one
|
||||||
/// pass without iteration.
|
/// pass without iteration.
|
||||||
///
|
///
|
||||||
void HoistRegion(DominatorTree::Node *N);
|
void HoistRegion(DominatorTree::DomTreeNode *N);
|
||||||
|
|
||||||
/// inSubLoop - Little predicate that returns true if the specified basic
|
/// inSubLoop - Little predicate that returns true if the specified basic
|
||||||
/// block is in a subloop of the current one, not the current one itself.
|
/// block is in a subloop of the current one, not the current one itself.
|
||||||
@ -140,8 +140,8 @@ namespace {
|
|||||||
if (BlockInLoop == LoopHeader)
|
if (BlockInLoop == LoopHeader)
|
||||||
return true;
|
return true;
|
||||||
|
|
||||||
DominatorTree::Node *BlockInLoopNode = DT->getNode(BlockInLoop);
|
DominatorTree::DomTreeNode *BlockInLoopNode = DT->getNode(BlockInLoop);
|
||||||
DominatorTree::Node *IDom = DT->getNode(ExitBlock);
|
DominatorTree::DomTreeNode *IDom = DT->getNode(ExitBlock);
|
||||||
|
|
||||||
// Because the exit block is not in the loop, we know we have to get _at
|
// Because the exit block is not in the loop, we know we have to get _at
|
||||||
// least_ its immediate dominator.
|
// least_ its immediate dominator.
|
||||||
@ -281,7 +281,7 @@ bool LICM::runOnLoop(Loop *L, LPPassManager &LPM) {
|
|||||||
/// uses before definitions, allowing us to sink a loop body in one pass without
|
/// uses before definitions, allowing us to sink a loop body in one pass without
|
||||||
/// iteration.
|
/// iteration.
|
||||||
///
|
///
|
||||||
void LICM::SinkRegion(DominatorTree::Node *N) {
|
void LICM::SinkRegion(DominatorTree::DomTreeNode *N) {
|
||||||
assert(N != 0 && "Null dominator tree node?");
|
assert(N != 0 && "Null dominator tree node?");
|
||||||
BasicBlock *BB = N->getBlock();
|
BasicBlock *BB = N->getBlock();
|
||||||
|
|
||||||
@ -289,7 +289,7 @@ void LICM::SinkRegion(DominatorTree::Node *N) {
|
|||||||
if (!CurLoop->contains(BB)) return;
|
if (!CurLoop->contains(BB)) return;
|
||||||
|
|
||||||
// We are processing blocks in reverse dfo, so process children first...
|
// We are processing blocks in reverse dfo, so process children first...
|
||||||
const std::vector<DominatorTree::Node*> &Children = N->getChildren();
|
const std::vector<DominatorTree::DomTreeNode*> &Children = N->getChildren();
|
||||||
for (unsigned i = 0, e = Children.size(); i != e; ++i)
|
for (unsigned i = 0, e = Children.size(); i != e; ++i)
|
||||||
SinkRegion(Children[i]);
|
SinkRegion(Children[i]);
|
||||||
|
|
||||||
@ -318,7 +318,7 @@ void LICM::SinkRegion(DominatorTree::Node *N) {
|
|||||||
/// first order w.r.t the DominatorTree. This allows us to visit definitions
|
/// first order w.r.t the DominatorTree. This allows us to visit definitions
|
||||||
/// before uses, allowing us to hoist a loop body in one pass without iteration.
|
/// before uses, allowing us to hoist a loop body in one pass without iteration.
|
||||||
///
|
///
|
||||||
void LICM::HoistRegion(DominatorTree::Node *N) {
|
void LICM::HoistRegion(DominatorTree::DomTreeNode *N) {
|
||||||
assert(N != 0 && "Null dominator tree node?");
|
assert(N != 0 && "Null dominator tree node?");
|
||||||
BasicBlock *BB = N->getBlock();
|
BasicBlock *BB = N->getBlock();
|
||||||
|
|
||||||
@ -340,7 +340,7 @@ void LICM::HoistRegion(DominatorTree::Node *N) {
|
|||||||
hoist(I);
|
hoist(I);
|
||||||
}
|
}
|
||||||
|
|
||||||
const std::vector<DominatorTree::Node*> &Children = N->getChildren();
|
const std::vector<DominatorTree::DomTreeNode*> &Children = N->getChildren();
|
||||||
for (unsigned i = 0, e = Children.size(); i != e; ++i)
|
for (unsigned i = 0, e = Children.size(); i != e; ++i)
|
||||||
HoistRegion(Children[i]);
|
HoistRegion(Children[i]);
|
||||||
}
|
}
|
||||||
|
@ -1986,7 +1986,7 @@ namespace {
|
|||||||
UnreachableBlocks UB;
|
UnreachableBlocks UB;
|
||||||
ValueRanges *VR;
|
ValueRanges *VR;
|
||||||
|
|
||||||
std::vector<DominatorTree::Node *> WorkList;
|
std::vector<DominatorTree::DomTreeNode *> WorkList;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
static char ID; // Pass identification, replacement for typeid
|
static char ID; // Pass identification, replacement for typeid
|
||||||
@ -2012,14 +2012,14 @@ namespace {
|
|||||||
class VISIBILITY_HIDDEN Forwards : public InstVisitor<Forwards> {
|
class VISIBILITY_HIDDEN Forwards : public InstVisitor<Forwards> {
|
||||||
friend class InstVisitor<Forwards>;
|
friend class InstVisitor<Forwards>;
|
||||||
PredicateSimplifier *PS;
|
PredicateSimplifier *PS;
|
||||||
DominatorTree::Node *DTNode;
|
DominatorTree::DomTreeNode *DTNode;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
InequalityGraph &IG;
|
InequalityGraph &IG;
|
||||||
UnreachableBlocks &UB;
|
UnreachableBlocks &UB;
|
||||||
ValueRanges &VR;
|
ValueRanges &VR;
|
||||||
|
|
||||||
Forwards(PredicateSimplifier *PS, DominatorTree::Node *DTNode)
|
Forwards(PredicateSimplifier *PS, DominatorTree::DomTreeNode *DTNode)
|
||||||
: PS(PS), DTNode(DTNode), IG(*PS->IG), UB(PS->UB), VR(*PS->VR) {}
|
: PS(PS), DTNode(DTNode), IG(*PS->IG), UB(PS->UB), VR(*PS->VR) {}
|
||||||
|
|
||||||
void visitTerminatorInst(TerminatorInst &TI);
|
void visitTerminatorInst(TerminatorInst &TI);
|
||||||
@ -2040,19 +2040,19 @@ namespace {
|
|||||||
// Used by terminator instructions to proceed from the current basic
|
// Used by terminator instructions to proceed from the current basic
|
||||||
// block to the next. Verifies that "current" dominates "next",
|
// block to the next. Verifies that "current" dominates "next",
|
||||||
// then calls visitBasicBlock.
|
// then calls visitBasicBlock.
|
||||||
void proceedToSuccessors(DominatorTree::Node *Current) {
|
void proceedToSuccessors(DominatorTree::DomTreeNode *Current) {
|
||||||
for (DominatorTree::Node::iterator I = Current->begin(),
|
for (DominatorTree::DomTreeNode::iterator I = Current->begin(),
|
||||||
E = Current->end(); I != E; ++I) {
|
E = Current->end(); I != E; ++I) {
|
||||||
WorkList.push_back(*I);
|
WorkList.push_back(*I);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void proceedToSuccessor(DominatorTree::Node *Next) {
|
void proceedToSuccessor(DominatorTree::DomTreeNode *Next) {
|
||||||
WorkList.push_back(Next);
|
WorkList.push_back(Next);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Visits each instruction in the basic block.
|
// Visits each instruction in the basic block.
|
||||||
void visitBasicBlock(DominatorTree::Node *Node) {
|
void visitBasicBlock(DominatorTree::DomTreeNode *Node) {
|
||||||
BasicBlock *BB = Node->getBlock();
|
BasicBlock *BB = Node->getBlock();
|
||||||
ETNode *ET = Forest->getNodeForBlock(BB);
|
ETNode *ET = Forest->getNodeForBlock(BB);
|
||||||
DOUT << "Entering Basic Block: " << BB->getName()
|
DOUT << "Entering Basic Block: " << BB->getName()
|
||||||
@ -2064,7 +2064,7 @@ namespace {
|
|||||||
|
|
||||||
// Tries to simplify each Instruction and add new properties to
|
// Tries to simplify each Instruction and add new properties to
|
||||||
// the PropertySet.
|
// the PropertySet.
|
||||||
void visitInstruction(Instruction *I, DominatorTree::Node *DT, ETNode *ET) {
|
void visitInstruction(Instruction *I, DominatorTree::DomTreeNode *DT, ETNode *ET) {
|
||||||
DOUT << "Considering instruction " << *I << "\n";
|
DOUT << "Considering instruction " << *I << "\n";
|
||||||
DEBUG(IG->dump());
|
DEBUG(IG->dump());
|
||||||
|
|
||||||
@ -2132,7 +2132,7 @@ namespace {
|
|||||||
WorkList.push_back(DT->getRootNode());
|
WorkList.push_back(DT->getRootNode());
|
||||||
|
|
||||||
do {
|
do {
|
||||||
DominatorTree::Node *DTNode = WorkList.back();
|
DominatorTree::DomTreeNode *DTNode = WorkList.back();
|
||||||
WorkList.pop_back();
|
WorkList.pop_back();
|
||||||
if (!UB.isDead(DTNode->getBlock())) visitBasicBlock(DTNode);
|
if (!UB.isDead(DTNode->getBlock())) visitBasicBlock(DTNode);
|
||||||
} while (!WorkList.empty());
|
} while (!WorkList.empty());
|
||||||
@ -2164,7 +2164,7 @@ namespace {
|
|||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
for (DominatorTree::Node::iterator I = DTNode->begin(), E = DTNode->end();
|
for (DominatorTree::DomTreeNode::iterator I = DTNode->begin(), E = DTNode->end();
|
||||||
I != E; ++I) {
|
I != E; ++I) {
|
||||||
BasicBlock *Dest = (*I)->getBlock();
|
BasicBlock *Dest = (*I)->getBlock();
|
||||||
DOUT << "Branch thinking about %" << Dest->getName()
|
DOUT << "Branch thinking about %" << Dest->getName()
|
||||||
@ -2194,7 +2194,7 @@ namespace {
|
|||||||
// Set the EQProperty in each of the cases BBs, and the NEProperties
|
// Set the EQProperty in each of the cases BBs, and the NEProperties
|
||||||
// in the default BB.
|
// in the default BB.
|
||||||
|
|
||||||
for (DominatorTree::Node::iterator I = DTNode->begin(), E = DTNode->end();
|
for (DominatorTree::DomTreeNode::iterator I = DTNode->begin(), E = DTNode->end();
|
||||||
I != E; ++I) {
|
I != E; ++I) {
|
||||||
BasicBlock *BB = (*I)->getBlock();
|
BasicBlock *BB = (*I)->getBlock();
|
||||||
DOUT << "Switch thinking about BB %" << BB->getName()
|
DOUT << "Switch thinking about BB %" << BB->getName()
|
||||||
|
@ -203,20 +203,20 @@ bool llvm::SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum, Pass *P,
|
|||||||
|
|
||||||
// Should we update DominatorTree information?
|
// Should we update DominatorTree information?
|
||||||
if (DominatorTree *DT = P->getAnalysisToUpdate<DominatorTree>()) {
|
if (DominatorTree *DT = P->getAnalysisToUpdate<DominatorTree>()) {
|
||||||
DominatorTree::Node *TINode = DT->getNode(TIBB);
|
DominatorTree::DomTreeNode *TINode = DT->getNode(TIBB);
|
||||||
|
|
||||||
// The new block is not the immediate dominator for any other nodes, but
|
// The new block is not the immediate dominator for any other nodes, but
|
||||||
// TINode is the immediate dominator for the new node.
|
// TINode is the immediate dominator for the new node.
|
||||||
//
|
//
|
||||||
if (TINode) { // Don't break unreachable code!
|
if (TINode) { // Don't break unreachable code!
|
||||||
DominatorTree::Node *NewBBNode = DT->createNewNode(NewBB, TINode);
|
DominatorTree::DomTreeNode *NewBBNode = DT->createNewNode(NewBB, TINode);
|
||||||
DominatorTree::Node *DestBBNode = 0;
|
DominatorTree::DomTreeNode *DestBBNode = 0;
|
||||||
|
|
||||||
// If NewBBDominatesDestBB hasn't been computed yet, do so with DT.
|
// If NewBBDominatesDestBB hasn't been computed yet, do so with DT.
|
||||||
if (!OtherPreds.empty()) {
|
if (!OtherPreds.empty()) {
|
||||||
DestBBNode = DT->getNode(DestBB);
|
DestBBNode = DT->getNode(DestBB);
|
||||||
while (!OtherPreds.empty() && NewBBDominatesDestBB) {
|
while (!OtherPreds.empty() && NewBBDominatesDestBB) {
|
||||||
if (DominatorTree::Node *OPNode = DT->getNode(OtherPreds.back()))
|
if (DominatorTree::DomTreeNode *OPNode = DT->getNode(OtherPreds.back()))
|
||||||
NewBBDominatesDestBB = DestBBNode->dominates(OPNode);
|
NewBBDominatesDestBB = DestBBNode->dominates(OPNode);
|
||||||
OtherPreds.pop_back();
|
OtherPreds.pop_back();
|
||||||
}
|
}
|
||||||
|
@ -75,8 +75,8 @@ namespace {
|
|||||||
void getLoopValuesUsedOutsideLoop(Loop *L,
|
void getLoopValuesUsedOutsideLoop(Loop *L,
|
||||||
SetVector<Instruction*> &AffectedValues);
|
SetVector<Instruction*> &AffectedValues);
|
||||||
|
|
||||||
Value *GetValueForBlock(DominatorTree::Node *BB, Instruction *OrigInst,
|
Value *GetValueForBlock(DominatorTree::DomTreeNode *BB, Instruction *OrigInst,
|
||||||
std::map<DominatorTree::Node*, Value*> &Phis);
|
std::map<DominatorTree::DomTreeNode*, Value*> &Phis);
|
||||||
|
|
||||||
/// inLoop - returns true if the given block is within the current loop
|
/// inLoop - returns true if the given block is within the current loop
|
||||||
const bool inLoop(BasicBlock* B) {
|
const bool inLoop(BasicBlock* B) {
|
||||||
@ -146,16 +146,16 @@ void LCSSA::ProcessInstruction(Instruction *Instr,
|
|||||||
++NumLCSSA; // We are applying the transformation
|
++NumLCSSA; // We are applying the transformation
|
||||||
|
|
||||||
// Keep track of the blocks that have the value available already.
|
// Keep track of the blocks that have the value available already.
|
||||||
std::map<DominatorTree::Node*, Value*> Phis;
|
std::map<DominatorTree::DomTreeNode*, Value*> Phis;
|
||||||
|
|
||||||
DominatorTree::Node *InstrNode = DT->getNode(Instr->getParent());
|
DominatorTree::DomTreeNode *InstrNode = DT->getNode(Instr->getParent());
|
||||||
|
|
||||||
// Insert the LCSSA phi's into the exit blocks (dominated by the value), and
|
// Insert the LCSSA phi's into the exit blocks (dominated by the value), and
|
||||||
// add them to the Phi's map.
|
// add them to the Phi's map.
|
||||||
for (std::vector<BasicBlock*>::const_iterator BBI = exitBlocks.begin(),
|
for (std::vector<BasicBlock*>::const_iterator BBI = exitBlocks.begin(),
|
||||||
BBE = exitBlocks.end(); BBI != BBE; ++BBI) {
|
BBE = exitBlocks.end(); BBI != BBE; ++BBI) {
|
||||||
BasicBlock *BB = *BBI;
|
BasicBlock *BB = *BBI;
|
||||||
DominatorTree::Node *ExitBBNode = DT->getNode(BB);
|
DominatorTree::DomTreeNode *ExitBBNode = DT->getNode(BB);
|
||||||
Value *&Phi = Phis[ExitBBNode];
|
Value *&Phi = Phis[ExitBBNode];
|
||||||
if (!Phi && InstrNode->dominates(ExitBBNode)) {
|
if (!Phi && InstrNode->dominates(ExitBBNode)) {
|
||||||
PHINode *PN = new PHINode(Instr->getType(), Instr->getName()+".lcssa",
|
PHINode *PN = new PHINode(Instr->getType(), Instr->getName()+".lcssa",
|
||||||
@ -229,8 +229,8 @@ void LCSSA::getLoopValuesUsedOutsideLoop(Loop *L,
|
|||||||
|
|
||||||
/// GetValueForBlock - Get the value to use within the specified basic block.
|
/// GetValueForBlock - Get the value to use within the specified basic block.
|
||||||
/// available values are in Phis.
|
/// available values are in Phis.
|
||||||
Value *LCSSA::GetValueForBlock(DominatorTree::Node *BB, Instruction *OrigInst,
|
Value *LCSSA::GetValueForBlock(DominatorTree::DomTreeNode *BB, Instruction *OrigInst,
|
||||||
std::map<DominatorTree::Node*, Value*> &Phis) {
|
std::map<DominatorTree::DomTreeNode*, Value*> &Phis) {
|
||||||
// If there is no dominator info for this BB, it is unreachable.
|
// If there is no dominator info for this BB, it is unreachable.
|
||||||
if (BB == 0)
|
if (BB == 0)
|
||||||
return UndefValue::get(OrigInst->getType());
|
return UndefValue::get(OrigInst->getType());
|
||||||
@ -239,7 +239,7 @@ Value *LCSSA::GetValueForBlock(DominatorTree::Node *BB, Instruction *OrigInst,
|
|||||||
Value *&V = Phis[BB];
|
Value *&V = Phis[BB];
|
||||||
if (V) return V;
|
if (V) return V;
|
||||||
|
|
||||||
DominatorTree::Node *IDom = BB->getIDom();
|
DominatorTree::DomTreeNode *IDom = BB->getIDom();
|
||||||
|
|
||||||
// Otherwise, there are two cases: we either have to insert a PHI node or we
|
// Otherwise, there are two cases: we either have to insert a PHI node or we
|
||||||
// don't. We need to insert a PHI node if this block is not dominated by one
|
// don't. We need to insert a PHI node if this block is not dominated by one
|
||||||
|
@ -778,15 +778,15 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
|
|||||||
}
|
}
|
||||||
assert(NewBBIDom && "No immediate dominator found??");
|
assert(NewBBIDom && "No immediate dominator found??");
|
||||||
}
|
}
|
||||||
DominatorTree::Node *NewBBIDomNode = DT->getNode(NewBBIDom);
|
DominatorTree::DomTreeNode *NewBBIDomNode = DT->getNode(NewBBIDom);
|
||||||
|
|
||||||
// Create the new dominator tree node... and set the idom of NewBB.
|
// Create the new dominator tree node... and set the idom of NewBB.
|
||||||
DominatorTree::Node *NewBBNode = DT->createNewNode(NewBB, NewBBIDomNode);
|
DominatorTree::DomTreeNode *NewBBNode = DT->createNewNode(NewBB, NewBBIDomNode);
|
||||||
|
|
||||||
// If NewBB strictly dominates other blocks, then it is now the immediate
|
// If NewBB strictly dominates other blocks, then it is now the immediate
|
||||||
// dominator of NewBBSucc. Update the dominator tree as appropriate.
|
// dominator of NewBBSucc. Update the dominator tree as appropriate.
|
||||||
if (NewBBDominatesNewBBSucc) {
|
if (NewBBDominatesNewBBSucc) {
|
||||||
DominatorTree::Node *NewBBSuccNode = DT->getNode(NewBBSucc);
|
DominatorTree::DomTreeNode *NewBBSuccNode = DT->getNode(NewBBSucc);
|
||||||
DT->changeImmediateDominator(NewBBSuccNode, NewBBNode);
|
DT->changeImmediateDominator(NewBBSuccNode, NewBBNode);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -234,7 +234,7 @@ void DominatorTree::Link(BasicBlock *V, BasicBlock *W, InfoRec &WInfo){
|
|||||||
void DominatorTree::calculate(Function& F) {
|
void DominatorTree::calculate(Function& F) {
|
||||||
BasicBlock* Root = Roots[0];
|
BasicBlock* Root = Roots[0];
|
||||||
|
|
||||||
Nodes[Root] = RootNode = new Node(Root, 0); // Add a node for the root...
|
DomTreeNodes[Root] = RootNode = new DomTreeNode(Root, 0); // Add a node for the root...
|
||||||
|
|
||||||
Vertex.push_back(0);
|
Vertex.push_back(0);
|
||||||
|
|
||||||
@ -282,14 +282,14 @@ void DominatorTree::calculate(Function& F) {
|
|||||||
// Loop over all of the reachable blocks in the function...
|
// Loop over all of the reachable blocks in the function...
|
||||||
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
|
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
|
||||||
if (BasicBlock *ImmDom = getIDom(I)) { // Reachable block.
|
if (BasicBlock *ImmDom = getIDom(I)) { // Reachable block.
|
||||||
Node *&BBNode = Nodes[I];
|
DomTreeNode *&BBNode = DomTreeNodes[I];
|
||||||
if (!BBNode) { // Haven't calculated this node yet?
|
if (!BBNode) { // Haven't calculated this node yet?
|
||||||
// Get or calculate the node for the immediate dominator
|
// Get or calculate the node for the immediate dominator
|
||||||
Node *IDomNode = getNodeForBlock(ImmDom);
|
DomTreeNode *IDomNode = getNodeForBlock(ImmDom);
|
||||||
|
|
||||||
// Add a new tree node for this BasicBlock, and link it as a child of
|
// Add a new tree node for this BasicBlock, and link it as a child of
|
||||||
// IDomNode
|
// IDomNode
|
||||||
BBNode = IDomNode->addChild(new Node(I, IDomNode));
|
BBNode = IDomNode->addChild(new DomTreeNode(I, IDomNode));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -302,19 +302,19 @@ void DominatorTree::calculate(Function& F) {
|
|||||||
// DominatorTreeBase::reset - Free all of the tree node memory.
|
// DominatorTreeBase::reset - Free all of the tree node memory.
|
||||||
//
|
//
|
||||||
void DominatorTreeBase::reset() {
|
void DominatorTreeBase::reset() {
|
||||||
for (NodeMapType::iterator I = Nodes.begin(), E = Nodes.end(); I != E; ++I)
|
for (DomTreeNodeMapType::iterator I = DomTreeNodes.begin(), E = DomTreeNodes.end(); I != E; ++I)
|
||||||
delete I->second;
|
delete I->second;
|
||||||
Nodes.clear();
|
DomTreeNodes.clear();
|
||||||
IDoms.clear();
|
IDoms.clear();
|
||||||
Roots.clear();
|
Roots.clear();
|
||||||
Vertex.clear();
|
Vertex.clear();
|
||||||
RootNode = 0;
|
RootNode = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
void DominatorTreeBase::Node::setIDom(Node *NewIDom) {
|
void DominatorTreeBase::DomTreeNode::setIDom(DomTreeNode *NewIDom) {
|
||||||
assert(IDom && "No immediate dominator?");
|
assert(IDom && "No immediate dominator?");
|
||||||
if (IDom != NewIDom) {
|
if (IDom != NewIDom) {
|
||||||
std::vector<Node*>::iterator I =
|
std::vector<DomTreeNode*>::iterator I =
|
||||||
std::find(IDom->Children.begin(), IDom->Children.end(), this);
|
std::find(IDom->Children.begin(), IDom->Children.end(), this);
|
||||||
assert(I != IDom->Children.end() &&
|
assert(I != IDom->Children.end() &&
|
||||||
"Not in immediate dominator children set!");
|
"Not in immediate dominator children set!");
|
||||||
@ -327,22 +327,22 @@ void DominatorTreeBase::Node::setIDom(Node *NewIDom) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
DominatorTreeBase::Node *DominatorTree::getNodeForBlock(BasicBlock *BB) {
|
DominatorTreeBase::DomTreeNode *DominatorTree::getNodeForBlock(BasicBlock *BB) {
|
||||||
Node *&BBNode = Nodes[BB];
|
DomTreeNode *&BBNode = DomTreeNodes[BB];
|
||||||
if (BBNode) return BBNode;
|
if (BBNode) return BBNode;
|
||||||
|
|
||||||
// Haven't calculated this node yet? Get or calculate the node for the
|
// Haven't calculated this node yet? Get or calculate the node for the
|
||||||
// immediate dominator.
|
// immediate dominator.
|
||||||
BasicBlock *IDom = getIDom(BB);
|
BasicBlock *IDom = getIDom(BB);
|
||||||
Node *IDomNode = getNodeForBlock(IDom);
|
DomTreeNode *IDomNode = getNodeForBlock(IDom);
|
||||||
|
|
||||||
// Add a new tree node for this BasicBlock, and link it as a child of
|
// Add a new tree node for this BasicBlock, and link it as a child of
|
||||||
// IDomNode
|
// IDomNode
|
||||||
return BBNode = IDomNode->addChild(new Node(BB, IDomNode));
|
return BBNode = IDomNode->addChild(new DomTreeNode(BB, IDomNode));
|
||||||
}
|
}
|
||||||
|
|
||||||
static std::ostream &operator<<(std::ostream &o,
|
static std::ostream &operator<<(std::ostream &o,
|
||||||
const DominatorTreeBase::Node *Node) {
|
const DominatorTreeBase::DomTreeNode *Node) {
|
||||||
if (Node->getBlock())
|
if (Node->getBlock())
|
||||||
WriteAsOperand(o, Node->getBlock(), false);
|
WriteAsOperand(o, Node->getBlock(), false);
|
||||||
else
|
else
|
||||||
@ -350,10 +350,10 @@ static std::ostream &operator<<(std::ostream &o,
|
|||||||
return o << "\n";
|
return o << "\n";
|
||||||
}
|
}
|
||||||
|
|
||||||
static void PrintDomTree(const DominatorTreeBase::Node *N, std::ostream &o,
|
static void PrintDomTree(const DominatorTreeBase::DomTreeNode *N, std::ostream &o,
|
||||||
unsigned Lev) {
|
unsigned Lev) {
|
||||||
o << std::string(2*Lev, ' ') << "[" << Lev << "] " << N;
|
o << std::string(2*Lev, ' ') << "[" << Lev << "] " << N;
|
||||||
for (DominatorTreeBase::Node::const_iterator I = N->begin(), E = N->end();
|
for (DominatorTreeBase::DomTreeNode::const_iterator I = N->begin(), E = N->end();
|
||||||
I != E; ++I)
|
I != E; ++I)
|
||||||
PrintDomTree(*I, o, Lev+1);
|
PrintDomTree(*I, o, Lev+1);
|
||||||
}
|
}
|
||||||
@ -387,19 +387,19 @@ namespace {
|
|||||||
class DFCalculateWorkObject {
|
class DFCalculateWorkObject {
|
||||||
public:
|
public:
|
||||||
DFCalculateWorkObject(BasicBlock *B, BasicBlock *P,
|
DFCalculateWorkObject(BasicBlock *B, BasicBlock *P,
|
||||||
const DominatorTree::Node *N,
|
const DominatorTree::DomTreeNode *N,
|
||||||
const DominatorTree::Node *PN)
|
const DominatorTree::DomTreeNode *PN)
|
||||||
: currentBB(B), parentBB(P), Node(N), parentNode(PN) {}
|
: currentBB(B), parentBB(P), DomTreeNode(N), parentNode(PN) {}
|
||||||
BasicBlock *currentBB;
|
BasicBlock *currentBB;
|
||||||
BasicBlock *parentBB;
|
BasicBlock *parentBB;
|
||||||
const DominatorTree::Node *Node;
|
const DominatorTree::DomTreeNode *DomTreeNode;
|
||||||
const DominatorTree::Node *parentNode;
|
const DominatorTree::DomTreeNode *parentNode;
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
const DominanceFrontier::DomSetType &
|
const DominanceFrontier::DomSetType &
|
||||||
DominanceFrontier::calculate(const DominatorTree &DT,
|
DominanceFrontier::calculate(const DominatorTree &DT,
|
||||||
const DominatorTree::Node *Node) {
|
const DominatorTree::DomTreeNode *Node) {
|
||||||
BasicBlock *BB = Node->getBlock();
|
BasicBlock *BB = Node->getBlock();
|
||||||
DomSetType *Result = NULL;
|
DomSetType *Result = NULL;
|
||||||
|
|
||||||
@ -413,8 +413,8 @@ DominanceFrontier::calculate(const DominatorTree &DT,
|
|||||||
|
|
||||||
BasicBlock *currentBB = currentW->currentBB;
|
BasicBlock *currentBB = currentW->currentBB;
|
||||||
BasicBlock *parentBB = currentW->parentBB;
|
BasicBlock *parentBB = currentW->parentBB;
|
||||||
const DominatorTree::Node *currentNode = currentW->Node;
|
const DominatorTree::DomTreeNode *currentNode = currentW->DomTreeNode;
|
||||||
const DominatorTree::Node *parentNode = currentW->parentNode;
|
const DominatorTree::DomTreeNode *parentNode = currentW->parentNode;
|
||||||
assert (currentBB && "Invalid work object. Missing current Basic Block");
|
assert (currentBB && "Invalid work object. Missing current Basic Block");
|
||||||
assert (currentNode && "Invalid work object. Missing current Node");
|
assert (currentNode && "Invalid work object. Missing current Node");
|
||||||
DomSetType &S = Frontiers[currentBB];
|
DomSetType &S = Frontiers[currentBB];
|
||||||
@ -436,9 +436,9 @@ DominanceFrontier::calculate(const DominatorTree &DT,
|
|||||||
// Loop through and visit the nodes that Node immediately dominates (Node's
|
// Loop through and visit the nodes that Node immediately dominates (Node's
|
||||||
// children in the IDomTree)
|
// children in the IDomTree)
|
||||||
bool visitChild = false;
|
bool visitChild = false;
|
||||||
for (DominatorTree::Node::const_iterator NI = currentNode->begin(),
|
for (DominatorTree::DomTreeNode::const_iterator NI = currentNode->begin(),
|
||||||
NE = currentNode->end(); NI != NE; ++NI) {
|
NE = currentNode->end(); NI != NE; ++NI) {
|
||||||
DominatorTree::Node *IDominee = *NI;
|
DominatorTree::DomTreeNode *IDominee = *NI;
|
||||||
BasicBlock *childBB = IDominee->getBlock();
|
BasicBlock *childBB = IDominee->getBlock();
|
||||||
if (visited.count(childBB) == 0) {
|
if (visited.count(childBB) == 0) {
|
||||||
workList.push_back(DFCalculateWorkObject(childBB, currentBB,
|
workList.push_back(DFCalculateWorkObject(childBB, currentBB,
|
||||||
@ -927,7 +927,7 @@ ETNode *ETForest::getNodeForBlock(BasicBlock *BB) {
|
|||||||
|
|
||||||
// Haven't calculated this node yet? Get or calculate the node for the
|
// Haven't calculated this node yet? Get or calculate the node for the
|
||||||
// immediate dominator.
|
// immediate dominator.
|
||||||
DominatorTree::Node *node= getAnalysis<DominatorTree>().getNode(BB);
|
DominatorTree::DomTreeNode *node= getAnalysis<DominatorTree>().getNode(BB);
|
||||||
|
|
||||||
// If we are unreachable, we may not have an immediate dominator.
|
// If we are unreachable, we may not have an immediate dominator.
|
||||||
if (!node || !node->getIDom())
|
if (!node || !node->getIDom())
|
||||||
@ -951,7 +951,7 @@ void ETForest::calculate(const DominatorTree &DT) {
|
|||||||
Function *F = Root->getParent();
|
Function *F = Root->getParent();
|
||||||
// Loop over all of the reachable blocks in the function...
|
// Loop over all of the reachable blocks in the function...
|
||||||
for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {
|
for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {
|
||||||
DominatorTree::Node* node = DT.getNode(I);
|
DominatorTree::DomTreeNode* node = DT.getNode(I);
|
||||||
if (node && node->getIDom()) { // Reachable block.
|
if (node && node->getIDom()) { // Reachable block.
|
||||||
BasicBlock* ImmDom = node->getIDom()->getBlock();
|
BasicBlock* ImmDom = node->getIDom()->getBlock();
|
||||||
ETNode *&BBNode = Nodes[I];
|
ETNode *&BBNode = Nodes[I];
|
||||||
|
Loading…
Reference in New Issue
Block a user