Add the C++17 <memory_resource> header (mono-patch)

[philnik]

Summary

This patch is the rebase and squash of three earlier patches. It supersedes all three of them.

• D47111: experimental monotonic_buffer_resource.
• D47358: experimental pool resources.
• D47360: Copy std::experimental::pmr to std::pmr.

The significant difference between this patch and the-sum-of-those-three is that this patch does not add std::experimental::pmr::monotonic_buffer_resource and so on. This patch simply adds the C++17 standard facilities, and leaves the std::experimental namespace entirely alone.

[• Quuxplusone]

Fix copyright headers. Maybe fix the failing monotonic-buffer-resource test, finally!
Still to do: Change "header" to "footer" throughout.
Still to do: Maybe rename e.g. "chunk_size_in_bytes => num_bytes_in_chunk".

[• Quuxplusone]

Renamed chunk_header to chunk_footer and the corresponding header_{size,align} to footer_{size,align}. This actually makes the math in aligned_capacity easier to understand, IMO! I left the loop variable h alone, rather than rename it to f, because f seems uglier to me.

I left vacancy_header alone, because it is actually stored in the initial bytes of the chunk. (Right?)

So far, I've left initial_header alone, even though technically it is neither a header nor a footer, because it is stored outside of the initial buffer. Perhaps it could be renamed something like initial_info? Any thoughts on terminology there, @griwes?

Also in this update I've merged in a couple of threading-related fixes that have been made to <experimental/memory_resource> in the past year.

[• Quuxplusone]

No change since last time. Rebase on D93137, and poke buildbots.

[griwes]

So far, I've left initial_header alone, even though technically it is neither a header nor a footer, because it is stored outside of the initial buffer. Perhaps it could be renamed something like initial_info? Any thoughts on terminology there, @griwes?

I think the name I've been using for things like that is "descriptor".

[• Quuxplusone]

Rename "initial_header" to "initial_descriptor" (since technically it's neither a header nor a footer).
Rebase on main.

[• Quuxplusone]

Rebased and split into "new-style" granular headers.
This deliberately doesn't include any C++20 stuff; just the C++17 stuff for now.

[• Quuxplusone]

@ldionne: I'll need your help to generate the "abilist" text files for this patch. Buildkite refuses to run any of the usual tests until the abilist is correct, and I have no way to generate a correct abilist without access to x86-64 and ARM64 Linux machines.

Sample failure: https://buildkite.com/llvm-project/libcxx-ci/builds/4991

[Mordante]

In D89057#2966367, @Quuxplusone wrote:

@ldionne: I'll need your help to generate the "abilist" text files for this patch. Buildkite refuses to run any of the usual tests until the abilist is correct, and I have no way to generate a correct abilist without access to x86-64 and ARM64 Linux machines.

Sample failure: https://buildkite.com/llvm-project/libcxx-ci/builds/4991

The abilist text files should be available as artifact of the failed build.
Sample X86_64 abi list: https://buildkite.com/organizations/llvm-project/pipelines/libcxx-ci/builds/5037/jobs/669a7ee3-2214-46f5-84dd-b171d94cf4ca/artifacts/23ab7856-9a88-45dd-8345-0129748b172a

[• Quuxplusone]

Rebase, add abilist artifacts (thanks @Mordante!), fix some formatting

[• Quuxplusone]

Cosmetic improvements in the tests, and make more of them pass. (Still got trouble on 32-bit builds.)
Update another abilist.

[• Quuxplusone]

Include <version> in <memory_resource>.
Fix the build when size_t is 32-bit.

[• Quuxplusone]

Fix some tests for lack of aligned allocation.

[• Quuxplusone]

One final(?) test-suite update. Use ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS to fix the Windows DLL buildkite (hooray!).

Apple 10.9 through 10.13 pass the overaligned-request tests, because they define TEST_HAS_NO_ALIGNED_ALLOCATION. Apple 10.14 and 10.15 fail, because the system dylib doesn't contain the required symbols from memory_resource.cpp.

[• Quuxplusone]

@ldionne @griwes what do we think this year?

[jloser]

@Quuxplusone can you please remove destroy() (and its tests) from polymorphic_allocator? Then you can mark LWG3036 as done and we avoid the issue of whether to mark destroy() as deprecated vs hard removal. Simply not including it when we ship this for the first time is the easiest :)

[• Quuxplusone]

polymorphic_allocator: Remove the __max_size() private member, and include-what-you-use. Mark the allocate method as [[nodiscard]] (to match C++20). Stop discarding the result of allocate in the tests. Mark destroy as _LIBCPP_DEPRECATED_IN_CXX23. Stop using destroy in the tests.

I've now got a local patch on top of this one that implements p0339 "polymorphic_allocator<> as a vocabulary type," but I still need to write unit tests for it.

libcxx/include/__memory_resource/polymorphic_allocator.h

147–150

@jloser wrote:

@Quuxplusone can you please remove destroy() (and its tests) from polymorphic_allocator? Then you can mark LWG3036 as done and we avoid the issue of whether to mark destroy() as deprecated vs hard removal. Simply not including it when we ship this for the first time is the easiest :)

Sadly, it appears that destroy is only deprecated in C++23, not removed, so if we want to be conforming we should still have it (just marked as [[deprecated]]).
http://eel.is/c++draft/depr#mem.poly.allocator.mem

Or is your point that we could just kinda "forget" to implement destroy (the same way we've "forgotten" to implement all of <memory_resource> for the past 4 years ;)), and just wait for the Standard to catch up to our non-implementation? @ldionne thoughts?

[jloser]

libcxx/include/__memory_resource/polymorphic_allocator.h

147–150

Yeah, I was hoping we could skip the deprecated step since libc++ doesn't have std::pmr::polymorphic_allocator right now - it's in the experimental namespace.

[dougsonos]

libcxx/include/__memory_resource/polymorphic_allocator.h

147–150

By this same logic, libc++ could neglect to implement all the variants of construct() which were added in C++17 and removed in C++20 :/

[philnik]

I didn't get all the way through, but here are about 20 nit picks. I'll look at the tests later.

libcxx/include/__memory_resource/memory_resource.h

30

Is there a reason this isn't constexpr or just directly in lines 35 and 39?

37

I hate this brace style with all my heart, but it's used through out the code base so I guess I can't do anything about it.

40

Nit: Use void* instead of void * or at least do it consistently (see line 35).

69–79

libcxx/include/__memory_resource/synchronized_pool_resource.h

62

Remember https://youtu.be/F6Ipn7gCOsY?t=1835?

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

50–58

Again - is there a reason these aren't constexpr?

97

What do you want to say with // key function? For the vtable?

libcxx/include/deque

3027–3035

Why is this not just in the above std namespace?

libcxx/lib/abi/CHANGELOG.TXT

26–60

Are these symbols not added under linux?

libcxx/src/memory_resource.cpp

18

Doesn't this only work with lld?

117–118

127–136

And with the other set checks as well.

128

177–178

191–192

213

Wouldn't it make more sense to put that in the header so the dylib doesn't have to change depending on wanting these assertions or not?

214–229

336–346

414

Please remove this else as well.

427–428

Why not use std::min and std::max?

[• Quuxplusone]

Address @philnik's review comments.
Mark allocate as [[nodiscard]]: that might be new in C++20, but I think we can get away with backporting it anyway. Should add a test for that, I guess.

libcxx/include/__memory_resource/memory_resource.h

30

The answer in both cases is that this came via copy-paste from <experimental/memory_resource>. I agree s/const/constexpr/g is an improvement. I'll keep it pulled out as a named constant, though, since it's used in two places and it's just barely conceivable that some platform might like to change it.

40

This is one of those places where I think LLVM style is T* x but my-preference and at-least-half-the-time-libc++-style is T *x. I'll change line 35 instead.

libcxx/include/__memory_resource/synchronized_pool_resource.h

62

:) I actually have no idea why I did this here. Will fix.

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

97

Yes, that's right; see also

../libcxx/include/__filesystem/filesystem_error.h:  ~filesystem_error() override; // key function

libcxx/include/deque

3027–3035

Here and also in the C++20 Ranges stuff, I've got a habit of "returning to zero" in between unrelated facilities, i.e. I'll nest things like (x)((y))(x) rather than (x(y)x). IMO this makes it easier to keep track of the nesting levels. It's not to the level of a conscious guideline with me, necessarily — it's mostly muscle memory / personal style — but if you explicitly ask me to pick one style or the other, well, I'll still pick this one.
Leaving as-is, at least until a consensus builds against it. ;)

libcxx/lib/abi/CHANGELOG.TXT

26–60

They are; I just was too lazy to dig up the build artifact that lists them. Will fix after a build completes again.

libcxx/src/memory_resource.cpp

18

Copied from experimental/memory_resource.cpp, so it'll work as well as that one does (for better and worse).

127–136

This was originally copy-pasted from src/experimental/... but the early-return rewrite strikes me as harder to read, so I'm keeping it as-is for now.

128

PSA: You flipped the sense of this; you meant != nullptr. Fixed.

213

I agree with your goal, but this guy's caller is unsynchronized_pool_resource::do_deallocate (also in src/), so I don't think it's possible. Not without leaking a lot more stuff into the headers, which conflicts with our other goal of trying to maintain some semblance of ability-to-change-implementation.

427–428

