[libc++] Remove UB in list, forward_list and __hash_table

[ldionne]

Summary

This patch removes undefined behavior in list and forward_list and __hash_table
caused by improperly beginning and ending the lifetime of the various node
classes. It allows removing the _LIBCPP_STANDALONE_DEBUG macro from
these node types since we now properly begin and end their lifetime,
meaning that we won't trip up constructor homing.

See https://reviews.llvm.org/D98750 for more information on what prompted
this patch.

[akhuang]

remove commented out code

[akhuang]

remove commented code

[Mordante]

This looks somewhat similar to D99624. Does it attempt to address the same issue? @ldionne you might want to have a look at this.

[• Quuxplusone]

@Mordante: yes it does. :)
@akhuang: My understanding is that removing-the-UB is needed (or at least desired) for the benefit of some particular sanitizer; could you add info to the review summary (and commit message) about that?
Also, are we really interested in getting that benefit for C++03 code? Arguably it would be better to preserve the existing behavior for C++03 and fix the behavior only for C++>=11. Is it physically possible to go that route? and if so, does that eliminate a lot of the ifdefs in this PR? (I'm thinking we could just have one ifdef around the union itself, and then the rest of the code wouldn't need ifdefs at all.) The behavior would remain UB, but unchanged, in C++03; and we could say "if you want to use such-and-such sanitizer, please compile as C++>=11." That won't be a hardship for the user, will it?

[akhuang]

In D101206#2714550, @Quuxplusone wrote:

@Mordante: yes it does. :)
@akhuang: My understanding is that removing-the-UB is needed (or at least desired) for the benefit of some particular sanitizer; could you add info to the review summary (and commit message) about that?
Also, are we really interested in getting that benefit for C++03 code? Arguably it would be better to preserve the existing behavior for C++03 and fix the behavior only for C++>=11. Is it physically possible to go that route? and if so, does that eliminate a lot of the ifdefs in this PR? (I'm thinking we could just have one ifdef around the union itself, and then the rest of the code wouldn't need ifdefs at all.) The behavior would remain UB, but unchanged, in C++03; and we could say "if you want to use such-and-such sanitizer, please compile as C++>=11." That won't be a hardship for the user, will it?

So the motivation for this is for a debug info optimization that homes debug info for classes to their constructors, and it relies on constructors being called (and we'd like to enable that mode by default in llvm). We don't necessarily care whether there's UB or not, but in this situation we wouldn't have debug info for these types.

I think making it only work for only C++>=11 could be fine, though.

[akhuang]

For the debug info issue, we can also just add an attribute to these types (https://reviews.llvm.org/D98750); I think @ldionne preferred solving this by fixing the UB directly though.

[akhuang]

Remove fix for c++03.

[• Quuxplusone]

LGTM at this point. So I guess the next question (besides how it looks to @ldionne!) is, should you do it for forward_list etc. in this same PR? Do you know already the complete list of types that need this kind of patch done for them? If so, I would think it's appropriate to do them all together in this PR.

libcxx/include/list

354–357

Any reason not to =default this constructor? (And I'd make it explicit, since there's no reason not to, and it might ease overload resolution just a tiny bit. In my codebases, the explicit keyword basically means "Look out, here comes a constructor!")

[• Quuxplusone]

libcxx/include/list

332

Nit: Indent 4 spaces to match the indentation everywhere else in this file. (I blame clang-format. ;))

[akhuang]

Apply union fix to forward_list_node and hash_node

[akhuang]

Seems like it's a little less straightforward for some of the other types (__tree_node, __value_type and __hash_value_type), especially since they explicitly delete the constructors/destructors and I don't have a great understanding of why. Should probably get @EricWF's opinion on this?

I'm still somewhat leaning toward just adding an attribute to those types to solve the debug info issue (https://reviews.llvm.org/D98750)

libcxx/include/list

354–357

apparently using =default complains because __value_ doesn't have a default constructor

[EricWF]

Has this been tested with various sanitizers on? Does it give warnings about weird object lifetimes?

libcxx/include/list

332

I'm a bit worried that there are combinations of types and compiler flags that will align a subobject differently when it's in a union than when it's not.
I need to investigate further.

1083

Maybe we can sink these repeated lines of code into a function?

[EricWF]

In D101206#2721174, @akhuang wrote:

Seems like it's a little less straightforward for some of the other types (__tree_node, __value_type and __hash_value_type), especially since they explicitly delete the constructors/destructors and I don't have a great understanding of why. Should probably get @EricWF's opinion on this?

I'm still somewhat leaning toward just adding an attribute to those types to solve the debug info issue (https://reviews.llvm.org/D98750)

I agree that the attribute is a non-complicated and good way to address those types.

[akhuang]

In D101206#2725743, @EricWF wrote:

Has this been tested with various sanitizers on? Does it give warnings about weird object lifetimes?

Tried running tests with sanitizers (Address, Memory, Undefined) - doesn't look like there are any new failures.

[akhuang]

Move some of the #ifndefs in forward_list into a function

[akhuang]

Fix #ifdef for function

[ldionne]

[Github PR transition cleanup]

Commandeering to poke CI, rebase, etc.

[ldionne]

Update. This is still a WIP. This rebases the patch and reworks how it's achieved to

1. Increase consistency
2. Remove code duplication
3. Simplify the code

The resulting patch touches more lines, but it becomes a lot easier to verify the correctness of the resulting code.

This is still a WIP, I need to update std::list but this is enough for today.

[ldionne]

I am opting to do a refactoring in https://github.com/llvm/llvm-project/pull/65614 first.

[ldionne]

Rebase on top of refactoring in https://github.com/llvm/llvm-project/pull/65614

[dblaikie]

This also allows removing the _LIBCPP_STANDALONE_DEBUG attribute from a few types since constructor homing should now work for them. For more details, see https://reviews.llvm.org/D98750

Awesome! I'm really glad to see this & the UB being cleaned up.

(though this does mean the debug info will be broken for C++03 mode, yeah? I don't think we/Google care about that, but other people might... )

[ldionne]

In D101206#4646845, @dblaikie wrote:

(though this does mean the debug info will be broken for C++03 mode, yeah? I don't think we/Google care about that, but other people might... )

I could keep the _LIBCPP_STANDALONE_DEBUG attribute on the classes for the C++03 case, I guess!

[ldionne]

Rebase onto main, which contains the refactoring. Keep _LIBCPP_STANDALONE_DEBUG on the node types to avoid breaking debug info in C++03.

I don't know how to add a test for this change, suggestions welcome.

[dblaikie]

In D101206#4647403, @ldionne wrote:

Rebase onto main, which contains the refactoring. Keep _LIBCPP_STANDALONE_DEBUG on the node types to avoid breaking debug info in C++03.

I don't know how to add a test for this change, suggestions welcome.

I don't think the original commit had test coverage for this, probably - so "just as good" to still not have it.

I think the way to test it, if you wanted to, would be to llvm-dwarfdump a simple usage and check that the type definition is available.

It'd look something like...

RUN: clang x.cpp -g -c -o %t.o
RUN: llvm-dwarfdump %t.o | FileCheck %s

CHECK:   DW_AT_name "SomeType"
CHECK-NOT: DW_AT_declaration
CHECK-NOT: DW_TAG
CHECK:  DW_AT_byte_size
CHECK: DW_TAG

(This is sort of hedging my bets a bit - checking both that it's not a declaration, and that it does have a size (size isn't included in declarations) - there's some risk that the attributes are out of order and that declaration or size could come before name, but I don't think LLVM produces type attributes in that order - pretty sure the name comes first)

[ldionne]

In D101206#4647492, @dblaikie wrote:

RUN: clang x.cpp -g -c -o %t.o
RUN: llvm-dwarfdump %t.o | FileCheck %s

CHECK:   DW_AT_name "SomeType"
CHECK-NOT: DW_AT_declaration
CHECK-NOT: DW_TAG
CHECK:  DW_AT_byte_size
CHECK: DW_TAG

(This is sort of hedging my bets a bit - checking both that it's not a declaration, and that it does have a size (size isn't included in declarations) - there's some risk that the attributes are out of order and that declaration or size could come before name, but I don't think LLVM produces type attributes in that order - pretty sure the name comes first)

Thanks for the suggestion! We don't have access to FileCheck in the libc++ tests unfortunately, so this would require a bunch of additional work (as outlined in https://github.com/llvm/llvm-project/pull/65917). I also tried running this locally and I don't see anything that looks like DW_AT_name "SomeType" (where I imagine SomeType should be e.g. __list_node in some form)?

[dblaikie]

In D101206#4647500, @ldionne wrote:

In D101206#4647492, @dblaikie wrote:

RUN: clang x.cpp -g -c -o %t.o
RUN: llvm-dwarfdump %t.o | FileCheck %s

CHECK:   DW_AT_name "SomeType"
CHECK-NOT: DW_AT_declaration
CHECK-NOT: DW_TAG
CHECK:  DW_AT_byte_size
CHECK: DW_TAG

(This is sort of hedging my bets a bit - checking both that it's not a declaration, and that it does have a size (size isn't included in declarations) - there's some risk that the attributes are out of order and that declaration or size could come before name, but I don't think LLVM produces type attributes in that order - pretty sure the name comes first)

