[libcxx] Implement P0883R2 ("Fixing Atomic Initialization")

[• Quuxplusone]

LGTM % comments, but several comments are major.

libcxx/docs/Cxx2aStatusPaperStatus.csv

136

You also need to change the value of __cpp_lib_atomic_value_initialization and re-run libcxx/utils/generate_feature_test_macro_components.py.

Also, p0883r2 asks to deprecate atomic_init. That could easily be a separate PR, but I don't think we should mark p0883 "Complete" until that's complete.
http://eel.is/c++draft/depr.atomics.general

(p0883 is also supposed to affect atomic<shared_ptr<T>> and atomic<weak_ptr<T>>, but libc++ does not implement those specializations (yet). So I think that part is OK.)

libcxx/include/atomic

205–207

Nit: IMHO you could/should make this

atomic() noexcept;  // constexpr since C++20

and likewise below. (I'm guessing this one should say "C++20" like the others, too.)
But I do see that C++20 dropped the =default, and maybe that's significant enough to call out in the synopsis (but IMHO it's not).

1679

> 17. (C++2b behaves more like 23 than like 20. We don't actually expect to see e.g. 18 here anymore, but if we did, it'd mean C++2a, which should behave more like 20 than like 17. This is a general libc++ style no matter which three-year cycle we're talking about.)

1714

Personally I'd prefer to see __base() here. The Standard says T() not T{}:
http://eel.is/c++draft/atomics.types.operations#2
In fact, don't they have visibly different effects when T is struct A { int i; A() = default; }? Or is that different in C++20 because aggregate init, and/or different everywhere now due to some DR? I'm having trouble demonstrating the issue on Godbolt: https://godbolt.org/z/o5aY7E3Eb
I can demonstrate that A a; and auto a = A(); have different behavior (but I don't actually understand why): https://godbolt.org/z/3r75zG8Ms

Ditto below (line 1804 and anywhere I missed).

libcxx/test/std/atomics/atomics.types.generic/constexpr_noexcept.pass.cpp

29–32 ↗

(On Diff #350116)

static_assert(test<std::atomic<int>>()); etc., and make the constexpr function test end with return true;. This way you make sure it's actually happening at compile time.
Also please test test<std::atomic<bool>>(), since it looks like it gets a different specialization?
Also nit: > > is a C++03-ism, and we can use >> here.

Also, doesn't the constructor of throwing need a body? How does this link?

[tambre]

Address review comments

[tambre]

Thanks for the lightning fast review!

libcxx/docs/Cxx2aStatusPaperStatus.csv

136

You also need to change the value of __cpp_lib_atomic_value_initialization and re-run libcxx/utils/generate_feature_test_macro_components.py.

Added.

Also, p0883r2 asks to deprecate atomic_init. That could easily be a separate PR, but I don't think we should mark p0883 "Complete" until that's complete.
http://eel.is/c++draft/depr.atomics.general

Commit 06aaf0b3431f29b6debbb96fdd92ada896f336ff adjusted the synopsis "to match what is implemented" so I assumed that part was considered done.
The required change seems to be simply adding _LIBCPP_DEPRECATED_IN_CXX20 so I don't think it's worthy of a separate change. I've added it here.

libcxx/include/atomic

205–207

Done.

1679

Done. Thanks for the background on why it should be used like that.

1714

Changed to the parentheses variant.
T() and T{} are equivalent since they're both variants of value initialization.
T(args) and T{args} (direct initialization) should be equivalent for aggregates since C++20 as a result of P0960R3 (except in case of narrowing).

I can demonstrate that A a; and auto a = A(); have different behavior (but I don't actually understand why): https://godbolt.org/z/3r75zG8Ms

I'm not sure either. P1008R1 did change this to not be aggregate initialization when using {}.

1714

Personally I'd prefer to see __base() here. The Standard says T() not T{}:
http://eel.is/c++draft/atomics.types.operations#2
In fact, don't they have visibly different effects when T is struct A { int i; A() = default; }? Or is that different in C++20 because aggregate init, and/or different everywhere now due to some DR? I'm having trouble demonstrating the issue on Godbolt: https://godbolt.org/z/o5aY7E3Eb
I can demonstrate that A a; and auto a = A(); have different behavior (but I don't actually understand why): https://godbolt.org/z/3r75zG8Ms

Ditto below (line 1804 and anywhere I missed).

libcxx/test/std/atomics/atomics.types.generic/constexpr_noexcept.pass.cpp

29–32 ↗

(On Diff #350116)

static_assert(test<std::atomic<int>>()); etc., and make the constexpr function test end with return true;. This way you make sure it's actually happening at compile time.

Done.

Also please test test<std::atomic<bool>>(), since it looks like it gets a different specialization?

I think this should be covered by the trivial variant since the general case is used if "integral and not bool", but I've added it.

Also nit: > > is a C++03-ism, and we can use >> here.

Fixed. I trusted clang-format here. This is probably the result of Standard: Cpp03 in libcxx's .clang-format. Had to use --nolint for arc diff.

Also, doesn't the constructor of throwing need a body? How does this link?

Not sure, I've added an empty body. is_nothrow_constructible.pass.cpp similarly has many functions without bodies.

[tambre]

Fix a missed case of parentheses

[• Quuxplusone]

libcxx/docs/Cxx2aStatusPaperStatus.csv

136

The required change seems to be simply adding _LIBCPP_DEPRECATED_IN_CXX20

Code change LGTM. We usually want to see a "deprecation warning test" added as well; I think you should add a libcxx/test/libcxx/depr/depr.atomics.general/atomic_init.depr_in_cxx20.verify.cpp along the same lines as libcxx/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.verify.cpp. (My impression is that we're not very consistent about these tests, so I suggest copying-and-modifying adaptors.depr_in_cxx11.verify.cpp in the obvious way, but if @ldionne asks for some other testing strategy, you should listen to him not me.)

libcxx/include/atomic

205–207

Nit: I think the leading constexpr should be dropped:

atomic() noexcept;  // constexpr since C++20

but if anyone disagrees, I don't care that much. These synopses are all pretty ad-hoc. :)

1714

Bah, I missed the first time around that this is initializing __atomic_base<_Tp, false> __base, not _Tp __a_, anyway! The important parens-not-braces is on line 1679; I now agree it definitely doesn't matter which one we use here. Can't we eliminate this member-initializer entirely, because __atomic_base<_Tp, false>'s default ctor (line 1679) will do the right thing? I think the whole #if can be removed, and all you need to change here is to add _LIBCPP_CONSTEXPR_AFTER_CXX17:

_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
__atomic_base() _NOEXCEPT _LIBCPP_DEFAULT

Ditto lines 1800, 1832.

2558

Since __a_ is not literally bool, I would feel slightly safer if this explicitly said __a_(false); compare line 2573. Sorry for not noticing this the first time around.

libcxx/test/std/atomics/atomics.types.generic/constexpr_noexcept.pass.cpp

29–32 ↗

(On Diff #350116)

Ah, I get it now: you instantiate test<std::atomic<trivial>> but not test<std::atomic<throwing>>. Instantiating test<std::atomic<throwing>> would require a body for trivial's constructor.

[Mordante]

Thanks for working this. (Actually I was considering to look at it, but happy I didn't start ;-))
Can you investigate the CI errors that are introduced with this patch?

libcxx/docs/Cxx2aStatusPaperStatus.csv

136

Can you add a note that floating-point and shared_ptr aren't done yet?

libcxx/include/atomic

205–207

But I do see that C++20 dropped the =default, and maybe that's significant enough to call out in the synopsis (but IMHO it's not).

I think it would be better to show the difference. (Actually I already wrote a comment about it, only to discover these remarks were a line below.)

514–515

Likewise I prefer an until and since version.

1799

Since this code is version guarded you can use constexpr and noexcept directly.

2558

Can you update the test test/std/atomics/atomics.flag/default.pass.cpp to validate the new behaviour?

libcxx/test/std/atomics/atomics.types.generic/constexpr_noexcept.pass.cpp

29 ↗

(On Diff #350227)

Since the test is compile-time only there's no need for a run-time check. Can you make the following changes

• rename the file to constexpr_noexcept.compile.pass.cpp
• int main() -> void test()
• Add the following two lines at the end:

// Required for MSVC internal test runner compatibility.
int main(int, char**) { return 0; }

30 ↗

(On Diff #350227)

We typically use the macros ASSERT_NOEXCEPT and ASSERT_NOT_NOEXCEPT from "test_macros.h".

[• Quuxplusone]

libcxx/test/std/atomics/atomics.types.generic/constexpr_noexcept.pass.cpp

29 ↗

(On Diff #350227)

I'm in agreement on the first two bullet points, but on the third point, I believe we have an unwritten policy that .compile.pass.cpp tests specifically must not contain int main, because otherwise there's a hazard that people will unwittingly add code to main expecting it to run. We have lots of .compile.pass.cpp tests these days that don't contain a main:

$ find libcxx/test -name \*.compile.pass.cpp | xargs grep -l main | wc -l
      31
$ find libcxx/test -name \*.compile.pass.cpp | xargs grep -L main | wc -l
     185

[tambre]

Address review comments

[tambre]

libcxx/docs/Cxx2aStatusPaperStatus.csv

136

Added note that shared_ptr and floating-point changes haven't been applied as they themselves aren't implemented yet.
Added the deprecation test, but in the std directory as I don't think this should be a libc++-specific test.

libcxx/include/atomic

205–207

Nit: I think the leading constexpr should be dropped:

I took the leading constexpr by example from <numerics> synopsis.
But I've now returned this to be separate as it was originally.

205–207

Nit: I think the leading constexpr should be dropped:

atomic() noexcept;  // constexpr since C++20

but if anyone disagrees, I don't care that much. These synopses are all pretty ad-hoc. :)

1714

Good idea, done.

2558

Good catch, the false is necessary due to the indirection through __cxx_atomic_impl. The rest weren't actually getting properly initialized either. Should be implemented correctly now.
Adjusted the test.

Can you update the test test/std/atomics/atomics.flag/default.pass.cpp to validate the new behaviour?

I'm afraid not, it's already testing the behaviour required by P0883, i.e. that the underlying storage is zeroed on creation.

2558

Can you update the test test/std/atomics/atomics.flag/default.pass.cpp to validate the new behaviour?

libcxx/test/libcxx/atomics/atomics.align/align.pass.cpp

11

Since we're now initializing we otherwise get:

In file included from /opt/deb/llvm/libcxx/test/libcxx/atomics/atomics.align/align.pass.pass.cpp:25:
/opt/deb/llvm/build/include/c++/v1/atomic:1681:33: error: AVX vector argument of type '__attribute__((__vector_size__(16 * sizeof(int)))) int' (vector of 16 'int' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    __atomic_base() _NOEXCEPT : __a_(_Tp()) {}
                                ^
/opt/deb/llvm/build/include/c++/v1/atomic:1500:7: error: AVX vector argument of type '__attribute__((__vector_size__(16 * sizeof(int)))) int' (vector of 16 'int' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    : _Base(value) {}
      ^
/opt/deb/llvm/build/include/c++/v1/atomic:1681:33: error: AVX vector argument of type '__attribute__((__vector_size__(32 * sizeof(int)))) int' (vector of 32 'int' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    __atomic_base() _NOEXCEPT : __a_(_Tp()) {}
                                ^
/opt/deb/llvm/build/include/c++/v1/atomic:1500:7: error: AVX vector argument of type '__attribute__((__vector_size__(32 * sizeof(int)))) int' (vector of 32 'int' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    : _Base(value) {}
      ^
/opt/deb/llvm/build/include/c++/v1/atomic:1681:33: error: AVX vector argument of type '__attribute__((__vector_size__(16 * sizeof(float)))) float' (vector of 16 'float' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    __atomic_base() _NOEXCEPT : __a_(_Tp()) {}
                                ^
/opt/deb/llvm/build/include/c++/v1/atomic:1500:7: error: AVX vector argument of type '__attribute__((__vector_size__(16 * sizeof(float)))) float' (vector of 16 'float' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    : _Base(value) {}
      ^
/opt/deb/llvm/build/include/c++/v1/atomic:1681:33: error: AVX vector argument of type '__attribute__((__vector_size__(32 * sizeof(float)))) float' (vector of 32 'float' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    __atomic_base() _NOEXCEPT : __a_(_Tp()) {}
                                ^
/opt/deb/llvm/build/include/c++/v1/atomic:1500:7: error: AVX vector argument of type '__attribute__((__vector_size__(32 * sizeof(float)))) float' (vector of 32 'float' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    : _Base(value) {}
      ^
/opt/deb/llvm/build/include/c++/v1/atomic:1681:33: error: AVX vector argument of type '__attribute__((__vector_size__(4 * sizeof(double)))) double' (vector of 4 'double' values) without 'avx' enabled changes the ABI [-Werror,-Wpsabi]
    __atomic_base() _NOEXCEPT : __a_(_Tp()) {}
                                ^
/opt/deb/llvm/build/include/c++/v1/atomic:1500:7: error: AVX vector argument of type '__attribute__((__vector_size__(4 * sizeof(double)))) double' (vector of 4 'double' values) without 'avx' enabled changes the ABI [-Werror,-Wpsabi]
    : _Base(value) {}
      ^
/opt/deb/llvm/build/include/c++/v1/atomic:1681:33: error: AVX vector argument of type '__attribute__((__vector_size__(16 * sizeof(double)))) double' (vector of 16 'double' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    __atomic_base() _NOEXCEPT : __a_(_Tp()) {}
                                ^
/opt/deb/llvm/build/include/c++/v1/atomic:1500:7: error: AVX vector argument of type '__attribute__((__vector_size__(16 * sizeof(double)))) double' (vector of 16 'double' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    : _Base(value) {}
      ^
/opt/deb/llvm/build/include/c++/v1/atomic:1681:33: error: AVX vector argument of type '__attribute__((__vector_size__(32 * sizeof(double)))) double' (vector of 32 'double' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    __atomic_base() _NOEXCEPT : __a_(_Tp()) {}
                                ^
/opt/deb/llvm/build/include/c++/v1/atomic:1500:7: error: AVX vector argument of type '__attribute__((__vector_size__(32 * sizeof(double)))) double' (vector of 32 'double' values) without 'avx512f' enabled changes the ABI [-Werror,-Wpsabi]
    : _Base(value) {}
      ^

[• Quuxplusone]

I did not realize this was going to be such a rabbit hole. :P But I think at least we're making forward progress in each round.

libcxx/include/atomic

205–207

Ack, LGTM.

1797–1803

I recommend replacing lines 1797-1803 with

#if _LIBCPP_STD_VER > 17
    _LIBCPP_INLINE_VISIBILITY
    atomic()  = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic() _NOEXCEPT _LIBCPP_DEFAULT
#endif

And then, please add a new test case:

struct Throwing { Throwing() { throw 42; } };
int main(int, char**) {
    try {
        std::atomic<Throwing> a;
        (void)a;
        assert(false);
    } catch (int x) {
        assert(x == 42);
    }
    return 0;
}

I believe that this test case will fail with your current PR, because you incorrectly mark __atomic_base's constructor as unconditionally noexcept. Try to use noexcept/_NOEXCEPT as sparingly as possible — let the compiler infer it for you whenever possible, a la the Rule of Zero. By defaulting our constructor here, we get "noexcept auto" semantics: the compiler will infer noexcept exactly when it's appropriate (and then we just have to write tests to verify that the compiler is getting it right). Ditto for "constexpr auto" semantics: just write =default (or follow the Rule of Zero) and the compiler will sort it out for you.

libcxx/test/libcxx/atomics/atomics.align/align.pass.cpp

11

I suspect (from git grep psabi libcxx/ and git log libcxx/ | grep psabi) that this is not the appropriate solution to whatever the problem is here. However, grep vector_size libcxx/ didn't turn up anything likely-looking either.
I think it's now important to figure out whether this PR is actually ABI-breaking in some way.

libcxx/test/std/atomics/atomics.types.generic/address.pass.cpp

9–10

I know line 10 is a pre-existing comment, but it makes no sense to me. Looks like 5 comments just like this were added by @jroelofs in b3fcc67f8f13cd95d36ed29d0ae1308decb9e099 (D3969) back in 2014. I propose that someone should delete these comments. Could even be in this PR, since you are having to touch all 5 of these test files already.

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp

33–34

Rather than disable the deprecation warning, could we just rewrite this as

A t(T(1));
~~~
volatile A vt(T(3));

and likewise in the other affected files? The point of these tests doesn't seem related to atomic_init; it seems like whoever wrote them was just using atomic_init incidentally to set up the inputs for the actual test of atomic_exchange or whatever.

[jroelofs]

libcxx/test/std/atomics/atomics.types.generic/address.pass.cpp

9–10

Now I'm kicking myself for not having filed bugzilla's for them. Oops.

[tambre]

Address review comments

[tambre]

Thanks for the continued reviewing and sorry for the delay.

libcxx/include/atomic

1797–1803

Good catch and thanks for the tips!

libcxx/test/libcxx/atomics/atomics.align/align.pass.cpp

11

I think the reason is the ABI for passing a default-initialized T for the vector types to __cxx_atomic_impl ends up different depending whether using architecture extensions or not.
Maybe could this be an issue when linking a static library with one using a different set of extensions compared to the other? Otherwise I'm not sure how one could end up compiling __cxx_atomic_impl with different architecture extensions than __atomic_base and using them together.

Note having the constructor as atomic_test() : std__atomic_base<T>(T()) before would've given the same warning before.

PS. I renamed remove the double pass in the filename.

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp

33–34

Good idea. I actually thought about this, but disregarded it because I for some reason thought initializing with a value is a libc++ extension, but that's only for std::atomic_flag.

[• Quuxplusone]

LGTM % comments at this point; but before landing it please

• wait for a second OK from the "libc++" reviewer
• make sure CI is green

libcxx/test/libcxx/atomics/atomics.align/align.pass.cpp

53–54

Please leave the original indentation here, and also on line 38 above, and also on all the lines below this one.
If you're doing this because clang-format recommended it, please ignore clang-format.
It looks to me like the only diff that should be in this file is just adding -Wno-psabi on line 11 and all these other diffs are bogus, right?

libcxx/test/std/atomics/atomics.types.generic/bool.pass.cpp

165–215

FWIW, one could actually replace these 50 lines with

static_assert(std::is_same<std::atomic_bool, std::atomic<bool> >::value, "");

You don't have to do that in this PR, but I wouldn't fault you if you did. :)

libcxx/test/std/atomics/atomics.types.generic/throw.pass.cpp

30

Nice!
Nit: please make main's signature int main(int, char**) and add return 0; at the end. We do this on all mains, for some reason related to testing on embedded platforms.

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp

74–78

Attn: @Mordante! These bogusly-template-argumented calls are relevant to D103983, right?

(This diff LGTM. Just cross-referencing it with @Mordante's PR, which will merge-conflict with it.)

These tests are utterly bogus, btw. Basically what they're doing is initializing an atomic<int*> with (int*)(4), and then fetch_add'ing 2 to it, and then asserting that the result is (int*)(12). This is entirely UB. They should be rewritten to use an array of T or something. But that's out of scope for this PR.

[tambre]

Address review comments

[tambre]

In D103769#2820085, @Quuxplusone wrote:

LGTM % comments at this point; but before landing it please

• wait for a second OK from the "libc++" reviewer
• make sure CI is green

Thanks again for the reviews. I will wait for a second OK.

libcxx/test/libcxx/atomics/atomics.align/align.pass.cpp

11

I tried replicating the potential ABI breakage, but only managed to get identical binaries.

I'm fairly confident the only real effects are:

• Users compiling without vector extensions will now get a warning and will have an ABI mismatch if using in translation units with differing vector extensions. Only a potential ABI issue if re-compiled.
• Translation units with differing vector extensions and where one of them used libc++ internals to do what we do now (initialize std::__cxx_atomic_impl). They would've gotten the warning before for the initialization, and will also now get it in the translation unit where they didn't initialize.

53–54

It looks to me like the only diff that should be in this file is just adding -Wno-psabi on line 11 and all these other diffs are bogus, right?

Correct, done. Would be nice if someone either ran clang-format on the codebase or the configuration better matched the actual mandated style.

libcxx/test/std/atomics/atomics.types.generic/bool.pass.cpp

165–215

I'll do that separately.

[Mordante]

LGTM, but there's one comment not addressed yet. Please fix that before landing the patch.

libcxx/test/libcxx/atomics/atomics.align/align.pass.cpp

53–54

The problem is the version of clang-format used can't properly format the entire code base. In C++03 mode it breaks C++20 and in C++20 mode it breaks C++03. Probably we can use clang-format on our codebase once we use clang-format 13.

libcxx/test/std/atomics/atomics.types.generic/throw.pass.cpp

30

This comment hasn't been addressed yet.

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp

74–78

Correct this is what I'm fixing in D103983.

[tambre]

Update deprecation test to not use main() since it doesn't need to be run

[tambre]

libcxx/test/std/atomics/atomics.types.generic/throw.pass.cpp

30

I do seem to have addressed this. Am I missing something?
I've now updated the deprecation test to not use main() since it doesn't need to be run in case if that's what you meant.

libcxx/docs/Cxx2aStatus.rst

.. csv-table::
    :file: Cxx2aStatusPaperStatus.csv
    :header-rows: 1
    :widths: auto
 
 .. note::
 
    .. [#note-P0600] P0600: The missing bits in P0600 are in |sect|\ [mem.res.class], |sect|\ [mem.poly.allocator.class], and |sect|\ [container.node.overview].
    .. [#note-P0966] P0966: It was previously erroneously marked as complete in version 8.0. See `bug 45368 <https://llvm.org/PR45368>`__.
-
    .. [#note-P0619] P0619: Only sections D.9 and D.10 are implemented. Section D.8 is partly implemented. Sections D.4, D.7, D.11, D.12, and D.14 remain undone.
+   .. [#note-P0883] P0883: shared_ptr and floating-point changes weren't applied as they themselves aren't implemented yet.
 
 
 .. _issues-status-cxx2a:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx2aStatusIssuesStatus.csv
    :header-rows: 1
    :widths: auto
 
 Last Updated: 24-May-2021

libcxx/docs/Cxx2aStatusPaperStatus.csv

 "`P1643 <https://wg21.link/P1643>`__","LWG","Add wait/notify to atomic_ref","Cologne","",""
 "`P1644 <https://wg21.link/P1644>`__","LWG","Add wait/notify to atomic<shared_ptr>","Cologne","",""
 "`P1650 <https://wg21.link/P1650>`__","LWG","Output std::chrono::days with 'd' suffix","Cologne","",""
 "`P1651 <https://wg21.link/P1651>`__","LWG","bind_front should not unwrap reference_wrapper","Cologne","|Complete|","13.0"
 "`P1652 <https://wg21.link/P1652>`__","LWG","Printf corner cases in std::format","Cologne","",""
 "`P1661 <https://wg21.link/P1661>`__","LWG","Remove dedicated precalculated hash lookup interface","Cologne","|Nothing To Do|",""
 "`P1754 <https://wg21.link/P1754>`__","LWG","Rename concepts to standard_case for C++20, while we still can","Cologne","|In Progress|",""
 "","","","","",""
-"`P0883 <https://wg21.link/P0883>`__","LWG","Fixing Atomic Initialization","Belfast","* *",""
+"`P0883 <https://wg21.link/P0883>`__","LWG","Fixing Atomic Initialization","Belfast","|Complete| [#note-P0883]","13.0"
 "`P1391 <https://wg21.link/P1391>`__","LWG","Range constructor for std::string_view","Belfast","* *",""
 "`P1394 <https://wg21.link/P1394>`__","LWG","Range constructor for std::span","Belfast","* *",""
 "`P1456 <https://wg21.link/P1456>`__","LWG","Move-only views","Belfast","* *",""
 "`P1622 <https://wg21.link/P1622>`__","LWG","Mandating the Standard Library: Clause 32 - Thread support library","Belfast","* *",""
 "`P1645 <https://wg21.link/P1645>`__","LWG","constexpr for numeric algorithms","Belfast","|Complete|","12.0"
 "`P1664 <https://wg21.link/P1664>`__","LWG","reconstructible_range - a concept for putting ranges back together","Belfast","* *",""
 "`P1686 <https://wg21.link/P1686>`__","LWG","Mandating the Standard Library: Clause 27 - Time library","Belfast","* *",""
 "`P1690 <https://wg21.link/P1690>`__","LWG","Refinement Proposal for P0919 Heterogeneous lookup for unordered containers","Belfast","|Complete|","12.0"

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_atomic_float``                        *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_lock_free_type_aliases``       ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_ref``                          *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_shared_ptr``                   *unimplemented*
     ------------------------------------------------- -----------------
-    ``__cpp_lib_atomic_value_initialization``         *unimplemented*
+    ``__cpp_lib_atomic_value_initialization``         ``201911L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_wait``                         ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_barrier``                             ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_bind_front``                          ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_bit_cast``                            *unimplemented*

libcxx/include/atomic

 struct atomic
 {
     using value_type = T;
 
     static constexpr bool is_always_lock_free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
 
-    atomic() noexcept = default;
+    atomic() noexcept = default; // until C++20
+    constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>); // since C++20
     constexpr atomic(T desr) noexcept;
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
 
     T load(memory_order m = memory_order_seq_cst) const volatile noexcept;
     T load(memory_order m = memory_order_seq_cst) const noexcept;
     operator T() const volatile noexcept;

 {
     using value_type = T*;
     using difference_type = ptrdiff_t;
 
     static constexpr bool is_always_lock_free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
 
-    atomic() noexcept = default;
+    atomic() noexcept = default; // until C++20
+    constexpr atomic() noexcept; // since C++20
     constexpr atomic(T* desr) noexcept;
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
 
     T* load(memory_order m = memory_order_seq_cst) const volatile noexcept;
     T* load(memory_order m = memory_order_seq_cst) const noexcept;
     operator T*() const volatile noexcept;
     operator T*() const noexcept;

 typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
 typedef atomic<intmax_t>  atomic_intmax_t;
 typedef atomic<uintmax_t> atomic_uintmax_t;
 
 // flag type and operations
 
 typedef struct atomic_flag
 {
-    atomic_flag() noexcept = default;
+    atomic_flag() noexcept = default; // until C++20
+    constexpr atomic_flag() noexcept; // since C++20
     atomic_flag(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) volatile = delete;
 
     bool test(memory_order m = memory_order_seq_cst) volatile noexcept;
     bool test(memory_order m = memory_order_seq_cst) noexcept;
     bool test_and_set(memory_order m = memory_order_seq_cst) volatile noexcept;
     bool test_and_set(memory_order m = memory_order_seq_cst) noexcept;
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_one() volatile _NOEXCEPT
         {__cxx_atomic_notify_one(&__a_);}
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_one() _NOEXCEPT
         {__cxx_atomic_notify_one(&__a_);}
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_all() volatile _NOEXCEPT
         {__cxx_atomic_notify_all(&__a_);}
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_all() _NOEXCEPT
         {__cxx_atomic_notify_all(&__a_);}
 
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY constexpr
+    __atomic_base() noexcept(is_nothrow_default_constructible_v<_Tp>) : __a_(_Tp()) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     __atomic_base() _NOEXCEPT _LIBCPP_DEFAULT
+#endif
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {}
 
 #ifndef _LIBCPP_CXX03_LANG
     __atomic_base(const __atomic_base&) = delete;
 #else
 private:

 
 // atomic<Integral>
 
 template <class _Tp>
 struct __atomic_base<_Tp, true>
     : public __atomic_base<_Tp, false>
 {
     typedef __atomic_base<_Tp, false> __base;
-    _LIBCPP_INLINE_VISIBILITY
+
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     __atomic_base() _NOEXCEPT _LIBCPP_DEFAULT
+
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {}
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
         {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT

 
 template <class _Tp>
 struct atomic
     : public __atomic_base<_Tp>
 {
     typedef __atomic_base<_Tp> __base;
     typedef _Tp value_type;
     typedef value_type difference_type;
+
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY
+    atomic() = default;
+#else
     _LIBCPP_INLINE_VISIBILITY
     atomic() _NOEXCEPT _LIBCPP_DEFAULT
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {}
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator=(_Tp __d) volatile _NOEXCEPT
         {__base::store(__d); return __d;}
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator=(_Tp __d) _NOEXCEPT
         {__base::store(__d); return __d;}
 
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
 };
 
 // atomic<T*>
 
 template <class _Tp>
 struct atomic<_Tp*>
     : public __atomic_base<_Tp*>
 {
     typedef __atomic_base<_Tp*> __base;
     typedef _Tp* value_type;
     typedef ptrdiff_t difference_type;
+
     _LIBCPP_INLINE_VISIBILITY
     atomic() _NOEXCEPT _LIBCPP_DEFAULT
+
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR atomic(_Tp* __d) _NOEXCEPT : __base(__d) {}
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp* operator=(_Tp* __d) volatile _NOEXCEPT
         {__base::store(__d); return __d;}
     _LIBCPP_INLINE_VISIBILITY
     _Tp* operator=(_Tp* __d) _NOEXCEPT

 atomic_is_lock_free(const atomic<_Tp>* __o) _NOEXCEPT
 {
     return __o->is_lock_free();
 }
 
 // atomic_init
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY
 void
 atomic_init(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     __cxx_atomic_init(&__o->__a_, __d);
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY
 void
 atomic_init(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     __cxx_atomic_init(&__o->__a_, __d);
 }
 
 // atomic_store
 
void notify_one() _NOEXCEPT
         {__cxx_atomic_notify_one(&__a_);}
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void notify_all() volatile _NOEXCEPT
         {__cxx_atomic_notify_all(&__a_);}
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void notify_all() _NOEXCEPT
         {__cxx_atomic_notify_all(&__a_);}
 
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY constexpr
+    atomic_flag() _NOEXCEPT : __a_(false) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     atomic_flag() _NOEXCEPT _LIBCPP_DEFAULT
+#endif
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} // EXTENSION
 
 #ifndef _LIBCPP_CXX03_LANG
     atomic_flag(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) volatile = delete;

libcxx/include/version

 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS)
 // #   define __cpp_lib_atomic_ref                         201806L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS)
 // #   define __cpp_lib_atomic_shared_ptr                  201711L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS)
-// #   define __cpp_lib_atomic_value_initialization        201911L
+#   define __cpp_lib_atomic_value_initialization        201911L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
 #   define __cpp_lib_atomic_wait                        201907L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)
 #   define __cpp_lib_barrier                            201907L
 # endif
 # define __cpp_lib_bind_front                           201907L

libcxx/test/libcxx/atomics/atomics.align/align.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads, c++03
 // REQUIRES: is-lockfree-runtime-function
+// ADDITIONAL_COMPILE_FLAGS: -Wno-psabi
+// ... since C++20 std::__atomic_base initializes, so we get a warning about an
+// ABI change for vector variants since the constructor code for that is
+// different if one were to compile with architecture-specific vector
+// extensions enabled.
+// This however isn't ABI breaking as it was impossible for any code to trigger
+// this without using libc++ internals.
 
 // GCC currently fails because it needs -fabi-version=6 to fix mangling of
 // std::atomic when used with __attribute__((vector(X))).
 // XFAIL: gcc
 
 // <atomic>
 
 // Verify that the content of atomic<T> is properly aligned if the type is

 
 int main(int, char**) {
 
 // structs and unions can't be defined in the template invocation.
 // Work around this with a typedef.
 #define CHECK_ALIGNMENT(T)                                                     \
   do {                                                                         \
     typedef T type;                                                            \
     atomic_test<type> t;                                                       \
   } while (0)
 
   CHECK_ALIGNMENT(bool);
   CHECK_ALIGNMENT(char);
   CHECK_ALIGNMENT(signed char);
   CHECK_ALIGNMENT(unsigned char);
   CHECK_ALIGNMENT(char16_t);
   CHECK_ALIGNMENT(char32_t);
   CHECK_ALIGNMENT(wchar_t);

libcxx/test/std/atomics/atomics.types.generic/address.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-//  ... test case crashes clang.
 
 // <atomic>
 
 // template <class T>
 // struct atomic<T*>
 // {
 //     bool is_lock_free() const volatile;
 //     bool is_lock_free() const;
 //     void store(T* desr, memory_order m = memory_order_seq_cst) volatile;

 #include "test_macros.h"
 
 template <class A, class T>
 void
 do_test()
 {
     typedef typename std::remove_pointer<T>::type X;
     A obj(T(0));
+    assert(obj == T(0));
     bool b0 = obj.is_lock_free();
     ((void)b0); // mark as unused
-    assert(obj == T(0));
-    std::atomic_init(&obj, T(1));
-    assert(obj == T(1));
-    std::atomic_init(&obj, T(2));
-    assert(obj == T(2));
     obj.store(T(0));
     assert(obj == T(0));
     obj.store(T(1), std::memory_order_release);
     assert(obj == T(1));
     assert(obj.load() == T(1));
     assert(obj.load(std::memory_order_acquire) == T(1));
     assert(obj.exchange(T(2)) == T(1));
     assert(obj == T(2));

libcxx/test/std/atomics/atomics.types.generic/bool.pass.cpp

 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         volatile std::atomic<bool> obj(true);
         assert(obj == true);
-        std::atomic_init(&obj, false);
-        assert(obj == false);
-        std::atomic_init(&obj, true);
-        assert(obj == true);
         bool b0 = obj.is_lock_free();
         (void)b0; // to placate scan-build
         obj.store(false);
         assert(obj == false);
         obj.store(true, std::memory_order_release);
         assert(obj == true);
         assert(obj.load() == true);
         assert(obj.load(std::memory_order_acquire) == true);
int main(int, char**)
         assert((obj = false) == false);
         assert(obj == false);
         assert((obj = true) == true);
         assert(obj == true);
     }
     {
         std::atomic<bool> obj(true);
         assert(obj == true);
-        std::atomic_init(&obj, false);
-        assert(obj == false);
-        std::atomic_init(&obj, true);
-        assert(obj == true);
         bool b0 = obj.is_lock_free();
         (void)b0; // to placate scan-build
         obj.store(false);
         assert(obj == false);
         obj.store(true, std::memory_order_release);
         assert(obj == true);
         assert(obj.load() == true);
         assert(obj.load(std::memory_order_acquire) == true);
int main(int, char**)
                                            std::memory_order_seq_cst) == true);
         assert(obj == false);
         assert(x == true);
         assert((obj = false) == false);
         assert(obj == false);
         assert((obj = true) == true);
         assert(obj == true);
     }
     {
         std::atomic_bool obj(true);
         assert(obj == true);
-        std::atomic_init(&obj, false);
-        assert(obj == false);
-        std::atomic_init(&obj, true);
-        assert(obj == true);
         bool b0 = obj.is_lock_free();
         (void)b0; // to placate scan-build
         obj.store(false);
         assert(obj == false);
         obj.store(true, std::memory_order_release);
         assert(obj == true);
         assert(obj.load() == true);
         assert(obj.load(std::memory_order_acquire) == true);
         assert(obj.exchange(false) == true);
         assert(obj == false);
         assert(obj.exchange(true, std::memory_order_relaxed) == false);
         assert(obj == true);
         bool x = obj;
         assert(cmpxchg_weak_loop(obj, x, false) == true);
         assert(obj == false);
         assert(x == true);
         assert(obj.compare_exchange_weak(x, true,
                                          std::memory_order_seq_cst) == false);
         assert(obj == false);
         assert(x == false);
         obj.store(true);
         x = true;
         assert(cmpxchg_weak_loop(obj, x, false,
                                  std::memory_order_seq_cst,
                                  std::memory_order_seq_cst) == true);
         assert(obj == false);
         assert(x == true);
         x = true;
         obj.store(true);
         assert(obj.compare_exchange_strong(x, false) == true);
         assert(obj == false);
         assert(x == true);
         assert(obj.compare_exchange_strong(x, true,
                                          std::memory_order_seq_cst) == false);
         assert(obj == false);
         assert(x == false);
         x = true;
         obj.store(true);
         assert(obj.compare_exchange_strong(x, false,
                                            std::memory_order_seq_cst,
                                            std::memory_order_seq_cst) == true);
         assert(obj == false);
         assert(x == true);
         assert((obj = false) == false);
         assert(obj == false);
         assert((obj = true) == true);
         assert(obj == true);
     }
     {
         typedef std::atomic<bool> A;
         TEST_ALIGNAS_TYPE(A) char storage[sizeof(A)] = {1};
         A& zero = *new (storage) A();
         assert(zero == false);
         zero.~A();
     }
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.generic/constexpr_noexcept.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-threads
+
+#include <atomic>
+
+#include "test_macros.h"
+
+template <typename T>
+constexpr bool test() {
+  [[maybe_unused]] constexpr T a;
+  static_assert(std::is_nothrow_constructible_v<T>);
+  ASSERT_NOEXCEPT(T{});
+  return true;
+}
+
+struct throwing {
+  throwing() {}
+};
+
+struct trivial {
+  int a;
+};
+
+void test() {
+  static_assert(test<std::atomic<bool>>());
+  static_assert(test<std::atomic<int>>());
+  static_assert(test<std::atomic<int*>>());
+  static_assert(test<std::atomic<trivial>>());
+  static_assert(test<std::atomic_flag>());
+
+  static_assert(!std::is_nothrow_constructible_v<std::atomic<throwing>>);
+  ASSERT_NOT_NOEXCEPT(std::atomic<throwing>{});
+}

libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp

 #include "test_macros.h"
 
 template <class A, class T>
 void
 do_test()
 {
     A obj(T(0));
     assert(obj == T(0));
-    std::atomic_init(&obj, T(1));
-    assert(obj == T(1));
-    std::atomic_init(&obj, T(2));
-    assert(obj == T(2));
     bool b0 = obj.is_lock_free();
     ((void)b0); // mark as unused
     obj.store(T(0));
     assert(obj == T(0));
     obj.store(T(1), std::memory_order_release);
     assert(obj == T(1));
     assert(obj.load() == T(1));
     assert(obj.load(std::memory_order_acquire) == T(1));

libcxx/test/std/atomics/atomics.types.generic/throw.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: no-exceptions
+
+// <atomic>
+
+#include <atomic>
+#include <cassert>
+
+struct throwing {
+  throwing() { throw 42; }
+};
+
+int main(int, char**) {
+  try {
+    [[maybe_unused]] std::atomic<throwing> a;
+    assert(false);
+  } catch (int x) {
+    assert(x == 42);
+  }
+
+  return 0;
+}

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A a;
         T t(T(1));
-        std::atomic_init(&a, t);
+        A a(t);
         assert(std::atomic_compare_exchange_strong(&a, &t, T(2)) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_strong(&a, &t, T(3)) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
     {
         typedef std::atomic<T> A;
-        volatile A a;
         T t(T(1));
-        std::atomic_init(&a, t);
+        volatile A a(t);
         assert(std::atomic_compare_exchange_strong(&a, &t, T(2)) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_strong(&a, &t, T(3)) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A a;
         T t(T(1));
-        std::atomic_init(&a, t);
+        A a(t);
         assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(2),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(3),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
     {
         typedef std::atomic<T> A;
-        volatile A a;
         T t(T(1));
-        std::atomic_init(&a, t);
+        volatile A a(t);
         assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(2),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(3),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
         assert(a == T(2));
         assert(t == T(2));

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A a;
         T t(T(1));
-        std::atomic_init(&a, t);
+        A a(t);
         assert(c_cmpxchg_weak_loop(&a, &t, T(2)) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_weak(&a, &t, T(3)) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
     {
         typedef std::atomic<T> A;
-        volatile A a;
         T t(T(1));
-        std::atomic_init(&a, t);
+        volatile A a(t);
         assert(c_cmpxchg_weak_loop(&a, &t, T(2)) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_weak(&a, &t, T(3)) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A a;
         T t(T(1));
-        std::atomic_init(&a, t);
+        A a(t);
         assert(c_cmpxchg_weak_loop(&a, &t, T(2),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_weak_explicit(&a, &t, T(3),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
     {
         typedef std::atomic<T> A;
-        volatile A a;
         T t(T(1));
-        std::atomic_init(&a, t);
+        volatile A a(t);
         assert(c_cmpxchg_weak_loop(&a, &t, T(2),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_weak_explicit(&a, &t, T(3),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
         assert(a == T(2));
         assert(t == T(2));

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
-    A t;
-    std::atomic_init(&t, T(1));
+    A t(T(1));
     assert(std::atomic_exchange(&t, T(2)) == T(1));
     assert(t == T(2));
-    volatile A vt;
-    std::atomic_init(&vt, T(3));
+    volatile A vt(T(3));
     assert(std::atomic_exchange(&vt, T(4)) == T(3));
     assert(vt == T(4));
   }
 };
 
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp

 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
-    A t;
-    std::atomic_init(&t, T(1));
+    A t(T(1));
     assert(std::atomic_exchange_explicit(&t, T(2), std::memory_order_seq_cst)
            == T(1));
     assert(t == T(2));
-    volatile A vt;
-    std::atomic_init(&vt, T(3));
+    volatile A vt(T(3));
     assert(std::atomic_exchange_explicit(&vt, T(4), std::memory_order_seq_cst)
            == T(3));
     assert(vt == T(4));
   }
 };
 
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-//  ... test crashes clang
 
 // <atomic>
 
 // template <class Integral>
 //     Integral
 //     atomic_fetch_add(volatile atomic<Integral>* obj, Integral op);
 //
 // template <class Integral>

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A t;
-        std::atomic_init(&t, T(1));
+        A t(T(1));
         assert(std::atomic_fetch_add(&t, T(2)) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
-        volatile A t;
-        std::atomic_init(&t, T(1));
+        volatile A t(T(1));
         assert(std::atomic_fetch_add(&t, T(2)) == T(1));
         assert(t == T(3));
     }
   }
 };
 
 template <class T>
 void testp()
 {
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
-        A t;
-        std::atomic_init(&t, T(1*sizeof(X)));
+        A t(T(1 * sizeof(X)));
         assert(std::atomic_fetch_add(&t, 2) == T(1*sizeof(X)));
 #ifdef _LIBCPP_VERSION // libc++ is nonconforming
         std::atomic_fetch_add<X>(&t, 0);
 #else
         std::atomic_fetch_add<T>(&t, 0);
 #endif // _LIBCPP_VERSION
         assert(t == T(3*sizeof(X)));
     }
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
-        volatile A t;
-        std::atomic_init(&t, T(1*sizeof(X)));
+        volatile A t(T(1 * sizeof(X)));
         assert(std::atomic_fetch_add(&t, 2) == T(1*sizeof(X)));
 #ifdef _LIBCPP_VERSION // libc++ is nonconforming
         std::atomic_fetch_add<X>(&t, 0);
 #else
         std::atomic_fetch_add<T>(&t, 0);
 #endif // _LIBCPP_VERSION
         assert(t == T(3*sizeof(X)));
     }
 }
 
 int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-//  ... test crashes clang
 
 // <atomic>
 
 // template <class Integral>
 //     Integral
 //     atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op,
 //                               memory_order m);
 // template <class Integral>

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A t;
-        std::atomic_init(&t, T(1));
+        A t(T(1));
         assert(std::atomic_fetch_add_explicit(&t, T(2),
                                             std::memory_order_seq_cst) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
-        volatile A t;
-        std::atomic_init(&t, T(1));
+        volatile A t(T(1));
         assert(std::atomic_fetch_add_explicit(&t, T(2),
                                             std::memory_order_seq_cst) == T(1));
         assert(t == T(3));
     }
   }
 };
 
 template <class T>
 void
 testp()
 {
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
-        A t;
-        std::atomic_init(&t, T(1*sizeof(X)));
+        A t(T(1 * sizeof(X)));
         assert(std::atomic_fetch_add_explicit(&t, 2,
                                   std::memory_order_seq_cst) == T(1*sizeof(X)));
 #ifdef _LIBCPP_VERSION // libc++ is not conforming
         std::atomic_fetch_add_explicit<X>(&t, 0, std::memory_order_relaxed);
 #else
         std::atomic_fetch_add_explicit<T>(&t, 0, std::memory_order_relaxed);
 #endif // _LIBCPP_VERSION
         assert(t == T(3*sizeof(X)));
     }
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
-        volatile A t;
-        std::atomic_init(&t, T(1*sizeof(X)));
+        volatile A t(T(1 * sizeof(X)));
         assert(std::atomic_fetch_add_explicit(&t, 2,
                                   std::memory_order_seq_cst) == T(1*sizeof(X)));
 #ifdef _LIBCPP_VERSION // libc++ is not conforming
         std::atomic_fetch_add_explicit<X>(&t, 0, std::memory_order_relaxed);
 #else
         std::atomic_fetch_add_explicit<T>(&t, 0, std::memory_order_relaxed);
 #endif // _LIBCPP_VERSION
         assert(t == T(3*sizeof(X)));

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A t;
-        std::atomic_init(&t, T(1));
+        A t(T(1));
         assert(std::atomic_fetch_and(&t, T(2)) == T(1));
         assert(t == T(0));
     }
     {
         typedef std::atomic<T> A;
-        volatile A t;
-        std::atomic_init(&t, T(3));
+        volatile A t(T(3));
         assert(std::atomic_fetch_and(&t, T(2)) == T(3));
         assert(t == T(2));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A t;
-        std::atomic_init(&t, T(1));
+        A t(T(1));
         assert(std::atomic_fetch_and_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(1));
         assert(t == T(0));
     }
     {
         typedef std::atomic<T> A;
-        volatile A t;
-        std::atomic_init(&t, T(3));
+        volatile A t(T(3));
         assert(std::atomic_fetch_and_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(3));
         assert(t == T(2));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A t;
-        std::atomic_init(&t, T(1));
+        A t(T(1));
         assert(std::atomic_fetch_or(&t, T(2)) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
-        volatile A t;
-        std::atomic_init(&t, T(3));
+        volatile A t(T(3));
         assert(std::atomic_fetch_or(&t, T(2)) == T(3));
         assert(t == T(3));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A t;
-        std::atomic_init(&t, T(1));
+        A t(T(1));
         assert(std::atomic_fetch_or_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
-        volatile A t;
-        std::atomic_init(&t, T(3));
+        volatile A t(T(3));
         assert(std::atomic_fetch_or_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(3));
         assert(t == T(3));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-//  ... test crashes clang
 
 // <atomic>
 
 // template <class Integral>
 //     Integral
 //     atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op);
 //
 // template <class Integral>

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A t;
-        std::atomic_init(&t, T(3));
+        A t(T(3));
         assert(std::atomic_fetch_sub(&t, T(2)) == T(3));
         assert(t == T(1));
     }
     {
         typedef std::atomic<T> A;
-        volatile A t;
-        std::atomic_init(&t, T(3));
+        volatile A t(T(3));
         assert(std::atomic_fetch_sub(&t, T(2)) == T(3));
         assert(t == T(1));
     }
   }
 };
 
 template <class T>
 void testp()
 {
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
-        A t;
-        std::atomic_init(&t, T(3*sizeof(X)));
+        A t(T(3 * sizeof(X)));
         assert(std::atomic_fetch_sub(&t, 2) == T(3*sizeof(X)));
 #ifdef _LIBCPP_VERSION // libc++ is nonconforming
         std::atomic_fetch_sub<X>(&t, 0);
 #else
         std::atomic_fetch_sub<T>(&t, 0);
 #endif // _LIBCPP_VERSION
         assert(t == T(1*sizeof(X)));
     }
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
-        volatile A t;
-        std::atomic_init(&t, T(3*sizeof(X)));
+        volatile A t(T(3 * sizeof(X)));
         assert(std::atomic_fetch_sub(&t, 2) == T(3*sizeof(X)));
 #ifdef _LIBCPP_VERSION // libc++ is nonconforming
         std::atomic_fetch_sub<X>(&t, 0);
 #else
         std::atomic_fetch_sub<T>(&t, 0);
 #endif // _LIBCPP_VERSION
         assert(t == T(1*sizeof(X)));
     }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-//  ... test crashes clang
 
 // <atomic>
 
 // template <class Integral>
 //     Integral
 //     atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op,
 //                               memory_order m);
 // template <class Integral>

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A t;
-        std::atomic_init(&t, T(3));
+        A t(T(3));
         assert(std::atomic_fetch_sub_explicit(&t, T(2),
                                             std::memory_order_seq_cst) == T(3));
         assert(t == T(1));
     }
     {
         typedef std::atomic<T> A;
-        volatile A t;
-        std::atomic_init(&t, T(3));
+        volatile A t(T(3));
         assert(std::atomic_fetch_sub_explicit(&t, T(2),
                                             std::memory_order_seq_cst) == T(3));
         assert(t == T(1));
     }
   }
 };
 
 template <class T>
 void testp()
 {
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
-        A t;
-        std::atomic_init(&t, T(3*sizeof(X)));
+        A t(T(3 * sizeof(X)));
         assert(std::atomic_fetch_sub_explicit(&t, 2,
                                   std::memory_order_seq_cst) == T(3*sizeof(X)));
 #ifdef _LIBCPP_VERSION // libc++ is nonconforming
         std::atomic_fetch_sub_explicit<X>(&t, 0, std::memory_order_relaxed);
 #else
         std::atomic_fetch_sub_explicit<T>(&t, 0, std::memory_order_relaxed);
 #endif // _LIBCPP_VERSION
         assert(t == T(1*sizeof(X)));
     }
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
-        volatile A t;
-        std::atomic_init(&t, T(3*sizeof(X)));
+        volatile A t(T(3 * sizeof(X)));
         assert(std::atomic_fetch_sub_explicit(&t, 2,
                                   std::memory_order_seq_cst) == T(3*sizeof(X)));
 #ifdef _LIBCPP_VERSION // libc++ is nonconforming
         std::atomic_fetch_sub_explicit<X>(&t, 0, std::memory_order_relaxed);
 #else
         std::atomic_fetch_sub_explicit<T>(&t, 0, std::memory_order_relaxed);
 #endif // _LIBCPP_VERSION
         assert(t == T(1*sizeof(X)));

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A t;
-        std::atomic_init(&t, T(1));
+        A t(T(1));
         assert(std::atomic_fetch_xor(&t, T(2)) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
-        volatile A t;
-        std::atomic_init(&t, T(3));
+        volatile A t(T(3));
         assert(std::atomic_fetch_xor(&t, T(2)) == T(3));
         assert(t == T(1));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp

 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
-        A t;
-        std::atomic_init(&t, T(1));
+        A t(T(1));
         assert(std::atomic_fetch_xor_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
-        volatile A t;
-        std::atomic_init(&t, T(3));
+        volatile A t(T(3));
         assert(std::atomic_fetch_xor_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(3));
         assert(t == T(1));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
 // XFAIL: !non-lockfree-atomics
 //  ... assertion fails line 36
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 // <atomic>
 
 // template <class T>
 //     void
 //     atomic_init(volatile atomic<T>* obj, T desr);
 //
 // template <class T>

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp

 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
-    A t;
-    std::atomic_init(&t, T(1));
+    A t(T(1));
     assert(std::atomic_load(&t) == T(1));
-    volatile A vt;
-    std::atomic_init(&vt, T(2));
+    volatile A vt(T(2));
     assert(std::atomic_load(&vt) == T(2));
   }
 };
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp

 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
-    A t;
-    std::atomic_init(&t, T(1));
+    A t(T(1));
     assert(std::atomic_load_explicit(&t, std::memory_order_seq_cst) == T(1));
-    volatile A vt;
-    std::atomic_init(&vt, T(2));
+    volatile A vt(T(2));
     assert(std::atomic_load_explicit(&vt, std::memory_order_seq_cst) == T(2));
   }
 };
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_wait.pass.cpp

 #include "test_macros.h"
 #include "../atomics.types.operations.req/atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
 
-    A t;
-    std::atomic_init(&t, T(1));
+    A t(T(1));
     assert(std::atomic_load(&t) == T(1));
     std::atomic_wait(&t, T(0));
     std::thread t1 = support::make_test_thread([&](){
       std::atomic_store(&t, T(3));
       std::atomic_notify_one(&t);
     });
     std::atomic_wait(&t, T(1));
     t1.join();
 
-    volatile A vt;
-    std::atomic_init(&vt, T(2));
+    volatile A vt(T(2));
     assert(std::atomic_load(&vt) == T(2));
     std::atomic_wait(&vt, T(1));
     std::thread t2 = support::make_test_thread([&](){
       std::atomic_store(&vt, T(4));
       std::atomic_notify_one(&vt);
     });
     std::atomic_wait(&vt, T(2));
     t2.join();

libcxx/test/std/depr/depr.atomics/depr.atomics.nonmembers/atomic_init.depr_in_cxx20.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-threads
+
+// <atomic>
+//
+// atomic_init
+
+#include <atomic>
+
+int main() {
+  std::atomic<int> a;
+  std::atomic_init(&a, 1); // expected-warning {{'atomic_init<int>' is deprecated}}
+
+  volatile std::atomic<int> b;
+  std::atomic_init(&b, 1); // expected-warning {{'atomic_init<int>' is deprecated}}
+}

libcxx/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp

 #     error "__cpp_lib_atomic_shared_ptr should have the value 201711L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_atomic_shared_ptr
 #     error "__cpp_lib_atomic_shared_ptr should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_value_initialization
 #     error "__cpp_lib_atomic_value_initialization should be defined in c++20"
 #   endif
 #   if __cpp_lib_atomic_value_initialization != 201911L
 #     error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++20"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_atomic_value_initialization
-#     error "__cpp_lib_atomic_value_initialization should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_atomic_value_initialization should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
 #   ifndef __cpp_lib_atomic_wait
 #     error "__cpp_lib_atomic_wait should be defined in c++20"
 #   endif
 #   if __cpp_lib_atomic_wait != 201907L

 #     error "__cpp_lib_atomic_shared_ptr should have the value 201711L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_atomic_shared_ptr
 #     error "__cpp_lib_atomic_shared_ptr should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_value_initialization
 #     error "__cpp_lib_atomic_value_initialization should be defined in c++2b"
 #   endif
 #   if __cpp_lib_atomic_value_initialization != 201911L
 #     error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++2b"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_atomic_value_initialization
-#     error "__cpp_lib_atomic_value_initialization should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_atomic_value_initialization should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
 #   ifndef __cpp_lib_atomic_wait
 #     error "__cpp_lib_atomic_wait should be defined in c++2b"
 #   endif
 #   if __cpp_lib_atomic_wait != 201907L

libcxx/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp

 #     error "__cpp_lib_assume_aligned should have the value 201811L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_assume_aligned
 #     error "__cpp_lib_assume_aligned should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_value_initialization
 #     error "__cpp_lib_atomic_value_initialization should be defined in c++20"
 #   endif
 #   if __cpp_lib_atomic_value_initialization != 201911L
 #     error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++20"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_atomic_value_initialization
-#     error "__cpp_lib_atomic_value_initialization should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_atomic_value_initialization should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should be defined in c++20"
 # endif
 # if __cpp_lib_constexpr_dynamic_alloc != 201907L
 #   error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++20"

 #     error "__cpp_lib_assume_aligned should have the value 201811L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_assume_aligned
 #     error "__cpp_lib_assume_aligned should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_value_initialization
 #     error "__cpp_lib_atomic_value_initialization should be defined in c++2b"
 #   endif
 #   if __cpp_lib_atomic_value_initialization != 201911L
 #     error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++2b"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_atomic_value_initialization
-#     error "__cpp_lib_atomic_value_initialization should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_atomic_value_initialization should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_dynamic_alloc != 201907L
 #   error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++2b"

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

 #     error "__cpp_lib_atomic_shared_ptr should have the value 201711L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_atomic_shared_ptr
 #     error "__cpp_lib_atomic_shared_ptr should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_value_initialization
 #     error "__cpp_lib_atomic_value_initialization should be defined in c++20"
 #   endif
 #   if __cpp_lib_atomic_value_initialization != 201911L
 #     error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++20"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_atomic_value_initialization
-#     error "__cpp_lib_atomic_value_initialization should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_atomic_value_initialization should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
 #   ifndef __cpp_lib_atomic_wait
 #     error "__cpp_lib_atomic_wait should be defined in c++20"
 #   endif
 #   if __cpp_lib_atomic_wait != 201907L

 #     error "__cpp_lib_atomic_shared_ptr should have the value 201711L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_atomic_shared_ptr
 #     error "__cpp_lib_atomic_shared_ptr should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_value_initialization
 #     error "__cpp_lib_atomic_value_initialization should be defined in c++2b"
 #   endif
 #   if __cpp_lib_atomic_value_initialization != 201911L
 #     error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++2b"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_atomic_value_initialization
-#     error "__cpp_lib_atomic_value_initialization should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_atomic_value_initialization should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
 #   ifndef __cpp_lib_atomic_wait
 #     error "__cpp_lib_atomic_wait should be defined in c++2b"
 #   endif
 #   if __cpp_lib_atomic_wait != 201907L

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_atomic_value_initialization",
     "values": { "c++20": 201911 },
     "headers": ["atomic", "memory"],
     "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_atomic_wait",
     "values": { "c++20": 201907 },
     "headers": ["atomic"],
     "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)",
   }, {
     "name": "__cpp_lib_barrier",