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

29

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

36

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.

39

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

68–78

libcxx/include/__memory_resource/synchronized_pool_resource.h

61

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

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

49–57

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

96

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

17

Doesn't this only work with lld?

116–117

126–135

And with the other set checks as well.

127

176–177

190–191

212

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?

213–228

335–345

413

Please remove this else as well.

426–427

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

29

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.

39

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

61

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

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

96

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

17

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

126–135

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.

127

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

212

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.

426–427

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.

448–451

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

[ldionne]

libcxx/docs/Status/Cxx20Issues.csv

236

This should be 15.0 since we slipped again.

libcxx/docs/Status/Cxx2bIssues.csv

19

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.

67

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

112

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

2 ↗

(On Diff #398211)

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

447

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

118

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

120–121

123–163

[philnik]

• Rebased
• Address comments

libcxx/docs/Status/Cxx20Issues.csv

 "`3296 <https://wg21.link/LWG3296>`__","Inconsistent default argument for ``basic_regex<>::assign``\ ","Prague","|Complete|",""
 "`3299 <https://wg21.link/LWG3299>`__","Pointers don't need customized iterator behavior","Prague","","","|ranges|"
 "`3300 <https://wg21.link/LWG3300>`__","Non-array ``ssize``\  overload is underconstrained","Prague","",""
 "`3301 <https://wg21.link/LWG3301>`__","``transform_view::iterator``\  has incorrect ``iterator_category``\ ","Prague","","","|ranges|"
 "`3302 <https://wg21.link/LWG3302>`__","Range adaptor objects ``keys``\  and ``values``\  are unspecified","Prague","","","|ranges|"
 "`3303 <https://wg21.link/LWG3303>`__","Bad ""``constexpr``\ "" marker for ``destroy/destroy_n``\ ","Prague","",""
 "`3304 <https://wg21.link/LWG3304>`__","Allocate functions of ``std::polymorphic_allocator``\  should require ``[[nodiscard]]``\ ","Prague","",""
 "`3307 <https://wg21.link/LWG3307>`__","``std::allocator<void>().allocate(n)``\ ","Prague","",""
-"`3310 <https://wg21.link/LWG3310>`__","Replace ``SIZE_MAX``\  with ``numeric_limits<size_t>::max()``\ ","Prague","",""
+"`3310 <https://wg21.link/LWG3310>`__","Replace ``SIZE_MAX``\  with ``numeric_limits<size_t>::max()``\ ","Prague","|Complete|","14.0"
 "`3313 <https://wg21.link/LWG3313>`__","``join_view::iterator::operator--``\  is incorrectly constrained","Prague","","","|ranges|"
 "`3314 <https://wg21.link/LWG3314>`__","Is stream insertion behavior locale dependent when ``Period::type``\  is ``micro``\ ?","Prague","","","|chrono|"
 "`3315 <https://wg21.link/LWG3315>`__","Correct Allocator Default Behavior","Prague","",""
 "`3316 <https://wg21.link/LWG3316>`__","Correctly define epoch for ``utc_clock``\  / ``utc_timepoint``\ ","Prague","","","|chrono|"
 "`3317 <https://wg21.link/LWG3317>`__","Incorrect ``operator<<``\  for floating-point durations","Prague","","","|chrono|"
 "`3318 <https://wg21.link/LWG3318>`__","Clarify whether clocks can represent time before their epoch","Prague","","","|chrono|"
 "`3319 <https://wg21.link/LWG3319>`__","Properly reference specification of IANA time zone database","Prague","","","|chrono|"
 "`3320 <https://wg21.link/LWG3320>`__","``span::cbegin/cend``\  methods produce different results than ``std::[ranges::]cbegin/cend``\ ","Prague","|Complete|",""

libcxx/docs/Status/Cxx2bIssues.csv

 "`3447 <https://wg21.link/LWG3447>`__","Deduction guides for ``take_view`` and ``drop_view`` have different constraints","November 2020","|Complete|","14.0"
 "`3450 <https://wg21.link/LWG3450>`__","The const overloads of ``take_while_view::begin/end`` are underconstrained","November 2020","","","|ranges|"
 "`3464 <https://wg21.link/LWG3464>`__","``istream::gcount()`` can overflow","November 2020","",""
 "`2731 <https://wg21.link/LWG2731>`__","Existence of ``lock_guard<MutexTypes...>::mutex_type`` typedef unclear","November 2020","|Complete|","5.0"
 "`2743 <https://wg21.link/LWG2743>`__","P0083R3 ``node_handle`` private members missing ""exposition only"" comment","November 2020","",""
 "`2820 <https://wg21.link/LWG2820>`__","Clarify ``<cstdint>`` macros","November 2020","",""
 "`3120 <https://wg21.link/LWG3120>`__","Unclear behavior of ``monotonic_buffer_resource::release()``","November 2020","",""
 "`3170 <https://wg21.link/LWG3170>`__","``is_always_equal`` added to ``std::allocator`` makes the standard library treat derived types as always equal","November 2020","",""
-"`3036 <https://wg21.link/LWG3036>`__","``polymorphic_allocator::destroy`` is extraneous","November 2020","",""
+"`3036 <https://wg21.link/LWG3036>`__","``polymorphic_allocator::destroy`` is extraneous","November 2020","|Complete|","14.0"
 "`3171 <https://wg21.link/LWG3171>`__","LWG2989 breaks ``directory_entry`` stream insertion","November 2020","",""
 "`3306 <https://wg21.link/LWG3306>`__","``ranges::advance`` violates its preconditions","November 2020","","","|ranges|"
 "`3403 <https://wg21.link/LWG3403>`__","Domain of ``ranges::ssize(E)`` doesn't ``match ranges::size(E)``","November 2020","","","|ranges|"
 "`3404 <https://wg21.link/LWG3404>`__","Finish removing subrange's conversions from pair-like","November 2020","","","|ranges|"
 "`3405 <https://wg21.link/LWG3405>`__","``common_view``'s converting constructor is bad, too","November 2020","","","|ranges|"
 "`3406 <https://wg21.link/LWG3406>`__","``elements_view::begin()`` and ``elements_view::end()`` have incompatible constraints","November 2020","","","|ranges|"
 "`3419 <https://wg21.link/LWG3419>`__","[algorithms.requirements]/15 doesn't reserve as many rights as it intends to","November 2020","",""
 "`3420 <https://wg21.link/LWG3420>`__","cpp17-iterator should check that the type looks like an iterator first","November 2020","|Complete|","14.0","|ranges|"

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]
+
+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;
+};
+
+// [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 <__config>
+#include <__memory_resource/memory_resource.h>
+#include <cstddef>
+#include <new>
+#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_(_VSTD::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]
+
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    _ValueType *allocate(size_t __n) {
+        if (__n > (size_t(-1) / sizeof(_ValueType))) {
+            __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 <= (size_t(-1) / sizeof(_ValueType)),
+                       "deallocate called for size which exceeds max_size()");
+        __res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
+    }
+
+    template <class _Tp, class... _Args>
+    _LIBCPP_HIDE_FROM_ABI
+    void construct(_Tp *__p, _Args&&... __args)
+    {
+        _VSTD::__user_alloc_construct_impl(
+            typename __uses_alloc_ctor<_Tp, polymorphic_allocator&, _Args...>::type(),
+            __p, *this, _VSTD::forward<_Args>(__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()
+            , _VSTD::move(__x)
+            , typename __make_tuple_indices<sizeof...(_Args1)>::type{}
+          )
+          , __transform_tuple(
+              typename __uses_alloc_ctor<
+                  _T2, polymorphic_allocator&, _Args2...
+              >::type()
+            , _VSTD::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
+          , _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u))
+          , _VSTD::forward_as_tuple(_VSTD::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
+            , _VSTD::forward_as_tuple(__pr.first)
+            , _VSTD::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
+            , _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first))
+            , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second)));
+    }
+
+    template <class _Tp>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_IN_CXX23
+    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 _VSTD::forward_as_tuple(_VSTD::get<_Is>(_VSTD::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,
+                    _VSTD::get<_Is>(_VSTD::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(_VSTD::get<_Is>(_VSTD::move(__t))..., *this);
+    }
+
+    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();
+}
+
+#if _LIBCPP_STD_VER <= 17
+
+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);
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
+} // 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

     erase_if(deque<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
+#include <__memory_resource/polymorphic_allocator.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <algorithm>
 #include <compare>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <stdexcept>

   __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end());
   return __old_size - __c.size();
 }
 #endif
 
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr
+{
+    template <class _ValueT>
+    using deque = _VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>;
+}
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_DEQUE