Thanks for the suggestion! We don't have access to FileCheck in the libc++ tests unfortunately, so this would require a bunch of additional work (as outlined in https://github.com/llvm/llvm-project/pull/65917). I also tried running this locally and I don't see anything that looks like DW_AT_name "SomeType" (where I imagine SomeType should be e.g. __list_node in some form)?

looks like it's __forward_list_node in this case? Here's an example with/without the attribute at some version of libc++ I have installed locally:

$ clang++-tot test.cpp -g -c -stdlib=libc++ && llvm-dwarfdump-tot test.o | grep "DW_AT_name.*\"__forward_list_node<" -A5
                    DW_AT_name  ("__forward_list_node<int, void *>")
                    DW_AT_byte_size     (0x10)
                    DW_AT_decl_file     ("/usr/local/google/home/blaikie/dev/llvm/build/default/bin/../include/c++/v1/forward_list")
                    DW_AT_decl_line     (324)
...

$ clang++-tot test.cpp -g -c -stdlib=libc++ && llvm-dwarfdump-tot test.o | grep "DW_AT_name.*\"__forward_list_node<" -A5
                    DW_AT_name  ("__forward_list_node<int, void *>")
                    DW_AT_declaration   (true)
...

[EricWF]

In D101206#4647500, @ldionne wrote:

In D101206#4647492, @dblaikie wrote:

RUN: clang x.cpp -g -c -o %t.o
RUN: llvm-dwarfdump %t.o | FileCheck %s

CHECK:   DW_AT_name "SomeType"
CHECK-NOT: DW_AT_declaration
CHECK-NOT: DW_TAG
CHECK:  DW_AT_byte_size
CHECK: DW_TAG

(This is sort of hedging my bets a bit - checking both that it's not a declaration, and that it does have a size (size isn't included in declarations) - there's some risk that the attributes are out of order and that declaration or size could come before name, but I don't think LLVM produces type attributes in that order - pretty sure the name comes first)

Thanks for the suggestion! We don't have access to FileCheck in the libc++ tests unfortunately, so this would require a bunch of additional work (as outlined in https://github.com/llvm/llvm-project/pull/65917). I also tried running this locally and I don't see anything that looks like DW_AT_name "SomeType" (where I imagine SomeType should be e.g. __list_node in some form)?

We do have access to filecheck sometimes. We could just check for the binary, and make our decision based off that. Though, that means we'll likely not have the test running on the bots (right away), but we can still write the test.
I don't know that it'll provide a ton of value though.

---

On another note, I think this patch could be a lot smaller and introduce fewer #ifdef branches. I think we should simply default-construct the node, then initialize each member as we were before. We can also skip the calls to the destructors because they have no observable effects.
This has the benefit of reducing the amount of code duplication between the branches, as well as keeping the pre/post conditions of the node type after construction the same. You don't need to add additional constructors.

Let me know if I've missed something.

libcxx/include/__hash_table

1398

I don't know that we need to call the destructor here.
Do we?

1398

Lets drop the calls to the destructor. They should have no affect, and so it's more readable without them as it makes clear they don't perform any user-observable behaviors.

2237

Why are we initializing more in this branch than we are in the other?

I would rather keep the two sets of behavior as convergent as possible.

2237

In fact, why not simply make the constructor an nop, then keep using the code below to initialize the members.

It's easier to reason about one conditional compilation block than it is two.

2237

Same note as above. Simply default construct the object, then initialize it the same way we were.

libcxx/include/forward_list

331

Is there a correctness reason for using the union over some other form of aligned storage?

332

I don't like macros that get defined mid-file like this. We typically don't do it, and I would like to avoid it.

620

Same comment here.

libcxx/include/list

356

Do we cause ourselves any problems not starting the lifetime of the object in C++03 mode now that it's got a user defined destructor?

I suspect not, because it's not like the type was always trivially destructible, but maybe?

[ldionne]

libcxx/include/__hash_table

1398

As discussed during live review, we're going to call the destructor for symmetry with calling construct_at.

2237

As discussed during live review, the new approach will initialize the node in all standard modes.

libcxx/include/forward_list

331

As discussed, I think the main benefit is readability and probably the debugging experience in non-C++03 mode.

libcxx/include/list

356

This will become moot with the new approach we discussed.

[ldionne]

Update after discussion with Eric. This allows fixing the UB in all standard modes and simplifies the code quite a bit!

[dblaikie]

libcxx/include/forward_list

331

Readability seems a bit limited if the cost is #ifdefs and having the other implementation here too, though, yeah? Like this code would be easier, I think, to read and modify if there was only one implementation even if it's the aligned storage one, rather than having two. Less is easier to read, generally.

Debuggability - yeah, that's true, though probably not super important except for standard library authors? (& sounds like you're not convinced/certain it'd be especially helpful to you personally?) - if you want to inspect the value in the node directly, without invoking any code (eg: debugging a core dump) then the union is easier (you don't have to write out the cast in a debugger expression evaluator to get the value from the aligned storage)

(I'm not making some firm statement here - just my 2c, feel free to disregard)

[dblaikie]

In D101206#4651782, @ldionne wrote:

Update after discussion with Eric. This allows fixing the UB in all standard modes and simplifies the code quite a bit!

Oh, also meant to say: This is a great improvement!

[ldionne]

Fix CI issues.

[ldionne]

libcxx/include/forward_list

331

I don't have a strong opinion, but I think the "inspecting a value from the debugger is easier with a union" was the main motivating factor for doing this.

[dblaikie]

libcxx/include/forward_list

331

Fair - yeah, if I were maintaining only one version and I could write the union one, I would. But if it comes to maintaining two versions - I probably wouldn't bother with two versions for that benefit. *shrug*

[ldionne]

Fix gnu_cxx test on GCC. Remove CFI tests which are unnecessary according to EricWF (after offline discussion).

[Michael137]

Looks like this broke the LLDB buildbot on Darwin: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/61029/console

Specifically the formatters:

Failed Tests (2):
  lldb-api :: commands/expression/import-std-module/queue/TestQueueFromStdModule.py
  lldb-api :: functionalities/data-formatter/data-formatter-stl/generic/unordered/TestDataFormatterGenericUnordered.py

AssertionError: Ran command:
"frame variable map"

Got output:
(std::unordered_map<int, std::string>) map = size=5 {}

Expecting regex pattern: "std::unordered_map" (was found, matched "std::unordered_map")
Expecting regex pattern: "\[0\] = \{\s*first = " (was not found)

Presumably because we removed the _LIBCPP_STANDALONE_DEBUG. I don't think we do constructor homing on Darwin since we do -fstandalone-debug

[krasimir]

Temporarily rolled back due to the LLDB failures.

[dblaikie]

In D101206#4653253, @Michael137 wrote:

Looks like this broke the LLDB buildbot on Darwin: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/61029/console

Specifically the formatters:

Failed Tests (2):
  lldb-api :: commands/expression/import-std-module/queue/TestQueueFromStdModule.py
  lldb-api :: functionalities/data-formatter/data-formatter-stl/generic/unordered/TestDataFormatterGenericUnordered.py

AssertionError: Ran command:
"frame variable map"

Got output:
(std::unordered_map<int, std::string>) map = size=5 {}

Expecting regex pattern: "std::unordered_map" (was found, matched "std::unordered_map")
Expecting regex pattern: "\[0\] = \{\s*first = " (was not found)

Presumably because we removed the _LIBCPP_STANDALONE_DEBUG. I don't think we do constructor homing on Darwin since we do -fstandalone-debug

Adding/removing the attribute shouldn't make any difference on Darwin. (the standalone debug attribute says "treat this type as though it were compiled with -fstandalone-debug" and Darwin's default is -fstandalone-debug - so adding/removing the attribute shouldn't change the behavior - it's possible there are bugs here, but I'd wager that's not the case/is a red herring)

