diff --git a/libcxx/docs/ReleaseNotes.rst b/libcxx/docs/ReleaseNotes.rst
--- a/libcxx/docs/ReleaseNotes.rst
+++ b/libcxx/docs/ReleaseNotes.rst
@@ -89,6 +89,12 @@
 - ``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
 -----------
 
diff --git a/libcxx/docs/Status/Cxx17Papers.csv b/libcxx/docs/Status/Cxx17Papers.csv
--- a/libcxx/docs/Status/Cxx17Papers.csv
+++ b/libcxx/docs/Status/Cxx17Papers.csv
@@ -2,7 +2,7 @@
 "`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"
diff --git a/libcxx/include/__config b/libcxx/include/__config
--- a/libcxx/include/__config
+++ b/libcxx/include/__config
@@ -1220,6 +1220,7 @@
 #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)
@@ -1230,6 +1231,10 @@
 #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
diff --git a/libcxx/include/__functional/binary_function.h b/libcxx/include/__functional/binary_function.h
--- a/libcxx/include/__functional/binary_function.h
+++ b/libcxx/include/__functional/binary_function.h
@@ -16,10 +16,12 @@
 #  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;
@@ -28,4 +30,6 @@
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // _LIBCPP_STD_VER <= 14
+
 #endif // _LIBCPP___FUNCTIONAL_BINARY_FUNCTION_H
diff --git a/libcxx/include/__functional/binary_negate.h b/libcxx/include/__functional/binary_negate.h
--- a/libcxx/include/__functional/binary_negate.h
+++ b/libcxx/include/__functional/binary_negate.h
@@ -23,9 +23,11 @@
 
 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:
@@ -36,6 +38,10 @@
     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>
diff --git a/libcxx/include/__functional/binder1st.h b/libcxx/include/__functional/binder1st.h
--- a/libcxx/include/__functional/binder1st.h
+++ b/libcxx/include/__functional/binder1st.h
@@ -23,8 +23,10 @@
 
 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;
diff --git a/libcxx/include/__functional/binder2nd.h b/libcxx/include/__functional/binder2nd.h
--- a/libcxx/include/__functional/binder2nd.h
+++ b/libcxx/include/__functional/binder2nd.h
@@ -23,8 +23,10 @@
 
 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;
