[libc++] Add incomplete availability markup for std::pmr

[ldionne]

Summary

This fixes rdar://110330781, which asked for the feature-test macro
for std::pmr to take into account the deployment target. It doesn't
fix https://llvm.org/PR62212, though, because the availability markup
itself must be disabled until some Clang bugs have been fixed.

This is pretty vexing, however at least everything should work once
those Clang bugs have been fixed. In the meantime, this patch at least
adds the required markup (as disabled) and ensures that the feature-test
macro for std::pmr is aware of the deployment target requirement.

[ldionne]

libcxx/include/__availability

330

I *think* it does the correct thing, but you should be adding tests to verify that. See for example libcxx/test/libcxx/thread/atomic.availability.verify.cpp.

[philnik]

• Address comments

[Mordante]

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

74

This function probably needs to be marked too since it calls release.

I usually use the attribute on the entire class/struct.

[philnik]

• Address comments

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

74

Thanks for the info! I didn't know you could mark a class as unavailable.

[philnik]

• Try to fix CI

[ldionne]

I think you need to propagate availability macros to the typedefs in std::pmr. You should also add a simple test for those -- it's probably fine to put everything inside the same file.

libcxx/include/__availability

172

Missing a comment like all the other ones.

[philnik]

• Address comments

[ldionne]

LGTM once CI is passing. I'll try to get you access to our CI node per our discussion.

[ldionne]

Rebase onto main. There's a lot of problems that I think are basically Clang bugs with the availability attributes.

[ldionne]

Format

[ldionne]

Update commit message

[Mordante]

LGTM modulo one comment.

libcxx/test/libcxx/utilities/utility/mem.res/pmr.availability.verify.cpp

9

Based on the other test we haven't backported PMR.

[ldionne]

Rebase and trigger CI

[ldionne]

Disable availability markup and explain why.

[ldionne]

Poke CI

[ldionne]

Rebase on top of GCC fix for CI.

[ldionne]

Update failing tests on Apple

libcxx/include/__availability

 #   define _LIBCPP_AVAILABILITY_SYNC
 
     // This controls whether the library claims to provide a default verbose
     // termination function, and consequently whether the headers will try
     // to use it when the mechanism isn't overriden at compile-time.
 // #   define _LIBCPP_AVAILABILITY_HAS_NO_VERBOSE_ABORT
 #   define _LIBCPP_AVAILABILITY_VERBOSE_ABORT
 