Originally, either because <algorithm> had not been granularized and I didn't want to drag in all of <algorithm> for this (although that's a bad rationale), or because these can deal with mixed types (e.g. min(sizeof(int), 4) whereas _VSTD::min would require casting.
But now: sure, OK.

449–452

FYI, this is the call that requires a cast after switching to _VSTD::min.

[ldionne]

libcxx/docs/Status/Cxx20Issues.csv

236 ↗

(On Diff #398211)

This should be 15.0 since we slipped again.

libcxx/docs/Status/Cxx2bIssues.csv

19 ↗

(On Diff #398211)

Same, 15.0.

libcxx/include/memory_resource

3

We don't include the name of the file anymore!

[ldionne]

libcxx/include/__memory_resource/polymorphic_allocator.h

66

Please use numeric_limits<size_t>::max(). I know they are equivalent, but being close to the Standard is good. I don't mind taking an additional dependency on <limits> at all. This applies elsewhere too.

154–156

This is nitpicky on a style matter, but can you please just do

memory_resource *resource() const noexcept { 
    return __res_;
}

or

memory_resource *resource() const noexcept { return __res_; }

if you really care about saving a line. This applies elsewhere too.

The reason I'm asking this is that we don't use the pattern you have here anywhere else (that I can tell), and I don't want to introduce yet another stylistic inconsistency.

libcxx/include/__memory_resource/synchronized_pool_resource.h

19

Please indent includes when they are nested to near-located #ifs.

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

106–110

It sucks that we have to commit to an ABI right here. It would be great if we could instead store a pimpl, but that would require allocating and that's not a great idea.

libcxx/include/memory_resource

21

Can we get section names like // [mem.res.class]?

libcxx/include/regex

6801

Any reason for not putting those declarations inside the _LIBCPP_BEGIN_NAMESPACE_STD that was closed just above?

6805

Suggestion: you don't have to, but you could move all your new code to std:: instead of _VSTD::.

libcxx/include/string

4593

I think this needs to be guarded by _LIBCPP_HAS_NO_WIDE_CHARACTERS. I would expect this to be caught by the CI.

libcxx/lib/abi/CHANGELOG.TXT

1

[commenting here for lack of better place]

Another thing we'll need to add is availability macros for the newly added dylib functionality. You can look at include/__availability for how that's done.

144

This should be moved under a new section 15.0. Sorry for the churn.

189

You can figure this one out by running ./libcxx/utils/ci/run-buildbot-container locally (requires Docker) and then running the generate-cxx-abilist target on Linux.

libcxx/src/memory_resource.cpp

2

No file name!

14

Please indent nested #includes.

29

Why not remove this altogether?

33

Let's always include this.

54

So when aligned allocation is not supported, we allocate unaligned and try to align the pointer within the allocated buffer. If that works, we're happy, otherwise we fail. I don't understand why that would ever succeed, can you explain?

Also, I've always been a bit confused by the _LIBCPP_HAS_NO_ALIGNED_ALLOCATION situation. It would be worth looking into whether we can just assume that it's provided when we build the library.

112

Is there a reason why you don't just assume that atomics are available? I would do:

#if defined(_LIBCPP_HAS_NO_THREADS)

    <no threading implementation>

#else

    <use atomic>

#endif

libcxx/src/memory_resource_init_helper.h

3

Once you rebase, you'll need to use _LIBCPP_CONSTINIT.

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/resource.pass.cpp

11

Here and everywhere else, you'll need to also add

// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{11|12}}

libcxx/test/support/test_std_memory_resource.h

13–21

Sort?

libcxx/utils/generate_feature_test_macro_components.py

478

Can we add a release note?

[philnik]

Could you add comments in the TODO.txt for all the experimental things that can be removed in libc++17 (hopefully)? I think most experimental headers could be removed.

libcxx/src/memory_resource.cpp

368

It's not a strong feeling, but I'd rather see *= 2 than <<= 1. FWIW it produces the same asm, even at -O0

388–389

471–472

libcxx/test/libcxx/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_piecewise_pair.pass.cpp

43–49

Please reorder the includes

57–59

74–75

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.ctor/copy.pass.cpp

27–32

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.ctor/other_alloc.pass.cpp

29–40

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair.pass.cpp

43

Couldn't we just use a char ptr[sizeof(P)]? Seems overkill to malloc() for that.

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair_rvalue.pass.cpp

40

Please choose PtrT* v or PtrT *v, but not PtrT * v for all that is sacred. I don't want to multiply my types!

libcxx/test/std/utilities/utility/mem.res/mem.res.global/default_resource.pass.cpp

68–72

[mmuetzel]

Is this still being worked on? It would be nice (from a user point of view) if this could be in one of the next releases of libc++.

(I'm sorry for the noise if bumping dists like this is frowned upon.)

[Mordante]

In D89057#3595320, @mmuetzel wrote:

Is this still being worked on? It would be nice (from a user point of view) if this could be in one of the next releases of libc++.

I'm not aware of anybody working on this so I don't expect it to become part of the next libc++ release.
I'm not going to work on it, my todo list has enough items to keep me busy.

[philnik]

In D89057#3597000, @Mordante wrote:

In D89057#3595320, @mmuetzel wrote:

Is this still being worked on? It would be nice (from a user point of view) if this could be in one of the next releases of libc++.

I'm not aware of anybody working on this so I don't expect it to become part of the next libc++ release.
I'm not going to work on it, my todo list has enough items to keep me busy.

I plan to work on it after the LLVM 15 release branch if we don't get things sorted with Arthur until then. I really want to get this into LLVM 16, but who knows how long it will take.

[philnik]

• Rebased
• clang-formatted
• Replaced _VSTD with std

[philnik]

• Try to fix CI

[philnik]

• Fix transitive includes list

[philnik]

poke CI

[ldionne]

LGTM once the CI passes.

libcxx/lib/abi/CHANGELOG.TXT

144

This should be moved to 16.0.

[philnik]

poke CI

[philnik]

• Try to fix CI

[philnik]

• Next try

[philnik]

• Update ABI lists

[philnik]

• Rebased
• Fix transitive_includes tests
• XFAIL macOS

[philnik]

• Generate files

[ldionne]

libcxx/test/libcxx/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/db_deallocate.pass.cpp

2

Please rename this to debug.deallocate.pass.cpp for consistency.

10–12

[philnik]

• Try to fix CI

[philnik]

• Next try

[ldionne]

libcxx/lib/abi/CHANGELOG.TXT

146–147

149–189

[philnik]

• Rebased
• Address comments

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 <__config>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 14
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+
+// [mem.res.class]
+
+_LIBCPP_DIAGNOSTIC_PUSH
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wweak-vtables") // TODO: move destructor into the dylib
+class _LIBCPP_TYPE_VIS memory_resource {
+  static const size_t __max_align = alignof(max_align_t);
+
+public:
+  virtual ~memory_resource() = default;
+
+  _LIBCPP_HIDE_FROM_ABI void* allocate(size_t __bytes, size_t __align = __max_align) {
+    return do_allocate(__bytes, __align);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void deallocate(void* __p, size_t __bytes, size_t __align = __max_align) {
+    do_deallocate(__p, __bytes, __align);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool is_equal(const memory_resource& __other) const noexcept { return do_is_equal(__other); }
+
+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;
+};
+_LIBCPP_DIAGNOSTIC_POP
+
+// [mem.res.eq]
+
+inline _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 {
+  return !(__lhs == __rhs);
+}
+
+// [mem.res.global]
+
+_LIBCPP_FUNC_VIS memory_resource* get_default_resource() noexcept;
+
+_LIBCPP_FUNC_VIS memory_resource* set_default_resource(memory_resource*) noexcept;
+
+_LIBCPP_FUNC_VIS memory_resource* new_delete_resource() noexcept;
+
+_LIBCPP_FUNC_VIS memory_resource* null_memory_resource() noexcept;
+
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 14
+
+#endif // _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H

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 <__config>
+#include <__memory_resource/memory_resource.h>
+#include <cstddef>
+#include <limits>
+#include <new>
+#include <stdexcept>
+#include <tuple>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER > 14
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+
+// [mem.poly.allocator.class]
+
+template <class _ValueType>
+class _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()) {}
+
+  _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(memory_resource* __r) noexcept : __res_(__r) {}
+
+  polymorphic_allocator(const polymorphic_allocator&) = default;
+
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(const polymorphic_allocator<_Tp>& __other) noexcept
+      : __res_(__other.resource()) {}
+
+  polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;
+
+  // [mem.poly.allocator.mem]
+
+  _LIBCPP_HIDE_FROM_ABI _ValueType* allocate(size_t __n) {
+    if (__n > __max_size()) {
+      __throw_bad_array_new_length();
+    }
+    return static_cast<_ValueType*>(__res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType)));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void deallocate(_ValueType* __p, size_t __n) {
+    _LIBCPP_ASSERT(__n <= __max_size(), "deallocate called for size which exceeds max_size()");
+    __res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
+  }
+
+  template <class _Tp, class... _Ts>
+  _LIBCPP_HIDE_FROM_ABI void construct(_Tp* __p, _Ts&&... __args) {
+    std::__user_alloc_construct_impl(
+        typename __uses_alloc_ctor<_Tp, polymorphic_allocator&, _Ts...>::type(),
+        __p,
+        *this,
+        std::forward<_Ts>(__args)...);
+  }
+
+  template <class _T1, class _T2, class... _Args1, class... _Args2>
+  _LIBCPP_HIDE_FROM_ABI void
+  construct(pair<_T1, _T2>* __p, piecewise_construct_t, tuple<_Args1...> __x, tuple<_Args2...> __y) {
+    ::new ((void*)__p) pair<_T1, _T2>(
+        piecewise_construct,
+        __transform_tuple(typename __uses_alloc_ctor< _T1, polymorphic_allocator&, _Args1... >::type(),
+                          std::move(__x),
+                          typename __make_tuple_indices<sizeof...(_Args1)>::type{}),
+        __transform_tuple(typename __uses_alloc_ctor< _T2, polymorphic_allocator&, _Args2... >::type(),
+                          std::move(__y),
+                          typename __make_tuple_indices<sizeof...(_Args2)>::type{}));
+  }
+
+  template <class _T1, class _T2>
+  _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p) {
+    construct(__p, piecewise_construct, tuple<>(), tuple<>());
+  }
+
+  template <class _T1, class _T2, class _Up, class _Vp>
+  _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p, _Up&& __u, _Vp&& __v) {
+    construct(__p,
+              piecewise_construct,
+              std::forward_as_tuple(std::forward<_Up>(__u)),
+              std::forward_as_tuple(std::forward<_Vp>(__v)));
+  }
+
+  template <class _T1, class _T2, class _U1, class _U2>
+  _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p, const pair<_U1, _U2>& __pr) {
+    construct(__p, piecewise_construct, std::forward_as_tuple(__pr.first), std::forward_as_tuple(__pr.second));
+  }
+
+  template <class _T1, class _T2, class _U1, class _U2>
+  _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p, pair<_U1, _U2>&& __pr) {
+    construct(__p,
+              piecewise_construct,
+              std::forward_as_tuple(std::forward<_U1>(__pr.first)),
+              std::forward_as_tuple(std::forward<_U2>(__pr.second)));
+  }
+
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI void destroy(_Tp* __p) {
+    __p->~_Tp();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI polymorphic_allocator select_on_container_copy_construction() const noexcept {
+    return polymorphic_allocator();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI memory_resource* resource() const noexcept { return __res_; }
+
+private:
+  template <class... _Args, size_t... _Is>
+  _LIBCPP_HIDE_FROM_ABI tuple<_Args&&...>
+  __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t, __tuple_indices<_Is...>) {
+    return std::forward_as_tuple(std::get<_Is>(std::move(__t))...);
+  }
+
+  template <class... _Args, size_t... _Is>
+  _LIBCPP_HIDE_FROM_ABI tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>
+  __transform_tuple(integral_constant<int, 1>, tuple<_Args...>&& __t, __tuple_indices<_Is...>) {
+    using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>;
+    return _Tup(allocator_arg, *this, std::get<_Is>(std::move(__t))...);
+  }
+
+  template <class... _Args, size_t... _Is>
+  _LIBCPP_HIDE_FROM_ABI tuple<_Args&&..., polymorphic_allocator&>
+  __transform_tuple(integral_constant<int, 2>, tuple<_Args...>&& __t, __tuple_indices<_Is...>) {
+    using _Tup = tuple<_Args&&..., polymorphic_allocator&>;
+    return _Tup(std::get<_Is>(std::move(__t))..., *this);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI size_t __max_size() const noexcept {
+    return numeric_limits<size_t>::max() / sizeof(value_type);
+  }
+
+  memory_resource* __res_;
+};
+
+// [mem.poly.allocator.eq]
+
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const polymorphic_allocator<_Tp>& __lhs, const polymorphic_allocator<_Up>& __rhs) noexcept {
+  return *__lhs.resource() == *__rhs.resource();
+}
+
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const polymorphic_allocator<_Tp>& __lhs, const polymorphic_allocator<_Up>& __rhs) noexcept {
+  return !(__lhs == __rhs);
+}
+
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 14
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___MEMORY_RESOURCE_POLYMORPHIC_ALLOCATOR_H

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 <__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 > 14
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+
+// [mem.res.pool.overview]
+
+class _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)
+      : synchronized_pool_resource(pool_options(), __upstream) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit synchronized_pool_resource(const pool_options& __opts)
+      : synchronized_pool_resource(__opts, get_default_resource()) {}
+
+  synchronized_pool_resource(const synchronized_pool_resource&) = delete;
+
+  ~synchronized_pool_resource() override = default;
+
+  synchronized_pool_resource& operator=(const synchronized_pool_resource&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI void release() {
+#  if !defined(_LIBCPP_HAS_NO_THREADS)
+    unique_lock<mutex> __lk(__mut_);
+#  endif
+    __unsync_.release();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI memory_resource* upstream_resource() const { return __unsync_.upstream_resource(); }
+
+  _LIBCPP_HIDE_FROM_ABI pool_options options() const { return __unsync_.options(); }
+
+protected:
+  _LIBCPP_HIDE_FROM_ABI void* do_allocate(size_t __bytes, size_t __align) override {
+#  if !defined(_LIBCPP_HAS_NO_THREADS)
+    unique_lock<mutex> __lk(__mut_);
+#  endif
+    return __unsync_.allocate(__bytes, __align);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void do_deallocate(void* __p, size_t __bytes, size_t __align) override {
+#  if !defined(_LIBCPP_HAS_NO_THREADS)
+    unique_lock<mutex> __lk(__mut_);
+#  endif
+    return __unsync_.deallocate(__p, __bytes, __align);
+  }
+
+  bool do_is_equal(const memory_resource& __other) const noexcept override; // key function
+
+private:
+#  if !defined(_LIBCPP_HAS_NO_THREADS)
+  mutex __mut_;
+#  endif
+  unsynchronized_pool_resource __unsync_;
+};
+
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 14
+
+#endif // _LIBCPP___MEMORY_RESOURCE_SYNCHRONIZED_POOL_RESOURCE_H

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 <__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 > 14
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+
+// [mem.res.pool.overview]
+
+class _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) {}
+
+    void __release_ptr(memory_resource* __upstream);
+    void* __do_allocate(memory_resource* __upstream, size_t __bytes, size_t __align);
+    void __do_deallocate(memory_resource* __upstream, void* __p, size_t __bytes, size_t __align);
+  };
+
+  static const size_t __min_blocks_per_chunk = 16;
+  static const size_t __min_bytes_per_chunk  = 1024;
+  static const size_t __max_blocks_per_chunk = (size_t(1) << 20);
+  static const size_t __max_bytes_per_chunk  = (size_t(1) << 30);
+
+  static const int __log2_smallest_block_size      = 3;
+  static const size_t __smallest_block_size        = 8;
+  static const size_t __default_largest_block_size = (size_t(1) << 20);
+  static const size_t __max_largest_block_size     = (size_t(1) << 30);
+
+  size_t __pool_block_size(int __i) const;
+  int __log2_pool_block_size(int __i) const;
+  int __pool_index(size_t __bytes, size_t __align) const;
+
+public:
+  unsynchronized_pool_resource(const pool_options& __opts, memory_resource* __upstream);
+
+  _LIBCPP_HIDE_FROM_ABI unsynchronized_pool_resource()
+      : unsynchronized_pool_resource(pool_options(), get_default_resource()) {}
+
+  _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 ~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_; }
+
+  pool_options options() const;
+
+protected:
+  void* do_allocate(size_t __bytes, size_t __align) override; // key function
+
+  void do_deallocate(void* __p, size_t __bytes, size_t __align) override;
+
+  _LIBCPP_HIDE_FROM_ABI bool do_is_equal(const memory_resource& __other) const _NOEXCEPT override {
+    return &__other == this;
+  }
+
+private:
+  memory_resource* __res_;
+  __adhoc_pool __adhoc_pool_;
+  __fixed_pool* __fixed_pools_;
+  int __num_fixed_pools_;
+  uint32_t __options_max_blocks_per_chunk_;
+};
+
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 14
+
+#endif // _LIBCPP___MEMORY_RESOURCE_UNSYNCHRONIZED_POOL_RESOURCE_H

