Pass comparators by reference, not by copying them.

libcxx/include/__algorithm/sort.h

__restart:
                     __first = ++__i;
                     continue;
                 }
             }
         }
         // sort smaller range with recursive call and larger with tail recursion elimination
         if (__i - __first < __last - __i)
         {
-          _VSTD::__introsort<_Compare>(__first, __i, __comp, __depth);
+          _VSTD::__introsort<_Compare>(__first, __i, _Comp_ref(__comp), __depth);
           __first = ++__i;
         }
         else
         {
-          _VSTD::__introsort<_Compare>(__i + 1, __last, __comp, __depth);
+          _VSTD::__introsort<_Compare>(__i + 1, __last, _Comp_ref(__comp), __depth);
           __last = __i;
         }
     }
 }
 
 template <typename _Number>
 inline _LIBCPP_HIDE_FROM_ABI _Number __log2i(_Number __n) {
   _Number __log2 = 0;
   while (__n > 1) {
     __log2++;
     __n >>= 1;
   }
   return __log2;
 }
 
 template <class _Compare, class _RandomAccessIterator>
 void __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
+  typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
   difference_type __depth_limit = 2 * __log2i(__last - __first);
-  __introsort(__first, __last, __comp, __depth_limit);
+  _VSTD::__introsort<_Compare>(__first, __last, _Comp_ref(__comp), __depth_limit);
 }
 
 template <class _Compare, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 __sort(_Tp** __first, _Tp** __last, __less<_Tp*>&)
 {
     __less<uintptr_t> __comp;

libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp

 
 struct indirect_less
 {
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}
 };
 
+#if TEST_STD_VER >= 11
+template <typename T>
+struct test_compare {
+  bool Compare(const T& x, const T& y) { return x < y; }
+};
+
+template <typename T>
+struct unique_ptr_less {
+  explicit unique_ptr_less(std::unique_ptr<test_compare<T>> cmp) : cmp_(std::move(cmp)) {}
+  bool operator()(const T& x, const T& y) { return cmp_->Compare(x, y); }
+
+private:
+  std::unique_ptr<test_compare<T>> cmp_;
+};
+#endif
+
 int main(int, char**)
 {
     {
     std::vector<int> v(1000);
     for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
         v[i] = i;
     std::sort(v.begin(), v.end(), std::greater<int>());
     std::reverse(v.begin(), v.end());
     assert(std::is_sorted(v.begin(), v.end()));
     }
 
 #if TEST_STD_VER >= 11
     {
     std::vector<std::unique_ptr<int> > v(1000);
     for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
         v[i].reset(new int(i));
     std::sort(v.begin(), v.end(), indirect_less());
     assert(std::is_sorted(v.begin(), v.end(), indirect_less()));
     assert(*v[0] == 0);
     assert(*v[1] == 1);
     assert(*v[2] == 2);
     }
+    {
+      auto cmp = std::make_unique<test_compare<int>>();
+      std::vector<int> v(1000);
+      for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
+        v[i] = i;
+      std::sort(v.begin(), v.end(), unique_ptr_less<int>(std::move(cmp)));
+    }
 #endif
 
   return 0;
 }