+    // This controls the availability of the C++17 std::pmr library,
+    // which is implemented in large part in the built library.
+// #   define _LIBCPP_AVAILABILITY_HAS_NO_PMR
+#   define _LIBCPP_AVAILABILITY_PMR
+
 #elif defined(__APPLE__)
 
     // shared_mutex and shared_timed_mutex
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \
         (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) ||         \
         (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX
#   define _LIBCPP_AVAILABILITY_SYNC                                            \
 
     // __libcpp_verbose_abort
 #   if 1 // TODO: Update once this is released
 #       define _LIBCPP_AVAILABILITY_HAS_NO_VERBOSE_ABORT
 #   endif
 #   define _LIBCPP_AVAILABILITY_VERBOSE_ABORT                                   \
         __attribute__((unavailable))
 
+    // std::pmr
+#   if 1 // TODO: Update once this is released
+#       define _LIBCPP_AVAILABILITY_HAS_NO_PMR
+#   endif
+#   define _LIBCPP_AVAILABILITY_PMR                                             \
+        __attribute__((unavailable))
+
 #else
 
 // ...New vendors can add availability markup here...
 
 #   error "It looks like you're trying to enable vendor availability markup, but you haven't defined the corresponding macros yet!"
 
 #endif
 

libcxx/include/__fwd/memory_resource.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___FWD_MEMORY_RESOURCE_H
 #define _LIBCPP___FWD_MEMORY_RESOURCE_H
 
+#include <__availability>
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace pmr {
 template <class _ValueType>
-class _LIBCPP_TEMPLATE_VIS polymorphic_allocator;
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_TEMPLATE_VIS polymorphic_allocator;
 } // namespace pmr
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FWD_MEMORY_RESOURCE_H

libcxx/include/__fwd/string.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___FWD_STRING_H
 #define _LIBCPP___FWD_STRING_H
 
+#include <__availability>
 #include <__config>
 #include <__fwd/memory_resource.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

 
 using u16string = basic_string<char16_t>;
 using u32string = basic_string<char32_t>;
 
 #if _LIBCPP_STD_VER >= 17
 
 namespace pmr {
 template <class _CharT, class _Traits = char_traits<_CharT>>
-using basic_string = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
+using basic_string _LIBCPP_AVAILABILITY_PMR = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
 
-using string = basic_string<char>;
+using string _LIBCPP_AVAILABILITY_PMR = basic_string<char>;
 
 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-using wstring = basic_string<wchar_t>;
+using wstring _LIBCPP_AVAILABILITY_PMR = basic_string<wchar_t>;
 #  endif
 
 #  ifndef _LIBCPP_HAS_NO_CHAR8_T
-using u8string = basic_string<char8_t>;
+using u8string _LIBCPP_AVAILABILITY_PMR = basic_string<char8_t>;
 #  endif
 
-using u16string = basic_string<char16_t>;
-using u32string = basic_string<char32_t>;
-
+using u16string _LIBCPP_AVAILABILITY_PMR = basic_string<char16_t>;
+using u32string _LIBCPP_AVAILABILITY_PMR = basic_string<char32_t>;
 } // namespace pmr
 
 #endif // _LIBCPP_STD_VER >= 17
 
 // clang-format off
 template <class _CharT, class _Traits, class _Allocator>
 class _LIBCPP_PREFERRED_NAME(string)
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS

libcxx/include/__memory_resource/memory_resource.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___MEMORY_RESOURCE_MEMORY_RESOURCE_H
 #define _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H
 
+#include <__availability>
 #include <__config>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace pmr {
 
 // [mem.res.class]
 
-class _LIBCPP_TYPE_VIS memory_resource {
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_TYPE_VIS memory_resource {
   static const size_t __max_align = alignof(max_align_t);
 
 public:
   virtual ~memory_resource();
 
   _LIBCPP_NODISCARD_AFTER_CXX17
   [[using __gnu__: __returns_nonnull__, __alloc_size__(2), __alloc_align__(3)]] _LIBCPP_HIDE_FROM_ABI void*
   allocate(size_t __bytes, size_t __align = __max_align) {

 private:
   virtual void* do_allocate(size_t, size_t)                       = 0;
   virtual void do_deallocate(void*, size_t, size_t)               = 0;
   virtual bool do_is_equal(memory_resource const&) const noexcept = 0;
 };
 
 // [mem.res.eq]
 
-inline _LIBCPP_HIDE_FROM_ABI bool operator==(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
+inline _LIBCPP_AVAILABILITY_PMR _LIBCPP_HIDE_FROM_ABI bool
+operator==(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
   return &__lhs == &__rhs || __lhs.is_equal(__rhs);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
+inline _LIBCPP_AVAILABILITY_PMR _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
   return !(__lhs == __rhs);
 }
 
 // [mem.res.global]
 
-[[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS memory_resource* get_default_resource() noexcept;
-[[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS memory_resource* set_default_resource(memory_resource*) noexcept;
-[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* new_delete_resource() noexcept;
-[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* null_memory_resource() noexcept;
+[[__gnu__::__returns_nonnull__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_FUNC_VIS memory_resource*
+get_default_resource() noexcept;
+[[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_PMR memory_resource*
+set_default_resource(memory_resource*) noexcept;
+[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_FUNC_VIS memory_resource*
+new_delete_resource() noexcept;
+[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_FUNC_VIS memory_resource*
+null_memory_resource() noexcept;
 
 } // namespace pmr
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H

libcxx/include/__memory_resource/monotonic_buffer_resource.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___MEMORY_RESOURCE_MONOTONIC_BUFFER_RESOURCE_H
 #define _LIBCPP___MEMORY_RESOURCE_MONOTONIC_BUFFER_RESOURCE_H
 
+#include <__availability>
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory_resource/memory_resource.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace pmr {
 
 // [mem.res.monotonic.buffer]
 
-class _LIBCPP_TYPE_VIS monotonic_buffer_resource : public memory_resource {
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_TYPE_VIS monotonic_buffer_resource : public memory_resource {
   static const size_t __default_buffer_capacity  = 1024;
   static const size_t __default_buffer_alignment = 16;
 
   struct __chunk_footer {
     __chunk_footer* __next_;
     char* __start_;
     char* __cur_;
     size_t __align_;

libcxx/include/__memory_resource/polymorphic_allocator.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___MEMORY_RESOURCE_POLYMORPHIC_ALLOCATOR_H
 #define _LIBCPP___MEMORY_RESOURCE_POLYMORPHIC_ALLOCATOR_H
 
 #include <__assert>
+#include <__availability>
 #include <__config>
 #include <__memory_resource/memory_resource.h>
 #include <__utility/exception_guard.h>
 #include <cstddef>
 #include <limits>
 #include <new>
 #include <stdexcept>
 #include <tuple>

 
 // [mem.poly.allocator.class]
 
 template <class _ValueType
 #  if _LIBCPP_STD_VER >= 20
           = byte
 #  endif
           >
-class _LIBCPP_TEMPLATE_VIS polymorphic_allocator {
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_TEMPLATE_VIS polymorphic_allocator {
 
 public:
   using value_type = _ValueType;
 
   // [mem.poly.allocator.ctor]
 
   _LIBCPP_HIDE_FROM_ABI polymorphic_allocator() noexcept : __res_(std::pmr::get_default_resource()) {}
 

libcxx/include/__memory_resource/synchronized_pool_resource.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___MEMORY_RESOURCE_SYNCHRONIZED_POOL_RESOURCE_H
 #define _LIBCPP___MEMORY_RESOURCE_SYNCHRONIZED_POOL_RESOURCE_H
 
+#include <__availability>
 #include <__config>
 #include <__memory_resource/memory_resource.h>
 #include <__memory_resource/pool_options.h>
 #include <__memory_resource/unsynchronized_pool_resource.h>
 #include <cstddef>
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #  include <mutex>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace pmr {
 
 // [mem.res.pool.overview]
 
-class _LIBCPP_TYPE_VIS synchronized_pool_resource : public memory_resource {
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_TYPE_VIS synchronized_pool_resource : public memory_resource {
 public:
   _LIBCPP_HIDE_FROM_ABI synchronized_pool_resource(const pool_options& __opts, memory_resource* __upstream)
       : __unsync_(__opts, __upstream) {}
 
   _LIBCPP_HIDE_FROM_ABI synchronized_pool_resource()
       : synchronized_pool_resource(pool_options(), get_default_resource()) {}
 
   _LIBCPP_HIDE_FROM_ABI explicit synchronized_pool_resource(memory_resource* __upstream)

libcxx/include/__memory_resource/unsynchronized_pool_resource.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___MEMORY_RESOURCE_UNSYNCHRONIZED_POOL_RESOURCE_H
 #define _LIBCPP___MEMORY_RESOURCE_UNSYNCHRONIZED_POOL_RESOURCE_H
 
+#include <__availability>
 #include <__config>
 #include <__memory_resource/memory_resource.h>
 #include <__memory_resource/pool_options.h>
 #include <cstddef>
 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace pmr {
 
 // [mem.res.pool.overview]
 
-class _LIBCPP_TYPE_VIS unsynchronized_pool_resource : public memory_resource {
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_TYPE_VIS unsynchronized_pool_resource : public memory_resource {
   class __fixed_pool;
 
   class __adhoc_pool {
     struct __chunk_footer;
     __chunk_footer* __first_;
 
   public:
     _LIBCPP_HIDE_FROM_ABI explicit __adhoc_pool() : __first_(nullptr) {}
public:
   _LIBCPP_HIDE_FROM_ABI explicit unsynchronized_pool_resource(memory_resource* __upstream)
       : unsynchronized_pool_resource(pool_options(), __upstream) {}
 
   _LIBCPP_HIDE_FROM_ABI explicit unsynchronized_pool_resource(const pool_options& __opts)
       : unsynchronized_pool_resource(__opts, get_default_resource()) {}
 
   unsynchronized_pool_resource(const unsynchronized_pool_resource&) = delete;
 
   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~unsynchronized_pool_resource() override { release(); }
 
   unsynchronized_pool_resource& operator=(const unsynchronized_pool_resource&) = delete;
 
   void release();
 
   _LIBCPP_HIDE_FROM_ABI memory_resource* upstream_resource() const { return __res_; }
 
   [[__gnu__::__pure__]] pool_options options() const;

libcxx/include/deque

 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/min.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__availability>
 #include <__config>
 #include <__format/enable_insertable.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
 #include <__iterator/segmented_iterator.h>
 #include <__memory/addressof.h>

 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _ValueT>
-using deque = std::deque<_ValueT, polymorphic_allocator<_ValueT>>;
+using deque _LIBCPP_AVAILABILITY_PMR = std::deque<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>

libcxx/include/forward_list

 
 */
 
 #include <__algorithm/comp.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__availability>
 #include <__config>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_destructor.h>

 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _ValueT>
-using forward_list = std::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
+using forward_list _LIBCPP_AVAILABILITY_PMR = std::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>

libcxx/include/list

 */
 
 #include <__algorithm/comp.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__availability>
 #include <__config>
 #include <__debug>
 #include <__format/enable_insertable.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>

 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _ValueT>
-using list = std::list<_ValueT, polymorphic_allocator<_ValueT>>;
+using list _LIBCPP_AVAILABILITY_PMR = std::list<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>

libcxx/include/map

 }  // std
 
 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__availability>
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/addressof.h>

 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>>
-using map = std::map<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
+using map _LIBCPP_AVAILABILITY_PMR = std::map<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 
 template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>>
-using multimap = std::multimap<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
+using multimap _LIBCPP_AVAILABILITY_PMR = std::multimap<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstdlib>
 #  include <functional>
 #  include <iterator>
 #  include <type_traits>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_MAP

libcxx/include/regex

 typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 
 } // std
 */
 
 #include <__algorithm/find.h>
 #include <__algorithm/search.h>
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__availability>
 #include <__config>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__type_traits/is_swappable.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>

 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _BidirT>
-using match_results = std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>;
+using match_results _LIBCPP_AVAILABILITY_PMR = std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>;
 
-using cmatch  = match_results<const char*>;
-using smatch  = match_results<std::pmr::string::const_iterator>;
+using cmatch _LIBCPP_AVAILABILITY_PMR  = match_results<const char*>;
+using smatch _LIBCPP_AVAILABILITY_PMR  = match_results<std::pmr::string::const_iterator>;
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-using wcmatch = match_results<const wchar_t*>;
-using wsmatch = match_results<std::pmr::wstring::const_iterator>;
+using wcmatch _LIBCPP_AVAILABILITY_PMR = match_results<const wchar_t*>;
+using wsmatch _LIBCPP_AVAILABILITY_PMR = match_results<std::pmr::wstring::const_iterator>;
 #endif
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20

libcxx/include/set

 
 }  // std
 
 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__availability>
 #include <__config>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>

 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _KeyT, class _CompareT = std::less<_KeyT>>
-using set = std::set<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
+using set _LIBCPP_AVAILABILITY_PMR = std::set<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
 
 template <class _KeyT, class _CompareT = std::less<_KeyT>>
-using multiset = std::multiset<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
+using multiset _LIBCPP_AVAILABILITY_PMR = std::multiset<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstdlib>
 #  include <functional>
 #  include <iterator>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_SET

libcxx/include/unordered_map

operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
                const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 }  // std
 
 */
 
 #include <__algorithm/is_permutation.h>
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__availability>
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__hash_table>
 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>

 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _KeyT, class _ValueT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
-using unordered_map =
+using unordered_map _LIBCPP_AVAILABILITY_PMR =
     std::unordered_map<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 
 template <class _KeyT, class _ValueT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
-using unordered_multimap =
+using unordered_multimap _LIBCPP_AVAILABILITY_PMR =
     std::unordered_multimap<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <bit>
 #  include <concepts>
 #  include <cstdlib>
 #  include <iterator>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_UNORDERED_MAP

libcxx/include/unordered_set

template <class Value, class Hash, class Pred, class Alloc>
     operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
                const unordered_multiset<Value, Hash, Pred, Alloc>& y);
 }  // std
 
 */
 
 #include <__algorithm/is_permutation.h>
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__availability>
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__hash_table>
 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>

 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
-using unordered_set = std::unordered_set<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
+using unordered_set _LIBCPP_AVAILABILITY_PMR = std::unordered_set<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
 
 template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
-using unordered_multiset = std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
+using unordered_multiset _LIBCPP_AVAILABILITY_PMR = std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstdlib>
 #  include <functional>
 #  include <iterator>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_UNORDERED_SET

libcxx/include/vector

 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__availability>
 #include <__bit_reference>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__debug>
 #include <__format/enable_insertable.h>
 #include <__format/formatter.h>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>

 #endif // _LIBCPP_STD_VER >= 23
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _ValueT>
-using vector = std::vector<_ValueT, polymorphic_allocator<_ValueT>>;
+using vector _LIBCPP_AVAILABILITY_PMR = std::vector<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>

libcxx/include/version

 # define __cpp_lib_is_aggregate                         201703L
 # define __cpp_lib_is_invocable                         201703L
 # define __cpp_lib_is_swappable                         201603L
 # define __cpp_lib_launder                              201606L
 # define __cpp_lib_logical_traits                       201510L
 # define __cpp_lib_make_from_tuple                      201606L
 # define __cpp_lib_map_try_emplace                      201411L
 // # define __cpp_lib_math_special_functions               201603L
-# define __cpp_lib_memory_resource                      201603L
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   define __cpp_lib_memory_resource                    201603L
+# endif
 # define __cpp_lib_node_extract                         201606L
 # define __cpp_lib_nonmember_container_access           201411L
 # define __cpp_lib_not_fn                               201603L
 # define __cpp_lib_optional                             201606L
 // # define __cpp_lib_parallel_algorithm                   201603L
 # define __cpp_lib_raw_memory_algorithms                201606L
 # define __cpp_lib_sample                               201603L
 # define __cpp_lib_scoped_lock                          201703L

 // #   define __cpp_lib_jthread                            201911L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   define __cpp_lib_latch                              201907L
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
 # define __cpp_lib_math_constants                       201907L
 # define __cpp_lib_move_iterator_concept                202207L
-# define __cpp_lib_polymorphic_allocator                201902L
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   define __cpp_lib_polymorphic_allocator              201902L
+# endif
 # define __cpp_lib_ranges                               202106L
 # define __cpp_lib_remove_cvref                         201711L
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   define __cpp_lib_semaphore                          201907L
 # endif
 # undef  __cpp_lib_shared_ptr_arrays
 # define __cpp_lib_shared_ptr_arrays                    201707L
 # define __cpp_lib_shift                                201806L

libcxx/test/libcxx/utilities/utility/mem.res/pmr.availability.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+// REQUIRES: availability-pmr-missing
+
+// Test the availability markup on std::pmr components.
+
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <memory_resource>
+#include <regex>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+void f() {
+    [[maybe_unused]] std::pmr::match_results<const char8_t*> m1; // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::cmatch m2;                        // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::wcmatch m3;                       // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::smatch m4;                        // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::wsmatch m5;                       // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::deque<int> m6;                    // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::forward_list<int> m7;             // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::list<int> m8;                     // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::map<int, int> m9;                 // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::multimap<int, int> m10;           // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::set<int> m11;                     // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::multiset<int> m12;                // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::string m13;                       // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::wstring m14;                      // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::u8string m15;                     // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::u16string m16;                    // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::u32string m17;                    // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::basic_string<char8_t> m18;        // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::unordered_map<int, int> m19;      // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::unordered_multimap<int, int> m20; // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::unordered_set<int, int> m21;      // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::unordered_multiset<int, int> m22; // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::vector<int> m23;                  // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::polymorphic_allocator<int> poly;  // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::memory_resource* res = nullptr;   // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::synchronized_pool_resource r1;    // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::monotonic_buffer_resource r2;     // expected-error {{is unavailable}}
+    [[maybe_unused]] std::pmr::unsynchronized_pool_resource r3;  // expected-error {{is unavailable}}
+    (void)std::pmr::get_default_resource();                      // expected-error {{is unavailable}}
+    (void)std::pmr::set_default_resource(nullptr);               // expected-error {{is unavailable}}
+    (void)std::pmr::new_delete_resource();                       // expected-error {{is unavailable}}
+    (void)std::pmr::null_memory_resource();                      // expected-error {{is unavailable}}
+    (void)(*res == *res);                                        // expected-error {{is unavailable}}
+}

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

 # endif
 
 # ifdef __cpp_lib_polymorphic_allocator
 #   error "__cpp_lib_polymorphic_allocator should not be defined before c++20"
 # endif
 
 #elif TEST_STD_VER == 17
 
-# ifndef __cpp_lib_memory_resource
-#   error "__cpp_lib_memory_resource should be defined in c++17"
-# endif
-# if __cpp_lib_memory_resource != 201603L
-#   error "__cpp_lib_memory_resource should have the value 201603L in c++17"
-# endif
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   ifndef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should be defined in c++17"
+#   endif
+#   if __cpp_lib_memory_resource != 201603L
+#     error "__cpp_lib_memory_resource should have the value 201603L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
+#   endif
+# endif
 
 # ifdef __cpp_lib_polymorphic_allocator
 #   error "__cpp_lib_polymorphic_allocator should not be defined before c++20"
 # endif
 
 #elif TEST_STD_VER == 20
 
-# ifndef __cpp_lib_memory_resource
-#   error "__cpp_lib_memory_resource should be defined in c++20"
-# endif
-# if __cpp_lib_memory_resource != 201603L
-#   error "__cpp_lib_memory_resource should have the value 201603L in c++20"
-# endif
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   ifndef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should be defined in c++20"
+#   endif
+#   if __cpp_lib_memory_resource != 201603L
+#     error "__cpp_lib_memory_resource should have the value 201603L in c++20"
+#   endif
+# else
+#   ifdef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
+#   endif
+# endif
 
-# ifndef __cpp_lib_polymorphic_allocator
-#   error "__cpp_lib_polymorphic_allocator should be defined in c++20"
-# endif
-# if __cpp_lib_polymorphic_allocator != 201902L
-#   error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++20"
-# endif
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   ifndef __cpp_lib_polymorphic_allocator
+#     error "__cpp_lib_polymorphic_allocator should be defined in c++20"
+#   endif
+#   if __cpp_lib_polymorphic_allocator != 201902L
+#     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++20"
+#   endif
+# else
+#   ifdef __cpp_lib_polymorphic_allocator
+#     error "__cpp_lib_polymorphic_allocator should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
+#   endif
+# endif
 
 #elif TEST_STD_VER > 20
 
-# ifndef __cpp_lib_memory_resource
-#   error "__cpp_lib_memory_resource should be defined in c++2b"
-# endif
-# if __cpp_lib_memory_resource != 201603L
-#   error "__cpp_lib_memory_resource should have the value 201603L in c++2b"
-# endif
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   ifndef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should be defined in c++2b"
+#   endif
+#   if __cpp_lib_memory_resource != 201603L
+#     error "__cpp_lib_memory_resource should have the value 201603L in c++2b"
+#   endif
+# else
+#   ifdef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
+#   endif
+# endif
 
-# ifndef __cpp_lib_polymorphic_allocator
-#   error "__cpp_lib_polymorphic_allocator should be defined in c++2b"
-# endif
-# if __cpp_lib_polymorphic_allocator != 201902L
-#   error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++2b"
-# endif
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   ifndef __cpp_lib_polymorphic_allocator
+#     error "__cpp_lib_polymorphic_allocator should be defined in c++2b"
+#   endif
+#   if __cpp_lib_polymorphic_allocator != 201902L
+#     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++2b"
+#   endif
+# else
+#   ifdef __cpp_lib_polymorphic_allocator
+#     error "__cpp_lib_polymorphic_allocator should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
+#   endif
+# endif
 
 #endif // TEST_STD_VER > 20
 

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

 #     error "__cpp_lib_math_special_functions should have the value 201603L in c++17"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_math_special_functions
 #     error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# ifndef __cpp_lib_memory_resource
-#   error "__cpp_lib_memory_resource should be defined in c++17"
-# endif
-# if __cpp_lib_memory_resource != 201603L
-#   error "__cpp_lib_memory_resource should have the value 201603L in c++17"
-# endif
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   ifndef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should be defined in c++17"
+#   endif
+#   if __cpp_lib_memory_resource != 201603L
+#     error "__cpp_lib_memory_resource should have the value 201603L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
+#   endif
+# endif
 
 # ifdef __cpp_lib_move_iterator_concept
 #   error "__cpp_lib_move_iterator_concept should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_move_only_function
 #   error "__cpp_lib_move_only_function should not be defined before c++2b"
 # endif

 #     error "__cpp_lib_math_special_functions should have the value 201603L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_math_special_functions
 #     error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# ifndef __cpp_lib_memory_resource
-#   error "__cpp_lib_memory_resource should be defined in c++20"
-# endif
-# if __cpp_lib_memory_resource != 201603L
-#   error "__cpp_lib_memory_resource should have the value 201603L in c++20"
-# endif
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   ifndef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should be defined in c++20"
+#   endif
+#   if __cpp_lib_memory_resource != 201603L
+#     error "__cpp_lib_memory_resource should have the value 201603L in c++20"
+#   endif
+# else
+#   ifdef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
+#   endif
+# endif
 
 # ifndef __cpp_lib_move_iterator_concept
 #   error "__cpp_lib_move_iterator_concept should be defined in c++20"
 # endif
 # if __cpp_lib_move_iterator_concept != 202207L
 #   error "__cpp_lib_move_iterator_concept should have the value 202207L in c++20"
 # endif
 

 #     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# ifndef __cpp_lib_polymorphic_allocator
-#   error "__cpp_lib_polymorphic_allocator should be defined in c++20"
-# endif
-# if __cpp_lib_polymorphic_allocator != 201902L
-#   error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++20"
-# endif
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   ifndef __cpp_lib_polymorphic_allocator
+#     error "__cpp_lib_polymorphic_allocator should be defined in c++20"
+#   endif
+#   if __cpp_lib_polymorphic_allocator != 201902L
+#     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++20"
+#   endif
+# else
+#   ifdef __cpp_lib_polymorphic_allocator
+#     error "__cpp_lib_polymorphic_allocator should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
+#   endif
+# endif
 
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++20"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++20"
 # endif
 

 #     error "__cpp_lib_math_special_functions should have the value 201603L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_math_special_functions
 #     error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# ifndef __cpp_lib_memory_resource
-#   error "__cpp_lib_memory_resource should be defined in c++2b"
-# endif
-# if __cpp_lib_memory_resource != 201603L
-#   error "__cpp_lib_memory_resource should have the value 201603L in c++2b"
-# endif
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   ifndef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should be defined in c++2b"
+#   endif
+#   if __cpp_lib_memory_resource != 201603L
+#     error "__cpp_lib_memory_resource should have the value 201603L in c++2b"
+#   endif
+# else
+#   ifdef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
+#   endif
+# endif
 
 # ifndef __cpp_lib_move_iterator_concept
 #   error "__cpp_lib_move_iterator_concept should be defined in c++2b"
 # endif
 # if __cpp_lib_move_iterator_concept != 202207L
 #   error "__cpp_lib_move_iterator_concept should have the value 202207L in c++2b"
 # endif
 

 #     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# ifndef __cpp_lib_polymorphic_allocator
-#   error "__cpp_lib_polymorphic_allocator should be defined in c++2b"
-# endif
-# if __cpp_lib_polymorphic_allocator != 201902L
-#   error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++2b"
-# endif
+# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
+#   ifndef __cpp_lib_polymorphic_allocator
+#     error "__cpp_lib_polymorphic_allocator should be defined in c++2b"
+#   endif
+#   if __cpp_lib_polymorphic_allocator != 201902L
+#     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++2b"
+#   endif
+# else
+#   ifdef __cpp_lib_polymorphic_allocator
+#     error "__cpp_lib_polymorphic_allocator should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
+#   endif
+# endif
 
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++2b"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++2b"
 # endif
 

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.ctor/assign.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
+// XFAIL: availability-pmr-missing
 
 // <memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator operator=(polymorphic_allocator const &) = delete
 
 #include <memory_resource>

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.ctor/copy.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
+// XFAIL: availability-pmr-missing
 
 // <memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator const &);
 
 #include <memory_resource>

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.ctor/other_alloc.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
+// XFAIL: availability-pmr-missing
 
 // <memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U>
 // polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator<U> const &);
 

libcxx/test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.ctor/copy_move.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
+// XFAIL: availability-pmr-missing
 
 // <memory_resource>
 
 // monotonic_buffer_resource(monotonic_buffer_resource const&) = delete;
 // monotonic_buffer_resource& operator=(monotonic_buffer_resource const&) = delete;
 
 #include <memory_resource>
 #include <type_traits>

libcxx/test/std/utilities/utility/mem.res/mem.res/construct.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
+// XFAIL: availability-pmr-missing
 
 // <memory_resource>
 
 // Check that memory_resource is not constructible
 
 #include <memory_resource>
 
 void test() {
   std::pmr::memory_resource m; // expected-error {{variable type 'std::pmr::memory_resource' is an abstract class}}
 }

libcxx/test/std/utilities/utility/mem.res/mem.res/mem.res.private/private_members.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
+// XFAIL: availability-pmr-missing
 
 // <memory_resource>
 
 // memory_resource::do_allocate(size_t, size_t);          /* private */
 // memory_resource::do_deallocate(void*, size_t, size_t); /* private */
 // memory_resource::do_is_equal(memory_resource const&);  /* private */
 
 #include <memory_resource>
 
 void test() {
   std::pmr::memory_resource* m = std::pmr::new_delete_resource();
   m->do_allocate(0, 0);            // expected-error{{'do_allocate' is a private member}}
   m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a private member}}
   m->do_is_equal(*m);              // expected-error{{'do_is_equal' is a private member}}
 }

libcxx/test/std/utilities/utility/mem.res/mem.res/mem.res.private/protected_members.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
+// XFAIL: availability-pmr-missing
 
 // <memory_resource>
 
 // monotonic_buffer_resource::do_allocate(size_t, size_t);          /* protected */
 // monotonic_buffer_resource::do_deallocate(void*, size_t, size_t); /* protected */
 // monotonic_buffer_resource::do_is_equal(memory_resource const&);  /* protected */
 
 // synchronized_pool_resource::do_allocate(size_t, size_t);          /* protected */

libcxx/test/std/utilities/utility/mem.res/nodiscard.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-pmr-missing
 
 // check that functions are marked [[nodiscard]]
 
 // [[nodiscard]] std::pmr::memory_resource::allocate(size_t, size_t);
 // [[nodiscard]] std::pmr::polymorphic_allocator<T>::allocate(size_t, size_t);
 
 #include <memory_resource>
 
 void f() {
   std::pmr::memory_resource* res = nullptr;
   res->allocate(0);    // expected-warning {{ignoring return value of function}}
   res->allocate(0, 1); // expected-warning {{ignoring return value of function}}
 
   std::pmr::polymorphic_allocator<int> poly;
   poly.allocate(0); // expected-warning {{ignoring return value of function}}
 }

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_math_special_functions",
     "values": { "c++17": 201603 },
     "headers": ["cmath"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_memory_resource",
     "values": { "c++17": 201603 },
     "headers": ["memory_resource"],
+    "test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)",
+    "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)",
   }, {
     "name": "__cpp_lib_move_iterator_concept",
     "values": { "c++20": 202207 },
     "headers": ["iterator"],
    }, {
     "name": "__cpp_lib_move_only_function",
     "values": { "c++2b": 202110 },
     "headers": ["functional"],
feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_parallel_algorithm",
     "values": { "c++17": 201603 },
     "headers": ["algorithm", "numeric"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_polymorphic_allocator",
     "values": { "c++20": 201902 },
     "headers": ["memory_resource"],
+    "test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)",
+    "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)",
   }, {
     "name": "__cpp_lib_quoted_string_io",
     "values": { "c++14": 201304 },
     "headers": ["iomanip"],
   }, {
     "name": "__cpp_lib_ranges",
     "values": { "c++20": 202106 },
     "headers": ["algorithm", "functional", "iterator", "memory", "ranges"],

libcxx/utils/libcxx/test/features.py

Feature(name='availability-bad_optional_access-missing',
     when=lambda cfg: BooleanExpression.evaluate('stdlib=apple-libc++ && target={{.+}}-apple-macosx10.{{(9|10|11|12)(.0)?}}', cfg.available_features)),
 
   # Tests that require std::bad_any_cast in the built library
   Feature(name='availability-bad_any_cast-missing',
     when=lambda cfg: BooleanExpression.evaluate('stdlib=apple-libc++ && target={{.+}}-apple-macosx10.{{(9|10|11|12)(.0)?}}', cfg.available_features)),
 
   # Tests that require std::pmr support in the built library
   Feature(name='availability-pmr-missing',
-    when=lambda cfg: BooleanExpression.evaluate('stdlib=apple-libc++ && target={{.+}}-apple-macosx{{(10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0)(.0)?}}', cfg.available_features)),
+    when=lambda cfg: BooleanExpression.evaluate('stdlib=apple-libc++ && target={{.+}}-apple-macosx{{(10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0|13.0)(.0)?}}', cfg.available_features)),
 
   # Tests that require std::filesystem support in the built library
   Feature(name='availability-filesystem-missing',
     when=lambda cfg: BooleanExpression.evaluate('stdlib=apple-libc++ && target={{.+}}-apple-macosx10.{{(9|10|11|12|13|14)(.0)?}}', cfg.available_features)),
 
   # Tests that require the C++20 synchronization library (P1135R6 implemented by https://llvm.org/D68480) in the built library
   Feature(name='availability-synchronization_library-missing',
     when=lambda cfg: BooleanExpression.evaluate('stdlib=apple-libc++ && target={{.+}}-apple-macosx10.{{(9|10|11|12|13|14|15)(.0)?}}', cfg.available_features)),