Implement C++17 <memory_resource>.

[• Quuxplusone]

Summary

This is a complete but partly silly implementation of C++17 <memory_resource>.

Preliminary pieces of this patch are already filed as D46806 and D46807. If those get merged I'll rebase this one. I myself do not have commit privileges.

Potential issues with this patch:

1. monotonic_buffer_resource is complete and IMHO well tested, but I bet someone can find suboptimal things in its design.

2. unsynchronized_pool_resource is trivial; it ignores the pool_options and just passes everything through to the upstream, which is conforming but I'm sure someone has a better idea.

3. unsynchronized_pool_resource is "code complete" but untested.

I feel guilty about (3) and will fix it eventually. I'm willing to take a stab at (2) if anyone can explain in English what the _intended_ implementation is. On (1) I hope there will be only easy nits.

https://github.com/Quuxplusone/libcxx/compare/master...memory-resource-header

[EricWF]

I would prefer if we completed <experimental/memory_resource> (according to the current standard, not the LFTS spec), and then moved it.

Would you be willing to do that instead?

[• Quuxplusone]

I would prefer if we completed <experimental/memory_resource> (according to the current standard, not the LFTS spec), and then moved it.
Would you be willing to do that instead?

Let me see if I understand. libc++'s <experimental/memory_resource> differs from C++17 <memory_resource> in at least these ways:
(A) It's missing monotonic_buffer_resource and {un,}synchronized_pool_resource
(B) It's got different semantics around uses-allocator construction because of https://wg21.link/lwg2969
(C) It's got a different header name

This patch is basically proposing to fix things in the order C-A-B (and fix C by making copies of everything); you're proposing to fix things in the order A-B-C (and fix C by moving everything).

I have no objection to fixing A in <experimental/memory_resource> if people think that'd be useful. I didn't do that in this patch simply because I'd observed other <experimental/*> headers already getting replaced with #error messages, and it seemed like any further work on the <experimental/*> headers would have been wasted.

I don't know who's using <experimental/memory_resource> today, but in theory I worry that fixing B in <experimental/memory_resource> (before doing C) might actually break someone's code.

Philosophically as I understand it LWG2969 was a patch against C++17, not a patch against the TS. If LWG2969 (and incidentally I asked lwgchair to open a new issue for https://github.com/Quuxplusone/libcxx/commit/54e1a59a ) are actually supposed to be patches against *both* C++17 *and* the TS, then cool, yeah, we should fix B in <experimental/memory_resource>. Thoughts?

[EricWF]

In D47090#1105389, @Quuxplusone wrote:

I would prefer if we completed <experimental/memory_resource> (according to the current standard, not the LFTS spec), and then moved it.
Would you be willing to do that instead?

Let me see if I understand. libc++'s <experimental/memory_resource> differs from C++17 <memory_resource> in at least these ways:
(A) It's missing monotonic_buffer_resource and {un,}synchronized_pool_resource

Those were initially in the LFTS spec, I think they're in LFTS v2.

(B) It's got different semantics around uses-allocator construction because of https://wg21.link/lwg2969

Issue resolutions should probably be applied to the experimental versions as well.

(C) It's got a different header name

I don't think this is relevant.

This patch is basically proposing to fix things in the order C-A-B (and fix C by making copies of everything); you're proposing to fix things in the order A-B-C (and fix C by moving everything).

I have no objection to fixing A in <experimental/memory_resource> if people think that'd be useful. I didn't do that in this patch simply because I'd observed other <experimental/*> headers already getting replaced with #error messages, and it seemed like any further work on the <experimental/*> headers would have been wasted.

I don't know who's using <experimental/memory_resource> today, but in theory I worry that fixing B in <experimental/memory_resource> (before doing C) might actually break someone's code.

I'm not concerned with it. We make no promises about ABI and API stability for <experimental> headers. Do we implement the LFTS v1, v2, or in future, v3, API? I would rather follow the standard spec. I believe
it will actually make transitioning from <experimental/foo> to <foo>, since the behaviour is the same.

[EricWF]

I should add that this is the approach I've taken with <experimental/filesystem> with no complaints.

[EricWF]

src/memory_resource.cpp

63

We certainly don't want a different definition of the global resources in each TU. See below.

65

This should go inside the library, so we're not emitting an initializer in each TU.

84

I think the global resources should be in the unversioned namespace std::pmr instead of std::__v::pmr. Like new/delete and exceptions I suspect we only want one definition of these in any given program. I'm considering every function from here up to and including set_default_resource.

@mclow.lists, @dexonsmith: what do you think?

148

_Tp

150

__res_
__ptr_
__size_
__align_

181

__bytes_
__alignment_ (or __align_)
__allocation_
__next_

[• Quuxplusone]

include/__memory_resource_base

197

(B) It's got different semantics around uses-allocator construction because of https://wg21.link/lwg2969

Issue resolutions should probably be applied to the experimental versions as well.

Okay, I can roll with that. I'll create a new patch that modifies <experimental/memory_resource>'s uses-allocator parts per LWG2969 (and my followup DR), without any other diffs.

Should <experimental/memory_resource> continue caring about std::experimental::erased_type, which was in LFTS and LFTSv2 but did not make it into C++17? My kneejerk reaction is "yes". (And at the end of this process, when we copy <experimental/memory_resource> into <memory_resource>, should <memory_resource> care about erased_type? My kneejerk reaction is "no".)

src/memory_resource.cpp

63

@EricWF: I think all of your comments in this file are the result of misreading "src/memory_resource.cpp" as "include/memory_resource". Or else I *totally* don't understand the current directory organization and you're going to have to instruct me. :)

[EricWF]

src/memory_resource.cpp

63

Woops. I feel dumb now.

[• Quuxplusone]

Here's a work-in-progress, slightly-less-silly implementation of {un,}synchronized_pool_resource, plus a test.

Eric has suggested adding these things into <experimental/memory_resource> instead of <memory_resource>, and then creating <memory_resource> as the very last step; so I've started opening pull requests in that direction already (D46806, D47109) and will keep doing so, as those start getting merged.

[• Quuxplusone]

I'm re-submitting this as a series of smaller patches that first bring <experimental/memory_resource> up to date with C++17, and then copy it over to <memory_resource>.
In order, these smaller patches are: D46806 D47109 D47344 D47111 D47358 D47360.

include/__functional_base

 // FIXME: This should have a version which takes a non-const alloc.
 template <class _Tp, class _Allocator, class... _Args>
 inline _LIBCPP_INLINE_VISIBILITY
 void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
 {
     new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a);
 }
 
-// FIXME: Theis should have a version which takes a non-const alloc.
-template <class _Tp, class _Allocator, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __user_alloc_construct (_Tp *__storage, const _Allocator &__a, _Args &&... __args)
-{ 
-    __user_alloc_construct_impl( 
-             __uses_alloc_ctor<_Tp, _Allocator>(), 
-             __storage, __a, _VSTD::forward<_Args>(__args)...
-        );
-}
 #endif  // _LIBCPP_CXX03_LANG
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_FUNCTIONAL_BASE

include/__memory_resource_base

+// -*- C++ -*-
+//===------------------------ memory_resource -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_RESOURCE_BASE
+#define _LIBCPP___MEMORY_RESOURCE_BASE
+
+/**
+    memory_resource synopsis
+
+// C++17
+
+namespace std {
+namespace pmr {
+
+  class memory_resource;
+
+  bool operator==(const memory_resource& a,
+                  const memory_resource& b) noexcept;
+  bool operator!=(const memory_resource& a,
+                  const memory_resource& b) noexcept;
+
+  template <class Tp> class polymorphic_allocator;
+
+  template <class T1, class T2>
+  bool operator==(const polymorphic_allocator<T1>& a,
+                  const polymorphic_allocator<T2>& b) noexcept;
+  template <class T1, class T2>
+  bool operator!=(const polymorphic_allocator<T1>& a,
+                  const polymorphic_allocator<T2>& b) noexcept;
+
+  // Global memory resources
+  memory_resource* set_default_resource(memory_resource* r) noexcept;
+  memory_resource* get_default_resource() noexcept;
+
+} // namespace pmr
+} // namespace std
+
+ */
+
+#include <__config>
+#include <__functional_base>
+#include <limits>
+#include <memory>
+#include <new>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <cstddef>
+#include <cstdlib>
+#include <__debug>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr
+{
+
+// 23.12.2, mem.res.class
+class _LIBCPP_TYPE_VIS memory_resource
+{
+    static const size_t __max_align = alignof(max_align_t);
+
+// 23.12.2.1, mem.res.public
+public:
+    virtual ~memory_resource() = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    void* allocate(size_t __bytes, size_t __align = __max_align)
+        { return do_allocate(__bytes, __align); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
+        { do_deallocate(__p, __bytes, __align); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool is_equal(memory_resource const & __other) const _NOEXCEPT
+        { return do_is_equal(__other); }
+
+// 23.12.2.2, mem.res.private
+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;
+};
+
+// 23.12.2.3, mem.res.eq
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator==(memory_resource const & __lhs,
+                memory_resource const & __rhs) _NOEXCEPT
+{
+    return &__lhs == &__rhs || __lhs.is_equal(__rhs);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(memory_resource const & __lhs,
+                memory_resource const & __rhs) _NOEXCEPT
+{
+    return !(__lhs == __rhs);
+}
+
+// 23.12.4, mem.res.global
+
+_LIBCPP_FUNC_VIS
+memory_resource * new_delete_resource() _NOEXCEPT;
+
+_LIBCPP_FUNC_VIS
+memory_resource * null_memory_resource() _NOEXCEPT;
+
+_LIBCPP_FUNC_VIS
+memory_resource * get_default_resource() _NOEXCEPT;
+
+_LIBCPP_FUNC_VIS
+memory_resource * set_default_resource(memory_resource *) _NOEXCEPT;
+
+// 23.12.3, mem.poly.allocator.class
+template <class _ValueType>
+class _LIBCPP_TEMPLATE_VIS polymorphic_allocator
+{
+public:
+    typedef _ValueType value_type;
+
+    // 23.12.3.1, mem.poly.allocator.ctor
+    _LIBCPP_INLINE_VISIBILITY
+    polymorphic_allocator() _NOEXCEPT
+      : __res_(_VSTD::pmr::get_default_resource())
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    polymorphic_allocator(memory_resource * __r) _NOEXCEPT
+      : __res_(__r)
+    {}
+
+    polymorphic_allocator(polymorphic_allocator const &) = default;
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY
+    polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT
+      : __res_(__other.resource())
+    {}
+
+    polymorphic_allocator &
+    operator=(polymorphic_allocator const &) = delete;
+
+    // 23.12.3.2, mem.poly.allocator.mem
+    _LIBCPP_INLINE_VISIBILITY
+    _ValueType* allocate(size_t __n) {
+        if (__n > __max_size()) {
+            __throw_length_error(
+                "std::pmr::polymorphic_allocator<T>::allocate(size_t n)"
+                " 'n' exceeds maximum supported size");
+        }
+        return static_cast<_ValueType*>(
+            __res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType))
+        );
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
+        _LIBCPP_ASSERT(__n <= __max_size(),
+                       "deallocate called for size which exceeds max_size()");
+        __res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
+    }
+
+    template <class _Tp, class ..._Ts>
+    _LIBCPP_INLINE_VISIBILITY
+    void construct(_Tp* __p, _Ts &&... __args)
+    {
+        _VSTD::__user_alloc_construct_impl(
+            typename __uses_alloc_ctor<_Tp, polymorphic_allocator&, _Ts...>::type(),
+            __p, *this, _VSTD::forward<_Ts>(__args)...
+        );
+    }
+
+    template <class _T1, class _T2, class ..._Args1, class ..._Args2>
+    _LIBCPP_INLINE_VISIBILITY
+    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_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2>* __p) {
+        construct(__p, piecewise_construct, tuple<>(), tuple<>());
+    }
+
+    template <class _T1, class _T2, class _Up, class _Vp>
+    _LIBCPP_INLINE_VISIBILITY
+    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_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __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_INLINE_VISIBILITY
+    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_INLINE_VISIBILITY
+    void destroy(_Tp * __p) _NOEXCEPT
+        { __p->~_Tp(); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    polymorphic_allocator
+    select_on_container_copy_construction() const _NOEXCEPT
+        { return polymorphic_allocator(); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    memory_resource * resource() const _NOEXCEPT
+        { return __res_; }
+
+private:
+    template <class ..._Args, size_t ..._Idx>
+    _LIBCPP_INLINE_VISIBILITY
+    tuple<_Args&&...>
+    __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
+                      __tuple_indices<_Idx...>)
+    {
+        return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...);
+    }
+
+    template <class ..._Args, size_t ..._Idx>
+    _LIBCPP_INLINE_VISIBILITY
+    tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>
+    __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
+                      __tuple_indices<_Idx...>)
+    {
+        using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>;
+        return _Tup(allocator_arg, *this,
+                    _VSTD::get<_Idx>(_VSTD::move(__t))...);
+    }
+
+    template <class ..._Args, size_t ..._Idx>
+    _LIBCPP_INLINE_VISIBILITY
+    tuple<_Args&&..., polymorphic_allocator&>
+    __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
+                      __tuple_indices<_Idx...>)
+    {
+        using _Tup = tuple<_Args&&..., polymorphic_allocator&>;
+        return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_t __max_size() const _NOEXCEPT
+        { return numeric_limits<size_t>::max() / sizeof(value_type); }
+
+    memory_resource * __res_;
+};
+
+// 23.12.3.3, mem.poly.allocator.eq
+
+template <class _Tp, class _Up>
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator==(polymorphic_allocator<_Tp> const & __lhs,
+                polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
+{
+    return *__lhs.resource() == *__rhs.resource();
+}
+
+template <class _Tp, class _Up>
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
+                polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
+{
+    return !(__lhs == __rhs);
+}
+
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif /* _LIBCPP___MEMORY_RESOURCE_BASE */

include/deque

 #include <__config>
 #include <__split_buffer>
 #include <type_traits>
 #include <initializer_list>
 #include <iterator>
 #include <algorithm>
 #include <stdexcept>
 
+#if _LIBCPP_STD_VER > 14
+#include <__memory_resource_base>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

 swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 _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

include/forward_list

 
 #include <__config>
 #include <initializer_list>
 #include <memory>
 #include <limits>
 #include <iterator>
 #include <algorithm>
 
+#if _LIBCPP_STD_VER > 14
+#include <__memory_resource_base>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

 swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr
+{
+    template <class _ValueT>
+    using forward_list = _VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
+}
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_FORWARD_LIST

include/list

 #include <limits>
 #include <initializer_list>
 #include <iterator>
 #include <algorithm>
 #include <type_traits>
 
 #include <__debug>
 
+#if _LIBCPP_STD_VER > 14
+#include <__memory_resource_base>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

 swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr
+{
+    template <class _ValueT>
+    using list = _VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>;
+}
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_LIST

include/map

 #include <__tree>
 #include <iterator>
 #include <memory>
 #include <utility>
 #include <functional>
 #include <initializer_list>
 #include <type_traits>
 
+#if _LIBCPP_STD_VER > 14
+#include <__memory_resource_base>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Key, class _CP, class _Compare, bool _IsSmall>
 class __map_value_compare
swap(multimap<_Key, _Tp, _Compare, _Allocator>& __x,
      multimap<_Key, _Tp, _Compare, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr
+{
+    template <class _KeyT, class _ValueT, class _CompareT = _VSTD::less<_KeyT>>
+    using map = _VSTD::map<_KeyT, _ValueT, _CompareT, polymorphic_allocator<_VSTD::pair<const _KeyT, _ValueT>>>;
+
+    template <class _KeyT, class _ValueT, class _CompareT = _VSTD::less<_KeyT>>
+    using multimap = _VSTD::multimap<_KeyT, _ValueT, _CompareT, polymorphic_allocator<_VSTD::pair<const _KeyT, _ValueT>>>;
+}
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 #endif  // _LIBCPP_MAP

include/memory_resource

+// -*- C++ -*-
+//===------------------------ memory_resource -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_MEMORY_RESOURCE
+#define _LIBCPP_MEMORY_RESOURCE
+
+/**
+    memory_resource synopsis
+
+// C++17
+
+namespace std {
+namespace pmr {
+
+  // Global memory resources
+  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 pmr
+} // namespace std
+
+ */
+
+#include <__config>
+#include <__functional_base>
+#include <__memory_resource_base>
+#include <limits>
+#include <memory>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#include <mutex>
+#endif
+#include <new>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <cstddef>
+#include <cstdlib>
+#include <__debug>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr
+{
+
+// 23.12.4, mem.res.global
+
+_LIBCPP_FUNC_VIS
+memory_resource * new_delete_resource() _NOEXCEPT;
+
+_LIBCPP_FUNC_VIS
+memory_resource * null_memory_resource() _NOEXCEPT;
+
+
+// 23.12.5, mem.res.pool
+
+// 23.12.5.2, mem.res.pool.options
+
+struct pool_options {
+    size_t max_blocks_per_chunk = 0;
+    size_t largest_required_pool_block = 0;
+};
+
+// 23.12.5.1, mem.res.pool.overview
+
+
+struct __pool_resource_adhoc_pool_header;
+
+class __pool_resource_adhoc_pool {
+    using __header = __pool_resource_adhoc_pool_header;
+    __header *__first_;
+
+public:
+    explicit __pool_resource_adhoc_pool() : __first_(nullptr) {}
+    void release(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);
+};
+
+class __pool_resource_fixed_pool;
+
+class _LIBCPP_TYPE_VIS unsynchronized_pool_resource : public memory_resource
+{
+    static const size_t __smallest_block_size = 8;
+    static const int __log2_smallest_block_size = 3;
+
+    size_t __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_INLINE_VISIBILITY
+    unsynchronized_pool_resource()
+        : unsynchronized_pool_resource(pool_options(), get_default_resource()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit unsynchronized_pool_resource(memory_resource* __upstream)
+        : unsynchronized_pool_resource(pool_options(), __upstream) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit unsynchronized_pool_resource(const pool_options& __opts)
+        : unsynchronized_pool_resource(__opts, get_default_resource()) {}
+
+    unsynchronized_pool_resource(const unsynchronized_pool_resource&) = delete;
+
+    virtual ~unsynchronized_pool_resource();
+
+    unsynchronized_pool_resource& operator=(const unsynchronized_pool_resource&) = delete;
+
+    void release();
+
+    _LIBCPP_INLINE_VISIBILITY
+    memory_resource* upstream_resource() const
+        { return __res_; }
+
+    _LIBCPP_INLINE_VISIBILITY
+    pool_options options() const
+        { return __options_; }
+
+protected:
+    void* do_allocate(size_t __bytes, size_t __align);
+
+    void do_deallocate(void* __p, size_t __bytes, size_t __align);
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool do_is_equal(const memory_resource& __other) const _NOEXCEPT
+        { return this == _VSTD::addressof(__other); }
+
+private:
+    memory_resource *__res_;
+    __pool_resource_adhoc_pool __adhoc_pool_;
+    __pool_resource_fixed_pool *__fixed_pools_;
+    int __num_fixed_pools_;
+    pool_options __options_;
+};
+
+class _LIBCPP_TYPE_VIS synchronized_pool_resource : public memory_resource
+{
+public:
+    synchronized_pool_resource(const pool_options& __opts, memory_resource* __upstream)
+        : __unsync_(__opts, __upstream) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    synchronized_pool_resource()
+        : synchronized_pool_resource(pool_options(), get_default_resource()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit synchronized_pool_resource(memory_resource* __upstream)
+        : synchronized_pool_resource(pool_options(), __upstream) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit synchronized_pool_resource(const pool_options& __opts)
+        : synchronized_pool_resource(__opts, get_default_resource()) {}
+
+    synchronized_pool_resource(const synchronized_pool_resource&) = delete;
+
+    virtual ~synchronized_pool_resource();
+
+    synchronized_pool_resource& operator=(const synchronized_pool_resource&) = delete;
+
+    void release() {
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+        unique_lock<mutex> __lk(__mut_);
+#endif
+        __unsync_.release();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    memory_resource* upstream_resource() const
+        { return __unsync_.upstream_resource(); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    pool_options options() const
+        { return __unsync_.options(); }
+
+protected:
+    void* do_allocate(size_t __bytes, size_t __align) {
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+        unique_lock<mutex> __lk(__mut_);
+#endif
+        return __unsync_.allocate(__bytes, __align);
+    }
+
+    void do_deallocate(void* __p, size_t __bytes, size_t __align) {
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+        unique_lock<mutex> __lk(__mut_);
+#endif
+        return __unsync_.deallocate(__p, __bytes, __align);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool do_is_equal(const memory_resource& __other) const _NOEXCEPT
+        { return this == _VSTD::addressof(__other); }
+
+private:
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+    mutex __mut_;
+#endif
+    unsynchronized_pool_resource __unsync_;
+};
+
+// 23.12.6, mem.res.monotonic.buffer
+
+struct __monotonic_buffer_header {
+    void *__start_;
+    __monotonic_buffer_header *__next_;
+    size_t __capacity_;
+    size_t __alignment_;
+    size_t __used_;
+};
+
+class _LIBCPP_TYPE_VIS monotonic_buffer_resource : public memory_resource
+{
+    static const size_t __default_buffer_capacity = 1024;
+    static const size_t __default_buffer_alignment = 16;
+
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    explicit monotonic_buffer_resource(memory_resource* __upstream)
+        : monotonic_buffer_resource(nullptr, __default_buffer_capacity, __upstream) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    monotonic_buffer_resource(size_t __initial_size, memory_resource* __upstream)
+        : monotonic_buffer_resource(nullptr, __initial_size, __upstream) {}
+
+    monotonic_buffer_resource(void* __buffer, size_t __buffer_size, memory_resource* __upstream);
+
+    _LIBCPP_INLINE_VISIBILITY
+    monotonic_buffer_resource()
+        : monotonic_buffer_resource(get_default_resource()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit monotonic_buffer_resource(size_t __initial_size)
+        : monotonic_buffer_resource(__initial_size, get_default_resource()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    monotonic_buffer_resource(void* __buffer, size_t __buffer_size)
+        : monotonic_buffer_resource(__buffer, __buffer_size, get_default_resource()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    monotonic_buffer_resource(const monotonic_buffer_resource&) = delete;
+
+    virtual ~monotonic_buffer_resource();
+
+    monotonic_buffer_resource& operator=(const monotonic_buffer_resource&) = delete;
+
+    void release();
+
+    _LIBCPP_INLINE_VISIBILITY
+    memory_resource* upstream_resource() const
+        { return __res_; }
+
+protected:
+    void* do_allocate(size_t __bytes, size_t __alignment);
+
+    _LIBCPP_INLINE_VISIBILITY
+    void do_deallocate(void*, size_t, size_t)
+        {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool do_is_equal(const memory_resource& __other) const _NOEXCEPT
+        { return this == _VSTD::addressof(__other); }
+
+private:
+    __monotonic_buffer_header __original_;
+    memory_resource* __res_;
+    size_t __next_buffer_size_;
+};
+
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif /* _LIBCPP_MEMORY_RESOURCE */

include/module.modulemap

module map {
     header "map"
     export initializer_list
     export *
   }
   module memory {
     header "memory"
     export *
   }
+  module memory_resource {
+    header "memory_resource"
+    export *
+  }
   module mutex {
     header "mutex"
     export *
   }
   module new {
     header "new"
     export *
   }

include/regex

 #include <initializer_list>
 #include <utility>
 #include <iterator>
 #include <string>
 #include <memory>
 #include <vector>
 #include <deque>
 
+#if _LIBCPP_STD_VER > 14
+#include <__memory_resource_base>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

     _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

include/set

 }  // std
 
 */
 
 #include <__config>
 #include <__tree>
 #include <functional>
 
+#if _LIBCPP_STD_VER > 14
+#include <__memory_resource_base>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Key, class _Compare = less<_Key>,
           class _Allocator = allocator<_Key> >
swap(multiset<_Key, _Compare, _Allocator>& __x,
      multiset<_Key, _Compare, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr
+{
+    template <class _KeyT, class _CompareT = _VSTD::less<_KeyT>>
+    using set = _VSTD::set<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
+
+    template <class _KeyT, class _CompareT = _VSTD::less<_KeyT>>
+    using multiset = _VSTD::multiset<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
+}
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 #endif  // _LIBCPP_SET

include/string

 #include <initializer_list>
 #include <__functional_base>
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #include <cstdint>
 #endif
 
 #include <__debug>
 
+#if _LIBCPP_STD_VER > 14
+#include <__memory_resource_base>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

         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

include/unordered_map

 */
 
 #include <__config>
 #include <__hash_table>
 #include <functional>
 #include <stdexcept>
 #include <tuple>
 
+#if _LIBCPP_STD_VER > 14
+#include <__memory_resource_base>
+#endif
+
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

 operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
            const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 {
     return !(__x == __y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr
+{
+    template <class _KeyT, class _ValueT, class _HashT = _VSTD::hash<_KeyT>, class _PredT = _VSTD::equal_to<_KeyT>>
+    using unordered_map = _VSTD::unordered_map<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<_VSTD::pair<const _KeyT, _ValueT>>>;
+
+    template <class _KeyT, class _ValueT, class _HashT = _VSTD::hash<_KeyT>, class _PredT = _VSTD::equal_to<_KeyT>>
+    using unordered_multimap = _VSTD::unordered_multimap<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<_VSTD::pair<const _KeyT, _ValueT>>>;
+}
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 #endif  // _LIBCPP_UNORDERED_MAP

include/unordered_set

 */
 
 #include <__config>
 #include <__hash_table>
 #include <functional>
 
 #include <__debug>
 
+#if _LIBCPP_STD_VER > 14
+#include <__memory_resource_base>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >

 operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
            const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
 {
     return !(__x == __y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr
+{
+    template <class _KeyT, class _HashT = _VSTD::hash<_KeyT>, class _PredT = _VSTD::equal_to<_KeyT>>
+    using unordered_set = _VSTD::unordered_set<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
+
+    template <class _KeyT, class _HashT = _VSTD::hash<_KeyT>, class _PredT = _VSTD::equal_to<_KeyT>>
+    using unordered_multiset = _VSTD::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
+}
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 #endif  // _LIBCPP_UNORDERED_SET

include/vector

 #include <stdexcept>
 #include <algorithm>
 #include <cstring>
 #include <__split_buffer>
 #include <__functional_base>
 
 #include <__debug>
 
+#if _LIBCPP_STD_VER > 14
+#include <__memory_resource_base>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

 swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 14
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace pmr
+{
+    template <class _ValueT>
+    using vector = _VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>;
+}
+_LIBCPP_END_NAMESPACE_STD
+#endif
+
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_VECTOR

src/memory_resource.cpp

+//===------------------------ memory_resource.cpp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "memory_resource"
+
+#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
+#include "atomic"
+#endif
+#include "memory"
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#include "mutex"
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+
+// memory_resource
+
+// new_delete_resource()
+
+class _LIBCPP_TYPE_VIS __new_delete_memory_resource_imp
+    : public memory_resource
+{
+public:
+    ~__new_delete_memory_resource_imp() = default;
+
+protected:
+    virtual void* do_allocate(size_t __size, size_t __align)
+        { return _VSTD::__libcpp_allocate(__size, __align); /* FIXME */}
+
+    virtual void do_deallocate(void * __p, size_t, size_t __align)
+        { _VSTD::__libcpp_deallocate(__p, __align); /* FIXME */ }
+
+    virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT
+        { return &__other == this; }
+};
+
+// null_memory_resource()
+
+class _LIBCPP_TYPE_VIS __null_memory_resource_imp
+    : public memory_resource
+{
+public:
+    ~__null_memory_resource_imp() = default;
+
+protected:
+    virtual void* do_allocate(size_t, size_t) {
+        __throw_bad_alloc();
+    }
+    virtual void do_deallocate(void *, size_t, size_t) {}
+    virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT
+    { 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() {}
+};
+// When compiled in C++14 this initialization should be a constant expression.
+// Only in C++11 is "init_priority" needed to ensure initialization order.
+#if _LIBCPP_STD_VER > 11
+_LIBCPP_SAFE_STATIC
+#endif
+ResourceInitHelper res_init  __attribute__((init_priority (101)));
+
+} // 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::memory_order_acq_rel);
+    }
+    else {
+        return _VSTD::atomic_load_explicit(
+            &__res, memory_order::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 __pool_resource_adhoc_pool_header {
+    size_t bytes;
+    size_t alignment;
+    void *allocation;
+    __pool_resource_adhoc_pool_header *next;
+};
+
+void __pool_resource_adhoc_pool::release(memory_resource *upstream)
+{
+    while (__first_ != nullptr) {
+        __header *next = __first_->next;
+        upstream->deallocate(__first_->allocation, __first_->bytes, __first_->alignment);
+        __first_ = next;
+    }
+}
+
+void *__pool_resource_adhoc_pool::do_allocate(memory_resource *upstream, size_t bytes, size_t align)
+{
+    const size_t header_size = sizeof(__header);
+    const size_t header_align = alignof(__header);
+
+    if (align < header_align) {
+        align = header_align;
+    }
+
+    size_t aligned_capacity = roundup(bytes, header_align) + header_size;
+
+    void *result = upstream->allocate(aligned_capacity, align);
+
+    __header *h = (__header *)((char *)result + aligned_capacity - header_size);
+    h->allocation = result;
+    h->bytes = aligned_capacity;
+    h->alignment = align;
+    h->next = __first_;
+    __first_ = h;
+    return result;
+}
+
+void __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_->allocation == p) {
+        __header *next = __first_->next;
+        upstream->deallocate(p, bytes, align);
+        __first_ = next;
+    } else {
+        for (__header *h = __first_; h != nullptr; h = h->next) {
+            if (h->next != nullptr && h->next->allocation == p) {
+                __header *next = h->next->next;
+                upstream->deallocate(p, bytes, align);
+                h->next = next;
+                return;
+            }
+        }
+        _LIBCPP_ASSERT(false, "deallocating a block that was not allocated with this allocator");
+    }
+}
+
+struct __pool_resource_vacancy_header {
+    __pool_resource_vacancy_header *next_vacancy;
+};
+
+struct __pool_resource_fixed_pool_header {
+    __pool_resource_vacancy_header *first_vacancy;
+    size_t bytes;
+    size_t alignment;
+    void *allocation;
+    __pool_resource_fixed_pool_header *next;
+
+    bool allocation_contains(const char *p) const {
+        // TODO: This part technically relies on undefined behavior.
+        return allocation <= p && p < ((char*)allocation + bytes);
+    }
+};
+
+class __pool_resource_fixed_pool {
+    using __header = __pool_resource_fixed_pool_header;
+    __header *__first_;
+
+public:
+    explicit __pool_resource_fixed_pool() : __first_(nullptr) {}
+    void release(memory_resource *upstream);
+    void *try_allocate_from_vacancies();
+    void *do_allocate_with_new_chunk(memory_resource *upstream, size_t block_size);
+    void do_evacuate(void *__p);
+
+    static const size_t __default_alignment = alignof(max_align_t);
+};
+
+void __pool_resource_fixed_pool::release(memory_resource *upstream)
+{
+    while (__first_ != nullptr) {
+        __header *next = __first_->next;
+        upstream->deallocate(__first_->allocation, __first_->bytes, __first_->alignment);
+        __first_ = next;
+    }
+}
+
+void *__pool_resource_fixed_pool::try_allocate_from_vacancies()
+{
+    for (__header *h = __first_; h != nullptr; h = h->next) {
+        if (h->first_vacancy != nullptr) {
+            void *result = h->first_vacancy;
+            h->first_vacancy = h->first_vacancy->next_vacancy;
+            return result;
+        }
+    }
+    return nullptr;
+}
+
+void *__pool_resource_fixed_pool::do_allocate_with_new_chunk(memory_resource *upstream, size_t block_size)
+{
+    static_assert(__default_alignment >= alignof(std::max_align_t), "");
+    static_assert(__default_alignment >= alignof(__header), "");
+    static_assert(__default_alignment >= alignof(__pool_resource_vacancy_header), "");
+
+    const size_t header_size = sizeof(__header);
+
+    size_t aligned_capacity = roundup(block_size, alignof(__header)) + header_size;
+
+    void *result = upstream->allocate(aligned_capacity, __default_alignment);
+
+    __header *h = (__header *)((char *)result + aligned_capacity - header_size);
+    h->allocation = result;
+    h->bytes = aligned_capacity;
+    h->alignment = __default_alignment;
+    h->next = __first_;
+    h->first_vacancy = nullptr;
+    __first_ = h;
+    return result;
+}
+
+void __pool_resource_fixed_pool::do_evacuate(void *p)
+{
+    _LIBCPP_ASSERT(__first_ != nullptr, "deallocating a block that was not allocated with this allocator");
+    for (__header *h = __first_; h != nullptr; h = h->next) {
+        if (h->allocation_contains((char*)p)) {
+            __pool_resource_vacancy_header *v = (__pool_resource_vacancy_header *)(p);
+            v->next_vacancy = h->first_vacancy;
+            h->first_vacancy = v;
+            return;
+        }
+    }
+    _LIBCPP_ASSERT(false, "deallocating a block that was not allocated with this allocator");
+}
+
+size_t unsynchronized_pool_resource::__pool_block_size(int i) const
+{
+    return size_t(1) << (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 > (1 << __num_fixed_pools_)) {
+        return __num_fixed_pools_;
+    } else if (bytes <= __smallest_block_size) {
+        return 0;
+    } else {
+        int i = 0;
+        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), __options_(opts)
+{
+    if (__options_.largest_required_pool_block == 0) {
+        __options_.largest_required_pool_block = (size_t(1) << 20);
+    } else if (__options_.largest_required_pool_block < __smallest_block_size) {
+        __options_.largest_required_pool_block = __smallest_block_size;
+    } else if (__options_.largest_required_pool_block > (size_t(1) << 30)) {
+        __options_.largest_required_pool_block = (size_t(1) << 30);
+    }
+    __num_fixed_pools_ = 1;
+    size_t capacity = __smallest_block_size;
+    while (capacity < __options_.largest_required_pool_block) {
+        capacity <<= 1;
+        __num_fixed_pools_ += 1;
+    }
+
+    __options_.max_blocks_per_chunk = 0;
+}
+
+unsynchronized_pool_resource::~unsynchronized_pool_resource()
+{
+    release();
+}
+
+void unsynchronized_pool_resource::release()
+{
+    __adhoc_pool_.release(__res_);
+    if (__fixed_pools_ != nullptr) {
+        const int n = __num_fixed_pools_;
+        for (int i=0; i < n; ++i) {
+            __fixed_pools_[i].release(__res_);
+        }
+        __res_->deallocate(__fixed_pools_, __num_fixed_pools_ * sizeof(__pool_resource_fixed_pool), alignof(__pool_resource_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) {
+            using P = __pool_resource_fixed_pool;
+            __fixed_pools_ = (P*)__res_->allocate(__num_fixed_pools_ * sizeof(P), alignof(P));
+            P *first = __fixed_pools_;
+            P *last = __fixed_pools_ + __num_fixed_pools_;
+            for (P *pool = first; pool != last; ++pool) {
+                ::new((void*)pool) P;
+            }
+        }
+        void *result = __fixed_pools_[i].try_allocate_from_vacancies();
+        if (result == nullptr) {
+            result = __fixed_pools_[i].do_allocate_with_new_chunk(__res_, __pool_block_size(i));
+        }
+        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].do_evacuate(p);
+    }
+}
+
+// 23.12.6, mem.res.monotonic.buffer
+
+static void *try_allocate_from_chunk(__monotonic_buffer_header *header, size_t bytes, size_t align)
+{
+    if (!header || !header->__start_) return nullptr;
+    if (header->__capacity_ < bytes) return nullptr;
+    void *new_ptr = static_cast<char *>(header->__start_) + header->__used_;
+    size_t new_capacity = (header->__capacity_ - header->__used_);
+    void *aligned_ptr = _VSTD::align(align, bytes, new_ptr, new_capacity);
+    if (aligned_ptr == nullptr) {
+        return nullptr;
+    }
+    header->__used_ = (header->__capacity_ - new_capacity) + bytes;
+    return aligned_ptr;
+}
+
+monotonic_buffer_resource::monotonic_buffer_resource(void* buffer, size_t buffer_size, memory_resource* upstream)
+    : __res_(upstream)
+{
+    __original_.__start_ = buffer;
+    __original_.__next_ = nullptr;
+    __original_.__capacity_ = buffer_size;
+    __original_.__alignment_ = 1;
+    __original_.__used_ = 0;
+    __next_buffer_size_ = buffer_size >= 1 ? buffer_size : 1;
+}
+
+monotonic_buffer_resource::~monotonic_buffer_resource()
+{
+    release();
+}
+
+void monotonic_buffer_resource::release()
+{
+    const size_t header_size = sizeof(__monotonic_buffer_header);
+
+    __original_.__used_ = 0;
+    while (__original_.__next_ != nullptr) {
+        __monotonic_buffer_header *header = __original_.__next_;
+        __monotonic_buffer_header *next_header = header->__next_;
+        size_t aligned_capacity = header->__capacity_ + header_size;
+        __res_->deallocate(header->__start_, aligned_capacity, header->__alignment_);
+        __original_.__next_ = next_header;
+    }
+}
+
+void* monotonic_buffer_resource::do_allocate(size_t bytes, size_t align)
+{
+    if (void *result = try_allocate_from_chunk(&__original_, bytes, align)) {
+        return result;
+    }
+    if (void *result = try_allocate_from_chunk(__original_.__next_, bytes, align)) {
+        return result;
+    }
+    // Allocate a brand-new chunk.
+    const size_t header_size = sizeof(__monotonic_buffer_header);
+    const size_t header_align = alignof(__monotonic_buffer_header);
+
+    if (align < header_align) {
+        align = header_align;
+    }
+
+    size_t aligned_capacity = roundup(bytes, header_align) + header_size;
+
+    if (aligned_capacity < __next_buffer_size_) {
+        aligned_capacity = roundup(__next_buffer_size_ - header_size, header_align) + header_size;
+    }
+
+    void *result = __res_->allocate(aligned_capacity, align);
+    __monotonic_buffer_header *header = (__monotonic_buffer_header *)((char *)result + aligned_capacity - header_size);
+    header->__start_ = result;
+    header->__capacity_ = aligned_capacity - header_size;
+    header->__alignment_ = align;
+    header->__used_ = 0;
+    header->__next_ = __original_.__next_;
+    __original_.__next_ = header;
+
+    size_t prospective_next_buffer_size = (__next_buffer_size_ * 5) / 4;
+    if (prospective_next_buffer_size <= __next_buffer_size_) {
+        prospective_next_buffer_size = __next_buffer_size_ + 1;
+    }
+    __next_buffer_size_ = prospective_next_buffer_size;
+
+    return try_allocate_from_chunk(__original_.__next_, bytes, align);
+}
+
+
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD

test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp

 // 'tuple<Args1...>' and 'tuple<Args2...>'.
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
 #include <cstdlib>
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 template <class T>
 struct TestHarness {
     TestResource R;
     ex::memory_resource * M = &R;
     ex::polymorphic_allocator<T> A = M;

test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp

 int AssertCount = 0;
 
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
 #define _LIBCPP_DEBUG 0
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     using Alloc = ex::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);
 }

test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp

 int AssertCount = 0;
 
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
 #define _LIBCPP_DEBUG 0
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     using Alloc = NullAllocator<char>;
     using R = ex::resource_adaptor<Alloc>;
     AllocController P;

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp

 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator<T>::polymorphic_allocator() noexcept
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     {
         static_assert(
             std::is_nothrow_default_constructible<ex::polymorphic_allocator<void>>::value

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp

 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator<T>::polymorphic_allocator(memory_resource *)
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     {
         typedef ex::polymorphic_allocator<void> A;
         static_assert(

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp

 // bool operator==(
 //      polymorphic_allocator<T> const &
 //    , polymorphic_allocator<U> const &) noexcept
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     typedef ex::polymorphic_allocator<void> A1;
     typedef ex::polymorphic_allocator<int> A2;
     // check return types

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp

 // bool operator!=(
 //      polymorphic_allocator<T> const &
 //    , polymorphic_allocator<T> const &) noexcept
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     typedef ex::polymorphic_allocator<void> A1;
     typedef ex::polymorphic_allocator<int> A2;
     // check return types

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp

 #include <experimental/memory_resource>
 #include <limits>
 #include <memory>
 #include <exception>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 template <size_t S, size_t Align>
 void testForSizeAndAlign() {
     using T = typename std::aligned_storage<S, Align>::type;
     TestResource R;
     ex::polymorphic_allocator<T> a(&R);

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

 #include <experimental/memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 #include "uses_alloc_types.hpp"
 #include "controlled_allocators.hpp"
 #include "test_allocator.h"
 
 namespace ex = std::experimental::pmr;
 
 
 template <class UA1, class UA2, class TT, class UU>

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp

 #include <experimental/memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 #include "uses_alloc_types.hpp"
 #include "controlled_allocators.hpp"
 #include "test_allocator.h"
 
 namespace ex = std::experimental::pmr;
 
 
 

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp

 #include <experimental/memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 #include "uses_alloc_types.hpp"
 #include "controlled_allocators.hpp"
 #include "test_allocator.h"
 
 namespace ex = std::experimental::pmr;
 
 
 template <class UA1, class UA2, class TT, class UU>

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp

 #include <experimental/memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 #include "uses_alloc_types.hpp"
 #include "controlled_allocators.hpp"
 #include "test_allocator.h"
 
 namespace ex = std::experimental::pmr;
 
 template <class T, class U, class ...TTuple, class ...UTuple>
 bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp

 // void polymorphic_allocator<T>::construct(U *, Args &&...)
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 #include "uses_alloc_types.hpp"
 #include "controlled_allocators.hpp"
 #include "test_allocator.h"
 
 namespace ex = std::experimental::pmr;
 
 template <class T>
 struct PMATest {

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp

 // template <class T> class polymorphic_allocator
 
 // T* polymorphic_allocator<T>::deallocate(T*, size_t size)
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 template <size_t S, size_t Align>
 void testForSizeAndAlign() {
     using T = typename std::aligned_storage<S, Align>::type;
 
     TestResource R;

test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp

 
 // template <class Alloc> class resource_adaptor_imp;
 
 // resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc const &)
 
 #include <experimental/memory_resource>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     typedef CountingAllocator<char> AllocT;
     typedef ex::resource_adaptor<AllocT> R;
     {

test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp

 
 // template <class Alloc> class resource_adaptor_imp;
 
 // resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc &&)
 
 #include <experimental/memory_resource>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     typedef CountingAllocator<char> AllocT;
     typedef ex::resource_adaptor<AllocT> R;
     {

test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp

 
 // resource_adaptor_imp<Alloc>::resource_adaptor_imp() = default;
 
 #include <experimental/memory_resource>
 #include <memory>
 #include <type_traits>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     {
         typedef CountingAllocator<char> AllocT; // Not default constructible
         typedef ex::resource_adaptor<AllocT> R;

test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp

 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <memory>
 #include <exception>
 #include <cassert>
 
 #include "test_macros.h"
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 template <class Alloc>
 void check_allocate_deallocate()
 {
     typedef ex::resource_adaptor<Alloc> R1;
     const std::size_t max_align = alignof(std::max_align_t);

test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp

 // template <class Alloc> class resource_adaptor_imp;
 
 // bool do_is_equal(memory_resource const &) const noexcept;
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <memory>
 #include <cassert>
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 using std::size_t;
 namespace ex = std::experimental::pmr;
 
 int main()
 {
 
     typedef CountingAllocator<char> Alloc1;

test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp

 //  E) 'set_default_resource(null)' sets the default resource to
 //     'new_delete_resource()'.
 //  F) 'get_default_resource' and 'set_default_resource' are noexcept.
 
 
 #include <experimental/memory_resource>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 using namespace std::experimental::pmr;
 
 int main() {
     TestResource R;
     { // Test (A) and (B)
         memory_resource* p = get_default_resource();
         assert(p != nullptr);

test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp

 
 // bool operator==(memory_resource const &, memory_resource const &) noexcept;
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     // check return types
     {
         ex::memory_resource const * mr1(nullptr);

test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp

 // <experimental/memory_resource>
 
 // bool operator!=(memory_resource const &, memory_resource const &) noexcept;
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 namespace ex = std::experimental::pmr;
 
 int main()
 {
     // check return types
     {
         ex::memory_resource const * mr1(nullptr);

test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp

 //  E) If 'do_allocate' throws then 'allocate' propagates that exception.
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 using std::experimental::pmr::memory_resource;
 
 int main()
 {
     TestResource R(42);
     auto& P = R.getController();
     memory_resource& M = R;

test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp

 //  D) Invoking 'deallocate' invokes 'do_deallocate' with the same arguments.
 
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cstddef>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 using std::experimental::pmr::memory_resource;
 
 int main()
 {
     NullResource R(42);
     auto& P = R.getController();
     memory_resource& M = R;

test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp

 //  A) 'memory_resource' is destructible.
 //  B) The destructor is implicitly marked noexcept.
 //  C) The destructor is marked virtual.
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 using std::experimental::pmr::memory_resource;
 
 int main()
 {
     static_assert(
         std::has_virtual_destructor<memory_resource>::value
       , "Must have virtual destructor"

test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp

 //   B) 'is_equal' is noexcept.
 //   C) 'do_is_equal' is called using the same arguments passed to 'is_equal'
 //      and the resulting value is returned.
 //   D) 'do_is_equal' is called on the LHS object and not the RHS object.
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
-#include "test_memory_resource.hpp"
+#include "test_experimental_memory_resource.hpp"
 
 using std::experimental::pmr::memory_resource;
 
 int main()
 {
     {
         memory_resource const* r1 = nullptr;
         memory_resource const* r2 = nullptr;

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator operator=(polymorphic_allocator const &) = delete
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+    typedef std::pmr::polymorphic_allocator<void> T;
+    static_assert(!std::is_copy_assignable<T>::value, "");
+    static_assert(!std::is_move_assignable<T>::value, "");
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator const &);
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+    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);
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator<T>::polymorphic_allocator() noexcept
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::pmr;
+
+int main()
+{
+    {
+        static_assert(
+            std::is_nothrow_default_constructible<ex::polymorphic_allocator<void>>::value
+          , "Must me nothrow default constructible"
+          );
+    }
+    {
+        // test that the allocator gets its resource from get_default_resource
+        TestResource R1(42);
+        ex::set_default_resource(&R1);
+
+        typedef ex::polymorphic_allocator<void> A;
+        A const a;
+        assert(a.resource() == &R1);
+
+        ex::set_default_resource(nullptr);
+        A const a2;
+        assert(a.resource() == &R1);
+        assert(a2.resource() == ex::new_delete_resource());
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator<T>::polymorphic_allocator(memory_resource *)
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::pmr;
+
+int main()
+{
+    {
+        typedef ex::polymorphic_allocator<void> A;
+        static_assert(
+            std::is_convertible<decltype(nullptr), A>::value
+          , "Must be convertible"
+          );
+        static_assert(
+            std::is_convertible<ex::memory_resource *, A>::value
+          , "Must be convertible"
+          );
+    }
+    {
+        typedef ex::polymorphic_allocator<void> A;
+        TestResource R;
+        A const a(&R);
+        assert(a.resource() == &R);
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U>
+// polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator<U> const &);
+
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A1;
+    typedef ex::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((ex::memory_resource*)42);
+        A2 const a2(a);
+        assert(a.resource() == a2.resource());
+        assert(a2.resource() == (ex::memory_resource*)42);
+    }
+    {
+        A1 a((ex::memory_resource*)42);
+        A2 const a2(std::move(a));
+        assert(a.resource() == a2.resource());
+        assert(a2.resource() == (ex::memory_resource*)42);
+    }
+}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.eq/equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator;
+
+// template <class T, class U>
+// bool operator==(
+//      polymorphic_allocator<T> const &
+//    , polymorphic_allocator<U> const &) noexcept
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A1;
+    typedef ex::polymorphic_allocator<int> A2;
+    // check return types
+    {
+        A1 const a1;
+        A2 const a2;
+        static_assert(std::is_same<decltype(a1 == a2), bool>::value, "");
+        static_assert(noexcept(a1 == a2), "");
+    }
+    // equal same type (different resource)
+    {
+        TestResource d1(1);
+        TestResource d2(1);
+        A1 const a1(&d1);
+        A1 const a2(&d2);
+
+        assert(a1 == a2);
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(a2 == a1);
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+    }
+    // equal same type (same resource)
+    {
+        TestResource d1;
+        A1 const a1(&d1);
+        A1 const a2(&d1);
+
+        assert(a1 == a2);
+        assert(d1.checkIsEqualCalledEq(0));
+
+        assert(a2 == a1);
+        assert(d1.checkIsEqualCalledEq(0));
+    }
+    // equal different type (different resource)
+    {
+        TestResource d1(42);
+        TestResource d2(42);
+        A1 const a1(&d1);
+        A2 const a2(&d2);
+
+        assert(a1 == a2);
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        assert(a2 == a1);
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(1));
+
+    }
+    // equal different type (same resource)
+    {
+        TestResource d1(42);
+        A1 const a1(&d1);
+        A2 const a2(&d1);
+
+        assert(a1 == a2);
+        assert(d1.checkIsEqualCalledEq(0));
+
+        assert(a2 == a1);
+        assert(d1.checkIsEqualCalledEq(0));
+
+    }
+    // not equal same type
+    {
+        TestResource d1(1);
+        TestResource d2(2);
+        A1 const a1(&d1);
+        A1 const a2(&d2);
+
+        assert(!(a1 == a2));
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(!(a2 == a1));
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+
+    }
+    // not equal different types
+    {
+        TestResource  d1;
+        TestResource1 d2;
+        A1 const a1(&d1);
+        A2 const a2(&d2);
+
+        assert(!(a1 == a2));
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(!(a2 == a1));
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+    }
+}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.eq/not_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator;
+
+// template <class T>
+// bool operator!=(
+//      polymorphic_allocator<T> const &
+//    , polymorphic_allocator<T> const &) noexcept
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A1;
+    typedef ex::polymorphic_allocator<int> A2;
+    // check return types
+    {
+        A1 const a1;
+        A2 const a2;
+        static_assert(std::is_same<decltype(a1 != a2), bool>::value, "");
+        static_assert(noexcept(a1 != a2), "");
+    }
+    // not equal same type (different resource)
+    {
+        TestResource d1(1);
+        TestResource d2(2);
+        A1 const a1(&d1);
+        A1 const a2(&d2);
+
+        assert(a1 != a2);
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(a2 != a1);
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+    }
+    // equal same type (same resource)
+    {
+        TestResource d1;
+        A1 const a1(&d1);
+        A1 const a2(&d1);
+
+        assert(!(a1 != a2));
+        assert(d1.checkIsEqualCalledEq(0));
+
+        assert(!(a2 != a1));
+        assert(d1.checkIsEqualCalledEq(0));
+    }
+    // equal same type
+    {
+        TestResource d1(1);
+        TestResource d2(1);
+        A1 const a1(&d1);
+        A1 const a2(&d2);
+
+        assert(!(a1 != a2));
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(!(a2 != a1));
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+
+    }
+    // not equal different types
+    {
+        TestResource  d1;
+        TestResource1 d2;
+        A1 const a1(&d1);
+        A2 const a2(&d2);
+
+        assert(a1 != a2);
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(a2 != a1);
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// T* polymorphic_allocator<T>::allocate(size_t n)
+
+#include <memory_resource>
+#include <limits>
+#include <memory>
+#include <exception>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+
+namespace ex = std::pmr;
+
+template <size_t S, size_t Align>
+void testForSizeAndAlign() {
+    using T = typename std::aligned_storage<S, Align>::type;
+    TestResource R;
+    ex::polymorphic_allocator<T> a(&R);
+
+    for (int N = 1; N <= 5; ++N) {
+        auto ret = a.allocate(N);
+        assert(R.checkAlloc(ret, N * sizeof(T), alignof(T)));
+
+        a.deallocate(ret, N);
+        R.reset();
+    }
+}
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+template <size_t S>
+void testAllocForSizeThrows() {
+    using T = typename std::aligned_storage<S>::type;
+    using Alloc = ex::polymorphic_allocator<T>;
+    using Traits = std::allocator_traits<Alloc>;
+    NullResource R;
+    Alloc a(&R);
+
+    // Test that allocating exactly the max size does not throw.
+    size_t maxSize = Traits::max_size(a);
+    try {
+        a.allocate(maxSize);
+    } catch (...) {
+        assert(false);
+    }
+
+    size_t sizeTypeMax = std::numeric_limits<std::size_t>::max();
+    if (maxSize != sizeTypeMax)
+    {
+        // Test that allocating size_t(~0) throws bad alloc.
+        try {
+            a.allocate(sizeTypeMax);
+            assert(false);
+        } catch (std::exception const&) {
+        }
+
+        // Test that allocating even one more than the max size does throw.
+        size_t overSize = maxSize + 1;
+        try {
+            a.allocate(overSize);
+            assert(false);
+        } catch (std::exception const&) {
+        }
+    }
+}
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+int main()
+{
+    {
+        ex::polymorphic_allocator<int> a;
+        static_assert(std::is_same<decltype(a.allocate(0)), int*>::value, "");
+        static_assert(!noexcept(a.allocate(0)), "");
+    }
+    {
+        constexpr std::size_t MA = alignof(std::max_align_t);
+        testForSizeAndAlign<1, 1>();
+        testForSizeAndAlign<1, 2>();
+        testForSizeAndAlign<1, MA>();
+        testForSizeAndAlign<2, 2>();
+        testForSizeAndAlign<73, alignof(void*)>();
+        testForSizeAndAlign<73, MA>();
+        testForSizeAndAlign<13, MA>();
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        testAllocForSizeThrows<1>();
+        testAllocForSizeThrows<2>();
+        testAllocForSizeThrows<4>();
+        testAllocForSizeThrows<8>();
+        testAllocForSizeThrows<16>();
+        testAllocForSizeThrows<73>();
+        testAllocForSizeThrows<13>();
+    }
+#endif
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <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 <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+
+namespace ex = std::pmr;
+
+int constructed = 0;
+
+struct default_constructible
+{
+    default_constructible() : x(42)  { ++constructed; }
+    int x{0};
+};
+
+int main()
+{
+    // pair<default_constructible, default_constructible> as T()
+    {
+        typedef default_constructible T;
+        typedef std::pair<T, T> P;
+        typedef ex::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);
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <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> const&)
+
+#include <memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+#include "test_allocator.h"
+
+
+template <class UA1, class UA2, class TT, class UU>
+bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
+            std::pair<TT, UU> const& p)
+{
+    using P = std::pair<UA1, UA2>;
+    TestResource R;
+    std::pmr::memory_resource * M = &R;
+    std::pmr::polymorphic_allocator<P> A(M);
+    P * ptr = (P*)std::malloc(sizeof(P));
+    P * ptr2 =  (P*)std::malloc(sizeof(P));
+
+    // UNDER TEST //
+    A.construct(ptr, p);
+
+    A.construct(ptr2, std::piecewise_construct,
+                std::forward_as_tuple(p.first),
+                std::forward_as_tuple(p.second));
+    // ------- //
+
+    bool tres = checkConstruct<decltype((p.first))>(ptr->first, TExpect, M) &&
+                checkConstructionEquiv(ptr->first, ptr2->first);
+
+    bool ures = checkConstruct<decltype((p.second))>(ptr->second, UExpect, M) &&
+                checkConstructionEquiv(ptr->second, ptr2->second);
+
+    A.destroy(ptr);
+    std::free(ptr);
+    A.destroy(ptr2);
+    std::free(ptr2);
+    return tres && ures;
+
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_uses_allocator(std::pair<TT, UU> const& p)
+{
+    {
+        using T = NotUsesAllocator<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, p)));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, 1>;
+        using U = UsesAllocatorV2<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_AllocLast, p)));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, 1>;
+        using U = UsesAllocatorV3<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocLast, UA_AllocArg, p)));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_None, p)));
+    }
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_not_uses_allocator(std::pair<TT, UU> const& p)
+{
+    {
+        using T = NotUsesAllocator<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, p)));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, 1>;
+        using U = UsesAllocatorV2<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, p)));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, 1>;
+        using U = UsesAllocatorV3<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, p)));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, p)));
+    }
+}
+
+template <class Tp>
+struct Print;
+
+int main()
+{
+    using PMR = std::pmr::memory_resource*;
+    using PMA = std::pmr::polymorphic_allocator<char>;
+    {
+        int x = 42;
+        int y = 42;
+        const std::pair<int, int&> p(x, y);
+        test_pmr_not_uses_allocator<PMR>(p);
+        test_pmr_uses_allocator<PMA>(p);
+    }
+    {
+        int x = 42;
+        int y = 42;
+        const std::pair<int&, int&&> p(x, std::move(y));
+        test_pmr_not_uses_allocator<PMR>(p);
+        test_pmr_uses_allocator<PMA>(p);
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <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_memory_resource.hpp"
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+#include "test_allocator.h"
+
+
+template <class UA1, class UA2, class TT, class UU>
+bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
+            std::pair<TT, UU>&& p)
+{
+    using P = std::pair<UA1, UA2>;
+    TestResource R;
+    std::pmr::memory_resource * M = &R;
+    std::pmr::polymorphic_allocator<P> A(M);
+    P * ptr  = A.allocate(2);
+    P * ptr2 = ptr + 1;
+
+    // UNDER TEST //
+    A.construct(ptr, std::move(p));
+
+    A.construct(ptr2, std::piecewise_construct,
+                std::forward_as_tuple(std::forward<TT>(p.first)),
+                std::forward_as_tuple(std::forward<UU>(p.second)));
+    // ------- //
+
+    bool tres = checkConstruct<TT&&>(ptr->first, TExpect, M) &&
+                checkConstructionEquiv(ptr->first, ptr2->first);
+
+    bool ures = checkConstruct<UU&&>(ptr->second, UExpect, M) &&
+                checkConstructionEquiv(ptr->second, ptr2->second);
+
+    A.destroy(ptr);
+    A.destroy(ptr2);
+    A.deallocate(ptr, 2);
+    return tres && ures;
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_uses_allocator(std::pair<TT, UU>&& p)
+{
+    {
+        using T = NotUsesAllocator<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, 1>;
+        using U = UsesAllocatorV2<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_AllocLast, std::move(p))));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, 1>;
+        using U = UsesAllocatorV3<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocLast, UA_AllocArg, std::move(p))));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_None, std::move(p))));
+    }
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_not_uses_allocator(std::pair<TT, UU>&& p)
+{
+    {
+        using T = NotUsesAllocator<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, 1>;
+        using U = UsesAllocatorV2<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, 1>;
+        using U = UsesAllocatorV3<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+    }
+}
+
+int main()
+{
+    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));
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <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>*, U1&&, U2&&)
+
+#include <memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+#include "test_allocator.h"
+
+
+template <class UA1, class UA2, class TT, class UU>
+bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
+            TT&& t, UU&& u)
+{
+    using P = std::pair<UA1, UA2>;
+    TestResource R;
+    std::pmr::memory_resource * M = &R;
+    std::pmr::polymorphic_allocator<P> A(M);
+    P * ptr = (P*)std::malloc(sizeof(P));
+    P * ptr2 = (P*)std::malloc(sizeof(P));
+
+    // UNDER TEST //
+    A.construct(ptr, std::forward<TT>(t), std::forward<UU>(u));
+    A.construct(ptr2, std::piecewise_construct,
+                      std::forward_as_tuple(std::forward<TT>(t)),
+                      std::forward_as_tuple(std::forward<UU>(u)));
+    // ------- //
+
+    bool tres = checkConstruct<TT&&>(ptr->first, TExpect, M) &&
+                checkConstructionEquiv(ptr->first, ptr2->first);
+
+    bool ures = checkConstruct<UU&&>(ptr->second, UExpect, M) &&
+                checkConstructionEquiv(ptr->second, ptr2->second);
+
+    A.destroy(ptr);
+    A.destroy(ptr2);
+    std::free(ptr);
+    std::free(ptr2);
+    return tres && ures;
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_uses_allocator(TT&& t, UU&& u)
+{
+    {
+        using T = NotUsesAllocator<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, 1>;
+        using U = UsesAllocatorV2<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_AllocLast,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, 1>;
+        using U = UsesAllocatorV3<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocLast, UA_AllocArg,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_None,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_not_uses_allocator(TT&& t, UU&& u)
+{
+    {
+        using T = NotUsesAllocator<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, 1>;
+        using U = UsesAllocatorV2<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, 1>;
+        using U = UsesAllocatorV3<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+}
+
+int main()
+{
+    using PMR = std::pmr::memory_resource*;
+    using PMA = std::pmr::polymorphic_allocator<char>;
+    {
+        int x = 42;
+        int y = 42;
+        test_pmr_not_uses_allocator<PMR>(x, std::move(y));
+        test_pmr_uses_allocator<PMA>(x, std::move(y));
+    }
+    {
+        int x = 42;
+        const int y = 42;
+        test_pmr_not_uses_allocator<PMR>(std::move(x), y);
+        test_pmr_uses_allocator<PMA>(std::move(x), y);
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U1, class U2, class ...Args1, class ...Args2>
+// void polymorphic_allocator<T>::construct(pair<U1, U2>*, piecewise_construct_t
+//                                          tuple<Args1...>, tuple<Args2...>)
+
+#include <memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+#include "test_allocator.h"
+
+template <class T, class U, class ...TTuple, class ...UTuple>
+bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
+            std::tuple<TTuple...> ttuple, std::tuple<UTuple...> utuple)
+{
+    using P = std::pair<T, U>;
+    TestResource R;
+    std::pmr::memory_resource * M = &R;
+    std::pmr::polymorphic_allocator<P> A(M);
+    P * ptr = A.allocate(1);
+
+    // UNDER TEST //
+    A.construct(ptr, std::piecewise_construct, std::move(ttuple), std::move(utuple));
+    // ------- //
+    bool tres = checkConstruct<TTuple&&...>(ptr->first, TExpect, M);
+    bool ures = checkConstruct<UTuple&&...>(ptr->second, UExpect, M);
+
+    A.destroy(ptr);
+    A.deallocate(ptr, 1);
+    return tres && ures;
+}
+
+template <class Alloc, class ...TTypes, class ...UTypes>
+void test_pmr_uses_allocator(std::tuple<TTypes...> ttuple, std::tuple<UTypes...> utuple)
+{
+    {
+        using T = NotUsesAllocator<Alloc, sizeof...(TTypes)>;
+        using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::move(ttuple), std::move(utuple))));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, sizeof...(TTypes)>;
+        using U = UsesAllocatorV2<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_AllocArg, UA_AllocLast,
+                             std::move(ttuple), std::move(utuple))));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, sizeof...(TTypes)>;
+        using U = UsesAllocatorV3<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_AllocLast, UA_AllocArg,
+                             std::move(ttuple), std::move(utuple))));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, sizeof...(TTypes)>;
+        using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_AllocArg, UA_None,
+                             std::move(ttuple), std::move(utuple))));
+    }
+}
+
+template <class Alloc, class ...TTypes, class ...UTypes>
+void test_pmr_not_uses_allocator(std::tuple<TTypes...> ttuple, std::tuple<UTypes...> utuple)
+{
+    {
+        using T = NotUsesAllocator<Alloc, sizeof...(TTypes)>;
+        using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::move(ttuple), std::move(utuple))));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, sizeof...(TTypes)>;
+        using U = UsesAllocatorV2<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::move(ttuple), std::move(utuple))));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, sizeof...(TTypes)>;
+        using U = UsesAllocatorV3<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::move(ttuple), std::move(utuple))));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, sizeof...(TTypes)>;
+        using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::move(ttuple), std::move(utuple))));
+    }
+}
+
+int main()
+{
+    using PMR = std::pmr::memory_resource*;
+    using PMA = std::pmr::polymorphic_allocator<char>;
+    {
+        std::tuple<> t1;
+        test_pmr_not_uses_allocator<PMR>(t1, t1);
+        test_pmr_uses_allocator<PMA>(t1, t1);
+    }
+    {
+        std::tuple<int> t1(42);
+        std::tuple<> t2;
+        test_pmr_not_uses_allocator<PMR>(t1, t2);
+        test_pmr_not_uses_allocator<PMR>(t2, t1);
+        test_pmr_uses_allocator<PMA>(t1, t2);
+        test_pmr_uses_allocator<PMA>(t2, t1);
+    }
+    {
+        std::tuple<int> t1(42);
+        int x = 55;
+        double dx = 42.42;
+        std::tuple<int&, double&&> t2(x, std::move(dx));
+        test_pmr_not_uses_allocator<PMR>(           t1, std::move(t2));
+        test_pmr_not_uses_allocator<PMR>(std::move(t2),            t1);
+        test_pmr_uses_allocator<PMA>(           t1, std::move(t2));
+        test_pmr_uses_allocator<PMA>(std::move(t2),            t1);
+    }
+    {
+        void* xptr = nullptr;
+        long y = 4242;
+        std::tuple<int, long const&, void*&> t1(42, y, xptr);
+        int x = 55;
+        double dx = 42.42;
+        const char* s = "hello World";
+        std::tuple<int&, double&&, const char*> t2(x, std::move(dx), s);
+        test_pmr_not_uses_allocator<PMR>(           t1, std::move(t2));
+        test_pmr_not_uses_allocator<PMR>(std::move(t2),            t1);
+        test_pmr_uses_allocator<PMA>(           t1, std::move(t2));
+        test_pmr_uses_allocator<PMA>(std::move(t2),            t1);
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U1, class U2, class ...Args1, class ...Args2>
+// void polymorphic_allocator<T>::construct(pair<U1, U2>*, piecewise_construct_t
+//                                          tuple<Args1...>, tuple<Args2...>)
+
+#include <memory_resource>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <cassert>
+#include <cstdlib>
+
+#include "test_macros.h"
+
+template <class T>
+struct EvilAlloc {
+    explicit EvilAlloc() : inner_(std::pmr::null_memory_resource()) {}
+
+    EvilAlloc(std::pmr::polymorphic_allocator<T> & a) : inner_(a) {}
+    EvilAlloc(std::pmr::polymorphic_allocator<T> && a) : inner_(a) {}
+    EvilAlloc(std::pmr::polymorphic_allocator<T> const & a) = delete;
+    EvilAlloc(std::pmr::polymorphic_allocator<T> const && a) = delete;
+
+    using value_type = T;
+    template <class U> EvilAlloc(EvilAlloc<U> const & rhs) : inner_(rhs.inner_) {}
+
+    std::pmr::polymorphic_allocator<T> inner_;
+};
+
+struct WidgetV0 {
+    WidgetV0(int v) : value_(v) {}
+
+    bool holds(int v, const std::pmr::polymorphic_allocator<char>&) const {
+        return value_ == v;
+    }
+private:
+    int value_;
+};
+
+struct WidgetV1 {
+    using allocator_type = EvilAlloc<char>;
+
+    WidgetV1(int v) : value_(v), alloc_() {}
+    WidgetV1(std::allocator_arg_t, EvilAlloc<char> a, int v) : value_(v), alloc_(a) {}
+
+    bool holds(int v, const std::pmr::polymorphic_allocator<char>& a) const {
+        return value_ == v && alloc_.inner_ == a;
+    }
+private:
+    int value_;
+    EvilAlloc<char> alloc_;
+};
+
+struct WidgetV2 {
+    using allocator_type = EvilAlloc<char>;
+
+    WidgetV2(int v) : value_(v), alloc_() {}
+    WidgetV2(int v, EvilAlloc<char> a) : value_(v), alloc_(a) {}
+
+    bool holds(int v, std::pmr::polymorphic_allocator<char> a) const {
+        return value_ == v && alloc_.inner_ == a;
+    }
+private:
+    int value_;
+    EvilAlloc<char> alloc_;
+};
+
+struct WidgetV3 {
+    using allocator_type = EvilAlloc<char>;
+
+    WidgetV3(int v) : value_(v), alloc_() {}
+    WidgetV3(std::allocator_arg_t, EvilAlloc<char> a, int v) : value_(v), alloc_(a) {}
+    WidgetV3(int v, EvilAlloc<char> a) : value_(v), alloc_(a) {}
+
+    bool holds(int v, std::pmr::polymorphic_allocator<char> a) const {
+        return value_ == v && alloc_.inner_ == a;
+    }
+private:
+    int value_;
+    EvilAlloc<char> alloc_;
+};
+
+static_assert(std::uses_allocator<WidgetV1, EvilAlloc<char>>::value, "");
+static_assert(std::uses_allocator<WidgetV2, EvilAlloc<char>>::value, "");
+static_assert(std::uses_allocator<WidgetV3, EvilAlloc<char>>::value, "");
+static_assert(std::uses_allocator<WidgetV1, std::pmr::polymorphic_allocator<char>>::value, "");
+static_assert(std::uses_allocator<WidgetV2, std::pmr::polymorphic_allocator<char>>::value, "");
+static_assert(std::uses_allocator<WidgetV3, std::pmr::polymorphic_allocator<char>>::value, "");
+
+template<class W1, class W2>
+void test_evil()
+{
+    using PMA = std::pmr::polymorphic_allocator<char>;
+    PMA pma(std::pmr::new_delete_resource());
+    {
+        using Pair = std::pair<W1, W2>;
+        void *where = std::malloc(sizeof (Pair));
+        Pair *p = (Pair *)where;
+        pma.construct(p, std::piecewise_construct, std::make_tuple(42), std::make_tuple(42));
+        assert(p->first.holds(42, pma));
+        assert(p->second.holds(42, pma));
+        pma.destroy(p);
+        std::free(where);
+    }
+}
+
+int main()
+{
+    test_evil<WidgetV0, WidgetV0>();
+    test_evil<WidgetV0, WidgetV1>();
+    test_evil<WidgetV0, WidgetV2>();
+    test_evil<WidgetV0, WidgetV3>();
+    test_evil<WidgetV1, WidgetV0>();
+    test_evil<WidgetV1, WidgetV1>();
+    test_evil<WidgetV1, WidgetV2>();
+    test_evil<WidgetV1, WidgetV3>();
+    test_evil<WidgetV2, WidgetV0>();
+    test_evil<WidgetV2, WidgetV1>();
+    test_evil<WidgetV2, WidgetV2>();
+    test_evil<WidgetV2, WidgetV3>();
+    test_evil<WidgetV3, WidgetV0>();
+    test_evil<WidgetV3, WidgetV1>();
+    test_evil<WidgetV3, WidgetV2>();
+    test_evil<WidgetV3, WidgetV3>();
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U, class ...Args>
+// void polymorphic_allocator<T>::construct(U *, Args &&...)
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+#include <cstdlib>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+#include "test_allocator.h"
+
+template <class T>
+struct PMATest {
+    TestResource R;
+    std::pmr::polymorphic_allocator<T> A;
+    T* ptr;
+    bool constructed;
+
+    PMATest() : A(&R), ptr(A.allocate(1)), constructed(false) {}
+
+    template <class ...Args>
+    void construct(Args&&... args) {
+        A.construct(ptr, std::forward<Args>(args)...);
+        constructed = true;
+    }
+
+    ~PMATest() {
+        if (constructed) A.destroy(ptr);
+        A.deallocate(ptr, 1);
+    }
+};
+
+template <class T, class ...Args>
+bool doTest(UsesAllocatorType UAExpect, Args&&... args)
+{
+    PMATest<T> TH;
+    // UNDER TEST //
+    TH.construct(std::forward<Args>(args)...);
+    return checkConstruct<Args&&...>(*TH.ptr, UAExpect, &TH.R);
+    // ------- //
+}
+
+
+template <class T, class ...Args>
+bool doTestUsesAllocV0(Args&&... args)
+{
+    PMATest<T> TH;
+    // UNDER TEST //
+    TH.construct(std::forward<Args>(args)...);
+    return checkConstruct<Args&&...>(*TH.ptr, UA_None);
+    // -------- //
+}
+
+
+template <class T, class EAlloc, class ...Args>
+bool doTestUsesAllocV1(EAlloc const& ealloc, Args&&... args)
+{
+    PMATest<T> TH;
+    // UNDER TEST //
+    TH.construct(std::allocator_arg, ealloc, std::forward<Args>(args)...);
+    return checkConstruct<Args&&...>(*TH.ptr, UA_AllocArg, ealloc);
+    // -------- //
+}
+
+template <class T, class EAlloc, class ...Args>
+bool doTestUsesAllocV2(EAlloc const& ealloc, Args&&... args)
+{
+    PMATest<T> TH;
+    // UNDER TEST //
+    TH.construct(std::forward<Args>(args)..., ealloc);
+    return checkConstruct<Args&&...>(*TH.ptr, UA_AllocLast, ealloc);
+    // -------- //
+}
+
+template <class Alloc, class ...Args>
+void test_pmr_uses_alloc(Args&&... args)
+{
+    TestResource R(12435);
+    std::pmr::memory_resource* M = &R;
+    {
+        // NotUsesAllocator provides valid signatures for each uses-allocator
+        // construction but does not supply the required allocator_type typedef.
+        // Test that we can call these constructors manually without
+        // polymorphic_allocator interfering.
+        using T = NotUsesAllocator<Alloc, sizeof...(Args)>;
+        assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
+        assert((doTestUsesAllocV1<T>(M, std::forward<Args>(args)...)));
+        assert((doTestUsesAllocV2<T>(M, std::forward<Args>(args)...)));
+    }
+    {
+        // Test T(std::allocator_arg_t, Alloc const&, Args...) construction
+        using T = UsesAllocatorV1<Alloc, sizeof...(Args)>;
+        assert((doTest<T>(UA_AllocArg, std::forward<Args>(args)...)));
+    }
+    {
+        // Test T(Args..., Alloc const&) construction
+        using T = UsesAllocatorV2<Alloc, sizeof...(Args)>;
+        assert((doTest<T>(UA_AllocLast, std::forward<Args>(args)...)));
+    }
+    {
+        // Test that T(std::allocator_arg_t, Alloc const&, Args...) construction
+        // is preferred when T(Args..., Alloc const&) is also available.
+        using T = UsesAllocatorV3<Alloc, sizeof...(Args)>;
+        assert((doTest<T>(UA_AllocArg, std::forward<Args>(args)...)));
+    }
+}
+
+// Test that polymorphic_allocator does not prevent us from manually
+// doing non-pmr uses-allocator construction.
+template <class Alloc, class AllocObj, class ...Args>
+void test_non_pmr_uses_alloc(AllocObj const& A, Args&&... args)
+{
+    {
+        using T = NotUsesAllocator<Alloc, sizeof...(Args)>;
+        assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
+        assert((doTestUsesAllocV1<T>(A, std::forward<Args>(args)...)));
+        assert((doTestUsesAllocV2<T>(A, std::forward<Args>(args)...)));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, sizeof...(Args)>;
+        assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
+        assert((doTestUsesAllocV1<T>(A, std::forward<Args>(args)...)));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, sizeof...(Args)>;
+        assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
+        assert((doTestUsesAllocV2<T>(A, std::forward<Args>(args)...)));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, sizeof...(Args)>;
+        assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
+        assert((doTestUsesAllocV1<T>(A, std::forward<Args>(args)...)));
+        assert((doTestUsesAllocV2<T>(A, std::forward<Args>(args)...)));
+    }
+}
+
+int main()
+{
+    using PMR = std::pmr::memory_resource*;
+    using PMA = std::pmr::polymorphic_allocator<char>;
+    using STDA = std::allocator<char>;
+    using TESTA = test_allocator<char>;
+
+    int value = 42;
+    const int cvalue = 43;
+    {
+        test_pmr_uses_alloc<PMA>();
+        test_pmr_uses_alloc<PMA>(value);
+        test_pmr_uses_alloc<PMA>(cvalue);
+        test_pmr_uses_alloc<PMA>(cvalue, std::move(value));
+    }
+    {
+        STDA std_alloc;
+        TESTA test_alloc(42);
+        PMR mem_res = std::pmr::new_delete_resource();
+
+        test_non_pmr_uses_alloc<PMR>(mem_res);
+        test_non_pmr_uses_alloc<STDA>(std_alloc);
+        test_non_pmr_uses_alloc<TESTA>(test_alloc);
+        test_non_pmr_uses_alloc<PMR>(mem_res, value);
+        test_non_pmr_uses_alloc<STDA>(std_alloc, value);
+        test_non_pmr_uses_alloc<TESTA>(test_alloc, value);
+        test_non_pmr_uses_alloc<PMR>(mem_res, cvalue);
+        test_non_pmr_uses_alloc<STDA>(std_alloc, cvalue);
+        test_non_pmr_uses_alloc<TESTA>(test_alloc, cvalue);
+        test_non_pmr_uses_alloc<PMR>(mem_res, cvalue, std::move(cvalue));
+        test_non_pmr_uses_alloc<STDA>(std_alloc, cvalue, std::move(value));
+        test_non_pmr_uses_alloc<TESTA>(test_alloc, cvalue, std::move(value));
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// T* polymorphic_allocator<T>::deallocate(T*, size_t size)
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::pmr;
+
+template <size_t S, size_t Align>
+void testForSizeAndAlign() {
+    using T = typename std::aligned_storage<S, Align>::type;
+
+    TestResource R;
+    ex::polymorphic_allocator<T> a(&R);
+
+    for (int N = 1; N <= 5; ++N) {
+        auto ret = a.allocate(N);
+        assert(R.checkAlloc(ret, N * sizeof(T), alignof(T)));
+
+        a.deallocate(ret, N);
+        assert(R.checkDealloc(ret, N * sizeof(T), alignof(T)));
+
+        R.reset();
+    }
+}
+
+int main()
+{
+    {
+        ex::polymorphic_allocator<int> a;
+        static_assert(
+            std::is_same<decltype(a.deallocate(nullptr, 0)), void>::value, "");
+    }
+    {
+        constexpr std::size_t MA = alignof(std::max_align_t);
+        testForSizeAndAlign<1, 1>();
+        testForSizeAndAlign<1, 2>();
+        testForSizeAndAlign<1, MA>();
+        testForSizeAndAlign<2, 2>();
+        testForSizeAndAlign<73, alignof(void*)>();
+        testForSizeAndAlign<73, MA>();
+        testForSizeAndAlign<13, MA>();
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U>
+// void polymorphic_allocator<T>::destroy(U * ptr);
+
+#include <memory_resource>
+#include <type_traits>
+#include <new>
+#include <cassert>
+#include <cstdlib>
+
+namespace ex = std::pmr;
+
+int count = 0;
+
+struct destroyable
+{
+    destroyable() { ++count; }
+    ~destroyable() { --count; }
+};
+
+int main()
+{
+    typedef ex::polymorphic_allocator<double> A;
+    {
+        A a;
+        static_assert(
+            std::is_same<decltype(a.destroy((destroyable*)nullptr)), void>::value,
+            "");
+    }
+    {
+        destroyable * ptr = ::new (std::malloc(sizeof(destroyable))) destroyable();
+        assert(count == 1);
+        A{}.destroy(ptr);
+        assert(count == 0);
+        std::free(ptr);
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// memory_resource *
+// polymorphic_allocator<T>::resource() const
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A;
+    {
+        A const a;
+        static_assert(
+            std::is_same<decltype(a.resource()), ex::memory_resource*>::value
+          , ""
+          );
+    }
+    {
+        ex::memory_resource * mptr = (ex::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() == ex::get_default_resource());
+    }
+    {
+        ex::memory_resource * mptr = (ex::memory_resource*)42;
+        ex::set_default_resource(mptr);
+        A const a;
+        assert(a.resource() == mptr);
+        assert(a.resource() == ex::get_default_resource());
+    }
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator
+// polymorphic_allocator<T>::select_on_container_copy_construction() const
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A;
+    {
+        A const a;
+        static_assert(
+            std::is_same<decltype(a.select_on_container_copy_construction()), A>::value,
+            "");
+    }
+    {
+        ex::memory_resource * mptr = (ex::memory_resource*)42;
+        A const a(mptr);
+        assert(a.resource() == mptr);
+        A const other = a.select_on_container_copy_construction();
+        assert(other.resource() == ex::get_default_resource());
+        assert(a.resource() == mptr);
+    }
+    {
+        ex::memory_resource * mptr = (ex::memory_resource*)42;
+        ex::set_default_resource(mptr);
+        A const a(nullptr);
+        assert(a.resource() == nullptr);
+        A const other = a.select_on_container_copy_construction();
+        assert(other.resource() == ex::get_default_resource());
+        assert(other.resource() == mptr);
+        assert(a.resource() == nullptr);
+    }
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_deque_synop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <deque>
+
+// namespace std::pmr {
+// template <class T>
+// using deque =
+//     ::std::deque<T, polymorphic_allocator<T>>
+//
+// } // namespace std::pmr
+
+#include <deque>
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+    using StdDeque = std::deque<int, std::pmr::polymorphic_allocator<int>>;
+    using PmrDeque = std::pmr::deque<int>;
+    static_assert(std::is_same<StdDeque, PmrDeque>::value, "");
+    PmrDeque d;
+    assert(d.get_allocator().resource() == std::pmr::get_default_resource());
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_forward_list_synop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <forward_list>
+
+// namespace std::pmr {
+// template <class T>
+// using forward_list =
+//     ::std::forward_list<T, polymorphic_allocator<T>>
+//
+// } // namespace std::pmr
+
+#include <forward_list>
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+    using StdForwardList = std::forward_list<int, std::pmr::polymorphic_allocator<int>>;
+    using PmrForwardList = std::pmr::forward_list<int>;
+    static_assert(std::is_same<StdForwardList, PmrForwardList>::value, "");
+    PmrForwardList d;
+    assert(d.get_allocator().resource() == std::pmr::get_default_resource());
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_list_synop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <list>
+
+// namespace std::pmr {
+// template <class T>
+// using list =
+//     ::std::list<T, polymorphic_allocator<T>>
+//
+// } // namespace std::pmr
+
+#include <list>
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+    using StdList = std::list<int, std::pmr::polymorphic_allocator<int>>;
+    using PmrList = std::pmr::list<int>;
+    static_assert(std::is_same<StdList, PmrList>::value, "");
+    PmrList d;
+    assert(d.get_allocator().resource() == std::pmr::get_default_resource());
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_list_synop2.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++17
+
+// <list>
+
+// namespace std::pmr {
+//
+// typedef ... list
+//
+// } // namespace std::pmr
+
+#include <list>
+
+int main()
+{
+    {
+        // Check that std::pmr::list is usable without <memory_resource>.
+        std::pmr::list<int> l;
+    }
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_map_synop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <map>
+
+// namespace std::pmr {
+// template <class K, class V, class Compare = less<Key> >
+// using map =
+//     ::std::map<K, V, Compare, polymorphic_allocator<pair<const K, V>>>
+//
+// template <class K, class V, class Compare = less<Key> >
+// using multimap =
+//     ::std::multimap<K, V, Compare, polymorphic_allocator<pair<const K, V>>>
+//
+// } // namespace std::pmr
+
+#include <map>
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+    using K = int;
+    using V = char;
+    using DC = std::less<int>;
+    using OC = std::greater<int>;
+    using P = std::pair<const K, V>;
+    {
+        using StdMap = std::map<K, V, DC, std::pmr::polymorphic_allocator<P>>;
+        using PmrMap = std::pmr::map<K, V>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::map<K, V, OC, std::pmr::polymorphic_allocator<P>>;
+        using PmrMap = std::pmr::map<K, V, OC>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        std::pmr::map<int, int> m;
+        assert(m.get_allocator().resource() == std::pmr::get_default_resource());
+    }
+    {
+        using StdMap = std::multimap<K, V, DC, std::pmr::polymorphic_allocator<P>>;
+        using PmrMap = std::pmr::multimap<K, V>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::multimap<K, V, OC, std::pmr::polymorphic_allocator<P>>;
+        using PmrMap = std::pmr::multimap<K, V, OC>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        std::pmr::multimap<int, int> m;
+        assert(m.get_allocator().resource() == std::pmr::get_default_resource());
+    }
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_regex_synop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <regex>
+
+// namespace std::pmr {
+//
+//  template <class BidirectionalIterator>
+//  using match_results =
+//    std::match_results<BidirectionalIterator,
+//                       polymorphic_allocator<sub_match<BidirectionalIterator>>>;
+//
+//  typedef match_results<const char*> cmatch;
+//  typedef match_results<const wchar_t*> wcmatch;
+//  typedef match_results<string::const_iterator> smatch;
+//  typedef match_results<wstring::const_iterator> wsmatch;
+//
+// } // namespace std::pmr
+
+#include <regex>
+#include <type_traits>
+#include <cassert>
+
+template <class Iter, class PmrTypedef>
+void test_match_result_typedef() {
+    using StdMR = std::match_results<Iter, std::pmr::polymorphic_allocator<std::sub_match<Iter>>>;
+    using PmrMR = std::pmr::match_results<Iter>;
+    static_assert(std::is_same<StdMR, PmrMR>::value, "");
+    static_assert(std::is_same<PmrMR, PmrTypedef>::value, "");
+}
+
+int main()
+{
+    {
+        test_match_result_typedef<const char*, std::pmr::cmatch>();
+        test_match_result_typedef<const wchar_t*, std::pmr::wcmatch>();
+        test_match_result_typedef<std::pmr::string::const_iterator, std::pmr::smatch>();
+        test_match_result_typedef<std::pmr::wstring::const_iterator, std::pmr::wsmatch>();
+    }
+    {
+        // Check that std::match_results has been included and is complete.
+        std::pmr::smatch s;
+        assert(s.get_allocator().resource() == std::pmr::get_default_resource());
+    }
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_set_synop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <set>
+
+// namespace std::pmr {
+// template <class V, class Compare = less<V> >
+// using set =
+//     ::std::set<V, Compare, polymorphic_allocator<V>>
+//
+// template <class V, class Compare = less<V> >
+// using multiset =
+//     ::std::multiset<V, Compare, polymorphic_allocator<V>>
+//
+// } // namespace std::pmr
+
+#include <set>
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+    using V = char;
+    using DC = std::less<V>;
+    using OC = std::greater<V>;
+    {
+        using StdSet = std::set<V, DC, std::pmr::polymorphic_allocator<V>>;
+        using PmrSet = std::pmr::set<V>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::set<V, OC, std::pmr::polymorphic_allocator<V>>;
+        using PmrSet = std::pmr::set<V, OC>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        std::pmr::set<int> m;
+        assert(m.get_allocator().resource() == std::pmr::get_default_resource());
+    }
+    {
+        using StdSet = std::multiset<V, DC, std::pmr::polymorphic_allocator<V>>;
+        using PmrSet = std::pmr::multiset<V>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::multiset<V, OC, std::pmr::polymorphic_allocator<V>>;
+        using PmrSet = std::pmr::multiset<V, OC>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        std::pmr::multiset<int> m;
+        assert(m.get_allocator().resource() == std::pmr::get_default_resource());
+    }
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_string_synop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <string>
+
+// namespace std::pmr {
+// template <class Char, class Traits = ...>
+// using basic_string =
+//     ::std::basic_string<Char, Traits, polymorphic_allocator<Char>>
+//
+// typedef ... string
+// typedef ... u16string
+// typedef ... u32string
+// typedef ... wstring
+//
+// } // namespace std::pmr
+
+#include <string>
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "constexpr_char_traits.hpp"
+
+namespace pmr = std::pmr;
+
+template <class Char, class PmrTypedef>
+void test_string_typedef() {
+    using StdStr = std::basic_string<Char, std::char_traits<Char>,
+                                     std::pmr::polymorphic_allocator<Char>>;
+    using PmrStr = std::pmr::basic_string<Char>;
+    static_assert(std::is_same<StdStr, PmrStr>::value, "");
+    static_assert(std::is_same<PmrStr, PmrTypedef>::value, "");
+}
+
+template <class Char, class Traits>
+void test_basic_string_alias() {
+    using StdStr = std::basic_string<Char, Traits,
+                                     std::pmr::polymorphic_allocator<Char>>;
+    using PmrStr = std::pmr::basic_string<Char, Traits>;
+    static_assert(std::is_same<StdStr, PmrStr>::value, "");
+}
+
+int main()
+{
+    {
+        test_string_typedef<char,     std::pmr::string>();
+        test_string_typedef<wchar_t,  std::pmr::wstring>();
+        test_string_typedef<char16_t, std::pmr::u16string>();
+        test_string_typedef<char32_t, std::pmr::u32string>();
+    }
+    {
+        test_basic_string_alias<char,    constexpr_char_traits<char>>();
+        test_basic_string_alias<wchar_t, constexpr_char_traits<wchar_t>>();
+        test_basic_string_alias<char16_t, constexpr_char_traits<char16_t>>();
+        test_basic_string_alias<char32_t, constexpr_char_traits<char32_t>>();
+    }
+    {
+        // Check that std::basic_string has been included and is complete.
+        std::pmr::string s;
+        assert(s.get_allocator().resource() == std::pmr::get_default_resource());
+    }
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_string_synop2.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++17
+
+// <string>
+
+// namespace std::pmr {
+//
+// typedef ... string
+// typedef ... u16string
+// typedef ... u32string
+// typedef ... wstring
+//
+// } // namespace std::pmr
+
+#include <string>
+
+int main()
+{
+    {
+        // Check that std::pmr::string is usable without <memory_resource>.
+        std::pmr::string s;
+        std::pmr::wstring ws;
+        std::pmr::u16string u16s;
+        std::pmr::u32string u32s;
+    }
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_unordered_map_synop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <unordered_map>
+
+// namespace std::pmr {
+// template <class K, class V, class H = hash<K>, class P = equal_to<K> >
+// using unordered_map =
+//     ::std::unordered_map<K, V, H, P, polymorphic_allocator<pair<const K, V>>>
+//
+// template <class K, class V,  class H = hash<K>, class P = equal_to<K> >
+// using unordered_multimap =
+//     ::std::unordered_multimap<K, V, H, P, polymorphic_allocator<pair<const K, V>>>
+//
+// } // namespace std::pmr
+
+#include <unordered_map>
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+template <class T>
+struct MyHash : std::hash<T> {};
+
+template <class T>
+struct MyPred : std::equal_to<T> {};
+
+int main()
+{
+    using K = int;
+    using V = char;
+    using DH = std::hash<K>;
+    using MH = MyHash<K>;
+    using DP = std::equal_to<K>;
+    using MP = MyPred<K>;
+    using P = std::pair<const K, V>;
+    {
+        using StdMap = std::unordered_map<K, V, DH, DP, std::pmr::polymorphic_allocator<P>>;
+        using PmrMap = std::pmr::unordered_map<K, V>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::unordered_map<K, V, MH, DP, std::pmr::polymorphic_allocator<P>>;
+        using PmrMap = std::pmr::unordered_map<K, V, MH>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::unordered_map<K, V, MH, MP, std::pmr::polymorphic_allocator<P>>;
+        using PmrMap = std::pmr::unordered_map<K, V, MH, MP>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        std::pmr::unordered_map<int, int> m;
+        assert(m.get_allocator().resource() == std::pmr::get_default_resource());
+    }
+    {
+        using StdMap = std::unordered_multimap<K, V, DH, DP, std::pmr::polymorphic_allocator<P>>;
+        using PmrMap = std::pmr::unordered_multimap<K, V>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::unordered_multimap<K, V, MH, DP, std::pmr::polymorphic_allocator<P>>;
+        using PmrMap = std::pmr::unordered_multimap<K, V, MH>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::unordered_multimap<K, V, MH, MP, std::pmr::polymorphic_allocator<P>>;
+        using PmrMap = std::pmr::unordered_multimap<K, V, MH, MP>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        std::pmr::unordered_multimap<int, int> m;
+        assert(m.get_allocator().resource() == std::pmr::get_default_resource());
+    }
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_unordered_set_synop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <unordered_set>
+
+// namespace std::pmr {
+// template <class V, class H = hash<V>, class P = equal_to<V> >
+// using unordered_set =
+//     ::std::unordered_set<V, H, P, polymorphic_allocator<V>>
+//
+// template <class V,  class H = hash<V>, class P = equal_to<V> >
+// using unordered_multiset =
+//     ::std::unordered_multiset<V, H, P, polymorphic_allocator<V>>
+//
+// } // namespace std::pmr
+
+#include <unordered_set>
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+template <class T>
+struct MyHash : std::hash<T> {};
+
+template <class T>
+struct MyPred : std::equal_to<T> {};
+
+int main()
+{
+    using V = char;
+    using DH = std::hash<V>;
+    using MH = MyHash<V>;
+    using DP = std::equal_to<V>;
+    using MP = MyPred<V>;
+    {
+        using StdSet = std::unordered_set<V, DH, DP, std::pmr::polymorphic_allocator<V>>;
+        using PmrSet = std::pmr::unordered_set<V>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::unordered_set<V, MH, DP, std::pmr::polymorphic_allocator<V>>;
+        using PmrSet = std::pmr::unordered_set<V, MH>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::unordered_set<V, MH, MP, std::pmr::polymorphic_allocator<V>>;
+        using PmrSet = std::pmr::unordered_set<V, MH, MP>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        std::pmr::unordered_set<int> m;
+        assert(m.get_allocator().resource() == std::pmr::get_default_resource());
+    }
+    {
+        using StdSet = std::unordered_multiset<V, DH, DP, std::pmr::polymorphic_allocator<V>>;
+        using PmrSet = std::pmr::unordered_multiset<V>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::unordered_multiset<V, MH, DP, std::pmr::polymorphic_allocator<V>>;
+        using PmrSet = std::pmr::unordered_multiset<V, MH>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::unordered_multiset<V, MH, MP, std::pmr::polymorphic_allocator<V>>;
+        using PmrSet = std::pmr::unordered_multiset<V, MH, MP>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        std::pmr::unordered_multiset<int> m;
+        assert(m.get_allocator().resource() == std::pmr::get_default_resource());
+    }
+}

test/std/utilities/utility/mem.res/mem.res.aliases/header_vector_synop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <vector>
+
+// namespace std::pmr {
+// template <class T>
+// using vector =
+//     ::std::vector<T, polymorphic_allocator<T>>
+//
+// } // namespace std::pmr
+
+#include <vector>
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+    using StdVector = std::vector<int, std::pmr::polymorphic_allocator<int>>;
+    using PmrVector = std::pmr::vector<int>;
+    static_assert(std::is_same<StdVector, PmrVector>::value, "");
+    PmrVector d;
+    assert(d.get_allocator().resource() == std::pmr::get_default_resource());
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <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_memory_resource.hpp"
+
+using namespace std::pmr;
+
+int main() {
+    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");
+    }
+}

test/std/utilities/utility/mem.res/mem.res.global/new_delete_resource.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// memory_resource * new_delete_resource()
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "count_new.hpp"
+
+namespace ex = std::pmr;
+
+struct assert_on_compare : public ex::memory_resource
+{
+protected:
+    virtual void * do_allocate(size_t, size_t)
+    { assert(false); }
+
+    virtual void do_deallocate(void *, size_t, size_t)
+    { assert(false); }
+
+    virtual bool do_is_equal(ex::memory_resource const &) const noexcept
+    { assert(false); }
+};
+
+void test_return()
+{
+    {
+        static_assert(std::is_same<
+            decltype(ex::new_delete_resource()), ex::memory_resource*
+          >::value, "");
+    }
+    // assert not null
+    {
+        assert(ex::new_delete_resource());
+    }
+    // assert same return value
+    {
+        assert(ex::new_delete_resource() == ex::new_delete_resource());
+    }
+}
+
+void test_equality()
+{
+    // Same object
+    {
+        ex::memory_resource & r1 = *ex::new_delete_resource();
+        ex::memory_resource & r2 = *ex::new_delete_resource();
+        // check both calls returned the same object
+        assert(&r1 == &r2);
+        // check for proper equality semantics
+        assert(r1 == r2);
+        assert(r2 == r1);
+        assert(!(r1 != r2));
+        assert(!(r2 != r1));
+    }
+    // Different types
+    {
+        ex::memory_resource & r1 = *ex::new_delete_resource();
+        assert_on_compare c;
+        ex::memory_resource & r2 = c;
+        assert(r1 != r2);
+        assert(!(r1 == r2));
+    }
+}
+
+void test_allocate_deallocate()
+{
+    ex::memory_resource & r1 = *ex::new_delete_resource();
+
+    globalMemCounter.reset();
+
+    void *ret = r1.allocate(50);
+    assert(ret);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
+    assert(globalMemCounter.checkLastNewSizeEq(50));
+
+    r1.deallocate(ret, 1);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+    assert(globalMemCounter.checkDeleteCalledEq(1));
+
+}
+
+int main()
+{
+    static_assert(noexcept(ex::new_delete_resource()), "Must be noexcept");
+    test_return();
+    test_equality();
+    test_allocate_deallocate();
+}

test/std/utilities/utility/mem.res/mem.res.global/null_memory_resource.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// memory_resource * null_memory_resource()
+
+#include <memory_resource>
+#include <new>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "count_new.hpp"
+
+namespace ex = std::pmr;
+
+struct assert_on_compare : public ex::memory_resource
+{
+protected:
+    virtual void * do_allocate(size_t, size_t)
+    { assert(false); }
+
+    virtual void do_deallocate(void *, size_t, size_t)
+    { assert(false); }
+
+    virtual bool do_is_equal(ex::memory_resource const &) const noexcept
+    { assert(false); }
+};
+
+void test_return()
+{
+    {
+        static_assert(std::is_same<
+            decltype(ex::null_memory_resource()), ex::memory_resource*
+          >::value, "");
+    }
+    // Test that the returned value is not null
+    {
+        assert(ex::null_memory_resource());
+    }
+    // Test the same value is returned by repeated calls.
+    {
+        assert(ex::null_memory_resource() == ex::null_memory_resource());
+    }
+}
+
+void test_equality()
+{
+    // Same object
+    {
+        ex::memory_resource & r1 = *ex::null_memory_resource();
+        ex::memory_resource & r2 = *ex::null_memory_resource();
+        // check both calls returned the same object
+        assert(&r1 == &r2);
+        // check for proper equality semantics
+        assert(r1 == r2);
+        assert(r2 == r1);
+        assert(!(r1 != r2));
+        assert(!(r2 != r1));
+        // check the is_equal method
+        assert(r1.is_equal(r2));
+        assert(r2.is_equal(r1));
+    }
+    // Different types
+    {
+        ex::memory_resource & r1 = *ex::null_memory_resource();
+        assert_on_compare c;
+        ex::memory_resource & r2 = c;
+        assert(r1 != r2);
+        assert(!(r1 == r2));
+        assert(!r1.is_equal(r2));
+    }
+}
+
+void test_allocate()
+{
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    DisableAllocationGuard g; // null_memory_resource shouldn't allocate.
+    try {
+        ex::null_memory_resource()->allocate(1);
+        assert(false);
+    } catch (std::bad_alloc const &) {
+       // do nothing
+    } catch (...) {
+        assert(false);
+    }
+#endif
+}
+
+void test_deallocate()
+{
+    globalMemCounter.reset();
+
+    int x = 42;
+    ex::null_memory_resource()->deallocate(nullptr, 0);
+    ex::null_memory_resource()->deallocate(&x, 0);
+
+    assert(globalMemCounter.checkDeleteCalledEq(0));
+    assert(globalMemCounter.checkDeleteArrayCalledEq(0));
+}
+
+int main()
+{
+    test_return();
+    test_equality();
+    test_allocate();
+    test_deallocate();
+}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/monotonic_buffer.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// class monotonic_buffer_resource
+
+#include <memory_resource>
+#include <new>
+#include <type_traits>
+#include <cassert>
+
+#include "count_new.hpp"
+
+struct assert_on_compare : public std::pmr::memory_resource
+{
+protected:
+    virtual void * do_allocate(size_t, size_t)
+    { assert(false); }
+
+    virtual void do_deallocate(void *, size_t, size_t)
+    { assert(false); }
+
+    virtual bool do_is_equal(std::pmr::memory_resource const &) const noexcept
+    { assert(false); }
+};
+
+struct repointable_resource : public std::pmr::memory_resource
+{
+    std::pmr::memory_resource *which;
+
+    explicit repointable_resource(std::pmr::memory_resource *res) : which(res) {}
+
+protected:
+    virtual void *do_allocate(size_t size, size_t align)
+    { return which->allocate(size, align); }
+
+    virtual void do_deallocate(void *p, size_t size, size_t align)
+    { return which->deallocate(p, size, align); }
+
+    virtual bool do_is_equal(std::pmr::memory_resource const &rhs) const noexcept
+    { return which->is_equal(rhs); }
+};
+
+void test_construction_with_default_resource()
+{
+    std::pmr::memory_resource *expected = std::pmr::null_memory_resource();
+    std::pmr::set_default_resource(expected);
+    {
+        char buffer[16];
+        std::pmr::monotonic_buffer_resource r1;
+        std::pmr::monotonic_buffer_resource r2(16);
+        std::pmr::monotonic_buffer_resource r3(buffer, sizeof buffer);
+        assert(r1.upstream_resource() == expected);
+        assert(r2.upstream_resource() == expected);
+        assert(r3.upstream_resource() == expected);
+    }
+
+    expected = std::pmr::new_delete_resource();
+    std::pmr::set_default_resource(expected);
+    {
+        char buffer[16];
+        std::pmr::monotonic_buffer_resource r1;
+        std::pmr::monotonic_buffer_resource r2(16);
+        std::pmr::monotonic_buffer_resource r3(buffer, sizeof buffer);
+        assert(r1.upstream_resource() == expected);
+        assert(r2.upstream_resource() == expected);
+        assert(r3.upstream_resource() == expected);
+    }
+}
+
+void test_construction_without_buffer()
+{
+    // Constructing a monotonic_buffer_resource should not cause allocations
+    // by itself; the resource should wait to allocate until an allocation is
+    // requested.
+
+    globalMemCounter.reset();
+    std::pmr::set_default_resource(std::pmr::new_delete_resource());
+
+    std::pmr::monotonic_buffer_resource r1;
+    assert(globalMemCounter.checkNewCalledEq(0));
+
+    std::pmr::monotonic_buffer_resource r2(1024);
+    assert(globalMemCounter.checkNewCalledEq(0));
+
+    std::pmr::monotonic_buffer_resource r3(1024, std::pmr::new_delete_resource());
+    assert(globalMemCounter.checkNewCalledEq(0));
+}
+
+void test_equality()
+{
+    // Same object
+    {
+        std::pmr::monotonic_buffer_resource r1;
+        std::pmr::monotonic_buffer_resource r2;
+        assert(r1 == r1);
+        assert(r1 != r2);
+
+        std::pmr::memory_resource & p1 = r1;
+        std::pmr::memory_resource & p2 = r2;
+        assert(p1 == p1);
+        assert(p1 != p2);
+        assert(p1 == r1);
+        assert(r1 == p1);
+        assert(p1 != r2);
+        assert(r2 != p1);
+    }
+    // Different types
+    {
+        std::pmr::monotonic_buffer_resource mono1;
+        std::pmr::memory_resource & r1 = mono1;
+        assert_on_compare c;
+        std::pmr::memory_resource & r2 = c;
+        assert(r1 != r2);
+        assert(!(r1 == r2));
+    }
+}
+
+void test_allocate_deallocate()
+{
+    {
+        globalMemCounter.reset();
+
+        std::pmr::monotonic_buffer_resource mono1(std::pmr::new_delete_resource());
+        std::pmr::memory_resource & r1 = mono1;
+
+        void *ret = r1.allocate(50);
+        assert(ret);
+        assert(globalMemCounter.checkNewCalledGreaterThan(0));
+        assert(globalMemCounter.checkDeleteCalledEq(0));
+
+        // mem.res.monotonic.buffer 1.2
+        // A call to deallocate has no effect, thus the amount of memory
+        // consumed increases monotonically until the resource is destroyed.
+        // Check that deallocate is a no-op
+        r1.deallocate(ret, 50);
+        assert(globalMemCounter.checkDeleteCalledEq(0));
+
+        mono1.release();
+        assert(globalMemCounter.checkDeleteCalledEq(1));
+        assert(globalMemCounter.checkOutstandingNewEq(0));
+
+        globalMemCounter.reset();
+
+        ret = r1.allocate(500);
+        assert(ret);
+        assert(globalMemCounter.checkNewCalledGreaterThan(0));
+        assert(globalMemCounter.checkDeleteCalledEq(0));
+
+        // Check that the destructor calls release()
+    }
+    assert(globalMemCounter.checkDeleteCalledEq(1));
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+}
+
+void test_allocate_deallocate_from_original_buffer()
+{
+    globalMemCounter.reset();
+    char buffer[100];
+    std::pmr::monotonic_buffer_resource mono1((void *)buffer, sizeof buffer, std::pmr::new_delete_resource());
+    std::pmr::memory_resource & r1 = mono1;
+
+    // Check that construction with a buffer does not allocate anything from the upstream
+    assert(globalMemCounter.checkNewCalledEq(0));
+
+    // Check that an allocation that fits in the buffer does not allocate anything from the upstream
+    void *ret = r1.allocate(50);
+    assert(ret);
+    assert(globalMemCounter.checkNewCalledEq(0));
+
+    // Check a second allocation
+    ret = r1.allocate(20);
+    assert(ret);
+    assert(globalMemCounter.checkNewCalledEq(0));
+
+    r1.deallocate(ret, 50);
+    assert(globalMemCounter.checkDeleteCalledEq(0));
+
+    // Check an allocation that doesn't fit in the original buffer
+    ret = r1.allocate(50);
+    assert(ret);
+    assert(globalMemCounter.checkNewCalledEq(1));
+
+    r1.deallocate(ret, 50);
+    assert(globalMemCounter.checkDeleteCalledEq(0));
+
+    mono1.release();
+    assert(globalMemCounter.checkDeleteCalledEq(1));
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+}
+
+void test_geometric_progression()
+{
+    // mem.res.monotonic.buffer 1.3
+    // Each additional buffer is larger than the previous one, following a
+    // geometric progression.
+
+    globalMemCounter.reset();
+    std::pmr::monotonic_buffer_resource mono1(100, std::pmr::new_delete_resource());
+    std::pmr::memory_resource & r1 = mono1;
+
+    assert(globalMemCounter.checkNewCalledEq(0));
+    size_t next_buffer_size = 100;
+    void *ret = r1.allocate(10, 1);
+    assert(ret != nullptr);
+    assert(globalMemCounter.checkNewCalledEq(1));
+    assert(globalMemCounter.last_new_size >= next_buffer_size);
+    next_buffer_size = globalMemCounter.last_new_size + 1;
+
+    int new_called = 1;
+    while (new_called < 5) {
+        ret = r1.allocate(10, 1);
+        if (globalMemCounter.new_called > new_called) {
+            assert(globalMemCounter.new_called == new_called + 1);
+            assert(globalMemCounter.last_new_size >= next_buffer_size);
+            next_buffer_size = globalMemCounter.last_new_size + 1;
+            new_called += 1;
+        }
+    }
+}
+
+void test_geometric_progression_after_release()
+{
+    // mem.res.monotonic.buffer 1.3
+    // Each additional buffer is larger than the previous one, following a
+    // geometric progression.
+
+    // mem.res.monotonic.buffer.mem 1
+    // release() calls upstream_rsrc->deallocate() as necessary to release all allocated memory.
+
+    // Implicitly: release() does not reset the geometric progression of next_buffer_size.
+
+    globalMemCounter.reset();
+    std::pmr::monotonic_buffer_resource mono1;
+    std::pmr::memory_resource & r1 = mono1;
+
+    void *ret = r1.allocate(100, 1);
+    assert(ret != nullptr);
+    assert(globalMemCounter.checkNewCalledEq(1));
+    size_t last_new_size = globalMemCounter.last_new_size;
+
+    r1.allocate(last_new_size, 1);
+    assert(globalMemCounter.checkNewCalledEq(2));
+    assert(globalMemCounter.last_new_size > last_new_size);
+    last_new_size = globalMemCounter.last_new_size;
+
+    mono1.release();
+    assert(globalMemCounter.checkDeleteCalledEq(2));
+
+    // We expect to see a large upstream allocation corresponding
+    // to this small request, because the upstream allocation must
+    // be at least `next_buffer_size` bytes.
+    r1.allocate(10, 1);
+    assert(globalMemCounter.checkNewCalledEq(3));
+    assert(globalMemCounter.last_new_size >= 10);
+    assert(globalMemCounter.last_new_size > 100);
+    assert(globalMemCounter.last_new_size > last_new_size);
+}
+
+void test_zero_sized_initial_buffer()
+{
+    globalMemCounter.reset();
+    {
+        char buffer[100];
+        std::pmr::monotonic_buffer_resource mono1((void *)buffer, 0, std::pmr::new_delete_resource());
+        std::pmr::memory_resource & r1 = mono1;
+
+        void *ret = r1.allocate(1, 1);
+        assert(ret != nullptr);
+        assert(globalMemCounter.checkNewCalledEq(1));
+    }
+    assert(globalMemCounter.checkDeleteCalledEq(1));
+
+    globalMemCounter.reset();
+    {
+        std::pmr::monotonic_buffer_resource mono1(nullptr, 0, std::pmr::new_delete_resource());
+        std::pmr::memory_resource & r1 = mono1;
+
+        void *ret = r1.allocate(1, 1);
+        assert(ret != nullptr);
+        assert(globalMemCounter.checkNewCalledEq(1));
+    }
+    assert(globalMemCounter.checkDeleteCalledEq(1));
+}
+
+void test_underaligned_initial_buffer()
+{
+    globalMemCounter.reset();
+    {
+        alignas(4) char buffer[17];
+        std::pmr::monotonic_buffer_resource mono1(buffer + 1, 16, std::pmr::new_delete_resource());
+        std::pmr::memory_resource & r1 = mono1;
+
+        void *ret = r1.allocate(1, 1);
+        assert(ret == buffer + 1);
+        mono1.release();
+
+        ret = r1.allocate(1, 2);
+        assert(ret == buffer + 2);
+        mono1.release();
+
+        ret = r1.allocate(1, 4);
+        assert(ret == buffer + 4);
+        mono1.release();
+
+        // Test a size that is just big enough to fit in the buffer,
+        // but can't fit if it's aligned.
+        ret = r1.allocate(16, 1);
+        assert(ret == buffer + 1);
+        mono1.release();
+
+        assert(globalMemCounter.checkNewCalledEq(0));
+        ret = r1.allocate(16, 2);
+        assert(globalMemCounter.checkNewCalledEq(1));
+        assert(globalMemCounter.last_new_size >= 16);
+        // assert(globalMemCounter.last_new_align >= 2);
+        mono1.release();
+        assert(globalMemCounter.checkDeleteCalledEq(1));
+        // assert(globalMemCounter.last_new_align == globalMemCounter.last_delete_align);
+    }
+}
+
+void test_overaligned_single_allocation()
+{
+    globalMemCounter.reset();
+    std::pmr::monotonic_buffer_resource mono1(1024, std::pmr::new_delete_resource());
+    std::pmr::memory_resource & r1 = mono1;
+
+    constexpr size_t big_alignment = 8 * alignof(std::max_align_t);
+    static_assert(big_alignment > 4);
+
+    void *ret = r1.allocate(2048, big_alignment);
+    assert(ret != nullptr);
+    assert(globalMemCounter.checkNewCalledEq(1));
+    assert(globalMemCounter.last_new_size >= 2048);
+    // assert(globalMemCounter.last_new_align >= big_alignment);
+
+    // Check that a single highly aligned allocation request doesn't
+    // permanently "poison" the resource to allocate only super-aligned
+    // blocks of memory.
+    ret = r1.allocate(globalMemCounter.last_new_size, 4);
+    assert(ret != nullptr);
+    assert(globalMemCounter.checkNewCalledEq(2));
+    // assert(globalMemCounter.last_new_align >= 4);
+    // assert(globalMemCounter.last_new_align < big_alignment);
+}
+
+void test_exception_safety()
+{
+    globalMemCounter.reset();
+    repointable_resource upstream(std::pmr::new_delete_resource());
+    alignas(16) char buffer[64];
+    std::pmr::monotonic_buffer_resource mono1(buffer, sizeof buffer, &upstream);
+    std::pmr::memory_resource & r1 = mono1;
+
+    void *res = r1.allocate(64, 16);
+    assert(res == buffer);
+    assert(globalMemCounter.checkNewCalledEq(0));
+
+    res = r1.allocate(64, 16);
+    assert(res != buffer);
+    assert(globalMemCounter.checkNewCalledEq(1));
+    assert(globalMemCounter.checkDeleteCalledEq(0));
+
+    upstream.which = std::pmr::null_memory_resource();
+    try {
+        res = r1.allocate(globalMemCounter.last_new_size, 16);
+        assert(false);
+    } catch (const std::bad_alloc&) {
+        // we expect this
+    }
+    assert(globalMemCounter.checkNewCalledEq(1));
+    assert(globalMemCounter.checkDeleteCalledEq(0));
+
+    upstream.which = std::pmr::new_delete_resource();
+    res = r1.allocate(64, 16);
+    assert(res != buffer);
+    assert(globalMemCounter.checkNewCalledEq(2));
+    assert(globalMemCounter.checkDeleteCalledEq(0));
+
+    mono1.release();
+    assert(globalMemCounter.checkNewCalledEq(2));
+    assert(globalMemCounter.checkDeleteCalledEq(2));
+}
+
+int main()
+{
+    test_construction_with_default_resource();
+    test_construction_without_buffer();
+    test_equality();
+    test_allocate_deallocate();
+    test_allocate_deallocate_from_original_buffer();
+    test_geometric_progression();
+    test_geometric_progression_after_release();
+    test_zero_sized_initial_buffer();
+    test_underaligned_initial_buffer();
+    test_overaligned_single_allocation();
+    test_exception_safety();
+}

test/std/utilities/utility/mem.res/mem.res.pool/unsynchronized_buffer.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// class unsynchronized_pool_resource
+
+#include <memory_resource>
+#include <new>
+#include <type_traits>
+#include <cassert>
+
+#include "count_new.hpp"
+
+struct assert_on_compare : public std::pmr::memory_resource
+{
+protected:
+    virtual void * do_allocate(size_t, size_t)
+    { assert(false); }
+
+    virtual void do_deallocate(void *, size_t, size_t)
+    { assert(false); }
+
+    virtual bool do_is_equal(std::pmr::memory_resource const &) const noexcept
+    { assert(false); }
+};
+
+static bool is_aligned_to(void *p, size_t alignment)
+{
+    void *p2 = p;
+    size_t space = 1;
+    void *result = std::align(alignment, 1, p2, space);
+    return (result == p);
+}
+
+void test_construction_with_default_resource()
+{
+    std::pmr::memory_resource *expected = std::pmr::null_memory_resource();
+    std::pmr::set_default_resource(expected);
+    {
+        std::pmr::pool_options opts { 0, 0 };
+        std::pmr::unsynchronized_pool_resource r1;
+        std::pmr::unsynchronized_pool_resource r2(opts);
+        assert(r1.upstream_resource() == expected);
+        assert(r2.upstream_resource() == expected);
+    }
+
+    expected = std::pmr::new_delete_resource();
+    std::pmr::set_default_resource(expected);
+    {
+        std::pmr::pool_options opts { 1024, 2048 };
+        std::pmr::unsynchronized_pool_resource r1;
+        std::pmr::unsynchronized_pool_resource r2(opts);
+        assert(r1.upstream_resource() == expected);
+        assert(r2.upstream_resource() == expected);
+    }
+}
+
+void test_construction_does_not_allocate()
+{
+    // Constructing a unsynchronized_pool_resource should not cause allocations
+    // by itself; the resource should wait to allocate until an allocation is
+    // requested.
+
+    globalMemCounter.reset();
+    std::pmr::set_default_resource(std::pmr::new_delete_resource());
+
+    std::pmr::unsynchronized_pool_resource r1;
+    assert(globalMemCounter.checkNewCalledEq(0));
+
+    std::pmr::unsynchronized_pool_resource r2(std::pmr::pool_options{ 1024, 2048 });
+    assert(globalMemCounter.checkNewCalledEq(0));
+
+    std::pmr::unsynchronized_pool_resource r3(std::pmr::pool_options{ 1024, 2048 }, std::pmr::new_delete_resource());
+    assert(globalMemCounter.checkNewCalledEq(0));
+}
+
+void test_equality()
+{
+    // Same object
+    {
+        std::pmr::unsynchronized_pool_resource r1;
+        std::pmr::unsynchronized_pool_resource r2;
+        assert(r1 == r1);
+        assert(r1 != r2);
+
+        std::pmr::memory_resource & p1 = r1;
+        std::pmr::memory_resource & p2 = r2;
+        assert(p1 == p1);
+        assert(p1 != p2);
+        assert(p1 == r1);
+        assert(r1 == p1);
+        assert(p1 != r2);
+        assert(r2 != p1);
+    }
+    // Different types
+    {
+        std::pmr::unsynchronized_pool_resource unsync1;
+        std::pmr::memory_resource & r1 = unsync1;
+        assert_on_compare c;
+        std::pmr::memory_resource & r2 = c;
+        assert(r1 != r2);
+        assert(!(r1 == r2));
+    }
+}
+
+void test_allocate_deallocate()
+{
+    {
+        globalMemCounter.reset();
+
+        std::pmr::unsynchronized_pool_resource unsync1(std::pmr::new_delete_resource());
+        std::pmr::memory_resource & r1 = unsync1;
+
+        void *ret = r1.allocate(50);
+        assert(ret);
+        assert(globalMemCounter.checkNewCalledGreaterThan(0));
+        assert(globalMemCounter.checkDeleteCalledEq(0));
+
+        r1.deallocate(ret, 50);
+        unsync1.release();
+        assert(globalMemCounter.checkDeleteCalledGreaterThan(0));
+        assert(globalMemCounter.checkOutstandingNewEq(0));
+
+        globalMemCounter.reset();
+
+        ret = r1.allocate(500);
+        assert(ret);
+        assert(globalMemCounter.checkNewCalledGreaterThan(0));
+        assert(globalMemCounter.checkDeleteCalledEq(0));
+
+        // Check that the destructor calls release()
+    }
+    assert(globalMemCounter.checkDeleteCalledGreaterThan(0));
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+}
+
+void test_overaligned_single_allocation()
+{
+    globalMemCounter.reset();
+    std::pmr::pool_options opts { 1, 1024 };
+    std::pmr::unsynchronized_pool_resource unsync1(opts, std::pmr::new_delete_resource());
+    std::pmr::memory_resource & r1 = unsync1;
+
+    constexpr size_t big_alignment = 8 * alignof(std::max_align_t);
+    static_assert(big_alignment > 4);
+
+    assert(globalMemCounter.checkNewCalledEq(0));
+
+    void *ret = r1.allocate(2048, big_alignment);
+    assert(ret != nullptr);
+    assert(is_aligned_to(ret, big_alignment));
+    assert(globalMemCounter.checkNewCalledGreaterThan(0));
+
+    ret = r1.allocate(16, 4);
+    assert(ret != nullptr);
+    assert(is_aligned_to(ret, 4));
+    assert(globalMemCounter.checkNewCalledGreaterThan(1));
+}
+
+void test_reuse()
+{
+    globalMemCounter.reset();
+    std::pmr::pool_options opts { 1, 256 };
+    std::pmr::unsynchronized_pool_resource unsync1(opts, std::pmr::new_delete_resource());
+    std::pmr::memory_resource & r1 = unsync1;
+
+    void *ret = r1.allocate(8);
+    assert(ret != nullptr);
+    assert(is_aligned_to(ret, 8));
+    assert(globalMemCounter.checkNewCalledGreaterThan(0));
+    int new_called = globalMemCounter.new_called;
+
+    // After deallocation, the pool for 8-byte blocks should have at least one vacancy.
+    r1.deallocate(ret, 8);
+    assert(globalMemCounter.new_called == new_called);
+    assert(globalMemCounter.checkDeleteCalledEq(0));
+
+    // This should return an existing block from the pool: no new allocations.
+    ret = r1.allocate(8);
+    assert(ret != nullptr);
+    assert(is_aligned_to(ret, 8));
+    assert(globalMemCounter.new_called == new_called);
+    assert(globalMemCounter.checkDeleteCalledEq(0));
+}
+
+int main()
+{
+    test_construction_with_default_resource();
+    test_construction_does_not_allocate();
+    test_equality();
+    test_allocate_deallocate();
+    test_overaligned_single_allocation();
+    test_reuse();
+}

test/std/utilities/utility/mem.res/mem.res/construct.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// Check that memory_resource is not constructible
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::pmr;
+
+int main()
+{
+    ex::memory_resource m; // expected-error {{variable type 'ex::memory_resource' is an abstract class}}
+}

test/std/utilities/utility/mem.res/mem.res/mem.res.eq/equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// bool operator==(memory_resource const &, memory_resource const &) noexcept;
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+
+namespace ex = std::pmr;
+
+int main()
+{
+    // check return types
+    {
+        ex::memory_resource const * mr1(nullptr);
+        ex::memory_resource const * mr2(nullptr);
+        static_assert(std::is_same<decltype(*mr1 == *mr2), bool>::value, "");
+        static_assert(noexcept(*mr1 == *mr2), "");
+    }
+    // equal
+    {
+        TestResource r1(1);
+        TestResource r2(1);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r2;
+
+        assert(mr1 == mr2);
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(0));
+
+        assert(mr2 == mr1);
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(1));
+    }
+    // equal same object
+    {
+        TestResource r1(1);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r1;
+
+        assert(mr1 == mr2);
+        assert(r1.checkIsEqualCalledEq(0));
+
+        assert(mr2 == mr1);
+        assert(r1.checkIsEqualCalledEq(0));
+    }
+    // not equal
+    {
+        TestResource r1(1);
+        TestResource r2(2);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r2;
+
+        assert(!(mr1 == mr2));
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(0));
+
+        assert(!(mr2 == mr1));
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(1));
+    }
+}

test/std/utilities/utility/mem.res/mem.res/mem.res.eq/not_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// bool operator!=(memory_resource const &, memory_resource const &) noexcept;
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::pmr;
+
+int main()
+{
+    // check return types
+    {
+        ex::memory_resource const * mr1(nullptr);
+        ex::memory_resource const * mr2(nullptr);
+        static_assert(std::is_same<decltype(*mr1 != *mr2), bool>::value, "");
+        static_assert(noexcept(*mr1 != *mr2), "");
+    }
+    // not equal
+    {
+        TestResource r1(1);
+        TestResource r2(2);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r2;
+
+        assert(mr1 != mr2);
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(0));
+
+        assert(mr2 != mr1);
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(1));
+    }
+    // equal
+    {
+        TestResource r1(1);
+        TestResource r2(1);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r2;
+
+        assert(!(mr1 != mr2));
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(0));
+
+        assert(!(mr2 != mr1));
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(1));
+    }
+    // equal same object
+    {
+        TestResource r1(1);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r1;
+
+        assert(!(mr1 != mr2));
+        assert(r1.checkIsEqualCalledEq(0));
+
+        assert(!(mr2 != mr1));
+        assert(r1.checkIsEqualCalledEq(0));
+    }
+}

test/std/utilities/utility/mem.res/mem.res/mem.res.private/private_members.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// memory_resource::do_allocate(size_t, size_t);          /* private */
+// memory_resource::do_deallocate(void*, size_t, size_t); /* private */
+// memory_resource::do_is_equal(memory_resource const&);  /* private */
+
+#include <memory_resource>
+
+namespace ex = std::pmr;
+
+int main() {
+    ex::memory_resource *m = ex::new_delete_resource();
+    m->do_allocate(0, 0); // expected-error{{'do_allocate' is a private member}}
+    m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a private member}}
+    m->do_is_equal(*m); // expected-error{{'do_is_equal' is a private member}}
+}

test/std/utilities/utility/mem.res/mem.res/mem.res.private/protected_members.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+// monotonic_buffer_resource::do_allocate(size_t, size_t);          /* protected */
+// monotonic_buffer_resource::do_deallocate(void*, size_t, size_t); /* protected */
+// monotonic_buffer_resource::do_is_equal(memory_resource const&);  /* protected */
+
+// synchronized_pool_resource::do_allocate(size_t, size_t);          /* protected */
+// synchronized_pool_resource::do_deallocate(void*, size_t, size_t); /* protected */
+// synchronized_pool_resource::do_is_equal(memory_resource const&);  /* protected */
+
+// unsynchronized_pool_resource::do_allocate(size_t, size_t);          /* protected */
+// unsynchronized_pool_resource::do_deallocate(void*, size_t, size_t); /* protected */
+// unsynchronized_pool_resource::do_is_equal(memory_resource const&);  /* protected */
+
+#include <memory_resource>
+
+int main() {
+    {
+        std::pmr::monotonic_buffer_resource m;
+        m.do_allocate(0, 0); // expected-error{{'do_allocate' is a protected member}}
+        m.do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
+        m.do_is_equal(m); // expected-error{{'do_is_equal' is a protected member}}
+    }
+    {
+        std::pmr::synchronized_pool_resource m;
+        m.do_allocate(0, 0); // expected-error{{'do_allocate' is a protected member}}
+        m.do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
+        m.do_is_equal(m); // expected-error{{'do_is_equal' is a protected member}}
+    }
+    {
+        std::pmr::unsynchronized_pool_resource m;
+        m.do_allocate(0, 0); // expected-error{{'do_allocate' is a protected member}}
+        m.do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
+        m.do_is_equal(m); // expected-error{{'do_is_equal' is a protected member}}
+    }
+}

test/std/utilities/utility/mem.res/mem.res/mem.res.public/allocate.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory_resource>
+
+// UNSUPPORTED: c++98, c++03
+
+//------------------------------------------------------------------------------
+// TESTING void * memory_resource::allocate(size_t, size_t = max_align)
+//
+// Concerns:
+//  A) 'memory_resource' contains a member 'allocate' with the required
+//     signature, including the default alignment parameter.
+//  B) The return type of 'allocate' is 'void*'.
+//  C) 'allocate' is not marked as 'noexcept'.
+//  D) Invoking 'allocate' invokes 'do_allocate' with the same arguments.
+//  E) If 'do_allocate' throws then 'allocate' propagates that exception.
+
+#include <memory_resource>
+#include <type_traits>
+#include <cstddef>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+
+using std::pmr::memory_resource;
+
+int main()
+{
+    TestResource R(42);
+    auto& P = R.getController();
+    memory_resource& M = R;
+    {
+        static_assert(
+            std::is_same<decltype(M.allocate(0, 0)), void*>::value
+          , "Must be void*"
+          );
+        static_assert(
+            std::is_same<decltype(M.allocate(0)), void*>::value
+          , "Must be void*"
+          );
+    }
+    {
+        static_assert(
+            ! noexcept(M.allocate(0, 0))
+          , "Must not be noexcept."
+          );
+        static_assert(
+            ! noexcept(M.allocate(0))
+          , "Must not be noexcept."
+          );
+    }
+    {
+        int s = 42;
+        int a = 64;
+        void* p = M.allocate(s, a);
+        assert(P.alloc_count == 1);
+        assert(P.checkAlloc(p, s, a));
+
+        s = 128;
+        a = MaxAlignV;
+        p = M.allocate(s);
+        assert(P.alloc_count == 2);
+        assert(P.checkAlloc(p, s, a));
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        TestResource R2;
+        auto& P2 = R2.getController();
+        P2.throw_on_alloc = true;
+        memory_resource& M2 = R2;
+        try {
+            M2.allocate(42);
+            assert(false);
+        } catch (TestException const&) {
+            // do nothing.
+        } catch (...) {
+            assert(false);
+        }
+    }
+#endif
+}

test/std/utilities/utility/mem.res/mem.res/mem.res.public/deallocate.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory_resource>
+
+// UNSUPPORTED: c++98, c++03
+
+//------------------------------------------------------------------------------
+// TESTING void * memory_resource::deallocate(void *, size_t, size_t = max_align)
+//
+// Concerns:
+//  A) 'memory_resource' contains a member 'deallocate' with the required
+//     signature, including the default alignment parameter.
+//  B) The return type of 'deallocate' is 'void'.
+//  C) 'deallocate' is not marked as 'noexcept'.
+//  D) Invoking 'deallocate' invokes 'do_deallocate' with the same arguments.
+
+
+#include <memory_resource>
+#include <type_traits>
+#include <cstddef>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+using std::pmr::memory_resource;
+
+int main()
+{
+    NullResource R(42);
+    auto& P = R.getController();
+    memory_resource& M = R;
+    {
+        static_assert(
+            std::is_same<decltype(M.deallocate(nullptr, 0, 0)), void>::value
+          , "Must be void"
+          );
+        static_assert(
+            std::is_same<decltype(M.deallocate(nullptr, 0)), void>::value
+          , "Must be void"
+          );
+    }
+    {
+        static_assert(
+            ! noexcept(M.deallocate(nullptr, 0, 0))
+          , "Must not be noexcept."
+          );
+        static_assert(
+            ! noexcept(M.deallocate(nullptr, 0))
+          , "Must not be noexcept."
+          );
+    }
+    {
+        int s = 100;
+        int a = 64;
+        void* p = reinterpret_cast<void*>(640);
+        M.deallocate(p, s, a);
+        assert(P.dealloc_count == 1);
+        assert(P.checkDealloc(p, s, a));
+
+        s = 128;
+        a = alignof(std::max_align_t);
+        p = reinterpret_cast<void*>(12800);
+        M.deallocate(p, s);
+        assert(P.dealloc_count == 2);
+        assert(P.checkDealloc(p, s, a));
+    }
+}

test/std/utilities/utility/mem.res/mem.res/mem.res.public/dtor.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+//------------------------------------------------------------------------------
+// TESTING virtual ~memory_resource()
+//
+// Concerns:
+//  A) 'memory_resource' is destructible.
+//  B) The destructor is implicitly marked noexcept.
+//  C) The destructor is marked virtual.
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+using std::pmr::memory_resource;
+
+int main()
+{
+    static_assert(
+        std::has_virtual_destructor<memory_resource>::value
+      , "Must have virtual destructor"
+      );
+    static_assert(
+        std::is_nothrow_destructible<memory_resource>::value,
+        "Must be nothrow destructible"
+      );
+    static_assert(
+        std::is_abstract<memory_resource>::value
+      , "Must be abstract"
+      );
+    // Check that the destructor of `TestResource` is called when
+    // it is deleted as a pointer to `memory_resource`
+    {
+        using TR = TestResource;
+        memory_resource* M = new TR(42);
+        assert(TR::resource_alive == 1);
+        assert(TR::resource_constructed == 1);
+        assert(TR::resource_destructed == 0);
+
+        delete M;
+
+        assert(TR::resource_alive == 0);
+        assert(TR::resource_constructed == 1);
+        assert(TR::resource_destructed == 1);
+    }
+}

test/std/utilities/utility/mem.res/mem.res/mem.res.public/is_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory_resource>
+
+//------------------------------------------------------------------------------
+// TESTING virtual bool is_equal(memory_resource const &) const noexcept
+//
+// Concerns:
+//   A) 'memory_resource' provides a function 'is_equal' with the required
+//      signature.
+//   B) 'is_equal' is noexcept.
+//   C) 'do_is_equal' is called using the same arguments passed to 'is_equal'
+//      and the resulting value is returned.
+//   D) 'do_is_equal' is called on the LHS object and not the RHS object.
+
+#include <memory_resource>
+#include <type_traits>
+#include <cassert>
+#include "test_memory_resource.hpp"
+
+using std::pmr::memory_resource;
+
+int main()
+{
+    {
+        memory_resource const* r1 = nullptr;
+        memory_resource const* r2 = nullptr;
+        static_assert(
+            noexcept(r1->is_equal(*r2))
+          , "is_equal must be noexcept"
+          );
+    }
+    {
+        TestResource1 R1(1);
+        auto& P1 = R1.getController();
+        memory_resource const& M1 = R1;
+
+        TestResource2 R2(1);
+        auto& P2 = R2.getController();
+        memory_resource const& M2 = R2;
+
+        assert(M1.is_equal(M2) == false);
+        assert(P1.checkIsEqualCalledEq(1));
+        assert(P2.checkIsEqualCalledEq(0));
+
+        assert(M2.is_equal(M1) == false);
+        assert(P2.checkIsEqualCalledEq(1));
+        assert(P1.checkIsEqualCalledEq(1));
+    }
+    {
+        TestResource1 R1(1);
+        auto& P1 = R1.getController();
+        memory_resource const& M1 = R1;
+
+        TestResource1 R2(2);
+        auto& P2 = R2.getController();
+        memory_resource const& M2 = R2;
+
+        assert(M1.is_equal(M2) == false);
+        assert(P1.checkIsEqualCalledEq(1));
+        assert(P2.checkIsEqualCalledEq(0));
+
+        assert(M2.is_equal(M1) == false);
+        assert(P2.checkIsEqualCalledEq(1));
+        assert(P1.checkIsEqualCalledEq(1));
+    }
+    {
+        TestResource1 R1(1);
+        auto& P1 = R1.getController();
+        memory_resource const& M1 = R1;
+
+        TestResource1 R2(1);
+        auto& P2 = R2.getController();
+        memory_resource const& M2 = R2;
+
+        assert(M1.is_equal(M2) == true);
+        assert(P1.checkIsEqualCalledEq(1));
+        assert(P2.checkIsEqualCalledEq(0));
+
+        assert(M2.is_equal(M1) == true);
+        assert(P2.checkIsEqualCalledEq(1));
+        assert(P1.checkIsEqualCalledEq(1));
+    }
+}

test/std/utilities/utility/mem.res/nothing_to_do.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+int main()
+{
+}

test/support/count_new.hpp

bool checkDeleteCalledEq(int n) const
         return disable_checking || n == delete_called;
     }
 
     bool checkDeleteCalledNotEq(int n) const
     {
         return disable_checking || n != delete_called;
     }
 
+    bool checkDeleteCalledGreaterThan(int n) const
+    {
+        return disable_checking || delete_called > n;
+    }
+
     bool checkAlignedNewCalledEq(int n) const
     {
         return disable_checking || n == aligned_new_called;
     }
 
     bool checkAlignedNewCalledNotEq(int n) const
     {
         return disable_checking || n != aligned_new_called;
bool checkAlignedDeleteCalledEq(int n) const
         return disable_checking || n == aligned_delete_called;
     }
 
     bool checkAlignedDeleteCalledNotEq(int n) const
     {
         return disable_checking || n != aligned_delete_called;
     }
 
+    bool checkAlignedDeleteCalledGreaterThan(int n) const
+    {
+        return disable_checking || aligned_delete_called > n;
+    }
+
     bool checkLastNewSizeEq(std::size_t n) const
     {
         return disable_checking || n == last_new_size;
     }
 
     bool checkLastNewSizeNotEq(std::size_t n) const
     {
         return disable_checking || n != last_new_size;

test/support/test_experimental_memory_resource.hpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_TEST_EXPERIMENTAL_MEMORY_RESOURCE_HPP
+#define SUPPORT_TEST_EXPERIMENTAL_MEMORY_RESOURCE_HPP
+
+#include <experimental/memory_resource>
+#include <experimental/utility>
+#include <memory>
+#include <type_traits>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cstdint>
+#include <cassert>
+#include "test_macros.h"
+#include "controlled_allocators.hpp"
+#include "uses_alloc_types.hpp"
+
+// FIXME: This is a hack to allow uses_allocator_types.hpp to work with
+// erased_type. However we can't define that behavior directly in the header
+// because it can't include <experimental/memory_resource>
+template <>
+struct TransformErasedTypeAlloc<std::experimental::erased_type> {
+  using type = std::experimental::pmr::memory_resource*;
+};
+
+template <class ProviderT, int = 0>
+class TestResourceImp : public std::experimental::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::experimental::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_EXPERIMENTAL_MEMORY_RESOURCE_HPP */

test/support/test_memory_resource.hpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUPPORT_TEST_MEMORY_RESOURCE_HPP
 #define SUPPORT_TEST_MEMORY_RESOURCE_HPP
 
-#include <experimental/memory_resource>
-#include <experimental/utility>
 #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.hpp"
 #include "uses_alloc_types.hpp"
 
-// FIXME: This is a hack to allow uses_allocator_types.hpp to work with
-// erased_type. However we can't define that behavior directly in the header
-// because it can't include <experimental/memory_resource>
-template <>
-struct TransformErasedTypeAlloc<std::experimental::erased_type> {
-  using type = std::experimental::pmr::memory_resource*;
-};
-
 template <class ProviderT, int = 0>
-class TestResourceImp : public std::experimental::pmr::memory_resource
+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::experimental::pmr::memory_resource;
+    using memory_resource = std::pmr::memory_resource;
     using Provider = ProviderT;
 
     int value;
 
     explicit TestResourceImp(int val = 0) : value(val) {
         ++resource_alive;
         ++resource_constructed;
     }

test/support/uses_alloc_types.hpp

 using EnableIfB = typename std::enable_if<Value, bool>::type;
 
 } // end namespace detail
 
 // FIXME: UsesAllocatorTestBase needs some special logic to deal with
 // polymorphic allocators. However we don't want to include
 // <experimental/memory_resource> in this header. Therefore in order
 // to inject this behavior later we use a trait.
-// See test_memory_resource.hpp for more info.
+// See test_experimental_memory_resource.hpp for more info.
 template <class Alloc>
 struct TransformErasedTypeAlloc {
   using type = Alloc;
 };
 
 using detail::EnableIfB;
 
 struct AllocLastTag {};