libcxx/include/memory_resource

+// -*- C++ -*-
+//===------------------------ memory_resource -----------------------------===//
+//
+// 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 {
+  public:
+    using value_type = Tp;
+
+    polymorphic_allocator() noexcept;
+    polymorphic_allocator(memory_resource* r);
+
+    polymorphic_allocator(const polymorphic_allocator& other) = default;
+
+    template<class U>
+      polymorphic_allocator(const polymorphic_allocator<U>& other) noexcept;
+
+    polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;
+
+    [[nodiscard]] Tp *allocate(size_t n);
+    void deallocate(Tp *p, size_t n);
+
+    template<class T, class... Args>
+      void construct(T* p, Args&&... args);
+
+    template <class T>
+      void destroy(T* p);  // deprecated in C++23
+
+    polymorphic_allocator select_on_container_copy_construction() const;
+
+    memory_resource *resource() const;
+  };
+
+  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;  // removed in C++20
+
+  // 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

 
 } // std
 */
 
 #include <__config>
 #include <__debug>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
+#include <__memory_resource/polymorphic_allocator.h>
 #include <compare>
 #include <deque>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <stdexcept>
 #include <string>
 #include <utility>

     _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 = _VSTD::match_results<_BidirT, polymorphic_allocator<_VSTD::sub_match<_BidirT>>>;
