[libc++] Complete the implementation of N4190

[philnik]

Summary

Fixes #37402

[ldionne]

libcxx/docs/Status/Cxx17Papers.csv

1

We need to add a release note, since this will cause some code to start failing to compile (because of deprecation warnings and the removed classes).

libcxx/include/__config

1235

I don't understand why we're making an ABI change in the stable ABI?

libcxx/include/__functional/binary_function.h

24

Can you please add a test to check that this is deprecated in C++11? (same for others).

libcxx/include/__functional/function.h

100

This comment is inconsistent with the #if's condition. However, regardless, I think we should remove the #if entirely, since it is always valid.

libcxx/include/ext/__hash

25

Technically, I think we still need to be providing the argument_type and result_type typedefs in C++17, but they should be deprecated. In practice, I don't know whether we care, it may be acceptable to just remove them. But whatever we do, we should be consistent between different specializations of std::hash (the current patch isn't, since e.g. std::hash<std::bitset<...>> provides those typedefs.

Furthermore, if we do provide them in C++17, they should be marked as deprecated.

In C++20, they should never be provided.

[philnik]

libcxx/include/__config

1235

AFAICT this can only be ABI affecting if you have a class that is derived from both unary_function and another class that derives from it. Since there is no more unary_function to derive from, there is no way to have an ABI break. Same for binary_function.

libcxx/include/__functional/function.h

100

How is the condition always valid?

libcxx/include/ext/__hash

25

I'm going with removing them, since they are removed in C++20 anyways.

[philnik]

• Address comments

[avogelsgesang]

libcxx/docs/ReleaseNotes.rst

93

The -> The functions

96

deprectaiton -> deprecation

[philnik]

• Fix CI

[philnik]

• Fix GCC C++11

[ldionne]

libcxx/include/__functional/binder2nd.h

24

Unrelated, but we should rename this to _Operation (elsewhere too). Can you make a NFC commit?

[ldionne]

libcxx/include/__config

1235

I don't think that is correct. Indeed, let's consider:

template <class _Pred>
class binary_negate
    : public binary_function<_Pred::first_argument_type, _Pred::second_argument_type, bool>
{ ... };

template <class _Arg1, class _Arg2, class _Result>
class pointer_to_binary_function
    : public binary_function<_Arg1, _Arg2, _Result>
{ ... };

The exact classes don't matter, I just picked two classes that derived from binary_function. Now, let's take a look at the layout of the following type:

struct Foo
  : binary_negate<bool(int,int)>,
    pointer_to_binary_function<int, int, bool>
{ };

Without the bases, sizeof(Foo) is 1, and it is 2 with the bases. See https://godbolt.org/z/5b3PnjK54.

---

This sucks because it makes this PR more complicated. One simple thing we could do is inherit from a new type called __binary_function_or_empty <binary_negate<_Pred>, _Pred::first_argument_type, _Pred::second_argument_type, bool> (and similarly for all function objects):

template <class> struct __empty { };
template <class, class, class> struct __binary_function_layout { };

#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
template <class _Token, class, class, class>
using __binary_function_or_empty = binary_function<_Arg1, _Arg2, _Result>;
#elif defined(_LIBCPP_ABI_NO_BINDER_BASES)
template <class _Token, class, class, class>
using __binary_function_or_empty = __empty<_Token>;
#else
template <class _Token, class _Arg1, class _Arg2, class _Result>
using __binary_function_or_empty = __binary_function_layout<_Arg1, _Arg2, _Result>;
#endif

That way, we can define function objects unconditionally like

template <class _Pred>
class binary_negate
    : public __binary_function_or_empty<binary_negate<_Pred>, _Pred::first_argument_type, _Pred::second_argument_type, bool>
{ ... };

Since the _Token is guaranteed to be unique, we'll always get the EBO (🤞🏻).

1245

For the types that are specified as inheriting from unary_function/binary_function, can you please add a test to check that we inherit from them in C++ <= 14?

libcxx/include/ext/__hash

25

I'm sorry for the churn, but I don't know why I said it was reasonable not to provide them. Looking at cppreference, they are clearly documented as being there in C++17, so I think we should provide them, but mark them as deprecated.

[philnik]

libcxx/include/__config

1245

There are already tests for all of them. They haven't been guarded with _LIBCPP_ABI_NO_BINDER_BASES.

libcxx/include/__functional/binder2nd.h

24

I've added a TODO on my list.

[philnik]

• Address comments

[philnik]

• Fix CI

[philnik]

• Next try

[philnik]

• Try to fix CI

[ldionne]

libcxx/docs/ReleaseNotes.rst

96

Still a typo!

libcxx/include/__functional/binary_function.h

41

libcxx/include/__functional/hash.h

383 ↗

