Author: Hamza Sood Date: 2021-04-12T10:47:14-07:00 New Revision: 0a92aff721f43406691e38a0965fd0c917121d09
URL: https://github.com/llvm/llvm-project/commit/0a92aff721f43406691e38a0965fd0c917121d09 DIFF: https://github.com/llvm/llvm-project/commit/0a92aff721f43406691e38a0965fd0c917121d09.diff LOG: Replace uses of std::iterator with explicit using This patch removes all uses of `std::iterator`, which was deprecated in C++17. While this isn't currently an issue while compiling LLVM, it's useful for those using LLVM as a library. For some reason there're a few places that were seemingly able to use `std` functions unqualified, which no longer works after this patch. I've updated those places, but I'm not really sure why it worked in the first place. Reviewed By: MaskRay Differential Revision: https://reviews.llvm.org/D67586 Added: Modified: clang/include/clang/AST/StmtIterator.h clang/include/clang/Rewrite/Core/RewriteRope.h llvm/include/llvm/ADT/BreadthFirstIterator.h llvm/include/llvm/ADT/CoalescingBitVector.h llvm/include/llvm/ADT/DepthFirstIterator.h llvm/include/llvm/ADT/EquivalenceClasses.h llvm/include/llvm/ADT/ImmutableSet.h llvm/include/llvm/ADT/IntervalMap.h llvm/include/llvm/ADT/PostOrderIterator.h llvm/include/llvm/ADT/SparseMultiSet.h llvm/include/llvm/ADT/iterator.h llvm/include/llvm/Analysis/AliasSetTracker.h llvm/include/llvm/Analysis/MemorySSA.h llvm/include/llvm/Analysis/RegionIterator.h llvm/include/llvm/CodeGen/MachineRegisterInfo.h llvm/include/llvm/CodeGen/ScheduleDAG.h llvm/include/llvm/CodeGen/SelectionDAGNodes.h llvm/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h llvm/include/llvm/IR/CFG.h llvm/include/llvm/IR/DebugInfoMetadata.h llvm/include/llvm/IR/GetElementPtrTypeIterator.h llvm/include/llvm/IR/Metadata.h llvm/include/llvm/IR/Module.h llvm/include/llvm/IR/Value.h llvm/include/llvm/IR/ValueMap.h llvm/include/llvm/Object/ELFTypes.h llvm/include/llvm/Object/SymbolicFile.h llvm/include/llvm/ProfileData/Coverage/CoverageMappingReader.h llvm/include/llvm/ProfileData/InstrProfReader.h llvm/include/llvm/Support/LineIterator.h llvm/include/llvm/Support/TargetRegistry.h llvm/include/llvm/Support/YAMLParser.h llvm/include/llvm/TextAPI/ArchitectureSet.h llvm/include/llvm/Transforms/Scalar/GVNExpression.h llvm/lib/Analysis/CFGPrinter.cpp llvm/tools/llvm-objdump/MachODump.cpp polly/include/polly/Support/VirtualInstruction.h Removed: ################################################################################ diff --git a/clang/include/clang/AST/StmtIterator.h b/clang/include/clang/AST/StmtIterator.h index bcdb0df829fba..e98408c51a505 100644 --- a/clang/include/clang/AST/StmtIterator.h +++ b/clang/include/clang/AST/StmtIterator.h @@ -74,14 +74,17 @@ class StmtIteratorBase { }; template <typename DERIVED, typename REFERENCE> -class StmtIteratorImpl : public StmtIteratorBase, - public std::iterator<std::forward_iterator_tag, - REFERENCE, ptr diff _t, - REFERENCE, REFERENCE> { +class StmtIteratorImpl : public StmtIteratorBase { protected: StmtIteratorImpl(const StmtIteratorBase& RHS) : StmtIteratorBase(RHS) {} public: + using iterator_category = std::forward_iterator_tag; + using value_type = REFERENCE; + using diff erence_type = std::ptr diff _t; + using pointer = REFERENCE; + using reference = REFERENCE; + StmtIteratorImpl() = default; StmtIteratorImpl(Stmt **s) : StmtIteratorBase(s) {} StmtIteratorImpl(Decl **dgi, Decl **dge) : StmtIteratorBase(dgi, dge) {} diff --git a/clang/include/clang/Rewrite/Core/RewriteRope.h b/clang/include/clang/Rewrite/Core/RewriteRope.h index 039927c48b08a..8fa7af245eb81 100644 --- a/clang/include/clang/Rewrite/Core/RewriteRope.h +++ b/clang/include/clang/Rewrite/Core/RewriteRope.h @@ -83,8 +83,7 @@ namespace clang { /// over bytes that are in a RopePieceBTree. This first iterates over bytes /// in a RopePiece, then iterates over RopePiece's in a RopePieceBTreeLeaf, /// then iterates over RopePieceBTreeLeaf's in a RopePieceBTree. - class RopePieceBTreeIterator : - public std::iterator<std::forward_iterator_tag, const char, ptr diff _t> { + class RopePieceBTreeIterator { /// CurNode - The current B+Tree node that we are inspecting. const void /*RopePieceBTreeLeaf*/ *CurNode = nullptr; @@ -96,6 +95,12 @@ namespace clang { unsigned CurChar = 0; public: + using iterator_category = std::forward_iterator_tag; + using value_type = const char; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + RopePieceBTreeIterator() = default; RopePieceBTreeIterator(const void /*RopePieceBTreeNode*/ *N); diff --git a/llvm/include/llvm/ADT/BreadthFirstIterator.h b/llvm/include/llvm/ADT/BreadthFirstIterator.h index e97d76680db8d..e8af66d7527eb 100644 --- a/llvm/include/llvm/ADT/BreadthFirstIterator.h +++ b/llvm/include/llvm/ADT/BreadthFirstIterator.h @@ -44,11 +44,15 @@ template <class GraphT, class SetType = bf_iterator_default_set<typename GraphTraits<GraphT>::NodeRef>, class GT = GraphTraits<GraphT>> -class bf_iterator - : public std::iterator<std::forward_iterator_tag, typename GT::NodeRef>, - public bf_iterator_storage<SetType> { - using super = std::iterator<std::forward_iterator_tag, typename GT::NodeRef>; +class bf_iterator : public bf_iterator_storage<SetType> { +public: + using iterator_category = std::forward_iterator_tag; + using value_type = typename GT::NodeRef; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; +private: using NodeRef = typename GT::NodeRef; using ChildItTy = typename GT::ChildIteratorType; @@ -62,7 +66,6 @@ class bf_iterator // Current level. unsigned Level; -private: inline bf_iterator(NodeRef Node) { this->Visited.insert(Node); Level = 0; @@ -107,8 +110,6 @@ class bf_iterator } public: - using pointer = typename super::pointer; - // Provide static begin and end methods as our public "constructors" static bf_iterator begin(const GraphT &G) { return bf_iterator(GT::getEntryNode(G)); diff --git a/llvm/include/llvm/ADT/CoalescingBitVector.h b/llvm/include/llvm/ADT/CoalescingBitVector.h index 0a7dcfe226315..18803ecf209f4 100644 --- a/llvm/include/llvm/ADT/CoalescingBitVector.h +++ b/llvm/include/llvm/ADT/CoalescingBitVector.h @@ -231,10 +231,17 @@ template <typename IndexT> class CoalescingBitVector { bool operator!=(const ThisT &RHS) const { return !operator==(RHS); } - class const_iterator - : public std::iterator<std::forward_iterator_tag, IndexT> { + class const_iterator { friend class CoalescingBitVector; + public: + using iterator_category = std::forward_iterator_tag; + using value_type = IndexT; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + + private: // For performance reasons, make the offset at the end diff erent than the // one used in \ref begin, to optimize the common `It == end()` pattern. static constexpr unsigned kIteratorAtTheEndOffset = ~0u; diff --git a/llvm/include/llvm/ADT/DepthFirstIterator.h b/llvm/include/llvm/ADT/DepthFirstIterator.h index 5bfea28332b2e..d4f173ca7caa8 100644 --- a/llvm/include/llvm/ADT/DepthFirstIterator.h +++ b/llvm/include/llvm/ADT/DepthFirstIterator.h @@ -82,10 +82,15 @@ template <class GraphT, class SetType = df_iterator_default_set<typename GraphTraits<GraphT>::NodeRef>, bool ExtStorage = false, class GT = GraphTraits<GraphT>> -class df_iterator - : public std::iterator<std::forward_iterator_tag, typename GT::NodeRef>, - public df_iterator_storage<SetType, ExtStorage> { - using super = std::iterator<std::forward_iterator_tag, typename GT::NodeRef>; +class df_iterator : public df_iterator_storage<SetType, ExtStorage> { +public: + using iterator_category = std::forward_iterator_tag; + using value_type = typename GT::NodeRef; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + +private: using NodeRef = typename GT::NodeRef; using ChildItTy = typename GT::ChildIteratorType; @@ -97,7 +102,6 @@ class df_iterator // VisitStack - Used to maintain the ordering. Top = current block std::vector<StackElement> VisitStack; -private: inline df_iterator(NodeRef Node) { this->Visited.insert(Node); VisitStack.push_back(StackElement(Node, None)); @@ -144,8 +148,6 @@ class df_iterator } public: - using pointer = typename super::pointer; - // Provide static begin and end methods as our public "constructors" static df_iterator begin(const GraphT &G) { return df_iterator(GT::getEntryNode(G)); diff --git a/llvm/include/llvm/ADT/EquivalenceClasses.h b/llvm/include/llvm/ADT/EquivalenceClasses.h index 2cb7108c07948..273b00f99d5d8 100644 --- a/llvm/include/llvm/ADT/EquivalenceClasses.h +++ b/llvm/include/llvm/ADT/EquivalenceClasses.h @@ -248,19 +248,18 @@ class EquivalenceClasses { return It != member_end() && It == findLeader(V2); } - class member_iterator : public std::iterator<std::forward_iterator_tag, - const ElemTy, ptr diff _t> { + class member_iterator { friend class EquivalenceClasses; - using super = std::iterator<std::forward_iterator_tag, - const ElemTy, ptr diff _t>; - const ECValue *Node; public: - using size_type = size_t; - using pointer = typename super::pointer; - using reference = typename super::reference; + using iterator_category = std::forward_iterator_tag; + using value_type = const ElemTy; + using size_type = std::size_t; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; explicit member_iterator() = default; explicit member_iterator(const ECValue *N) : Node(N) {} diff --git a/llvm/include/llvm/ADT/ImmutableSet.h b/llvm/include/llvm/ADT/ImmutableSet.h index f19913f8dcdd7..48b253d3b75e7 100644 --- a/llvm/include/llvm/ADT/ImmutableSet.h +++ b/llvm/include/llvm/ADT/ImmutableSet.h @@ -651,13 +651,16 @@ class ImutAVLFactory { // Immutable AVL-Tree Iterators. //===----------------------------------------------------------------------===// -template <typename ImutInfo> -class ImutAVLTreeGenericIterator - : public std::iterator<std::bidirectional_iterator_tag, - ImutAVLTree<ImutInfo>> { +template <typename ImutInfo> class ImutAVLTreeGenericIterator { SmallVector<uintptr_t,20> stack; public: + using iterator_category = std::bidirectional_iterator_tag; + using value_type = ImutAVLTree<ImutInfo>; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + enum VisitFlag { VisitedNone=0x0, VisitedLeft=0x1, VisitedRight=0x3, Flags=0x3 }; @@ -762,15 +765,18 @@ class ImutAVLTreeGenericIterator } }; -template <typename ImutInfo> -class ImutAVLTreeInOrderIterator - : public std::iterator<std::bidirectional_iterator_tag, - ImutAVLTree<ImutInfo>> { +template <typename ImutInfo> class ImutAVLTreeInOrderIterator { using InternalIteratorTy = ImutAVLTreeGenericIterator<ImutInfo>; InternalIteratorTy InternalItr; public: + using iterator_category = std::bidirectional_iterator_tag; + using value_type = ImutAVLTree<ImutInfo>; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + using TreeTy = ImutAVLTree<ImutInfo>; ImutAVLTreeInOrderIterator(const TreeTy* Root) : InternalItr(Root) { diff --git a/llvm/include/llvm/ADT/IntervalMap.h b/llvm/include/llvm/ADT/IntervalMap.h index 0b6c7d6678076..26a7ed0cd3338 100644 --- a/llvm/include/llvm/ADT/IntervalMap.h +++ b/llvm/include/llvm/ADT/IntervalMap.h @@ -63,9 +63,14 @@ // }; // // template <typename KeyT, typename ValT, unsigned N, typename Traits> -// class IntervalMap::const_iterator : -// public std::iterator<std::bidirectional_iterator_tag, ValT> { +// class IntervalMap::const_iterator { // public: +// using iterator_category = std::bidirectional_iterator_tag; +// using value_type = ValT; +// using diff erence_type = std::ptr diff _t; +// using pointer = value_type *; +// using reference = value_type &; +// // bool operator==(const const_iterator &) const; // bool operator!=(const const_iterator &) const; // bool valid() const; @@ -1289,12 +1294,17 @@ clear() { //===----------------------------------------------------------------------===// template <typename KeyT, typename ValT, unsigned N, typename Traits> -class IntervalMap<KeyT, ValT, N, Traits>::const_iterator : - public std::iterator<std::bidirectional_iterator_tag, ValT> { - -protected: +class IntervalMap<KeyT, ValT, N, Traits>::const_iterator { friend class IntervalMap; +public: + using iterator_category = std::bidirectional_iterator_tag; + using value_type = ValT; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + +protected: // The map referred to. IntervalMap *map = nullptr; diff --git a/llvm/include/llvm/ADT/PostOrderIterator.h b/llvm/include/llvm/ADT/PostOrderIterator.h index bb413a956d9f7..9586a8f3c8ee1 100644 --- a/llvm/include/llvm/ADT/PostOrderIterator.h +++ b/llvm/include/llvm/ADT/PostOrderIterator.h @@ -90,13 +90,17 @@ class po_iterator_storage<SetType, true> { }; template <class GraphT, - class SetType = - SmallPtrSet<typename GraphTraits<GraphT>::NodeRef, 8>, + class SetType = SmallPtrSet<typename GraphTraits<GraphT>::NodeRef, 8>, bool ExtStorage = false, class GT = GraphTraits<GraphT>> -class po_iterator - : public std::iterator<std::forward_iterator_tag, typename GT::NodeRef>, - public po_iterator_storage<SetType, ExtStorage> { - using super = std::iterator<std::forward_iterator_tag, typename GT::NodeRef>; +class po_iterator : public po_iterator_storage<SetType, ExtStorage> { +public: + using iterator_category = std::forward_iterator_tag; + using value_type = typename GT::NodeRef; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + +private: using NodeRef = typename GT::NodeRef; using ChildItTy = typename GT::ChildIteratorType; @@ -135,8 +139,6 @@ class po_iterator } public: - using pointer = typename super::pointer; - // Provide static "constructors"... static po_iterator begin(GraphT G) { return po_iterator(GT::getEntryNode(G)); diff --git a/llvm/include/llvm/ADT/SparseMultiSet.h b/llvm/include/llvm/ADT/SparseMultiSet.h index 307d2c3f84e53..fec0a70a0bef8 100644 --- a/llvm/include/llvm/ADT/SparseMultiSet.h +++ b/llvm/include/llvm/ADT/SparseMultiSet.h @@ -216,11 +216,17 @@ class SparseMultiSet { /// Our iterators are iterators over the collection of objects that share a /// key. - template<typename SMSPtrTy> - class iterator_base : public std::iterator<std::bidirectional_iterator_tag, - ValueT> { + template <typename SMSPtrTy> class iterator_base { friend class SparseMultiSet; + public: + using iterator_category = std::bidirectional_iterator_tag; + using value_type = ValueT; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + + private: SMSPtrTy SMS; unsigned Idx; unsigned SparseIdx; @@ -247,12 +253,6 @@ class SparseMultiSet { void setNext(unsigned N) { SMS->Dense[Idx].Next = N; } public: - using super = std::iterator<std::bidirectional_iterator_tag, ValueT>; - using value_type = typename super::value_type; - using diff erence_type = typename super:: diff erence_type; - using pointer = typename super::pointer; - using reference = typename super::reference; - reference operator*() const { assert(isKeyed() && SMS->sparseIndex(SMS->Dense[Idx].Data) == SparseIdx && "Dereferencing iterator of invalid key or index"); @@ -411,7 +411,7 @@ class SparseMultiSet { RangePair equal_range(const KeyT &K) { iterator B = find(K); iterator E = iterator(this, SMSNode::INVALID, B.SparseIdx); - return make_pair(B, E); + return std::make_pair(B, E); } /// Insert a new element at the tail of the subset list. Returns an iterator diff --git a/llvm/include/llvm/ADT/iterator.h b/llvm/include/llvm/ADT/iterator.h index 6625a3f6179e8..5b304dfe8b2f5 100644 --- a/llvm/include/llvm/ADT/iterator.h +++ b/llvm/include/llvm/ADT/iterator.h @@ -64,9 +64,14 @@ namespace llvm { template <typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptr diff _t, typename PointerT = T *, typename ReferenceT = T &> -class iterator_facade_base - : public std::iterator<IteratorCategoryT, T, DifferenceTypeT, PointerT, - ReferenceT> { +class iterator_facade_base { +public: + using iterator_category = IteratorCategoryT; + using value_type = T; + using diff erence_type = DifferenceTypeT; + using pointer = PointerT; + using reference = ReferenceT; + protected: enum { IsRandomAccess = std::is_base_of<std::random_access_iterator_tag, diff --git a/llvm/include/llvm/Analysis/AliasSetTracker.h b/llvm/include/llvm/Analysis/AliasSetTracker.h index b9d8593937d43..b66ff395454d8 100644 --- a/llvm/include/llvm/Analysis/AliasSetTracker.h +++ b/llvm/include/llvm/Analysis/AliasSetTracker.h @@ -232,11 +232,16 @@ class AliasSet : public ilist_node<AliasSet> { void dump() const; /// Define an iterator for alias sets... this is just a forward iterator. - class iterator : public std::iterator<std::forward_iterator_tag, - PointerRec, ptr diff _t> { + class iterator { PointerRec *CurNode; public: + using iterator_category = std::forward_iterator_tag; + using value_type = PointerRec; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + explicit iterator(PointerRec *CN = nullptr) : CurNode(CN) {} bool operator==(const iterator& x) const { diff --git a/llvm/include/llvm/Analysis/MemorySSA.h b/llvm/include/llvm/Analysis/MemorySSA.h index 5b32f5cec8872..a26115aa82f11 100644 --- a/llvm/include/llvm/Analysis/MemorySSA.h +++ b/llvm/include/llvm/Analysis/MemorySSA.h @@ -1100,7 +1100,7 @@ class memoryaccess_def_iterator_base return MP->getIncomingBlock(ArgNo); } - typename BaseT::iterator::pointer operator*() const { + typename std::iterator_traits<BaseT>::pointer operator*() const { assert(Access && "Tried to access past the end of our iterator"); // Go to the first argument for phis, and the defining access for everything // else. @@ -1196,7 +1196,7 @@ class upward_defs_iterator return DefIterator == Other.DefIterator; } - BaseT::iterator::reference operator*() const { + typename std::iterator_traits<BaseT>::reference operator*() const { assert(DefIterator != OriginalAccess->defs_end() && "Tried to access past the end of our iterator"); return CurrentPair; diff --git a/llvm/include/llvm/Analysis/RegionIterator.h b/llvm/include/llvm/Analysis/RegionIterator.h index 72bc5bbcb506e..fecb28725dcc9 100644 --- a/llvm/include/llvm/Analysis/RegionIterator.h +++ b/llvm/include/llvm/Analysis/RegionIterator.h @@ -35,10 +35,15 @@ class BasicBlock; /// /// For a subregion RegionNode there is just one successor. The RegionNode /// representing the exit of the subregion. -template <class NodeRef, class BlockT, class RegionT> -class RNSuccIterator - : public std::iterator<std::forward_iterator_tag, NodeRef> { - using super = std::iterator<std::forward_iterator_tag, NodeRef>; +template <class NodeRef, class BlockT, class RegionT> class RNSuccIterator { +public: + using iterator_category = std::forward_iterator_tag; + using value_type = NodeRef; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + +private: using BlockTraits = GraphTraits<BlockT *>; using SuccIterTy = typename BlockTraits::ChildIteratorType; @@ -99,7 +104,6 @@ class RNSuccIterator public: using Self = RNSuccIterator<NodeRef, BlockT, RegionT>; - using value_type = typename super::value_type; /// Create begin iterator of a RegionNode. inline RNSuccIterator(NodeRef node) @@ -163,9 +167,7 @@ class RNSuccIterator /// are contained in the Region and its subregions. This is close to a virtual /// control flow graph of the Region. template <class NodeRef, class BlockT, class RegionT> -class RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT> - : public std::iterator<std::forward_iterator_tag, NodeRef> { - using super = std::iterator<std::forward_iterator_tag, NodeRef>; +class RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT> { using BlockTraits = GraphTraits<BlockT *>; using SuccIterTy = typename BlockTraits::ChildIteratorType; @@ -173,8 +175,13 @@ class RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT> SuccIterTy Itor; public: + using iterator_category = std::forward_iterator_tag; + using value_type = NodeRef; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + using Self = RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT>; - using value_type = typename super::value_type; /// Create the iterator from a RegionNode. /// diff --git a/llvm/include/llvm/CodeGen/MachineRegisterInfo.h b/llvm/include/llvm/CodeGen/MachineRegisterInfo.h index fa4da428597b9..2ac74536b54c5 100644 --- a/llvm/include/llvm/CodeGen/MachineRegisterInfo.h +++ b/llvm/include/llvm/CodeGen/MachineRegisterInfo.h @@ -970,10 +970,17 @@ class MachineRegisterInfo { /// when incrementing. template <bool ReturnUses, bool ReturnDefs, bool SkipDebug, bool ByOperand, bool ByInstr, bool ByBundle> - class defusechain_iterator : public std::iterator<std::forward_iterator_tag, - MachineOperand, ptr diff _t> { + class defusechain_iterator { friend class MachineRegisterInfo; + public: + using iterator_category = std::forward_iterator_tag; + using value_type = MachineOperand; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + + private: MachineOperand *Op = nullptr; explicit defusechain_iterator(MachineOperand *op) : Op(op) { @@ -1008,11 +1015,6 @@ class MachineRegisterInfo { } public: - using reference = std::iterator<std::forward_iterator_tag, MachineOperand, - ptr diff _t>::reference; - using pointer = std::iterator<std::forward_iterator_tag, MachineOperand, - ptr diff _t>::pointer; - defusechain_iterator() = default; bool operator==(const defusechain_iterator &x) const { @@ -1074,12 +1076,19 @@ class MachineRegisterInfo { /// returns defs. If neither are true then you are silly and it always /// returns end(). If SkipDebug is true it skips uses marked Debug /// when incrementing. - template<bool ReturnUses, bool ReturnDefs, bool SkipDebug, - bool ByOperand, bool ByInstr, bool ByBundle> - class defusechain_instr_iterator - : public std::iterator<std::forward_iterator_tag, MachineInstr, ptr diff _t> { + template <bool ReturnUses, bool ReturnDefs, bool SkipDebug, bool ByOperand, + bool ByInstr, bool ByBundle> + class defusechain_instr_iterator { friend class MachineRegisterInfo; + public: + using iterator_category = std::forward_iterator_tag; + using value_type = MachineInstr; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + + private: MachineOperand *Op = nullptr; explicit defusechain_instr_iterator(MachineOperand *op) : Op(op) { @@ -1114,11 +1123,6 @@ class MachineRegisterInfo { } public: - using reference = std::iterator<std::forward_iterator_tag, - MachineInstr, ptr diff _t>::reference; - using pointer = std::iterator<std::forward_iterator_tag, - MachineInstr, ptr diff _t>::pointer; - defusechain_instr_iterator() = default; bool operator==(const defusechain_instr_iterator &x) const { diff --git a/llvm/include/llvm/CodeGen/ScheduleDAG.h b/llvm/include/llvm/CodeGen/ScheduleDAG.h index 4c8d047727ceb..af8c0cd8756e0 100644 --- a/llvm/include/llvm/CodeGen/ScheduleDAG.h +++ b/llvm/include/llvm/CodeGen/ScheduleDAG.h @@ -614,14 +614,19 @@ class TargetRegisterInfo; const MCInstrDesc *getNodeDesc(const SDNode *Node) const; }; - class SUnitIterator : public std::iterator<std::forward_iterator_tag, - SUnit, ptr diff _t> { + class SUnitIterator { SUnit *Node; unsigned Operand; SUnitIterator(SUnit *N, unsigned Op) : Node(N), Operand(Op) {} public: + using iterator_category = std::forward_iterator_tag; + using value_type = SUnit; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + bool operator==(const SUnitIterator& x) const { return Operand == x.Operand; } diff --git a/llvm/include/llvm/CodeGen/SelectionDAGNodes.h b/llvm/include/llvm/CodeGen/SelectionDAGNodes.h index 731fb9968c4d1..87e74ba799bff 100644 --- a/llvm/include/llvm/CodeGen/SelectionDAGNodes.h +++ b/llvm/include/llvm/CodeGen/SelectionDAGNodes.h @@ -716,8 +716,7 @@ END_TWO_BYTE_PACK() /// This class provides iterator support for SDUse /// operands that use a specific SDNode. - class use_iterator - : public std::iterator<std::forward_iterator_tag, SDUse, ptr diff _t> { + class use_iterator { friend class SDNode; SDUse *Op = nullptr; @@ -725,10 +724,11 @@ END_TWO_BYTE_PACK() explicit use_iterator(SDUse *op) : Op(op) {} public: - using reference = std::iterator<std::forward_iterator_tag, - SDUse, ptr diff _t>::reference; - using pointer = std::iterator<std::forward_iterator_tag, - SDUse, ptr diff _t>::pointer; + using iterator_category = std::forward_iterator_tag; + using value_type = SDUse; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; use_iterator() = default; use_iterator(const use_iterator &I) : Op(I.Op) {} @@ -2592,14 +2592,19 @@ class AssertAlignSDNode : public SDNode { } }; -class SDNodeIterator : public std::iterator<std::forward_iterator_tag, - SDNode, ptr diff _t> { +class SDNodeIterator { const SDNode *Node; unsigned Operand; SDNodeIterator(const SDNode *N, unsigned Op) : Node(N), Operand(Op) {} public: + using iterator_category = std::forward_iterator_tag; + using value_type = SDNode; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + bool operator==(const SDNodeIterator& x) const { return Operand == x.Operand; } diff --git a/llvm/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h b/llvm/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h index b82ad9d580932..355995bf69b9f 100644 --- a/llvm/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h +++ b/llvm/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h @@ -140,7 +140,7 @@ class AppleAcceleratorTable : public DWARFAcceleratorTable { friend class ValueIterator; }; - class ValueIterator : public std::iterator<std::input_iterator_tag, Entry> { + class ValueIterator { const AppleAcceleratorTable *AccelTable = nullptr; Entry Current; ///< The current entry. uint64_t DataOffset = 0; ///< Offset into the section. @@ -149,7 +149,14 @@ class AppleAcceleratorTable : public DWARFAcceleratorTable { /// Advance the iterator. void Next(); + public: + using iterator_category = std::input_iterator_tag; + using value_type = Entry; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + /// Construct a new iterator for the entries at \p DataOffset. ValueIterator(const AppleAcceleratorTable &AccelTable, uint64_t DataOffset); /// End marker. @@ -466,8 +473,15 @@ class DWARFDebugNames : public DWARFAcceleratorTable { friend class DWARFDebugNames; }; - class ValueIterator : public std::iterator<std::input_iterator_tag, Entry> { + class ValueIterator { + public: + using iterator_category = std::input_iterator_tag; + using value_type = Entry; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + private: /// The Name Index we are currently iterating through. The implementation /// relies on the fact that this can also be used as an iterator into the /// "NameIndices" vector in the Accelerator section. diff --git a/llvm/include/llvm/IR/CFG.h b/llvm/include/llvm/IR/CFG.h index f798b1af6c837..b872e26269810 100644 --- a/llvm/include/llvm/IR/CFG.h +++ b/llvm/include/llvm/IR/CFG.h @@ -40,10 +40,15 @@ class Use; //===----------------------------------------------------------------------===// template <class Ptr, class USE_iterator> // Predecessor Iterator -class PredIterator : public std::iterator<std::forward_iterator_tag, - Ptr, ptr diff _t, Ptr*, Ptr*> { - using super = - std::iterator<std::forward_iterator_tag, Ptr, ptr diff _t, Ptr*, Ptr*>; +class PredIterator { +public: + using iterator_category = std::forward_iterator_tag; + using value_type = Ptr; + using diff erence_type = std::ptr diff _t; + using pointer = Ptr *; + using reference = Ptr *; + +private: using Self = PredIterator<Ptr, USE_iterator>; USE_iterator It; @@ -59,9 +64,6 @@ class PredIterator : public std::iterator<std::forward_iterator_tag, } public: - using pointer = typename super::pointer; - using reference = typename super::reference; - PredIterator() = default; explicit inline PredIterator(Ptr *bb) : It(bb->user_begin()) { advancePastNonTerminators(); diff --git a/llvm/include/llvm/IR/DebugInfoMetadata.h b/llvm/include/llvm/IR/DebugInfoMetadata.h index 42d0b618a9171..48e8c175db918 100644 --- a/llvm/include/llvm/IR/DebugInfoMetadata.h +++ b/llvm/include/llvm/IR/DebugInfoMetadata.h @@ -80,11 +80,16 @@ class DITypeRefArray { return cast_or_null<DIType>(N->getOperand(I)); } - class iterator : std::iterator<std::input_iterator_tag, DIType *, - std::ptr diff _t, void, DIType *> { + class iterator { MDNode::op_iterator I = nullptr; public: + using iterator_category = std::input_iterator_tag; + using value_type = DIType *; + using diff erence_type = std::ptr diff _t; + using pointer = void; + using reference = DIType *; + iterator() = default; explicit iterator(MDNode::op_iterator I) : I(I) {} @@ -2639,11 +2644,16 @@ class DIExpression : public MDNode { }; /// An iterator for expression operands. - class expr_op_iterator - : public std::iterator<std::input_iterator_tag, ExprOperand> { + class expr_op_iterator { ExprOperand Op; public: + using iterator_category = std::input_iterator_tag; + using value_type = ExprOperand; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + expr_op_iterator() = default; explicit expr_op_iterator(element_iterator I) : Op(I) {} diff --git a/llvm/include/llvm/IR/GetElementPtrTypeIterator.h b/llvm/include/llvm/IR/GetElementPtrTypeIterator.h index 6293305a2639f..ed854e458da2d 100644 --- a/llvm/include/llvm/IR/GetElementPtrTypeIterator.h +++ b/llvm/include/llvm/IR/GetElementPtrTypeIterator.h @@ -27,106 +27,112 @@ namespace llvm { - template<typename ItTy = User::const_op_iterator> - class generic_gep_type_iterator - : public std::iterator<std::forward_iterator_tag, Type *, ptr diff _t> { - using super = std::iterator<std::forward_iterator_tag, Type *, ptr diff _t>; - - ItTy OpIt; - PointerUnion<StructType *, Type *> CurTy; - enum : uint64_t { Unbounded = -1ull }; - uint64_t NumElements = Unbounded; - - generic_gep_type_iterator() = default; - - public: - static generic_gep_type_iterator begin(Type *Ty, ItTy It) { - generic_gep_type_iterator I; - I.CurTy = Ty; - I.OpIt = It; - return I; - } - - static generic_gep_type_iterator end(ItTy It) { - generic_gep_type_iterator I; - I.OpIt = It; - return I; - } - - bool operator==(const generic_gep_type_iterator& x) const { - return OpIt == x.OpIt; - } - - bool operator!=(const generic_gep_type_iterator& x) const { - return !operator==(x); - } - - // FIXME: Make this the iterator's operator*() after the 4.0 release. - // operator*() had a diff erent meaning in earlier releases, so we're - // temporarily not giving this iterator an operator*() to avoid a subtle - // semantics break. - Type *getIndexedType() const { - if (auto *T = CurTy.dyn_cast<Type *>()) - return T; - return CurTy.get<StructType *>()->getTypeAtIndex(getOperand()); - } - - Value *getOperand() const { return const_cast<Value *>(&**OpIt); } - - generic_gep_type_iterator& operator++() { // Preincrement - Type *Ty = getIndexedType(); - if (auto *ATy = dyn_cast<ArrayType>(Ty)) { - CurTy = ATy->getElementType(); - NumElements = ATy->getNumElements(); - } else if (auto *VTy = dyn_cast<VectorType>(Ty)) { - CurTy = VTy->getElementType(); - if (isa<ScalableVectorType>(VTy)) - NumElements = Unbounded; - else - NumElements = cast<FixedVectorType>(VTy)->getNumElements(); - } else - CurTy = dyn_cast<StructType>(Ty); - ++OpIt; - return *this; - } - - generic_gep_type_iterator operator++(int) { // Postincrement - generic_gep_type_iterator tmp = *this; ++*this; return tmp; - } - - // All of the below API is for querying properties of the "outer type", i.e. - // the type that contains the indexed type. Most of the time this is just - // the type that was visited immediately prior to the indexed type, but for - // the first element this is an unbounded array of the GEP's source element - // type, for which there is no clearly corresponding IR type (we've - // historically used a pointer type as the outer type in this case, but - // pointers will soon lose their element type). - // - // FIXME: Most current users of this class are just interested in byte - // offsets (a few need to know whether the outer type is a struct because - // they are trying to replace a constant with a variable, which is only - // legal for arrays, e.g. canReplaceOperandWithVariable in SimplifyCFG.cpp); - // we should provide a more minimal API here that exposes not much more than - // that. - - bool isStruct() const { return CurTy.is<StructType *>(); } - bool isSequential() const { return CurTy.is<Type *>(); } - - StructType *getStructType() const { return CurTy.get<StructType *>(); } - - StructType *getStructTypeOrNull() const { - return CurTy.dyn_cast<StructType *>(); - } - - bool isBoundedSequential() const { - return isSequential() && NumElements != Unbounded; - } - - uint64_t getSequentialNumElements() const { - assert(isBoundedSequential()); - return NumElements; - } - }; +template <typename ItTy = User::const_op_iterator> +class generic_gep_type_iterator { + + ItTy OpIt; + PointerUnion<StructType *, Type *> CurTy; + enum : uint64_t { Unbounded = -1ull }; + uint64_t NumElements = Unbounded; + + generic_gep_type_iterator() = default; + +public: + using iterator_category = std::forward_iterator_tag; + using value_type = Type *; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + + static generic_gep_type_iterator begin(Type *Ty, ItTy It) { + generic_gep_type_iterator I; + I.CurTy = Ty; + I.OpIt = It; + return I; + } + + static generic_gep_type_iterator end(ItTy It) { + generic_gep_type_iterator I; + I.OpIt = It; + return I; + } + + bool operator==(const generic_gep_type_iterator &x) const { + return OpIt == x.OpIt; + } + + bool operator!=(const generic_gep_type_iterator &x) const { + return !operator==(x); + } + + // FIXME: Make this the iterator's operator*() after the 4.0 release. + // operator*() had a diff erent meaning in earlier releases, so we're + // temporarily not giving this iterator an operator*() to avoid a subtle + // semantics break. + Type *getIndexedType() const { + if (auto *T = CurTy.dyn_cast<Type *>()) + return T; + return CurTy.get<StructType *>()->getTypeAtIndex(getOperand()); + } + + Value *getOperand() const { return const_cast<Value *>(&**OpIt); } + + generic_gep_type_iterator &operator++() { // Preincrement + Type *Ty = getIndexedType(); + if (auto *ATy = dyn_cast<ArrayType>(Ty)) { + CurTy = ATy->getElementType(); + NumElements = ATy->getNumElements(); + } else if (auto *VTy = dyn_cast<VectorType>(Ty)) { + CurTy = VTy->getElementType(); + if (isa<ScalableVectorType>(VTy)) + NumElements = Unbounded; + else + NumElements = cast<FixedVectorType>(VTy)->getNumElements(); + } else + CurTy = dyn_cast<StructType>(Ty); + ++OpIt; + return *this; + } + + generic_gep_type_iterator operator++(int) { // Postincrement + generic_gep_type_iterator tmp = *this; + ++*this; + return tmp; + } + + // All of the below API is for querying properties of the "outer type", i.e. + // the type that contains the indexed type. Most of the time this is just + // the type that was visited immediately prior to the indexed type, but for + // the first element this is an unbounded array of the GEP's source element + // type, for which there is no clearly corresponding IR type (we've + // historically used a pointer type as the outer type in this case, but + // pointers will soon lose their element type). + // + // FIXME: Most current users of this class are just interested in byte + // offsets (a few need to know whether the outer type is a struct because + // they are trying to replace a constant with a variable, which is only + // legal for arrays, e.g. canReplaceOperandWithVariable in SimplifyCFG.cpp); + // we should provide a more minimal API here that exposes not much more than + // that. + + bool isStruct() const { return CurTy.is<StructType *>(); } + bool isSequential() const { return CurTy.is<Type *>(); } + + StructType *getStructType() const { return CurTy.get<StructType *>(); } + + StructType *getStructTypeOrNull() const { + return CurTy.dyn_cast<StructType *>(); + } + + bool isBoundedSequential() const { + return isSequential() && NumElements != Unbounded; + } + + uint64_t getSequentialNumElements() const { + assert(isBoundedSequential()); + return NumElements; + } +}; using gep_type_iterator = generic_gep_type_iterator<>; diff --git a/llvm/include/llvm/IR/Metadata.h b/llvm/include/llvm/IR/Metadata.h index d74b0800106e4..6a9d9455deb9d 100644 --- a/llvm/include/llvm/IR/Metadata.h +++ b/llvm/include/llvm/IR/Metadata.h @@ -1247,13 +1247,16 @@ class AliasScopeNode { /// /// An iterator that transforms an \a MDNode::iterator into an iterator over a /// particular Metadata subclass. -template <class T> -class TypedMDOperandIterator - : public std::iterator<std::input_iterator_tag, T *, std::ptr diff _t, void, - T *> { +template <class T> class TypedMDOperandIterator { MDNode::op_iterator I = nullptr; public: + using iterator_category = std::input_iterator_tag; + using value_type = T *; + using diff erence_type = std::ptr diff _t; + using pointer = void; + using reference = T *; + TypedMDOperandIterator() = default; explicit TypedMDOperandIterator(MDNode::op_iterator I) : I(I) {} @@ -1392,9 +1395,7 @@ class NamedMDNode : public ilist_node<NamedMDNode> { explicit NamedMDNode(const Twine &N); - template<class T1, class T2> - class op_iterator_impl : - public std::iterator<std::bidirectional_iterator_tag, T2> { + template <class T1, class T2> class op_iterator_impl { friend class NamedMDNode; const NamedMDNode *Node = nullptr; @@ -1403,6 +1404,12 @@ class NamedMDNode : public ilist_node<NamedMDNode> { op_iterator_impl(const NamedMDNode *N, unsigned i) : Node(N), Idx(i) {} public: + using iterator_category = std::bidirectional_iterator_tag; + using value_type = T2; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + op_iterator_impl() = default; bool operator==(const op_iterator_impl &o) const { return Idx == o.Idx; } diff --git a/llvm/include/llvm/IR/Module.h b/llvm/include/llvm/IR/Module.h index ca8a49f10f535..9bd8aa95a3a04 100644 --- a/llvm/include/llvm/IR/Module.h +++ b/llvm/include/llvm/IR/Module.h @@ -718,14 +718,19 @@ class Module { } /// An iterator for DICompileUnits that skips those marked NoDebug. - class debug_compile_units_iterator - : public std::iterator<std::input_iterator_tag, DICompileUnit *> { + class debug_compile_units_iterator { NamedMDNode *CUs; unsigned Idx; void SkipNoDebugCUs(); public: + using iterator_category = std::input_iterator_tag; + using value_type = DICompileUnit *; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + explicit debug_compile_units_iterator(NamedMDNode *CUs, unsigned Idx) : CUs(CUs), Idx(Idx) { SkipNoDebugCUs(); diff --git a/llvm/include/llvm/IR/Value.h b/llvm/include/llvm/IR/Value.h index 73216bccf12bc..6bc406c8de837 100644 --- a/llvm/include/llvm/IR/Value.h +++ b/llvm/include/llvm/IR/Value.h @@ -123,8 +123,7 @@ class Value { private: template <typename UseT> // UseT == 'Use' or 'const Use' - class use_iterator_impl - : public std::iterator<std::forward_iterator_tag, UseT *> { + class use_iterator_impl { friend class Value; UseT *U; @@ -132,6 +131,12 @@ class Value { explicit use_iterator_impl(UseT *u) : U(u) {} public: + using iterator_category = std::forward_iterator_tag; + using value_type = UseT *; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + use_iterator_impl() : U() {} bool operator==(const use_iterator_impl &x) const { return U == x.U; } @@ -162,13 +167,18 @@ class Value { }; template <typename UserTy> // UserTy == 'User' or 'const User' - class user_iterator_impl - : public std::iterator<std::forward_iterator_tag, UserTy *> { + class user_iterator_impl { use_iterator_impl<Use> UI; explicit user_iterator_impl(Use *U) : UI(U) {} friend class Value; public: + using iterator_category = std::forward_iterator_tag; + using value_type = UserTy *; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + user_iterator_impl() = default; bool operator==(const user_iterator_impl &x) const { return UI == x.UI; } diff --git a/llvm/include/llvm/IR/ValueMap.h b/llvm/include/llvm/IR/ValueMap.h index a5a06b76dbf6d..67f275cc06d96 100644 --- a/llvm/include/llvm/IR/ValueMap.h +++ b/llvm/include/llvm/IR/ValueMap.h @@ -323,17 +323,19 @@ struct DenseMapInfo<ValueMapCallbackVH<KeyT, ValueT, Config>> { } }; -template<typename DenseMapT, typename KeyT> -class ValueMapIterator : - public std::iterator<std::forward_iterator_tag, - std::pair<KeyT, typename DenseMapT::mapped_type>, - ptr diff _t> { +template <typename DenseMapT, typename KeyT> class ValueMapIterator { using BaseT = typename DenseMapT::iterator; using ValueT = typename DenseMapT::mapped_type; BaseT I; public: + using iterator_category = std::forward_iterator_tag; + using value_type = std::pair<KeyT, typename DenseMapT::mapped_type>; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + ValueMapIterator() : I() {} ValueMapIterator(BaseT I) : I(I) {} @@ -375,17 +377,19 @@ class ValueMapIterator : } }; -template<typename DenseMapT, typename KeyT> -class ValueMapConstIterator : - public std::iterator<std::forward_iterator_tag, - std::pair<KeyT, typename DenseMapT::mapped_type>, - ptr diff _t> { +template <typename DenseMapT, typename KeyT> class ValueMapConstIterator { using BaseT = typename DenseMapT::const_iterator; using ValueT = typename DenseMapT::mapped_type; BaseT I; public: + using iterator_category = std::forward_iterator_tag; + using value_type = std::pair<KeyT, typename DenseMapT::mapped_type>; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + ValueMapConstIterator() : I() {} ValueMapConstIterator(BaseT I) : I(I) {} ValueMapConstIterator(ValueMapIterator<DenseMapT, KeyT> Other) diff --git a/llvm/include/llvm/Object/ELFTypes.h b/llvm/include/llvm/Object/ELFTypes.h index 534deaabed8d1..483aeeabe2bde 100644 --- a/llvm/include/llvm/Object/ELFTypes.h +++ b/llvm/include/llvm/Object/ELFTypes.h @@ -655,9 +655,15 @@ class Elf_Note_Impl { Elf_Word getType() const { return Nhdr.n_type; } }; -template <class ELFT> -class Elf_Note_Iterator_Impl - : std::iterator<std::forward_iterator_tag, Elf_Note_Impl<ELFT>> { +template <class ELFT> class Elf_Note_Iterator_Impl { +public: + using iterator_category = std::forward_iterator_tag; + using value_type = Elf_Note_Impl<ELFT>; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + +private: // Nhdr being a nullptr marks the end of iteration. const Elf_Nhdr_Impl<ELFT> *Nhdr = nullptr; size_t RemainingSize = 0u; diff --git a/llvm/include/llvm/Object/SymbolicFile.h b/llvm/include/llvm/Object/SymbolicFile.h index 012f9f7fad07f..284302c5e0425 100644 --- a/llvm/include/llvm/Object/SymbolicFile.h +++ b/llvm/include/llvm/Object/SymbolicFile.h @@ -64,12 +64,16 @@ inline bool operator<(const DataRefImpl &a, const DataRefImpl &b) { return std::memcmp(&a, &b, sizeof(DataRefImpl)) < 0; } -template <class content_type> -class content_iterator - : public std::iterator<std::forward_iterator_tag, content_type> { +template <class content_type> class content_iterator { content_type Current; public: + using iterator_category = std::forward_iterator_tag; + using value_type = content_type; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + content_iterator(content_type symb) : Current(std::move(symb)) {} const content_type *operator->() const { return &Current; } diff --git a/llvm/include/llvm/ProfileData/Coverage/CoverageMappingReader.h b/llvm/include/llvm/ProfileData/Coverage/CoverageMappingReader.h index 86a3c4af9c3c8..e823d21add136 100644 --- a/llvm/include/llvm/ProfileData/Coverage/CoverageMappingReader.h +++ b/llvm/include/llvm/ProfileData/Coverage/CoverageMappingReader.h @@ -41,8 +41,7 @@ struct CoverageMappingRecord { }; /// A file format agnostic iterator over coverage mapping data. -class CoverageMappingIterator - : public std::iterator<std::input_iterator_tag, CoverageMappingRecord> { +class CoverageMappingIterator { CoverageMappingReader *Reader; CoverageMappingRecord Record; coveragemap_error ReadErr; @@ -50,6 +49,12 @@ class CoverageMappingIterator void increment(); public: + using iterator_category = std::input_iterator_tag; + using value_type = CoverageMappingRecord; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + CoverageMappingIterator() : Reader(nullptr), Record(), ReadErr(coveragemap_error::success) {} diff --git a/llvm/include/llvm/ProfileData/InstrProfReader.h b/llvm/include/llvm/ProfileData/InstrProfReader.h index 2c2cfb90d4fa3..6746f0c2e55e7 100644 --- a/llvm/include/llvm/ProfileData/InstrProfReader.h +++ b/llvm/include/llvm/ProfileData/InstrProfReader.h @@ -38,8 +38,15 @@ namespace llvm { class InstrProfReader; /// A file format agnostic iterator over profiling data. -class InstrProfIterator : public std::iterator<std::input_iterator_tag, - NamedInstrProfRecord> { +class InstrProfIterator { +public: + using iterator_category = std::input_iterator_tag; + using value_type = NamedInstrProfRecord; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + +private: InstrProfReader *Reader = nullptr; value_type Record; diff --git a/llvm/include/llvm/Support/LineIterator.h b/llvm/include/llvm/Support/LineIterator.h index b391412685c4d..01cf7e061505a 100644 --- a/llvm/include/llvm/Support/LineIterator.h +++ b/llvm/include/llvm/Support/LineIterator.h @@ -30,8 +30,7 @@ class MemoryBuffer; /// character. /// /// Note that this iterator requires the buffer to be nul terminated. -class line_iterator - : public std::iterator<std::forward_iterator_tag, StringRef> { +class line_iterator { Optional<MemoryBufferRef> Buffer; char CommentMarker = '\0'; bool SkipBlanks = true; @@ -40,6 +39,12 @@ class line_iterator StringRef CurrentLine; public: + using iterator_category = std::forward_iterator_tag; + using value_type = StringRef; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + /// Default construct an "end" iterator. line_iterator() = default; diff --git a/llvm/include/llvm/Support/TargetRegistry.h b/llvm/include/llvm/Support/TargetRegistry.h index 2c65eb60f9109..75bc5ce75104d 100644 --- a/llvm/include/llvm/Support/TargetRegistry.h +++ b/llvm/include/llvm/Support/TargetRegistry.h @@ -603,8 +603,7 @@ struct TargetRegistry { // function). TargetRegistry() = delete; - class iterator - : public std::iterator<std::forward_iterator_tag, Target, ptr diff _t> { + class iterator { friend struct TargetRegistry; const Target *Current = nullptr; @@ -612,6 +611,12 @@ struct TargetRegistry { explicit iterator(Target *T) : Current(T) {} public: + using iterator_category = std::forward_iterator_tag; + using value_type = Target; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + iterator() = default; bool operator==(const iterator &x) const { return Current == x.Current; } diff --git a/llvm/include/llvm/Support/YAMLParser.h b/llvm/include/llvm/Support/YAMLParser.h index 759e11afd4478..a4b2ab5e49ec1 100644 --- a/llvm/include/llvm/Support/YAMLParser.h +++ b/llvm/include/llvm/Support/YAMLParser.h @@ -325,10 +325,14 @@ class KeyValueNode final : public Node { /// /// BaseT must have a ValueT* member named CurrentEntry and a member function /// increment() which must set CurrentEntry to 0 to create an end iterator. -template <class BaseT, class ValueT> -class basic_collection_iterator - : public std::iterator<std::input_iterator_tag, ValueT> { +template <class BaseT, class ValueT> class basic_collection_iterator { public: + using iterator_category = std::input_iterator_tag; + using value_type = ValueT; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; + basic_collection_iterator() = default; basic_collection_iterator(BaseT *B) : Base(B) {} diff --git a/llvm/include/llvm/TextAPI/ArchitectureSet.h b/llvm/include/llvm/TextAPI/ArchitectureSet.h index 0901278141c9d..e9b374e4f69fa 100644 --- a/llvm/include/llvm/TextAPI/ArchitectureSet.h +++ b/llvm/include/llvm/TextAPI/ArchitectureSet.h @@ -66,9 +66,14 @@ class ArchitectureSet { return has(AK_i386) || has(AK_x86_64) || has(AK_x86_64h); } - template <typename Ty> - class arch_iterator - : public std::iterator<std::forward_iterator_tag, Architecture, size_t> { + template <typename Ty> class arch_iterator { + public: + using iterator_category = std::forward_iterator_tag; + using value_type = Architecture; + using diff erence_type = std::size_t; + using pointer = value_type *; + using reference = value_type &; + private: ArchSetType Index; Ty *ArchSet; diff --git a/llvm/include/llvm/Transforms/Scalar/GVNExpression.h b/llvm/include/llvm/Transforms/Scalar/GVNExpression.h index c4a04877a1ff0..2433890d0df80 100644 --- a/llvm/include/llvm/Transforms/Scalar/GVNExpression.h +++ b/llvm/include/llvm/Transforms/Scalar/GVNExpression.h @@ -240,14 +240,19 @@ class BasicExpression : public Expression { } }; -class op_inserter - : public std::iterator<std::output_iterator_tag, void, void, void, void> { +class op_inserter { private: using Container = BasicExpression; Container *BE; public: + using iterator_category = std::output_iterator_tag; + using value_type = void; + using diff erence_type = void; + using pointer = void; + using reference = void; + explicit op_inserter(BasicExpression &E) : BE(&E) {} explicit op_inserter(BasicExpression *E) : BE(E) {} @@ -472,14 +477,19 @@ class AggregateValueExpression final : public BasicExpression { } }; -class int_op_inserter - : public std::iterator<std::output_iterator_tag, void, void, void, void> { +class int_op_inserter { private: using Container = AggregateValueExpression; Container *AVE; public: + using iterator_category = std::output_iterator_tag; + using value_type = void; + using diff erence_type = void; + using pointer = void; + using reference = void; + explicit int_op_inserter(AggregateValueExpression &E) : AVE(&E) {} explicit int_op_inserter(AggregateValueExpression *E) : AVE(E) {} diff --git a/llvm/lib/Analysis/CFGPrinter.cpp b/llvm/lib/Analysis/CFGPrinter.cpp index 33b5a4603272e..3373dfab011ac 100644 --- a/llvm/lib/Analysis/CFGPrinter.cpp +++ b/llvm/lib/Analysis/CFGPrinter.cpp @@ -286,8 +286,7 @@ void DOTGraphTraits<DOTFuncInfo *>::computeHiddenNodes(const Function *F) { }; /// The post order traversal iteration is done to know the status of /// isHiddenBasicBlock for all the successors on the current BB. - for_each(po_begin(&F->getEntryBlock()), po_end(&F->getEntryBlock()), - evaluateBB); + llvm::for_each(post_order(&F->getEntryBlock()), evaluateBB); } bool DOTGraphTraits<DOTFuncInfo *>::isNodeHidden(const BasicBlock *Node, diff --git a/llvm/tools/llvm-objdump/MachODump.cpp b/llvm/tools/llvm-objdump/MachODump.cpp index 0ee32bc4a2844..11d22a9cfb3d3 100644 --- a/llvm/tools/llvm-objdump/MachODump.cpp +++ b/llvm/tools/llvm-objdump/MachODump.cpp @@ -466,7 +466,7 @@ static void printRelocationTargetName(const MachOObjectFile *O, if (isExtern) { symbol_iterator SI = O->symbol_begin(); - advance(SI, Val); + std::advance(SI, Val); S = unwrapOrError(SI->getName(), FileName); } else { section_iterator SI = O->section_begin(); @@ -478,7 +478,7 @@ static void printRelocationTargetName(const MachOObjectFile *O, uint32_t I = Val - 1; while (I != 0 && SI != O->section_end()) { --I; - advance(SI, 1); + std::advance(SI, 1); } if (SI == O->section_end()) { Fmt << Val << " (?,?)"; diff --git a/polly/include/polly/Support/VirtualInstruction.h b/polly/include/polly/Support/VirtualInstruction.h index 4faf66e6caf9f..c9746d82d17d9 100644 --- a/polly/include/polly/Support/VirtualInstruction.h +++ b/polly/include/polly/Support/VirtualInstruction.h @@ -167,12 +167,10 @@ class VirtualUse { }; /// An iterator for virtual operands. -class VirtualOperandIterator - : public std::iterator<std::forward_iterator_tag, VirtualUse> { +class VirtualOperandIterator { friend class VirtualInstruction; friend class VirtualUse; - using super = std::iterator<std::forward_iterator_tag, VirtualUse>; using Self = VirtualOperandIterator; ScopStmt *User; @@ -182,8 +180,11 @@ class VirtualOperandIterator : User(User), U(U) {} public: - using pointer = typename super::pointer; - using reference = typename super::reference; + using iterator_category = std::forward_iterator_tag; + using value_type = VirtualUse; + using diff erence_type = std::ptr diff _t; + using pointer = value_type *; + using reference = value_type &; inline bool operator==(const Self &that) const { assert(this->User == that.User); _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
