[BOLT] Stop using std::iterator (NFC)

[kazu]

Summary

With this patch, I get warnings like:

bolt/include/bolt/Core/BinaryContext.h:108:19: error:
'iterator<std::bidirectional_iterator_tag,
llvm::bolt::BinarySection>' is deprecated
[-Werror,-Wdeprecated-declarations]

This patch fixes those warnings by defining iterator_category,
value_type, etc.

This patch intentionally leaves duplicate types like FilterIterator::T
and FilterIterator::PointerT intact to avoid mixing the fix and the
cleanup.

[kazu]

Please take a look. Thanks!

[rafauler]

LGTM, thanks!

[rafauler]

nit: fix the summary: "With this patch, I get warnings" --> "Without this patch, I get warnings"

bolt/include/bolt/Core/BinaryContext.h

 /// Helper function to truncate a \p Value to given size in \p Bytes.
 inline int64_t truncateToSize(int64_t Value, unsigned Bytes) {
   return Value & ((uint64_t)(int64_t)-1 >> (64 - Bytes * 8));
 }
 
 /// Filter iterator.
 template <typename ItrType,
           typename PredType = std::function<bool(const ItrType &)>>
-class FilterIterator
-    : public std::iterator<std::bidirectional_iterator_tag,
-                           typename std::iterator_traits<ItrType>::value_type> {
+class FilterIterator {
+  using inner_traits = std::iterator_traits<ItrType>;
   using Iterator = FilterIterator;
   using T = typename std::iterator_traits<ItrType>::reference;
   using PointerT = typename std::iterator_traits<ItrType>::pointer;
 
   PredType Pred;
   ItrType Itr, End;
 
   void prev() {
     while (!Pred(--Itr))
       ;
   }
   void next() {
     ++Itr;
     nextMatching();
   }
   void nextMatching() {
     while (Itr != End && !Pred(Itr))
       ++Itr;
   }
 
 public:
+  using iterator_category = std::bidirectional_iterator_tag;
+  using value_type = typename inner_traits::value_type;
+  using difference_type = typename inner_traits::difference_type;
+  using pointer = typename inner_traits::pointer;
+  using reference = typename inner_traits::reference;
+
   Iterator &operator++() { next(); return *this; }
   Iterator &operator--() { prev(); return *this; }
   Iterator operator++(int) { auto Tmp(Itr); next(); return Tmp; }
   Iterator operator--(int) { auto Tmp(Itr); prev(); return Tmp; }
   bool operator==(const Iterator &Other) const { return Itr == Other.Itr; }
   bool operator!=(const Iterator &Other) const { return !operator==(Other); }
   T operator*() { return *Itr; }
   PointerT operator->() { return &operator*(); }

bolt/include/bolt/Core/MCPlusBuilder.h

protected:
   /// Names of non-standard annotations.
   SmallVector<std::string, 8> AnnotationNames;
 
   /// Allocate the TailCall annotation value. Clients of the target-specific
   /// MCPlusBuilder classes must use convert/lower/create* interfaces instead.
   void setTailCall(MCInst &Inst);
 
 public:
-  class InstructionIterator
-      : public std::iterator<std::bidirectional_iterator_tag, MCInst> {
+  class InstructionIterator {
   public:
+    using iterator_category = std::bidirectional_iterator_tag;
+    using value_type = MCInst;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
     class Impl {
     public:
       virtual Impl *Copy() const = 0;
       virtual void Next() = 0;
       virtual void Prev() = 0;
       virtual MCInst &Deref() = 0;
       virtual bool Compare(const Impl &Other) const = 0;
       virtual ~Impl() {}

bolt/include/bolt/Passes/DataflowAnalysis.h

while (!Worklist.empty()) {
       }
     } // end while (!Worklist.empty())
   }
 };
 
 /// Define an iterator for navigating the expressions calculated by a
 /// dataflow analysis at each program point, when they are backed by a
 /// BitVector.
-class ExprIterator
-    : public std::iterator<std::forward_iterator_tag, const MCInst *> {
+class ExprIterator {
   const BitVector *BV;
   const std::vector<MCInst *> &Expressions;
   int Idx;
 
 public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = const MCInst *;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using reference = value_type &;
+
   ExprIterator &operator++() {
     assert(Idx != -1 && "Iterator already at the end");
     Idx = BV->find_next(Idx);
     return *this;
   }
   ExprIterator operator++(int) {
     assert(Idx != -1 && "Iterator already at the end");
     ExprIterator Ret = *this;