libcxx/include/deque

 #include <__format/enable_insertable.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/temp_value.h>
 #include <__memory/unique_ptr.h>
+#include <__memory_resource/polymorphic_allocator.h>
 #include <__split_buffer>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>

 template <>
 inline constexpr bool __format::__enable_insertable<std::deque<wchar_t>> = true;
 #endif
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr {
+template <class _ValueT>
+using deque = 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>
 #  include <functional>
 #  include <iterator>
 #endif
 
 #endif // _LIBCPP_DEQUE

libcxx/include/memory_resource

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_MEMORY_RESOURCE
+#define _LIBCPP_MEMORY_RESOURCE
+
+/**
+    memory_resource synopsis
+
+// C++17
+
+namespace std::pmr {
+
+  class memory_resource;
+
+  bool operator==(const memory_resource& a,
+                  const memory_resource& b) noexcept;
+  bool operator!=(const memory_resource& a,
+                  const memory_resource& b) noexcept;
+
+  template <class Tp> class polymorphic_allocator;
+
+  template <class T1, class T2>
+  bool operator==(const polymorphic_allocator<T1>& a,
+                  const polymorphic_allocator<T2>& b) noexcept;
+  template <class T1, class T2>
+  bool operator!=(const polymorphic_allocator<T1>& a,
+                  const polymorphic_allocator<T2>& b) noexcept;
+
+  // Global memory resources
+  memory_resource* set_default_resource(memory_resource* r) noexcept;
+  memory_resource* get_default_resource() noexcept;
+  memory_resource* new_delete_resource() noexcept;
+  memory_resource* null_memory_resource() noexcept;
+
+  // Pool resource classes
+  struct pool_options;
+  class synchronized_pool_resource;
+  class unsynchronized_pool_resource;
+  class monotonic_buffer_resource;
+
+} // namespace std::pmr
+
+ */
+
+#include <__config>
+#include <__memory_resource/memory_resource.h>
+#include <__memory_resource/monotonic_buffer_resource.h>
+#include <__memory_resource/polymorphic_allocator.h>
+#include <__memory_resource/pool_options.h>
+#include <__memory_resource/synchronized_pool_resource.h>
+#include <__memory_resource/unsynchronized_pool_resource.h>
+#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#endif /* _LIBCPP_MEMORY_RESOURCE */

libcxx/include/regex

 
 #include <__algorithm/find.h>
 #include <__algorithm/search.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
+#include <__memory_resource/polymorphic_allocator.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <deque>
 #include <stdexcept>
 #include <string>
 #include <vector>
 #include <version>
regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
     return __r;
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _ST, _SA>
 regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
               const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT, _ST, _SA> __r;
     _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
                         __fmt, __flags);
     return __r;
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT>
 regex_replace(const _CharT* __s,
               const basic_regex<_CharT, _Traits>& __e,
regex_replace(const _CharT* __s,
     _VSTD::regex_replace(back_inserter(__r), __s,
                         __s + char_traits<_CharT>::length(__s), __e,
                         __fmt, __flags);
     return __r;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr {
+template <class _BidirT>
+using match_results = std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>;
+
+using cmatch  = match_results<const char*>;
+using wcmatch = match_results<const wchar_t*>;
+using smatch  = match_results<std::pmr::string::const_iterator>;
+using wsmatch = match_results<std::pmr::wstring::const_iterator>;
+} // namespace pmr
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_REGEX

libcxx/include/string

 #include <__iterator/wrap_iter.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
+#include <__memory_resource/polymorphic_allocator.h>
 #include <__string/char_traits.h>
 #include <__string/extern_template_lists.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/noexcept_move_assign_container.h>
 #include <__utility/auto_cast.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>

 
 template<class _CharT, class _Traits, class _Allocator>
 bool
 basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const
 {
     return data() <= std::__to_address(__i->base()) &&
            std::__to_address(__i->base()) < data() + size();
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 bool
 basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const
 {
     return data() < std::__to_address(__i->base()) &&
            std::__to_address(__i->base()) <= data() + size();
 }
 

 inline constexpr bool __format::__enable_insertable<std::basic_string<wchar_t>> = true;
 #endif
 #endif
 
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr {
+template <class _CharT, class _TraitsT = std::char_traits<_CharT>>
+using basic_string = std::basic_string<_CharT, _TraitsT, polymorphic_allocator<_CharT>>;
+
+using string    = basic_string<char>;
+using u16string = basic_string<char16_t>;
+using u32string = basic_string<char32_t>;
+using wstring   = basic_string<wchar_t>;
+} // namespace pmr
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #  include <iterator>
 #  include <new>
 #  include <typeinfo>
 #  include <utility>
 #  include <vector>
 #endif
 
 #endif // _LIBCPP_STRING

libcxx/lib/abi/CHANGELOG.TXT

 ABI Changelog
 ==============
 This changelog contains information about ABI changes in libc++. Specifically
 the addition and deletion of symbols from the libc++ dylib.
 
 Each entry should start with the revision number followed by a description of
 the change. The entry should contain a summary of the ABI changes made,
 including what symbols were added, removed, or changed.
 
 To generate a summary, re-generate the new ABI list using the
 `generate-cxx-abilist` target, and look at the diff.
 
 New entries should be added directly below the "Version" header.
 
 ------------
 Version 15.0
 ------------
 
 * f1c30135417f - [libc++] Drop the legacy debug mode symbols by default
 
   This commit removed symbols implementing debug mode in the non-debug
   configuration of the library. Using the debug mode now requires a
   differently-configured version of libc++. This is technically an ABI
   break, however any user having been using the debug mode support previously
   was already at risk of non-benign ODR violations, and in practice we
   never found it to work reliably.
 
   All platforms
   -------------
   Symbol removed: _ZNKSt3__111__libcpp_db15__decrementableEPKv
   Symbol removed: _ZNKSt3__111__libcpp_db15__find_c_from_iEPv
   Symbol removed: _ZNKSt3__111__libcpp_db15__subscriptableEPKvl
   Symbol removed: _ZNKSt3__111__libcpp_db17__dereferenceableEPKv
   Symbol removed: _ZNKSt3__111__libcpp_db17__find_c_and_lockEPv
   Symbol removed: _ZNKSt3__111__libcpp_db22__less_than_comparableEPKvS2_
   Symbol removed: _ZNKSt3__111__libcpp_db6unlockEv
   Symbol removed: _ZNKSt3__111__libcpp_db8__find_cEPv
   Symbol removed: _ZNKSt3__111__libcpp_db9__addableEPKvl
   Symbol removed: _ZNKSt3__119__libcpp_debug_info4whatEv
   Symbol removed: _ZNSt3__111__libcpp_db10__insert_cEPvPFPNS_8__c_nodeES1_S1_S3_E
   Symbol removed: _ZNSt3__111__libcpp_db10__insert_iEPv
   Symbol removed: _ZNSt3__111__libcpp_db11__insert_icEPvPKv
   Symbol removed: _ZNSt3__111__libcpp_db15__iterator_copyEPvPKv
   Symbol removed: _ZNSt3__111__libcpp_db16__invalidate_allEPv
   Symbol removed: _ZNSt3__111__libcpp_db4swapEPvS1_
   Symbol removed: _ZNSt3__111__libcpp_db9__erase_cEPv
   Symbol removed: _ZNSt3__111__libcpp_db9__erase_iEPv
   Symbol removed: _ZNSt3__111__libcpp_dbC1Ev
   Symbol removed: _ZNSt3__111__libcpp_dbC2Ev
   Symbol removed: _ZNSt3__111__libcpp_dbD1Ev
   Symbol removed: _ZNSt3__111__libcpp_dbD2Ev
   Symbol removed: _ZNSt3__114__get_const_dbEv
   Symbol removed: _ZNSt3__123__libcpp_debug_functionE
   Symbol removed: _ZNSt3__127__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE
   Symbol removed: _ZNSt3__129__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE
   Symbol removed: _ZNSt3__18__c_node5__addEPNS_8__i_nodeE
   Symbol removed: _ZNSt3__18__c_nodeD0Ev
   Symbol removed: _ZNSt3__18__c_nodeD1Ev
   Symbol removed: _ZNSt3__18__c_nodeD2Ev
   Symbol removed: _ZNSt3__18__get_dbEv
   Symbol removed: _ZNSt3__18__i_nodeD1Ev
   Symbol removed: _ZNSt3__18__i_nodeD2Ev
   Symbol removed: _ZTINSt3__18__c_nodeE
   Symbol removed: _ZTSNSt3__18__c_nodeE
   Symbol removed: _ZTVNSt3__18__c_nodeE
 
 * b0fd9497af6d, 7de5aca84c54 and XXXXXXXX - [libc++] Add a lightweight overridable assertion handler
 
* 434dc0a5bcae - [libc++] Always define a key function for std::bad_function_call in the dylib
   Symbol added: _ZTINSt3__117bad_function_callE
   Symbol added: _ZTSNSt3__117bad_function_callE
   Symbol added: _ZTVNSt3__117bad_function_callE
 
   <arch>-unknown-linux-gnu
   ------------------------
   Added dependency on symbol: _ZNKSt9exception4whatEv
 
+* [libc++] [C++17] Implement <memory_resource>.
+
+  This commit adds <memory_resource> to the shared library, similarly to how
+  <filesystem> was added in r356518 below.
+
+  x86_64-apple-apple-darwin
+  -------------------------
+    Symbol added: __ZNKSt3__13pmr26synchronized_pool_resource11do_is_equalERKNS0_15memory_resourceE
+    Symbol added: __ZNKSt3__13pmr28unsynchronized_pool_resource12__pool_indexEmm
+    Symbol added: __ZNKSt3__13pmr28unsynchronized_pool_resource17__pool_block_sizeEi
+    Symbol added: __ZNKSt3__13pmr28unsynchronized_pool_resource22__log2_pool_block_sizeEi
+    Symbol added: __ZNKSt3__13pmr28unsynchronized_pool_resource7optionsEv
+    Symbol added: __ZNSt3__13pmr19new_delete_resourceEv
+    Symbol added: __ZNSt3__13pmr20get_default_resourceEv
+    Symbol added: __ZNSt3__13pmr20null_memory_resourceEv
+    Symbol added: __ZNSt3__13pmr20set_default_resourceEPNS0_15memory_resourceE
+    Symbol added: __ZNSt3__13pmr25monotonic_buffer_resource11do_allocateEmm
+    Symbol added: __ZNSt3__13pmr25monotonic_buffer_resource14__chunk_footer25__try_allocate_from_chunkEmm
+    Symbol added: __ZNSt3__13pmr25monotonic_buffer_resource20__initial_descriptor25__try_allocate_from_chunkEmm
+    Symbol added: __ZNSt3__13pmr28unsynchronized_pool_resource11do_allocateEmm
+    Symbol added: __ZNSt3__13pmr28unsynchronized_pool_resource12__adhoc_pool13__do_allocateEPNS0_15memory_resourceEmm
+    Symbol added: __ZNSt3__13pmr28unsynchronized_pool_resource12__adhoc_pool13__release_ptrEPNS0_15memory_resourceE
+    Symbol added: __ZNSt3__13pmr28unsynchronized_pool_resource12__adhoc_pool15__do_deallocateEPNS0_15memory_resourceEPvmm
+    Symbol added: __ZNSt3__13pmr28unsynchronized_pool_resource13do_deallocateEPvmm
+    Symbol added: __ZNSt3__13pmr28unsynchronized_pool_resource7releaseEv
+    Symbol added: __ZNSt3__13pmr28unsynchronized_pool_resourceC1ERKNS0_12pool_optionsEPNS0_15memory_resourceE
+    Symbol added: __ZNSt3__13pmr28unsynchronized_pool_resourceC2ERKNS0_12pool_optionsEPNS0_15memory_resourceE
+    Symbol added: __ZTINSt3__13pmr15memory_resourceE
+    Symbol added: __ZTINSt3__13pmr25monotonic_buffer_resourceE
+    Symbol added: __ZTINSt3__13pmr26__null_memory_resource_impE
+    Symbol added: __ZTINSt3__13pmr26synchronized_pool_resourceE
+    Symbol added: __ZTINSt3__13pmr28unsynchronized_pool_resourceE
+    Symbol added: __ZTINSt3__13pmr32__new_delete_memory_resource_impE
+    Symbol added: __ZTSNSt3__13pmr15memory_resourceE
+    Symbol added: __ZTSNSt3__13pmr25monotonic_buffer_resourceE
+    Symbol added: __ZTSNSt3__13pmr26__null_memory_resource_impE
+    Symbol added: __ZTSNSt3__13pmr26synchronized_pool_resourceE
+    Symbol added: __ZTSNSt3__13pmr28unsynchronized_pool_resourceE
+    Symbol added: __ZTSNSt3__13pmr32__new_delete_memory_resource_impE
+    Symbol added: __ZTVNSt3__13pmr25monotonic_buffer_resourceE
+    Symbol added: __ZTVNSt3__13pmr26synchronized_pool_resourceE
+    Symbol added: __ZTVNSt3__13pmr28unsynchronized_pool_resourceE
+
+  x86_64-unknown-linux-gnu
+  ------------------------
+  Symbol added:
+
 ------------
 Version 12.0
 ------------
 
 * a984dcaf7c21 - [libc++] [P0482] [C++20] Implement missing bits for codecvt and codecvt_byname.
 
   This commit added new instantiations with char8_t for classes codecvt and
   codecvt_byname in <locale> in the library.

libcxx/src/memory_resource.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
+//
+//===----------------------------------------------------------------------===//
+
+#include <memory>
+#include <memory_resource>
+
+#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
+#  include <atomic>
+#elif !defined(_LIBCPP_HAS_NO_THREADS)
+#  include <mutex>
+#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#    pragma comment(lib, "pthread")
+#  endif
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+
+// memory_resource
+
+//memory_resource::~memory_resource() {}
+
+// new_delete_resource()
+
+#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
+static bool is_aligned_to(void* ptr, size_t align) {
+  void* p2     = ptr;
+  size_t space = 1;
+  void* result = std::align(align, 1, p2, space);
+  return (result == ptr);
+}
+#endif
+
+class _LIBCPP_TYPE_VIS __new_delete_memory_resource_imp : public memory_resource {
+  void* do_allocate(size_t bytes, size_t align) override {
+#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
+    return std::__libcpp_allocate(bytes, align);
+#else
+    if (bytes == 0)
+      bytes = 1;
+    void* result = std::__libcpp_allocate(bytes, align);
+    if (!is_aligned_to(result, align)) {
+      std::__libcpp_deallocate(result, bytes, align);
+      __throw_bad_alloc();
+    }
+    return result;
+#endif
+  }
+
+  void do_deallocate(void* p, size_t bytes, size_t align) override { std::__libcpp_deallocate(p, bytes, align); }
+
+  bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
+};
+
+// null_memory_resource()
+
+class _LIBCPP_TYPE_VIS __null_memory_resource_imp : public memory_resource {
+  void* do_allocate(size_t, size_t) override { __throw_bad_alloc(); }
+  void do_deallocate(void*, size_t, size_t) override {}
+  bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
+};
+
+namespace {
+
+union ResourceInitHelper {
+  struct {
+    __new_delete_memory_resource_imp new_delete_res;
+    __null_memory_resource_imp null_res;
+  } resources;
+  char dummy;
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 ResourceInitHelper() : resources() {}
+  ~ResourceInitHelper() {}
+};
+
+// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
+// attribute with a value that's reserved for the implementation (we're the implementation).
+#include "memory_resource_init_helper.h"
+
+} // end namespace
+
+memory_resource* new_delete_resource() noexcept { return &res_init.resources.new_delete_res; }
+
+memory_resource* null_memory_resource() noexcept { return &res_init.resources.null_res; }
+
+// default_memory_resource()
+
+static memory_resource* __default_memory_resource(bool set = false, memory_resource* new_res = nullptr) noexcept {
+#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
+  static constinit atomic<memory_resource*> __res{&res_init.resources.new_delete_res};
+  if (set) {
+    new_res = new_res ? new_res : new_delete_resource();
+    // TODO: Can a weaker ordering be used?
+    return std::atomic_exchange_explicit(&__res, new_res, memory_order_acq_rel);
+  } else {
+    return std::atomic_load_explicit(&__res, memory_order_acquire);
+  }
+#elif !defined(_LIBCPP_HAS_NO_THREADS)
+  static constinit memory_resource* res = &res_init.resources.new_delete_res;
+  static mutex res_lock;
+  if (set) {
+    new_res = new_res ? new_res : new_delete_resource();
+    lock_guard<mutex> guard(res_lock);
+    memory_resource* old_res = res;
+    res = new_res;
+    return old_res;
+  } else {
+    lock_guard<mutex> guard(res_lock);
+    return res;
+  }
+#else
+  static constinit memory_resource* res = &res_init.resources.new_delete_res;
+  if (set) {
+    new_res                  = new_res ? new_res : new_delete_resource();
+    memory_resource* old_res = res;
+    res                      = new_res;
+    return old_res;
+  } else {
+    return res;
+  }
+#endif
+}
+
+memory_resource* get_default_resource() noexcept { return __default_memory_resource(); }
+
+memory_resource* set_default_resource(memory_resource* __new_res) noexcept {
+  return __default_memory_resource(true, __new_res);
+}
+
+// 23.12.5, mem.res.pool
+
+static size_t roundup(size_t count, size_t alignment) {
+  size_t mask = alignment - 1;
+  return (count + mask) & ~mask;
+}
+
+struct unsynchronized_pool_resource::__adhoc_pool::__chunk_footer {
+  __chunk_footer* __next_;
+  char* __start_;
+  size_t __align_;
+  size_t __allocation_size() { return (reinterpret_cast<char*>(this) - __start_) + sizeof(*this); }
+};
+
+void unsynchronized_pool_resource::__adhoc_pool::__release_ptr(memory_resource* upstream) {
+  while (__first_ != nullptr) {
+    __chunk_footer* next = __first_->__next_;
+    upstream->deallocate(__first_->__start_, __first_->__allocation_size(), __first_->__align_);
+    __first_ = next;
+  }
+}
+
+void* unsynchronized_pool_resource::__adhoc_pool::__do_allocate(memory_resource* upstream, size_t bytes, size_t align) {
+  const size_t footer_size  = sizeof(__chunk_footer);
+  const size_t footer_align = alignof(__chunk_footer);
+
+  if (align < footer_align)
+    align = footer_align;
+
+  size_t aligned_capacity = roundup(bytes, footer_align) + footer_size;
+
+  void* result = upstream->allocate(aligned_capacity, align);
+
+  __chunk_footer* h = (__chunk_footer*)((char*)result + aligned_capacity - footer_size);
+  h->__next_        = __first_;
+  h->__start_       = (char*)result;
+  h->__align_       = align;
+  __first_          = h;
+  return result;
+}
+
+void unsynchronized_pool_resource::__adhoc_pool::__do_deallocate(
+    memory_resource* upstream, void* p, size_t bytes, size_t align) {
+  _LIBCPP_ASSERT(__first_ != nullptr, "deallocating a block that was not allocated with this allocator");
+  if (__first_->__start_ == p) {
+    __chunk_footer* next = __first_->__next_;
+    upstream->deallocate(p, __first_->__allocation_size(), __first_->__align_);
+    __first_ = next;
+  } else {
+    for (__chunk_footer* h = __first_; h->__next_ != nullptr; h = h->__next_) {
+      if (h->__next_->__start_ == p) {
+        __chunk_footer* next = h->__next_->__next_;
+        upstream->deallocate(p, h->__next_->__allocation_size(), h->__next_->__align_);
+        h->__next_ = next;
+        return;
+      }
+    }
+    _LIBCPP_ASSERT(false, "deallocating a block that was not allocated with this allocator");
+  }
+}
+
+class unsynchronized_pool_resource::__fixed_pool {
+  struct __chunk_footer {
+    __chunk_footer* __next_;
+    char* __start_;
+    size_t __align_;
+    size_t __allocation_size() { return (reinterpret_cast<char*>(this) - __start_) + sizeof(*this); }
+  };
+
+  struct __vacancy_header {
+    __vacancy_header* __next_vacancy_;
+  };
+
+  __chunk_footer* __first_chunk_     = nullptr;
+  __vacancy_header* __first_vacancy_ = nullptr;
+
+public:
+  explicit __fixed_pool() = default;
+
+  void __release_ptr(memory_resource* upstream) {
+    __first_vacancy_ = nullptr;
+    while (__first_chunk_ != nullptr) {
+      __chunk_footer* next = __first_chunk_->__next_;
+      upstream->deallocate(__first_chunk_->__start_, __first_chunk_->__allocation_size(), __first_chunk_->__align_);
+      __first_chunk_ = next;
+    }
+  }
+
+  void* __try_allocate_from_vacancies() {
+    if (__first_vacancy_ != nullptr) {
+      void* result     = __first_vacancy_;
+      __first_vacancy_ = __first_vacancy_->__next_vacancy_;
+      return result;
+    }
+    return nullptr;
+  }
+
+  void* __allocate_in_new_chunk(memory_resource* upstream, size_t block_size, size_t chunk_size) {
+    _LIBCPP_ASSERT(chunk_size % block_size == 0, "");
+    static_assert(__default_alignment >= alignof(std::max_align_t), "");
+    static_assert(__default_alignment >= alignof(__chunk_footer), "");
+    static_assert(__default_alignment >= alignof(__vacancy_header), "");
+
+    const size_t footer_size  = sizeof(__chunk_footer);
+    const size_t footer_align = alignof(__chunk_footer);
+
+    size_t aligned_capacity = roundup(chunk_size, footer_align) + footer_size;
+
+    void* result = upstream->allocate(aligned_capacity, __default_alignment);
+
+    __chunk_footer* h = (__chunk_footer*)((char*)result + aligned_capacity - footer_size);
+    h->__next_        = __first_chunk_;
+    h->__start_       = (char*)result;
+    h->__align_       = __default_alignment;
+    __first_chunk_    = h;
+
+    if (chunk_size > block_size) {
+      __vacancy_header* last_vh = this->__first_vacancy_;
+      for (size_t i = block_size; i != chunk_size; i += block_size) {
+        __vacancy_header* vh = (__vacancy_header*)((char*)result + i);
+        vh->__next_vacancy_  = last_vh;
+        last_vh              = vh;
+      }
+      this->__first_vacancy_ = last_vh;
+    }
+    return result;
+  }
+
+  void __evacuate(void* p) {
+    __vacancy_header* vh = (__vacancy_header*)(p);
+    vh->__next_vacancy_  = __first_vacancy_;
+    __first_vacancy_     = vh;
+  }
+
+  size_t __previous_chunk_size_in_bytes() const { return __first_chunk_ ? __first_chunk_->__allocation_size() : 0; }
+
+  static const size_t __default_alignment = alignof(max_align_t);
+};
+
+size_t unsynchronized_pool_resource::__pool_block_size(int i) const { return size_t(1) << __log2_pool_block_size(i); }
+
+int unsynchronized_pool_resource::__log2_pool_block_size(int i) const { return (i + __log2_smallest_block_size); }
+
+int unsynchronized_pool_resource::__pool_index(size_t bytes, size_t align) const {
+  if (align > alignof(std::max_align_t) || bytes > (size_t(1) << __num_fixed_pools_))
+    return __num_fixed_pools_;
+  else {
+    int i = 0;
+    bytes = (bytes > align) ? bytes : align;
+    bytes -= 1;
+    bytes >>= __log2_smallest_block_size;
+    while (bytes != 0) {
+      bytes >>= 1;
+      i += 1;
+    }
+    return i;
+  }
+}
+
+unsynchronized_pool_resource::unsynchronized_pool_resource(const pool_options& opts, memory_resource* upstream)
+    : __res_(upstream), __fixed_pools_(nullptr) {
+  size_t largest_block_size;
+  if (opts.largest_required_pool_block == 0)
+    largest_block_size = __default_largest_block_size;
+  else if (opts.largest_required_pool_block < __smallest_block_size)
+    largest_block_size = __smallest_block_size;
+  else if (opts.largest_required_pool_block > __max_largest_block_size)
+    largest_block_size = __max_largest_block_size;
+  else
+    largest_block_size = opts.largest_required_pool_block;
+
+  if (opts.max_blocks_per_chunk == 0)
+    __options_max_blocks_per_chunk_ = __max_blocks_per_chunk;
+  else if (opts.max_blocks_per_chunk < __min_blocks_per_chunk)
+    __options_max_blocks_per_chunk_ = __min_blocks_per_chunk;
+  else if (opts.max_blocks_per_chunk > __max_blocks_per_chunk)
+    __options_max_blocks_per_chunk_ = __max_blocks_per_chunk;
+  else
+    __options_max_blocks_per_chunk_ = opts.max_blocks_per_chunk;
+
+  __num_fixed_pools_ = 1;
+  size_t capacity    = __smallest_block_size;
+  while (capacity < largest_block_size) {
+    capacity <<= 1;
+    __num_fixed_pools_ += 1;
+  }
+}
+
+pool_options unsynchronized_pool_resource::options() const {
+  pool_options p;
+  p.max_blocks_per_chunk        = __options_max_blocks_per_chunk_;
+  p.largest_required_pool_block = __pool_block_size(__num_fixed_pools_ - 1);
+  return p;
+}
+
+void unsynchronized_pool_resource::release() {
+  __adhoc_pool_.__release_ptr(__res_);
+  if (__fixed_pools_ != nullptr) {
+    const int n = __num_fixed_pools_;
+    for (int i = 0; i < n; ++i)
+      __fixed_pools_[i].__release_ptr(__res_);
+    __res_->deallocate(__fixed_pools_, __num_fixed_pools_ * sizeof(__fixed_pool), alignof(__fixed_pool));
+    __fixed_pools_ = nullptr;
+  }
+}
+
+void* unsynchronized_pool_resource::do_allocate(size_t bytes, size_t align) {
+  // A pointer to allocated storage (6.6.4.4.1) with a size of at least bytes.
+  // The size and alignment of the allocated memory shall meet the requirements for
+  // a class derived from memory_resource (23.12).
+  // If the pool selected for a block of size bytes is unable to satisfy the memory request
+  // from its own internal data structures, it will call upstream_resource()->allocate()
+  // to obtain more memory. If bytes is larger than that which the largest pool can handle,
+  // then memory will be allocated using upstream_resource()->allocate().
+
+  int i = __pool_index(bytes, align);
+  if (i == __num_fixed_pools_)
+    return __adhoc_pool_.__do_allocate(__res_, bytes, align);
+  else {
+    if (__fixed_pools_ == nullptr) {
+      __fixed_pools_ =
+          (__fixed_pool*)__res_->allocate(__num_fixed_pools_ * sizeof(__fixed_pool), alignof(__fixed_pool));
+      __fixed_pool* first = __fixed_pools_;
+      __fixed_pool* last  = __fixed_pools_ + __num_fixed_pools_;
+      for (__fixed_pool* pool = first; pool != last; ++pool)
+        ::new ((void*)pool) __fixed_pool;
+    }
+    void* result = __fixed_pools_[i].__try_allocate_from_vacancies();
+    if (result == nullptr) {
+      auto min = [](size_t a, size_t b) { return a < b ? a : b; };
+      auto max = [](size_t a, size_t b) { return a < b ? b : a; };
+
+      size_t prev_chunk_size_in_bytes  = __fixed_pools_[i].__previous_chunk_size_in_bytes();
+      size_t prev_chunk_size_in_blocks = prev_chunk_size_in_bytes >> __log2_pool_block_size(i);
+
+      size_t chunk_size_in_blocks;
+
+      if (prev_chunk_size_in_blocks == 0) {
+        size_t min_blocks_per_chunk = max(__min_bytes_per_chunk >> __log2_pool_block_size(i), __min_blocks_per_chunk);
+        chunk_size_in_blocks        = min_blocks_per_chunk;
+      } else {
+        static_assert(__max_bytes_per_chunk <= SIZE_MAX - (__max_bytes_per_chunk / 4), "unsigned overflow is possible");
+        chunk_size_in_blocks = prev_chunk_size_in_blocks + (prev_chunk_size_in_blocks / 4);
+      }
+
+      size_t max_blocks_per_chunk =
+          min((__max_bytes_per_chunk >> __log2_pool_block_size(i)),
+              min(__max_blocks_per_chunk, __options_max_blocks_per_chunk_));
+      if (chunk_size_in_blocks > max_blocks_per_chunk)
+        chunk_size_in_blocks = max_blocks_per_chunk;
+
+      size_t block_size = __pool_block_size(i);
+
+      size_t chunk_size_in_bytes = (chunk_size_in_blocks << __log2_pool_block_size(i));
+      result                     = __fixed_pools_[i].__allocate_in_new_chunk(__res_, block_size, chunk_size_in_bytes);
+    }
+    return result;
+  }
+}
+
+void unsynchronized_pool_resource::do_deallocate(void* p, size_t bytes, size_t align) {
+  // Returns the memory at p to the pool. It is unspecified if,
+  // or under what circumstances, this operation will result in
+  // a call to upstream_resource()->deallocate().
+
+  int i = __pool_index(bytes, align);
+  if (i == __num_fixed_pools_)
+    return __adhoc_pool_.__do_deallocate(__res_, p, bytes, align);
+  else {
+    _LIBCPP_ASSERT(__fixed_pools_ != nullptr, "deallocating a block that was not allocated with this allocator");
+    __fixed_pools_[i].__evacuate(p);
+  }
+}
+
+bool synchronized_pool_resource::do_is_equal(const memory_resource& other) const noexcept { return &other == this; }
+
+// 23.12.6, mem.res.monotonic.buffer
+
+void* monotonic_buffer_resource::__initial_descriptor::__try_allocate_from_chunk(size_t bytes, size_t align) {
+  if (!__cur_)
+    return nullptr;
+  void* new_ptr       = static_cast<void*>(__cur_);
+  size_t new_capacity = (__end_ - __cur_);
+  void* aligned_ptr   = std::align(align, bytes, new_ptr, new_capacity);
+  if (aligned_ptr != nullptr)
+    __cur_ = static_cast<char*>(new_ptr) + bytes;
+  return aligned_ptr;
+}
+
+void* monotonic_buffer_resource::__chunk_footer::__try_allocate_from_chunk(size_t bytes, size_t align) {
+  void* new_ptr       = static_cast<void*>(__cur_);
+  size_t new_capacity = (reinterpret_cast<char*>(this) - __cur_);
+  void* aligned_ptr   = std::align(align, bytes, new_ptr, new_capacity);
+  if (aligned_ptr != nullptr)
+    __cur_ = static_cast<char*>(new_ptr) + bytes;
+  return aligned_ptr;
+}
+
+void* monotonic_buffer_resource::do_allocate(size_t bytes, size_t align) {
+  const size_t footer_size  = sizeof(__chunk_footer);
+  const size_t footer_align = alignof(__chunk_footer);
+
+  auto previous_allocation_size = [&]() {
+    if (__chunks_ != nullptr)
+      return __chunks_->__allocation_size();
+
+    size_t newsize = (__initial_.__start_ != nullptr) ? (__initial_.__end_ - __initial_.__start_) : __initial_.__size_;
+
+    return roundup(newsize, footer_align) + footer_size;
+  };
+
+  if (void* result = __initial_.__try_allocate_from_chunk(bytes, align))
+    return result;
+  if (__chunks_ != nullptr) {
+    if (void* result = __chunks_->__try_allocate_from_chunk(bytes, align))
+      return result;
+  }
+
+  // Allocate a brand-new chunk.
+
+  if (align < footer_align)
+    align = footer_align;
+
+  size_t aligned_capacity  = roundup(bytes, footer_align) + footer_size;
+  size_t previous_capacity = previous_allocation_size();
+
+  if (aligned_capacity <= previous_capacity) {
+    size_t newsize   = 2 * (previous_capacity - footer_size);
+    aligned_capacity = roundup(newsize, footer_align) + footer_size;
+  }
+
+  char* start            = (char*)__res_->allocate(aligned_capacity, align);
+  __chunk_footer* footer = (__chunk_footer*)(start + aligned_capacity - footer_size);
+  footer->__next_        = __chunks_;
+  footer->__start_       = start;
+  footer->__cur_         = start;
+  footer->__align_       = align;
+  __chunks_              = footer;
+
+  return __chunks_->__try_allocate_from_chunk(bytes, align);
+}
+
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/src/memory_resource_init_helper.h

+#pragma GCC system_header
+static constinit ResourceInitHelper res_init _LIBCPP_INIT_PRIORITY_MAX;

libcxx/test/libcxx/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_piecewise_pair.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++98, c++03, c++11, c++14
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U1, class U2, class ...Args1, class ...Args2>
+// void polymorphic_allocator<T>::construct(pair<T1, T2>*, piecewise_construct_t
+//                                          tuple<Args1...> x, tuple<Args2...>)
+
+// The stardard specifiers a tranformation to uses-allocator construction as
+// follows:
+//  - If uses_allocator_v<T1,memory_resource*> is false and
+//      is_constructible_v<T,Args1...> is true, then xprime is x.
+//  - Otherwise, if uses_allocator_v<T1,memory_resource*> is true and
+//      is_constructible_v<T1,allocator_arg_t,memory_resource*,Args1...> is true,
+//      then xprime is
+//      tuple_cat(make_tuple(allocator_arg, this->resource()), std::move(x)).
+//  - Otherwise, if uses_allocator_v<T1,memory_resource*> is true and
+//      is_constructible_v<T1,Args1...,memory_resource*> is true, then xprime is
+//      tuple_cat(std::move(x), make_tuple(this->resource())).
+//  - Otherwise the program is ill formed.
+//
+// The use of "xprime = tuple_cat(..., std::move(x), ...)" causes all of the
+// objects in 'x' to be copied into 'xprime'. If 'x' contains any types which
+// are stored by value this causes an unessary copy to occur. To prevent this
+//  libc++ changes this call into
+// "xprime = forward_as_tuple(..., std::get<Idx>(std::move(x))..., ...)".
+// 'xprime' contains references to the values in 'x' instead of copying them.
+
+// This test checks the number of copies incurred to the elements in
+// 'tuple<Args1...>' and 'tuple<Args2...>'.
+
+#include <memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "test_std_memory_resource.h"
+
+template <class T>
+struct TestHarness {
+  TestResource R;
+  std::pmr::memory_resource* M         = &R;
+  std::pmr::polymorphic_allocator<T> A = M;
+  bool constructed                     = false;
+  T* ptr;
+
+  TestHarness() : ptr(A.allocate(1)) {}
+
+  template <class... Args>
+  void construct(Args&&... args) {
+    A.construct(ptr, std::forward<Args>(args)...);
+    constructed = true;
+  }
+
+  ~TestHarness() {
+    if (constructed)
+      A.destroy(ptr);
+    A.deallocate(ptr, 1);
+  }
+};
+
+struct CountCopies {
+  int count;
+  CountCopies() : count(0) {}
+  CountCopies(CountCopies const& o) : count(o.count + 1) {}
+};
+
+struct CountCopiesAllocV1 {
+  typedef std::pmr::polymorphic_allocator<char> allocator_type;
+  std::pmr::memory_resource* alloc;
+  int count;
+  CountCopiesAllocV1() : alloc(nullptr), count(0) {}
+  CountCopiesAllocV1(std::allocator_arg_t, allocator_type const& a, CountCopiesAllocV1 const& o)
+      : alloc(a.resource()), count(o.count + 1) {}
+
+  CountCopiesAllocV1(CountCopiesAllocV1 const& o) : count(o.count + 1) {}
+};
+
+struct CountCopiesAllocV2 {
+  typedef std::pmr::polymorphic_allocator<char> allocator_type;
+  std::pmr::memory_resource* alloc;
+  int count;
+  CountCopiesAllocV2() : alloc(nullptr), count(0) {}
+  CountCopiesAllocV2(CountCopiesAllocV2 const& o, allocator_type const& a) : alloc(a.resource()), count(o.count + 1) {}
+
+  CountCopiesAllocV2(CountCopiesAllocV2 const& o) : count(o.count + 1) {}
+};
+
+int main(int, char**) {
+  {
+    using T = CountCopies;
+    using U = CountCopiesAllocV1;
+    using P = std::pair<T, U>;
+
+    std::tuple<T> t1;
+    std::tuple<U> t2;
+
+    TestHarness<P> h;
+    h.construct(std::piecewise_construct, t1, t2);
+    P const& p = *h.ptr;
+    assert(p.first.count == 2);
+    assert(p.second.count == 2);
+    assert(p.second.alloc == h.M);
+  }
+  {
+    using T = CountCopiesAllocV1;
+    using U = CountCopiesAllocV2;
+    using P = std::pair<T, U>;
+
+    std::tuple<T> t1;
+    std::tuple<U> t2;
+
+    TestHarness<P> h;
+    h.construct(std::piecewise_construct, std::move(t1), std::move(t2));
+    P const& p = *h.ptr;
+    assert(p.first.count == 2);
+    assert(p.first.alloc == h.M);
+    assert(p.second.count == 2);
+    assert(p.second.alloc == h.M);
+  }
+  {
+    using T = CountCopiesAllocV2;
+    using U = CountCopiesAllocV1;
+    using P = std::pair<T, U>;
+
+    std::tuple<T> t1;
+    std::tuple<U> t2;
+
+    TestHarness<P> h;
+    h.construct(std::piecewise_construct, std::move(t1), std::move(t2));
+    P const& p = *h.ptr;
+    assert(p.first.count == 2);
+    assert(p.first.alloc == h.M);
+    assert(p.second.count == 2);
+    assert(p.second.alloc == h.M);
+  }
+  {
+    using T = CountCopiesAllocV2;
+    using U = CountCopies;
+    using P = std::pair<T, U>;
+
+    std::tuple<T> t1;
+    std::tuple<U> t2;
+
+    TestHarness<P> h;
+    h.construct(std::piecewise_construct, t1, t2);
+    P const& p = *h.ptr;
+    assert(p.first.count == 2);
+    assert(p.first.alloc == h.M);
+    assert(p.second.count == 2);
+  }
+
+  return 0;
+}

libcxx/test/libcxx/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/db_deallocate.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++98, c++03, c++11, c++14
+// REQUIRES: has-unix-headers
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 -D_LIBCPP_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// T* polymorphic_allocator<T>::deallocate(T*, size_t size)
+
+int AssertCount = 0;
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "check_assertion.h"
+#include "test_std_memory_resource.h"
+
+int main(int, char**) {
+  using Alloc  = std::pmr::polymorphic_allocator<int>;
+  using Traits = std::allocator_traits<Alloc>;
+  NullResource R;
+  Alloc a(&R);
+  const std::size_t maxSize = Traits::max_size(a);
+
+  a.deallocate(nullptr, maxSize); // no assertion
+  TEST_LIBCPP_ASSERT_FAILURE(a.deallocate(nullptr, maxSize + 1), "deallocate called for size which exceeds max_size()");
+
+  return 0;
+}

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++98, c++03, c++11, c++14
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator const &);
+
+#include <memory_resource>
+#include <cassert>
+#include <type_traits>
+#include <utility>
+
+int main(int, char**) {
+  typedef std::pmr::polymorphic_allocator<void> A1;
+  {
+    static_assert(std::is_copy_constructible<A1>::value, "");
+    static_assert(std::is_move_constructible<A1>::value, "");
+  }
+  // copy
+  {
+    A1 const a((std::pmr::memory_resource*)42);
+    A1 const a2(a);
+    assert(a.resource() == a2.resource());
+  }
+  // move
+  {
+    A1 a((std::pmr::memory_resource*)42);
+    A1 a2(std::move(a));
+    assert(a.resource() == a2.resource());
+    assert(a2.resource() == (std::pmr::memory_resource*)42);
+  }
+
+  return 0;
+}

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++98, c++03, c++11, c++14
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U>
+// polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator<U> const &);
+
+#include <memory_resource>
+#include <cassert>
+#include <type_traits>
+#include <utility>
+
+int main(int, char**) {
+  typedef std::pmr::polymorphic_allocator<void> A1;
+  typedef std::pmr::polymorphic_allocator<char> A2;
+  { // Test that the conversion is implicit and noexcept.
+    static_assert(std::is_convertible<A1 const&, A2>::value, "");
+    static_assert(std::is_convertible<A2 const&, A1>::value, "");
+    static_assert(std::is_nothrow_constructible<A1, A2 const&>::value, "");
+    static_assert(std::is_nothrow_constructible<A2, A1 const&>::value, "");
+  }
+  // copy other type
+  {
+    A1 const a((std::pmr::memory_resource*)42);
+    A2 const a2(a);
+    assert(a.resource() == a2.resource());
+    assert(a2.resource() == (std::pmr::memory_resource*)42);
+  }
+  {
+    A1 a((std::pmr::memory_resource*)42);
+    A2 const a2(std::move(a));
+    assert(a.resource() == a2.resource());
+    assert(a2.resource() == (std::pmr::memory_resource*)42);
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair.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++98, c++03, c++11, c++14
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U1, class U2>
+// void polymorphic_allocator<T>::construct(pair<U1, U2>*)
+
+#include <memory_resource>
+#include <cassert>
+#include <cstdlib>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include "uses_alloc_types.h"
+
+int constructed = 0;
+
+struct default_constructible {
+  default_constructible() : x(42) { ++constructed; }
+  int x = 0;
+};
+
+int main(int, char**) {
+  // pair<default_constructible, default_constructible> as T()
+  {
+    typedef default_constructible T;
+    typedef std::pair<T, T> P;
+    typedef std::pmr::polymorphic_allocator<void> A;
+    P* ptr = (P*)std::malloc(sizeof(P));
+    A a;
+    a.construct(ptr);
+    assert(constructed == 2);
+    assert(ptr->first.x == 42);
+    assert(ptr->second.x == 42);
+    std::free(ptr);
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair_rvalue.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++98, c++03, c++11, c++14
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class P1, class P2, class U1, class U2>
+// void polymorphic_allocator<T>::construct(pair<P1, P2>*, pair<U1, U2> &&)
+
+#include <memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+
+#include "test_macros.h"
+#include "test_std_memory_resource.h"
+#include "uses_alloc_types.h"
+#include "controlled_allocators.h"
+#include "test_allocator.h"
+
+template <class UA1, class UA2, class TT, class UU>
+bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect, std::pair<TT, UU>&& p) {
+  using P = std::pair<UA1, UA2>;
+  TestResource R;
+  std::pmr::memory_resource* M = &R;
+  std::pmr::polymorphic_allocator<P> A(M);
+  P* ptr  = A.allocate(2);
+  P* ptr2 = ptr + 1;
+
+  // UNDER TEST //
+  A.construct(ptr, std::move(p));
+
+  A.construct(ptr2,
+              std::piecewise_construct,
+              std::forward_as_tuple(std::forward<TT>(p.first)),
+              std::forward_as_tuple(std::forward<UU>(p.second)));
+  // ------- //
+
+  bool tres = checkConstruct<TT&&>(ptr->first, TExpect, M) && checkConstructionEquiv(ptr->first, ptr2->first);
+
+  bool ures = checkConstruct<UU&&>(ptr->second, UExpect, M) && checkConstructionEquiv(ptr->second, ptr2->second);
+
+  A.destroy(ptr);
+  A.destroy(ptr2);
+  A.deallocate(ptr, 2);
+  return tres && ures;
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_uses_allocator(std::pair<TT, UU>&& p) {
+  {
+    using T = NotUsesAllocator<Alloc, 1>;
+    using U = NotUsesAllocator<Alloc, 1>;
+    assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+  }
+  {
+    using T = UsesAllocatorV1<Alloc, 1>;
+    using U = UsesAllocatorV2<Alloc, 1>;
+    assert((doTest<T, U>(UA_AllocArg, UA_AllocLast, std::move(p))));
+  }
+  {
+    using T = UsesAllocatorV2<Alloc, 1>;
+    using U = UsesAllocatorV3<Alloc, 1>;
+    assert((doTest<T, U>(UA_AllocLast, UA_AllocArg, std::move(p))));
+  }
+  {
+    using T = UsesAllocatorV3<Alloc, 1>;
+    using U = NotUsesAllocator<Alloc, 1>;
+    assert((doTest<T, U>(UA_AllocArg, UA_None, std::move(p))));
+  }
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_not_uses_allocator(std::pair<TT, UU>&& p) {
+  {
+    using T = NotUsesAllocator<Alloc, 1>;
+    using U = NotUsesAllocator<Alloc, 1>;
+    assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+  }
+  {
+    using T = UsesAllocatorV1<Alloc, 1>;
+    using U = UsesAllocatorV2<Alloc, 1>;
+    assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+  }
+  {
+    using T = UsesAllocatorV2<Alloc, 1>;
+    using U = UsesAllocatorV3<Alloc, 1>;
+    assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+  }
+  {
+    using T = UsesAllocatorV3<Alloc, 1>;
+    using U = NotUsesAllocator<Alloc, 1>;
+    assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+  }
+}
+
+int main(int, char**) {
+  using PMR = std::pmr::memory_resource*;
+  using PMA = std::pmr::polymorphic_allocator<char>;
+  {
+    int x = 42;
+    int y = 42;
+    std::pair<int&, int&&> p(x, std::move(y));
+    test_pmr_not_uses_allocator<PMR>(std::move(p));
+    test_pmr_uses_allocator<PMA>(std::move(p));
+  }
+  {
+    int x = 42;
+    int y = 42;
+    std::pair<int&&, int&> p(std::move(x), y);
+    test_pmr_not_uses_allocator<PMR>(std::move(p));
+    test_pmr_uses_allocator<PMA>(std::move(p));
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/resource.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++98, c++03, c++11, c++14
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// memory_resource *
+// polymorphic_allocator<T>::resource() const
+
+#include <memory_resource>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  typedef std::pmr::polymorphic_allocator<void> A;
+  {
+    A const a;
+    ASSERT_SAME_TYPE(decltype(a.resource()), std::pmr::memory_resource*);
+  }
+  {
+    std::pmr::memory_resource* mptr = (std::pmr::memory_resource*)42;
+    A const a(mptr);
+    assert(a.resource() == mptr);
+  }
+  {
+    A const a(nullptr);
+    assert(a.resource() == nullptr);
+    assert(a.resource() == nullptr);
+  }
+  {
+    A const a;
+    assert(a.resource() == std::pmr::get_default_resource());
+  }
+  {
+    std::pmr::memory_resource* mptr = (std::pmr::memory_resource*)42;
+    std::pmr::set_default_resource(mptr);
+    A const a;
+    assert(a.resource() == mptr);
+    assert(a.resource() == std::pmr::get_default_resource());
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/utility/mem.res/mem.res.global/default_resource.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++98, c++03, c++11, c++14
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
+
+// <memory_resource>
+
+//-----------------------------------------------------------------------------
+// TESTING memory_resource * get_default_resource() noexcept;
+//         memory_resource * set_default_resource(memory_resource*) noexcept;
+//
+// Concerns:
+//  A) 'get_default_resource()' returns a non-null memory_resource pointer.
+//  B) 'get_default_resource()' returns the value set by the last call to
+//     'set_default_resource(...)' and 'new_delete_resource()' if no call
+//     to 'set_default_resource(...)' has occurred.
+//  C) 'set_default_resource(...)' returns the previous value of the default
+//     resource.
+//  D) 'set_default_resource(T* p)' for a non-null 'p' sets the default resource
+//     to be 'p'.
+//  E) 'set_default_resource(null)' sets the default resource to
+//     'new_delete_resource()'.
+//  F) 'get_default_resource' and 'set_default_resource' are noexcept.
+
+#include <memory_resource>
+#include <cassert>
+
+#include "test_std_memory_resource.h"
+
+using namespace std::pmr;
+
+int main(int, char**) {
+  TestResource R;
+  { // Test (A) and (B)
+    memory_resource* p = get_default_resource();
+    assert(p != nullptr);
+    assert(p == new_delete_resource());
+    assert(p == get_default_resource());
+  }
+  { // Test (C) and (D)
+    memory_resource* expect = &R;
+    memory_resource* old    = set_default_resource(expect);
+    assert(old != nullptr);
+    assert(old == new_delete_resource());
+
+    memory_resource* p = get_default_resource();
+    assert(p != nullptr);
+    assert(p == expect);
+    assert(p == get_default_resource());
+  }
+  { // Test (E)
+    memory_resource* old = set_default_resource(nullptr);
+    assert(old == &R);
+    memory_resource* p = get_default_resource();
+    assert(p != nullptr);
+    assert(p == new_delete_resource());
+    assert(p == get_default_resource());
+  }
+  { // Test (F)
+    static_assert(noexcept(get_default_resource()), "get_default_resource() must be noexcept");
+
+    static_assert(noexcept(set_default_resource(nullptr)), "set_default_resource() must be noexcept");
+  }
+
+  return 0;
+}

libcxx/test/support/test_std_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 SUPPORT_TEST_STD_MEMORY_RESOURCE_H
+#define SUPPORT_TEST_STD_MEMORY_RESOURCE_H
+
+#include <memory>
+#include <memory_resource>
+#include <type_traits>
+#include <utility>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cstdint>
+#include <cassert>
+#include "test_macros.h"
+#include "controlled_allocators.h"
+#include "uses_alloc_types.h"
+
+template <class ProviderT, int = 0>
+class TestResourceImp : public std::pmr::memory_resource {
+public:
+  static int resource_alive;
+  static int resource_constructed;
+  static int resource_destructed;
+
+  static void resetStatics() {
+    assert(resource_alive == 0);
+    resource_alive       = 0;
+    resource_constructed = 0;
+    resource_destructed  = 0;
+  }
+
+  using memory_resource = std::pmr::memory_resource;
+  using Provider        = ProviderT;
+
+  int value;
+
+  explicit TestResourceImp(int val = 0) : value(val) {
+    ++resource_alive;
+    ++resource_constructed;
+  }
+
+  ~TestResourceImp() noexcept {
+    --resource_alive;
+    ++resource_destructed;
+  }
+
+  void reset() {
+    C.reset();
+    P.reset();
+  }
+  AllocController& getController() { return C; }
+
+  bool checkAlloc(void* p, std::size_t s, std::size_t a) const { return C.checkAlloc(p, s, a); }
+
+  bool checkDealloc(void* p, std::size_t s, std::size_t a) const { return C.checkDealloc(p, s, a); }
+
+  bool checkIsEqualCalledEq(int n) const { return C.checkIsEqualCalledEq(n); }
+
+protected:
+  virtual void* do_allocate(std::size_t s, std::size_t a) {
+    if (C.throw_on_alloc) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+      throw TestException{};
+#else
+      assert(false);
+#endif
+    }
+    void* ret = P.allocate(s, a);
+    C.countAlloc(ret, s, a);
+    return ret;
+  }
+
+  virtual void do_deallocate(void* p, std::size_t s, std::size_t a) {
+    C.countDealloc(p, s, a);
+    P.deallocate(p, s, a);
+  }
+
+  virtual bool do_is_equal(memory_resource const& other) const noexcept {
+    C.countIsEqual();
+    TestResourceImp const* o = dynamic_cast<TestResourceImp const*>(&other);
+    return o && o->value == value;
+  }
+
+private:
+  mutable AllocController C;
+  mutable Provider P;
+  DISALLOW_COPY(TestResourceImp);
+};
+
+template <class Provider, int N>
+int TestResourceImp<Provider, N>::resource_alive = 0;
+
+template <class Provider, int N>
+int TestResourceImp<Provider, N>::resource_constructed = 0;
+
+template <class Provider, int N>
+int TestResourceImp<Provider, N>::resource_destructed = 0;
+
+struct NullProvider {
+  NullProvider() {}
+  void* allocate(size_t, size_t) { return nullptr; }
+  void deallocate(void*, size_t, size_t) {}
+  void reset() {}
+
+private:
+  DISALLOW_COPY(NullProvider);
+};
+
+struct NewDeleteProvider {
+  NewDeleteProvider() {}
+  void* allocate(size_t s, size_t) { return ::operator new(s); }
+  void deallocate(void* p, size_t, size_t) { ::operator delete(p); }
+  void reset() {}
+
+private:
+  DISALLOW_COPY(NewDeleteProvider);
+};
+
+template <size_t Size = 4096 * 10> // 10 pages worth of memory.
+struct BufferProvider {
+  char buffer[Size];
+  void* next   = &buffer;
+  size_t space = Size;
+
+  BufferProvider() {}
+
+  void* allocate(size_t s, size_t a) {
+    void* ret = std::align(s, a, next, space);
+    if (ret == nullptr) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+      throw std::bad_alloc();
+#else
+      assert(false);
+#endif
+    }
+
+    return ret;
+  }
+
+  void deallocate(void*, size_t, size_t) {}
+
+  void reset() {
+    next  = &buffer;
+    space = Size;
+  }
+
+private:
+  DISALLOW_COPY(BufferProvider);
+};
+
+using NullResource      = TestResourceImp<NullProvider, 0>;
+using NewDeleteResource = TestResourceImp<NewDeleteProvider, 0>;
+using TestResource      = TestResourceImp<BufferProvider<>, 0>;
+using TestResource1     = TestResourceImp<BufferProvider<>, 1>;
+using TestResource2     = TestResourceImp<BufferProvider<>, 2>;
+
+#endif /* SUPPORT_TEST_STD_MEMORY_RESOURCE_H */

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_map_try_emplace",
     "values": { "c++17": 201411 },
     "headers": ["map"],
   }, {
     "name": "__cpp_lib_math_constants",
     "values": { "c++20": 201907 },
     "headers": ["numbers"],
   }, {
     "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"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_move_only_function",
     "values": { "c++2b": 202110 },
     "headers": ["functional"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_node_extract",
     "values": { "c++17": 201606 },