(On Diff #431265)

It seems to me like we can probably remove these PUSH/POP macros here now, since unary_function is used behind the __unary_function_or_empty alias, which has the right PUSH/POP macros when it is defined. Can you try removing them (here and elsewhere)?

libcxx/include/__functional/mem_fn.h

46–48

Why is this needed?

libcxx/include/__functional/unary_function.h

31

libcxx/include/__functional/unary_negate.h

39–40

I don't think that should be there.

libcxx/include/__functional/weak_result_type.h

247

Something for a different patch, but we do support variadics in C++03 so we can include this code block in all cases, unless I am mistaken.

libcxx/include/string

4381–4382

I don't think you need to push/pop here?

libcxx/include/string_view

911–912

Same.

libcxx/include/system_error

436–437

Same.

libcxx/include/thread

199–200

Same.

libcxx/include/typeindex

104–105

Same.

libcxx/include/vector

3227–3228

Same.

libcxx/test/std/depr/depr.function.objects/depr.base/depr.verify.cpp

9–18

Can you have one test for binary_function and one test for unary_function? Also, please make sure the comments at the top of the test are accurate.

libcxx/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp

13

I think this can stay? And if it should go (because the Standard doesn't mandate that inheritance), then it should go from the other hash tests too.

29

I think this should be guarded with #if TEST_STD_VER <= 14 instead like you've done elsewhere.

libcxx/test/std/utilities/function.objects/refwrap/binder_typedefs.compile.pass.cpp

1 ↗

(On Diff #431265)

Thanks for adding this coverage.

[philnik]

• Address comments

libcxx/include/__functional/mem_fn.h

46–48

I can't remember why I added it and everything works without it, so I removed it.

libcxx/include/__functional/weak_result_type.h

247

Added a TODO.

[philnik]

• Rebased
• Add new feature release note

[ldionne]

What a patch. Thanks a lot for your collaboration on all the iterations here, this is really not a simple one. LGTM once my comments are applied, but I'd like you to ping me once you land this so I can post-commit review the ABI test you added. Also, please make sure to get a green CI run.

libcxx/include/__functional/binary_function.h

23

Can you please add a comment in this file explaining what's going on? Point out the fact that we're jumping through these hoops to remain ABI compatible.

libcxx/include/__functional/unary_function.h

12

For both unary_function and binary_function, I would like to add a test that would fail if this patch had the effect of changing the layout. You can base it on something like https://godbolt.org/z/5b3PnjK54, like static_assert(sizeof(Foo) == X).

22

Same thing here, let's add a comment explaining the tricks we do.

[philnik]

• Rebased
• Address comments

[EricWF]

I'm pretty sure this change results in cases where, under ABI v2, C++14 and C++17 produce different ABI's. Am I mistaken?

libcxx/include/__functional/unary_function.h

38

As I mention below, I don't think this optimization is worth the cost. And I think adding this extra template parameter will increase debug info sizes enough to matter more than the types sizes.

51

I'm not convinced this optimization is worth the complexity it adds to the library. I suspect nobody is really writing code that would benefit from this, and if they are, I don't think they really care about the extra byte.

Also this generates different ABI's between C++14 and C++17, which is a not OK. You should be able to link code compiled in different dialects.

libcxx/include/__functional/weak_result_type.h

60

This seems super weird and confusing. Does the thing derived from std::binary_function or not? Now we have weird cases.

libcxx/test/std/utilities/function.objects/func.require/binary_function.pass.cpp

13 ↗

(On Diff #435626)

Yeah, just disable the warning. It seems like a footgun to configure the library differently than the user would to test conforming behavior. The user shouldn't need to pass that flag, so neither should we.

libcxx/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp

17 ↗

(On Diff #435626)

Or just turn off the warning?

[ldionne]

libcxx/include/__functional/unary_function.h

51

Also this generates different ABI's between C++14 and C++17, which is a not OK.

I don't see it -- can you explain why we generate different ABIs? The goal of jumping through these hoops was specifically to generate the same ABI, but maybe we missed something (you know how tricky these changes are, so it's great to have additional opinions). This is how I understand the code right now (let's ignore _LIBCPP_ABI_NO_BINDER_BASES for the moment):

• C++ <= 14: we inherit from unary_function<Arg, Result>
• C++ > 14: we inherit from __unary_function_keep_layout_base<Arg, Result>

In both cases, the layout of the base classes is the same, and they have the same properties with respect to the empty base optimization applying. Did we miss something?

libcxx/test/std/utilities/function.objects/func.require/binary_function.pass.cpp

13 ↗

(On Diff #435626)

Just to make sure I understand, are you suggesting that we drop the deprecation warnings from this patch entirely? If so, I'd disagree -- that's the whole point of the patch. I know it means we're requesting that users do some work, and that's not the most fun part of our job, but I think it's really important for the health of the ecosystem as a whole.

[ldionne]

In D124346#3571465, @EricWF wrote:

I'm pretty sure this change results in cases where, under ABI v2, C++14 and C++17 produce different ABI's. Am I mistaken?

Oh, I missed that you said "Under ABI V2". Yes, I think that's correct, actually. It's tricky because we generally don't think about ABI compatibility at all when we start enabling these ABI macros, however I do agree that if we are to ever consider ABI v2 as stable, we need to. It's doubly tricky because I don't know what's the state of other ABI macros w.r.t. standard versions -- have we done other things that would produce a different ABI between C++14 and C++17 in ABI v2? That's possible, we'd need to check.

Concretely for this patch, I think it only means that we need to drop the _LIBCPP_ABI_NO_BINDER_BASES macro. Furthermore, I think it gives us a new criterion for creating these ABI macros in the first place: An ABI macro must not result in a different ABI for different Standard versions, period. I'll document that.

[EricWF]

libcxx/include/__functional/unary_function.h

51

Consider when _LIBCPP_ABI_NO_BINDER_BASES is defined.
It's observable if you're inheriting from __unary_function_ebo_base base or not.

Because we pass the extra arg to make sure the base class is unique, can't that uniqueness make something EBO away in C++17 that wouldn't in C++14?

[EricWF]

libcxx/include/__functional/unary_function.h

51

Though I grant the cases which trigger this are likely rare. But they're also the same set of cases this EBO optimization is targeting.

Please let me know if I'm misunderstanding something.

[philnik]

• Remove _LIBCPP_ABI_NO_BINDER_BASES

[philnik]

• Rebased
• Try to fix CI

[philnik]

• Try to fix CI

[philnik]

Rebased

[philnik]

• Next try

[philnik]

Rebased

[cmtice]

Just a heads up, this looks like it may have broken compiler-rt builds. I'm seeing errors like:
ERROR: third_party/stl/BUILD:57:11: Compiling third_party/stl/stl.cppmap failed: (Exit 1) wrapped_clang failed: error executing command (from target third_party/stl:stl) third_party/crosstool/v18/llvm_unstable/toolchain/bin/wrapped_clang '-frandom-seed=blaze-out/k8-opt/bin/third_party/stl/_objs/stl/stl.pcm' -iquote . -iquote blaze-out/k8-opt/genfiles -iquote ... (remaining 224 arguments skipped). [forge_remote_host=lmdw19]
While building module 'third_party/stl:stl':
In file included from <module-includes>:43:
./third_party/stl/cxx17/ext/functional:17:24: error: no template named 'unary_function' in namespace 'std'; did you mean '__unary_function'?
struct identity : std::unary_function<T, T> {

~~~~~^~~~~~~~~~~~~~
     __unary_function

third_party/crosstool/v18/llvm_unstable/toolchain/bin/../include/c++/v1/__functional/unary_function.h:46:1: note: 'unary_function' declared here
using unary_function = unary_function_keep_layout_base<_Arg, _Result>;
^
While building module '//third_party/stl:stl':
In file included from <module-includes>:43:
./third_party/stl/cxx17/ext/functional:22:25: error: no template named 'unary_function' in namespace 'std'; did you mean 'unary_function'?
struct select1st : std::unary_function<Pair, typename Pair::first_type> {

~~~~~^~~~~~~~~~~~~~
     __unary_function

third_party/crosstool/v18/llvm_unstable/toolchain/bin/../include/c++/v1/__functional/unary_function.h:46:1: note: 'unary_function' declared here
using unary_function = __unary_function_keep_layout_base<_Arg, _Result>;

(and more)

[philnik]

@cmtice I'm guessing you build with C++17 or higher? In that case it's expected, since unary_function doesn't exist anymore.

[cmtice]

@philnik Ah, thanks for pointing that out. Ignore my previous comment. :-)

libcxx/docs/ReleaseNotes.rst

 
 - Setting a custom debug handler with ``std::__libcpp_debug_function`` is not
   supported anymore. Please migrate to using the new support for
   :ref:`assertions <assertions-mode>` instead.
 
 - ``vector<bool>::const_reference``, ``vector<bool>::const_iterator::reference``
   and ``bitset::const_reference`` are now aliases for `bool` in the unstable ABI.
 
+- ``unary_function`` and ``binary_function`` are no longer available in C++17 and C++20.
+  The can be re-enabled by defining ``_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION``.
+  They are also marked as ``[[deprecated]]`` in C++11 and later. To disable deprecation warnings
+  you have to define ``_LIBCPP_DISABLE_DEPRECATION_WARNINGS``. Note that this disables
+  all deprectaiton warnings.
+
 ABI Changes
 -----------
 
 - The ``_LIBCPP_ABI_USE_CXX03_NULLPTR_EMULATION`` macro controlling whether we use an
   emulation for ``std::nullptr_t`` in C++03 mode has been removed. After this change,
   ``_LIBCPP_ABI_USE_CXX03_NULLPTR_EMULATION`` will not be honoured anymore and there
   will be no way to opt back into the C++03 emulation of ``std::nullptr_t``.
 

libcxx/docs/Status/Cxx17Papers.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version"
 "`N3911 <https://wg21.link/n3911>`__","LWG","TransformationTrait Alias ``void_t``\ .","Urbana","|Complete|","3.6"
 "`N4089 <https://wg21.link/n4089>`__","LWG","Safe conversions in ``unique_ptr<T[]>``\ .","Urbana","|In Progress|","3.9"
 "`N4169 <https://wg21.link/n4169>`__","LWG","A proposal to add invoke function template","Urbana","|Complete|","3.7"
-"`N4190 <https://wg21.link/n4190>`__","LWG","Removing auto_ptr, random_shuffle(), And Old <functional> Stuff.","Urbana","|In Progress|",""
+"`N4190 <https://wg21.link/n4190>`__","LWG","Removing auto_ptr, random_shuffle(), And Old <functional> Stuff.","Urbana","|Complete|","15.0"
 "`N4258 <https://wg21.link/n4258>`__","LWG","Cleaning-up noexcept in the Library.","Urbana","|In Progress|","3.7"
 "`N4259 <https://wg21.link/n4259>`__","CWG","Wording for std::uncaught_exceptions","Urbana","|Complete|","3.7"
 "`N4277 <https://wg21.link/n4277>`__","LWG","TriviallyCopyable ``reference_wrapper``\ .","Urbana","|Complete|","3.2"
 "`N4279 <https://wg21.link/n4279>`__","LWG","Improved insertion interface for unique-key maps.","Urbana","|Complete|","3.7"
 "`N4280 <https://wg21.link/n4280>`__","LWG","Non-member size() and more","Urbana","|Complete|","3.6"
 "`N4284 <https://wg21.link/n4284>`__","LWG","Contiguous Iterators.","Urbana","|Complete|","3.6"
 "`N4285 <https://wg21.link/n4285>`__","CWG","Cleanup for exception-specification and throw-expression.","Urbana","|Complete|","4.0"
 "","","","","",""

libcxx/include/__config

 #  define _LIBCPP_DECLSPEC_EMPTY_BASES
 #endif
 
 #if defined(_LIBCPP_ENABLE_CXX17_REMOVED_FEATURES)
 #define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
 #define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
 #define _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS
+#define _LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION
 #endif // _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
 
 #if defined(_LIBCPP_ENABLE_CXX20_REMOVED_FEATURES)
 #define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 #define _LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS
 #define _LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
 #define _LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR
 #define _LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS
 #endif // _LIBCPP_ENABLE_CXX20_REMOVED_FEATURES
 
+#if !defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION) && _LIBCPP_STD_VER > 14
+#  define _LIBCPP_ABI_NO_BINDER_BASES
+#endif
+
 #if !defined(__cpp_impl_coroutine) || __cpp_impl_coroutine < 201902L
 #define _LIBCPP_HAS_NO_CXX20_COROUTINES
 #endif
 
 #if defined(_LIBCPP_COMPILER_IBM)
 #define _LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO
 #endif
 
 #if defined(_LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO)
 #  define _LIBCPP_PUSH_MACROS
 #  define _LIBCPP_POP_MACROS
 #else
   // Don't warn about macro conflicts when we can restore them at the
   // end of the header.
 #  ifndef _LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS
 #    define _LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS

libcxx/include/__functional/binary_function.h

 #define _LIBCPP___FUNCTIONAL_BINARY_FUNCTION_H
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Arg1, class _Arg2, class _Result>
-struct _LIBCPP_TEMPLATE_VIS binary_function
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binary_function
 {
     typedef _Arg1   first_argument_type;
     typedef _Arg2   second_argument_type;
     typedef _Result result_type;
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // _LIBCPP_STD_VER <= 14
+
 #endif // _LIBCPP___FUNCTIONAL_BINARY_FUNCTION_H

libcxx/include/__functional/binary_negate.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS)
 
 template <class _Predicate>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 binary_negate
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public binary_function<typename _Predicate::first_argument_type,
                              typename _Predicate::second_argument_type,
                              bool>
+#endif
 {
     _Predicate __pred_;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11
     binary_negate(const _Predicate& __pred) : __pred_(__pred) {}
 
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const typename _Predicate::first_argument_type& __x,
                     const typename _Predicate::second_argument_type& __y) const
         {return !__pred_(__x, __y);}
+
+    using first_argument_type = typename _Predicate::first_argument_type;
+    using second_argument_type = typename _Predicate::second_argument_type;
+    using result_type = bool;
 };
 
 template <class _Predicate>
 _LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 binary_negate<_Predicate>
 not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
 
 #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_BINARY_NEGATE_H

libcxx/include/__functional/binder1st.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
 template <class __Operation>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder1st
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<typename __Operation::second_argument_type,
                             typename __Operation::result_type>
+#endif
 {
 protected:
     __Operation                               op;
     typename __Operation::first_argument_type value;
 public:
     _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
                                const typename __Operation::first_argument_type __y)
         : op(__x), value(__y) {}

libcxx/include/__functional/binder2nd.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
 template <class __Operation>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder2nd
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<typename __Operation::first_argument_type,
                             typename __Operation::result_type>
+#endif
 {
 protected:
     __Operation                                op;
     typename __Operation::second_argument_type value;
 public:
     _LIBCPP_INLINE_VISIBILITY
     binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
         : op(__x), value(__y) {}

libcxx/include/__functional/function.h

 #   define _LIBCPP_DEPRECATED_CXX03_FUNCTION /* nothing */
 #endif
 
 template<class _Fp> class _LIBCPP_DEPRECATED_CXX03_FUNCTION _LIBCPP_TEMPLATE_VIS function; // undefined
 
 namespace __function
 {
 
+#if _LIBCPP_STD_VER <= 17 || !defined(_LIBCPP_ABI_NO_BINDER_BASES)
 template<class _Rp>
 struct __maybe_derive_from_unary_function
 {
 };
 
 template<class _Rp, class _A1>
 struct __maybe_derive_from_unary_function<_Rp(_A1)>
-    : public unary_function<_A1, _Rp>
+    : public __unary_function<_A1, _Rp>
 {
 };
 
 template<class _Rp>
 struct __maybe_derive_from_binary_function
 {
 };
 
 template<class _Rp, class _A1, class _A2>
 struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
-    : public binary_function<_A1, _A2, _Rp>
+    : public __binary_function<_A1, _A2, _Rp>
 {
 };
+#endif // _LIBCPP_STD_VER <= 17 || !defined(_LIBCPP_ABI_NO_BINDER_BASES)
 
 template <class _Fp>
 _LIBCPP_INLINE_VISIBILITY
 bool __not_null(_Fp const&) { return true; }
 
 template <class _Fp>
 _LIBCPP_INLINE_VISIBILITY
 bool __not_null(_Fp* __ptr) { return __ptr; }

libcxx/include/__functional/mem_fn.h

 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     __mem_fn(type __f) _NOEXCEPT : __f_(__f) {}
 
 #ifndef _LIBCPP_CXX03_LANG
     // invoke
     template <class... _ArgTypes>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+#if _LIBCPP_STD_VER > 14
+    typename invoke_result<type, _ArgTypes...>::type
+#else
     typename __invoke_return<type, _ArgTypes...>::type
+#endif
     operator() (_ArgTypes&&... __args) const {
         return _VSTD::__invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
     }
 #else
 
     template <class _A0>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return0<type, _A0>::type

libcxx/include/__functional/mem_fun_ref.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
 template<class _Sp, class _Tp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_t
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<_Tp*, _Sp>
+#endif
 {
     _Sp (_Tp::*__p_)();
 public:
     _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const
         {return (__p->*__p_)();}
 };
 
 template<class _Sp, class _Tp, class _Ap>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_t
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public binary_function<_Tp*, _Ap, _Sp>
+#endif
 {
     _Sp (_Tp::*__p_)(_Ap);
 public:
     _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const
         {return (__p->*__p_)(__x);}
 };
 
 template<class _Sp, class _Tp>
 _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 mem_fun_t<_Sp,_Tp>
 mem_fun(_Sp (_Tp::*__f)())
     {return mem_fun_t<_Sp,_Tp>(__f);}
 
 template<class _Sp, class _Tp, class _Ap>
 _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 mem_fun1_t<_Sp,_Tp,_Ap>
 mem_fun(_Sp (_Tp::*__f)(_Ap))
     {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
 template<class _Sp, class _Tp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_ref_t
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<_Tp, _Sp>
+#endif
 {
     _Sp (_Tp::*__p_)();
 public:
     _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const
         {return (__p.*__p_)();}
 };
 
 template<class _Sp, class _Tp, class _Ap>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_ref_t
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public binary_function<_Tp, _Ap, _Sp>
+#endif
 {
     _Sp (_Tp::*__p_)(_Ap);
 public:
     _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const
         {return (__p.*__p_)(__x);}
 };
 
 template<class _Sp, class _Tp>
 _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 mem_fun_ref_t<_Sp,_Tp>
 mem_fun_ref(_Sp (_Tp::*__f)())
     {return mem_fun_ref_t<_Sp,_Tp>(__f);}
 
 template<class _Sp, class _Tp, class _Ap>
 _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 mem_fun1_ref_t<_Sp,_Tp,_Ap>
 mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
     {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 
 template <class _Sp, class _Tp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_t
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<const _Tp*, _Sp>
+#endif
 {
     _Sp (_Tp::*__p_)() const;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const
         {return (__p->*__p_)();}
 };
 
 template <class _Sp, class _Tp, class _Ap>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_t
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public binary_function<const _Tp*, _Ap, _Sp>
+#endif
 {
     _Sp (_Tp::*__p_)(_Ap) const;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const
         {return (__p->*__p_)(__x);}
 };
 
 template <class _Sp, class _Tp>
 _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 const_mem_fun_t<_Sp,_Tp>
 mem_fun(_Sp (_Tp::*__f)() const)
     {return const_mem_fun_t<_Sp,_Tp>(__f);}
 
 template <class _Sp, class _Tp, class _Ap>
 _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 const_mem_fun1_t<_Sp,_Tp,_Ap>
 mem_fun(_Sp (_Tp::*__f)(_Ap) const)
     {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
 template <class _Sp, class _Tp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_ref_t
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<_Tp, _Sp>
+#endif
 {
     _Sp (_Tp::*__p_)() const;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const
         {return (__p.*__p_)();}
 };
 
 template <class _Sp, class _Tp, class _Ap>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_ref_t
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public binary_function<_Tp, _Ap, _Sp>
+#endif
 {
     _Sp (_Tp::*__p_)(_Ap) const;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const
         {return (__p.*__p_)(__x);}
 };

libcxx/include/__functional/pointer_to_binary_function.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
 template <class _Arg1, class _Arg2, class _Result>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_binary_function
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public binary_function<_Arg1, _Arg2, _Result>
+#endif
 {
     _Result (*__f_)(_Arg1, _Arg2);
 public:
     _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))
         : __f_(__f) {}
     _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const
         {return __f_(__x, __y);}
 };

libcxx/include/__functional/pointer_to_unary_function.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
 template <class _Arg, class _Result>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_unary_function
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<_Arg, _Result>
+#endif
 {
     _Result (*__f_)(_Arg);
 public:
     _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))
         : __f_(__f) {}
     _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const
         {return __f_(__x);}
 };

libcxx/include/__functional/unary_function.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_UNARY_FUNCTION_H
 #define _LIBCPP___FUNCTIONAL_UNARY_FUNCTION_H
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Arg, class _Result>
-struct _LIBCPP_TEMPLATE_VIS unary_function
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 unary_function
 {
     typedef _Arg    argument_type;
     typedef _Result result_type;
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // _LIBCPP_STD_VER <= 14
+
 #endif // _LIBCPP___FUNCTIONAL_UNARY_FUNCTION_H

libcxx/include/__functional/unary_negate.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS)
 
 template <class _Predicate>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 unary_negate
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<typename _Predicate::argument_type, bool>
+#endif
 {
     _Predicate __pred_;
 public:
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     explicit unary_negate(const _Predicate& __pred)
         : __pred_(__pred) {}
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const typename _Predicate::argument_type& __x) const
         {return !__pred_(__x);}
+
+    using argument_type = typename _Predicate::argument_type;
+    using result_type = bool;
 };
 
 template <class _Predicate>
 _LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 unary_negate<_Predicate>
 not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
 
 #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_UNARY_NEGATE_H

libcxx/include/__functional/weak_result_type.h

private:
     template <class _Up> static __two __test(...);
     template <class _Up> static char __test(typename _Up::result_type* = 0);
 public:
     static const bool value = sizeof(__test<_Tp>(0)) == 1;
 };
 
 // __weak_result_type
 
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
 template <class _Tp>
 struct __derives_from_unary_function
 {
 private:
     struct __two {char __lx; char __lxx;};
     static __two __test(...);
     template <class _Ap, class _Rp>
         static unary_function<_Ap, _Rp>
         __test(const volatile unary_function<_Ap, _Rp>*);
 public:
     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
     typedef decltype(__test((_Tp*)0)) type;
 };
 
 template <class _Tp>
 struct __derives_from_binary_function
 {
 private:
     struct __two {char __lx; char __lxx;};
     static __two __test(...);
     template <class _A1, class _A2, class _Rp>
         static binary_function<_A1, _A2, _Rp>
         __test(const volatile binary_function<_A1, _A2, _Rp>*);
 public:
     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
     typedef decltype(__test((_Tp*)0)) type;
 };
 
+#else
+template <class>
+struct __derives_from_unary_function : false_type {};
+
+template <class>
+struct __derives_from_binary_function : false_type {};
+#endif
+
 template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
 struct __maybe_derive_from_unary_function  // bool is true
     : public __derives_from_unary_function<_Tp>::type
 {
 };
 
 template <class _Tp>
 struct __maybe_derive_from_unary_function<_Tp, false>

 template <class _Rp>
 struct __weak_result_type<_Rp (*)()>
 {
     typedef _LIBCPP_NODEBUG _Rp result_type;
 };
 
 // 1 argument case
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
+template <class _Arg, class _Result>
+using __unary_function = unary_function<_Arg, _Result>;
+template <class _Arg1, class _Arg2, class _Result>
+using __binary_function = binary_function<_Arg1, _Arg2, _Result>;
+#else
+template <class _Arg, class _Result>
+struct __unary_function {
+    using argument_type = _Arg;
+    using result_type = _Result;
+};
+
+template <class _Arg1, class _Arg2, class _Result>
+struct __binary_function {
+    using first_argument_type = _Arg1;
+    using second_argument_type = _Arg2;
+    using result_type = _Result;
+};
+
+#endif
+
 template <class _Rp, class _A1>
 struct __weak_result_type<_Rp (_A1)>
-    : public unary_function<_A1, _Rp>
+    : public __unary_function<_A1, _Rp>
 {
 };
 
 template <class _Rp, class _A1>
 struct __weak_result_type<_Rp (&)(_A1)>
-    : public unary_function<_A1, _Rp>
+    : public __unary_function<_A1, _Rp>
 {
 };
 
 template <class _Rp, class _A1>
 struct __weak_result_type<_Rp (*)(_A1)>
-    : public unary_function<_A1, _Rp>
+    : public __unary_function<_A1, _Rp>
 {
 };
 
 template <class _Rp, class _Cp>
 struct __weak_result_type<_Rp (_Cp::*)()>
-    : public unary_function<_Cp*, _Rp>
+    : public __unary_function<_Cp*, _Rp>
 {
 };
 
 template <class _Rp, class _Cp>
 struct __weak_result_type<_Rp (_Cp::*)() const>
-    : public unary_function<const _Cp*, _Rp>
+    : public __unary_function<const _Cp*, _Rp>
 {
 };
 
 template <class _Rp, class _Cp>
 struct __weak_result_type<_Rp (_Cp::*)() volatile>
-    : public unary_function<volatile _Cp*, _Rp>
+    : public __unary_function<volatile _Cp*, _Rp>
 {
 };
 
 template <class _Rp, class _Cp>
 struct __weak_result_type<_Rp (_Cp::*)() const volatile>
-    : public unary_function<const volatile _Cp*, _Rp>
+    : public __unary_function<const volatile _Cp*, _Rp>
 {
 };
 
 // 2 argument case
 
 template <class _Rp, class _A1, class _A2>
 struct __weak_result_type<_Rp (_A1, _A2)>
-    : public binary_function<_A1, _A2, _Rp>
+    : public __binary_function<_A1, _A2, _Rp>
 {
 };
 
 template <class _Rp, class _A1, class _A2>
 struct __weak_result_type<_Rp (*)(_A1, _A2)>
-    : public binary_function<_A1, _A2, _Rp>
+    : public __binary_function<_A1, _A2, _Rp>
 {
 };
 
 template <class _Rp, class _A1, class _A2>
 struct __weak_result_type<_Rp (&)(_A1, _A2)>
-    : public binary_function<_A1, _A2, _Rp>
+    : public __binary_function<_A1, _A2, _Rp>
 {
 };
 
 template <class _Rp, class _Cp, class _A1>
 struct __weak_result_type<_Rp (_Cp::*)(_A1)>
-    : public binary_function<_Cp*, _A1, _Rp>
+    : public __binary_function<_Cp*, _A1, _Rp>
 {
 };
 
 template <class _Rp, class _Cp, class _A1>
 struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
-    : public binary_function<const _Cp*, _A1, _Rp>
+    : public __binary_function<const _Cp*, _A1, _Rp>
 {
 };
 
 template <class _Rp, class _Cp, class _A1>
 struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
-    : public binary_function<volatile _Cp*, _A1, _Rp>
+    : public __binary_function<volatile _Cp*, _A1, _Rp>
 {
 };
 
 template <class _Rp, class _Cp, class _A1>
 struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile>
-    : public binary_function<const volatile _Cp*, _A1, _Rp>
+    : public __binary_function<const volatile _Cp*, _A1, _Rp>
 {
 };
 
 
 #ifndef _LIBCPP_CXX03_LANG
 // 3 or more arguments
 
 template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
 struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)>
 {
     typedef _Rp result_type;
 };
 

libcxx/include/__memory/auto_ptr.h

 #define _LIBCPP___MEMORY_AUTO_PTR_H
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 struct _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr_ref
 {
     _Tp* __ptr_;
 };
 

 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr<void>
 {
 public:
     typedef void element_type;
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
+
 #endif // _LIBCPP___MEMORY_AUTO_PTR_H

libcxx/include/__memory/shared_ptr.h

 #include <__functional/binary_function.h>
 #include <__functional/operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__iterator/access.h>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
+#include <__memory/auto_ptr.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <cstddef>
 #include <cstdlib> // abort
 #include <iosfwd>
 #include <stdexcept>
 #include <type_traits>
 #include <typeinfo>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <atomic>
 #endif
 
-#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
-#   include <__memory/auto_ptr.h>
-#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Alloc>

libcxx/include/__memory/unique_ptr.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_UNIQUE_PTR_H
 #define _LIBCPP___MEMORY_UNIQUE_PTR_H
 
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/operations.h>
 #include <__memory/allocator_traits.h> // __pointer
+#include <__memory/auto_ptr.h>
 #include <__memory/compressed_pair.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <cstddef>
 #include <type_traits>
 
-#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
-#   include <__memory/auto_ptr.h>
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS default_delete {

libcxx/include/bitset

 {
     bitset<_Size> __r = __x;
     __r ^= __y;
     return __r;
 }
 
 template <size_t _Size>
 struct _LIBCPP_TEMPLATE_VIS hash<bitset<_Size> >
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<bitset<_Size>, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT
         {return __bs.__hash_code();}
+
+    using argument_type = bitset<_Size>;
+    using result_type = size_t;
 };
 
 template <class _CharT, class _Traits, size_t _Size>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x);
 
 template <class _CharT, class _Traits, size_t _Size>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x);
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_BITSET

libcxx/include/ext/__hash

 #include <cstring>
 #include <string>
 
 namespace __gnu_cxx {
 
 template <typename _Tp> struct _LIBCPP_TEMPLATE_VIS hash { };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<const char*>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
  : public std::unary_function<const char*, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const char *__c) const _NOEXCEPT
     {
         return std::__do_string_hash(__c, __c + strlen(__c));
     }
 };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<char *>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
  : public std::unary_function<char*, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(char *__c) const _NOEXCEPT
     {
         return std::__do_string_hash<const char *>(__c, __c + strlen(__c));
     }
 };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<char>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
  : public std::unary_function<char, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(char __c) const _NOEXCEPT
     {
         return __c;
     }
 };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<signed char>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
  : public std::unary_function<signed char, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(signed char __c) const _NOEXCEPT
     {
         return __c;
     }
 };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned char>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
  : public std::unary_function<unsigned char, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(unsigned char __c) const _NOEXCEPT
     {
         return __c;
     }
 };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<short>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
  : public std::unary_function<short, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(short __c) const _NOEXCEPT
     {
         return __c;
     }
 };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned short>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
  : public std::unary_function<unsigned short, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(unsigned short __c) const _NOEXCEPT
     {
         return __c;
     }
 };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<int>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public std::unary_function<int, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(int __c) const _NOEXCEPT
     {
         return __c;
     }
 };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned int>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public std::unary_function<unsigned int, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(unsigned int __c) const _NOEXCEPT
     {
         return __c;
     }
 };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<long>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public std::unary_function<long, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(long __c) const _NOEXCEPT
     {
         return __c;
     }
 };
 
 template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned long>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public std::unary_function<unsigned long, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(unsigned long __c) const _NOEXCEPT
     {
         return __c;
     }
 };
 } // namespace __gnu_cxx
 
 #endif // _LIBCPP_EXT_HASH

