s/DominatorTreeBase::Node/DominatorTreeBase:DomTreeNode/g

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@37403 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/Dominators.h b/include/llvm/Analysis/Dominators.h
index b03c020704dbcb378596329e06b88b550ce12985..9a9a31b56c5e3b13a696da37d6732fcdff4ce41c 100644 (file)
--- a/include/llvm/Analysis/Dominators.h
+++ b/include/llvm/Analysis/Dominators.h
@@ -61,13 +61,13 @@ public:
 ///
 class DominatorTreeBase : public DominatorBase {
 public:
-  class Node;
+  class DomTreeNode;
 protected:
-  std::map<BasicBlock*, Node*> Nodes;
+  std::map<BasicBlock*, DomTreeNode*> DomTreeNodes;
   void reset();
-  typedef std::map<BasicBlock*, Node*> NodeMapType;
+  typedef std::map<BasicBlock*, DomTreeNode*> DomTreeNodeMapType;
 
-  Node *RootNode;
+  DomTreeNode *RootNode;
 
   struct InfoRec {
     unsigned Semi;
@@ -88,16 +88,16 @@ protected:
   std::map<BasicBlock*, InfoRec> Info;
 
 public:
-  class Node {
+  class DomTreeNode {
     friend class DominatorTree;
     friend struct PostDominatorTree;
     friend class DominatorTreeBase;
     BasicBlock *TheBB;
-    Node *IDom;
-    std::vector<Node*> Children;
+    DomTreeNode *IDom;
+    std::vector<DomTreeNode*> Children;
   public:
-    typedef std::vector<Node*>::iterator iterator;
-    typedef std::vector<Node*>::const_iterator const_iterator;
+    typedef std::vector<DomTreeNode*>::iterator iterator;
+    typedef std::vector<DomTreeNode*>::const_iterator const_iterator;
 
     iterator begin()             { return Children.begin(); }
     iterator end()               { return Children.end(); }
@@ -105,14 +105,14 @@ public:
     const_iterator end()   const { return Children.end(); }
 
     inline BasicBlock *getBlock() const { return TheBB; }
-    inline Node *getIDom() const { return IDom; }
-    inline const std::vector<Node*> &getChildren() const { return Children; }
+    inline DomTreeNode *getIDom() const { return IDom; }
+    inline const std::vector<DomTreeNode*> &getChildren() const { return Children; }
 
     /// properlyDominates - Returns true iff this dominates N and this != N.
     /// Note that this is not a constant time operation!
     ///
-    bool properlyDominates(const Node *N) const {
-      const Node *IDom;
+    bool properlyDominates(const DomTreeNode *N) const {
+      const DomTreeNode *IDom;
       if (this == 0 || N == 0) return false;
       while ((IDom = N->getIDom()) != 0 && IDom != this)
         N = IDom;   // Walk up the tree
@@ -122,16 +122,16 @@ public:
     /// dominates - Returns true iff this dominates N.  Note that this is not a
     /// 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.
       return properlyDominates(N);
     }
     
   private:
-    inline Node(BasicBlock *BB, Node *iDom) : TheBB(BB), IDom(iDom) {}
-    inline Node *addChild(Node *C) { Children.push_back(C); return C; }
+    inline DomTreeNode(BasicBlock *BB, DomTreeNode *iDom) : TheBB(BB), IDom(iDom) {}
+    inline DomTreeNode *addChild(DomTreeNode *C) { Children.push_back(C); return C; }
 
-    void setIDom(Node *NewIDom);
+    void setIDom(DomTreeNode *NewIDom);
   };
 
 public:
@@ -144,12 +144,12 @@ public:
   /// getNode - return the (Post)DominatorTree node for the specified basic
   /// block.  This is the same as using operator[] on this class.
   ///
-  inline Node *getNode(BasicBlock *BB) const {
-    NodeMapType::const_iterator i = Nodes.find(BB);
-    return (i != Nodes.end()) ? i->second : 0;
+  inline DomTreeNode *getNode(BasicBlock *BB) const {
+    DomTreeNodeMapType::const_iterator i = DomTreeNodes.find(BB);
+    return (i != DomTreeNodes.end()) ? i->second : 0;
   }
 
-  inline Node *operator[](BasicBlock *BB) const {
+  inline DomTreeNode *operator[](BasicBlock *BB) const {
     return getNode(BB);
   }
 
@@ -160,8 +160,8 @@ public:
   /// post-dominance information must be capable of dealing with this
   /// possibility.
   ///
-  Node *getRootNode() { return RootNode; }
-  const Node *getRootNode() const { return RootNode; }
+  DomTreeNode *getRootNode() { return RootNode; }
+  const DomTreeNode *getRootNode() const { return RootNode; }
 
   //===--------------------------------------------------------------------===//
   // 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
   /// 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(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
   /// 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!");
     N->setIDom(NewIDom);
   }
@@ -190,7 +190,7 @@ public:
   /// block.
   void removeNode(BasicBlock *BB) {
     assert(getNode(BB) && "Removing node that isn't in dominator tree.");
-    Nodes.erase(BB);
+    DomTreeNodes.erase(BB);
   }
 
   /// print - Convert to human readable form
@@ -223,7 +223,7 @@ public:
   }
 private:
   void calculate(Function& F);
-  Node *getNodeForBlock(BasicBlock *BB);
+  DomTreeNode *getNodeForBlock(BasicBlock *BB);
   unsigned DFSPass(BasicBlock *V, InfoRec &VInfo, unsigned N);
   void Compress(BasicBlock *V);
   BasicBlock *Eval(BasicBlock *v);
@@ -238,8 +238,8 @@ private:
 /// DominatorTree GraphTraits specialization so the DominatorTree can be
 /// iterable by generic graph iterators.
 ///
-template <> struct GraphTraits<DominatorTree::Node*> {
-  typedef DominatorTree::Node NodeType;
+template <> struct GraphTraits<DominatorTree::DomTreeNode*> {
+  typedef DominatorTree::DomTreeNode NodeType;
   typedef NodeType::iterator  ChildIteratorType;
   
   static NodeType *getEntryNode(NodeType *N) {
@@ -254,7 +254,7 @@ template <> struct GraphTraits<DominatorTree::Node*> {
 };
 
 template <> struct GraphTraits<DominatorTree*>
-  : public GraphTraits<DominatorTree::Node*> {
+  : public GraphTraits<DominatorTree::DomTreeNode*> {
   static NodeType *getEntryNode(DominatorTree *DT) {
     return DT->getRootNode();
   }
@@ -503,7 +503,7 @@ public:
   }
 private:
   const DomSetType &calculate(const DominatorTree &DT,
-                              const DominatorTree::Node *Node);
+                              const DominatorTree::DomTreeNode *Node);
 };
 
 

diff --git a/include/llvm/Analysis/PostDominators.h b/include/llvm/Analysis/PostDominators.h
index d5e6cd44839404fff6f59515312d7a87e5e3caa3..6acca2496169cda0c0f021f148cc052783876c61 100644 (file)
--- a/include/llvm/Analysis/PostDominators.h
+++ b/include/llvm/Analysis/PostDominators.h
@@ -38,7 +38,7 @@ struct PostDominatorTree : public DominatorTreeBase {
   }
 private:
   void calculate(Function &F);
-  Node *getNodeForBlock(BasicBlock *BB);
+  DomTreeNode *getNodeForBlock(BasicBlock *BB);
   unsigned DFSPass(BasicBlock *V, InfoRec &VInfo,unsigned N);
   void Compress(BasicBlock *V, InfoRec &VInfo);
   BasicBlock *Eval(BasicBlock *V);
@@ -87,7 +87,7 @@ struct PostDominanceFrontier : public DominanceFrontierBase {
     Frontiers.clear();
     PostDominatorTree &DT = getAnalysis<PostDominatorTree>();
     Roots = DT.getRoots();
-    if (const DominatorTree::Node *Root = DT.getRootNode())
+    if (const DominatorTree::DomTreeNode *Root = DT.getRootNode())
       calculate(DT, Root);
     return false;
   }
@@ -99,7 +99,7 @@ struct PostDominanceFrontier : public DominanceFrontierBase {
 
 private:
   const DomSetType &calculate(const PostDominatorTree &DT,
-                              const DominatorTree::Node *Node);
+                              const DominatorTree::DomTreeNode *Node);
 };
 
 } // End llvm namespace

diff --git a/lib/Analysis/PostDominators.cpp b/lib/Analysis/PostDominators.cpp
index 68424400dbfb5f4bfddb711e25141e82f934780b..15354729b7bcf2fef00c8b4d84b9168df2b5d421 100644 (file)
--- a/lib/Analysis/PostDominators.cpp
+++ b/lib/Analysis/PostDominators.cpp
@@ -165,19 +165,19 @@ void PostDominatorTree::calculate(Function &F) {
   // 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.
   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...
   for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
     if (BasicBlock *ImmPostDom = getIDom(I)) {  // Reachable block.
-      Node *&BBNode = Nodes[I];
+      DomTreeNode *&BBNode = DomTreeNodes[I];
       if (!BBNode) {  // Haven't calculated this node yet?
                       // 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
         // 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) {
-  Node *&BBNode = Nodes[BB];
+DominatorTreeBase::DomTreeNode *PostDominatorTree::getNodeForBlock(BasicBlock *BB) {
+  DomTreeNode *&BBNode = DomTreeNodes[BB];
   if (BBNode) return BBNode;
   
   // Haven't calculated this node yet?  Get or calculate the node for the
   // immediate postdominator.
   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
   // 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
   // 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 (!node)
@@ -245,7 +245,7 @@ void PostETForest::calculate(const PostDominatorTree &DT) {
     ETNode *&BBNode = Nodes[BB];
     if (!BBNode) {  
       ETNode *IDomNode =  NULL;
-      PostDominatorTree::Node *node = DT.getNode(BB);
+      PostDominatorTree::DomTreeNode *node = DT.getNode(BB);
       if (node && node->getIDom())
         IDomNode = getNodeForBlock(node->getIDom()->getBlock());
 
@@ -277,7 +277,7 @@ H("postdomfrontier", "Post-Dominance Frontier Construction", true);
 
 const DominanceFrontier::DomSetType &
 PostDominanceFrontier::calculate(const PostDominatorTree &DT,
-                                 const DominatorTree::Node *Node) {
+                                 const DominatorTree::DomTreeNode *Node) {
   // Loop over CFG successors to calculate DFlocal[Node]
   BasicBlock *BB = Node->getBlock();
   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);
          SI != SE; ++SI) {
       // Does Node immediately dominate this predecessor?
-      DominatorTree::Node *SINode = DT[*SI];
+      DominatorTree::DomTreeNode *SINode = DT[*SI];
       if (SINode && SINode->getIDom() != Node)
         S.insert(*SI);
     }
@@ -296,9 +296,9 @@ PostDominanceFrontier::calculate(const PostDominatorTree &DT,
   // Loop through and visit the nodes that Node immediately dominates (Node's
   // children in the IDomTree)
   //
-  for (PostDominatorTree::Node::const_iterator
+  for (PostDominatorTree::DomTreeNode::const_iterator
          NI = Node->begin(), NE = Node->end(); NI != NE; ++NI) {
-    DominatorTree::Node *IDominee = *NI;
+    DominatorTree::DomTreeNode *IDominee = *NI;
     const DomSetType &ChildDF = calculate(DT, IDominee);
 
     DomSetType::const_iterator CDFI = ChildDF.begin(), CDFE = ChildDF.end();

diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp
index 8219855faf437dcc7e74c0d515fec79987b0744d..5bfb587cbe996111c85de4d439a9f0490a4c611a 100644 (file)
--- a/lib/Transforms/Scalar/ADCE.cpp
+++ b/lib/Transforms/Scalar/ADCE.cpp
@@ -387,8 +387,8 @@ bool ADCE::doADCE() {
           // postdominator that is alive, and the last postdominator that is
           // dead...
           //
-          PostDominatorTree::Node *LastNode = DT[TI->getSuccessor(i)];
-          PostDominatorTree::Node *NextNode = 0;
+          PostDominatorTree::DomTreeNode *LastNode = DT[TI->getSuccessor(i)];
+          PostDominatorTree::DomTreeNode *NextNode = 0;
 
           if (LastNode) {
             NextNode = LastNode->getIDom();

diff --git a/lib/Transforms/Scalar/GCSE.cpp b/lib/Transforms/Scalar/GCSE.cpp
index c46c36a1cbb087c7263ced6419b999f2472550de..eb68f5a2727e5ed7a1c2fd192a745b00ae57f8bf 100644 (file)
--- a/lib/Transforms/Scalar/GCSE.cpp
+++ b/lib/Transforms/Scalar/GCSE.cpp
@@ -94,7 +94,7 @@ bool GCSE::runOnFunction(Function &F) {
 
   // Traverse the CFG of the function in dominator order, so that we see each
   // 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) {
     BasicBlock *BB = DI->getBlock();
 

diff --git a/lib/Transforms/Scalar/GVNPRE.cpp b/lib/Transforms/Scalar/GVNPRE.cpp
index 6a9a08e43090c84577a2d3655bdee44aeb4824f4..2a5e0f3fa7f71be376b8597ff4cde51360da9be8 100644 (file)
--- a/lib/Transforms/Scalar/GVNPRE.cpp
+++ b/lib/Transforms/Scalar/GVNPRE.cpp
@@ -87,7 +87,7 @@ namespace {
     // For a given block, calculate the generated expressions, temporaries,
     // and the AVAIL_OUT set
     void CalculateAvailOut(ValueTable& VN, std::set<Value*, ExprLT>& MS,
-                       DominatorTree::Node* DI,
+                       DominatorTree::DomTreeNode* DI,
                        std::set<Value*, ExprLT>& currExps,
                        std::set<PHINode*>& currPhis,
                        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,
-                       DominatorTree::Node* DI,
+                       DominatorTree::DomTreeNode* DI,
                        std::set<Value*, ExprLT>& currExps,
                        std::set<PHINode*>& currPhis,
                        std::set<Value*, ExprLT>& currTemps,
@@ -324,7 +324,7 @@ bool GVNPRE::runOnFunction(Function &F) {
   // First Phase of BuildSets - calculate AVAIL_OUT
   
   // 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) {
     
     // Get the sets to update for this block
@@ -350,7 +350,7 @@ bool GVNPRE::runOnFunction(Function &F) {
     std::set<Value*, ExprLT> anticOut;
     
     // 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());
          PDI != E; ++PDI) {
       BasicBlock* BB = PDI->getBlock();

diff --git a/lib/Transforms/Scalar/LICM.cpp b/lib/Transforms/Scalar/LICM.cpp
index 3b16814fe86d07b93608e5a2b52f7f49f9403983..81284d4f522740b91e1b90612e98b56afcaca1f4 100644 (file)
--- a/lib/Transforms/Scalar/LICM.cpp
+++ b/lib/Transforms/Scalar/LICM.cpp
@@ -107,7 +107,7 @@ namespace {
     /// visit uses before definitions, allowing us to sink a loop body in one
     /// pass without iteration.
     ///
-    void SinkRegion(DominatorTree::Node *N);
+    void SinkRegion(DominatorTree::DomTreeNode *N);
 
     /// HoistRegion - Walk the specified region of the CFG (defined by all
     /// 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
     /// pass without iteration.
     ///
-    void HoistRegion(DominatorTree::Node *N);
+    void HoistRegion(DominatorTree::DomTreeNode *N);
 
     /// inSubLoop - Little predicate that returns true if the specified basic
     /// block is in a subloop of the current one, not the current one itself.
@@ -140,8 +140,8 @@ namespace {
       if (BlockInLoop == LoopHeader)
         return true;
 
-      DominatorTree::Node *BlockInLoopNode = DT->getNode(BlockInLoop);
-      DominatorTree::Node *IDom            = DT->getNode(ExitBlock);
+      DominatorTree::DomTreeNode *BlockInLoopNode = DT->getNode(BlockInLoop);
+      DominatorTree::DomTreeNode *IDom            = DT->getNode(ExitBlock);
 
       // Because the exit block is not in the loop, we know we have to get _at
       // 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
 /// iteration.
 ///
-void LICM::SinkRegion(DominatorTree::Node *N) {
+void LICM::SinkRegion(DominatorTree::DomTreeNode *N) {
   assert(N != 0 && "Null dominator tree node?");
   BasicBlock *BB = N->getBlock();
 
@@ -289,7 +289,7 @@ void LICM::SinkRegion(DominatorTree::Node *N) {
   if (!CurLoop->contains(BB)) return;
 
   // 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)
     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
 /// 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?");
   BasicBlock *BB = N->getBlock();
 
@@ -340,7 +340,7 @@ void LICM::HoistRegion(DominatorTree::Node *N) {
         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)
     HoistRegion(Children[i]);
 }

diff --git a/lib/Transforms/Scalar/PredicateSimplifier.cpp b/lib/Transforms/Scalar/PredicateSimplifier.cpp
index b7718d0cff43f9259dbec1a22d0e974d930914bc..5385c1a81886fa1833ac9be3325283898257a494 100644 (file)
--- a/lib/Transforms/Scalar/PredicateSimplifier.cpp
+++ b/lib/Transforms/Scalar/PredicateSimplifier.cpp
@@ -1986,7 +1986,7 @@ namespace {
     UnreachableBlocks UB;
     ValueRanges *VR;
 
-    std::vector<DominatorTree::Node *> WorkList;
+    std::vector<DominatorTree::DomTreeNode *> WorkList;
 
   public:
     static char ID; // Pass identification, replacement for typeid
@@ -2012,14 +2012,14 @@ namespace {
     class VISIBILITY_HIDDEN Forwards : public InstVisitor<Forwards> {
       friend class InstVisitor<Forwards>;
       PredicateSimplifier *PS;
-      DominatorTree::Node *DTNode;
+      DominatorTree::DomTreeNode *DTNode;
 
     public:
       InequalityGraph &IG;
       UnreachableBlocks &UB;
       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) {}
 
       void visitTerminatorInst(TerminatorInst &TI);
@@ -2040,19 +2040,19 @@ namespace {
     // Used by terminator instructions to proceed from the current basic
     // block to the next. Verifies that "current" dominates "next",
     // then calls visitBasicBlock.
-    void proceedToSuccessors(DominatorTree::Node *Current) {
-      for (DominatorTree::Node::iterator I = Current->begin(),
+    void proceedToSuccessors(DominatorTree::DomTreeNode *Current) {
+      for (DominatorTree::DomTreeNode::iterator I = Current->begin(),
            E = Current->end(); I != E; ++I) {
         WorkList.push_back(*I);
       }
     }
 
-    void proceedToSuccessor(DominatorTree::Node *Next) {
+    void proceedToSuccessor(DominatorTree::DomTreeNode *Next) {
       WorkList.push_back(Next);
     }
 
     // Visits each instruction in the basic block.
-    void visitBasicBlock(DominatorTree::Node *Node) {
+    void visitBasicBlock(DominatorTree::DomTreeNode *Node) {
       BasicBlock *BB = Node->getBlock();
       ETNode *ET = Forest->getNodeForBlock(BB);
       DOUT << "Entering Basic Block: " << BB->getName()
@@ -2064,7 +2064,7 @@ namespace {
 
     // Tries to simplify each Instruction and add new properties to
     // 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";
       DEBUG(IG->dump());
 
@@ -2132,7 +2132,7 @@ namespace {
     WorkList.push_back(DT->getRootNode());
 
     do {
-      DominatorTree::Node *DTNode = WorkList.back();
+      DominatorTree::DomTreeNode *DTNode = WorkList.back();
       WorkList.pop_back();
       if (!UB.isDead(DTNode->getBlock())) visitBasicBlock(DTNode);
     } while (!WorkList.empty());
@@ -2164,7 +2164,7 @@ namespace {
       return;
     }
 
-    for (DominatorTree::Node::iterator I = DTNode->begin(), E = DTNode->end();
+    for (DominatorTree::DomTreeNode::iterator I = DTNode->begin(), E = DTNode->end();
          I != E; ++I) {
       BasicBlock *Dest = (*I)->getBlock();
       DOUT << "Branch thinking about %" << Dest->getName()
@@ -2194,7 +2194,7 @@ namespace {
     // Set the EQProperty in each of the cases BBs, and the NEProperties
     // 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) {
       BasicBlock *BB = (*I)->getBlock();
       DOUT << "Switch thinking about BB %" << BB->getName()

diff --git a/lib/Transforms/Utils/BreakCriticalEdges.cpp b/lib/Transforms/Utils/BreakCriticalEdges.cpp
index ef07ec48c8f7e4a2ed535ef02241641766b97887..03cd533cf260763cb1d61db3f7d523f9a5473795 100644 (file)
--- a/lib/Transforms/Utils/BreakCriticalEdges.cpp
+++ b/lib/Transforms/Utils/BreakCriticalEdges.cpp
@@ -203,20 +203,20 @@ bool llvm::SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum, Pass *P,
   
   // Should we update DominatorTree information?
   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
     // TINode is the immediate dominator for the new node.
     //
     if (TINode) {       // Don't break unreachable code!
-      DominatorTree::Node *NewBBNode = DT->createNewNode(NewBB, TINode);
-      DominatorTree::Node *DestBBNode = 0;
+      DominatorTree::DomTreeNode *NewBBNode = DT->createNewNode(NewBB, TINode);
+      DominatorTree::DomTreeNode *DestBBNode = 0;
      
       // If NewBBDominatesDestBB hasn't been computed yet, do so with DT.
       if (!OtherPreds.empty()) {
         DestBBNode = DT->getNode(DestBB);
         while (!OtherPreds.empty() && NewBBDominatesDestBB) {
-          if (DominatorTree::Node *OPNode = DT->getNode(OtherPreds.back()))
+          if (DominatorTree::DomTreeNode *OPNode = DT->getNode(OtherPreds.back()))
             NewBBDominatesDestBB = DestBBNode->dominates(OPNode);
           OtherPreds.pop_back();
         }

diff --git a/lib/Transforms/Utils/LCSSA.cpp b/lib/Transforms/Utils/LCSSA.cpp
index b51d7b51d36fcb8b10f4638ee42d3162bf660255..84b00b2fdc8d34c3b65a46911355e46b347709df 100644 (file)
--- a/lib/Transforms/Utils/LCSSA.cpp
+++ b/lib/Transforms/Utils/LCSSA.cpp
@@ -75,8 +75,8 @@ namespace {
     void getLoopValuesUsedOutsideLoop(Loop *L,
                                       SetVector<Instruction*> &AffectedValues);
 
-    Value *GetValueForBlock(DominatorTree::Node *BB, Instruction *OrigInst,
-                            std::map<DominatorTree::Node*, Value*> &Phis);
+    Value *GetValueForBlock(DominatorTree::DomTreeNode *BB, Instruction *OrigInst,
+                            std::map<DominatorTree::DomTreeNode*, Value*> &Phis);
 
     /// inLoop - returns true if the given block is within the current loop
     const bool inLoop(BasicBlock* B) {
@@ -146,16 +146,16 @@ void LCSSA::ProcessInstruction(Instruction *Instr,
   ++NumLCSSA; // We are applying the transformation
 
   // 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
   // add them to the Phi's map.
   for (std::vector<BasicBlock*>::const_iterator BBI = exitBlocks.begin(),
       BBE = exitBlocks.end(); BBI != BBE; ++BBI) {
     BasicBlock *BB = *BBI;
-    DominatorTree::Node *ExitBBNode = DT->getNode(BB);
+    DominatorTree::DomTreeNode *ExitBBNode = DT->getNode(BB);
     Value *&Phi = Phis[ExitBBNode];
     if (!Phi && InstrNode->dominates(ExitBBNode)) {
       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.
 /// available values are in Phis.
-Value *LCSSA::GetValueForBlock(DominatorTree::Node *BB, Instruction *OrigInst,
-                               std::map<DominatorTree::Node*, Value*> &Phis) {
+Value *LCSSA::GetValueForBlock(DominatorTree::DomTreeNode *BB, Instruction *OrigInst,
+                               std::map<DominatorTree::DomTreeNode*, Value*> &Phis) {
   // If there is no dominator info for this BB, it is unreachable.
   if (BB == 0)
     return UndefValue::get(OrigInst->getType());
@@ -239,7 +239,7 @@ Value *LCSSA::GetValueForBlock(DominatorTree::Node *BB, Instruction *OrigInst,
   Value *&V = Phis[BB];
   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
   // don't.  We need to insert a PHI node if this block is not dominated by one

diff --git a/lib/Transforms/Utils/LoopSimplify.cpp b/lib/Transforms/Utils/LoopSimplify.cpp
index badfb462a9b551f08d9f7af22ff249753d15d09f..67ffa71202b7e568350eab2337b2f72fc6368993 100644 (file)
--- a/lib/Transforms/Utils/LoopSimplify.cpp
+++ b/lib/Transforms/Utils/LoopSimplify.cpp
@@ -778,15 +778,15 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
       }
       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.
-    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
     // dominator of NewBBSucc.  Update the dominator tree as appropriate.
     if (NewBBDominatesNewBBSucc) {
-      DominatorTree::Node *NewBBSuccNode = DT->getNode(NewBBSucc);
+      DominatorTree::DomTreeNode *NewBBSuccNode = DT->getNode(NewBBSucc);
       DT->changeImmediateDominator(NewBBSuccNode, NewBBNode);
     }
   }

diff --git a/lib/VMCore/Dominators.cpp b/lib/VMCore/Dominators.cpp
index 32e40f05b9789f2473dbee4fdc543b00ec6382f9..e9ab25c2833099cd34f4adcb58cc2c015e6b05d7 100644 (file)
--- a/lib/VMCore/Dominators.cpp
+++ b/lib/VMCore/Dominators.cpp
@@ -234,7 +234,7 @@ void DominatorTree::Link(BasicBlock *V, BasicBlock *W, InfoRec &WInfo){
 void DominatorTree::calculate(Function& F) {
   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);
 
@@ -282,14 +282,14 @@ void DominatorTree::calculate(Function& F) {
   // Loop over all of the reachable blocks in the function...
   for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
     if (BasicBlock *ImmDom = getIDom(I)) {  // Reachable block.
-      Node *&BBNode = Nodes[I];
+      DomTreeNode *&BBNode = DomTreeNodes[I];
       if (!BBNode) {  // Haven't calculated this node yet?
         // 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
         // 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.
 //
 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;
-  Nodes.clear();
+  DomTreeNodes.clear();
   IDoms.clear();
   Roots.clear();
   Vertex.clear();
   RootNode = 0;
 }
 
-void DominatorTreeBase::Node::setIDom(Node *NewIDom) {
+void DominatorTreeBase::DomTreeNode::setIDom(DomTreeNode *NewIDom) {
   assert(IDom && "No immediate dominator?");
   if (IDom != NewIDom) {
-    std::vector<Node*>::iterator I =
+    std::vector<DomTreeNode*>::iterator I =
       std::find(IDom->Children.begin(), IDom->Children.end(), this);
     assert(I != IDom->Children.end() &&
            "Not in immediate dominator children set!");
@@ -327,22 +327,22 @@ void DominatorTreeBase::Node::setIDom(Node *NewIDom) {
   }
 }
 
-DominatorTreeBase::Node *DominatorTree::getNodeForBlock(BasicBlock *BB) {
-  Node *&BBNode = Nodes[BB];
+DominatorTreeBase::DomTreeNode *DominatorTree::getNodeForBlock(BasicBlock *BB) {
+  DomTreeNode *&BBNode = DomTreeNodes[BB];
   if (BBNode) return BBNode;
 
   // Haven't calculated this node yet?  Get or calculate the node for the
   // immediate dominator.
   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
   // IDomNode
-  return BBNode = IDomNode->addChild(new Node(BB, IDomNode));
+  return BBNode = IDomNode->addChild(new DomTreeNode(BB, IDomNode));
 }
 
 static std::ostream &operator<<(std::ostream &o,
-                                const DominatorTreeBase::Node *Node) {
+                                const DominatorTreeBase::DomTreeNode *Node) {
   if (Node->getBlock())
     WriteAsOperand(o, Node->getBlock(), false);
   else
@@ -350,10 +350,10 @@ static std::ostream &operator<<(std::ostream &o,
   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) {
   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)
     PrintDomTree(*I, o, Lev+1);
 }
@@ -387,19 +387,19 @@ namespace {
   class DFCalculateWorkObject {
   public:
     DFCalculateWorkObject(BasicBlock *B, BasicBlock *P, 
-                          const DominatorTree::Node *N,
-                          const DominatorTree::Node *PN)
-    : currentBB(B), parentBB(P), Node(N), parentNode(PN) {}
+                          const DominatorTree::DomTreeNode *N,
+                          const DominatorTree::DomTreeNode *PN)
+    : currentBB(B), parentBB(P), DomTreeNode(N), parentNode(PN) {}
     BasicBlock *currentBB;
     BasicBlock *parentBB;
-    const DominatorTree::Node *Node;
-    const DominatorTree::Node *parentNode;
+    const DominatorTree::DomTreeNode *DomTreeNode;
+    const DominatorTree::DomTreeNode *parentNode;
   };
 }
 
 const DominanceFrontier::DomSetType &
 DominanceFrontier::calculate(const DominatorTree &DT,
-                             const DominatorTree::Node *Node) {
+                             const DominatorTree::DomTreeNode *Node) {
   BasicBlock *BB = Node->getBlock();
   DomSetType *Result = NULL;
 
@@ -413,8 +413,8 @@ DominanceFrontier::calculate(const DominatorTree &DT,
 
     BasicBlock *currentBB = currentW->currentBB;
     BasicBlock *parentBB = currentW->parentBB;
-    const DominatorTree::Node *currentNode = currentW->Node;
-    const DominatorTree::Node *parentNode = currentW->parentNode;
+    const DominatorTree::DomTreeNode *currentNode = currentW->DomTreeNode;
+    const DominatorTree::DomTreeNode *parentNode = currentW->parentNode;
     assert (currentBB && "Invalid work object. Missing current Basic Block");
     assert (currentNode && "Invalid work object. Missing current Node");
     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
     // children in the IDomTree)
     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) {
-      DominatorTree::Node *IDominee = *NI;
+      DominatorTree::DomTreeNode *IDominee = *NI;
       BasicBlock *childBB = IDominee->getBlock();
       if (visited.count(childBB) == 0) {
         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
   // 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 (!node || !node->getIDom())
@@ -951,7 +951,7 @@ void ETForest::calculate(const DominatorTree &DT) {
   Function *F = Root->getParent();
   // Loop over all of the reachable blocks in the function...
   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.
       BasicBlock* ImmDom = node->getIDom()->getBlock();
       ETNode *&BBNode = Nodes[I];