[libc++][memory] P1132R8: out_ptr - a scalable output pointer abstraction

[H-G-Hristov]

Summary

Implements: P1132R8 - 20.3.4 Smart pointer adaptors

[H-G-Hristov]

Try to fix CI

[H-G-Hristov]

Try to fix CI

[H-G-Hristov]

Try to fix CI

[H-G-Hristov]

Try to fix CI

[H-G-Hristov]

Rebased + Try to fix CI

[philnik]

libcxx/include/__memory/inout_ptr.h

34

Maybe also static_assert Cpp17NullablePointer?

38–41

AFAICT this should be if constexpr (is_pointer_v<_Smart>). Why do you check whether s.get() is valid?

62

This shouldn't use curly braces. Otherwise an implicit conversion is impossible. regression test!

71

Same here.

95–99

libcxx/include/__memory/out_ptr.h

32–34

38

Looks like you're not value-initializing __p_.

42

Isn't the assertion a bit redundant?

64

This isn't ill-formed in the else case!

85–89

libcxx/include/__memory/pointer_traits.h

270

Why is this implemented completely differently from the standard wording?

libcxx/test/std/utilities/smartptr/adapt/inout.ptr/inout.ptr.compile.fail.cpp

1

This should be a .verify.cpp.

[H-G-Hristov]

@philnik Thank you very much for the review. I wanted to submit this as a draft to test it against the CI but by mistake I made it public.
I very much appreciate the feedback I'll try to find time to address the comments and add more tests soon.

[Mordante]

I've not looked at the patch, since changes are planed. I noticed a file that should not be modified.

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

568

This file is automatically updated by a bot after updating this file.

[H-G-Hristov]

Addressed some comments

[H-G-Hristov]

WIP: Test CI

[H-G-Hristov]

Addressed comments

[H-G-Hristov]

@philnik I resolved most of the comments. I think the patch is ready for another round of reviews.

I believe named requirements need to be implemented as concepts. I am not convinced that my first iteration of Cpp17NullablePointer is entirely correct, so I hope for feedback.
The concepts and other type traits stuff which were added, should probably be refactored and moved to other locations too. In this or in another (follow-up) patch. Please suggest.

Thank you for the initial review.

libcxx/include/__memory/inout_ptr.h

62

Curly braces fixed, there is no test yet.
TODO: Test

libcxx/include/__memory/out_ptr.h

64

Added a static_assert in the else path. I hope that's the correct approach.

[H-G-Hristov]

libcxx/include/__iterator/cpp17_iterator_concepts.h

77 ↗