diff --git a/libcxx/include/__functional/function.h b/libcxx/include/__functional/function.h
--- a/libcxx/include/__functional/function.h
+++ b/libcxx/include/__functional/function.h
@@ -75,6 +75,7 @@
 namespace __function
 {
 
+#if _LIBCPP_STD_VER <= 17 || !defined(_LIBCPP_ABI_NO_BINDER_BASES)
 template<class _Rp>
 struct __maybe_derive_from_unary_function
 {
@@ -82,7 +83,7 @@
 
 template<class _Rp, class _A1>
 struct __maybe_derive_from_unary_function<_Rp(_A1)>
-    : public unary_function<_A1, _Rp>
+    : public __unary_function<_A1, _Rp>
 {
 };
 
@@ -93,9 +94,10 @@
 
 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
diff --git a/libcxx/include/__functional/mem_fn.h b/libcxx/include/__functional/mem_fn.h
--- a/libcxx/include/__functional/mem_fn.h
+++ b/libcxx/include/__functional/mem_fn.h
@@ -43,7 +43,11 @@
     // 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)...);
     }
diff --git a/libcxx/include/__functional/mem_fun_ref.h b/libcxx/include/__functional/mem_fun_ref.h
--- a/libcxx/include/__functional/mem_fun_ref.h
+++ b/libcxx/include/__functional/mem_fun_ref.h
@@ -24,7 +24,9 @@
 
 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:
@@ -36,7 +38,9 @@
 
 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:
@@ -60,7 +64,9 @@
 
 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:
@@ -72,7 +78,9 @@
 
 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:
@@ -96,7 +104,9 @@
 
 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:
@@ -108,7 +118,9 @@
 
 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:
@@ -132,7 +144,9 @@
 
 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:
@@ -144,7 +158,9 @@
 
 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:
diff --git a/libcxx/include/__functional/pointer_to_binary_function.h b/libcxx/include/__functional/pointer_to_binary_function.h
--- a/libcxx/include/__functional/pointer_to_binary_function.h
+++ b/libcxx/include/__functional/pointer_to_binary_function.h
@@ -23,7 +23,9 @@
 
 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:
diff --git a/libcxx/include/__functional/pointer_to_unary_function.h b/libcxx/include/__functional/pointer_to_unary_function.h
--- a/libcxx/include/__functional/pointer_to_unary_function.h
+++ b/libcxx/include/__functional/pointer_to_unary_function.h
@@ -23,7 +23,9 @@
 
 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:
diff --git a/libcxx/include/__functional/unary_function.h b/libcxx/include/__functional/unary_function.h
--- a/libcxx/include/__functional/unary_function.h
+++ b/libcxx/include/__functional/unary_function.h
@@ -15,10 +15,12 @@
 #  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;
@@ -26,4 +28,6 @@
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // _LIBCPP_STD_VER <= 14
+
 #endif // _LIBCPP___FUNCTIONAL_UNARY_FUNCTION_H
diff --git a/libcxx/include/__functional/unary_negate.h b/libcxx/include/__functional/unary_negate.h
--- a/libcxx/include/__functional/unary_negate.h
+++ b/libcxx/include/__functional/unary_negate.h
@@ -23,7 +23,9 @@
 
 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:
@@ -33,6 +35,9 @@
     _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>
diff --git a/libcxx/include/__functional/weak_result_type.h b/libcxx/include/__functional/weak_result_type.h
--- a/libcxx/include/__functional/weak_result_type.h
+++ b/libcxx/include/__functional/weak_result_type.h
@@ -34,6 +34,7 @@
 
 // __weak_result_type
 
+#ifndef _LIBCPP_ABI_NO_BINDER_BASES
 template <class _Tp>
 struct __derives_from_unary_function
 {
@@ -62,6 +63,14 @@
     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
@@ -127,45 +136,66 @@
 
 // 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>
 {
 };
 
@@ -173,43 +203,43 @@
 
 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>
 {
 };
 
diff --git a/libcxx/include/__memory/auto_ptr.h b/libcxx/include/__memory/auto_ptr.h
--- a/libcxx/include/__memory/auto_ptr.h
+++ b/libcxx/include/__memory/auto_ptr.h
@@ -16,6 +16,8 @@
 #  pragma GCC system_header
 #endif
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
@@ -77,4 +79,6 @@
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
+
 #endif // _LIBCPP___MEMORY_AUTO_PTR_H
diff --git a/libcxx/include/__memory/shared_ptr.h b/libcxx/include/__memory/shared_ptr.h
--- a/libcxx/include/__memory/shared_ptr.h
+++ b/libcxx/include/__memory/shared_ptr.h
@@ -20,6 +20,7 @@
 #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>
@@ -38,9 +39,6 @@
 #  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
diff --git a/libcxx/include/__memory/unique_ptr.h b/libcxx/include/__memory/unique_ptr.h
--- a/libcxx/include/__memory/unique_ptr.h
+++ b/libcxx/include/__memory/unique_ptr.h
@@ -14,16 +14,13 @@
 #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
diff --git a/libcxx/include/bitset b/libcxx/include/bitset
--- a/libcxx/include/bitset
+++ b/libcxx/include/bitset
@@ -1087,11 +1087,16 @@
 
 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>
diff --git a/libcxx/include/ext/__hash b/libcxx/include/ext/__hash
--- a/libcxx/include/ext/__hash
+++ b/libcxx/include/ext/__hash
@@ -22,7 +22,9 @@
 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
@@ -32,7 +34,9 @@
 };
 
 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
@@ -42,7 +46,9 @@
 };
 
 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
@@ -52,7 +58,9 @@
 };
 
 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
@@ -62,7 +70,9 @@
 };
 
 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
@@ -72,7 +82,9 @@
 };
 
 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
@@ -82,7 +94,9 @@
 };
 
 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
@@ -92,7 +106,9 @@
 };
 
 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
@@ -102,7 +118,9 @@
 };
 
 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
@@ -112,7 +130,9 @@
 };
 
 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
@@ -122,7 +142,9 @@
 };
 
 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