libcxx/include/map

public:
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
 
     static_assert((is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     class _LIBCPP_TEMPLATE_VIS value_compare
-#if defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+#if defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) && !defined(_LIBCPP_ABI_NO_BINDER_BASES)
         : public binary_function<value_type, value_type, bool>
 #endif
     {
 _LIBCPP_SUPPRESS_DEPRECATED_POP
         friend class map;
     protected:
         key_compare comp;
 
public:
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
 
     static_assert((is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     class _LIBCPP_TEMPLATE_VIS value_compare
-#if defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+#if defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) && !defined(_LIBCPP_ABI_NO_BINDER_BASES)
         : public binary_function<value_type, value_type, bool>
 #endif
     {
 _LIBCPP_SUPPRESS_DEPRECATED_POP
         friend class multimap;
     protected:
         key_compare comp;
 

libcxx/include/memory

 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/assume_aligned.h>
+#include <__memory/auto_ptr.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/concepts.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/ranges_construct_at.h>
 #include <__memory/ranges_uninitialized_algorithms.h>
 #include <__memory/raw_storage_iterator.h>
 #include <__memory/shared_ptr.h>

 // TODO: remove these headers
 #include <__functional/binary_function.h>
 #include <__functional/invoke.h>
 #include <__functional/operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h>
 #include <__functional/weak_result_type.h>
 
-#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
-#   include <__memory/auto_ptr.h>
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Alloc, class _Ptr>
 _LIBCPP_INLINE_VISIBILITY

libcxx/include/string

 _LIBCPP_FUNC_VIS wstring to_wstring(long double __val);
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_TEMPLATE_DATA_VIS
 const typename basic_string<_CharT, _Traits, _Allocator>::size_type
                basic_string<_CharT, _Traits, _Allocator>::npos;
 
 template <class _CharT, class _Allocator>
 struct _LIBCPP_TEMPLATE_VIS
     hash<basic_string<_CharT, char_traits<_CharT>, _Allocator> >
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<
           basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t>
+#endif
 {
     size_t
     operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT
     { return __do_string_hash(__val.data(), __val.data() + __val.size()); }
 };
 
 
 template<class _CharT, class _Traits, class _Allocator>

libcxx/include/string_view

 
 
 template<class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            basic_string_view<_CharT, _Traits> __str);
 
 // [string.view.hash]
 template<class _CharT>
 struct _LIBCPP_TEMPLATE_VIS hash<basic_string_view<_CharT, char_traits<_CharT> > >
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<basic_string_view<_CharT, char_traits<_CharT> >, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const basic_string_view<_CharT, char_traits<_CharT> > __val) const _NOEXCEPT {
         return __do_string_hash(__val.data(), __val.data() + __val.size());
     }
 };
 
 

libcxx/include/system_error

 operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
 {return !(__x == __y);}
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
 {return !(__x == __y);}
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<error_code>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<error_code, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const error_code& __ec) const _NOEXCEPT
     {
         return static_cast<size_t>(__ec.value());
     }
 };
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<error_condition, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const error_condition& __ec) const _NOEXCEPT
     {
         return static_cast<size_t>(__ec.value());
     }
 };
 