+
+    using cmatch  = match_results<const char*>;
+    using wcmatch = match_results<const wchar_t*>;
+    using smatch  = match_results<_VSTD::pmr::string::const_iterator>;
+    using wsmatch = match_results<_VSTD::pmr::wstring::const_iterator>;
+}
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_REGEX

libcxx/include/string

 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional_base>
 #include <__iterator/wrap_iter.h>
+#include <__memory_resource/polymorphic_allocator.h>
 #include <algorithm>
 #include <compare>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd>
 #include <iterator>

         return basic_string<char32_t> (__str, __len);
     }
   }
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr
+{
+    template<class _CharT, class _TraitsT = _VSTD::char_traits<_CharT>>
+    using basic_string = _VSTD::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>;
+}
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 _LIBCPP_POP_MACROS
 
 #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 14.0
+------------
+
+* ?? - [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.
 
   x86_64-apple-apple-darwin
* a984dcaf7c21 - [libc++] [P0482] [C++20] Implement missing bits for codecvt and codecvt_byname.
   Symbol added: __ZNSt3__17codecvtIDsDu11__mbstate_tED2Ev
   Symbol added: __ZTINSt3__114codecvt_bynameIDiDu11__mbstate_tEE
   Symbol added: __ZTINSt3__114codecvt_bynameIDsDu11__mbstate_tEE
   Symbol added: __ZTINSt3__17codecvtIDiDu11__mbstate_tEE
   Symbol added: __ZTINSt3__17codecvtIDsDu11__mbstate_tEE
   Symbol added: __ZTSNSt3__17codecvtIDiDu11__mbstate_tEE
   Symbol added: __ZTSNSt3__17codecvtIDsDu11__mbstate_tEE
   Symbol added: __ZTVNSt3__114codecvt_bynameIDiDu11__mbstate_tEE
   Symbol added: __ZTVNSt3__114codecvt_bynameIDsDu11__mbstate_tEE
   Symbol added: __ZTVNSt3__17codecvtIDiDu11__mbstate_tEE
   Symbol added: __ZTVNSt3__17codecvtIDsDu11__mbstate_tEE
 
   x86_64-unknown-linux-gnu
   ------------------------
   Symbol added: _ZTINSt3__17codecvtIDsDu11__mbstate_tEE
   Symbol added: _ZTINSt3__114codecvt_bynameIDsDu11__mbstate_tEE
   Symbol added: _ZTINSt3__17codecvtIDiDu11__mbstate_tEE
   Symbol added: _ZTINSt3__114codecvt_bynameIDiDu11__mbstate_tEE
   Symbol added: _ZNKSt3__17codecvtIDsDu11__mbstate_tE9do_lengthERS1_PKDuS5_m
   Symbol added: _ZNKSt3__17codecvtIDiDu11__mbstate_tE13do_max_lengthEv
   Symbol added: _ZNSt3__17codecvtIDiDu11__mbstate_tE2idE
   Symbol added: _ZNKSt3__17codecvtIDsDu11__mbstate_tE16do_always_noconvEv
   Symbol added: _ZNKSt3__17codecvtIDsDu11__mbstate_tE13do_max_lengthEv
   Symbol added: _ZNSt3__17codecvtIDsDu11__mbstate_tE2idE
   Symbol added: _ZNKSt3__17codecvtIDsDu11__mbstate_tE6do_outERS1_PKDsS5_RS5_PDuS7_RS7_
   Symbol added: _ZNSt3__17codecvtIDiDu11__mbstate_tED0Ev
   Symbol added: _ZNKSt3__17codecvtIDiDu11__mbstate_tE5do_inERS1_PKDuS5_RS5_PDiS7_RS7_
   Symbol added: _ZNSt3__114codecvt_bynameIDsDu11__mbstate_tED0Ev
   Symbol added: _ZTSNSt3__17codecvtIDiDu11__mbstate_tEE
   Symbol added: _ZNSt3__17codecvtIDiDu11__mbstate_tED1Ev
   Symbol added: _ZNSt3__114codecvt_bynameIDsDu11__mbstate_tED1Ev
   Symbol added: _ZTVNSt3__17codecvtIDiDu11__mbstate_tEE
   Symbol added: _ZNSt3__17codecvtIDiDu11__mbstate_tED2Ev
   Symbol added: _ZNSt3__17codecvtIDsDu11__mbstate_tED0Ev
   Symbol added: _ZNSt3__114codecvt_bynameIDsDu11__mbstate_tED2Ev
   Symbol added: _ZTVNSt3__114codecvt_bynameIDsDu11__mbstate_tEE
   Symbol added: _ZNKSt3__17codecvtIDiDu11__mbstate_tE16do_always_noconvEv
   Symbol added: _ZNSt3__17codecvtIDsDu11__mbstate_tED1Ev
   Symbol added: _ZTVNSt3__114codecvt_bynameIDiDu11__mbstate_tEE
   Symbol added: _ZNKSt3__17codecvtIDiDu11__mbstate_tE11do_encodingEv
   Symbol added: _ZNSt3__114codecvt_bynameIDiDu11__mbstate_tED0Ev
   Symbol added: _ZNSt3__17codecvtIDsDu11__mbstate_tED2Ev
   Symbol added: _ZNSt3__114codecvt_bynameIDiDu11__mbstate_tED1Ev
   Symbol added: _ZNKSt3__17codecvtIDiDu11__mbstate_tE9do_lengthERS1_PKDuS5_m
   Symbol added: _ZNKSt3__17codecvtIDsDu11__mbstate_tE10do_unshiftERS1_PDuS4_RS4_
   Symbol added: _ZTSNSt3__17codecvtIDsDu11__mbstate_tEE
   Symbol added: _ZNSt3__114codecvt_bynameIDiDu11__mbstate_tED2Ev
   Symbol added: _ZTVNSt3__17codecvtIDsDu11__mbstate_tEE
   Symbol added: _ZNKSt3__17codecvtIDiDu11__mbstate_tE6do_outERS1_PKDiS5_RS5_PDuS7_RS7_
   Symbol added: _ZTSNSt3__114codecvt_bynameIDsDu11__mbstate_tEE
   Symbol added: _ZNKSt3__17codecvtIDsDu11__mbstate_tE11do_encodingEv
   Symbol added: _ZNKSt3__17codecvtIDiDu11__mbstate_tE10do_unshiftERS1_PDuS4_RS4_
   Symbol added: _ZNKSt3__17codecvtIDsDu11__mbstate_tE5do_inERS1_PKDuS5_RS5_PDsS7_RS7_
   Symbol added: _ZTSNSt3__114codecvt_bynameIDiDu11__mbstate_tEE
 
 * 997d41cdec53 - [libc++] Instantiate additional <iostream> members in the dylib
 
   This commit added new explicit instantiations for classes in <iostream> in
   the library. This was done after noticing that many programs that used streams
   ended up containing weak definitions of these classes, which has a negative
   impact on both code size and load times. This change is not an ABI break,
   since we are just adding additional symbols.
 
   x86_64-apple-apple-darwin
   -------------------------
   Symbol added: __ZNKSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE3strEv
   Symbol added: __ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE11__read_modeEv
   Symbol added: __ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE12__write_modeEv

libcxx/src/memory_resource.cpp

+//===------------------------ 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_resource"
+#include "memory"
+
+#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 = _VSTD::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 _VSTD::__libcpp_allocate(bytes, align);
+#else
+        if (bytes == 0)
+            bytes = 1;
+        void *result = _VSTD::__libcpp_allocate(bytes, align);
+        if (!is_aligned_to(result, align)) {
+            _VSTD::__libcpp_deallocate(result, bytes, align);
+            __throw_bad_alloc();
+        }
+        return result;
+#endif
+    }
+
+    void do_deallocate(void *p, size_t bytes, size_t align) override
+        { _VSTD::__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_AFTER_CXX11 ResourceInitHelper() : resources() {}
+  ~ResourceInitHelper() {}
+};
+
+# 90 "memory_resource.cpp" 1 3
+_LIBCPP_SAFE_STATIC ResourceInitHelper res_init _LIBCPP_INIT_PRIORITY_MAX;
+# 92 "memory_resource.cpp" 2
+
+} // 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
+    _LIBCPP_SAFE_STATIC static atomic<memory_resource*> __res =
+        ATOMIC_VAR_INIT(&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 _VSTD::atomic_exchange_explicit(
+            &__res, new_res, memory_order_acq_rel);
+    }
+    else {
+        return _VSTD::atomic_load_explicit(
+            &__res, memory_order_acquire);
+    }
+#elif !defined(_LIBCPP_HAS_NO_THREADS)
+    _LIBCPP_SAFE_STATIC static 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
+    _LIBCPP_SAFE_STATIC static 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 = _VSTD::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 = _VSTD::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/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() {
+        ptr->~T();
+        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
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// T* polymorphic_allocator<T>::deallocate(T*, size_t size)
+
+int AssertCount = 0;
+
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
+#define _LIBCPP_DEBUG 0
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#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);
+    assert(AssertCount == 0);
+    a.deallocate(nullptr, maxSize + 1);
+    assert(AssertCount == 1);
+
+    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);
+
+    ptr->~P();
+    ptr2->~P();
+    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 [
     "headers": ["map"],
   }, {
     "name": "__cpp_lib_math_constants",
     "values": { "c++20": 201907 },
     "headers": ["numbers"],
     "test_suite_guard": "defined(__cpp_concepts) && __cpp_concepts >= 201907L",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_CONCEPTS)",
   }, {
     "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_node_extract",
     "values": { "c++17": 201606 },
     "headers": ["map", "set", "unordered_map", "unordered_set"],
   }, {
     "name": "__cpp_lib_nonmember_container_access",
     "values": { "c++17": 201411 },
     "headers": ["array", "deque", "forward_list", "iterator", "list", "map", "regex", "set", "string", "unordered_map", "unordered_set", "vector"],