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

[dblaikie]

include/llvm/ADT/STLExtras.h

61–62

Should these changes be adding all these typedefs? I assume the reason std::unary_function et. al. are deprecated is that callers should likely be using decltype & similar things to work here instead?

[compnerd]

include/llvm/ADT/STLExtras.h

61–62

Well, doing it this way makes it a NFC change. Plus, doing something like decltype to get the argument types adds a bit of unnecessary complexity though.

[coder0xff]

If there are no revisions requested, can this be accepted, please?

[Ralith]

What's the status of this? I have a project that's currently blocked from updating to clang 5 as it needs both C++17 and LLVM.

[• zachrwolfe]

Any updates on this? I've found myself in the same situation as @Ralith, several months later.

Thanks!

[Ralith]

In D36049#1017134, @zachrwolfe wrote:

Any updates on this? I've found myself in the same situation as @Ralith, several months later.

Thanks!

The LLVM 6 RC seems to have had uses of std::{unary,binary}_function removed, and builds under clang 6's C++17 configurations, so if you don't absolutely need LLVM 5 specifically this is soon to be a nonissue.

[• zachrwolfe]

In D36049#1017462, @Ralith wrote:

In D36049#1017134, @zachrwolfe wrote:

Any updates on this? I've found myself in the same situation as @Ralith, several months later.

Thanks!

The LLVM 6 RC seems to have had uses of std::{unary,binary}_function removed, and builds under clang 6's C++17 configurations, so if you don't absolutely need LLVM 5 specifically this is soon to be a nonissue.

Thanks for your response. I assumed that I'd be notified of responses by email but never was, so I didn't see it until now. I ended up updating to LLVM 6.0 after it was released and that solved my issue.

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 {
+  using argument_type = Ty;
+  using result_type = Ty;
+
   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 {
+  using first_argument_type = Ty;
+  using second_argument_type = Ty;
+  using result_Type = bool;
+
   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 {
+  using first_argument_type = Ty;
+  using second_argument_type = Ty;
+  using result_Type = bool;
+
   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 {
+    using first_argument_type = SUnit*;
+    using second_argument_type = SUnit*;
+    using result_Type = bool;
+
     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 {
+  using argument_type = const MachineBasicBlock*;
+  using result_type = unsigned;
+
   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 {
+    using first_argument_type = SUnit*;
+    using second_argument_type = SUnit*;
+    using result_type = bool;
+
     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 *>;
+  using DerefFnTy = BasicBlock* (*)(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 *>;
+  using ConstDerefFnTy = const BasicBlock* (*)(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 {
+  using argument_type = unsigned;
+  using result_type = unsigned;
+
   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 {
+  using first_argument_type = SUnit*;
+  using second_argument_type = SUnit*;
+  using result_type = bool;
+
   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 {
+    using first_argument_type = SeqT;
+    using second_argument_type = SeqT;
+    using result_type = bool;
+
     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.