[Michael137]

In D101206#4653303, @dblaikie wrote:

In D101206#4653253, @Michael137 wrote:

Looks like this broke the LLDB buildbot on Darwin: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/61029/console

Specifically the formatters:

Failed Tests (2):
  lldb-api :: commands/expression/import-std-module/queue/TestQueueFromStdModule.py
  lldb-api :: functionalities/data-formatter/data-formatter-stl/generic/unordered/TestDataFormatterGenericUnordered.py

AssertionError: Ran command:
"frame variable map"

Got output:
(std::unordered_map<int, std::string>) map = size=5 {}

Expecting regex pattern: "std::unordered_map" (was found, matched "std::unordered_map")
Expecting regex pattern: "\[0\] = \{\s*first = " (was not found)

Presumably because we removed the _LIBCPP_STANDALONE_DEBUG. I don't think we do constructor homing on Darwin since we do -fstandalone-debug

Adding/removing the attribute shouldn't make any difference on Darwin. (the standalone debug attribute says "treat this type as though it were compiled with -fstandalone-debug" and Darwin's default is -fstandalone-debug - so adding/removing the attribute shouldn't change the behavior - it's possible there are bugs here, but I'd wager that's not the case/is a red herring)

Good point, though I did confirm that this patch caused the breakage.
Reason I pointed it at the attribute was following error:

error: warning: warning: got name from symbols: C
error: Couldn't look up symbols:
  __ZNSt3__19__voidifyB7v180000INS_11__list_nodeI1CPvEEEES3_RT_

Which on first glance sounds like a "lack of debug info" problem. Though your point makes sense, it shouldn't affect Darwin since it's already the default. Will investigate what else it could be

[Michael137]

In D101206#4653387, @Michael137 wrote:

In D101206#4653303, @dblaikie wrote:

In D101206#4653253, @Michael137 wrote:

Looks like this broke the LLDB buildbot on Darwin: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/61029/console

Specifically the formatters:

Failed Tests (2):
  lldb-api :: commands/expression/import-std-module/queue/TestQueueFromStdModule.py
  lldb-api :: functionalities/data-formatter/data-formatter-stl/generic/unordered/TestDataFormatterGenericUnordered.py

AssertionError: Ran command:
"frame variable map"

Got output:
(std::unordered_map<int, std::string>) map = size=5 {}

Expecting regex pattern: "std::unordered_map" (was found, matched "std::unordered_map")
Expecting regex pattern: "\[0\] = \{\s*first = " (was not found)

Presumably because we removed the _LIBCPP_STANDALONE_DEBUG. I don't think we do constructor homing on Darwin since we do -fstandalone-debug

Adding/removing the attribute shouldn't make any difference on Darwin. (the standalone debug attribute says "treat this type as though it were compiled with -fstandalone-debug" and Darwin's default is -fstandalone-debug - so adding/removing the attribute shouldn't change the behavior - it's possible there are bugs here, but I'd wager that's not the case/is a red herring)

Good point, though I did confirm that this patch caused the breakage.
Reason I pointed it at the attribute was following error:

error: warning: warning: got name from symbols: C
error: Couldn't look up symbols:
  __ZNSt3__19__voidifyB7v180000INS_11__list_nodeI1CPvEEEES3_RT_

Which on first glance sounds like a "lack of debug info" problem. Though your point makes sense, it shouldn't affect Darwin since it's already the default. Will investigate what else it could be

Ah the problem is most likely because __value_ is now wrapped in an anonymous union. Which breaks the formatter's assumption:

// In LibCxxUnorderedMap.cpp
node_sp = m_next_element->Cast(m_node_type.GetPointerType()) 
        ->Dereference(error);                                            
if (!node_sp || error.Fail())                                               
    return nullptr;                                                         
                                                                            
value_sp = node_sp->GetChildMemberWithName("__value_");

Should be able to fix this fairly quick. The other test is failing for a different reason by the looks of it. But it is for a much less widely used feature and I don't think it really needs to block this from landing if we don't get to the bottom of it soon.