libcxx/include/thread

 void
 __thread_specific_ptr<_Tp>::set_pointer(pointer __p)
 {
     _LIBCPP_ASSERT(get() == nullptr,
                    "Attempting to overwrite thread local data");
     __libcpp_tls_set(__key_, __p);
 }
 
 template<>
 struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<__thread_id, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(__thread_id __v) const _NOEXCEPT
     {
         return hash<__libcpp_thread_id>()(__v.__id_);
     }
 };
 

libcxx/include/typeindex

public:
     _LIBCPP_INLINE_VISIBILITY
     size_t hash_code() const _NOEXCEPT {return __t_->hash_code();}
     _LIBCPP_INLINE_VISIBILITY
     const char* name() const _NOEXCEPT {return __t_->name();}
 };
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<type_index>
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<type_index, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(type_index __index) const _NOEXCEPT
         {return __index.hash_code();}
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_TYPEINDEX

libcxx/include/vector

vector<bool, _Allocator>::__hash_code() const _NOEXCEPT
     if (__n > 0)
     {
         const __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
         __h ^= *__p & __m;
     }
     return __h;
 }
 
 template <class _Allocator>
 struct _LIBCPP_TEMPLATE_VIS hash<vector<bool, _Allocator> >
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
     : public unary_function<vector<bool, _Allocator>, size_t>