(On Diff #535490)

This concept and the other above should probably be moved to another location?

libcxx/include/__memory/allocator_traits.h

38 ↗

(On Diff #535490)

Should this be renamed and moved to a more central location so it can be reused?

[H-G-Hristov]

Rebased

[H-G-Hristov]

Re-run CI

[H-G-Hristov]

gentle ping....

The CI error seems unrelated and appeared after the rebase.

Shall we continue with the review here or should I move this to GitHub. I am not entirely sure if I can move one patch or I need to move all of them.

[H-G-Hristov]

Rebased + removed NullablePointer concept

[H-G-Hristov]

Rebased

[H-G-Hristov]

Rebased

[H-G-Hristov]

libcxx/include/__memory/inout_ptr.h

34

I made an attempt to implement this requirement but I don't think it was anywhere near correct, so I removed it from this revision. I'd be glad for some advice with this.

[H-G-Hristov]

This needs to be implemented:
LWG-3897: inout_ptr will not update raw pointer to 0
https://cplusplus.github.io/LWG/issue3897

[ldionne]

This is now https://github.com/llvm/llvm-project/pull/73618

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_is_scoped_enum``                      ``202011L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_mdspan``                              *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_move_only_function``                  *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_optional``                            ``202110L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_out_ptr``                             *unimplemented*
+    ``__cpp_lib_out_ptr``                             ``202106L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_as_rvalue``                    ``202207L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk``                        *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk_by``                     *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_iota``                         *unimplemented*

libcxx/docs/Status/Cxx23Issues.csv

 "`3724 <https://wg21.link/LWG3724>`__","``decay-copy`` should be constrained","July 2022","|Complete|","14.0"
 "","","","","",""
 "`3028 <https://wg21.link/LWG3028>`__","Container requirements tables should distinguish ``const`` and non-``const`` variables", "November 2022","","",""
 "`3118 <https://wg21.link/LWG3118>`__","``fpos`` equality comparison unspecified", "November 2022","","",""
 "`3177 <https://wg21.link/LWG3177>`__","Limit permission to specialize variable templates to program-defined types", "November 2022","|Nothing to do|","",""
 "`3515 <https://wg21.link/LWG3515>`__","§[stacktrace.basic.nonmem]: ``operator<<`` should be less templatized", "November 2022","","",""
 "`3545 <https://wg21.link/LWG3545>`__","``std::pointer_traits`` should be SFINAE-friendly", "November 2022","","",""
 "`3569 <https://wg21.link/LWG3569>`__","``join_view`` fails to support ranges of ranges with non-default_initializable iterators", "November 2022","","","|ranges|"
-"`3594 <https://wg21.link/LWG3594>`__","``inout_ptr`` — inconsistent ``release()`` in destructor", "November 2022","","",""
+"`3594 <https://wg21.link/LWG3594>`__","``inout_ptr`` — inconsistent ``release()`` in destructor", "November 2022","|Complete|","17.0",""
 "`3597 <https://wg21.link/LWG3597>`__","Unsigned integer types don't model advanceable", "November 2022","","","|ranges|"
 "`3600 <https://wg21.link/LWG3600>`__","Making ``istream_iterator`` copy constructor trivial is an ABI break", "November 2022","","",""
 "`3629 <https://wg21.link/LWG3629>`__","``make_error_code`` and ``make_error_condition`` are customization points","November 2022","|Complete|","16.0",""
 "`3636 <https://wg21.link/LWG3636>`__","``formatter<T>::format`` should be ``const``-qualified","November 2022","|Complete|","16.0","|format|"
 "`3646 <https://wg21.link/LWG3646>`__","``std::ranges::view_interface::size`` returns a signed type","November 2022","|Complete|","16.0","|ranges|"
 "`3677 <https://wg21.link/LWG3677>`__","Is a cv-qualified ``pair`` specially handled in uses-allocator construction?", "November 2022","","",""
 "`3717 <https://wg21.link/LWG3717>`__","``common_view::end`` should improve ``random_access_range`` case", "November 2022","","","|ranges|"
 "`3732 <https://wg21.link/LWG3732>`__","``prepend_range`` and ``append_range`` can't be amortized constant time", "November 2022","|Nothing to do|","","|ranges|"

 "`3866 <https://wg21.link/LWG3866>`__","Bad Mandates for ``expected::transform_error`` overloads","February 2023","|Complete|","17.0",""
 "`3867 <https://wg21.link/LWG3867>`__","Should ``std::basic_osyncstream``'s move assignment operator be ``noexcept``?","February 2023","","",""
 "`3441 <https://wg21.link/LWG3441>`__","Misleading note about calls to customization points","February 2023","","",""
 "`3622 <https://wg21.link/LWG3622>`__","Misspecified transitivity of equivalence in §[unord.req.general]","February 2023","","",""
 "`3631 <https://wg21.link/LWG3631>`__","``basic_format_arg(T&&)`` should use ``remove_cvref_t<T>`` throughout","February 2023","|Complete|","15.0",""
 "`3645 <https://wg21.link/LWG3645>`__","``resize_and_overwrite`` is overspecified to call its callback with lvalues","February 2023","|Complete|","14.0",""
 "`3655 <https://wg21.link/LWG3655>`__","The ``INVOKE`` operation and union types","February 2023","","",""
 "`3723 <https://wg21.link/LWG3723>`__","``priority_queue::push_range`` needs to ``append_range``","February 2023","","","|ranges|"
-"`3734 <https://wg21.link/LWG3734>`__","Inconsistency in ``inout_ptr`` and ``out_ptr`` for empty case","February 2023","","",""
+"`3734 <https://wg21.link/LWG3734>`__","Inconsistency in ``inout_ptr`` and ``out_ptr`` for empty case","February 2023","|Complete|","17.0",""
 "`3772 <https://wg21.link/LWG3772>`__","``repeat_view``'s ``piecewise`` constructor is missing Postconditions","February 2023","","","|ranges|"
 "`3786 <https://wg21.link/LWG3786>`__","Flat maps' deduction guide needs to default ``Allocator`` to be useful","February 2023","","",""
 "`3803 <https://wg21.link/LWG3803>`__","``flat_foo`` constructors taking ``KeyContainer`` lack ``KeyCompare`` parameter","February 2023","","",""
 "`3810 <https://wg21.link/LWG3810>`__","CTAD for ``std::basic_format_args``","February 2023","|Complete|","17.0","|format|"
 "`3827 <https://wg21.link/LWG3827>`__","Deprecate ``<stdalign.h>`` and ``<stdbool.h>`` macros","February 2023","","",""
 "`3828 <https://wg21.link/LWG3828>`__","Sync ``intmax_t`` and ``uintmax_t`` with C2x","February 2023","","",""
 "`3833 <https://wg21.link/LWG3833>`__","Remove specialization ``template<size_t N> struct formatter<const charT[N], charT>``","February 2023","|Complete|","17.0","|format|"
 "`3836 <https://wg21.link/LWG3836>`__","``std::expected<bool, E1>`` conversion constructor ``expected(const expected<U, G>&)`` should take precedence over ``expected(U&&)`` with operator ``bool``","February 2023","","",""

libcxx/docs/Status/Cxx23Papers.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version","Labels"
 "`P0881R7 <https://wg21.link/P0881R7>`__","LWG","A Proposal to add stacktrace library","Autumn 2020","",""
 "`P0943R6 <https://wg21.link/P0943R6>`__","LWG","Support C atomics in C++","Autumn 2020","|Complete|","15.0"
 "`P1048R1 <https://wg21.link/P1048R1>`__","LWG","A proposal for a type trait to detect scoped enumerations","Autumn 2020","|Complete|","12.0"
 "`P1679R3 <https://wg21.link/P1679R3>`__","LWG","string contains function","Autumn 2020","|Complete|","12.0"
 "","","","","","",""
 "`P1682R3 <https://wg21.link/P1682R3>`__","LWG","std::to_underlying for enumerations","February 2021","|Complete|","13.0"
 "`P2017R1 <https://wg21.link/P2017R1>`__","LWG","Conditionally borrowed ranges","February 2021","","","|ranges|"
 "`P2160R1 <https://wg21.link/P2160R1>`__","LWG","Locks lock lockables","February 2021","",""
 "`P2162R2 <https://wg21.link/P2162R2>`__","LWG","Inheriting from std::variant","February 2021","|Complete|","13.0"
 "`P2212R2 <https://wg21.link/P2212R2>`__","LWG","Relax Requirements for time_point::clock","February 2021","",""
 "`P2259R1 <https://wg21.link/P2259R1>`__","LWG","Repairing input range adaptors and counted_iterator","February 2021","","","|ranges|"
 "","","","","","",""
 "`P0401R6 <https://wg21.link/P0401R6>`__","LWG","Providing size feedback in the Allocator interface","June 2021","|Complete|","15.0"
 "`P0448R4 <https://wg21.link/P0448R4>`__","LWG","A strstream replacement using span<charT> as buffer","June 2021","",""
-"`P1132R8 <https://wg21.link/P1132R8>`__","LWG","out_ptr - a scalable output pointer abstraction","June 2021","",""
+"`P1132R8 <https://wg21.link/P1132R8>`__","LWG","out_ptr - a scalable output pointer abstraction","June 2021","|Complete|","17.0"
 "`P1328R1 <https://wg21.link/P1328R1>`__","LWG","Making std::type_info::operator== constexpr","June 2021","|Complete|","17.0"
 "`P1425R4 <https://wg21.link/P1425R4>`__","LWG","Iterators pair constructors for stack and queue","June 2021","|Complete|","14.0","|ranges|"
 "`P1518R2 <https://wg21.link/P1518R2>`__","LWG","Stop overconstraining allocators in container deduction guides","June 2021","|Complete|","13.0"
 "`P1659R3 <https://wg21.link/P1659R3>`__","LWG","starts_with and ends_with","June 2021","","","|ranges|"
 "`P1951R1 <https://wg21.link/P1951R1>`__","LWG","Default Arguments for pair Forwarding Constructor","June 2021","|Complete|","14.0"
 "`P1989R2 <https://wg21.link/P1989R2>`__","LWG","Range constructor for std::string_view","June 2021","|Complete|","14.0","|ranges|"
 "`P2136R3 <https://wg21.link/P2136R3>`__","LWG","invoke_r","June 2021","|Complete|","17.0"
 "`P2166R1 <https://wg21.link/P2166R1>`__","LWG","A Proposal to Prohibit std::basic_string and std::basic_string_view construction from nullptr","June 2021","|Complete|","13.0"

libcxx/include/CMakeLists.txt

set(files
   __memory/allocator_traits.h
   __memory/assume_aligned.h
   __memory/auto_ptr.h
   __memory/builtin_new_allocator.h
   __memory/compressed_pair.h
   __memory/concepts.h
   __memory/construct_at.h
   __memory/destruct_n.h
+  __memory/inout_ptr.h
+  __memory/out_ptr.h
   __memory/pointer_traits.h
   __memory/ranges_construct_at.h
   __memory/ranges_uninitialized_algorithms.h
   __memory/raw_storage_iterator.h
   __memory/shared_ptr.h
   __memory/swap_allocator.h
   __memory/temp_value.h
   __memory/temporary_buffer.h

libcxx/include/__memory/inout_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___INOUT_PTR_H
+#define _LIBCPP___INOUT_PTR_H
+
+#include <__config>
+#include <__memory/addressof.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_specialization.h>
+#include <__type_traits/is_void.h>
+#include <tuple>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Smart, class _Pointer, class... _Args>
+class _LIBCPP_TEMPLATE_VIS inout_ptr_t {
+  static_assert(!__is_specialization_v<_Smart, shared_ptr>, "std::shared_ptr<> is not supported");
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit inout_ptr_t(_Smart& __s, _Args... __args)
+      : __s_{__s}, __a_{std::forward<_Args>(__args)...}, __p_{[&__s] {
+          if constexpr (requires { __s.get(); }) {
+            return __s.get();
+          } else {
+            return __s;
+          }
+        }()} {
+    if constexpr (requires { __s.release(); }) {
+      __s.release();
+    } else {
+      __s = _Smart();
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI inout_ptr_t(const inout_ptr_t&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI ~inout_ptr_t() {
+    if (!__p_) {
+      return;
+    }
+
+    using _SP = __pointer_of_or_t<_Smart, _Pointer>;
+    if constexpr (is_pointer_v<_Smart>) {
+      std::apply(
+          [&](auto&&... __args) {
+            __s_ = _Smart{static_cast<_SP>(__p_), std::forward<_Args>(__args)...};
+          },
+          std::move(__a_));
+    } else if constexpr (__resettable_pointer<_Smart, _Pointer, _Args...>) {
+      std::apply([&](auto&&... __args) { __s_.reset(static_cast<_SP>(__p_), std::forward<_Args>(__args)...); },
+                 std::move(__a_));
+    } else if constexpr (is_constructible_v<_Smart, _SP, _Args...>) {
+      std::apply(
+          [&](auto&&... __args) {
+            __s_ = _Smart{static_cast<_SP>(__p_), std::forward<_Args>(__args)...};
+          },
+          std::move(__a_));
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI operator _Pointer*() const noexcept { return std::addressof(const_cast<_Pointer&>(__p_)); }
+
+  _LIBCPP_HIDE_FROM_ABI operator void**() const noexcept
+    requires(!is_same_v<_Pointer, void*>)
+  {
+    static_assert(is_pointer_v<_Pointer>);
+
+    return reinterpret_cast<void**>(static_cast<_Pointer*>(*this));
+  }
+
+private:
+  _Smart& __s_;
+  tuple<_Args...> __a_;
+  _Pointer __p_;
+};
+
+template <class _Pointer = void, class _Smart, class... _Args>
+_LIBCPP_HIDE_FROM_ABI auto inout_ptr(_Smart& __s, _Args&&... __args) {
+  if constexpr (!is_void_v<_Pointer>) {
+    return std::inout_ptr_t<_Smart, _Pointer, _Args&&...>{__s, std::forward<_Args>(__args)...};
+  } else {
+    return std::inout_ptr_t<_Smart, std::__pointer_of_t<_Smart>, _Args&&...>{__s, std::forward<_Args>(__args)...};
+  }
+}
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___INOUT_PTR_H

libcxx/include/__memory/out_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___OUT_PTR_H
+#define _LIBCPP___OUT_PTR_H
+
+#include <__config>
+#include <__memory/addressof.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
+#include <__type_traits/is_specialization.h>
+#include <__type_traits/is_void.h>
+#include <tuple>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Smart, class _Pointer, class... _Args>
+class _LIBCPP_TEMPLATE_VIS out_ptr_t {
+  static_assert(!__is_specialization_v<_Smart, shared_ptr> ||
+                    (__is_specialization_v<_Smart, shared_ptr> && sizeof...(_Args) > 0),
+                "Specialization of std::shared_ptr<> requires a deleter.");
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit out_ptr_t(_Smart& __s, _Args... __args)
+      : __s_{__s}, __a_{std::forward<_Args>(__args)...} {
+    if constexpr (requires { __s.reset(); }) {
+      __s_.reset();
+    } else {
+      static_assert(is_constructible_v<_Smart>);
+      __s_ = _Smart{};
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI out_ptr_t(const out_ptr_t&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI ~out_ptr_t() {
+    if (!__p_) {
+      return;
+    }
+
+    using _SP = __pointer_of_or_t<_Smart, _Pointer>;
+    if constexpr (__resettable_pointer<_Smart, _Pointer, _Args...>) {
+      std::apply([&](auto&&... __args) { __s_.reset(static_cast<_SP>(__p_), std::forward<_Args>(__args)...); },
+                 std::move(__a_));
+    } else if constexpr (is_constructible_v<_Smart, _SP, _Args...>) {
+      std::apply(
+          [&](auto&&... __args) {
+            __s_ = _Smart{static_cast<_SP>(__p_), std::forward<_Args>(__args)...};
+          },
+          std::move(__a_));
+    };
+  }
+
+  _LIBCPP_HIDE_FROM_ABI operator _Pointer*() const noexcept { return std::addressof(const_cast<_Pointer&>(__p_)); }
+
+  _LIBCPP_HIDE_FROM_ABI operator void**() const noexcept
+    requires(!is_same_v<_Pointer, void*>)
+  {
+    static_assert(is_pointer_v<_Pointer>);
+
+    return reinterpret_cast<void**>(static_cast<_Pointer*>(*this));
+  }
+
+private:
+  _Smart& __s_;
+  tuple<_Args...> __a_;
+  _Pointer __p_;
+};
+
+template <class _Pointer = void, class _Smart, class... _Args>
+_LIBCPP_HIDE_FROM_ABI auto out_ptr(_Smart& __s, _Args&&... __args) {
+  if constexpr (!is_void_v<_Pointer>) {
+    return std::out_ptr_t<_Smart, _Pointer, _Args&&...>(__s, std::forward<_Args>(__args)...);
+  } else {
+    return std::out_ptr_t<_Smart, std::__pointer_of_t<_Smart>, _Args&&...>(__s, std::forward<_Args>(__args)...);
+  }
+}
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___OUT_PTR_H

libcxx/include/__memory/pointer_traits.h

 #include <__type_traits/conditional.h>
 #include <__type_traits/conjunction.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_class.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
+#include <__utility/forward.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

 
 template <class _Pointer>
 inline _LIBCPP_INLINE_VISIBILITY constexpr
 auto to_address(const _Pointer& __p) noexcept -> decltype(std::__to_address(__p)) {
     return _VSTD::__to_address(__p);
 }
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Tp, class _Up>
+struct __pointer_of_or {};
+
+template <class _Tp, class _Up>
+  requires requires { typename __pointer_traits_element_type<_Tp>::element_type; }
+struct __pointer_of_or<_Tp, _Up> {
+    using type _LIBCPP_NODEBUG = _Tp;
+};
+
+template <class _Tp, class _Up>
+  requires(!requires { typename __pointer_traits_element_type<_Tp>::element_type; })
+struct __pointer_of_or<_Tp, _Up> {
+    using type _LIBCPP_NODEBUG = _Up;
+};
+
+template <typename _Tp, typename _Up>
+using __pointer_of_or_t = typename __pointer_of_or<_Tp, _Up>::type;
+
+template <typename _Tp>
+using __pointer_of = __pointer_of_or<_Tp, typename std::pointer_traits<_Tp>::element_type*>;
+
+template <typename _Tp>
+using __pointer_of_t = typename __pointer_of<_Tp>::type;
+
+template <class _Smart, class _Pointer, class... _Args>
+concept __resettable_pointer = requires(_Smart __s, _Pointer __p, _Args... __args) {
+  __s.reset(static_cast<__pointer_of_or_t<_Smart, _Pointer>>(__p), std::forward<_Args>(__args)...);
+};
+
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_POINTER_TRAITS_H

libcxx/include/memory

template <class T, class Alloc>
   inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
 
 // [ptr.align]
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 
 template<size_t N, class T>
 [[nodiscard]] constexpr T* assume_aligned(T* ptr); // since C++20
 
+// [out.ptr.t], class template out_ptr_t
+template<class Smart, class Pointer, class... Args>
+  class out_ptr_t;                                          // since c++23
+
+// [out.ptr], function template out_ptr
+template<class Pointer = void, class Smart, class... Args>
+  auto out_ptr(Smart& s, Args&&... args);                   // since c++23
+
+// [inout.ptr.t], class template inout_ptr_t
+template<class Smart, class Pointer, class... Args>
+  class inout_ptr_t;                                        // since c++23
+
+// [inout.ptr], function template inout_ptr
+template<class Pointer = void, class Smart, class... Args>
+  auto inout_ptr(Smart& s, Args&&... args);                 // since c++23
+
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/align.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/inout_ptr.h>
+#include <__memory/out_ptr.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>
 #include <__memory/temporary_buffer.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>

libcxx/include/module.modulemap.in

module __memory {
       module builtin_new_allocator           { private header "__memory/builtin_new_allocator.h" }
       module compressed_pair                 { private header "__memory/compressed_pair.h" }
       module concepts                        {
         private header "__memory/concepts.h"
         export type_traits.remove_reference
       }
       module construct_at                    { private header "__memory/construct_at.h" }
       module destruct_n                      { private header "__memory/destruct_n.h" }
+      module inout_ptr                       { private header "__memory/inout_ptr.h" }
+      module out_ptr                         { private header "__memory/out_ptr.h" }
       module pointer_traits                  { private header "__memory/pointer_traits.h" }
       module ranges_construct_at             { private header "__memory/ranges_construct_at.h" }
       module ranges_uninitialized_algorithms {
         private header "__memory/ranges_uninitialized_algorithms.h"
         export algorithm.__algorithm.in_out_result
       }
       module raw_storage_iterator            { private header "__memory/raw_storage_iterator.h" }
       module shared_ptr                      { private header "__memory/shared_ptr.h" }

libcxx/include/version

 // # define __cpp_lib_formatters                           202302L
 # define __cpp_lib_forward_like                         202207L
 # define __cpp_lib_invoke_r                             202106L
 # define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_mdspan                               202207L
 // # define __cpp_lib_move_only_function                   202110L
 # undef  __cpp_lib_optional
 # define __cpp_lib_optional                             202110L
-// # define __cpp_lib_out_ptr                              202106L
+# define __cpp_lib_out_ptr                              202106L
 # define __cpp_lib_ranges_as_rvalue                     202207L
 // # define __cpp_lib_ranges_chunk                         202202L
 // # define __cpp_lib_ranges_chunk_by                      202202L
 // # define __cpp_lib_ranges_iota                          202202L
 // # define __cpp_lib_ranges_join_with                     202202L
 // # define __cpp_lib_ranges_slide                         202202L
 // # define __cpp_lib_ranges_starts_ends_with              202106L
 // # define __cpp_lib_ranges_to_container                  202202L

libcxx/test/std/language.support/support.limits/support.limits.general/memory.version.compile.pass.cpp

 
 # ifndef __cpp_lib_make_unique
 #   error "__cpp_lib_make_unique should be defined in c++23"
 # endif
 # if __cpp_lib_make_unique != 201304L
 #   error "__cpp_lib_make_unique should have the value 201304L in c++23"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_out_ptr
-#     error "__cpp_lib_out_ptr should be defined in c++23"
-#   endif
-#   if __cpp_lib_out_ptr != 202106L
-#     error "__cpp_lib_out_ptr should have the value 202106L in c++23"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_out_ptr
-#     error "__cpp_lib_out_ptr should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_out_ptr
+#   error "__cpp_lib_out_ptr should be defined in c++23"
+# endif
+# if __cpp_lib_out_ptr != 202106L
+#   error "__cpp_lib_out_ptr should have the value 202106L in c++23"
+# endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
 # if __cpp_lib_ranges != 202106L
 #   error "__cpp_lib_ranges should have the value 202106L in c++23"
 # endif
 

 
 # ifndef __cpp_lib_make_unique
 #   error "__cpp_lib_make_unique should be defined in c++26"
 # endif
 # if __cpp_lib_make_unique != 201304L
 #   error "__cpp_lib_make_unique should have the value 201304L in c++26"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_out_ptr
-#     error "__cpp_lib_out_ptr should be defined in c++26"
-#   endif
-#   if __cpp_lib_out_ptr != 202106L
-#     error "__cpp_lib_out_ptr should have the value 202106L in c++26"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_out_ptr
-#     error "__cpp_lib_out_ptr should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_out_ptr
+#   error "__cpp_lib_out_ptr should be defined in c++26"
+# endif
+# if __cpp_lib_out_ptr != 202106L
+#   error "__cpp_lib_out_ptr should have the value 202106L in c++26"
+# endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
 # if __cpp_lib_ranges != 202106L
 #   error "__cpp_lib_ranges should have the value 202106L in c++26"
 # endif
 

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

 
 # ifndef __cpp_lib_optional
 #   error "__cpp_lib_optional should be defined in c++23"
 # endif
 # if __cpp_lib_optional != 202110L
 #   error "__cpp_lib_optional should have the value 202110L in c++23"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_out_ptr
-#     error "__cpp_lib_out_ptr should be defined in c++23"
-#   endif
-#   if __cpp_lib_out_ptr != 202106L
-#     error "__cpp_lib_out_ptr should have the value 202106L in c++23"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_out_ptr
-#     error "__cpp_lib_out_ptr should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_out_ptr
+#   error "__cpp_lib_out_ptr should be defined in c++23"
+# endif
+# if __cpp_lib_out_ptr != 202106L
+#   error "__cpp_lib_out_ptr should have the value 202106L in c++23"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should be defined in c++23"
 #   endif
 #   if __cpp_lib_parallel_algorithm != 201603L
 #     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++23"
 #   endif

 
 # ifndef __cpp_lib_optional
 #   error "__cpp_lib_optional should be defined in c++26"
 # endif
 # if __cpp_lib_optional != 202110L
 #   error "__cpp_lib_optional should have the value 202110L in c++26"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_out_ptr
-#     error "__cpp_lib_out_ptr should be defined in c++26"
-#   endif
-#   if __cpp_lib_out_ptr != 202106L
-#     error "__cpp_lib_out_ptr should have the value 202106L in c++26"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_out_ptr
-#     error "__cpp_lib_out_ptr should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_out_ptr
+#   error "__cpp_lib_out_ptr should be defined in c++26"
+# endif
+# if __cpp_lib_out_ptr != 202106L
+#   error "__cpp_lib_out_ptr should have the value 202106L in c++26"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should be defined in c++26"
 #   endif
 #   if __cpp_lib_parallel_algorithm != 201603L
 #     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++26"
 #   endif

libcxx/test/std/utilities/smartptr/adapt/inout.ptr/inout.ptr.compile.fail.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <memory>
+
+// [inout.ptr], function template inout_ptr
+// template<class Pointer = void, class Smart, class... Args>
+//   auto inout_ptr(Smart& s, Args&&... args);                 // since c++23
+
+#include <memory>
+
+int main(int, char**) {
+  // `std::inout_ptr<>` does not support `std::shared_ptr<>`.
+  {
+    std::shared_ptr<int> sPtr;
+
+    auto inoutUPtr1 = std::inout_ptr(sPtr);
+    auto inoutUPtr2 = std::inout_ptr<int*>(sPtr);
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/smartptr/adapt/inout.ptr/inout.ptr.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <memory>
+
+// [inout.ptr], function template inout_ptr
+// template<class Pointer = void, class Smart, class... Args>
+//   auto inout_ptr(Smart& s, Args&&... args);                 // since c++23
+
+#include <memory>
+
+int main(int, char**) {
+  {
+    std::unique_ptr<int> uPtr;
+
+    auto inoutUPtr1 = std::inout_ptr(uPtr);
+    auto inoutUPtr2 = std::inout_ptr<int*>(uPtr);
+  }
+  {
+    std::unique_ptr<int> uPtr;
+
+    auto inoutUPtr1 = std::inout_ptr(uPtr, [](auto* p) { delete p; });
+    auto inoutUPtr2 = std::inout_ptr<int*>(uPtr, [](auto* p) { delete p; });
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/smartptr/adapt/inout.ptr/inout.ptr.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <memory>
+
+// [inout.ptr.t], class template inout_ptr_t
+// template<class Smart, class Pointer, class... Args>
+//   class inout_ptr_t;                                        // since c++23
+
+// [inout.ptr], function template inout_ptr
+// template<class Pointer = void, class Smart, class... Args>
+//   auto inout_ptr(Smart& s, Args&&... args);                 // since c++23
+
+#include <cassert>
+#include <memory>
+
+#include "../types.h"
+
+// Test helpers.
+
+void replace_int_p(int** pp) {
+  assert(**pp == 90);
+  delete *pp;
+  *pp = new int{84};
+}
+
+void replace_int_p_with_nullptr(int** pp) {
+  assert(**pp == 90);
+  delete *pp;
+  *pp = nullptr;
+}
+
+void replace_nullptr_with_int_p(int** pp) {
+  assert(*pp == nullptr);
+  *pp = new int{84};
+}
+
+void replace_int_void_p(void** pp) {
+  assert(*(static_cast<int*>(*pp)) == 90);
+  delete static_cast<int*>(*pp);
+  *pp = new int{84};
+}
+
+void replace_int_void_p_with_nullptr(void** pp) {
+  assert(*(static_cast<int*>(*pp)) == 90);
+  delete static_cast<int*>(*pp);
+  *pp = nullptr;
+}
+
+void replace_nullptr_with_int_void_p(void** pp) {
+  assert(*pp == nullptr);
+  *pp = new int{84};
+}
+
+void replace_SomeInt_p(SomeInt** pp) {
+  auto si = **pp;
+  assert(si.value == 90);
+  delete static_cast<SomeInt*>(*pp);
+  *pp = new SomeInt{9084};
+}
+
+void replace_SomeInt_void_p(void** pp) {
+  assert(reinterpret_cast<SomeInt*>(*pp)->value == 90);
+  delete static_cast<SomeInt*>(*pp);
+  *pp = reinterpret_cast<void*>(new SomeInt{9084});
+}
+
+// Test `std::inout_ptr()` function.
+
+bool test_raw_ptr() {
+  {
+    auto rPtr = new int{90};
+
+    replace_int_p(std::inout_ptr<int*>(rPtr));
+    assert(*rPtr == 84);
+
+    delete rPtr;
+  }
+  {
+    auto rPtr = new int{90};
+
+    replace_int_p_with_nullptr(std::inout_ptr<int*>(rPtr));
+    assert(rPtr == nullptr);
+  }
+  {
+    int* rPtr = nullptr;
+
+    replace_nullptr_with_int_p(std::inout_ptr<int*>(rPtr));
+    assert(*rPtr == 84);
+    delete rPtr;
+  }
+  {
+    auto rPtr = new int{90};
+
+    replace_int_void_p(std::inout_ptr<int*>(rPtr));
+    assert(*rPtr == 84);
+    delete rPtr;
+  }
+  {
+    auto rPtr = new int{90};
+
+    replace_int_void_p_with_nullptr(std::inout_ptr<int*>(rPtr));
+    assert(rPtr == nullptr);
+  }
+  {
+    int* rPtr = nullptr;
+
+    replace_nullptr_with_int_void_p(std::inout_ptr<int*>(rPtr));
+    assert(*rPtr == 84);
+    delete rPtr;
+  }
+  {
+    auto* rPtr = new SomeInt{90};
+
+    replace_SomeInt_p(std::inout_ptr(rPtr));
+    assert(rPtr->value == 9084);
+    delete rPtr;
+  }
+  {
+    auto* rPtr = new SomeInt{90};
+
+    replace_SomeInt_void_p(std::inout_ptr<SomeInt*>(rPtr));
+    assert(rPtr->value == 9084);
+    delete rPtr;
+  }
+
+  return true;
+}
+
+bool test_unique_ptr() {
+  {
+    auto uPtr = std::make_unique<int>(90);
+
+    replace_int_p(std::inout_ptr(uPtr));
+    assert(*uPtr == 84);
+  }
+  {
+    std::unique_ptr<int> uPtr;
+
+    replace_nullptr_with_int_p(std::inout_ptr(uPtr));
+    assert(*uPtr == 84);
+  }
+  {
+    auto uPtr = std::make_unique<int>(90);
+
+    replace_int_void_p(std::inout_ptr(uPtr));
+    assert(*uPtr == 84);
+  }
+  {
+    std::unique_ptr<int> uPtr;
+
+    replace_nullptr_with_int_void_p(std::inout_ptr(uPtr));
+    assert(*uPtr == 84);
+  }
+  {
+    auto uPtr = std::make_unique<SomeInt>(90);
+
+    replace_SomeInt_p(std::inout_ptr(uPtr));
+    assert(uPtr->value == 9084);
+  }
+  {
+    auto uPtr = std::make_unique<SomeInt>(90);
+
+    replace_SomeInt_void_p(std::inout_ptr<SomeInt*>(uPtr));
+    assert(uPtr->value == 9084);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test_raw_ptr());
+  assert(test_unique_ptr());
+
+  return 0;
+}

libcxx/test/std/utilities/smartptr/adapt/inout.ptr/inout.ptr.t.compile.fail.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <memory>
+
+// [inout.ptr.t], class template inout_ptr_t
+// template<class Smart, class Pointer, class... Args>
+//   class inout_ptr_t;                                        // since c++23
+
+#include <memory>
+
+int main(int, char**) {
+  // `std::inout_ptr<>` does not support `std::shared_ptr<>`.
+  {
+    std::shared_ptr<int> sPtr;
+
+    std::inout_ptr_t<std::shared_ptr<int>, int*>{sPtr};
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/smartptr/adapt/inout.ptr/inout.ptr.t.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <memory>
+
+// [inout.ptr.t], class template inout_ptr_t
+// template<class Smart, class Pointer, class... Args>
+//   class inout_ptr_t;                                        // since c++23
+
+#include <memory>
+
+int main(int, char**) {
+  {
+    std::unique_ptr<int> uPtr;
+
+    std::inout_ptr_t<std::unique_ptr<int>, int*>{uPtr};
+  }
+  {
+    std::unique_ptr<int> uPtr;
+
+    std::inout_ptr_t<std::unique_ptr<int>, int*>{uPtr};
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/smartptr/adapt/out.ptr/out.ptr.compile.fail.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <memory>
+
+// [out.ptr], function template out_ptr
+// template<class Pointer = void, class Smart, class... Args>
+//   auto out_ptr(Smart& s, Args&&... args);                   // since c++23
+
+#include <memory>
+
+int main(int, char**) {
+  // `std::out_ptr<>` requires `std::shared_ptr<>` with a deleter.
+  {
+    std::shared_ptr<int> sPtr;
+
+    auto outSPtr1 = std::out_ptr(sPtr);
+    auto outSPtr2 = std::out_ptr<int*>(sPtr);
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/smartptr/adapt/out.ptr/out.ptr.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <memory>
+
+// [out.ptr], function template out_ptr
+// template<class Pointer = void, class Smart, class... Args>
+//   auto out_ptr(Smart& s, Args&&... args);                   // since c++23
+
+#include <memory>
+
+int main(int, char**) {
+  {
+    std::unique_ptr<int> uPtr;
+
+    auto outUPtr1 = std::out_ptr(uPtr);
+    auto outUPtr2 = std::out_ptr<int*>(uPtr);
+  }
+  {
+    std::shared_ptr<int> sPtr;
+
+    auto outSPtr1 = std::out_ptr(sPtr, [](auto* p) { delete p; });
+    auto outSPtr2 = std::out_ptr<int*>(sPtr, [](auto* p) { delete p; });
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/smartptr/adapt/out.ptr/out.ptr.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <memory>
+
+// [out.ptr.t], class template out_ptr_t
+// template<class Smart, class Pointer, class... Args>
+//   class out_ptr_t;                                          // since c++23
+
+// [out.ptr], function template out_ptr
+// template<class Pointer = void, class Smart, class... Args>
+//   auto out_ptr(Smart& s, Args&&... args);                   // since c++23
+
+#include <cassert>
+#include <memory>
+
+#include "../types.h"
+
+// Test helpers.
+
+void get_int_p(int** pp) { *pp = new int{84}; }
+
+void get_int_p_nullptr(int** pp) { *pp = nullptr; }
+
+void get_int_void_p(void** pp) { *(reinterpret_cast<int**>(pp)) = new int{84}; }
+
+void get_int_void_p_nullptr(void** pp) { *pp = nullptr; }
+
+void get_SomeInt_p(SomeInt** pp) { *pp = new SomeInt{84}; }
+
+void get_SomeInt_void_p(void** pp) { *pp = reinterpret_cast<void*>(new SomeInt{84}); }
+
+// Test `std::out_ptr()` function.
+
+bool test_raw_ptr() {
+  {
+    auto n{90};
+    auto rPtr = &n;
+
+    get_int_p(std::inout_ptr<int*>(rPtr));
+    assert(*rPtr == 84);
+    delete rPtr;
+
+    get_int_p_nullptr(std::out_ptr<int*>(rPtr));
+    assert(rPtr == nullptr);
+
+    get_int_void_p(std::inout_ptr<int*>(rPtr));
+    assert(*rPtr == 84);
+    delete rPtr;
+
+    get_int_void_p_nullptr(std::out_ptr<int*>(rPtr));
+    assert(rPtr == nullptr);
+  }
+  {
+    SomeInt si{90};
+    auto* rPtr = &si;
+
+    get_SomeInt_p(std::out_ptr(rPtr));
+    assert(rPtr->value == 84);
+    delete rPtr;
+  }
+  {
+    SomeInt si{90};
+    auto* rPtr = &si;
+
+    get_SomeInt_void_p(std::out_ptr<SomeInt*>(rPtr));
+    assert(rPtr->value == 84);
+    delete rPtr;
+  }
+
+  return true;
+}
+
+bool test_shared_ptr() {
+  {
+    auto sPtr = std::make_shared<int>(90);
+
+    get_int_p(std::out_ptr(sPtr, [](auto* p) { delete p; }));
+    assert(*sPtr == 84);
+
+    sPtr.reset(new int(90));
+
+    get_int_void_p(std::out_ptr(sPtr, [](auto* p) { delete p; }));
+    assert(*sPtr == 84);
+  }
+  {
+    auto sPtr = std::make_shared<SomeInt>(90);
+
+    get_SomeInt_p(std::out_ptr(sPtr, [](auto* p) { delete p; }));
+    assert(sPtr->value == 84);
+  }
+  {
+    auto sPtr = std::make_shared<SomeInt>(90);
+
+    get_SomeInt_void_p(std::out_ptr<SomeInt*>(sPtr, [](auto* p) { delete p; }));
+    assert(sPtr->value == 84);
+  }
+
+  return true;
+}
+
+bool test_unique_ptr() {
+  {
+    auto uPtr = std::make_unique<int>(90);
+
+    get_int_p(std::out_ptr(uPtr));
+    assert(*uPtr == 84);
+
+    uPtr.reset(new int{90});
+
+    get_int_void_p(std::out_ptr(uPtr));
+    assert(*uPtr == 84);
+  }
+  {
+    auto uPtr = std::make_unique<SomeInt>(90);
+
+    get_SomeInt_p(std::out_ptr(uPtr));
+    assert(uPtr->value == 84);
+  }
+  {
+    auto uPtr = std::make_unique<SomeInt>(90);
+
+    get_SomeInt_void_p(std::out_ptr<SomeInt*>(uPtr));
+    assert(uPtr->value == 84);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test_raw_ptr());
+  assert(test_shared_ptr());
+  assert(test_unique_ptr());
+
+  return 0;
+}

libcxx/test/std/utilities/smartptr/adapt/out.ptr/out.ptr.t.compile.fail.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <memory>
+
+// [out.ptr.t], class template out_ptr_t
+// template<class Smart, class Pointer, class... Args>
+//   class out_ptr_t;                                          // since c++23
+
+#include <memory>
+
+int main(int, char**) {
+  // `std::out_ptr_t<>` requires `std::shared_ptr<>` with a deleter.
+  {
+    std::shared_ptr<int> sPtr;
+    std::out_ptr_t<std::shared_ptr<int>, int*>{sPtr};
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/smartptr/adapt/out.ptr/out.ptr.t.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <memory>
+
+// [out.ptr.t], class template out_ptr_t
+// template<class Smart, class Pointer, class... Args>
+//   class out_ptr_t;                                          // since c++23
+
+#include <memory>
+
+int main(int, char**) {
+  {
+    std::unique_ptr<int> uPtr;
+
+    std::out_ptr_t<std::unique_ptr<int>, int*>{uPtr};
+  }
+  {
+    std::unique_ptr<int, std::default_delete<int>> uPtr;
+
+    std::out_ptr_t<decltype(uPtr), int*, std::default_delete<int>>{uPtr, std::default_delete<int>{}};
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/smartptr/adapt/types.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 TEST_LIBCXX_UTILITIES_SMARTPTR_ADAPT_TYPES_H
+#define TEST_LIBCXX_UTILITIES_SMARTPTR_ADAPT_TYPES_H
+
+// Custom pointer types.
+
+// template <typename _Tp, typename... _Args>
+// struct ConstructablePtr {
+//   _Tp* ptr;
+
+//   ConstructiblePtr(_Args... args) { ptr = new _Tp{_Args... args}; }
+//   ~ConstructablePtr() {
+//     delete ptr;
+//     ptr = nullptr;
+//   }
+// };
+
+// template <typename _Tp>
+// struct ResettablePtr {
+//   _Tp* ptr;
+
+//   ~ResettablePtr() {
+//     delete ptr;
+//     ptr = nullptr;
+//   }
+
+//   void reset() { delete data; }
+//   void reset(_Tp* p) {
+//     delete ptr;
+//     ptr = p;
+//   }
+// };
+
+// Custom types.
+
+struct SomeInt {
+  int value;
+
+  constexpr explicit SomeInt(int val = 0) : value{val} {}
+};
+
+#endif // TEST_LIBCXX_UTILITIES_SMARTPTR_ADAPT_TYPES_H

libcxx/utils/generate_feature_test_macro_components.py

for x in [
             "name": "__cpp_lib_optional",
             "values": {"c++17": 201606, "c++23": 202110},
             "headers": ["optional"],
         },
         {
             "name": "__cpp_lib_out_ptr",
             "values": {"c++23": 202106},
             "headers": ["memory"],
-            "unimplemented": True,
         },
         {
             "name": "__cpp_lib_parallel_algorithm",
             "values": {"c++17": 201603},
             "headers": ["algorithm", "numeric"],
             "unimplemented": True,
         },
         {

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

sources = [
       "__memory/allocator_traits.h",
       "__memory/assume_aligned.h",
       "__memory/auto_ptr.h",
       "__memory/builtin_new_allocator.h",
       "__memory/compressed_pair.h",
       "__memory/concepts.h",
       "__memory/construct_at.h",
       "__memory/destruct_n.h",
+      "__memory/inout_ptr.h",
+      "__memory/out_ptr.h",
       "__memory/pointer_traits.h",
       "__memory/ranges_construct_at.h",
       "__memory/ranges_uninitialized_algorithms.h",
       "__memory/raw_storage_iterator.h",
       "__memory/shared_ptr.h",
       "__memory/swap_allocator.h",
       "__memory/temp_value.h",
       "__memory/temporary_buffer.h",