Side note, we should really improve the error reporting when these formatters fail (currently I don't see any). So we can get to the bottom of the failures more quickly.

[Michael137]

Proposed LLDB fix: https://github.com/llvm/llvm-project/pull/68574

[dblaikie]

In D101206#4653421, @Michael137 wrote:

Proposed LLDB fix: https://github.com/llvm/llvm-project/pull/68574

Personally - maybe this added complexity (combined with the existing slight increase in complexity of having #ifdef'd code) is enough to tip in favor of having the one portable implementation - despite the possible slight reduction in implementation debuggability, since it doesn't sound like anyone's here saying they really need that feature?

[ldionne]

In D101206#4653478, @dblaikie wrote:

In D101206#4653421, @Michael137 wrote:

Proposed LLDB fix: https://github.com/llvm/llvm-project/pull/68574

Personally - maybe this added complexity (combined with the existing slight increase in complexity of having #ifdef'd code) is enough to tip in favor of having the one portable implementation - despite the possible slight reduction in implementation debuggability, since it doesn't sound like anyone's here saying they really need that feature?

I agree. However, after speaking with @Michael137 , it would actually make LLDB's life harder if I were to always use the C++03 variant because right now they only handle the union version of the code and the previous version of the code. @Michael137 tells me I can re-commit this now, so I'll do that.

[ldionne]

Actually I'll wait for tomorrow morning so the LLDB folks can follow-up with the fix quickly after.

[dblaikie]

In D101206#4653863, @ldionne wrote:

In D101206#4653478, @dblaikie wrote:

In D101206#4653421, @Michael137 wrote:

Proposed LLDB fix: https://github.com/llvm/llvm-project/pull/68574

Personally - maybe this added complexity (combined with the existing slight increase in complexity of having #ifdef'd code) is enough to tip in favor of having the one portable implementation - despite the possible slight reduction in implementation debuggability, since it doesn't sound like anyone's here saying they really need that feature?

I agree. However, after speaking with @Michael137 , it would actually make LLDB's life harder if I were to always use the C++03 variant because right now they only handle the union version of the code and the previous version of the code. @Michael137 tells me I can re-commit this now, so I'll do that.

Oh, it looks like it would handle the 03 variant today - because it'd find the __value_ member on the first lookup, then it only falls back to looking through the anonymous union if that fails? Or does that fail later on because the __value_ member isn't of the expected type in the 03 case (since it's just the raw buffer).

Pity to lose the ability to pretty print the 03 version :/

[Michael137]

In D101206#4653905, @dblaikie wrote:

In D101206#4653863, @ldionne wrote:

In D101206#4653478, @dblaikie wrote:

In D101206#4653421, @Michael137 wrote:

Proposed LLDB fix: https://github.com/llvm/llvm-project/pull/68574

Personally - maybe this added complexity (combined with the existing slight increase in complexity of having #ifdef'd code) is enough to tip in favor of having the one portable implementation - despite the possible slight reduction in implementation debuggability, since it doesn't sound like anyone's here saying they really need that feature?

I agree. However, after speaking with @Michael137 , it would actually make LLDB's life harder if I were to always use the C++03 variant because right now they only handle the union version of the code and the previous version of the code. @Michael137 tells me I can re-commit this now, so I'll do that.

Oh, it looks like it would handle the 03 variant today - because it'd find the __value_ member on the first lookup, then it only falls back to looking through the anonymous union if that fails? Or does that fail later on because the __value_ member isn't of the expected type in the 03 case (since it's just the raw buffer).

Pity to lose the ability to pretty print the 03 version :/

We can certainly add support for the C++03 format too. I don't think have any test coverage for C++03 but wouldn't be too difficult to add. Will have a look at that next week

libcxx/include/__hash_table

 #include <__bit/countl.h>
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/invoke.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
+#include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory/unique_ptr.h>
 #include <__type_traits/can_extract_key.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_const.h>
 #include <__type_traits/is_copy_constructible.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_nothrow_copy_constructible.h>
 #include <__type_traits/is_nothrow_default_constructible.h>
 #include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/is_nothrow_move_constructible.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_swappable.h>
 #include <__type_traits/remove_const.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <cmath>
 #include <cstring>
 #include <initializer_list>
+#include <new> // __launder
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
#endif
     }
 
     _LIBCPP_INLINE_VISIBILITY
     size_t __hash() const _NOEXCEPT {
         return static_cast<__node_type const&>(*this).__hash_;
     }
 
     _LIBCPP_INLINE_VISIBILITY __hash_node_base() _NOEXCEPT : __next_(nullptr) {}
+    _LIBCPP_HIDE_FROM_ABI explicit __hash_node_base(__next_pointer __next) _NOEXCEPT : __next_(__next) {}
 };
 
 template <class _Tp, class _VoidPtr>
-struct _LIBCPP_STANDALONE_DEBUG __hash_node
+struct __hash_node
     : public __hash_node_base
              <
                  __rebind_pointer_t<_VoidPtr, __hash_node<_Tp, _VoidPtr> >
              >
 {
     typedef _Tp __node_value_type;
+    using _Base = __hash_node_base<__rebind_pointer_t<_VoidPtr, __hash_node<_Tp, _VoidPtr> > >;
+    using __next_pointer = typename _Base::__next_pointer;
 
     size_t            __hash_;
-    __node_value_type __value_;
+
+    // We allow starting the lifetime of nodes without initializing the value held by the node,
+    // since that is handled by the hash table itself in order to be allocator-aware.
+#ifndef _LIBCPP_CXX03_LANG
+private:
+    union {
+        _Tp __value_;
+    };
+
+public:
+    _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return __value_; }
+#else
+private:
+    _ALIGNAS_TYPE(_Tp) char __buffer_[sizeof(_Tp)];
+
+public:
+    _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() {
+        return *std::__launder(reinterpret_cast<_Tp*>(&__buffer_));
+    }
+#endif
+
+    _LIBCPP_HIDE_FROM_ABI explicit __hash_node(__next_pointer __next, size_t __hash) : _Base(__next), __hash_(__hash) {}
+    _LIBCPP_HIDE_FROM_ABI ~__hash_node() {}
 };
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 __is_hash_power2(size_t __bc)
 {
     return __bc > 2 && !(__bc & (__bc - 1));
 }
public:
     typedef value_type&                                    reference;
     typedef typename _NodeTypes::__node_value_type_pointer pointer;
 
     _LIBCPP_INLINE_VISIBILITY __hash_iterator() _NOEXCEPT : __node_(nullptr) {
     }
 
     _LIBCPP_INLINE_VISIBILITY
     reference operator*() const {
-        return __node_->__upcast()->__value_;
+        return __node_->__upcast()->__get_value();
     }
 
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const {
-        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
+        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__get_value());
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_iterator& operator++() {
         __node_ = __node_->__next_;
         return *this;
     }
 
public:
     _LIBCPP_INLINE_VISIBILITY
     __hash_const_iterator(const __non_const_iterator& __x) _NOEXCEPT
         : __node_(__x.__node_)
     {
     }
 
     _LIBCPP_INLINE_VISIBILITY
     reference operator*() const {
-        return __node_->__upcast()->__value_;
+        return __node_->__upcast()->__get_value();
     }
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const {
-        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
+        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__get_value());
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_const_iterator& operator++() {
         __node_ = __node_->__next_;
         return *this;
     }
 
public:
     typedef value_type&                                         reference;
     typedef typename _NodeTypes::__node_value_type_pointer      pointer;
 
     _LIBCPP_INLINE_VISIBILITY __hash_local_iterator() _NOEXCEPT : __node_(nullptr) {
     }
 
     _LIBCPP_INLINE_VISIBILITY
     reference operator*() const {
-        return __node_->__upcast()->__value_;
+        return __node_->__upcast()->__get_value();
     }
 
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const {
-        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
+        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__get_value());
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_local_iterator& operator++() {
         __node_ = __node_->__next_;
         if (__node_ != nullptr && std::__constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
             __node_ = nullptr;
         return *this;
__hash_const_local_iterator(const __non_const_iterator& __x) _NOEXCEPT
         : __node_(__x.__node_),
           __bucket_(__x.__bucket_),
           __bucket_count_(__x.__bucket_count_)
     {
     }
 
     _LIBCPP_INLINE_VISIBILITY
     reference operator*() const {
-        return __node_->__upcast()->__value_;
+        return __node_->__upcast()->__get_value();
     }
 
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const {
-        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
+        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__get_value());
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_const_local_iterator& operator++() {
         __node_ = __node_->__next_;
         if (__node_ != nullptr && std::__constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
             __node_ = nullptr;
         return *this;
explicit __hash_node_destructor(allocator_type& __na,
                                     bool __constructed = false) _NOEXCEPT
         : __na_(__na),
           __value_constructed(__constructed)
         {}
 
     _LIBCPP_INLINE_VISIBILITY
     void operator()(pointer __p) _NOEXCEPT
     {
-        if (__value_constructed)
-            __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
+        if (__value_constructed) {
+            __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__get_value()));
+            std::__destroy_at(std::addressof(*__p));
+        }
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
 
     template <class> friend class __hash_map_node_destructor;
 };
 
 #if _LIBCPP_STD_VER >= 17

 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate_node(__next_pointer __np)
     _NOEXCEPT
 {
     __node_allocator& __na = __node_alloc();
     while (__np != nullptr)
     {
         __next_pointer __next = __np->__next_;
         __node_pointer __real_np = __np->__upcast();
-        __node_traits::destroy(__na, _NodeTypes::__get_ptr(__real_np->__value_));
+        __node_traits::destroy(__na, _NodeTypes::__get_ptr(__real_np->__get_value()));
+        std::__destroy_at(std::addressof(*__real_np));
         __node_traits::deallocate(__na, __real_np, 1);
         __np = __next;
     }
 }
 
 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
else
             __next_pointer __cache = __detach();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
             try
             {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
                 const_iterator __i = __u.begin();
                 while (__cache != nullptr && __u.size() != 0)
                 {
-                    __cache->__upcast()->__value_ =
-                        _VSTD::move(__u.remove(__i++)->__value_);
+                    __cache->__upcast()->__get_value() =
+                        _VSTD::move(__u.remove(__i++)->__get_value());
                     __next_pointer __next = __cache->__next_;
                     __node_insert_multi(__cache->__upcast());
                     __cache = __next;
                 }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
             }
             catch (...)
             {
                 __deallocate_node(__cache);
                 throw;
             }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
             __deallocate_node(__cache);
         }
         const_iterator __i = __u.begin();
         while (__u.size() != 0)
         {
-            __node_holder __h = __construct_node(_NodeTypes::__move(__u.remove(__i++)->__value_));
+            __node_holder __h = __construct_node(_NodeTypes::__move(__u.remove(__i++)->__get_value()));
             __node_insert_multi(__h.get());
             __h.release();
         }
     }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first,
     {
         __next_pointer __cache = __detach();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
             for (; __cache != nullptr && __first != __last; ++__first)
             {
-                __cache->__upcast()->__value_ = *__first;
+                __cache->__upcast()->__get_value() = *__first;
                 __next_pointer __next = __cache->__next_;
                 __node_insert_unique(__cache->__upcast());
                 __cache = __next;
             }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         }
         catch (...)
         {
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
     {
         __next_pointer __cache = __detach();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
             for (; __cache != nullptr && __first != __last; ++__first)
             {
-                __cache->__upcast()->__value_ = *__first;
+                __cache->__upcast()->__get_value() = *__first;
                 __next_pointer __next = __cache->__next_;
                 __node_insert_multi(__cache->__upcast());
                 __cache = __next;
             }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         }
         catch (...)
         {
if (__bc != 0)
         if (__ndptr != nullptr)
         {
             for (__ndptr = __ndptr->__next_; __ndptr != nullptr &&
                     (__ndptr->__hash() == __hash ||
                      std::__constrain_hash(__ndptr->__hash(), __bc) == __chash);
                                                      __ndptr = __ndptr->__next_)
             {
                 if ((__ndptr->__hash() == __hash) &&
-                    key_eq()(__ndptr->__upcast()->__value_, __value))
+                    key_eq()(__ndptr->__upcast()->__get_value(), __value))
                     return __ndptr;
             }
         }
     }
     if (size()+1 > __bc * max_load_factor() || __bc == 0)
     {
         __rehash_unique(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
                                      size_type(std::ceil(float(size() + 1) / max_load_factor()))));
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique_perform(
     }
     ++size();
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __nd)
 {
-    __nd->__hash_ = hash_function()(__nd->__value_);
+    __nd->__hash_ = hash_function()(__nd->__get_value());
     __next_pointer __existing_node =
-        __node_insert_unique_prepare(__nd->__hash(), __nd->__value_);
+        __node_insert_unique_prepare(__nd->__hash(), __nd->__get_value());
 
     // Insert the node, unless it already exists in the container.
     bool __inserted = false;
     if (__existing_node == nullptr)
     {
         __node_insert_unique_perform(__nd);
         __existing_node = __nd->__ptr();
         __inserted = true;
if (__pn != nullptr)
                                                            __pn = __pn->__next_)
         {
             //      __found    key_eq()     action
             //      false       false       loop
             //      true        true        loop
             //      false       true        set __found to true
             //      true        false       break
             if (__found != (__pn->__next_->__hash() == __cp_hash &&
-                            key_eq()(__pn->__next_->__upcast()->__value_, __cp_val)))
+                            key_eq()(__pn->__next_->__upcast()->__get_value(), __cp_val)))
             {
                 if (!__found)
                     __found = true;
                 else
                     break;
             }
         }
     }
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_perform(
     ++size();
 }
 
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __cp)
 {
-    __cp->__hash_ = hash_function()(__cp->__value_);
-    __next_pointer __pn = __node_insert_multi_prepare(__cp->__hash(), __cp->__value_);
+    __cp->__hash_ = hash_function()(__cp->__get_value());
+    __next_pointer __pn = __node_insert_multi_prepare(__cp->__hash(), __cp->__get_value());
     __node_insert_multi_perform(__cp, __pn);
 
     return iterator(__cp->__ptr());
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(
         const_iterator __p, __node_pointer __cp)
 {
-    if (__p != end() && key_eq()(*__p, __cp->__value_))
+    if (__p != end() && key_eq()(*__p, __cp->__get_value()))
     {
         __next_pointer __np = __p.__node_;
         __cp->__hash_ = __np->__hash();
         size_type __bc = bucket_count();
         if (size()+1 > __bc * max_load_factor() || __bc == 0)
         {
             __rehash_multi(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
                            size_type(std::ceil(float(size() + 1) / max_load_factor()))));
if (__bc != 0)
         __nd = __bucket_list_[__chash];
         if (__nd != nullptr)
         {
             for (__nd = __nd->__next_; __nd != nullptr &&
                 (__nd->__hash() == __hash || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
                                                            __nd = __nd->__next_)
             {
                 if ((__nd->__hash() == __hash) &&
-                    key_eq()(__nd->__upcast()->__value_, __k))
+                    key_eq()(__nd->__upcast()->__get_value(), __k))
                     goto __done;
             }
         }
     }
     {
         __node_holder __h = __construct_node_hash(__hash, _VSTD::forward<_Args>(__args)...);
         if (size()+1 > __bc * max_load_factor() || __bc == 0)
         {
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_merge_unique(
     _Table& __source)
 {
     static_assert(is_same<__node, typename _Table::__node>::value, "");
 
     for (typename _Table::iterator __it = __source.begin();
          __it != __source.end();)
     {
         __node_pointer __src_ptr = __it.__node_->__upcast();
-        size_t __hash = hash_function()(__src_ptr->__value_);
+        size_t __hash = hash_function()(__src_ptr->__get_value());
         __next_pointer __existing_node =
-            __node_insert_unique_prepare(__hash, __src_ptr->__value_);
+            __node_insert_unique_prepare(__hash, __src_ptr->__get_value());
         auto __prev_iter = __it++;
         if (__existing_node == nullptr)
         {
             (void)__source.remove(__prev_iter).release();
             __src_ptr->__hash_ = __hash;
             __node_insert_unique_perform(__src_ptr);
         }
     }
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_merge_multi(
     _Table& __source)
 {
     static_assert(is_same<typename _Table::__node, __node>::value, "");
 
     for (typename _Table::iterator __it = __source.begin();
          __it != __source.end();)
     {
         __node_pointer __src_ptr = __it.__node_->__upcast();
-        size_t __src_hash = hash_function()(__src_ptr->__value_);
+        size_t __src_hash = hash_function()(__src_ptr->__get_value());
         __next_pointer __pn =
-            __node_insert_multi_prepare(__src_hash, __src_ptr->__value_);
+            __node_insert_multi_prepare(__src_hash, __src_ptr->__get_value());
         (void)__source.remove(__it++).release();
         __src_ptr->__hash_ = __src_hash;
         __node_insert_multi_perform(__src_ptr, __pn);
     }
 }
 #endif // _LIBCPP_STD_VER >= 17
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
if (__nbc > 0)
                         __phash = __chash;
                     }
                     else
                     {
                         __next_pointer __np = __cp;
                         if _LIBCPP_CONSTEXPR_SINCE_CXX17 (!_UniqueKeys)
                         {
                             for (; __np->__next_ != nullptr &&
-                                   key_eq()(__cp->__upcast()->__value_,
-                                            __np->__next_->__upcast()->__value_);
+                                   key_eq()(__cp->__upcast()->__get_value(),
+                                            __np->__next_->__upcast()->__get_value());
                                                                __np = __np->__next_)
                                 ;
                         }
                         __pp->__next_ = __np->__next_;
                         __np->__next_ = __bucket_list_[__chash]->__next_;
                         __bucket_list_[__chash]->__next_ = __cp;
 
                     }
if (__bc != 0)
         if (__nd != nullptr)
         {
             for (__nd = __nd->__next_; __nd != nullptr &&
                 (__nd->__hash() == __hash
                   || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
                                                            __nd = __nd->__next_)
             {
                 if ((__nd->__hash() == __hash)
-                    && key_eq()(__nd->__upcast()->__value_, __k))
+                    && key_eq()(__nd->__upcast()->__get_value(), __k))
                     return iterator(__nd);
             }
         }
     }
     return end();
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
if (__bc != 0)
         if (__nd != nullptr)
         {
             for (__nd = __nd->__next_; __nd != nullptr &&
                 (__hash == __nd->__hash()
                     || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
                                                            __nd = __nd->__next_)
             {
                 if ((__nd->__hash() == __hash)
-                    && key_eq()(__nd->__upcast()->__value_, __k))
+                    && key_eq()(__nd->__upcast()->__get_value(), __k))
                     return const_iterator(__nd);
             }
         }
 
     }
     return end();
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class ..._Args>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&& ...__args)
 {
     static_assert(!__is_hash_value_type<_Args...>::value,
                   "Construct cannot be called with a hash value type");
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), _VSTD::forward<_Args>(__args)...);
+
+    // Begin the lifetime of the node itself. Note that this doesn't begin the lifetime of the value
+    // held inside the node, since we need to use the allocator's construct() method for that.
+    //
+    // We don't use the allocator's construct() method to construct the node itself since the
+    // Cpp17FooInsertable named requirements don't require the allocator's construct() method
+    // to work on anything other than the value_type.
+    std::__construct_at(std::addressof(*__h), /* next = */nullptr, /* hash = */0);
+
+    // Now construct the value_type using the allocator's construct() method.
+    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__get_value()), _VSTD::forward<_Args>(__args)...);
     __h.get_deleter().__value_constructed = true;
-    __h->__hash_ = hash_function()(__h->__value_);
-    __h->__next_ = nullptr;
+
+    __h->__hash_ = hash_function()(__h->__get_value());
     return __h;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _First, class ..._Rest>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node_hash(
     size_t __hash, _First&& __f, _Rest&& ...__rest)
 {
     static_assert(!__is_hash_value_type<_First, _Rest...>::value,
                   "Construct cannot be called with a hash value type");
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_),
+    std::__construct_at(std::addressof(*__h), /* next = */nullptr, /* hash = */__hash);
+    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__get_value()),
                              _VSTD::forward<_First>(__f),
                              _VSTD::forward<_Rest>(__rest)...);
     __h.get_deleter().__value_constructed = true;
-    __h->__hash_ = __hash;
-    __h->__next_ = nullptr;
     return __h;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __p)
 {
     __next_pointer __np = __p.__node_;

libcxx/include/__node_handle

 template <class _NodeType, class _Derived>
 struct __set_node_handle_specifics
 {
     typedef typename _NodeType::__node_value_type value_type;
 
     _LIBCPP_INLINE_VISIBILITY
     value_type& value() const
     {
-        return static_cast<_Derived const*>(this)->__ptr_->__value_;
+        return static_cast<_Derived const*>(this)->__ptr_->__get_value();
     }
 };
 
 template <class _NodeType, class _Derived>
 struct __map_node_handle_specifics
 {
     typedef typename _NodeType::__node_value_type::key_type key_type;
     typedef typename _NodeType::__node_value_type::mapped_type mapped_type;
 
     _LIBCPP_INLINE_VISIBILITY
     key_type& key() const
     {
         return static_cast<_Derived const*>(this)->
-            __ptr_->__value_.__ref().first;
+            __ptr_->__get_value().__ref().first;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     mapped_type& mapped() const
     {
         return static_cast<_Derived const*>(this)->
-            __ptr_->__value_.__ref().second;
+            __ptr_->__get_value().__ref().second;
     }
 };
 
 template <class _NodeType, class _Alloc>
 using __set_node_handle =
     __basic_node_handle< _NodeType, _Alloc, __set_node_handle_specifics>;
 
 template <class _NodeType, class _Alloc>

libcxx/include/__tree

 class _LIBCPP_STANDALONE_DEBUG __tree_node
     : public __tree_node_base<_VoidPtr>
 {
 public:
     typedef _Tp __node_value_type;
 
     __node_value_type __value_;
 
+    _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return __value_; }
+
 private:
   ~__tree_node() = delete;
   __tree_node(__tree_node const&) = delete;
   __tree_node& operator=(__tree_node const&) = delete;
 };
 
 
 template <class _Allocator>

libcxx/include/ext/hash_map

__hash_map_node_destructor(const std::__hash_node_destructor<allocator_type>& __x)
             const_cast<bool&>(__x.__value_constructed) = false;
         }
 #endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     void operator()(pointer __p)
     {
         if (__second_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__get_value().second));
         if (__first_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__get_value().first));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
 };
 
 template <class _HashIterator>
 class _LIBCPP_TEMPLATE_VIS __hash_map_iterator
 {

 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 typename hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
 hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k)
 {
     __node_allocator& __na = __table_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__get_value().first), __k);
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__get_value().second));
     __h.get_deleter().__second_constructed = true;
     return __h;
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
 inline
 void

