From 35854cb40b1359f8392e24eba32df749df6bb761 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Wed, 14 Jan 2015 03:56:00 +0000 Subject: [PATCH] [dom] The formatting of the generic domtree has bitrotted over the years significantly. Clean it up with the help of clang-format. I've touched this up by hand in a couple of places that weren't quite right (IMO). I think most of these actually have bugs open about already. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225938 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Support/GenericDomTree.h | 201 +++++++++++++------------- 1 file changed, 99 insertions(+), 102 deletions(-) diff --git a/include/llvm/Support/GenericDomTree.h b/include/llvm/Support/GenericDomTree.h index 12a1f5d6178..aa182c7ab56 100644 --- a/include/llvm/Support/GenericDomTree.h +++ b/include/llvm/Support/GenericDomTree.h @@ -31,71 +31,65 @@ namespace llvm { /// \brief Base class that other, more interesting dominator analyses /// inherit from. -template -class DominatorBase { +template class DominatorBase { protected: - std::vector Roots; + std::vector Roots; const bool IsPostDominators; - inline explicit DominatorBase(bool isPostDom) : - Roots(), IsPostDominators(isPostDom) {} -public: + inline explicit DominatorBase(bool isPostDom) + : Roots(), IsPostDominators(isPostDom) {} +public: /// getRoots - Return the root blocks of the current CFG. This may include /// multiple blocks if we are computing post dominators. For forward /// dominators, this will always be a single block (the entry node). /// - inline const std::vector &getRoots() const { return Roots; } + inline const std::vector &getRoots() const { return Roots; } /// isPostDominator - Returns true if analysis based of postdoms /// bool isPostDominator() const { return IsPostDominators; } }; - -template class DominatorTreeBase; +template class DominatorTreeBase; struct PostDominatorTree; /// \brief Base class for the actual dominator tree node. -template -class DomTreeNodeBase { +template class DomTreeNodeBase { NodeT *TheBB; DomTreeNodeBase *IDom; std::vector *> Children; mutable int DFSNumIn, DFSNumOut; - template friend class DominatorTreeBase; + template friend class DominatorTreeBase; friend struct PostDominatorTree; + public: typedef typename std::vector *>::iterator iterator; typedef typename std::vector *>::const_iterator - const_iterator; + const_iterator; - iterator begin() { return Children.begin(); } - iterator end() { return Children.end(); } + iterator begin() { return Children.begin(); } + iterator end() { return Children.end(); } const_iterator begin() const { return Children.begin(); } - const_iterator end() const { return Children.end(); } + const_iterator end() const { return Children.end(); } NodeT *getBlock() const { return TheBB; } DomTreeNodeBase *getIDom() const { return IDom; } - const std::vector*> &getChildren() const { + const std::vector *> &getChildren() const { return Children; } DomTreeNodeBase(NodeT *BB, DomTreeNodeBase *iDom) - : TheBB(BB), IDom(iDom), DFSNumIn(-1), DFSNumOut(-1) { } + : TheBB(BB), IDom(iDom), DFSNumIn(-1), DFSNumOut(-1) {} DomTreeNodeBase *addChild(DomTreeNodeBase *C) { Children.push_back(C); return C; } - size_t getNumChildren() const { - return Children.size(); - } + size_t getNumChildren() const { return Children.size(); } - void clearAllChildren() { - Children.clear(); - } + void clearAllChildren() { Children.clear(); } bool compare(const DomTreeNodeBase *Other) const { if (getNumChildren() != Other->getNumChildren()) @@ -118,8 +112,8 @@ public: void setIDom(DomTreeNodeBase *NewIDom) { assert(IDom && "No immediate dominator?"); if (IDom != NewIDom) { - typename std::vector*>::iterator I = - std::find(IDom->Children.begin(), IDom->Children.end(), this); + typename std::vector *>::iterator I = + std::find(IDom->Children.begin(), IDom->Children.end(), this); assert(I != IDom->Children.end() && "Not in immediate dominator children set!"); // I am no longer your child... @@ -135,16 +129,17 @@ public: /// 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. bool DominatedBy(const DomTreeNodeBase *other) const { return this->DFSNumIn >= other->DFSNumIn && - this->DFSNumOut <= other->DFSNumOut; + this->DFSNumOut <= other->DFSNumOut; } }; -template +template inline raw_ostream &operator<<(raw_ostream &o, const DomTreeNodeBase *Node) { if (Node->getBlock()) @@ -157,26 +152,26 @@ inline raw_ostream &operator<<(raw_ostream &o, return o << "\n"; } -template +template inline void PrintDomTree(const DomTreeNodeBase *N, raw_ostream &o, unsigned Lev) { - o.indent(2*Lev) << "[" << Lev << "] " << N; + o.indent(2 * Lev) << "[" << Lev << "] " << N; for (typename DomTreeNodeBase::const_iterator I = N->begin(), - E = N->end(); I != E; ++I) - PrintDomTree(*I, o, Lev+1); + E = N->end(); + I != E; ++I) + PrintDomTree(*I, o, Lev + 1); } // The calculate routine is provided in a separate header but referenced here. -template -void Calculate(DominatorTreeBase::NodeType>& DT, - FuncT& F); +template +void Calculate(DominatorTreeBase::NodeType> &DT, + FuncT &F); /// \brief Core dominator tree base class. /// /// This class is a generic template over graph nodes. It is instantiated for /// various graphs in the LLVM IR or in the code generator. -template -class DominatorTreeBase : public DominatorBase { +template class DominatorTreeBase : public DominatorBase { bool dominatedBySlowTreeWalk(const DomTreeNodeBase *A, const DomTreeNodeBase *B) const { assert(A != B); @@ -185,12 +180,12 @@ class DominatorTreeBase : public DominatorBase { const DomTreeNodeBase *IDom; while ((IDom = B->getIDom()) != nullptr && IDom != A && IDom != B) - B = IDom; // Walk up the tree + B = IDom; // Walk up the tree return IDom != nullptr; } protected: - typedef DenseMap*> DomTreeNodeMapType; + typedef DenseMap *> DomTreeNodeMapType; DomTreeNodeMapType DomTreeNodes; DomTreeNodeBase *RootNode; @@ -206,17 +201,18 @@ protected: InfoRec() : DFSNum(0), Parent(0), Semi(0), Label(nullptr) {} }; - DenseMap IDoms; + DenseMap IDoms; // Vertex - Map the DFS number to the NodeT* - std::vector Vertex; + std::vector Vertex; // Info - Collection of information used during the computation of idoms. - DenseMap Info; + DenseMap Info; void reset() { for (typename DomTreeNodeMapType::iterator I = this->DomTreeNodes.begin(), - E = DomTreeNodes.end(); I != E; ++I) + E = DomTreeNodes.end(); + I != E; ++I) delete I->second; DomTreeNodes.clear(); IDoms.clear(); @@ -227,27 +223,29 @@ protected: // NewBB is split and now it has one successor. Update dominator tree to // reflect this change. - template - void Split(DominatorTreeBase& DT, - typename GraphT::NodeType* NewBB) { + template + void Split(DominatorTreeBase &DT, + typename GraphT::NodeType *NewBB) { assert(std::distance(GraphT::child_begin(NewBB), GraphT::child_end(NewBB)) == 1 && "NewBB should have a single successor!"); - typename GraphT::NodeType* NewBBSucc = *GraphT::child_begin(NewBB); + typename GraphT::NodeType *NewBBSucc = *GraphT::child_begin(NewBB); - std::vector PredBlocks; - typedef GraphTraits > InvTraits; - for (typename InvTraits::ChildIteratorType PI = - InvTraits::child_begin(NewBB), - PE = InvTraits::child_end(NewBB); PI != PE; ++PI) + std::vector PredBlocks; + typedef GraphTraits> InvTraits; + for (typename InvTraits::ChildIteratorType + PI = InvTraits::child_begin(NewBB), + PE = InvTraits::child_end(NewBB); + PI != PE; ++PI) PredBlocks.push_back(*PI); assert(!PredBlocks.empty() && "No predblocks?"); bool NewBBDominatesNewBBSucc = true; - for (typename InvTraits::ChildIteratorType PI = - InvTraits::child_begin(NewBBSucc), - E = InvTraits::child_end(NewBBSucc); PI != E; ++PI) { + for (typename InvTraits::ChildIteratorType + PI = InvTraits::child_begin(NewBBSucc), + E = InvTraits::child_end(NewBBSucc); + PI != E; ++PI) { typename InvTraits::NodeType *ND = *PI; if (ND != NewBB && !DT.dominates(NewBBSucc, ND) && DT.isReachableFromEntry(ND)) { @@ -290,7 +288,7 @@ protected: public: explicit DominatorTreeBase(bool isPostDom) - : DominatorBase(isPostDom), DFSInfoValid(false), SlowQueries(0) {} + : DominatorBase(isPostDom), DFSInfoValid(false), SlowQueries(0) {} virtual ~DominatorTreeBase() { reset(); } /// compare - Return false if the other dominator tree base matches this @@ -302,15 +300,17 @@ public: return true; for (typename DomTreeNodeMapType::const_iterator - I = this->DomTreeNodes.begin(), - E = this->DomTreeNodes.end(); I != E; ++I) { + I = this->DomTreeNodes.begin(), + E = this->DomTreeNodes.end(); + I != E; ++I) { NodeT *BB = I->first; - typename DomTreeNodeMapType::const_iterator OI = OtherDomTreeNodes.find(BB); + typename DomTreeNodeMapType::const_iterator OI = + OtherDomTreeNodes.find(BB); if (OI == OtherDomTreeNodes.end()) return true; - DomTreeNodeBase* MyNd = I->second; - DomTreeNodeBase* OtherNd = OI->second; + DomTreeNodeBase *MyNd = I->second; + DomTreeNodeBase *OtherNd = OI->second; if (MyNd->compare(OtherNd)) return true; @@ -374,7 +374,7 @@ public: /// isReachableFromEntry - Return true if A is dominated by the entry /// block of the function containing it. - bool isReachableFromEntry(const NodeT* A) const { + bool isReachableFromEntry(const NodeT *A) const { assert(!this->isPostDominator() && "This is not implemented for post dominators"); return isReachableFromEntry(getNode(const_cast(A))); @@ -471,7 +471,7 @@ public: } // Collect NodeA dominators set. - SmallPtrSet*, 16> NodeADoms; + SmallPtrSet *, 16> NodeADoms; NodeADoms.insert(NodeA); DomTreeNodeBase *IDomA = NodeA->getIDom(); while (IDomA) { @@ -511,7 +511,7 @@ public: assert(IDomNode && "Not immediate dominator specified for block!"); DFSInfoValid = false; return DomTreeNodes[BB] = - IDomNode->addChild(new DomTreeNodeBase(BB, IDomNode)); + IDomNode->addChild(new DomTreeNodeBase(BB, IDomNode)); } /// changeImmediateDominator - This method is used to update the dominator @@ -536,11 +536,11 @@ public: assert(Node && "Removing node that isn't in dominator tree."); assert(Node->getChildren().empty() && "Node is not a leaf node."); - // Remove node from immediate dominator's children list. + // Remove node from immediate dominator's children list. DomTreeNodeBase *IDom = Node->getIDom(); if (IDom) { - typename std::vector*>::iterator I = - std::find(IDom->Children.begin(), IDom->Children.end(), Node); + typename std::vector *>::iterator I = + std::find(IDom->Children.begin(), IDom->Children.end(), Node); assert(I != IDom->Children.end() && "Not in immediate dominator children set!"); // I am no longer your child... @@ -561,11 +561,12 @@ public: /// splitBlock - BB is split and now it has one successor. Update dominator /// tree to reflect this change. - void splitBlock(NodeT* NewBB) { + void splitBlock(NodeT *NewBB) { if (this->IsPostDominators) - this->Split, GraphTraits > >(*this, NewBB); + this->Split, GraphTraits>>(*this, + NewBB); else - this->Split >(*this, NewBB); + this->Split>(*this, NewBB); } /// print - Convert to human readable form @@ -586,28 +587,27 @@ public: } protected: - template - friend typename GraphT::NodeType* Eval( - DominatorTreeBase& DT, - typename GraphT::NodeType* V, - unsigned LastLinked); + template + friend typename GraphT::NodeType * + Eval(DominatorTreeBase &DT, + typename GraphT::NodeType *V, unsigned LastLinked); - template - friend unsigned DFSPass(DominatorTreeBase& DT, - typename GraphT::NodeType* V, - unsigned N); + template + friend unsigned DFSPass(DominatorTreeBase &DT, + typename GraphT::NodeType *V, unsigned N); - template - friend void Calculate(DominatorTreeBase::NodeType>& DT, - FuncT& F); + template + friend void + Calculate(DominatorTreeBase::NodeType> &DT, FuncT &F); /// updateDFSNumbers - Assign In and Out numbers to the nodes while walking /// dominator tree in dfs order. void updateDFSNumbers() const { unsigned DFSNum = 0; - SmallVector*, - typename DomTreeNodeBase::const_iterator>, 32> WorkStack; + SmallVector *, + typename DomTreeNodeBase::const_iterator>, + 32> WorkStack; const DomTreeNodeBase *ThisRoot = getRootNode(); @@ -624,7 +624,7 @@ protected: while (!WorkStack.empty()) { const DomTreeNodeBase *Node = WorkStack.back().first; typename DomTreeNodeBase::const_iterator ChildIt = - WorkStack.back().second; + WorkStack.back().second; // If we visited all of the children of this node, "recurse" back up the // stack setting the DFOutNum. @@ -662,19 +662,14 @@ protected: return this->DomTreeNodes[BB] = IDomNode->addChild(C); } - inline NodeT *getIDom(NodeT *BB) const { - return IDoms.lookup(BB); - } + inline NodeT *getIDom(NodeT *BB) const { return IDoms.lookup(BB); } - inline void addRoot(NodeT* BB) { - this->Roots.push_back(BB); - } + inline void addRoot(NodeT *BB) { this->Roots.push_back(BB); } public: /// recalculate - compute a dominator tree for the given function - template - void recalculate(FT& F) { - typedef GraphTraits TraitsTy; + template void recalculate(FT &F) { + typedef GraphTraits TraitsTy; reset(); this->Vertex.push_back(nullptr); @@ -685,27 +680,29 @@ public: this->IDoms[entry] = nullptr; this->DomTreeNodes[entry] = nullptr; - Calculate(*this, F); + Calculate(*this, F); } else { // Initialize the roots list for (typename TraitsTy::nodes_iterator I = TraitsTy::nodes_begin(&F), - E = TraitsTy::nodes_end(&F); I != E; ++I) { + E = TraitsTy::nodes_end(&F); + I != E; ++I) { if (TraitsTy::child_begin(I) == TraitsTy::child_end(I)) addRoot(I); - // Prepopulate maps so that we don't get iterator invalidation issues later. + // Prepopulate maps so that we don't get iterator invalidation issues + // later. this->IDoms[I] = nullptr; this->DomTreeNodes[I] = nullptr; } - Calculate >(*this, F); + Calculate>(*this, F); } } }; // These two functions are declared out of line as a workaround for building // with old (< r147295) versions of clang because of pr11642. -template +template bool DominatorTreeBase::dominates(const NodeT *A, const NodeT *B) const { if (A == B) return true; @@ -716,9 +713,9 @@ bool DominatorTreeBase::dominates(const NodeT *A, const NodeT *B) const { return dominates(getNode(const_cast(A)), getNode(const_cast(B))); } -template -bool -DominatorTreeBase::properlyDominates(const NodeT *A, const NodeT *B) const { +template +bool DominatorTreeBase::properlyDominates(const NodeT *A, + const NodeT *B) const { if (A == B) return false;