+#endif
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT
         {return __vec.__hash_code();}
 };
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY

libcxx/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++03 || c++11 || c++14 || c++17
+// REQUIRES: c++03 || c++11 || c++14
 
 // <functional>
 
 // reference_wrapper
 
 // check for deriving from binary_function
 
 #include <functional>

libcxx/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++03 || c++11 || c++14 || c++17
+// REQUIRES: c++03 || c++11 || c++14
 
 // <functional>
 
 // reference_wrapper
 
 // check for deriving from unary_function
 
 #include <functional>

libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::vector<bool> T;
     typedef std::hash<T> H;
+#if TEST_STD_VER <= 14
     static_assert((std::is_same<H::argument_type, T>::value), "" );
     static_assert((std::is_same<H::result_type, std::size_t>::value), "" );
+#endif
     ASSERT_NOEXCEPT(H()(T()));
 
     bool ba[] = {true, false, true, true, false};
     T vb(std::begin(ba), std::end(ba));
     H h;
     assert(h(vb) != 0);
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::vector<bool, min_allocator<bool>> T;
     typedef std::hash<T> H;
+#if TEST_STD_VER <= 14
     static_assert((std::is_same<H::argument_type, T>::value), "" );
     static_assert((std::is_same<H::result_type, std::size_t>::value), "" );