libcxx/include/forward_list

 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
+#include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/container_compatible_range.h>
 #include <__ranges/from_range.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_const.h>
 #include <__type_traits/is_nothrow_default_constructible.h>
 #include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/is_nothrow_move_constructible.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <limits>
+#include <new> // __launder
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>
 #include <__iterator/empty.h>
__begin_node_pointer __next_as_begin() const {
         return static_cast<__begin_node_pointer>(__next_);
     }
 };
 
 template <class _Tp, class _VoidPtr>
 using __begin_node_of = __forward_begin_node<__rebind_pointer_t<_VoidPtr, __forward_list_node<_Tp, _VoidPtr> > >;
 
 template <class _Tp, class _VoidPtr>
-struct _LIBCPP_STANDALONE_DEBUG __forward_list_node
+struct __forward_list_node
     : public __begin_node_of<_Tp, _VoidPtr>
 {
     typedef _Tp value_type;
     typedef __begin_node_of<_Tp, _VoidPtr> _Base;
     typedef typename _Base::pointer _NodePtr;
 
-    value_type __value_;
+    // We allow starting the lifetime of nodes without initializing the value held by the node,
+    // since that is handled by the list itself in order to be allocator-aware.
+#ifndef _LIBCPP_CXX03_LANG
+private:
+    union {
+        _Tp __value_;
+    };
+
+public:
+    _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return __value_; }
+#else
+private:
+    _ALIGNAS_TYPE(_Tp) char __buffer_[sizeof(_Tp)];
 
-    _LIBCPP_HIDE_FROM_ABI __forward_list_node() = default;
-    _LIBCPP_HIDE_FROM_ABI __forward_list_node(const value_type& __v, _NodePtr __next) : _Base(__next), __value_(__v) {}
+public:
+    _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() {
+        return *std::__launder(reinterpret_cast<_Tp*>(&__buffer_));
+    }
+#endif
+
+    _LIBCPP_HIDE_FROM_ABI explicit __forward_list_node(_NodePtr __next) : _Base(__next) {}
+    _LIBCPP_HIDE_FROM_ABI ~__forward_list_node() {}
 };
 
 
 template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS forward_list;
 template<class _NodeConstPtr> class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;
 
 template <class _NodePtr>
 class _LIBCPP_TEMPLATE_VIS __forward_list_iterator
public:
     typedef typename pointer_traits<__node_pointer>::difference_type
                                                               difference_type;
     typedef __rebind_pointer_t<__node_pointer, value_type> pointer;
 
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_iterator() _NOEXCEPT : __ptr_(nullptr) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return __get_unsafe_node_pointer()->__value_;}
+    reference operator*() const {return __get_unsafe_node_pointer()->__get_value();}
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const {
-        return pointer_traits<pointer>::pointer_to(__get_unsafe_node_pointer()->__value_);
+        return pointer_traits<pointer>::pointer_to(__get_unsafe_node_pointer()->__get_value());
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_iterator& operator++()
     {
         __ptr_ = __traits::__as_iter_node(__ptr_->__next_);
         return *this;
     }
public:
 
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_const_iterator() _NOEXCEPT : __ptr_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_const_iterator(__forward_list_iterator<__node_pointer> __p) _NOEXCEPT
         : __ptr_(__p.__ptr_) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return __get_unsafe_node_pointer()->__value_;}
+    reference operator*() const {return __get_unsafe_node_pointer()->__get_value();}
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const {return pointer_traits<pointer>::pointer_to(
-                __get_unsafe_node_pointer()->__value_);}
+                __get_unsafe_node_pointer()->__get_value());}
 
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_const_iterator& operator++()
     {
         __ptr_ = __traits::__as_iter_node(__ptr_->__next_);
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__forward_list_base& __x)
                    is_nothrow_move_assignable<__node_allocator>::value)
         {__move_assign_alloc(__x, integral_constant<bool,
               __node_traits::propagate_on_container_move_assignment::value>());}
 
     template <class ..._Args>
     _LIBCPP_HIDE_FROM_ABI __node_pointer __create_node(__node_pointer __next, _Args&& ...__args) {
         __node_allocator& __a = __alloc();
         __allocation_guard<__node_allocator> __guard(__a, 1);
-        __guard.__get()->__next_ = __next;
-        __node_traits::construct(__a, std::addressof(__guard.__get()->__value_), std::forward<_Args>(__args)...);
+        // Begin the lifetime of the node itself. Note that this doesn't begin the lifetime of the value
+        // held inside the node, since we need to use the allocator's construct() method for that.
+        //
+        // We don't use the allocator's construct() method to construct the node itself since the
+        // Cpp17FooInsertable named requirements don't require the allocator's construct() method
+        // to work on anything other than the value_type.
+        std::__construct_at(std::addressof(*__guard.__get()), __next);
+
+        // Now construct the value_type using the allocator's construct() method.
+        __node_traits::construct(__a, std::addressof(__guard.__get()->__get_value()), std::forward<_Args>(__args)...);
         return __guard.__release_ptr();
     }
 
     template <class ..._Args>
     _LIBCPP_HIDE_FROM_ABI void __delete_node(__node_pointer __node) {
+        // For the same reason as above, we use the allocator's destroy() method for the value_type,
+        // but not for the node itself.
         __node_allocator& __a = __alloc();
-        __node_traits::destroy(__a, std::addressof(__node->__value_));
+        __node_traits::destroy(__a, std::addressof(__node->__get_value()));
+        std::__destroy_at(std::addressof(*__node));
         __node_traits::deallocate(__a, __node, 1);
     }
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     void swap(__forward_list_base& __x)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT;
 #else
