Author: Nicolai Hähnle Date: 2020-07-08T18:18:49+02:00 New Revision: 3fa989d4fd6b854209ba4e950d96b91d6d5797b4
URL: https://github.com/llvm/llvm-project/commit/3fa989d4fd6b854209ba4e950d96b91d6d5797b4 DIFF: https://github.com/llvm/llvm-project/commit/3fa989d4fd6b854209ba4e950d96b91d6d5797b4.diff LOG: DomTree: remove explicit use of DomTreeNodeBase::iterator Summary: Almost all uses of these iterators, including implicit ones, really only need the const variant (as it should be). The only exception is in NewGVN, which changes the order of dominator tree child nodes. Change-Id: I4b5bd71e32d71b0c67b03d4927d93fe9413726d4 Reviewers: arsenm, RKSimon, mehdi_amini, courbet, rriddle, aartbik Subscribers: wdng, Prazek, hiraditya, kuhar, rogfer01, rriddle, jpienaar, shauheen, antiagainst, nicolasvasilache, arpith-jacob, mgester, lucyrfox, aartbik, liufengdb, stephenneuendorffer, Joonsoo, grosul1, vkmr, Kayjukh, jurahul, msifontes, cfe-commits, llvm-commits Tags: #clang, #mlir, #llvm Differential Revision: https://reviews.llvm.org/D83087 Added: Modified: clang/include/clang/Analysis/Analyses/Dominators.h llvm/include/llvm/CodeGen/MachineDominators.h llvm/include/llvm/IR/Dominators.h llvm/lib/Target/X86/X86InstrInfo.cpp llvm/lib/Transforms/Scalar/EarlyCSE.cpp llvm/lib/Transforms/Scalar/Sink.cpp llvm/lib/Transforms/Vectorize/VPlanDominatorTree.h mlir/include/mlir/IR/Dominance.h mlir/lib/Transforms/CSE.cpp Removed: ################################################################################ diff --git a/clang/include/clang/Analysis/Analyses/Dominators.h b/clang/include/clang/Analysis/Analyses/Dominators.h index 51d86f6e4540..95a661138df4 100644 --- a/clang/include/clang/Analysis/Analyses/Dominators.h +++ b/clang/include/clang/Analysis/Analyses/Dominators.h @@ -349,7 +349,7 @@ ClangCFGPostDomReverseChildrenGetter::Get( /// template <> struct GraphTraits<clang::DomTreeNode *> { using NodeRef = ::clang::DomTreeNode *; - using ChildIteratorType = ::clang::DomTreeNode::iterator; + using ChildIteratorType = ::clang::DomTreeNode::const_iterator; static NodeRef getEntryNode(NodeRef N) { return N; } static ChildIteratorType child_begin(NodeRef N) { return N->begin(); } diff --git a/llvm/include/llvm/CodeGen/MachineDominators.h b/llvm/include/llvm/CodeGen/MachineDominators.h index 2d26163a76aa..cf3af4d38223 100644 --- a/llvm/include/llvm/CodeGen/MachineDominators.h +++ b/llvm/include/llvm/CodeGen/MachineDominators.h @@ -261,7 +261,8 @@ template <class T> struct GraphTraits; template <> struct GraphTraits<MachineDomTreeNode *> : public MachineDomTreeGraphTraitsBase<MachineDomTreeNode, - MachineDomTreeNode::iterator> {}; + MachineDomTreeNode::const_iterator> { +}; template <> struct GraphTraits<const MachineDomTreeNode *> diff --git a/llvm/include/llvm/IR/Dominators.h b/llvm/include/llvm/IR/Dominators.h index 0084ac0b655a..71595cb15df4 100644 --- a/llvm/include/llvm/IR/Dominators.h +++ b/llvm/include/llvm/IR/Dominators.h @@ -208,7 +208,8 @@ template <class Node, class ChildIterator> struct DomTreeGraphTraitsBase { template <> struct GraphTraits<DomTreeNode *> - : public DomTreeGraphTraitsBase<DomTreeNode, DomTreeNode::iterator> {}; + : public DomTreeGraphTraitsBase<DomTreeNode, DomTreeNode::const_iterator> { +}; template <> struct GraphTraits<const DomTreeNode *> diff --git a/llvm/lib/Target/X86/X86InstrInfo.cpp b/llvm/lib/Target/X86/X86InstrInfo.cpp index 46ff62f7a4ed..42c111173570 100644 --- a/llvm/lib/Target/X86/X86InstrInfo.cpp +++ b/llvm/lib/Target/X86/X86InstrInfo.cpp @@ -8660,8 +8660,7 @@ namespace { } // Visit the children of this block in the dominator tree. - for (MachineDomTreeNode::iterator I = Node->begin(), E = Node->end(); - I != E; ++I) { + for (auto I = Node->begin(), E = Node->end(); I != E; ++I) { Changed |= VisitNode(*I, TLSBaseAddrReg); } diff --git a/llvm/lib/Transforms/Scalar/EarlyCSE.cpp b/llvm/lib/Transforms/Scalar/EarlyCSE.cpp index 1dac64a12d3e..ddfc8555b0a0 100644 --- a/llvm/lib/Transforms/Scalar/EarlyCSE.cpp +++ b/llvm/lib/Transforms/Scalar/EarlyCSE.cpp @@ -620,8 +620,8 @@ class EarlyCSE { public: StackNode(ScopedHTType &AvailableValues, LoadHTType &AvailableLoads, InvariantHTType &AvailableInvariants, CallHTType &AvailableCalls, - unsigned cg, DomTreeNode *n, DomTreeNode::iterator child, - DomTreeNode::iterator end) + unsigned cg, DomTreeNode *n, DomTreeNode::const_iterator child, + DomTreeNode::const_iterator end) : CurrentGeneration(cg), ChildGeneration(cg), Node(n), ChildIter(child), EndIter(end), Scopes(AvailableValues, AvailableLoads, AvailableInvariants, @@ -635,7 +635,7 @@ class EarlyCSE { unsigned childGeneration() { return ChildGeneration; } void childGeneration(unsigned generation) { ChildGeneration = generation; } DomTreeNode *node() { return Node; } - DomTreeNode::iterator childIter() { return ChildIter; } + DomTreeNode::const_iterator childIter() { return ChildIter; } DomTreeNode *nextChild() { DomTreeNode *child = *ChildIter; @@ -643,7 +643,7 @@ class EarlyCSE { return child; } - DomTreeNode::iterator end() { return EndIter; } + DomTreeNode::const_iterator end() { return EndIter; } bool isProcessed() { return Processed; } void process() { Processed = true; } @@ -651,8 +651,8 @@ class EarlyCSE { unsigned CurrentGeneration; unsigned ChildGeneration; DomTreeNode *Node; - DomTreeNode::iterator ChildIter; - DomTreeNode::iterator EndIter; + DomTreeNode::const_iterator ChildIter; + DomTreeNode::const_iterator EndIter; NodeScope Scopes; bool Processed = false; }; diff --git a/llvm/lib/Transforms/Scalar/Sink.cpp b/llvm/lib/Transforms/Scalar/Sink.cpp index 677d86f8c7b4..48f289c8f17d 100644 --- a/llvm/lib/Transforms/Scalar/Sink.cpp +++ b/llvm/lib/Transforms/Scalar/Sink.cpp @@ -166,8 +166,8 @@ static bool SinkInstruction(Instruction *Inst, // dominated by one of the successors. // Look at all the dominated blocks and see if we can sink it in one. DomTreeNode *DTN = DT.getNode(Inst->getParent()); - for (DomTreeNode::iterator I = DTN->begin(), E = DTN->end(); - I != E && SuccToSinkTo == nullptr; ++I) { + for (auto I = DTN->begin(), E = DTN->end(); I != E && SuccToSinkTo == nullptr; + ++I) { BasicBlock *Candidate = (*I)->getBlock(); // A node always immediate-dominates its children on the dominator // tree. diff --git a/llvm/lib/Transforms/Vectorize/VPlanDominatorTree.h b/llvm/lib/Transforms/Vectorize/VPlanDominatorTree.h index 19f5d2c00c60..a42ebc9ee955 100644 --- a/llvm/lib/Transforms/Vectorize/VPlanDominatorTree.h +++ b/llvm/lib/Transforms/Vectorize/VPlanDominatorTree.h @@ -30,7 +30,8 @@ using VPDomTreeNode = DomTreeNodeBase<VPBlockBase>; /// Template specializations of GraphTraits for VPDomTreeNode. template <> struct GraphTraits<VPDomTreeNode *> - : public DomTreeGraphTraitsBase<VPDomTreeNode, VPDomTreeNode::iterator> {}; + : public DomTreeGraphTraitsBase<VPDomTreeNode, + VPDomTreeNode::const_iterator> {}; template <> struct GraphTraits<const VPDomTreeNode *> diff --git a/mlir/include/mlir/IR/Dominance.h b/mlir/include/mlir/IR/Dominance.h index 97ec99007708..9d9a19996765 100644 --- a/mlir/include/mlir/IR/Dominance.h +++ b/mlir/include/mlir/IR/Dominance.h @@ -141,7 +141,7 @@ namespace llvm { /// DominatorTree GraphTraits specialization so the DominatorTree can be /// iterated by generic graph iterators. template <> struct GraphTraits<mlir::DominanceInfoNode *> { - using ChildIteratorType = mlir::DominanceInfoNode::iterator; + using ChildIteratorType = mlir::DominanceInfoNode::const_iterator; using NodeRef = mlir::DominanceInfoNode *; static NodeRef getEntryNode(NodeRef N) { return N; } diff --git a/mlir/lib/Transforms/CSE.cpp b/mlir/lib/Transforms/CSE.cpp index eb31fd207d79..5f4791450c7b 100644 --- a/mlir/lib/Transforms/CSE.cpp +++ b/mlir/lib/Transforms/CSE.cpp @@ -64,7 +64,7 @@ struct CSE : public CSEBase<CSE> { ScopedMapTy::ScopeTy scope; DominanceInfoNode *node; - DominanceInfoNode::iterator childIterator; + DominanceInfoNode::const_iterator childIterator; /// If this node has been fully processed yet or not. bool processed; _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits