In the libc++ unstable ABI, use [[no_unique_address]] instead of __compressed_pair when available.

[ldionne]

Summary

Adds a new __config macro _LIBCPP_USE_NO_UNIQUE_ADDRESS that specifies when to
use [[no_unique_address]] (instead of __compressed_pair or similar layout
hacks). This macro is defined only when the unstable ABI is enabled and
[[no_unique_address]] is available.

This reduces the number of template instantiations, compile-time cost, size of
debug information, and number of copies performed when using various parts of
libc++. In one source file, we saw a 4% decrease in object file size from
switching std::function to use [[no_unique_address]] instead of
__compressed_pair stemming primarily from reduced debug info size.

This patch does not intend to provide any ABI compatibility between the new
mode and old modes (or between two different compilers with the unstable ABI
enabled, where one supports [[no_unique_address]] and the other does not).
If we want a hard guarantee that even the unstable ABI provides stability
between compilers, we'll need to provide user control over whether we apply
this optimization rather than doing it whenever possible in the unstable ABI.

[rsmith]

• Revert vestigial changes to __compressed_pair.

[rsmith]

• Revert one more vestigial change.

[mclow.lists]

A couple of general comments; still working through all the bits.

libcxx/include/__config

1013

This should really go with the rest of the ABI flags up around line #70, and let's give it an ABI name like _LIBCPP_ABI_USE_NO_UNIQUE_ADDRESS

libcxx/include/__hash_table

3035

Shouldn't these be wrapped in a #ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS block?

[rsmith]

• Address a couple of review comments from Marshall.

[rsmith]

• Rename __hash_ macro to avoid name collision.

[EricWF]

Thanks for working on this! __compressed_pair is a menace which causes serious template and code bloat.
And the code without it is much clearer and cleaner.

But...

I'm concerned by the number and size of the conditional compilation blocks this introduces.
In my time on libc++ conditional compilation blocks have been a frequent source of bugs; and I've been working to remove as many as I can.

I haven't figured out a cleaner way to implement this.
Does anyone have ideas on how we might eat our cake and have it too?

libcxx/include/__hash_table

1009

I really don't like this #define approach. Perhaps we could create accessor functions instead?

[ldionne]

I like this, however I want to echo @EricWF 's concern about the conditional compilation this introduces. Do we get any benefit if we still use compressed_pair but switch THAT to use no_unique_address instead?

[rsmith]

In D63744#1561087, @ldionne wrote:

I like this, however I want to echo @EricWF 's concern about the conditional compilation this introduces. Do we get any benefit if we still use compressed_pair but switch THAT to use no_unique_address instead?

Some, but much much less. In my experiments, converting __alloc_func to use [[no_unique_address]] directly had four times as much impact as converting __compressed_pair to use [[no_unique_address]]. Also, probably minor, but we can't easily get rid of the redundant (eg) allocator move constructions unless we remove the extra layer of indirection.

[rsmith]

• Replace #defines of field names in non-[[no_unique_address]] mode with accessor functions

libcxx/include/__hash_table

1009

OK. This will re-add some compilation overhead to the new mode that I was trying to eliminate, but it should be no more than we pay in the old mode. I certainly don't have any measurements to justify this ugliness.

[rsmith]

Ping. Is there any interest in pursuing this, or is the preprocessor complexity too great?

[rsmith]

In D63744#1639938, @rsmith wrote:

Ping. Is there any interest in pursuing this, or is the preprocessor complexity too great?

Ping.

[thakis]

libcxx/include/__config

121

Can we make this defined(_LIBCPP_ABI_UNSTABLE) && !defined(_LIBCPP_ABI_USE_NO_UNIQUE_ADDRESS?

We have a natviz file to tell msvc's debugger how to display libc++ types, and I don't know how well codeview can describe no_unique_address. Furthermore, the natviz files currently explicitly mention the compressed pairs.

So it'd be good if we could opt out of this for a while on windows after it lands, to prepare the visualizers.

[jyknight]

IMO, this is a good idea, and should be committed evendespite the addition of ifdefs in the implementation.

We'd definitely want to do this in a brand new ABI, and there's not really any better way to accomplish it now.

libcxx/include/__config

122

IMO, the ABI shouldn't change based on a compiler feature-test, even in unstable-abi mode.

But I don't see why it'd be a problem to just enable it by default with _LIBCPP_ABI_UNSTABLE, especially if, per the request above, there's a way to explicitly disable it again.

Then, if _LIBCPP_ABI_USE_NO_UNIQUE_ADDRESS is enabled, it should just emit an #error when the compiler fails to support the attribute.

libcxx/include/memory

2612

ifdef in the middle of an expression isn't worth it. Just repeat the rest of the statement.

[ldionne]

If we assume that the compiler supports [[no_unique_address]], is this an ABI break? Does no_unique_address result in a different layout than the __compressed_pair?

[zoecarver]

If we assume that the compiler supports [[no_unique_address]], is this an ABI break? Does no_unique_address result in a different layout than the __compressed_pair?

This is only enabled in the unstable ABI so I think it's OK.

[ldionne]

In D63744#2369727, @zoecarver wrote:

If we assume that the compiler supports [[no_unique_address]], is this an ABI break? Does no_unique_address result in a different layout than the __compressed_pair?

This is only enabled in the unstable ABI so I think it's OK.

The fact that it's only enabled in the unstable ABI causes all this #ifdef mess, which is the reason why this patch has not landed yet. I'm trying to figure out whether we can use __attribute__((no_unique_address)) in the stable ABI too. If we don't assume the compiler supports it then we can't (because then it would break ABI between compilers), but if we require the compiler to support it, then we might be okay. That's my question :-).

[jyknight]

In D63744#2369637, @ldionne wrote:

If we assume that the compiler supports [[no_unique_address]], is this an ABI break? Does no_unique_address result in a different layout than the __compressed_pair?

Yes, this creates an incompatible memory layout. I don't think there's any way around that, while getting the benefits of removing the intermediate object.

If we put [[no_unique_address]] on the elements inside __compressed_pair, I believe that probably creates the same memory layout, but that doesn't get the desired benefit.
As soon as you move the fields out of the intermediate object, you will lose some padding, and thus the layout will be different (consider class Foo {__compressed_pair<double, char> a; __compressed_pair<short, char> b;}; -- due to alignment, "a" has 7 bytes of padding on the end, resulting in a 24-byte object. Whereas, with class Foo {double a1; char a2; short b1; char b2; }; the total size of the object would only be 16 bytes. (I've omitted no_unique_address for brevity here, since none of the objects in this example are empty or possibly-empty).

[zoecarver]

In D63744#2369735, @ldionne wrote:

In D63744#2369727, @zoecarver wrote:

If we assume that the compiler supports [[no_unique_address]], is this an ABI break? Does no_unique_address result in a different layout than the __compressed_pair?

This is only enabled in the unstable ABI so I think it's OK.

The fact that it's only enabled in the unstable ABI causes all this #ifdef mess, which is the reason why this patch has not landed yet. I'm trying to figure out whether we can use __attribute__((no_unique_address)) in the stable ABI too. If we don't assume the compiler supports it then we can't (because then it would break ABI between compilers), but if we require the compiler to support it, then we might be okay. That's my question :-).

I misunderstood what you were saying. Hmm, that's an interesting idea. I think you're right, they would always have the same layout. Because if is_empty_v<T> == true then __compressed_pair_elem acts as an empty base class, so it would have the same effect as a member with [[no_unique_address]]. This wouldn't hold true if any of the compilers we support don't always implement empty base optimizations, though.

[zoecarver]

@jyknight I think we could change the uses were __compressed_pair is the only/last member of an object. Then I'm not sure the padding could change.

[ldionne]

In D63744#2369798, @jyknight wrote:

In D63744#2369637, @ldionne wrote:

If we assume that the compiler supports [[no_unique_address]], is this an ABI break? Does no_unique_address result in a different layout than the __compressed_pair?

Yes, this creates an incompatible memory layout. I don't think there's any way around that, while getting the benefits of removing the intermediate object.

[...]
As soon as you move the fields out of the intermediate object, you will lose some padding, and thus the layout will be different [...]

Ah, right, of course. In that case, though, we could do something like:

class Foo {
  double a1;
  char a2;
#if defined(_LIBCPP_ABI_STABLE)
  char __abi_stable_padding_blablabla[7];
#endif
  short b1;
  char b2;
#if defined(_LIBCPP_ABI_STABLE)
  char __abi_stable_padding2_blablabla[1];
#endif
};

And that would preserve the same layout. Or am I forgetting something else here?

In that case, we could have a utility that creates the right padding for translating from __compressed_pair<T, U> to a sequence of [[no_unique_address]] T; [[no_unique_address]] U;. The usage would be something along the lines of:

class Foo {
  double a1;
  char a2;
#if defined(_LIBCPP_ABI_STABLE)
  [[no_unique_address]] __old_compressed_pair_ABI_padding<double, char> __padding1;
#endif
  short b1;
  char b2;
#if defined(_LIBCPP_ABI_STABLE)
  [[no_unique_address]] __old_compressed_pair_ABI_padding<short, char> __padding2;
#endif
};

This would expand to the right amount of padding for preserving ABI, and it would make sure we don't have to hardcode number of bytes in the code (which is error prone because of platform differences).

And this would neatly preserve ABI while removing 90% of the noise in this patch. Only the member declarations would contain a bit of noise aimed specifically at preserving ABI. WDYT?

[thakis]

Somewhat related, I recently learned that no_unique_address can make clang assert in certain case. Test case + fix: D90622.

[jyknight]

Hm, that might indeed be feasible. We'll need to potentially insert padding both before the first type and after the second type, but we can static_assert the correctness against the old layout, so that's not _too_ scary.

If we go this route, it will mean that libc++ is only usable in an ABI-stable manner on Clang 9+ or GCC 9+. On earlier compilers, and on MSVC, the attribute is ignored, and the layout will thus be incorrect/incompatible. Is it viable to require those compiler versions to both build and use libc++? The LLVM build itself only requires GCC 5+/Clang 3.5 at the moment, so that would mean we'd need to start requiring the use of the 2-stage "runtimes" build in order to build libc++, at the least.

[mclow.lists]

In D63744#2385750, @jyknight wrote:

Hm, that might indeed be feasible. We'll need to potentially insert padding both before the first type and after the second type, but we can static_assert the correctness against the old layout, so that's not _too_ scary.

If we go this route, it will mean that libc++ is only usable in an ABI-stable manner on Clang 9+ or GCC 9+. On earlier compilers, and on MSVC, the attribute is ignored, and the layout will thus be incorrect/incompatible. Is it viable to require those compiler versions to both build and use libc++? The LLVM build itself only requires GCC 5+/Clang 3.5 at the moment, so that would mean we'd need to start requiring the use of the 2-stage "runtimes" build in order to build libc++, at the least.

At which point, we should be asking ourselves, "is this worth doing?"

[ldionne]

In D63744#2385752, @mclow.lists wrote:

In D63744#2385750, @jyknight wrote:

Hm, that might indeed be feasible. We'll need to potentially insert padding both before the first type and after the second type, but we can static_assert the correctness against the old layout, so that's not _too_ scary.

If we go this route, it will mean that libc++ is only usable in an ABI-stable manner on Clang 9+ or GCC 9+. On earlier compilers, and on MSVC, the attribute is ignored, and the layout will thus be incorrect/incompatible. Is it viable to require those compiler versions to both build and use libc++? The LLVM build itself only requires GCC 5+/Clang 3.5 at the moment, so that would mean we'd need to start requiring the use of the 2-stage "runtimes" build in order to build libc++, at the least.

I think this is entirely reasonable. I actually have a draft email I want to send to discuss the issue of libc++ compiler support, but its relevance is gated on making progress with the unified standalone build discussed at http://lists.llvm.org/pipermail/libcxx-dev/2020-October/001004.html.

TLDR: It's already wrong to build libc++ with older compilers if you truly care about ABI and having a robust setup, since those are not tested AND they can't always build the library properly (e.g. libc++abi might be missing RTTI for some fundamental types). I think a 2 stage runtimes build should be the default way that libc++ is built as part of releasing a toolchain. This is what libstdc++ does w/ GCC.

At which point, we should be asking ourselves, "is this worth doing?"

I think it's a good question, however according to my answer to the above, my personal opinion is that it's worth exploring, if there are true benefits to be had from using [[no_unique_address]]. I think the benefits are real.

[ldionne]

We now support only compilers that support [[no_unique_address]]. We could investigate the direction I proposed above. If there's interest in doing that, let's investigate it. Otherwise, let's abandon this patch to clear up the review queue.

[ldionne]

(requesting changes so it shows up correctly in the queue)

[Mordante]

In D63744#2911574, @ldionne wrote:

We now support only compilers that support [[no_unique_address]].

I just noticed our Windows build bots don't support it.
https://buildkite.com/organizations/llvm-project/pipelines/libcxx-ci/builds/4579/jobs/5b2eb7ca-c775-4418-84f2-989e6ba3016e/raw_log

-- The CXX compiler identification is Clang 12.0.0 with MSVC-like command-line
-- The C compiler identification is Clang 12.0.0 with MSVC-like command-line

...

C:/ws/w32-1/llvm-project/libcxx-ci/build/windows-dll/include/c++/v1\__iterator/counted_iterator.h(69,5): warning: unknown attribute 'no_unique_address' ignored [-Wunknown-attributes]
  [[no_unique_address]] _Iter __current_ = _Iter();
    ^~~~~~~~~~~~~~~~~
1 warning generated.

[ldionne]

[Github PR transition cleanup]

@rsmith Given that I think this patch would need a lot of work (rebase + the approach discussed above), do you think it is reasonable to abandon it? I also believe that @cjdb was thinking about picking up this work, so the underlying effect you wanted to achieve here would be achieved that way.

[ldionne]

Closing to clean up the queue.

libcxx/include/__config

 #  endif
 // Feature macros for disabling pre ABI v1 features. All of these options
 // are deprecated.
 #  if defined(__FreeBSD__)
 #    define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
 #  endif
 #endif
 
 #ifdef _LIBCPP_TRIVIAL_PAIR_COPY_CTOR
 #error "_LIBCPP_TRIVIAL_PAIR_COPY_CTOR" is no longer supported. \
        use _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR instead
 #endif
 
 #define _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_X##_LIBCPP_Y
 #define _LIBCPP_CONCAT(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y)
 
 #ifndef _LIBCPP_ABI_NAMESPACE
 # define _LIBCPP_ABI_NAMESPACE _LIBCPP_CONCAT(__,_LIBCPP_ABI_VERSION)

 
 #if !defined(_LIBCPP_DISABLE_NODISCARD_AFTER_CXX17) && \
     (_LIBCPP_STD_VER > 17 || defined(_LIBCPP_ENABLE_NODISCARD))
 #  define _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_NODISCARD_ATTRIBUTE
 #else
 #  define _LIBCPP_NODISCARD_AFTER_CXX17
 #endif
 
+#if __has_cpp_attribute(no_unique_address) && defined(_LIBCPP_ABI_UNSTABLE)
+#  define _LIBCPP_USE_NO_UNIQUE_ADDRESS 1
+#endif
+
 #if _LIBCPP_STD_VER > 14 && defined(__cpp_inline_variables) && (__cpp_inline_variables >= 201606L)
 #  define _LIBCPP_INLINE_VAR inline
 #else
 #  define _LIBCPP_INLINE_VAR
 #endif
 
 #ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #  define _LIBCPP_EXPLICIT_MOVE(x) _VSTD::move(x)

libcxx/include/__hash_table

 
 template <class _Alloc>
 class __bucket_list_deallocator
 {
     typedef _Alloc                                          allocator_type;
     typedef allocator_traits<allocator_type>                __alloc_traits;
     typedef typename __alloc_traits::size_type              size_type;
 
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    size_type __size_;
+    [[no_unique_address]] allocator_type __alloc_;
+#else
     __compressed_pair<size_type, allocator_type> __data_;
+#endif
 public:
     typedef typename __alloc_traits::pointer pointer;
 
     _LIBCPP_INLINE_VISIBILITY
     __bucket_list_deallocator()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
-        : __data_(0) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        : __size_(0), __alloc_()
+#else
+        : __data_(0)
+#endif
+    {}
 
     _LIBCPP_INLINE_VISIBILITY
     __bucket_list_deallocator(const allocator_type& __a, size_type __size)
         _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
-        : __data_(__size, __a) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        : __size_(__size), __alloc_(__a)
+#else
+        : __data_(__size, __a)
+#endif
+    {}
 
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     __bucket_list_deallocator(__bucket_list_deallocator&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        : __size_(__x.__size_), __alloc_(_VSTD::move(__x.__alloc_))
+#else
         : __data_(_VSTD::move(__x.__data_))
+#endif
     {
         __x.size() = 0;
     }
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
-    size_type& size() _NOEXCEPT {return __data_.first();}
+    size_type& size() _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        return __size_;
+#else
+        return __data_.first();
+#endif
+    }
     _LIBCPP_INLINE_VISIBILITY
-    size_type  size() const _NOEXCEPT {return __data_.first();}
+    size_type  size() const _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        return __size_;
+#else
+        return __data_.first();
+#endif
+    }
 
     _LIBCPP_INLINE_VISIBILITY
-    allocator_type& __alloc() _NOEXCEPT {return __data_.second();}
+    allocator_type& __alloc() _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        return __alloc_;
+#else
+        return __data_.second();
+#endif
+    }
     _LIBCPP_INLINE_VISIBILITY
-    const allocator_type& __alloc() const _NOEXCEPT {return __data_.second();}
+    const allocator_type& __alloc() const _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        return __alloc_;
+#else
+        return __data_.second();
+#endif
+    }
 
     _LIBCPP_INLINE_VISIBILITY
     void operator()(pointer __p) _NOEXCEPT
     {
         __alloc_traits::deallocate(__alloc(), __p, size());
     }
 };
 
private:
     typedef typename __rebind_alloc_helper<__node_traits, __next_pointer>::type __pointer_allocator;
     typedef __bucket_list_deallocator<__pointer_allocator> __bucket_list_deleter;
     typedef unique_ptr<__next_pointer[], __bucket_list_deleter> __bucket_list;
     typedef allocator_traits<__pointer_allocator>          __pointer_alloc_traits;
     typedef typename __bucket_list_deleter::pointer       __node_pointer_pointer;
 
     // --- Member data begin ---
     __bucket_list                                         __bucket_list_;
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    __first_node                                          __first_node_;
+    size_type                                             __size_;
+    float                                                 __max_load_factor_;
+    [[no_unique_address]] __node_allocator                __alloc_;
+    [[no_unique_address]] hasher                          __hash_;
+    [[no_unique_address]] key_equal                       __eq_;
+#else
     __compressed_pair<__first_node, __node_allocator>     __p1_;
     __compressed_pair<size_type, hasher>                  __p2_;
     __compressed_pair<float, key_equal>                   __p3_;
+    #define __first_node_      __p1_.first()
+    #define __size_            __p2_.first()
+    #define __max_load_factor_ __p3_.first()
+    #define __alloc_           __p1_.second()
+    #define __hash_            __p2_.second()
+    #define __eq_              __p3_.second()
+#endif
     // --- Member data end ---
 
     _LIBCPP_INLINE_VISIBILITY
-    size_type& size() _NOEXCEPT {return __p2_.first();}
+    size_type& size() _NOEXCEPT {return __size_;}
 public:
     _LIBCPP_INLINE_VISIBILITY
-    size_type  size() const _NOEXCEPT {return __p2_.first();}
+    size_type  size() const _NOEXCEPT {return __size_;}
 
     _LIBCPP_INLINE_VISIBILITY
-    hasher& hash_function() _NOEXCEPT {return __p2_.second();}
+    hasher& hash_function() _NOEXCEPT {return __hash_;}
     _LIBCPP_INLINE_VISIBILITY
-    const hasher& hash_function() const _NOEXCEPT {return __p2_.second();}
+    const hasher& hash_function() const _NOEXCEPT {return __hash_;}
 
     _LIBCPP_INLINE_VISIBILITY
-    float& max_load_factor() _NOEXCEPT {return __p3_.first();}
+    float& max_load_factor() _NOEXCEPT {return __max_load_factor_;}
     _LIBCPP_INLINE_VISIBILITY
-    float  max_load_factor() const _NOEXCEPT {return __p3_.first();}
+    float  max_load_factor() const _NOEXCEPT {return __max_load_factor_;}
 
     _LIBCPP_INLINE_VISIBILITY
-    key_equal& key_eq() _NOEXCEPT {return __p3_.second();}
+    key_equal& key_eq() _NOEXCEPT {return __eq_;}
     _LIBCPP_INLINE_VISIBILITY
-    const key_equal& key_eq() const _NOEXCEPT {return __p3_.second();}
+    const key_equal& key_eq() const _NOEXCEPT {return __eq_;}
 
     _LIBCPP_INLINE_VISIBILITY
-    __node_allocator& __node_alloc() _NOEXCEPT {return __p1_.second();}
+    __node_allocator& __node_alloc() _NOEXCEPT {return __alloc_;}
     _LIBCPP_INLINE_VISIBILITY
     const __node_allocator& __node_alloc() const _NOEXCEPT
-        {return __p1_.second();}
+        {return __alloc_;}
 
 public:
     typedef __hash_iterator<__node_pointer>                   iterator;
     typedef __hash_const_iterator<__node_pointer>             const_iterator;
     typedef __hash_local_iterator<__node_pointer>             local_iterator;
     typedef __hash_const_local_iterator<__node_pointer>       const_local_iterator;
 
     _LIBCPP_INLINE_VISIBILITY

 inline
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
     _NOEXCEPT_(
         is_nothrow_default_constructible<__bucket_list>::value &&
         is_nothrow_default_constructible<__first_node>::value &&
         is_nothrow_default_constructible<__node_allocator>::value &&
         is_nothrow_default_constructible<hasher>::value &&
         is_nothrow_default_constructible<key_equal>::value)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __size_(0),
+      __max_load_factor_(1.0f),
+      __alloc_(),
+      __hash_(),
+      __eq_()
+#else
     : __p2_(0),
       __p3_(1.0f)
+#endif
 {
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
-                                                       const key_equal& __eql)
+inline __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(
+    const hasher &__hf, const key_equal &__eql)
     : __bucket_list_(nullptr, __bucket_list_deleter()),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(0),
+      __max_load_factor_(1.0f),
+      __alloc_(),
+      __hash_(__hf),
+      __eq_(__eql)
+#else
       __p1_(),
       __p2_(0, __hf),
       __p3_(1.0f, __eql)
+#endif
 {
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
                                                        const key_equal& __eql,
                                                        const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(0),
+      __max_load_factor_(1.0f),
+      __alloc_(__a),
+      __hash_(__hf),
+      __eq_(__eql)
+#else
       __p1_(__second_tag(), __node_allocator(__a)),
       __p2_(0, __hf),
       __p3_(1.0f, __eql)
+#endif
 {
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(0),
+      __max_load_factor_(1.0f),
+      __alloc_(__a),
+      __hash_(),
+      __eq_()
+#else
       __p1_(__second_tag(), __node_allocator(__a)),
       __p2_(0),
       __p3_(1.0f)
+#endif
 {
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u)
     : __bucket_list_(nullptr,
           __bucket_list_deleter(allocator_traits<__pointer_allocator>::
               select_on_container_copy_construction(
                   __u.__bucket_list_.get_deleter().__alloc()), 0)),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(0),
+      __max_load_factor_(__u.__max_load_factor_),
+      __alloc_(allocator_traits<__node_allocator>::
+                   select_on_container_copy_construction(__u.__node_alloc())),
+      __hash_(__u.__hash_),
+      __eq_(__u.__eq_)
+#else
       __p1_(__second_tag(), allocator_traits<__node_allocator>::
           select_on_container_copy_construction(__u.__node_alloc())),
       __p2_(0, __u.hash_function()),
       __p3_(__u.__p3_)
+#endif
 {
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u,
                                                        const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(0),
+      __max_load_factor_(__u.__max_load_factor_),
+      __alloc_(__a),
+      __hash_(__u.__hash_),
+      __eq_(__u.__eq_)
+#else
       __p1_(__second_tag(), __node_allocator(__a)),
       __p2_(0, __u.hash_function()),
       __p3_(__u.__p3_)
+#endif
 {
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
         _NOEXCEPT_(
             is_nothrow_move_constructible<__bucket_list>::value &&
             is_nothrow_move_constructible<__first_node>::value &&
             is_nothrow_move_constructible<__node_allocator>::value &&
             is_nothrow_move_constructible<hasher>::value &&
             is_nothrow_move_constructible<key_equal>::value)
     : __bucket_list_(_VSTD::move(__u.__bucket_list_)),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __first_node_(_VSTD::move(__u.__first_node_)),
+      __size_(__u.__size_),
+      __max_load_factor_(__u.__max_load_factor_),
+      __alloc_(_VSTD::move(__u.__alloc_)),
+      __hash_(_VSTD::move(__u.__hash_)),
+      __eq_(_VSTD::move(__u.__eq_))
+#else
       __p1_(_VSTD::move(__u.__p1_)),
       __p2_(_VSTD::move(__u.__p2_)),
       __p3_(_VSTD::move(__u.__p3_))
+#endif
 {
     if (size() > 0)
     {
-        __bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
-            __p1_.first().__ptr();
-        __u.__p1_.first().__next_ = nullptr;
+        __bucket_list_[__constrain_hash(__first_node_.__next_->__hash(), bucket_count())] =
+            __first_node_.__ptr();
+        __u.__first_node_.__next_ = nullptr;
         __u.size() = 0;
     }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
                                                        const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(0),
+      __max_load_factor_(__u.__max_load_factor_),
+      __alloc_(__a),
+      __hash_(_VSTD::move(__u.__hash_)),
+      __eq_(_VSTD::move(__u.__eq_))
+#else
       __p1_(__second_tag(), __node_allocator(__a)),
       __p2_(0, _VSTD::move(__u.hash_function())),
       __p3_(_VSTD::move(__u.__p3_))
+#endif
 {
     if (__a == allocator_type(__u.__node_alloc()))
     {
         __bucket_list_.reset(__u.__bucket_list_.release());
         __bucket_list_.get_deleter().size() = __u.__bucket_list_.get_deleter().size();
         __u.__bucket_list_.get_deleter().size() = 0;
         if (__u.size() > 0)
         {
-            __p1_.first().__next_ = __u.__p1_.first().__next_;
-            __u.__p1_.first().__next_ = nullptr;
-            __bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
-                __p1_.first().__ptr();
+            __first_node_.__next_ = __u.__first_node_.__next_;
+            __u.__first_node_.__next_ = nullptr;
+            __bucket_list_[__constrain_hash(__first_node_.__next_->__hash(), bucket_count())] =
+                __first_node_.__ptr();
             size() = __u.size();
             __u.size() = 0;
         }
     }
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table()
 {
 #if defined(_LIBCPP_CXX03_LANG)
     static_assert((is_copy_constructible<key_equal>::value),
                  "Predicate must be copy-constructible.");
     static_assert((is_copy_constructible<hasher>::value),
                  "Hasher must be copy-constructible.");
 #endif
 
-    __deallocate_node(__p1_.first().__next_);
+    __deallocate_node(__first_node_.__next_);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__erase_c(this);
 #endif
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__copy_assign_alloc(

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__next_pointer
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__detach() _NOEXCEPT
 {
     size_type __bc = bucket_count();
     for (size_type __i = 0; __i < __bc; ++__i)
         __bucket_list_[__i] = nullptr;
     size() = 0;
-    __next_pointer __cache = __p1_.first().__next_;
-    __p1_.first().__next_ = nullptr;
+    __next_pointer __cache = __first_node_.__next_;
+    __first_node_.__next_ = nullptr;
     return __cache;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
         __hash_table& __u, true_type)
     _NOEXCEPT_(
         is_nothrow_move_assignable<__node_allocator>::value &&
         is_nothrow_move_assignable<hasher>::value &&
         is_nothrow_move_assignable<key_equal>::value)
 {
     clear();
     __bucket_list_.reset(__u.__bucket_list_.release());
     __bucket_list_.get_deleter().size() = __u.__bucket_list_.get_deleter().size();
     __u.__bucket_list_.get_deleter().size() = 0;
     __move_assign_alloc(__u);
     size() = __u.size();
     hash_function() = _VSTD::move(__u.hash_function());
     max_load_factor() = __u.max_load_factor();
     key_eq() = _VSTD::move(__u.key_eq());
-    __p1_.first().__next_ = __u.__p1_.first().__next_;
+    __first_node_.__next_ = __u.__first_node_.__next_;
     if (size() > 0)
     {
-        __bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
-            __p1_.first().__ptr();
-        __u.__p1_.first().__next_ = nullptr;
+        __bucket_list_[__constrain_hash(__first_node_.__next_->__hash(), bucket_count())] =
+            __first_node_.__ptr();
+        __u.__first_node_.__next_ = nullptr;
         __u.size() = 0;
     }
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->swap(this, &__u);
 #endif
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>

 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() _NOEXCEPT
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
-    return iterator(__p1_.first().__next_, this);
+    return iterator(__first_node_.__next_, this);
 #else
-    return iterator(__p1_.first().__next_);
+    return iterator(__first_node_.__next_);
 #endif
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::end() _NOEXCEPT
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return iterator(nullptr, this);
 #else
     return iterator(nullptr);
 #endif
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() const _NOEXCEPT
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
-    return const_iterator(__p1_.first().__next_, this);
+    return const_iterator(__first_node_.__next_, this);
 #else
-    return const_iterator(__p1_.first().__next_);
+    return const_iterator(__first_node_.__next_);
 #endif
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::end() const _NOEXCEPT
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return const_iterator(nullptr, this);
 #else
     return const_iterator(nullptr);
 #endif
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT
 {
     if (size() > 0)
     {
-        __deallocate_node(__p1_.first().__next_);
-        __p1_.first().__next_ = nullptr;
+        __deallocate_node(__first_node_.__next_);
+        __first_node_.__next_ = nullptr;
         size_type __bc = bucket_count();
         for (size_type __i = 0; __i < __bc; ++__i)
             __bucket_list_[__i] = nullptr;
         size() = 0;
     }
 }
 
 
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique_perform(
     __node_pointer __nd) _NOEXCEPT
 {
     size_type __bc = bucket_count();
     size_t __chash = __constrain_hash(__nd->__hash(), __bc);
     // insert_after __bucket_list_[__chash], or __first_node if bucket is null
     __next_pointer __pn = __bucket_list_[__chash];
     if (__pn == nullptr)
     {
-        __pn =__p1_.first().__ptr();
+        __pn =__first_node_.__ptr();
         __nd->__next_ = __pn->__next_;
         __pn->__next_ = __nd->__ptr();
         // fix up __bucket_list_
         __bucket_list_[__chash] = __pn;
         if (__nd->__next_ != nullptr)
             __bucket_list_[__constrain_hash(__nd->__next_->__hash(), __bc)] = __nd->__ptr();
     }
     else

 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_perform(
     __node_pointer __cp, __next_pointer __pn) _NOEXCEPT
 {
     size_type __bc = bucket_count();
     size_t __chash = __constrain_hash(__cp->__hash_, __bc);
     if (__pn == nullptr)
     {
-        __pn =__p1_.first().__ptr();
+        __pn =__first_node_.__ptr();
         __cp->__next_ = __pn->__next_;
         __pn->__next_ = __cp->__ptr();
         // fix up __bucket_list_
         __bucket_list_[__chash] = __pn;
         if (__cp->__next_ != nullptr)
             __bucket_list_[__constrain_hash(__cp->__next_->__hash(), __bc)]
                 = __cp->__ptr();
     }
#endif
                            size_type(ceil(float(size() + 1) / max_load_factor()))));
             __bc = bucket_count();
             __chash = __constrain_hash(__hash, __bc);
         }
         // insert_after __bucket_list_[__chash], or __first_node if bucket is null
         __next_pointer __pn = __bucket_list_[__chash];
         if (__pn == nullptr)
         {
-            __pn = __p1_.first().__ptr();
+            __pn = __first_node_.__ptr();
             __h->__next_ = __pn->__next_;
             __pn->__next_ = __h.get()->__ptr();
             // fix up __bucket_list_
             __bucket_list_[__chash] = __pn;
             if (__h->__next_ != nullptr)
                 __bucket_list_[__constrain_hash(__h->__next_->__hash(), __bc)]
                     = __h.get()->__ptr();
         }
#endif  // _LIBCPP_DEBUG_LEVEL >= 2
     __pointer_allocator& __npa = __bucket_list_.get_deleter().__alloc();
     __bucket_list_.reset(__nbc > 0 ?
                       __pointer_alloc_traits::allocate(__npa, __nbc) : nullptr);
     __bucket_list_.get_deleter().size() = __nbc;
     if (__nbc > 0)
     {
         for (size_type __i = 0; __i < __nbc; ++__i)
             __bucket_list_[__i] = nullptr;
-        __next_pointer __pp = __p1_.first().__ptr();
+        __next_pointer __pp = __first_node_.__ptr();
         __next_pointer __cp = __pp->__next_;
         if (__cp != nullptr)
         {
             size_type __chash = __constrain_hash(__cp->__hash(), __nbc);
             __bucket_list_[__chash] = __pp;
             size_type __phash = __chash;
             for (__pp = __cp, __cp = __cp->__next_; __cp != nullptr;
                                                            __cp = __pp->__next_)
__hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
     size_t __chash = __constrain_hash(__cn->__hash(), __bc);
     // find previous node
     __next_pointer __pn = __bucket_list_[__chash];
     for (; __pn->__next_ != __cn; __pn = __pn->__next_)
         ;
     // Fix up __bucket_list_
         // if __pn is not in same bucket (before begin is not in same bucket) &&
         //    if __cn->__next_ is not in same bucket (nullptr is not in same bucket)
-    if (__pn == __p1_.first().__ptr()
+    if (__pn == __first_node_.__ptr()
             || __constrain_hash(__pn->__hash(), __bc) != __chash)
     {
         if (__cn->__next_ == nullptr
             || __constrain_hash(__cn->__next_->__hash(), __bc) != __chash)
             __bucket_list_[__chash] = nullptr;
     }
         // if __cn->__next_ is not in same bucket (nullptr is in same bucket)
     if (__cn->__next_ != nullptr)
_LIBCPP_ASSERT(__node_traits::propagate_on_container_swap::value ||
                    this->__node_alloc() == __u.__node_alloc(),
                    "list::swap: Either propagate_on_container_swap must be true"
                    " or the allocators must compare equal");
     {
     __node_pointer_pointer __npp = __bucket_list_.release();
     __bucket_list_.reset(__u.__bucket_list_.release());
     __u.__bucket_list_.reset(__npp);
     }
-    _VSTD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
+    using _VSTD::swap;
+    swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
     __swap_allocator(__bucket_list_.get_deleter().__alloc(),
              __u.__bucket_list_.get_deleter().__alloc());
     __swap_allocator(__node_alloc(), __u.__node_alloc());
-    _VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
-    __p2_.swap(__u.__p2_);
-    __p3_.swap(__u.__p3_);
+    swap(__first_node_.__next_, __u.__first_node_.__next_);
+    swap(__size_, __u.__size_);
+    swap(__hash_, __u.__hash_);
+    swap(__max_load_factor_, __u.__max_load_factor_);
+    swap(__eq_, __u.__eq_);
     if (size() > 0)
-        __bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
-            __p1_.first().__ptr();
+        __bucket_list_[__constrain_hash(__first_node_.__next_->__hash(), bucket_count())] =
+            __first_node_.__ptr();
     if (__u.size() > 0)
-        __u.__bucket_list_[__constrain_hash(__u.__p1_.first().__next_->__hash(), __u.bucket_count())] =
-            __u.__p1_.first().__ptr();
+        __u.__bucket_list_[__constrain_hash(__u.__first_node_.__next_->__hash(), __u.bucket_count())] =
+            __u.__first_node_.__ptr();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->swap(this, &__u);
 #endif
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::bucket_size(size_type __n) const

 bool
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__subscriptable(const const_iterator*, ptrdiff_t) const
 {
     return false;
 }
 
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
 
+#undef __first_node_
+#undef __size_
+#undef __max_load_factor_
+#undef __alloc_
+#undef __hash_
+#undef __eq_
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP__HASH_TABLE

libcxx/include/__split_buffer

public:
     typedef typename __alloc_traits::pointer                pointer;
     typedef typename __alloc_traits::const_pointer          const_pointer;
     typedef pointer                                         iterator;
     typedef const_pointer                                   const_iterator;
 
     pointer                                         __first_;
     pointer                                         __begin_;
     pointer                                         __end_;
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    pointer                                         __end_cap_;
+    [[no_unique_address]] allocator_type            __alloc_;
+#else
     __compressed_pair<pointer, allocator_type> __end_cap_;
+#endif
 
     typedef typename add_lvalue_reference<allocator_type>::type __alloc_ref;
     typedef typename add_lvalue_reference<allocator_type>::type __alloc_const_ref;
 
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    _LIBCPP_INLINE_VISIBILITY __alloc_rr&           __alloc() _NOEXCEPT         {return __alloc_;}
+    _LIBCPP_INLINE_VISIBILITY const __alloc_rr&     __alloc() const _NOEXCEPT   {return __alloc_;}
+    _LIBCPP_INLINE_VISIBILITY pointer&              __end_cap() _NOEXCEPT       {return __end_cap_;}
+    _LIBCPP_INLINE_VISIBILITY const pointer&        __end_cap() const _NOEXCEPT {return __end_cap_;}
+#else
     _LIBCPP_INLINE_VISIBILITY __alloc_rr&           __alloc() _NOEXCEPT         {return __end_cap_.second();}
     _LIBCPP_INLINE_VISIBILITY const __alloc_rr&     __alloc() const _NOEXCEPT   {return __end_cap_.second();}
     _LIBCPP_INLINE_VISIBILITY pointer&              __end_cap() _NOEXCEPT       {return __end_cap_.first();}
     _LIBCPP_INLINE_VISIBILITY const pointer&        __end_cap() const _NOEXCEPT {return __end_cap_.first();}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     __split_buffer()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
     _LIBCPP_INLINE_VISIBILITY
     explicit __split_buffer(__alloc_rr& __a);
     _LIBCPP_INLINE_VISIBILITY
     explicit __split_buffer(const __alloc_rr& __a);

 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) _NOEXCEPT
 {
     __end_ = __new_last;
 }
 
 template <class _Tp, class _Allocator>
 __split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __start, __alloc_rr& __a)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __end_cap_(nullptr), __alloc_(__a)
+#else
     : __end_cap_(nullptr, __a)
+#endif
 {
     __first_ = __cap != 0 ? __alloc_traits::allocate(__alloc(), __cap) : nullptr;
     __begin_ = __end_ = __first_ + __start;
     __end_cap() = __first_ + __cap;
 }
 
 template <class _Tp, class _Allocator>
 inline
 __split_buffer<_Tp, _Allocator>::__split_buffer()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    , __alloc_()
+#endif
 {
 }
 
 template <class _Tp, class _Allocator>
 inline
 __split_buffer<_Tp, _Allocator>::__split_buffer(__alloc_rr& __a)
-    : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
+    : __first_(nullptr), __begin_(nullptr), __end_(nullptr),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __end_cap_(nullptr), __alloc_(__a)
+#else
+      __end_cap_(nullptr, __a)
+#endif
 {
 }
 
 template <class _Tp, class _Allocator>
 inline
 __split_buffer<_Tp, _Allocator>::__split_buffer(const __alloc_rr& __a)
-    : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
+    : __first_(nullptr), __begin_(nullptr), __end_(nullptr),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __end_cap_(nullptr), __alloc_(__a)
+#else
+      __end_cap_(nullptr, __a)
+#endif
 {
 }
 
 template <class _Tp, class _Allocator>
 __split_buffer<_Tp, _Allocator>::~__split_buffer()
 {
     clear();
     if (__first_)
         __alloc_traits::deallocate(__alloc(), __first_, capacity());
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
 __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
     : __first_(_VSTD::move(__c.__first_)),
       __begin_(_VSTD::move(__c.__begin_)),
       __end_(_VSTD::move(__c.__end_)),
       __end_cap_(_VSTD::move(__c.__end_cap_))
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    , __alloc_(_VSTD::move(__c.__alloc_))
+#endif
 {
     __c.__first_ = nullptr;
     __c.__begin_ = nullptr;
     __c.__end_ = nullptr;
     __c.__end_cap() = nullptr;
 }
 
 template <class _Tp, class _Allocator>
 __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __alloc_rr& __a)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __alloc_(__a)
+#else
     : __end_cap_(__second_tag(), __a)
+#endif
 {
     if (__a == __c.__alloc())
     {
         __first_ = __c.__first_;
         __begin_ = __c.__begin_;
         __end_ = __c.__end_;
         __end_cap() = __c.__end_cap();
         __c.__first_ = nullptr;

libcxx/include/__tree

private:
     typedef typename __rebind_alloc_helper<__node_traits, __node_base>::type
         __node_base_allocator;
     typedef allocator_traits<__node_base_allocator> __node_base_traits;
     static_assert((is_same<__node_base_pointer, typename __node_base_traits::pointer>::value),
                  "Allocator does not rebind pointers in a sane manner.");
 
 private:
     __iter_pointer                                     __begin_node_;
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    __end_node_t                                       __end_node_;
+    size_type                                          __size_;
+    [[no_unique_address]] __node_allocator             __alloc_;
+    [[no_unique_address]] value_compare                __comp_;
+#else
     __compressed_pair<__end_node_t, __node_allocator>  __pair1_;
     __compressed_pair<size_type, value_compare>        __pair3_;
+    #define __end_node_ __pair1_.first()
+    #define __alloc_ __pair1_.second()
+    #define __size_ __pair3_.first()
+    #define __comp_ __pair3_.second()
+#endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     __iter_pointer __end_node() _NOEXCEPT
     {
         return static_cast<__iter_pointer>(
-                pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first())
+                pointer_traits<__end_node_ptr>::pointer_to(__end_node_)
         );
     }
     _LIBCPP_INLINE_VISIBILITY
     __iter_pointer __end_node() const _NOEXCEPT
     {
         return static_cast<__iter_pointer>(
             pointer_traits<__end_node_ptr>::pointer_to(
-                const_cast<__end_node_t&>(__pair1_.first())
+                const_cast<__end_node_t&>(__end_node_)
             )
         );
     }
     _LIBCPP_INLINE_VISIBILITY
-          __node_allocator& __node_alloc() _NOEXCEPT {return __pair1_.second();}
+          __node_allocator& __node_alloc() _NOEXCEPT {return __alloc_;}
 private:
     _LIBCPP_INLINE_VISIBILITY
-    const __node_allocator& __node_alloc() const _NOEXCEPT
-        {return __pair1_.second();}
+    const __node_allocator& __node_alloc() const _NOEXCEPT {return __alloc_;}
     _LIBCPP_INLINE_VISIBILITY
           __iter_pointer& __begin_node() _NOEXCEPT {return __begin_node_;}
     _LIBCPP_INLINE_VISIBILITY
     const __iter_pointer& __begin_node() const _NOEXCEPT {return __begin_node_;}
 public:
     _LIBCPP_INLINE_VISIBILITY
     allocator_type __alloc() const _NOEXCEPT
         {return allocator_type(__node_alloc());}
 private:
     _LIBCPP_INLINE_VISIBILITY
-          size_type& size() _NOEXCEPT {return __pair3_.first();}
+          size_type& size() _NOEXCEPT {return __size_;}
 public:
     _LIBCPP_INLINE_VISIBILITY
-    const size_type& size() const _NOEXCEPT {return __pair3_.first();}
+    const size_type& size() const _NOEXCEPT {return __size_;}
     _LIBCPP_INLINE_VISIBILITY
-          value_compare& value_comp() _NOEXCEPT {return __pair3_.second();}
+          value_compare& value_comp() _NOEXCEPT {return __comp_;}
     _LIBCPP_INLINE_VISIBILITY
-    const value_compare& value_comp() const _NOEXCEPT
-        {return __pair3_.second();}
+    const value_compare& value_comp() const _NOEXCEPT {return __comp_;}
 public:
 
     _LIBCPP_INLINE_VISIBILITY
     __node_pointer __root() const _NOEXCEPT
         {return static_cast<__node_pointer>(__end_node()->__left_);}
 
     __node_base_pointer* __root_ptr() const _NOEXCEPT {
         return _VSTD::addressof(__end_node()->__left_);
#endif
     template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
 };
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)
         _NOEXCEPT_(
             is_nothrow_default_constructible<__node_allocator>::value &&
             is_nothrow_copy_constructible<value_compare>::value)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __size_(0), __alloc_(), __comp_(__comp)
+#else
     : __pair3_(0, __comp)
+#endif
 {
     __begin_node() = __end_node();
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const allocator_type& __a)
     : __begin_node_(__iter_pointer()),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(0), __alloc_(__a), __comp_()
+#else
       __pair1_(__second_tag(), __node_allocator(__a)),
       __pair3_(0)
+#endif
 {
     __begin_node() = __end_node();
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp,
                                            const allocator_type& __a)
     : __begin_node_(__iter_pointer()),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(0), __alloc_(__a), __comp_(__comp)
+#else
       __pair1_(__second_tag(), __node_allocator(__a)),
       __pair3_(0, __comp)
+#endif
 {
     __begin_node() = __end_node();
 }
 
 // Precondition:  size() != 0
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_pointer
 __tree<_Tp, _Compare, _Allocator>::__detach()
#endif  // _LIBCPP_NO_EXCEPTIONS
     }
     for (; __first != __last; ++__first)
         __insert_multi(_NodeTypes::__get_value(*__first));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)
     : __begin_node_(__iter_pointer()),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(0),
+      __alloc_(__node_traits::select_on_container_copy_construction(__t.__node_alloc())),
+      __comp_(__t.value_comp())
+#else
       __pair1_(__second_tag(), __node_traits::select_on_container_copy_construction(__t.__node_alloc())),
       __pair3_(0, __t.value_comp())
+#endif
 {
     __begin_node() = __end_node();
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
     _NOEXCEPT_(
         is_nothrow_move_constructible<__node_allocator>::value &&
         is_nothrow_move_constructible<value_compare>::value)
     : __begin_node_(_VSTD::move(__t.__begin_node_)),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __end_node_(_VSTD::move(__t.__end_node_)),
+      __size_(__t.__size_),
+      __alloc_(_VSTD::move(__t.__alloc_)),
+      __comp_(_VSTD::move(__t.__comp_))
+#else
       __pair1_(_VSTD::move(__t.__pair1_)),
       __pair3_(_VSTD::move(__t.__pair3_))
+#endif
 {
     if (size() == 0)
         __begin_node() = __end_node();
     else
     {
         __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
         __t.__begin_node() = __t.__end_node();
         __t.__end_node()->__left_ = nullptr;
         __t.size() = 0;
     }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __size_(0), __alloc_(__a), __comp_(_VSTD::move(__t.__comp_))
+#else
     : __pair1_(__second_tag(), __node_allocator(__a)),
       __pair3_(0, _VSTD::move(__t.value_comp()))
+#endif
 {
     if (__a == __t.__alloc())
     {
         if (__t.size() == 0)
             __begin_node() = __end_node();
         else
         {
             __begin_node() = __t.__begin_node();

 template <class _Tp, class _Compare, class _Allocator>
 void
 __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
     _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
                is_nothrow_move_assignable<__node_allocator>::value)
 {
     destroy(static_cast<__node_pointer>(__end_node()->__left_));
     __begin_node_ = __t.__begin_node_;
-    __pair1_.first() = __t.__pair1_.first();
+    __end_node_ = __t.__end_node_;
     __move_assign_alloc(__t);
-    __pair3_ = _VSTD::move(__t.__pair3_);
+    __size_ = __t.__size_;
+    __comp_ = _VSTD::move(__t.__comp_);
     if (size() == 0)
         __begin_node() = __end_node();
     else
     {
         __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
         __t.__begin_node() = __t.__end_node();
         __t.__end_node()->__left_ = nullptr;
         __t.size() = 0;
#if _LIBCPP_STD_VER <= 11
                  __is_nothrow_swappable<__node_allocator>::value)
             )
 #else
         _NOEXCEPT_(__is_nothrow_swappable<value_compare>::value)
 #endif
 {
     using _VSTD::swap;
     swap(__begin_node_, __t.__begin_node_);
-    swap(__pair1_.first(), __t.__pair1_.first());
+    swap(__end_node_, __t.__end_node_);
     __swap_allocator(__node_alloc(), __t.__node_alloc());
-    __pair3_.swap(__t.__pair3_);
+    swap(__size_, __t.__size_);
+    swap(__comp_, __t.__comp_);
     if (size() == 0)
         __begin_node() = __end_node();
     else
         __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
     if (__t.size() == 0)
         __t.__begin_node() = __t.__end_node();
     else
         __t.__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__t.__end_node());

 void
 swap(__tree<_Tp, _Compare, _Allocator>& __x,
      __tree<_Tp, _Compare, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
+#undef __end_node_
+#undef __alloc_
+#undef __size_
+#undef __comp_
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP___TREE

libcxx/include/deque

protected:
     typedef __deque_iterator<value_type, pointer, reference, __map_pointer,
                              difference_type>    iterator;
     typedef __deque_iterator<value_type, const_pointer, const_reference, __map_const_pointer,
                              difference_type>    const_iterator;
 
 protected:
     __map __map_;
     size_type __start_;
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    size_type __size_;
+    [[no_unique_address]] allocator_type __alloc_;
+#else
     __compressed_pair<size_type, allocator_type> __size_;
+#endif
 
     iterator       begin() _NOEXCEPT;
     const_iterator begin() const _NOEXCEPT;
     iterator       end() _NOEXCEPT;
     const_iterator end() const _NOEXCEPT;
 
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    _LIBCPP_INLINE_VISIBILITY size_type&            size()          {return __size_;}
+    _LIBCPP_INLINE_VISIBILITY
+    const size_type& size() const _NOEXCEPT {return __size_;}
+    _LIBCPP_INLINE_VISIBILITY allocator_type&       __alloc()       {return __alloc_;}
+    _LIBCPP_INLINE_VISIBILITY
+    const allocator_type& __alloc() const _NOEXCEPT {return __alloc_;}
+#else
     _LIBCPP_INLINE_VISIBILITY size_type&            size()          {return __size_.first();}
     _LIBCPP_INLINE_VISIBILITY
     const size_type& size() const _NOEXCEPT {return __size_.first();}
     _LIBCPP_INLINE_VISIBILITY allocator_type&       __alloc()       {return __size_.second();}
     _LIBCPP_INLINE_VISIBILITY
     const allocator_type& __alloc() const _NOEXCEPT {return __size_.second();}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     __deque_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
     _LIBCPP_INLINE_VISIBILITY
     explicit __deque_base(const allocator_type& __a);
 public:
     ~__deque_base();
__deque_base<_Tp, _Allocator>::end() const _NOEXCEPT
     __map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __block_size);
     return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline
 __deque_base<_Tp, _Allocator>::__deque_base()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
-    : __start_(0), __size_(0) {}
+    : __start_(0), __size_(0)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    , __alloc_()
+#endif
+{}
 
 template <class _Tp, class _Allocator>
 inline
 __deque_base<_Tp, _Allocator>::__deque_base(const allocator_type& __a)
-    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {}
+    : __map_(__pointer_allocator(__a)), __start_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(0), __alloc_(__a)
+#else
+      __size_(0, __a)
+#endif
+{}
 
 template <class _Tp, class _Allocator>
 __deque_base<_Tp, _Allocator>::~__deque_base()
 {
     clear();
     typename __map::iterator __i = __map_.begin();
     typename __map::iterator __e = __map_.end();
     for (; __i != __e; ++__i)
         __alloc_traits::deallocate(__alloc(), *__i, __block_size);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
 __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
     : __map_(_VSTD::move(__c.__map_)),
       __start_(_VSTD::move(__c.__start_)),
       __size_(_VSTD::move(__c.__size_))
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    , __alloc_(_VSTD::move(__c.__alloc_))
+#endif
 {
     __c.__start_ = 0;
     __c.size() = 0;
 }
 
 template <class _Tp, class _Allocator>
 __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c, const allocator_type& __a)
     : __map_(_VSTD::move(__c.__map_), __pointer_allocator(__a)),
       __start_(_VSTD::move(__c.__start_)),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __size_(_VSTD::move(__c.size())),
+      __alloc_(__a)
+#else
       __size_(_VSTD::move(__c.size()), __a)
+#endif
 {
     if (__a == __c.__alloc())
     {
         __c.__start_ = 0;
         __c.size() = 0;
     }
     else
     {

libcxx/include/forward_list

protected:
     >::type                                           __begin_node_allocator;
     typedef typename allocator_traits<__begin_node_allocator>::pointer
                                                       __begin_node_pointer;
 
     static_assert((!is_same<allocator_type, __node_allocator>::value),
                   "internal allocator type must differ from user-specified "
                   "type; otherwise overload resolution breaks");
 
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    __begin_node __before_begin_;
+    [[no_unique_address]] __node_allocator __alloc_;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __begin_node_pointer        __before_begin() _NOEXCEPT
+        {return pointer_traits<__begin_node_pointer>::pointer_to(__before_begin_);}
+    _LIBCPP_INLINE_VISIBILITY
+    __begin_node_pointer __before_begin() const _NOEXCEPT
+        {return pointer_traits<__begin_node_pointer>::pointer_to(const_cast<__begin_node&>(__before_begin_));}
+
+    _LIBCPP_INLINE_VISIBILITY
+          __node_allocator& __alloc() _NOEXCEPT {return __alloc_;}
+    _LIBCPP_INLINE_VISIBILITY
+    const __node_allocator& __alloc() const _NOEXCEPT {return __alloc_;}
+#else
     __compressed_pair<__begin_node, __node_allocator> __before_begin_;
 
     _LIBCPP_INLINE_VISIBILITY
     __begin_node_pointer        __before_begin() _NOEXCEPT
         {return pointer_traits<__begin_node_pointer>::pointer_to(__before_begin_.first());}
     _LIBCPP_INLINE_VISIBILITY
     __begin_node_pointer __before_begin() const _NOEXCEPT
         {return pointer_traits<__begin_node_pointer>::pointer_to(const_cast<__begin_node&>(__before_begin_.first()));}
 
     _LIBCPP_INLINE_VISIBILITY
           __node_allocator& __alloc() _NOEXCEPT
             {return __before_begin_.second();}
     _LIBCPP_INLINE_VISIBILITY
     const __node_allocator& __alloc() const _NOEXCEPT
         {return __before_begin_.second();}
+#endif
 
     typedef __forward_list_iterator<__node_pointer>             iterator;
     typedef __forward_list_const_iterator<__node_pointer>       const_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_base()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
-        : __before_begin_(__begin_node()) {}
+        : __before_begin_(__begin_node())
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        , __alloc_()
+#endif
+    {}
     _LIBCPP_INLINE_VISIBILITY
     explicit __forward_list_base(const allocator_type& __a)
-        : __before_begin_(__begin_node(), __node_allocator(__a)) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        : __before_begin_(__begin_node()), __alloc_(__a)
+#else
+        : __before_begin_(__begin_node(), __node_allocator(__a))
+#endif
+    {}
     _LIBCPP_INLINE_VISIBILITY
     explicit __forward_list_base(const __node_allocator& __a)
-        : __before_begin_(__begin_node(), __a) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        : __before_begin_(__begin_node()), __alloc_(__a)
+#else
+        : __before_begin_(__begin_node(), __a)
+#endif
+    {}
 #ifndef _LIBCPP_CXX03_LANG
 public:
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_base(__forward_list_base&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_base(__forward_list_base&& __x, const allocator_type& __a);
 #endif  // _LIBCPP_CXX03_LANG

 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
 inline
 __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
     : __before_begin_(_VSTD::move(__x.__before_begin_))
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    , __alloc_(_VSTD::move(__x.__alloc_))
+#endif
 {
     __x.__before_begin()->__next_ = nullptr;
 }
 
 template <class _Tp, class _Alloc>
 inline
 __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x,
                                                       const allocator_type& __a)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __before_begin_(__begin_node()), __alloc_(__a)
+#else
     : __before_begin_(__begin_node(), __node_allocator(__a))
+#endif
 {
     if (__alloc() == __x.__alloc())
     {
         __before_begin()->__next_ = __x.__before_begin()->__next_;
         __x.__before_begin()->__next_ = nullptr;
     }
 }
 

libcxx/include/functional

 namespace __function {
 
 // __alloc_func holds a functor and an allocator.
 
 template <class _Fp, class _Ap, class _FB> class __alloc_func;
 template <class _Fp, class _FB>
 class __default_alloc_func;
 
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+template <class _Fp, class _Ap, class _Rp, class... _ArgTypes>
+class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)>
+{
+    [[no_unique_address]] _Fp __target_;
+    [[no_unique_address]] _Ap __alloc_;
+
+  public:
+    typedef _Fp _Target;
+    typedef _Ap _Alloc;
+
+    _LIBCPP_INLINE_VISIBILITY
+    const _Target& __target() const { return __target_; }
+
+    // WIN32 APIs may define __allocator, so use __get_allocator instead.
+    _LIBCPP_INLINE_VISIBILITY
+    const _Alloc& __get_allocator() const { return __alloc_; }
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __alloc_func(_Target&& __f)
+        : __target_(_VSTD::move(__f)), __alloc_()
+    {
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __alloc_func(const _Target& __f, const _Alloc& __a)
+        : __target_(__f), __alloc_(__a)
+    {
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __alloc_func(const _Target& __f, _Alloc&& __a)
+        : __target_(__f), __alloc_(_VSTD::move(__a))
+    {
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __alloc_func(_Target&& __f, _Alloc&& __a)
+        : __target_(_VSTD::move(__f)), __alloc_(_VSTD::move(__a))
+    {
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    _Rp operator()(_ArgTypes&&... __arg)
+    {
+        typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+        return _Invoker::__call(__target_, _VSTD::forward<_ArgTypes>(__arg)...);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    __alloc_func* __clone() const
+    {
+        typedef allocator_traits<_Alloc> __alloc_traits;
+        typedef
+            typename __rebind_alloc_helper<__alloc_traits, __alloc_func>::type
+                _AA;
+        _AA __a(__alloc_);
+        typedef __allocator_destructor<_AA> _Dp;
+        unique_ptr<__alloc_func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
+        ::new ((void*)__hold.get()) __alloc_func(__target_, _Alloc(__a));
+        return __hold.release();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void destroy() _NOEXCEPT { this->~__alloc_func(); }
+};
+#else
 template <class _Fp, class _Ap, class _Rp, class... _ArgTypes>
 class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)>
 {
     __compressed_pair<_Fp, _Ap> __f_;
 
   public:
     typedef _LIBCPP_NODEBUG_TYPE _Fp _Target;
     typedef _LIBCPP_NODEBUG_TYPE _Ap _Alloc;
static void __destroy_and_delete(__alloc_func* __f) {
       typedef allocator_traits<_Alloc> __alloc_traits;
       typedef typename __rebind_alloc_helper<__alloc_traits, __alloc_func>::type
           _FunAlloc;
       _FunAlloc __a(__f->__get_allocator());
       __f->destroy();
       __a.deallocate(__f, 1);
     }
 };
+#endif
 
 template <class _Fp, class _Rp, class... _ArgTypes>
 class __default_alloc_func<_Fp, _Rp(_ArgTypes...)> {
   _Fp __f_;
 
 public:
   typedef _LIBCPP_NODEBUG_TYPE _Fp _Target;
 

libcxx/include/future

public:
     virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;
     virtual void destroy() = 0;
     virtual void destroy_deallocate() = 0;
     virtual _Rp operator()(_ArgTypes&& ...) = 0;
 };
 
 template<class _FD, class _Alloc, class _FB> class __packaged_task_func;
 
+#if _LIBCPP_USE_NO_UNIQUE_ADDRESS
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>
+    : public  __packaged_task_base<_Rp(_ArgTypes...)>
+{
+    [[no_unique_address]] _Fp __f_;
+    [[no_unique_address]] _Alloc __alloc_;
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __packaged_task_func(const _Fp& __f) : __f_(__f), __alloc_() {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f)), __alloc_() {}
+    _LIBCPP_INLINE_VISIBILITY
+    __packaged_task_func(const _Fp& __f, const _Alloc& __a)
+        : __f_(__f), __alloc_(__a) {}
+    _LIBCPP_INLINE_VISIBILITY
+    __packaged_task_func(_Fp&& __f, const _Alloc& __a)
+        : __f_(_VSTD::move(__f)), __alloc_(__a) {}
+    virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT;
+    virtual void destroy();
+    virtual void destroy_deallocate();
+    virtual _Rp operator()(_ArgTypes&& ... __args);
+};
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+void
+__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(
+                              __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT
+{
+    ::new (__p) __packaged_task_func(_VSTD::move(__f_), _VSTD::move(__alloc_));
+}
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+void
+__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate()
+{
+    typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap;
+    typedef allocator_traits<_Ap> _ATraits;
+    typedef pointer_traits<typename _ATraits::pointer> _PTraits;
+    _Ap __a(__alloc_);
+    this->~__packaged_task_func();
+    __a.deallocate(_PTraits::pointer_to(*this), 1);
+}
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+_Rp
+__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
+{
+    return __invoke(__f_, _VSTD::forward<_ArgTypes>(__arg)...);
+}
+#else
 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>
     : public  __packaged_task_base<_Rp(_ArgTypes...)>
 {
     __compressed_pair<_Fp, _Alloc> __f_;
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __packaged_task_func(const _Fp& __f) : __f_(__f) {}

 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(
                               __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT
 {
     ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
 }
 
 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 void
-__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy()
-{
-    __f_.~__compressed_pair<_Fp, _Alloc>();
-}
-
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-void
 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate()
 {
     typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap;
     typedef allocator_traits<_Ap> _ATraits;
     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
     _Ap __a(__f_.second());
-    __f_.~__compressed_pair<_Fp, _Alloc>();
+    this->~__packaged_task_func();
     __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 _Rp
 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
 {
     return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
 }
+#endif
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+void
+__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy()
+{
+    this->~__packaged_task_func();
+}
 
 template <class _Callable> class __packaged_task_function;
 
 template<class _Rp, class ..._ArgTypes>
 class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_function<_Rp(_ArgTypes...)>
 {
     typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;
     typename aligned_storage<3*sizeof(void*)>::type __buf_;

libcxx/include/list

__node_pointer __as_node() {
         return static_cast<__node_pointer>(__self());
     }
 };
 
 template <class _Tp, class _VoidPtr>
 struct __list_node
     : public __list_node_base<_Tp, _VoidPtr>
 {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    [[no_unique_address]]
+#endif
     _Tp __value_;
 
     typedef __list_node_base<_Tp, _VoidPtr> __base;
     typedef typename __base::__link_pointer __link_pointer;
 
     _LIBCPP_INLINE_VISIBILITY
     __link_pointer __as_link() {
         return static_cast<__link_pointer>(__base::__self());
protected:
 
     typedef typename __rebind_alloc_helper<__alloc_traits, __node_base>::type __node_base_allocator;
     typedef typename allocator_traits<__node_base_allocator>::pointer __node_base_pointer;
     static_assert((!is_same<allocator_type, __node_allocator>::value),
                   "internal allocator type must differ from user-specified "
                   "type; otherwise overload resolution breaks");
 
     __node_base __end_;
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    size_type __size_;
+    [[no_unique_address]] __node_allocator __alloc_;
+#else
     __compressed_pair<size_type, __node_allocator> __size_alloc_;
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     __link_pointer __end_as_link() const _NOEXCEPT {
         return __node_pointer_traits::__unsafe_link_pointer_cast(
                 const_cast<__node_base&>(__end_).__self());
     }
 
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    _LIBCPP_INLINE_VISIBILITY
+          size_type& __sz() _NOEXCEPT {return __size_;}
+    _LIBCPP_INLINE_VISIBILITY
+    const size_type& __sz() const _NOEXCEPT {return __size_;}
+    _LIBCPP_INLINE_VISIBILITY
+          __node_allocator& __node_alloc() _NOEXCEPT {return __alloc_;}
+    _LIBCPP_INLINE_VISIBILITY
+    const __node_allocator& __node_alloc() const _NOEXCEPT {return __alloc_;}
+#else
     _LIBCPP_INLINE_VISIBILITY
           size_type& __sz() _NOEXCEPT {return __size_alloc_.first();}
     _LIBCPP_INLINE_VISIBILITY
     const size_type& __sz() const _NOEXCEPT
         {return __size_alloc_.first();}
     _LIBCPP_INLINE_VISIBILITY
           __node_allocator& __node_alloc() _NOEXCEPT
           {return __size_alloc_.second();}
     _LIBCPP_INLINE_VISIBILITY
     const __node_allocator& __node_alloc() const _NOEXCEPT
         {return __size_alloc_.second();}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     size_type __node_alloc_max_size() const _NOEXCEPT {
         return __node_alloc_traits::max_size(__node_alloc());
     }
     _LIBCPP_INLINE_VISIBILITY
     static void __unlink_nodes(__link_pointer __f, __link_pointer __l) _NOEXCEPT;
 
__list_imp<_Tp, _Alloc>::__unlink_nodes(__link_pointer __f, __link_pointer __l)
     __f->__prev_->__next_ = __l->__next_;
     __l->__next_->__prev_ = __f->__prev_;
 }
 
 template <class _Tp, class _Alloc>
 inline
 __list_imp<_Tp, _Alloc>::__list_imp()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __size_(0), __alloc_()
+#else
     : __size_alloc_(0)
+#endif
 {
 }
 
 template <class _Tp, class _Alloc>
 inline
 __list_imp<_Tp, _Alloc>::__list_imp(const allocator_type& __a)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __size_(0), __alloc_(__node_allocator(__a))
+#else
     : __size_alloc_(0, __node_allocator(__a))
+#endif
 {
 }
 
 template <class _Tp, class _Alloc>
 inline __list_imp<_Tp, _Alloc>::__list_imp(const __node_allocator& __a)
-    : __size_alloc_(0, __a) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __size_(0), __alloc_(__a)
+#else
+    : __size_alloc_(0, __a)
+#endif
+{
+}
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Alloc>
 inline __list_imp<_Tp, _Alloc>::__list_imp(__node_allocator&& __a) _NOEXCEPT
-    : __size_alloc_(0, std::move(__a)) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __size_(0), __alloc_(std::move(__a))
+#else
+    : __size_alloc_(0, std::move(__a))
+#endif
 #endif
+{
+}
 
 template <class _Tp, class _Alloc>
 __list_imp<_Tp, _Alloc>::~__list_imp() {
   clear();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__erase_c(this);
 #endif
 }

libcxx/include/memory

 template <>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr<void>
 {
 public:
     typedef void element_type;
 };
 #endif
 
+#ifndef _LIBCPP_USE_NO_UNIQUE_ADDRESS
 template <class _Tp, int _Idx,
           bool _CanBeEmptyBase =
               is_empty<_Tp>::value && !__libcpp_is_final<_Tp>::value>
 struct __compressed_pair_elem {
   typedef _Tp _ParamT;
   typedef _Tp& reference;
   typedef const _Tp& const_reference;
 
#endif
   const_reference __get() const _NOEXCEPT { return *this; }
 };
 
 // Tag used to construct the second element of the compressed pair.
 struct __second_tag {};
 
 template <class _T1, class _T2>
 class __compressed_pair : private __compressed_pair_elem<_T1, 0>,
-                          private __compressed_pair_elem<_T2, 1> {
+                          private __compressed_pair_elem<_T2, 1>
+{
   typedef _LIBCPP_NODEBUG_TYPE __compressed_pair_elem<_T1, 0> _Base1;
   typedef _LIBCPP_NODEBUG_TYPE __compressed_pair_elem<_T2, 1> _Base2;
 
   // NOTE: This static assert should never fire because __compressed_pair
   // is *almost never* used in a scenario where it's possible for T1 == T2.
   // (The exception is std::function where it is possible that the function
   //  object and the allocator have the same type).
   static_assert((!is_same<_T1, _T2>::value),

 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
 void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y)
     _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                __is_nothrow_swappable<_T2>::value) {
   __x.swap(__y);
 }
+#endif
 
 // default_delete
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS default_delete {
     static_assert(!is_function<_Tp>::value,
                   "default_delete cannot be instantiated for function types");
 #ifndef _LIBCPP_CXX03_LANG
public:
   typedef _Tp element_type;
   typedef _Dp deleter_type;
   typedef _LIBCPP_NODEBUG_TYPE typename __pointer_type<_Tp, deleter_type>::type pointer;
 
   static_assert(!is_rvalue_reference<deleter_type>::value,
                 "the specified deleter type cannot be an rvalue reference");
 
 private:
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+  pointer __ptr_;
+  [[no_unique_address]] deleter_type __del_;
+#else
   __compressed_pair<pointer, deleter_type> __ptr_;
+#endif
 
   struct __nat { int __for_bool_; };
 
   typedef _LIBCPP_NODEBUG_TYPE __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
 
   template <bool _Dummy>
   using _LValRefType _LIBCPP_NODEBUG_TYPE =
       typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
#endif
   using _EnableIfDeleterAssignable = typename enable_if<
       is_assignable<_Dp&, _UDel&&>::value
     >::type;
 
 public:
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer()) {}
+  _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer())
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      , __del_()
+#endif
+  {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer()) {}
+  _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer())
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      , __del_()
+#endif
+  {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
-  explicit unique_ptr(pointer __p) _NOEXCEPT : __ptr_(__p) {}
+  explicit unique_ptr(pointer __p) _NOEXCEPT : __ptr_(__p)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      , __del_()
+#endif
+  {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(pointer __p, _LValRefType<_Dummy> __d) _NOEXCEPT
-      : __ptr_(__p, __d) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      : __ptr_(__p), __del_(__d)
+#else
+      : __ptr_(__p, __d)
+#endif
+  {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      : __ptr_(__p), __del_(_VSTD::move(__d)) {
+#else
       : __ptr_(__p, _VSTD::move(__d)) {
+#endif
     static_assert(!is_reference<deleter_type>::value,
                   "rvalue deleter bound to reference");
   }
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete;
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      : __ptr_(__u.release()),
+        __del_(_VSTD::forward<deleter_type>(__u.get_deleter()))
+#else
+      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter()))
+#endif
+  {
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterConvertible<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      : __ptr_(__u.release()), __del_(_VSTD::forward<_Ep>(__u.get_deleter()))
+#else
+      : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter()))
+#endif
+  {
+  }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(auto_ptr<_Up>&& __p,
              typename enable_if<is_convertible<_Up*, _Tp*>::value &&
                                     is_same<_Dp, default_delete<_Tp> >::value,
                                 __nat>::type = __nat()) _NOEXCEPT
-      : __ptr_(__p.release()) {}
+      : __ptr_(__p.release())
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      , __del_()
+#endif
+  {}
 #endif
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    __del_ = _VSTD::forward<deleter_type>(__u.__del_);
+#else
     __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
+#endif
     return *this;
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterAssignable<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    __del_ = _VSTD::forward<_Ep>(__u.get_deleter());
+#else
     __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
+#endif
     return *this;
   }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
       typename enable_if<is_convertible<_Up*, _Tp*>::value &&
                              is_same<_Dp, default_delete<_Tp> >::value,
#endif
   unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   typename add_lvalue_reference<_Tp>::type
   operator*() const {
-    return *__ptr_.first();
+    return *__ptr_
+#ifndef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        .first()
+#endif
+    ;
   }
   _LIBCPP_INLINE_VISIBILITY
   pointer operator->() const _NOEXCEPT {
-    return __ptr_.first();
+    return __ptr_
+#ifndef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        .first()
+#endif
+    ;
   }
   _LIBCPP_INLINE_VISIBILITY
   pointer get() const _NOEXCEPT {
-    return __ptr_.first();
+    return __ptr_
+#ifndef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        .first()
+#endif
+    ;
   }
   _LIBCPP_INLINE_VISIBILITY
   deleter_type& get_deleter() _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    return __del_;
+#else
     return __ptr_.second();
+#endif
   }
   _LIBCPP_INLINE_VISIBILITY
   const deleter_type& get_deleter() const _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    return __del_;
+#else
     return __ptr_.second();
+#endif
   }
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {
-    return __ptr_.first() != nullptr;
+    return get() != nullptr;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   pointer release() _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    pointer __t = __ptr_;
+    __ptr_ = pointer();
+#else
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
+#endif
     return __t;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void reset(pointer __p = pointer()) _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    pointer __tmp = __ptr_;
+    __ptr_ = __p;
+    if (__tmp)
+      __del_(__tmp);
+#else
     pointer __tmp = __ptr_.first();
     __ptr_.first() = __p;
     if (__tmp)
       __ptr_.second()(__tmp);
+#endif
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void swap(unique_ptr& __u) _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    using _VSTD::swap;
+    swap(__ptr_, __u.__ptr_);
+    swap(__del_, __u.__del_);
+#else
     __ptr_.swap(__u.__ptr_);
+#endif
   }
 };
 
 
 template <class _Tp, class _Dp>
 class _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> {
 public:
   typedef _Tp element_type;
   typedef _Dp deleter_type;
   typedef typename __pointer_type<_Tp, deleter_type>::type pointer;
 
 private:
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+  pointer __ptr_;
+  [[no_unique_address]] deleter_type __del_;
+#else
   __compressed_pair<pointer, deleter_type> __ptr_;
+#endif
 
   template <class _From>
   struct _CheckArrayPointerConversion : is_same<_From, pointer> {};
 
   template <class _FromElem>
   struct _CheckArrayPointerConversion<_FromElem*>
       : integral_constant<bool,
           is_same<_FromElem*, pointer>::value ||
#endif
   using _EnableIfDeleterAssignable _LIBCPP_NODEBUG_TYPE  = typename enable_if<
       is_assignable<_Dp&, _UDel&&>::value
     >::type;
 
 public:
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer()) {}
+  _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer())
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      , __del_()
+#endif
+  {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer()) {}
+  _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer())
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      , __del_()
+#endif
+  {}
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy>,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   explicit unique_ptr(_Pp __p) _NOEXCEPT
-      : __ptr_(__p) {}
+      : __ptr_(__p)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      , __del_()
+#endif
+  {}
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) _NOEXCEPT
-      : __ptr_(__p, __d) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      : __ptr_(__p), __del_(__d)
+#else
+      : __ptr_(__p, __d)
+#endif
+  {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) _NOEXCEPT
-      : __ptr_(nullptr, __d) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      : __ptr_(nullptr), __del_(__d)
+#else
+      : __ptr_(nullptr, __d)
+#endif
+  {}
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
-      : __ptr_(__p, _VSTD::move(__d)) {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      : __ptr_(__p), __del_(_VSTD::move(__d))
+#else
+      : __ptr_(__p, _VSTD::move(__d))
+#endif
+  {
     static_assert(!is_reference<deleter_type>::value,
                   "rvalue deleter bound to reference");
   }
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
-      : __ptr_(nullptr, _VSTD::move(__d)) {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      : __ptr_(nullptr), __del_(_VSTD::move(__d))
+#else
+      : __ptr_(nullptr, _VSTD::move(__d))
+#endif
+  {
     static_assert(!is_reference<deleter_type>::value,
                   "rvalue deleter bound to reference");
   }
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete;
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
-  }
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      : __ptr_(__u.release()),
+        __del_(_VSTD::forward<deleter_type>(__u.__del_))
+#else
+      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter()))
+#endif
+  {}
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    __del_ = _VSTD::forward<deleter_type>(__u.__del_);
+#else
     __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
+#endif
     return *this;
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterConvertible<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      : __ptr_(__u.release()), __del_(_VSTD::forward<_Ep>(__u.get_deleter())) {
+#else
       : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {
+#endif
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterAssignable<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr&
   operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    __del_ = _VSTD::forward<_Ep>(__u.get_deleter());
+#else
     __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
+#endif
     return *this;
   }
 
 #ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
 #endif
 
 public:
   _LIBCPP_INLINE_VISIBILITY
   ~unique_ptr() { reset(); }
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   typename add_lvalue_reference<_Tp>::type
   operator[](size_t __i) const {
-    return __ptr_.first()[__i];
+    return __ptr_
+#ifndef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        .first()
+#endif
+    [__i];
   }
   _LIBCPP_INLINE_VISIBILITY
   pointer get() const _NOEXCEPT {
-    return __ptr_.first();
+    return __ptr_
+#ifndef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        .first()
+#endif
+    ;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   deleter_type& get_deleter() _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    return __del_;
+#else
     return __ptr_.second();
+#endif
   }
 
   _LIBCPP_INLINE_VISIBILITY
   const deleter_type& get_deleter() const _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    return __del_;
+#else
     return __ptr_.second();
+#endif
   }
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {
-    return __ptr_.first() != nullptr;
+    return get() != nullptr;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   pointer release() _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    pointer __t = __ptr_;
+    __ptr_ = pointer();
+#else
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
+#endif
     return __t;
   }
 
   template <class _Pp>
   _LIBCPP_INLINE_VISIBILITY
   typename enable_if<
       _CheckArrayPointerConversion<_Pp>::value
   >::type
   reset(_Pp __p) _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    pointer __tmp = __ptr_;
+    __ptr_ = __p;
+    if (__tmp)
+      __del_(__tmp);
+#else
     pointer __tmp = __ptr_.first();
     __ptr_.first() = __p;
     if (__tmp)
       __ptr_.second()(__tmp);
+#endif
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void reset(nullptr_t = nullptr) _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    pointer __tmp = __ptr_;
+    __ptr_ = nullptr;
+    if (__tmp)
+      __del_(__tmp);
+#else
     pointer __tmp = __ptr_.first();
     __ptr_.first() = nullptr;
     if (__tmp)
       __ptr_.second()(__tmp);
+#endif
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void swap(unique_ptr& __u) _NOEXCEPT {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    using _VSTD::swap;
+    swap(__ptr_, __u.__ptr_);
+    swap(__del_, __u.__del_);
+#else
     __ptr_.swap(__u.__ptr_);
+#endif
   }
 
 };
 
 template <class _Tp, class _Dp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if<
     __is_swappable<_Dp>::value,

 private:
     virtual void __on_zero_shared_weak() _NOEXCEPT = 0;
 };
 
 template <class _Tp, class _Dp, class _Alloc>
 class __shared_ptr_pointer
     : public __shared_weak_count
 {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    _Tp __p_;
+    _Dp __d_;
+    _Alloc __a_;
+#else
     __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
+#endif
 public:
     _LIBCPP_INLINE_VISIBILITY
     __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
-        :  __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        : __p_(__p), __d_(_VSTD::move(__d)), __a_(_VSTD::move(__a))
+#else
+        : __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a))
+#endif
+   {}
 
 #ifndef _LIBCPP_NO_RTTI
     virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
 #endif
 
 private:
     virtual void __on_zero_shared() _NOEXCEPT;
     virtual void __on_zero_shared_weak() _NOEXCEPT;
 };
 
 #ifndef _LIBCPP_NO_RTTI
 
 template <class _Tp, class _Dp, class _Alloc>
 const void*
 __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT
 {
-    return __t == typeid(_Dp) ? _VSTD::addressof(__data_.first().second()) : nullptr;
+  return __t == typeid(_Dp)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+             ? _VSTD::addressof(__d_)
+#else
+             ? _VSTD::addressof(__data_.first().second())
+#endif
+             : nullptr;
 }
 
 #endif  // _LIBCPP_NO_RTTI
 
 template <class _Tp, class _Dp, class _Alloc>
 void
 __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT
 {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    __d_(__p_);
+    __d_.~_Dp();
+#else
     __data_.first().second()(__data_.first().first());
     __data_.first().second().~_Dp();
+#endif
 }
 
 template <class _Tp, class _Dp, class _Alloc>
 void
 __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT
 {
     typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al;
     typedef allocator_traits<_Al> _ATraits;
     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
 
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    _Al __a(__a_);
+    __a_.~_Alloc();
+#else
     _Al __a(__data_.second());
     __data_.second().~_Alloc();
+#endif
     __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template <class _Tp, class _Alloc>
 class __shared_ptr_emplace
     : public __shared_weak_count
 {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    _Tp __v_;
+    [[no_unique_address]] _Alloc __a_;
+#else
     __compressed_pair<_Alloc, _Tp> __data_;
+#endif
 public:
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     _LIBCPP_INLINE_VISIBILITY
     __shared_ptr_emplace(_Alloc __a)
-        :  __data_(_VSTD::move(__a)) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+        : __v_(), __a_(_VSTD::move(__a))
+#else
+        : __data_(_VSTD::move(__a))
+#endif
+    {}
 
     template <class ..._Args>
         _LIBCPP_INLINE_VISIBILITY
         __shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+            :  __v_(_VSTD::forward<_Args>(__args)...), __a_(__a)
+#else
             :  __data_(piecewise_construct, _VSTD::forward_as_tuple(__a),
-                   _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)) {}
+                   _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...))
+#endif
+    {}
 
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
     _LIBCPP_INLINE_VISIBILITY
     __shared_ptr_emplace(_Alloc __a)
         :  __data_(__a) {}
 
     template <class _A0>

 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 private:
     virtual void __on_zero_shared() _NOEXCEPT;
     virtual void __on_zero_shared_weak() _NOEXCEPT;
 public:
     _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    _Tp* get() _NOEXCEPT {return _VSTD::addressof(__v_);}
+#else
     _Tp* get() _NOEXCEPT {return _VSTD::addressof(__data_.second());}
+#endif
 };
 
 template <class _Tp, class _Alloc>
 void
 __shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared() _NOEXCEPT
 {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    __v_.~_Tp();
+#else
     __data_.second().~_Tp();
+#endif
 }
 
 template <class _Tp, class _Alloc>
 void
 __shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT
 {
     typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type _Al;
     typedef allocator_traits<_Al> _ATraits;
     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    _Al __a(__a_);
+    __a_.~_Alloc();
+#else
     _Al __a(__data_.first());
     __data_.first().~_Alloc();
+#endif
     __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 struct __shared_ptr_dummy_rebind_allocator_type;
 template <>
 class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type>
 {
 public:

libcxx/include/string

struct __rep
         union
         {
             __long  __l;
             __short __s;
             __raw   __r;
         };
     };
 
-    __compressed_pair<__rep, allocator_type> __r_;
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    __rep __r_;
+    [[no_unique_address]] allocator_type __alloc_;
+    #define __ALLOC_INIT __alloc_
+#else
+    __compressed_pair<__rep, allocator_type> __r_alloc_;
+    #define __r_ __r_alloc_.first()
+    #define __alloc_ __r_alloc_.second()
+    #define __ALLOC_INIT(init) __r_alloc_(__second_tag(), init)
+#endif
 
 public:
     static const size_type npos = -1;
 
     _LIBCPP_INLINE_VISIBILITY basic_string()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
 
     _LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a)

 #endif
 
     _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
 
     _LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     bool __is_long() const _NOEXCEPT
-        {return bool(__r_.first().__s.__size_ & __short_mask);}
+        {return bool(__r_.__s.__size_ & __short_mask);}
 
 #if _LIBCPP_DEBUG_LEVEL >= 2
 
     bool __dereferenceable(const const_iterator* __i) const;
     bool __decrementable(const const_iterator* __i) const;
     bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
     bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
 
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     allocator_type& __alloc() _NOEXCEPT
-        {return __r_.second();}
+        {return __alloc_;}
     _LIBCPP_INLINE_VISIBILITY
     const allocator_type& __alloc() const _NOEXCEPT
-        {return __r_.second();}
+        {return __alloc_;}
 
 #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_short_size(size_type __s) _NOEXCEPT
 #   ifdef _LIBCPP_BIG_ENDIAN
-        {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
+        {__r_.__s.__size_ = (unsigned char)(__s << 1);}
 #   else
-        {__r_.first().__s.__size_ = (unsigned char)(__s);}
+        {__r_.__s.__size_ = (unsigned char)(__s);}
 #   endif
 
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_short_size() const _NOEXCEPT
 #   ifdef _LIBCPP_BIG_ENDIAN
-        {return __r_.first().__s.__size_ >> 1;}
+        {return __r_.__s.__size_ >> 1;}
 #   else
-        {return __r_.first().__s.__size_;}
+        {return __r_.__s.__size_;}
 #   endif
 
 #else  // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_short_size(size_type __s) _NOEXCEPT
 #   ifdef _LIBCPP_BIG_ENDIAN
-        {__r_.first().__s.__size_ = (unsigned char)(__s);}
+        {__r_.__s.__size_ = (unsigned char)(__s);}
 #   else
-        {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
+        {__r_.__s.__size_ = (unsigned char)(__s << 1);}
 #   endif
 
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_short_size() const _NOEXCEPT
 #   ifdef _LIBCPP_BIG_ENDIAN
-        {return __r_.first().__s.__size_;}
+        {return __r_.__s.__size_;}
 #   else
-        {return __r_.first().__s.__size_ >> 1;}
+        {return __r_.__s.__size_ >> 1;}
 #   endif
 
 #endif  // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_long_size(size_type __s) _NOEXCEPT
-        {__r_.first().__l.__size_ = __s;}
+        {__r_.__l.__size_ = __s;}
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_long_size() const _NOEXCEPT
-        {return __r_.first().__l.__size_;}
+        {return __r_.__l.__size_;}
     _LIBCPP_INLINE_VISIBILITY
     void __set_size(size_type __s) _NOEXCEPT
         {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_long_cap(size_type __s) _NOEXCEPT
-        {__r_.first().__l.__cap_  = __long_mask | __s;}
+        {__r_.__l.__cap_  = __long_mask | __s;}
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_long_cap() const _NOEXCEPT
-        {return __r_.first().__l.__cap_ & size_type(~__long_mask);}
+        {return __r_.__l.__cap_ & size_type(~__long_mask);}
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_long_pointer(pointer __p) _NOEXCEPT
-        {__r_.first().__l.__data_ = __p;}
+        {__r_.__l.__data_ = __p;}
     _LIBCPP_INLINE_VISIBILITY
     pointer __get_long_pointer() _NOEXCEPT
-        {return __r_.first().__l.__data_;}
+        {return __r_.__l.__data_;}
     _LIBCPP_INLINE_VISIBILITY
     const_pointer __get_long_pointer() const _NOEXCEPT
-        {return __r_.first().__l.__data_;}
+        {return __r_.__l.__data_;}
     _LIBCPP_INLINE_VISIBILITY
     pointer __get_short_pointer() _NOEXCEPT
-        {return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);}
+        {return pointer_traits<pointer>::pointer_to(__r_.__s.__data_[0]);}
     _LIBCPP_INLINE_VISIBILITY
     const_pointer __get_short_pointer() const _NOEXCEPT
-        {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
+        {return pointer_traits<const_pointer>::pointer_to(__r_.__s.__data_[0]);}
     _LIBCPP_INLINE_VISIBILITY
     pointer __get_pointer() _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
     _LIBCPP_INLINE_VISIBILITY
     const_pointer __get_pointer() const _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
 
     _LIBCPP_INLINE_VISIBILITY
     void __zero() _NOEXCEPT
         {
-            size_type (&__a)[__n_words] = __r_.first().__r.__words;
+            size_type (&__a)[__n_words] = __r_.__r.__words;
             for (unsigned __i = 0; __i < __n_words; ++__i)
                 __a[__i] = 0;
         }
 
     template <size_type __a> static
         _LIBCPP_INLINE_VISIBILITY
         size_type __align_it(size_type __s) _NOEXCEPT
             {return (__s + (__a-1)) & ~(__a-1);}

 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
 #else
         _NOEXCEPT
 #endif
-: __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     __zero();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
     traits_type::assign(__p[__sz], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template <class>
 #endif
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
     __init(__s, traits_type::length(__s));
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
     __init(__s, __n);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
     __init(__s, __n);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
-    : __r_(__second_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
+    : __ALLOC_INIT(__alloc_traits::select_on_container_copy_construction(__str.__alloc()))
 {
     if (!__str.__is_long())
-        __r_.first().__r = __str.__r_.first().__r;
+        __r_.__r = __str.__r_.__r;
     else
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
     const basic_string& __str, const allocator_type& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     if (!__str.__is_long())
-        __r_.first().__r = __str.__r_.first().__r;
+        __r_.__r = __str.__r_.__r;
     else
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
 #else
         _NOEXCEPT
 #endif
-    : __r_(_VSTD::move(__str.__r_))
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    : __r_(_VSTD::move(__str.__r_)), __alloc_(_VSTD::move(__str.__alloc_))
+#else
+    : __r_alloc_(_VSTD::move(__str.__r_alloc_))
+#endif
 {
     __str.__zero();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
     if (__is_long())
         __get_db()->swap(this, &__str);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
     else
     {
-        __r_.first().__r = __str.__r_.first().__r;
+        __r_.__r = __str.__r_.__r;
         __str.__zero();
     }
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
     if (__is_long())
         __get_db()->swap(this, &__str);
 #endif
 }

 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template <class>
 #endif
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     __init(__n, __c);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,
                                                         size_type __pos, size_type __n,
                                                         const _Allocator& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         this->__throw_out_of_range();
     __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
                                                         const _Allocator& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         this->__throw_out_of_range();
     __init(__str.data() + __pos, __str_sz - __pos);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, class>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
              const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     __self_view __sv0 = __t;
     __self_view __sv = __sv0.substr(__pos, __n);
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, class>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)
 {
     __self_view __sv = __t;
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, class>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     __self_view __sv = __t;
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 

 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator, class>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
                                                         const allocator_type& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     __init(__first, __last);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 #ifndef _LIBCPP_CXX03_LANG

 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
     initializer_list<_CharT> __il, const _Allocator& __a)
-    : __r_(__second_tag(), __a)
+    : __ALLOC_INIT(__a)
 {
     __init(__il.begin(), __il.end());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 #endif  // _LIBCPP_CXX03_LANG

 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
 #if _LIBCPP_STD_VER > 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
 #endif
 {
     __clear_and_shrink();
-    __r_.first() = __str.__r_.first();
+    __r_ = __str.__r_;
     __move_assign_alloc(__str);
     __str.__zero();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
#if _LIBCPP_DEBUG_LEVEL >= 2
     if (!__str.__is_long())
         __get_db()->__invalidate_all(&__str);
     __get_db()->swap(this, &__str);
 #endif
     _LIBCPP_ASSERT(
         __alloc_traits::propagate_on_container_swap::value ||
         __alloc_traits::is_always_equal::value ||
         __alloc() == __str.__alloc(), "swapping non-equal allocators");
-    _VSTD::swap(__r_.first(), __str.__r_.first());
+    _VSTD::swap(__r_, __str.__r_);
     __swap_allocator(__alloc(), __str.__alloc());
 }
 
 // find
 
 template <class _Traits>
 struct _LIBCPP_HIDDEN __traits_eq
 {
#endif
     basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
     {
         return basic_string<char32_t> (__str, __len);
     }
   }
 }
 #endif
 
+#undef __r_
+#undef __alloc_
+#undef __ALLOC_INIT
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_STRING

libcxx/include/vector

protected:
     typedef typename __alloc_traits::difference_type difference_type;
     typedef typename __alloc_traits::pointer         pointer;
     typedef typename __alloc_traits::const_pointer   const_pointer;
     typedef pointer                                  iterator;
     typedef const_pointer                            const_iterator;
 
     pointer                                         __begin_;
     pointer                                         __end_;
-    __compressed_pair<pointer, allocator_type> __end_cap_;
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    pointer                                         __end_cap_;
+    [[no_unique_address]] allocator_type            __alloc_;
+
+    _LIBCPP_INLINE_VISIBILITY
+    allocator_type& __alloc() _NOEXCEPT {return __alloc_;}
+    _LIBCPP_INLINE_VISIBILITY
+    const allocator_type& __alloc() const _NOEXCEPT {return __alloc_;}
+    _LIBCPP_INLINE_VISIBILITY
+    pointer& __end_cap() _NOEXCEPT {return __end_cap_;}
+    _LIBCPP_INLINE_VISIBILITY
+    const pointer& __end_cap() const _NOEXCEPT {return __end_cap_;}
+#else
+    __compressed_pair<pointer, allocator_type> __end_cap_alloc_;
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type& __alloc() _NOEXCEPT
-        {return __end_cap_.second();}
+        {return __end_cap_alloc_.second();}
     _LIBCPP_INLINE_VISIBILITY
     const allocator_type& __alloc() const _NOEXCEPT
-        {return __end_cap_.second();}
+        {return __end_cap_alloc_.second();}
     _LIBCPP_INLINE_VISIBILITY
     pointer& __end_cap() _NOEXCEPT
-        {return __end_cap_.first();}
+        {return __end_cap_alloc_.first();}
     _LIBCPP_INLINE_VISIBILITY
     const pointer& __end_cap() const _NOEXCEPT
-        {return __end_cap_.first();}
+        {return __end_cap_alloc_.first();}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     __vector_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
     _LIBCPP_INLINE_VISIBILITY __vector_base(const allocator_type& __a);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY __vector_base(allocator_type&& __a) _NOEXCEPT;
 #endif

 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 __vector_base<_Tp, _Allocator>::__vector_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __begin_(nullptr),
       __end_(nullptr),
-      __end_cap_(nullptr)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __end_cap_(nullptr),
+      __alloc_()
+#else
+      __end_cap_alloc_(nullptr)
+#endif
 {
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 __vector_base<_Tp, _Allocator>::__vector_base(const allocator_type& __a)
     : __begin_(nullptr),
       __end_(nullptr),
-      __end_cap_(nullptr, __a)
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __end_cap_(nullptr),
+      __alloc_(__a)
+#else
+      __end_cap_alloc_(nullptr, __a)
+#endif
 {
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 __vector_base<_Tp, _Allocator>::__vector_base(allocator_type&& __a) _NOEXCEPT
     : __begin_(nullptr),
       __end_(nullptr),
-      __end_cap_(nullptr, std::move(__a)) {}
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __end_cap_(nullptr),
+      __alloc_(std::move(__a))
+#else
+      __end_cap_alloc_(nullptr, std::move(__a))
+#endif
+{
+}
 #endif
 
 template <class _Tp, class _Allocator>
 __vector_base<_Tp, _Allocator>::~__vector_base()
 {
     if (__begin_ != nullptr)
     {
         clear();

 private:
     typedef typename __rebind_alloc_helper<__alloc_traits, __storage_type>::type __storage_allocator;
     typedef allocator_traits<__storage_allocator>    __storage_traits;
     typedef typename __storage_traits::pointer       __storage_pointer;
     typedef typename __storage_traits::const_pointer __const_storage_pointer;
 
     __storage_pointer                                      __begin_;
     size_type                                              __size_;
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    size_type                                              __cap_;
+    [[no_unique_address]] __storage_allocator              __alloc_;
+#else
     __compressed_pair<size_type, __storage_allocator> __cap_alloc_;
+#endif
 public:
     typedef __bit_reference<vector>                  reference;
     typedef __bit_const_reference<vector>            const_reference;
 private:
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+    _LIBCPP_INLINE_VISIBILITY
+    size_type& __cap() _NOEXCEPT {return __cap_;}
+    _LIBCPP_INLINE_VISIBILITY
+    const size_type& __cap() const _NOEXCEPT {return __cap_;}
+    _LIBCPP_INLINE_VISIBILITY
+    __storage_allocator& __alloc() _NOEXCEPT {return __alloc_;}
+    _LIBCPP_INLINE_VISIBILITY
+    const __storage_allocator& __alloc() const _NOEXCEPT {return __alloc_;}
+#else
     _LIBCPP_INLINE_VISIBILITY
     size_type& __cap() _NOEXCEPT
         {return __cap_alloc_.first();}
     _LIBCPP_INLINE_VISIBILITY
     const size_type& __cap() const _NOEXCEPT
         {return __cap_alloc_.first();}
     _LIBCPP_INLINE_VISIBILITY
     __storage_allocator& __alloc() _NOEXCEPT
         {return __cap_alloc_.second();}
     _LIBCPP_INLINE_VISIBILITY
     const __storage_allocator& __alloc() const _NOEXCEPT
         {return __cap_alloc_.second();}
+#endif
 
     static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
 
     _LIBCPP_INLINE_VISIBILITY
     static size_type __internal_cap_to_external(size_type __n) _NOEXCEPT
         {return __n * __bits_per_word;}
     _LIBCPP_INLINE_VISIBILITY
     static size_type __external_cap_to_internal(size_type __n) _NOEXCEPT

 }
 
 template <class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 vector<bool, _Allocator>::vector()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_()
+#else
       __cap_alloc_(0)
+#endif
 {
 }
 
 template <class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 vector<bool, _Allocator>::vector(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
 #else
         _NOEXCEPT
 #endif
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_(__a)
+#else
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
+#endif
 {
 }
 
 template <class _Allocator>
 vector<bool, _Allocator>::vector(size_type __n)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_()
+#else
       __cap_alloc_(0)
+#endif
 {
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, false);
     }
 }
 
 #if _LIBCPP_STD_VER > 11
 template <class _Allocator>
 vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_(__a)
+#else
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
+#endif
 {
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, false);
     }
 }
 #endif
 
 template <class _Allocator>
 vector<bool, _Allocator>::vector(size_type __n, const value_type& __x)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_()
+#else
       __cap_alloc_(0)
+#endif
 {
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, __x);
     }
 }
 
 template <class _Allocator>
 vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const allocator_type& __a)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_(__a)
+#else
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
+#endif
 {
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, __x);
     }
 }
 
 template <class _Allocator>
 template <class _InputIterator>
 vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
        typename enable_if<__is_input_iterator  <_InputIterator>::value &&
                          !__is_forward_iterator<_InputIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_()
+#else
       __cap_alloc_(0)
+#endif
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         for (; __first != __last; ++__first)
             push_back(*__first);
 #ifndef _LIBCPP_NO_EXCEPTIONS

 
 template <class _Allocator>
 template <class _InputIterator>
 vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
        typename enable_if<__is_input_iterator  <_InputIterator>::value &&
                          !__is_forward_iterator<_InputIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_(__a)
+#else
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
+#endif
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         for (; __first != __last; ++__first)
             push_back(*__first);
 #ifndef _LIBCPP_NO_EXCEPTIONS

 }
 
 template <class _Allocator>
 template <class _ForwardIterator>
 vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last,
                                 typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_()
+#else
       __cap_alloc_(0)
+#endif
 {
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__first, __last);
     }
 }
 
 template <class _Allocator>
 template <class _ForwardIterator>
 vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
                                 typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_(__a)
+#else
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
+#endif
 {
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__first, __last);
     }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Allocator>
 vector<bool, _Allocator>::vector(initializer_list<value_type> __il)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_()
+#else
       __cap_alloc_(0)
+#endif
 {
     size_type __n = static_cast<size_type>(__il.size());
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__il.begin(), __il.end());
     }
 }
 
 template <class _Allocator>
 vector<bool, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_(__a)
+#else
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
+#endif
 {
     size_type __n = static_cast<size_type>(__il.size());
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__il.begin(), __il.end());
     }
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _Allocator>
 vector<bool, _Allocator>::~vector()
 {
     if (__begin_ != nullptr)
         __storage_traits::deallocate(__alloc(), __begin_, __cap());
     __invalidate_all_iterators();
 }
 
 template <class _Allocator>
 vector<bool, _Allocator>::vector(const vector& __v)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_(__storage_traits::select_on_container_copy_construction(__v.__alloc_))
+#else
       __cap_alloc_(0, __storage_traits::select_on_container_copy_construction(__v.__alloc()))
+#endif
 {
     if (__v.size() > 0)
     {
         __vallocate(__v.size());
         __construct_at_end(__v.begin(), __v.end());
     }
 }
 
 template <class _Allocator>
 vector<bool, _Allocator>::vector(const vector& __v, const allocator_type& __a)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_(__a)
+#else
       __cap_alloc_(0, __a)
+#endif
 {
     if (__v.size() > 0)
     {
         __vallocate(__v.size());
         __construct_at_end(__v.begin(), __v.end());
     }
 }
 

 inline _LIBCPP_INLINE_VISIBILITY vector<bool, _Allocator>::vector(vector&& __v)
 #if _LIBCPP_STD_VER > 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
 #endif
     : __begin_(__v.__begin_),
       __size_(__v.__size_),
-      __cap_alloc_(std::move(__v.__cap_alloc_)) {
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(__v.__cap_), __alloc_(_VSTD::move(__v.__alloc_))
+#else
+      __cap_alloc_(_VSTD::move(__v.__cap_alloc_))
+#endif
+{
     __v.__begin_ = nullptr;
     __v.__size_ = 0;
     __v.__cap() = 0;
 }
 
 template <class _Allocator>
 vector<bool, _Allocator>::vector(vector&& __v, const allocator_type& __a)
     : __begin_(nullptr),
       __size_(0),
+#ifdef _LIBCPP_USE_NO_UNIQUE_ADDRESS
+      __cap_(0), __alloc_(__a)
+#else
       __cap_alloc_(0, __a)
+#endif
 {
     if (__a == allocator_type(__v.__alloc()))
     {
         this->__begin_ = __v.__begin_;
         this->__size_ = __v.__size_;
         this->__cap() = __v.__cap();
         __v.__begin_ = nullptr;
         __v.__cap() = __v.__size_ = 0;

libcxx/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp

int main(int, char**) {
   {
     using Set = std::unordered_set<VT>;
     Set s; // expected-error@__hash_table:* {{the specified hash does not meet the Hash requirements}}
 
 
   // FIXME: It would be great to suppress the below diagnostic all together.
   //        but for now it's sufficient that it appears last. However there is
   //        currently no way to test the order diagnostics are issued.
-  // expected-error@memory:* {{call to implicitly-deleted default constructor of '__compressed_pair_elem}}
+  // expected-error@* {{call to implicitly-deleted default constructor}}
   }
   {
     using Set = std::unordered_set<int, BadHashNoCopy>;
     Set s; // expected-error@__hash_table:* {{the specified hash does not meet the Hash requirements}}
   }
   {
     using Set = std::unordered_set<int, BadHashNoCall>;
     Set s; // expected-error@__hash_table:* {{the specified hash does not meet the Hash requirements}}
   }
   {
     using Set = std::unordered_set<int, GoodHashNoDefault>;
     Set s(/*bucketcount*/42, GoodHashNoDefault(nullptr));
   }
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp

 
 struct S {
 protected:
    S () {};  // ctor is protected
 };
 
 int main(int, char**)
 {
+    // We only see the second error here if we don't use EBO.
     std::shared_ptr<S> p = std::make_shared<S>();  // expected-error-re@memory:* {{static_assert failed{{.*}} "Can't construct object in make_shared"}}
+    // expected-error@memory:* 0-1{{'S' has protected default constructor}}
 
   return 0;
 }