#endif
     _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {
         return _VSTD::min<size_type>(
             __node_traits::max_size(base::__alloc()),
             numeric_limits<difference_type>::max());
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    reference       front()       {return base::__before_begin()->__next_->__value_;}
+    reference       front()       {return base::__before_begin()->__next_->__get_value();}
     _LIBCPP_INLINE_VISIBILITY
-    const_reference front() const {return base::__before_begin()->__next_->__value_;}
+    const_reference front() const {return base::__before_begin()->__next_->__get_value();}
 
 #ifndef _LIBCPP_CXX03_LANG
 #if _LIBCPP_STD_VER >= 17
     template <class... _Args>
     _LIBCPP_HIDE_FROM_ABI reference emplace_front(_Args&&... __args);
 #else
     template <class... _Args>
     _LIBCPP_HIDE_FROM_ABI void      emplace_front(_Args&&... __args);

 typename forward_list<_Tp, _Alloc>::reference
 #else
 void
 #endif
 forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
 {
     base::__before_begin()->__next_ = this->__create_node(/* next = */base::__before_begin()->__next_, std::forward<_Args>(__args)...);
 #if _LIBCPP_STD_VER >= 17
-    return base::__before_begin()->__next_->__value_;
+    return base::__before_begin()->__next_->__get_value();
 #endif
 }
 
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
 {
     base::__before_begin()->__next_ = this->__create_node(/* next = */base::__before_begin()->__next_, std::move(__v));

 typename forward_list<_Tp, _Alloc>::__remove_return_type
 forward_list<_Tp, _Alloc>::remove(const value_type& __v)
 {
     forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
     typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
     const iterator __e = end();
     for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
     {
-        if (__i.__get_begin()->__next_->__value_ == __v)
+        if (__i.__get_begin()->__next_->__get_value() == __v)
         {
             ++__count_removed;
             iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && *__j == __v; ++__j)
                 ++__count_removed;
             __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
             if (__j == __e)
                 break;

 typename forward_list<_Tp, _Alloc>::__remove_return_type
 forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
 {
     forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
     typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
     const iterator __e = end();
     for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
     {
-        if (__pred(__i.__get_begin()->__next_->__value_))
+        if (__pred(__i.__get_begin()->__next_->__get_value()))
         {
             ++__count_removed;
             iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && __pred(*__j); ++__j)
                 ++__count_removed;
             __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
             if (__j == __e)
                 break;

 forward_list<_Tp, _Alloc>::__merge(__node_pointer __f1, __node_pointer __f2,
                                    _Compare& __comp)
 {
     if (__f1 == nullptr)
         return __f2;
     if (__f2 == nullptr)
         return __f1;
     __node_pointer __r;
-    if (__comp(__f2->__value_, __f1->__value_))
+    if (__comp(__f2->__get_value(), __f1->__get_value()))
     {
         __node_pointer __t = __f2;
         while (__t->__next_ != nullptr &&
-                             __comp(__t->__next_->__value_, __f1->__value_))
+                             __comp(__t->__next_->__get_value(), __f1->__get_value()))
             __t = __t->__next_;
         __r = __f2;
         __f2 = __t->__next_;
         __t->__next_ = __f1;
     }
     else
         __r = __f1;
     __node_pointer __p = __f1;
     __f1 = __f1->__next_;
     while (__f1 != nullptr && __f2 != nullptr)
     {
-        if (__comp(__f2->__value_, __f1->__value_))
+        if (__comp(__f2->__get_value(), __f1->__get_value()))
         {
             __node_pointer __t = __f2;
             while (__t->__next_ != nullptr &&
-                                 __comp(__t->__next_->__value_, __f1->__value_))
+                                 __comp(__t->__next_->__get_value(), __f1->__get_value()))
                 __t = __t->__next_;
             __p->__next_ = __f2;
             __f2 = __t->__next_;
             __t->__next_ = __f1;
         }
         __p = __f1;
         __f1 = __f1->__next_;
     }
forward_list<_Tp, _Alloc>::__sort(__node_pointer __f1, difference_type __sz,
                                   _Compare& __comp)
 {
     switch (__sz)
     {
     case 0:
     case 1:
         return __f1;
     case 2:
-        if (__comp(__f1->__next_->__value_, __f1->__value_))
+        if (__comp(__f1->__next_->__get_value(), __f1->__get_value()))
         {
             __node_pointer __t = __f1->__next_;
             __t->__next_ = __f1;
             __f1->__next_ = nullptr;
             __f1 = __t;
         }
         return __f1;
     }

libcxx/include/list

 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
+#include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/container_compatible_range.h>
 #include <__ranges/from_range.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_nothrow_default_constructible.h>
 #include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/is_nothrow_move_constructible.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <cstring>
 #include <limits>
+#include <new> // __launder
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>
 #include <__iterator/empty.h>
struct __list_node_base
 
     __link_pointer __prev_;
     __link_pointer __next_;
 
     _LIBCPP_INLINE_VISIBILITY
     __list_node_base() : __prev_(_NodeTraits::__unsafe_link_pointer_cast(__self())),
                          __next_(_NodeTraits::__unsafe_link_pointer_cast(__self())) {}
 
+    _LIBCPP_HIDE_FROM_ABI explicit __list_node_base(__link_pointer __prev, __link_pointer __next)
+        : __prev_(__prev), __next_(__next) {}
+
     _LIBCPP_INLINE_VISIBILITY
     __base_pointer __self() {
         return pointer_traits<__base_pointer>::pointer_to(*this);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __node_pointer __as_node() {
         return static_cast<__node_pointer>(__self());
     }
 };
 
 template <class _Tp, class _VoidPtr>
-struct _LIBCPP_STANDALONE_DEBUG __list_node
+struct __list_node
     : public __list_node_base<_Tp, _VoidPtr>
 {
+    // We allow starting the lifetime of nodes without initializing the value held by the node,
+    // since that is handled by the list itself in order to be allocator-aware.
+#ifndef _LIBCPP_CXX03_LANG
+private:
+    union {
         _Tp __value_;
+    };
+
+public:
+    _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return __value_; }
+#else
+private:
+    _ALIGNAS_TYPE(_Tp) char __buffer_[sizeof(_Tp)];
+
+public:
+    _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() {
+        return *std::__launder(reinterpret_cast<_Tp*>(&__buffer_));
+    }
+#endif
 
     typedef __list_node_base<_Tp, _VoidPtr> __base;
     typedef typename __base::__link_pointer __link_pointer;
 
+    _LIBCPP_HIDE_FROM_ABI explicit __list_node(__link_pointer __prev, __link_pointer __next) : __base(__prev, __next) {}
+    _LIBCPP_HIDE_FROM_ABI ~__list_node() {}
+
     _LIBCPP_INLINE_VISIBILITY
     __link_pointer __as_link() {
         return static_cast<__link_pointer>(__base::__self());
     }
 };
 
 template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS list;
 template <class _Tp, class _Alloc> class __list_imp;
 template <class _Tp, class _VoidPtr> class _LIBCPP_TEMPLATE_VIS __list_const_iterator;
public:
     _LIBCPP_INLINE_VISIBILITY
     __list_iterator() _NOEXCEPT : __ptr_(nullptr)
     {
     }
 
     _LIBCPP_INLINE_VISIBILITY
     reference operator*() const
     {
-        return __ptr_->__as_node()->__value_;
+        return __ptr_->__as_node()->__get_value();
     }
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const
     {
-        return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__value_);
+        return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__get_value());
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __list_iterator& operator++()
     {
         __ptr_ = __ptr_->__next_;
         return *this;
     }
public:
     __list_const_iterator(const __list_iterator<_Tp, _VoidPtr>& __p) _NOEXCEPT
         : __ptr_(__p.__ptr_)
     {
     }
 
     _LIBCPP_INLINE_VISIBILITY
     reference operator*() const
     {
-        return __ptr_->__as_node()->__value_;
+        return __ptr_->__as_node()->__get_value();
     }
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const
     {
-        return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__value_);
+        return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__get_value());
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __list_const_iterator& operator++()
     {
         __ptr_ = __ptr_->__next_;
         return *this;
     }
void __move_assign_alloc(__list_imp& __c)
             is_nothrow_move_assignable<__node_allocator>::value)
         {__move_assign_alloc(__c, integral_constant<bool,
                       __node_alloc_traits::propagate_on_container_move_assignment::value>());}
 
     template <class ..._Args>
     _LIBCPP_HIDE_FROM_ABI __node_pointer __create_node(__link_pointer __prev, __link_pointer __next, _Args&& ...__args) {
         __node_allocator& __alloc = __node_alloc();
         __allocation_guard<__node_allocator> __guard(__alloc, 1);
-        __guard.__get()->__prev_ = __prev;
-        __guard.__get()->__next_ = __next;
-        __node_alloc_traits::construct(__alloc, std::addressof(__guard.__get()->__value_), std::forward<_Args>(__args)...);
+        // Begin the lifetime of the node itself. Note that this doesn't begin the lifetime of the value
+        // held inside the node, since we need to use the allocator's construct() method for that.
+        //
+        // We don't use the allocator's construct() method to construct the node itself since the
+        // Cpp17FooInsertable named requirements don't require the allocator's construct() method
+        // to work on anything other than the value_type.
+        std::__construct_at(std::addressof(*__guard.__get()), __prev, __next);
+
+        // Now construct the value_type using the allocator's construct() method.
+        __node_alloc_traits::construct(__alloc, std::addressof(__guard.__get()->__get_value()), std::forward<_Args>(__args)...);
         return __guard.__release_ptr();
     }
 
     template <class ..._Args>
     _LIBCPP_HIDE_FROM_ABI void __delete_node(__node_pointer __node) {
+        // For the same reason as above, we use the allocator's destroy() method for the value_type,
+        // but not for the node itself.
         __node_allocator& __alloc = __node_alloc();
-        __node_alloc_traits::destroy(__alloc, std::addressof(__node->__value_));
+        __node_alloc_traits::destroy(__alloc, std::addressof(__node->__get_value()));
+        std::__destroy_at(std::addressof(*__node));
         __node_alloc_traits::deallocate(__alloc, __node, 1);
     }
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __list_imp& __c, true_type)
         {
             if (__node_alloc() != __c.__node_alloc())
#endif
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend()   const _NOEXCEPT
         {return const_reverse_iterator(begin());}
 
     _LIBCPP_INLINE_VISIBILITY
     reference front()
     {
         _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::front called on empty list");
-        return base::__end_.__next_->__as_node()->__value_;
+        return base::__end_.__next_->__as_node()->__get_value();
     }
     _LIBCPP_INLINE_VISIBILITY
     const_reference front() const
     {
         _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::front called on empty list");
-        return base::__end_.__next_->__as_node()->__value_;
+        return base::__end_.__next_->__as_node()->__get_value();
     }
     _LIBCPP_INLINE_VISIBILITY
     reference back()
     {
         _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::back called on empty list");
-        return base::__end_.__prev_->__as_node()->__value_;
+        return base::__end_.__prev_->__as_node()->__get_value();
     }
     _LIBCPP_INLINE_VISIBILITY
     const_reference back() const
     {
         _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::back called on empty list");
-        return base::__end_.__prev_->__as_node()->__value_;
+        return base::__end_.__prev_->__as_node()->__get_value();
     }
 
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __x);
     _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __x);
 
 #if _LIBCPP_STD_VER >= 23
     template <_ContainerCompatibleRange<_Tp> _Range>