+#endif
     ASSERT_NOEXCEPT(H()(T()));
     bool ba[] = {true, false, true, true, false};
     T vb(std::begin(ba), std::end(ba));
     H h;
     assert(h(vb) != 0);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/depr/depr.function.objects/depr.base/depr.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+// REQUIRES: c++03 || c++11 || c++14
+// binary_function was removed in C++17
+
+// check that binary_function is marked deprecated
+
+#include <functional>
+
+std::unary_function<int, int> u; // expected-warning {{'unary_function<int, int>' is deprecated}}
+std::binary_function<int, int, int> b; // expected-warning {{'binary_function<int, int, int>' is deprecated}}

libcxx/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp

 
 #include "test_macros.h"
 
 void
 test(int i)
 {
     typedef std::error_code T;
     typedef std::hash<T> H;
+#if TEST_STD_VER <= 14
     static_assert((std::is_same<H::argument_type, T>::value), "" );
     static_assert((std::is_same<H::result_type, std::size_t>::value), "" );
+#endif
     ASSERT_NOEXCEPT(H()(T()));
     H h;
     T ec(i, std::system_category());
     const std::size_t result = h(ec);
     LIBCPP_ASSERT(result == static_cast<std::size_t>(i));
     ((void)result); // Prevent unused warning
 }
 
 int main(int, char**)
 {
     test(0);
     test(2);
     test(10);
 
   return 0;
 }