diff --git a/libcxx/include/map b/libcxx/include/map
--- a/libcxx/include/map
+++ b/libcxx/include/map
@@ -968,7 +968,7 @@
 
 _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
     {
@@ -1753,7 +1753,7 @@
 
 _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
     {
diff --git a/libcxx/include/memory b/libcxx/include/memory
--- a/libcxx/include/memory
+++ b/libcxx/include/memory
@@ -847,6 +847,7 @@
 #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>
@@ -880,10 +881,6 @@
 #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
diff --git a/libcxx/include/string b/libcxx/include/string
--- a/libcxx/include/string
+++ b/libcxx/include/string
@@ -4381,8 +4381,10 @@
 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
diff --git a/libcxx/include/string_view b/libcxx/include/string_view
--- a/libcxx/include/string_view
+++ b/libcxx/include/string_view
@@ -910,7 +910,9 @@
 // [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 {
diff --git a/libcxx/include/system_error b/libcxx/include/system_error
--- a/libcxx/include/system_error
+++ b/libcxx/include/system_error
@@ -435,7 +435,9 @@
 
 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
@@ -446,7 +448,9 @@
 
 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
diff --git a/libcxx/include/thread b/libcxx/include/thread
--- a/libcxx/include/thread
+++ b/libcxx/include/thread
@@ -198,7 +198,9 @@
 
 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
diff --git a/libcxx/include/typeindex b/libcxx/include/typeindex
--- a/libcxx/include/typeindex
+++ b/libcxx/include/typeindex
@@ -103,7 +103,9 @@
 
 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
diff --git a/libcxx/include/vector b/libcxx/include/vector
--- a/libcxx/include/vector
+++ b/libcxx/include/vector
@@ -3226,7 +3226,9 @@
 
 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
diff --git a/libcxx/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp b/libcxx/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
--- a/libcxx/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
+++ b/libcxx/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++03 || c++11 || c++14 || c++17
+// REQUIRES: c++03 || c++11 || c++14
 
 // <functional>
 
diff --git a/libcxx/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp b/libcxx/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
--- a/libcxx/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
+++ b/libcxx/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++03 || c++11 || c++14 || c++17
+// REQUIRES: c++03 || c++11 || c++14
 
 // <functional>
 
diff --git a/libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
@@ -29,8 +29,10 @@
     {
     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};
@@ -42,8 +44,10 @@
     {
     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));
diff --git a/libcxx/test/std/depr/depr.function.objects/depr.base/depr.verify.cpp b/libcxx/test/std/depr/depr.function.objects/depr.base/depr.verify.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/depr/depr.function.objects/depr.base/depr.verify.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+// 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}}
diff --git a/libcxx/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp b/libcxx/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
--- a/libcxx/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
+++ b/libcxx/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
@@ -26,8 +26,10 @@
 {
     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());
diff --git a/libcxx/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp b/libcxx/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
--- a/libcxx/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
+++ b/libcxx/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
@@ -10,7 +10,6 @@
 
 // template <class T>
 // struct hash
-//     : public unary_function<T, size_t>
 // {
 //     size_t operator()(T val) const;
 // };
@@ -26,8 +25,6 @@
 {
     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());
diff --git a/libcxx/test/std/strings/basic.string.hash/strings.pass.cpp b/libcxx/test/std/strings/basic.string.hash/strings.pass.cpp
--- a/libcxx/test/std/strings/basic.string.hash/strings.pass.cpp
+++ b/libcxx/test/std/strings/basic.string.hash/strings.pass.cpp
@@ -28,8 +28,10 @@
 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;
diff --git a/libcxx/test/std/strings/string.view/string.view.hash/string_view.pass.cpp b/libcxx/test/std/strings/string.view/string.view.hash/string_view.pass.cpp
--- a/libcxx/test/std/strings/string.view/string.view.hash/string_view.pass.cpp
+++ b/libcxx/test/std/strings/string.view/string.view.hash/string_view.pass.cpp
@@ -31,8 +31,10 @@
 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;
diff --git a/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp b/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
--- a/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
+++ b/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
@@ -29,8 +29,10 @@
     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));
diff --git a/libcxx/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp b/libcxx/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
--- a/libcxx/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
+++ b/libcxx/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
@@ -27,8 +27,10 @@
 {
     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;
diff --git a/libcxx/test/std/utilities/type.index/type.index.hash/hash.pass.cpp b/libcxx/test/std/utilities/type.index/type.index.hash/hash.pass.cpp
--- a/libcxx/test/std/utilities/type.index/type.index.hash/hash.pass.cpp
+++ b/libcxx/test/std/utilities/type.index/type.index.hash/hash.pass.cpp
@@ -28,8 +28,10 @@
 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());
diff --git a/libcxx/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp b/libcxx/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
--- a/libcxx/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
+++ b/libcxx/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
@@ -27,9 +27,11 @@
 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
   {