#endif
     _LIBCPP_INLINE_VISIBILITY
     void sort();
     template <class _Comp>
         _LIBCPP_INLINE_VISIBILITY
         void sort(_Comp __comp);
 
     _LIBCPP_HIDE_FROM_ABI void reverse() _NOEXCEPT;
 
     _LIBCPP_HIDE_FROM_ABI bool __invariants() const;
 
 private:
     template <class _Iterator, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI
     void __assign_with_sentinel(_Iterator __f, _Sentinel __l);
 
     template <class _Iterator, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI

 #endif
 list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
 {
     __node_pointer __node = this->__create_node(/* prev = */nullptr, /* next = */nullptr, std::forward<_Args>(__args)...);
     __link_pointer __nl = __node->__as_link();
     __link_nodes_at_front(__nl, __nl);
     ++base::__sz();
 #if _LIBCPP_STD_VER >= 17
-    return __node->__value_;
+    return __node->__get_value();
 #endif
 }
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
 #if _LIBCPP_STD_VER >= 17
 typename list<_Tp, _Alloc>::reference
 #else
 void
 #endif
 list<_Tp, _Alloc>::emplace_back(_Args&&... __args)
 {
     __node_pointer __node = this->__create_node(/* prev = */nullptr, /* next = */nullptr, std::forward<_Args>(__args)...);
     __link_pointer __nl = __node->__as_link();
     __link_nodes_at_back(__nl, __nl);
     ++base::__sz();
 #if _LIBCPP_STD_VER >= 17
-    return __node->__value_;
+    return __node->__get_value();
 #endif
 }
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args)
 {

libcxx/include/unordered_map

__hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
             const_cast<bool&>(__x.__value_constructed) = false;
         }
 #endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     void operator()(pointer __p) _NOEXCEPT
     {
         if (__second_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__get_value().__get_value().second));
         if (__first_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__get_value().__get_value().first));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
 };
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Key, class _Tp>
 struct _LIBCPP_STANDALONE_DEBUG __hash_value_type
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
         unordered_map&& __u, const allocator_type& __a)
     : __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a))
 {
     if (__a != __u.get_allocator())
     {
         iterator __i = __u.begin();
         while (__u.size() != 0) {
             __table_.__emplace_unique(
-                __u.__table_.remove((__i++).__i_)->__value_.__move());
+                __u.__table_.remove((__i++).__i_)->__get_value().__move());
         }
     }
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
         initializer_list<value_type> __il)
 {

 #else // _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const key_type& __k)
 {
     __node_allocator& __na = __table_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().first), __k);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__get_value().__get_value().first), __k);
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().second));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__get_value().__get_value().second));
     __h.get_deleter().__second_constructed = true;
     return __h;
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 _Tp&
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
 {
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
     : __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a))
 {
     if (__a != __u.get_allocator())
     {
         iterator __i = __u.begin();
         while (__u.size() != 0)
         {
             __table_.__insert_multi(
-                __u.__table_.remove((__i++).__i_)->__value_.__move());
+                __u.__table_.remove((__i++).__i_)->__get_value().__move());
         }
     }
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
         initializer_list<value_type> __il)
 {

libcxx/include/unordered_set

 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
         unordered_set&& __u, const allocator_type& __a)
     : __table_(_VSTD::move(__u.__table_), __a)
 {
     if (__a != __u.get_allocator())
     {
         iterator __i = __u.begin();
         while (__u.size() != 0)
-            __table_.__insert_unique(_VSTD::move(__u.__table_.remove(__i++)->__value_));
+            __table_.__insert_unique(_VSTD::move(__u.__table_.remove(__i++)->__get_value()));
     }
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
         initializer_list<value_type> __il)
 {
     insert(__il.begin(), __il.end());

 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
         unordered_multiset&& __u, const allocator_type& __a)
     : __table_(_VSTD::move(__u.__table_), __a)
 {
     if (__a != __u.get_allocator())
     {
         iterator __i = __u.begin();
         while (__u.size() != 0)
-            __table_.__insert_multi(_VSTD::move(__u.__table_.remove(__i++)->__value_));
+            __table_.__insert_multi(_VSTD::move(__u.__table_.remove(__i++)->__get_value()));
     }
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
         initializer_list<value_type> __il)
 {
     insert(__il.begin(), __il.end());