libcxx/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template <class T>
 // struct hash
-//     : public unary_function<T, size_t>
 // {
 //     size_t operator()(T val) const;
 // };
 
 #include <system_error>
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 
 void
 test(int i)
 {
     typedef std::error_condition T;
     typedef std::hash<T> H;
-    static_assert((std::is_same<H::argument_type, T>::value), "" );
-    static_assert((std::is_same<H::result_type, std::size_t>::value), "" );
     ASSERT_NOEXCEPT(H()(T()));
     H h;
     T ec(i, std::system_category());
     const std::size_t result = h(ec);
     LIBCPP_ASSERT(result == static_cast<std::size_t>(i));
     ((void)result); // Prevent unused warning
 }
 
 int main(int, char**)
 {
     test(0);
     test(2);
     test(10);
 
   return 0;
 }

libcxx/test/std/strings/basic.string.hash/strings.pass.cpp

 
 #include "test_macros.h"
 
 template <class T>
 void
 test()
 {
     typedef std::hash<T> H;
+#if TEST_STD_VER <= 14
     static_assert((std::is_same<typename H::argument_type, T>::value), "" );
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
+#endif
     ASSERT_NOEXCEPT(H()(T()));
 
     H h;
     std::string g1 = "1234567890";
     std::string g2 = "1234567891";
     T s1(g1.begin(), g1.end());
     T s2(g2.begin(), g2.end());
     assert(h(s1) != h(s2));

libcxx/test/std/strings/string.view/string.view.hash/string_view.pass.cpp

 
 using std::string_view;
 
 template <class SV>
 void
 test()
 {
     typedef std::hash<SV> H;
+#if TEST_STD_VER <= 14
     static_assert((std::is_same<typename H::argument_type, SV>::value), "" );
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
+#endif
 
     typedef typename SV::value_type char_type;
     typedef std::basic_string<char_type> String;
     typedef std::hash<String> SH;
     ASSERT_NOEXCEPT(H()(SV()));
 
     char_type g1 [ 10 ];
     char_type g2 [ 10 ];

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp

 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::thread::id id1;
     std::thread::id id2 = std::this_thread::get_id();
     typedef std::hash<std::thread::id> H;
+#if TEST_STD_VER <= 14
     static_assert((std::is_same<typename H::argument_type, std::thread::id>::value), "" );
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
+#endif
     ASSERT_NOEXCEPT(H()(id2));
     H h;
     assert(h(id1) != h(id2));
 
   return 0;
 }

libcxx/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp

 #include "test_macros.h"
 
 template <std::size_t N>
 void
 test()
 {
     typedef std::bitset<N> T;
     typedef std::hash<T> H;
+#if TEST_STD_VER <= 14
     static_assert((std::is_same<typename H::argument_type, T>::value), "" );
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
+#endif
     ASSERT_NOEXCEPT(H()(T()));
 
     H h;
     T bs(static_cast<unsigned long long>(N));
     const std::size_t result = h(bs);
     LIBCPP_ASSERT(result == N);
     ((void)result); // Prevent unused warning
 }

libcxx/test/std/utilities/type.index/type.index.hash/hash.pass.cpp

 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     typedef std::hash<std::type_index> H;
+#if TEST_STD_VER <= 14
     static_assert((std::is_same<typename H::argument_type, std::type_index>::value), "" );
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
+#endif
 
     std::type_index t1 = typeid(int);
     assert(std::hash<std::type_index>()(t1) == t1.hash_code());
 
   return 0;
 }

libcxx/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp

 #include "test_macros.h"
 #if TEST_STD_VER >= 11
 #include "poisoned_hash_helper.h"
 #endif
 
 int main(int, char**)
 {
   {
+#if TEST_STD_VER <= 14
     typedef std::hash<std::type_index> H;
     static_assert((std::is_same<typename H::argument_type, std::type_index>::value), "" );
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
+#endif
   }
 #if TEST_STD_VER >= 11
   {
     test_hash_enabled_for_type<std::type_index>(std::type_index(typeid(int)));
   }
 #endif
 
   return 0;
 }