Remove uses of deprecated std::unary_function, binary_function, and pointer_to_unary_function.

[Eugene.Zelenko]

include/llvm/ADT/STLExtras.h

61

Please use using instead. See http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-using.html. Same in other places.

include/llvm/ADT/STLExtras.h

 
 } // End detail namespace
 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <functional>
 //===----------------------------------------------------------------------===//
 
 template<class Ty>
-struct identity : public std::unary_function<Ty, Ty> {
+struct identity {
+  typedef Ty argument_type;
+  typedef Ty result_type;
+
   Ty &operator()(Ty &self) const {
     return self;
   }
   const Ty &operator()(const Ty &self) const {
     return self;
   }
 };
 
 template<class Ty>
-struct less_ptr : public std::binary_function<Ty, Ty, bool> {
+struct less_ptr {
+  typedef Ty first_argument_type;
+  typedef Ty second_argument_type;
+  typedef bool result_Type;
+
   bool operator()(const Ty* left, const Ty* right) const {
     return *left < *right;
   }
 };
 
 template<class Ty>
-struct greater_ptr : public std::binary_function<Ty, Ty, bool> {
+struct greater_ptr {
+  typedef Ty first_argument_type;
+  typedef Ty second_argument_type;
+  typedef bool result_Type;
+
   bool operator()(const Ty* left, const Ty* right) const {
     return *right < *left;
   }
 };
 
 /// An efficient, type-erasing, non-owning reference to a callable. This is
 /// intended for use as the type of a function parameter that is not used
 /// after the function in question returns.

include/llvm/CodeGen/LatencyPriorityQueue.h

 #define LLVM_CODEGEN_LATENCYPRIORITYQUEUE_H
 
 #include "llvm/CodeGen/ScheduleDAG.h"
 
 namespace llvm {
   class LatencyPriorityQueue;
 
   /// Sorting functions for the Available queue.
-  struct latency_sort : public std::binary_function<SUnit*, SUnit*, bool> {
+  struct latency_sort {
+    typedef SUnit* first_argument_type;
+    typedef SUnit* second_argument_type;
+    typedef bool result_Type;
+
     LatencyPriorityQueue *PQ;
     explicit latency_sort(LatencyPriorityQueue *pq) : PQ(pq) {}
 
     bool operator()(const SUnit* left, const SUnit* right) const;
   };
 
   class LatencyPriorityQueue : public SchedulingPriorityQueue {
     // SUnits - The SUnits for the current graph.

include/llvm/CodeGen/MachineBasicBlock.h

private:
   /// unless you know what you're doing, because it doesn't update Pred's
   /// successors list. Use Pred->removeSuccessor instead.
   void removePredecessor(MachineBasicBlock *Pred);
 };
 
 raw_ostream& operator<<(raw_ostream &OS, const MachineBasicBlock &MBB);
 
 // This is useful when building IndexedMaps keyed on basic block pointers.
-struct MBB2NumberFunctor :
-  public std::unary_function<const MachineBasicBlock*, unsigned> {
+struct MBB2NumberFunctor {
+  typedef const MachineBasicBlock* argument_type;
+  typedef unsigned result_type;
+
   unsigned operator()(const MachineBasicBlock *MBB) const {
     return MBB->getNumber();
   }
 };
 
 //===--------------------------------------------------------------------===//
 // GraphTraits specializations for machine basic block graphs (machine-CFGs)
 //===--------------------------------------------------------------------===//

include/llvm/CodeGen/ResourcePriorityQueue.h

 #include "llvm/MC/MCInstrItineraries.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 
 namespace llvm {
   class ResourcePriorityQueue;
 
   /// Sorting functions for the Available queue.
-  struct resource_sort : public std::binary_function<SUnit*, SUnit*, bool> {
+  struct resource_sort {
+    typedef SUnit* first_argument_type;
+    typedef SUnit* second_argument_type;
+    typedef bool result_type;
+
     ResourcePriorityQueue *PQ;
     explicit resource_sort(ResourcePriorityQueue *pq) : PQ(pq) {}
 
     bool operator()(const SUnit* left, const SUnit* right) const;
   };
 
   class ResourcePriorityQueue : public SchedulingPriorityQueue {
     /// SUnits - The SUnits for the current graph.

include/llvm/IR/Instructions.h

 
 private:
   static BasicBlock *handler_helper(Value *V) { return cast<BasicBlock>(V); }
   static const BasicBlock *handler_helper(const Value *V) {
     return cast<BasicBlock>(V);
   }
 
 public:
-  using DerefFnTy = std::pointer_to_unary_function<Value *, BasicBlock *>;
+  typedef BasicBlock* (*DerefFnTy)(Value *);
   using handler_iterator = mapped_iterator<op_iterator, DerefFnTy>;
   using handler_range = iterator_range<handler_iterator>;
-  using ConstDerefFnTy =
-      std::pointer_to_unary_function<const Value *, const BasicBlock *>;
+  typedef const BasicBlock* (*ConstDerefFnTy)(const Value *);
   using const_handler_iterator =
       mapped_iterator<const_op_iterator, ConstDerefFnTy>;
   using const_handler_range = iterator_range<const_handler_iterator>;
 
   /// Returns an iterator that points to the first handler in CatchSwitchInst.
   handler_iterator handler_begin() {
     op_iterator It = op_begin() + 1;
     if (hasUnwindDest())

include/llvm/Target/TargetRegisterInfo.h

public:
   /// Advance iterator to the next entry.
   void operator++() {
     assert(isValid() && "Cannot move iterator past end.");
     moveToNextID();
   }
 };
 
 // This is useful when building IndexedMaps keyed on virtual registers
-struct VirtReg2IndexFunctor : public std::unary_function<unsigned, unsigned> {
+struct VirtReg2IndexFunctor {
+  typedef unsigned argument_type;
+  typedef unsigned result_type;
+
   unsigned operator()(unsigned Reg) const {
     return TargetRegisterInfo::virtReg2Index(Reg);
   }
 };
 
 /// Prints virtual and physical registers with or without a TRI instance.
 ///
 /// The format is:

lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp

 //===----------------------------------------------------------------------===//
 //
 // This is a SchedulingPriorityQueue that schedules using Sethi Ullman numbers
 // to reduce register pressure.
 //
 namespace {
 class RegReductionPQBase;
 
-struct queue_sort : public std::binary_function<SUnit*, SUnit*, bool> {
+struct queue_sort {
+  typedef SUnit* first_argument_type;
+  typedef SUnit* second_argument_type;
+  typedef bool result_type;
+
   bool isReady(SUnit* SU, unsigned CurCycle) const { return true; }
 };
 
 #ifndef NDEBUG
 template<class SF>
 struct reverse_sort : public queue_sort {
   SF &SortFunc;
   reverse_sort(SF &sf) : SortFunc(sf) {}

utils/TableGen/SequenceToOffsetTable.h

 /// @tparam SeqT The sequence container. (vector or string).
 /// @tparam Less A stable comparator for SeqT elements.
 template<typename SeqT, typename Less = std::less<typename SeqT::value_type> >
 class SequenceToOffsetTable {
   typedef typename SeqT::value_type ElemT;
 
   // Define a comparator for SeqT that sorts a suffix immediately before a
   // sequence with that suffix.
-  struct SeqLess : public std::binary_function<SeqT, SeqT, bool> {
+  struct SeqLess {
+    typedef SeqT first_argument_type;
+    typedef SeqT second_argument_type;
+    typedef bool result_type;
+
     Less L;
     bool operator()(const SeqT &A, const SeqT &B) const {
       return std::lexicographical_compare(A.rbegin(), A.rend(),
                                           B.rbegin(), B.rend(), L);
     }
   };
 
   // Keep sequences ordered according to SeqLess so suffixes are easy to find.