[libc++] Update atomic synopsis and tests.

[Mordante]

Summary

While looking at LWG-2988 and P0558 it seems the issues were already
implemented, but the synopsis wasn't updated. Some of the tests didn't
validate the noexcept status. A few tests were missing completely:

• atomic_wait_explicit
• atomic_notify_one
• atomic_notify_all

Mark P0558 as complete, didn't investigate which version of libc++ first
includes this. It seems the paper has been retroactively applied. I
couldn't find whether this is correct, but looking at cppreference it
seems intended.

Completes

• LWG-2988 Clause 32 cleanup missed one typename
• P0558 Resolving atomic<T> named base class inconsistencies

[ldionne]

Can you confirm that the corresponding tests are already testing this issue? LGTM if that's the case, otherwise would you kindly add some?

[ldionne]

Ping, are we waiting on something to land this?

[Mordante]

This kind of fell under the radar. I had a look and it seems the synopsis of the tests isn't updated yet. I also want to look whether this means P0558 is fully implemented. Since addition changes my conflict with D103983 I prefer to land that one first.

[Mordante]

Mark P0558 as complete, didn't investigate which version of libc++ first
includes this. It seems the paper has been retroactively applied. I
couldn't find whether this is correct, but looking at cppreference it
seems intended.

The other changes are:

• Update outdated synopsis in the tests.
• Where applicable added ASSERT_NOEXCEPT tests
• Added a atomic_wait_explicit test (based on atomic_wait)
• Added a atomic_notify_one test (based on atomic_wait)
• Added a atomic_notify_all test (based on atomic_wait and notify_all)

[• Quuxplusone]

Requesting changes, but basically this looks like an improvement and I don't actually care to see it again before it lands. :)

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

10–11

Pre-existing: this comment isn't right, and remains not-right after your PR changes the line numbers. I didn't look to find out which line number it should have said.

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

10–11

Ditto here.

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

10–11

Ditto here. (Etc. etc.)

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

51

Arguably, it'd be better to keep using 2 and 4 for this second set of tests, just to guard against the remote possibility that something goes wrong when the stack frame reuses the same memory address for both a variables.

Also, it looks like you removed the test coverage of std::atomic_wait(&t, T(some-other-value)), which is expected to return immediately as a no-op.

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

60

Would it make sense to test any other memory orders? I assume there's nothing we can really do in a test to verify that the codegen uses the "right" memory order, though, so whatever.

[Mordante]

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

10–11

I'll remove this line and in the other places.

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

51

The tests for atomic_wait and atomic_wait_explicit test the nop. This test is for
atomic_notify_one so here there's no need to test this nop. (This test is based on the atomic_wait.)

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

60

It might make sense, but I noticed the other tests also only test std::memory_order_seq_cst. In that case we should look at that for all these tests not only this one. Since we have some ARM build bots it would be interesting to test this. (On x86 the CPU often has a stronger memory order than the requested memory order.)

But I see that out of scope for this patch.

[• Quuxplusone]

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

51

Ah, I get it. OK.
Might be a good idea to insert assert(a.load() == T(3)) before t.join(), just for paranoia. Cf. line 46 of atomic_notify_all.pass.cpp.

[Mordante]

Addresses review comments.

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

51

It might be paranoia here, but the atomic_wait tests also don't do this test. I'll add them.

[ldionne]

LGTM! Thanks for cleaning this up.

libcxx/include/atomic

272

We could perhaps drop the typename here for readability, since this is only in a comment. WDYT?

[Mordante]

libcxx/include/atomic

272

I don't mind to remove them. It might be they're not even required in C++20, but too lazy too look for the details of the paper.

libcxx/docs/Status/Cxx17Papers.csv

 "`P0430R2 <https://wg21.link/P0430R2>`__","LWG","File system library on non-POSIX-like operating systems","Kona","|Complete|","7.0"
 "`P0433R2 <https://wg21.link/P0433R2>`__","LWG","Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library","Kona","|In Progress| [#note-P0433]_","7.0"
 "`P0452R1 <https://wg21.link/P0452R1>`__","LWG","Unifying <numeric> Parallel Algorithms","Kona","",""
 "`P0467R2 <https://wg21.link/P0467R2>`__","LWG","Iterator Concerns for Parallel Algorithms","Kona","",""
 "`P0492R2 <https://wg21.link/P0492R2>`__","LWG","Proposed Resolution of C++17 National Body Comments for Filesystems","Kona","|Complete|","7.0"
 "`P0518R1 <https://wg21.link/P0518R1>`__","LWG","Allowing copies as arguments to function objects given to parallel algorithms in response to CH11","Kona","",""
 "`P0523R1 <https://wg21.link/P0523R1>`__","LWG","Wording for CH 10: Complexity of parallel algorithms","Kona","",""
 "`P0548R1 <https://wg21.link/P0548R1>`__","LWG","common_type and duration","Kona","|Complete|","5.0"
-"`P0558R1 <https://wg21.link/P0558R1>`__","LWG","Resolving atomic<T> named base class inconsistencies","Kona","",""
+"`P0558R1 <https://wg21.link/P0558R1>`__","LWG","Resolving atomic<T> named base class inconsistencies","Kona","|Complete|",""
 "`P0574R1 <https://wg21.link/P0574R1>`__","LWG","Algorithm Complexity Constraints and Parallel Overloads","Kona","",""
 "`P0599R1 <https://wg21.link/P0599R1>`__","LWG","noexcept for hash functions","Kona","|Complete|","5.0"
 "`P0604R0 <https://wg21.link/P0604R0>`__","LWG","Resolving GB 55, US 84, US 85, US 86","Kona","|Complete|",""
 "`P0607R0 <https://wg21.link/P0607R0>`__","LWG","Inline Variables for the Standard Library","Kona","|In Progress| [#note-P0607]_","6.0"
 "`P0618R0 <https://wg21.link/P0618R0>`__","LWG","Deprecating <codecvt>","Kona","",""
 "`P0623R0 <https://wg21.link/P0623R0>`__","LWG","Final C++17 Parallel Algorithms Fixes","Kona","",""
 "","","","","",""
 "`P0682R1 <https://wg21.link/P0682R1>`__","LWG","Repairing elementary string conversions","Toronto","",""
 "`P0739R0 <https://wg21.link/P0739R0>`__","LWG","Some improvements to class template argument deduction integration into the standard library","Toronto","|Complete|","5.0"

libcxx/docs/Status/Cxx20Issues.csv

 "`2972 <https://wg21.link/LWG2972>`__","What is ``is_trivially_destructible_v<int>``\ ?","Albuquerque","|Complete|",""
 "`2976 <https://wg21.link/LWG2976>`__","Dangling uses_allocator specialization for packaged_task","Albuquerque","|Complete|",""
 "`2977 <https://wg21.link/LWG2977>`__","unordered_meow::merge() has incorrect Throws: clause","Albuquerque","|Nothing To Do|",""
 "`2978 <https://wg21.link/LWG2978>`__","Hash support for pmr::string and friends","Albuquerque","",""
 "`2979 <https://wg21.link/LWG2979>`__","aligned_union should require complete object types","Albuquerque","|Complete|",""
 "`2980 <https://wg21.link/LWG2980>`__","Cannot compare_exchange empty pointers","Albuquerque","",""
 "`2981 <https://wg21.link/LWG2981>`__","Remove redundant deduction guides from standard library","Albuquerque","",""
 "`2982 <https://wg21.link/LWG2982>`__","Making size_type consistent in associative container deduction guides","Albuquerque","",""
-"`2988 <https://wg21.link/LWG2988>`__","Clause 32 cleanup missed one typename","Albuquerque","",""
+"`2988 <https://wg21.link/LWG2988>`__","Clause 32 cleanup missed one typename","Albuquerque","|Complete|","13.0"
 "`2993 <https://wg21.link/LWG2993>`__","reference_wrapper<T> conversion from T&&","Albuquerque","|Complete|","13.0"
 "`2998 <https://wg21.link/LWG2998>`__","Requirements on function objects passed to {``forward_``,}list-specific algorithms","Albuquerque","|Nothing To Do|",""
 "`3001 <https://wg21.link/LWG3001>`__","weak_ptr::element_type needs remove_extent_t","Albuquerque","",""
 "`3024 <https://wg21.link/LWG3024>`__","variant's copies must be deleted instead of disabled via SFINAE","Albuquerque","|Complete|",""
 "","","","",""
 "`2164 <https://wg21.link/LWG2164>`__","What are the semantics of ``vector.emplace(vector.begin(), vector.back())``\ ?","Jacksonville","|Complete|",""
 "`2243 <https://wg21.link/LWG2243>`__","``istream::putback``\  problem","Jacksonville","|Complete|",""
 "`2816 <https://wg21.link/LWG2816>`__","``resize_file``\  has impossible postcondition","Jacksonville","|Nothing To Do|",""

libcxx/include/atomic

struct atomic<T*>
     void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
     void notify_one() noexcept;
     void notify_all() volatile noexcept;
     void notify_all() noexcept;
 };
 
 
-template <class T>
-  bool atomic_is_lock_free(const volatile atomic<T>* obj) noexcept;
-
-template <class T>
-  bool atomic_is_lock_free(const atomic<T>* obj) noexcept;
-
-template <class T>
-  void atomic_store(volatile atomic<T>* obj, T desr) noexcept;
-
-template <class T>
-  void atomic_store(atomic<T>* obj, T desr) noexcept;
-
-template <class T>
-  void atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
-
-template <class T>
-  void atomic_store_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
-
-template <class T>
-  T atomic_load(const volatile atomic<T>* obj) noexcept;
-
-template <class T>
-  T atomic_load(const atomic<T>* obj) noexcept;
-
-template <class T>
-  T atomic_load_explicit(const volatile atomic<T>* obj, memory_order m) noexcept;
-
-template <class T>
-  T atomic_load_explicit(const atomic<T>* obj, memory_order m) noexcept;
-
-template <class T>
-  T atomic_exchange(volatile atomic<T>* obj, T desr) noexcept;
-
-template <class T>
-  T atomic_exchange(atomic<T>* obj, T desr) noexcept;
-
-template <class T>
-  T atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
-
-template <class T>
-  T atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
-
-template <class T>
-  bool atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr) noexcept;
-
-template <class T>
-  bool atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr) noexcept;
-
-template <class T>
-  bool atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr) noexcept;
-
-template <class T>
-  bool atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr) noexcept;
-
-template <class T>
-  bool atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
-                                             T desr,
-                                             memory_order s, memory_order f) noexcept;
-
-template <class T>
-  bool atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
-                                             memory_order s, memory_order f) noexcept;
-
-template <class T>
-  bool atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj,
-                                               T* expc, T desr,
-                                               memory_order s, memory_order f) noexcept;
-
-template <class T>
-  bool atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc,
-                                               T desr,
-                                               memory_order s, memory_order f) noexcept;
+// [atomics.nonmembers], non-member functions
+template<class T>
+  bool atomic_is_lock_free(const volatile atomic<T>*) noexcept;
+template<class T>
+  bool atomic_is_lock_free(const atomic<T>*) noexcept;
+template<class T>
+  void atomic_store(volatile atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+  void atomic_store(atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+  void atomic_store_explicit(volatile atomic<T>*, atomic<T>::value_type,
+                             memory_order) noexcept;
+template<class T>
+  void atomic_store_explicit(atomic<T>*, atomic<T>::value_type,
+                             memory_order) noexcept;
+template<class T>
+  T atomic_load(const volatile atomic<T>*) noexcept;
+template<class T>
+  T atomic_load(const atomic<T>*) noexcept;
+template<class T>
+  T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept;
+template<class T>
+  T atomic_load_explicit(const atomic<T>*, memory_order) noexcept;
+template<class T>
+  T atomic_exchange(volatile atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+  T atomic_exchange(atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+  T atomic_exchange_explicit(volatile atomic<T>*, atomic<T>::value_type,
+                             memory_order) noexcept;
+template<class T>
+  T atomic_exchange_explicit(atomic<T>*, atomic<T>::value_type,
+                             memory_order) noexcept;
+template<class T>
+  bool atomic_compare_exchange_weak(volatile atomic<T>*, atomic<T>::value_type*,
+                                    atomic<T>::value_type) noexcept;
+template<class T>
+  bool atomic_compare_exchange_weak(atomic<T>*, atomic<T>::value_type*,
+                                    atomic<T>::value_type) noexcept;
+template<class T>
+  bool atomic_compare_exchange_strong(volatile atomic<T>*, atomic<T>::value_type*,
+                                      atomic<T>::value_type) noexcept;
+template<class T>
+  bool atomic_compare_exchange_strong(atomic<T>*, atomic<T>::value_type*,
+                                      atomic<T>::value_type) noexcept;
+template<class T>
+  bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*, atomic<T>::value_type*,
+                                             atomic<T>::value_type,
+                                             memory_order, memory_order) noexcept;
+template<class T>
+  bool atomic_compare_exchange_weak_explicit(atomic<T>*, atomic<T>::value_type*,
+                                             atomic<T>::value_type,
+                                             memory_order, memory_order) noexcept;
+template<class T>
+  bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*, atomic<T>::value_type*,
+                                               atomic<T>::value_type,
+                                               memory_order, memory_order) noexcept;
+template<class T>
+  bool atomic_compare_exchange_strong_explicit(atomic<T>*, atomic<T>::value_type*,
+                                               atomic<T>::value_type,
+                                               memory_order, memory_order) noexcept;
 
-template <class T>
-  void atomic_wait(const volatile atomic<T>* obj, T old) noexcept;
-
-template <class T>
-  void atomic_wait(const atomic<T>* obj, T old) noexcept;
-
-template <class T>
-  void atomic_wait_explicit(const volatile atomic<T>* obj, T old, memory_order m) noexcept;
-
-template <class T>
-  void atomic_wait_explicit(const atomic<T>* obj, T old, memory_order m) noexcept;
-
-template <class T>
-  void atomic_one(volatile atomic<T>* obj) noexcept;
-
-template <class T>
-  void atomic_one(atomic<T>* obj) noexcept;
-
-template <class T>
-  void atomic_all(volatile atomic<T>* obj) noexcept;
-
-template <class T>
-  void atomic_all(atomic<T>* obj) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_add(volatile atomic<Integral>* obj, Integral op) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_add(atomic<Integral>* obj, Integral op) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op,
-                              memory_order m) noexcept;
-template <class Integral>
-  Integral atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op,
-                              memory_order m) noexcept;
-template <class Integral>
-  Integral atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_sub(atomic<Integral>* obj, Integral op) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op,
-                                     memory_order m) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,
-                                     memory_order m) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_and(volatile atomic<Integral>* obj, Integral op) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_and(atomic<Integral>* obj, Integral op) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op,
-                                     memory_order m) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op,
-                                     memory_order m) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_or(volatile atomic<Integral>* obj, Integral op) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_or(atomic<Integral>* obj, Integral op) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op,
-                             memory_order m) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op,
-                             memory_order m) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_xor(atomic<Integral>* obj, Integral op) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op,
-                                     memory_order m) noexcept;
-
-template <class Integral>
-  Integral atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op,
-                                     memory_order m) noexcept;
-
-template <class T>
-  T* atomic_fetch_add(volatile atomic<T*>* obj, ptrdiff_t op) noexcept;
-
-template <class T>
-  T* atomic_fetch_add(atomic<T*>* obj, ptrdiff_t op) noexcept;
-
-template <class T>
-  T* atomic_fetch_add_explicit(volatile atomic<T*>* obj, ptrdiff_t op,
-                               memory_order m) noexcept;
-
-template <class T>
-  T* atomic_fetch_add_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m) noexcept;
-
-template <class T>
-  T* atomic_fetch_sub(volatile atomic<T*>* obj, ptrdiff_t op) noexcept;
-
-template <class T>
-  T* atomic_fetch_sub(atomic<T*>* obj, ptrdiff_t op) noexcept;
-
-template <class T>
-  T* atomic_fetch_sub_explicit(volatile atomic<T*>* obj, ptrdiff_t op,
-                               memory_order m) noexcept;
+template<class T>
+  T atomic_fetch_add(volatile atomic<T>*, atomic<T>::difference_type) noexcept;
+template<class T>
+  T atomic_fetch_add(atomic<T>*, atomic<T>::difference_type) noexcept;
+template<class T>
+  T atomic_fetch_add_explicit(volatile atomic<T>*, atomic<T>::difference_type,
+                              memory_order) noexcept;
+template<class T>
+  T atomic_fetch_add_explicit(atomic<T>*, atomic<T>::difference_type,
+                              memory_order) noexcept;
+template<class T>
+  T atomic_fetch_sub(volatile atomic<T>*, atomic<T>::difference_type) noexcept;
+template<class T>
+  T atomic_fetch_sub(atomic<T>*, atomic<T>::difference_type) noexcept;
+template<class T>
+  T atomic_fetch_sub_explicit(volatile atomic<T>*, atomic<T>::difference_type,
+                              memory_order) noexcept;
+template<class T>
+  T atomic_fetch_sub_explicit(atomic<T>*, atomic<T>::difference_type,
+                              memory_order) noexcept;
+template<class T>
+  T atomic_fetch_and(volatile atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+  T atomic_fetch_and(atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+  T atomic_fetch_and_explicit(volatile atomic<T>*, atomic<T>::value_type,
+                              memory_order) noexcept;
+template<class T>
+  T atomic_fetch_and_explicit(atomic<T>*, atomic<T>::value_type,
+                              memory_order) noexcept;
+template<class T>
+  T atomic_fetch_or(volatile atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+  T atomic_fetch_or(atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+  T atomic_fetch_or_explicit(volatile atomic<T>*, atomic<T>::value_type,
+                             memory_order) noexcept;
+template<class T>
+  T atomic_fetch_or_explicit(atomic<T>*, atomic<T>::value_type,
+                             memory_order) noexcept;
+template<class T>
+  T atomic_fetch_xor(volatile atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+  T atomic_fetch_xor(atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+  T atomic_fetch_xor_explicit(volatile atomic<T>*, atomic<T>::value_type,
+                              memory_order) noexcept;
+template<class T>
+  T atomic_fetch_xor_explicit(atomic<T>*, atomic<T>::value_type,
+                              memory_order) noexcept;
 
-template <class T>
-  T* atomic_fetch_sub_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m) noexcept;
+template<class T>
+  void atomic_wait(const volatile atomic<T>*, atomic<T>::value_type);
+template<class T>
+  void atomic_wait(const atomic<T>*, atomic<T>::value_type);
+template<class T>
+  void atomic_wait_explicit(const volatile atomic<T>*, atomic<T>::value_type,
+                            memory_order);
+template<class T>
+  void atomic_wait_explicit(const atomic<T>*, atomic<T>::value_type,
+                            memory_order);
+template<class T>
+  void atomic_notify_one(volatile atomic<T>*);
+template<class T>
+  void atomic_notify_one(atomic<T>*);
+template<class T>
+  void atomic_notify_all(volatile atomic<T>*);
+template<class T>
+  void atomic_notify_all(atomic<T>*);
 
 // Atomics for standard typedef types
 
 typedef atomic<bool>               atomic_bool;
 typedef atomic<char>               atomic_char;
 typedef atomic<signed char>        atomic_schar;
 typedef atomic<unsigned char>      atomic_uchar;
 typedef atomic<short>              atomic_short;

 // fences
 
 void atomic_thread_fence(memory_order m) noexcept;
 void atomic_signal_fence(memory_order m) noexcept;
 
 // deprecated
 
 template <class T>
-  void atomic_init(volatile atomic<T>* obj, typename atomic<T>::value_type desr) noexcept;
+  void atomic_init(volatile atomic<T>* obj, atomic<T>::value_type desr) noexcept;
 
 template <class T>
-  void atomic_init(atomic<T>* obj, typename atomic<T>::value_type desr) noexcept;
+  void atomic_init(atomic<T>* obj, atomic<T>::value_type desr) noexcept;
 
 #define ATOMIC_VAR_INIT(value) see below
 
 #define ATOMIC_FLAG_INIT see below
 
 }  // std
 
 */

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.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 34
 
 // <atomic>
 
 // template <class T>
 //     bool
-//     atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr);
+//     atomic_compare_exchange_strong(volatile atomic<T>*,
+//                                    atomic<T>::value_type*,
+//                                    atomic<T>::value_type) noexcept;
 //
 // template <class T>
 //     bool
-//     atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr);
+//     atomic_compare_exchange_strong(atomic<T>*,
+//                                    atomic<T>::value_type*,
+//                                    atomic<T>::value_type) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
         T t(T(1));
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_compare_exchange_strong(&a, &t, T(3)));
     }
     {
         typedef std::atomic<T> A;
         T t(T(1));
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_compare_exchange_strong(&a, &t, T(3)));
     }
   }
 };
 
 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

 //===----------------------------------------------------------------------===//
 //
 // 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 38
 
 // <atomic>
 
 // template <class T>
 //     bool
-//     atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj, T* expc,
-//                                           T desr,
-//                                           memory_order s, memory_order f);
+//     atomic_compare_exchange_strong_explicit(volatile atomic<T>*,
+//                                             atomic<T>::value_type*,
+//                                             atomic<T>::value_type,
+//                                             memory_order, memory_order) noexcept;
 //
 // template <class T>
 //     bool
-//     atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc, T desr,
-//                                           memory_order s, memory_order f);
+//     atomic_compare_exchange_strong_explicit(atomic<T>*,
+//                                             atomic<T>::value_type*,
+//                                             atomic<T>::value_type,
+//                                             memory_order, memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
         T t(T(1));
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_compare_exchange_strong_explicit(&a, &t, T(3), std::memory_order_seq_cst,
+                                                                     std::memory_order_seq_cst));
     }
     {
         typedef std::atomic<T> A;
         T t(T(1));
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_compare_exchange_strong_explicit(&a, &t, T(3), std::memory_order_seq_cst,
+                                                                     std::memory_order_seq_cst));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.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 34
 
 // <atomic>
 
 // template <class T>
 //     bool
-//     atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr);
+//     atomic_compare_exchange_weak(volatile atomic<T>*,
+//                                  atomic<T>::value_type*,
+//                                  atomic<T>::value_type) noexcept;
 //
 // template <class T>
 //     bool
-//     atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr);
+//     atomic_compare_exchange_weak(atomic<T>*,
+//                                  atomic<T>::value_type*,
+//                                  atomic<T>::value_type) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include <cmpxchg_loop.h>
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
         T t(T(1));
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_compare_exchange_weak(&a, &t, T(3)));
     }
     {
         typedef std::atomic<T> A;
         T t(T(1));
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_compare_exchange_weak(&a, &t, T(3)));
     }
   }
 };
 
 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

 //===----------------------------------------------------------------------===//
 //
 // 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 38
 
 // <atomic>
 
 // template <class T>
 //     bool
-//     atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
-//                                           T desr,
-//                                           memory_order s, memory_order f);
+//     atomic_compare_exchange_weak_explicit(volatile atomic<T>*,
+//                                           atomic<T>::value_type*,
+//                                           atomic<T>::value_type,
+//                                           memory_order, memory_order) noexcept;
 //
 // template <class T>
 //     bool
-//     atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
-//                                           memory_order s, memory_order f);
+//     atomic_compare_exchange_weak_explicit(atomic<T>*,
+//                                           atomic<T>::value_type*,
+//                                           atomic<T>::value_type,
+//                                           memory_order, memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include <cmpxchg_loop.h>
 
 #include "test_macros.h"
void operator()() const {
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_compare_exchange_weak_explicit(&a, &t, T(3), std::memory_order_seq_cst,
+                                                                   std::memory_order_seq_cst));
     }
     {
         typedef std::atomic<T> A;
         T t(T(1));
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_compare_exchange_weak_explicit(&a, &t, T(3), std::memory_order_seq_cst,
+                                                                   std::memory_order_seq_cst));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.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
-//  ... fails assertion line 31
 
 // <atomic>
 
 // template <class T>
 //     T
-//     atomic_exchange(volatile atomic<T>* obj, T desr);
+//     atomic_exchange(volatile atomic<T>*, atomic<T>::value_type) noexcept;
 //
 // template <class T>
 //     T
-//     atomic_exchange(atomic<T>* obj, T desr);
+//     atomic_exchange(atomic<T>*, atomic<T>::value_type) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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(T(1));
     assert(std::atomic_exchange(&t, T(2)) == T(1));
     assert(t == T(2));
     volatile A vt(T(3));
     assert(std::atomic_exchange(&vt, T(4)) == T(3));
     assert(vt == T(4));
+
+    ASSERT_NOEXCEPT(std::atomic_exchange(&t, T(2)));
+    ASSERT_NOEXCEPT(std::atomic_exchange(&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

 //===----------------------------------------------------------------------===//
 //
 // 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 32
 
 // <atomic>
 
 // template <class T>
 //     T
-//     atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m);
+//     atomic_exchange_explicit(volatile atomic<T>*, atomic<T>::value_type,
+//                              memory_order) noexcept;
 //
 // template <class T>
 //     T
-//     atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m);
+//     atomic_exchange_explicit(atomic<T>*, atomic<T>::value_type,
+//                              memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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(T(1));
     assert(std::atomic_exchange_explicit(&t, T(2), std::memory_order_seq_cst)
            == T(1));
     assert(t == T(2));
     volatile A vt(T(3));
     assert(std::atomic_exchange_explicit(&vt, T(4), std::memory_order_seq_cst)
            == T(3));
     assert(vt == T(4));
+
+    ASSERT_NOEXCEPT(std::atomic_exchange_explicit(&t, T(2), std::memory_order_seq_cst));
+    ASSERT_NOEXCEPT(std::atomic_exchange_explicit(&vt, T(4), std::memory_order_seq_cst));
   }
 };
 
 
 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
 
 // <atomic>
 
-// template <class Integral>
-//     Integral
-//     atomic_fetch_add(volatile atomic<Integral>* obj, Integral op);
-//
-// template <class Integral>
-//     Integral
-//     atomic_fetch_add(atomic<Integral>* obj, Integral op);
-//
-// template <class T>
-//     T*
-//     atomic_fetch_add(volatile atomic<T>* obj, typename atomic<T>::difference_type) noexcept;
+// template<class T>
+//     T
+//     atomic_fetch_add(volatile atomic<T>* obj, atomic<T>::difference_type) noexcept;
 //
-// template <class T>
-//     T*
-//     atomic_fetch_add(atomic<T*>* obj, typename atomic<T>::difference_type) noexcept;
+// template<class T>
+//     T
+//     atomic_fetch_add(atomic<T>* obj, atomic<T>::difference_type) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 

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
 
 // <atomic>
 
-// template <class Integral>
-//     Integral
-//     atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op,
-//                               memory_order m);
-// template <class Integral>
-//     Integral
-//     atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op,
-//                               memory_order m);
-// template <class T>
-//     T*
-//     atomic_fetch_add_explicit(volatile atomic<T*>* obj, ptrdiff_t op,
-//                               memory_order m);
-// template <class T>
-//     T*
-//     atomic_fetch_add_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m);
+// template<class T>
+//     T
+//     atomic_fetch_add_explicit(volatile atomic<T>*, atomic<T>::difference_type,
+//                               memory_order) noexcept;
+//
+// template<class T>
+//     T
+//     atomic_fetch_add_explicit(atomic<T>*, atomic<T>::difference_type,
+//                               memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.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
 
 // <atomic>
 
-// template <class Integral>
-//     Integral
-//     atomic_fetch_and(volatile atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_and(volatile atomic<T>*, atomic<T>::value_type) noexcept;
 //
-// template <class Integral>
-//     Integral
-//     atomic_fetch_and(atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_and(atomic<T>*, atomic<T>::value_type) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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(T(1));
         assert(std::atomic_fetch_and(&t, T(2)) == T(1));
         assert(t == T(0));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_and(&t, T(2)));
     }
     {
         typedef std::atomic<T> A;
         volatile A t(T(3));
         assert(std::atomic_fetch_and(&t, T(2)) == T(3));
         assert(t == T(2));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_and(&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

 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // <atomic>
 
-// template <class Integral>
-//     Integral
-//     atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_and_explicit(volatile atomic<T>*, atomic<T>::value_type,
+//                               memory_order) noexcept;
 //
-// template <class Integral>
-//     Integral
-//     atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_and_explicit(atomic<T>*, atomic<T>::value_type,
+//                               memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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(T(1));
         assert(std::atomic_fetch_and_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(1));
         assert(t == T(0));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_and_explicit(&t, T(2), std::memory_order_seq_cst));
     }
     {
         typedef std::atomic<T> A;
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_and_explicit(&t, T(2), std::memory_order_seq_cst));
     }
   }
 };
 
 int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.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
 
 // <atomic>
 
-// template <class Integral>
-//     Integral
-//     atomic_fetch_or(volatile atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_or(volatile atomic<T>*, atomic<T>::value_type) noexcept;
 //
-// template <class Integral>
-//     Integral
-//     atomic_fetch_or(atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_or(atomic<T>*, atomic<T>::value_type) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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(T(1));
         assert(std::atomic_fetch_or(&t, T(2)) == T(1));
         assert(t == T(3));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_or(&t, T(2)));
     }
     {
         typedef std::atomic<T> A;
         volatile A t(T(3));
         assert(std::atomic_fetch_or(&t, T(2)) == T(3));
         assert(t == T(3));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_or(&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_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
 
 // <atomic>
 
-// template <class Integral>
-//     Integral
-//     atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_or_explicit(volatile atomic<T>*, atomic<T>::value_type,
+//                              memory_order) noexcept;
 //
-// template <class Integral>
-//     Integral
-//     atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_or_explicit(atomic<T>*, atomic<T>::value_type,
+//                              memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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(T(1));
         assert(std::atomic_fetch_or_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(1));
         assert(t == T(3));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_or_explicit(&t, T(2), std::memory_order_seq_cst));
     }
     {
         typedef std::atomic<T> A;
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_or_explicit(&t, T(2), std::memory_order_seq_cst));
     }
   }
 };
 
 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
 
 // <atomic>
 
-// template <class Integral>
-//     Integral
-//     atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op);
-//
-// template <class Integral>
-//     Integral
-//     atomic_fetch_sub(atomic<Integral>* obj, Integral op);
-//
-// template <class T>
-//     T*
-//     atomic_fetch_sub(volatile atomic<T*>* obj, ptrdiff_t op);
+// template<class T>
+//     T
+//     atomic_fetch_sub(volatile atomic<T>*, atomic<T>::difference_type) noexcept;
 //
-// template <class T>
-//     T*
-//     atomic_fetch_sub(atomic<T*>* obj, ptrdiff_t op);
+// template<class T>
+//     T
+//     atomic_fetch_sub(atomic<T>*, atomic<T>::difference_type) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 

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
 
 // <atomic>
 
-// template <class Integral>
-//     Integral
-//     atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op,
-//                               memory_order m);
-// template <class Integral>
-//     Integral
-//     atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,
-//                               memory_order m);
-//
-// template <class T>
-//     T*
-//     atomic_fetch_sub_explicit(volatile atomic<T*>* obj, ptrdiff_t op,
-//                               memory_order m);
-// template <class T>
-//     T*
-//     atomic_fetch_sub_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m);
+// template<class T>
+//     T
+//     atomic_fetch_sub_explicit(volatile atomic<T>*, atomic<T>::difference_type,
+//                               memory_order) noexcept;
+//
+// template<class T>
+//     T
+//     atomic_fetch_sub_explicit(atomic<T>*, atomic<T>::difference_type,
+//                               memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.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
 
 // <atomic>
 
-// template <class Integral>
-//     Integral
-//     atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_xor(volatile atomic<T>*, atomic<T>::value_type) noexcept;
 //
-// template <class Integral>
-//     Integral
-//     atomic_fetch_xor(atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_xor(atomic<T>*, atomic<T>::value_type) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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(T(1));
         assert(std::atomic_fetch_xor(&t, T(2)) == T(1));
         assert(t == T(3));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_xor(&t, T(2)));
     }
     {
         typedef std::atomic<T> A;
         volatile A t(T(3));
         assert(std::atomic_fetch_xor(&t, T(2)) == T(3));
         assert(t == T(1));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_xor(&t, T(2)));
     }
   }
 };
 
 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

 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // <atomic>
 
-// template <class Integral>
-//     Integral
-//     atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_xor_explicit(volatile atomic<T>*, atomic<T>::value_type,
+//                               memory_order) noexcept;
 //
-// template <class Integral>
-//     Integral
-//     atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op);
+// template<class T>
+//     T
+//     atomic_fetch_xor_explicit(atomic<T>*, atomic<T>::value_type,
+//                               memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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(T(1));
         assert(std::atomic_fetch_xor_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(1));
         assert(t == T(3));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_xor_explicit(&t, T(2), std::memory_order_seq_cst));
     }
     {
         typedef std::atomic<T> A;
         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));
+
+        ASSERT_NOEXCEPT(std::atomic_fetch_xor_explicit(&t, T(2), std::memory_order_seq_cst));
     }
   }
 };
 
 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);
+//     atomic_init(volatile atomic<T>* obj, atomic<T>::value_type desr) noexcept;
 //
 // template <class T>
 //     void
-//     atomic_init(atomic<T>* obj, T desr);
+//     atomic_init(atomic<T>* obj, atomic<T>::value_type desr) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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));
     assert(t == T(1));
     volatile A vt;
     std::atomic_init(&vt, T(2));
     assert(vt == T(2));
+
+    ASSERT_NOEXCEPT(std::atomic_init(&t, T(1)));
+    ASSERT_NOEXCEPT(std::atomic_init(&vt, T(2)));
   }
 };
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.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: !is-lockfree-runtime-function
 
 // <atomic>
 
 // template <class T>
-// bool atomic_is_lock_free(const volatile atomic<T>* obj);
+// bool atomic_is_lock_free(const volatile atomic<T>* obj) noexcept;
 //
 // template <class T>
-// bool atomic_is_lock_free(const atomic<T>* obj);
+// bool atomic_is_lock_free(const atomic<T>* obj) noexcept;
 
 #include <atomic>
 #include <cassert>
 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
     T t = T();
     A a(t);
     bool b1 = std::atomic_is_lock_free(static_cast<const A*>(&a));
     volatile A va(t);
     bool b2 = std::atomic_is_lock_free(static_cast<const volatile A*>(&va));
     assert(b1 == b2);
+
+    ASSERT_NOEXCEPT(std::atomic_is_lock_free(static_cast<const A*>(&a)));
+    ASSERT_NOEXCEPT(std::atomic_is_lock_free(static_cast<const volatile A*>(&va)));
   }
 };
 
 struct A {
   char x[4];
 };
 
 int main(int, char**) {
   TestFn<A>()();
   TestEachAtomicType<TestFn>()();
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.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 35
 
 // <atomic>
 
 // template <class T>
 //     T
-//     atomic_load(const volatile atomic<T>* obj);
+//     atomic_load(const volatile atomic<T>*) noexcept;
 //
 // template <class T>
 //     T
-//     atomic_load(const atomic<T>* obj);
+//     atomic_load(const atomic<T>*) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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(T(1));
     assert(std::atomic_load(&t) == T(1));
     volatile A vt(T(2));
     assert(std::atomic_load(&vt) == T(2));
+
+    ASSERT_NOEXCEPT(std::atomic_load(&t));
+    ASSERT_NOEXCEPT(std::atomic_load(&vt));
   }
 };
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_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
 // XFAIL: !non-lockfree-atomics
-//  ... assertion fails line 31
 
 // <atomic>
 
 // template <class T>
 //     T
-//     atomic_load_explicit(const volatile atomic<T>* obj, memory_order m);
+//     atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept;
 //
 // template <class T>
 //     T
-//     atomic_load_explicit(const atomic<T>* obj, memory_order m);
+//     atomic_load_explicit(const atomic<T>*, memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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(T(1));
     assert(std::atomic_load_explicit(&t, std::memory_order_seq_cst) == T(1));
     volatile A vt(T(2));
     assert(std::atomic_load_explicit(&vt, std::memory_order_seq_cst) == T(2));
+
+    ASSERT_NOEXCEPT(std::atomic_load_explicit(&t, std::memory_order_seq_cst));
+    ASSERT_NOEXCEPT(std::atomic_load_explicit(&vt, std::memory_order_seq_cst));
   }
 };
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.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
 
 // <atomic>
 
 // template <class T>
 //     void
-//     atomic_store(volatile atomic<T>* obj, T desr);
+//     atomic_store(volatile atomic<T>*, atomic<T>::value_type) noexcept;
 //
 // template <class T>
 //     void
-//     atomic_store(atomic<T>* obj, T desr);
+//     atomic_store(atomic<T>*, atomic<T>::value_type) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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_store(&t, T(1));
     assert(t == T(1));
     volatile A vt;
     std::atomic_store(&vt, T(2));
     assert(vt == T(2));
+
+    ASSERT_NOEXCEPT(std::atomic_store(&t, T(1)));
+    ASSERT_NOEXCEPT(std::atomic_store(&vt, T(2)));
   }
 };
 
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_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
 // XFAIL: !non-lockfree-atomics
 
 // <atomic>
 
 // template <class T>
 //     void
-//     atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m);
+//     atomic_store_explicit(volatile atomic<T>*, atomic<T>::value_type,
+//                           memory_order) noexcept;
 //
 // template <class T>
 //     void
-//     atomic_store_explicit(atomic<T>* obj, T desr, memory_order m);
+//     atomic_store_explicit(atomic<T>*, atomic<T>::value_type,
+//                           memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #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_store_explicit(&t, T(1), std::memory_order_seq_cst);
     assert(t == T(1));
     volatile A vt;
     std::atomic_store_explicit(&vt, T(2), std::memory_order_seq_cst);
     assert(vt == T(2));
+
+    ASSERT_NOEXCEPT(std::atomic_store_explicit(&t, T(1), std::memory_order_seq_cst));
+    ASSERT_NOEXCEPT(std::atomic_store_explicit(&vt, T(2), std::memory_order_seq_cst));
   }
 };
 
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_notify_all.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: c++03
+// XFAIL: !non-lockfree-atomics
+
+// This test requires the dylib support introduced in D68480, which shipped in
+// macOS 11.0.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
+
+// <atomic>
+
+// template<class T>
+//     void
+//     atomic_notify_all(volatile atomic<T>*);
+//
+// template<class T>
+//     void
+//     atomic_notify_all(atomic<T>*);
+
+#include <atomic>
+#include <type_traits>
+#include <cassert>
+#include <thread>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+#include "atomic_helpers.h"
+
+template <class T>
+struct TestFn {
+  void operator()() const {
+    typedef std::atomic<T> A;
+
+    {
+      A a(T(1));
+      auto f = [&]() {
+        assert(std::atomic_load(&a) == T(1));
+        std::atomic_wait(&a, T(1));
+        assert(std::atomic_load(&a) == T(3));
+      };
+      std::thread t1 = support::make_test_thread(f);
+      std::thread t2 = support::make_test_thread(f);
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+      std::atomic_store(&a, T(3));
+      std::atomic_notify_all(&a);
+      t1.join();
+      t2.join();
+    }
+    {
+      volatile A a(T(2));
+      auto f = [&]() {
+        assert(std::atomic_load(&a) == T(2));
+        std::atomic_wait(&a, T(2));
+        assert(std::atomic_load(&a) == T(4));
+      };
+      std::thread t1 = support::make_test_thread(f);
+      std::thread t2 = support::make_test_thread(f);
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+      std::atomic_store(&a, T(4));
+      std::atomic_notify_all(&a);
+      t1.join();
+      t2.join();
+    }
+  }
+};
+
+int main(int, char**) {
+  TestEachAtomicType<TestFn>()();
+
+  return 0;
+}

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

 // XFAIL: !non-lockfree-atomics
 
 // This test requires the dylib support introduced in D68480, which shipped in
 // macOS 11.0.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
 // <atomic>
 
+// template<class T>
+//     void
+//     atomic_notify_one(volatile atomic<T>*);
+//
+// template<class T>
+//     void
+//     atomic_notify_one(atomic<T>*);
+
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 #include <thread>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
 
-    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);
+    {
+      A a(T(1));
+      std::thread t = support::make_test_thread([&]() {
+        std::atomic_store(&a, T(3));
+        std::atomic_notify_one(&a);
       });
-    std::atomic_wait(&t, T(1));
-    t1.join();
-
-    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(&a, T(1));
+      assert(std::atomic_load(&a) == T(3));
+      t.join();
+    }
+    {
+      volatile A a(T(2));
+      std::thread t = support::make_test_thread([&]() {
+        std::atomic_store(&a, T(4));
+        std::atomic_notify_one(&a);
       });
-    std::atomic_wait(&vt, T(2));
-    t2.join();
+      std::atomic_wait(&a, T(2));
+      assert(std::atomic_load(&a) == T(4));
+      t.join();
+    }
   }
 };
 
-int main(int, char**)
-{
-    TestEachAtomicType<TestFn>()();
+int main(int, char**) {
 
   return 0;
 }

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

 // XFAIL: !non-lockfree-atomics
 
 // This test requires the dylib support introduced in D68480, which shipped in
 // macOS 11.0.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
 // <atomic>
 
+// template<class T>
+//     void
+//     atomic_wait(const volatile atomic<T>*, atomic<T>::value_type);
+//
+// template<class T>
+//     void
+//     atomic_wait(const atomic<T>*, atomic<T>::value_type);
+
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 #include <thread>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
-
+    {
       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::thread t1 = support::make_test_thread([&]() {
         std::atomic_store(&t, T(3));
         std::atomic_notify_one(&t);
       });
       std::atomic_wait(&t, T(1));
+      assert(std::atomic_load(&t) == T(3));
       t1.join();
-
+    }
+    {
       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::thread t2 = support::make_test_thread([&]() {
         std::atomic_store(&vt, T(4));
         std::atomic_notify_one(&vt);
       });
       std::atomic_wait(&vt, T(2));
+      assert(std::atomic_load(&vt) == T(4));
       t2.join();
     }
+  }
 };
 
-int main(int, char**)
-{
-    TestEachAtomicType<TestFn>()();
+int main(int, char**) {
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_wait_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
+// XFAIL: c++03
+// XFAIL: !non-lockfree-atomics
+
+// This test requires the dylib support introduced in D68480, which shipped in
+// macOS 11.0.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
+
+// <atomic>
+
+// template<class T>
+//     void
+//     atomic_wait_explicit(const volatile atomic<T>*, atomic<T>::value_type,
+//                          memory_order);
+//
+// template<class T>
+//     void
+//     atomic_wait_explicit(const volatile atomic<T>*, atomic<T>::value_type,
+//                          memory_order);
+
+#include <atomic>
+#include <type_traits>
+#include <cassert>
+#include <thread>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+#include "atomic_helpers.h"
+
+template <class T>
+struct TestFn {
+  void operator()() const {
+    typedef std::atomic<T> A;
+    {
+      A t(T(1));
+      assert(std::atomic_load(&t) == T(1));
+      std::atomic_wait_explicit(&t, T(0), std::memory_order_seq_cst);
+      std::thread t1 = support::make_test_thread([&]() {
+        std::atomic_store(&t, T(3));
+        std::atomic_notify_one(&t);
+      });
+      std::atomic_wait_explicit(&t, T(1), std::memory_order_seq_cst);
+      assert(std::atomic_load(&t) == T(3));
+      t1.join();
+    }
+    {
+      volatile A vt(T(2));
+      assert(std::atomic_load(&vt) == T(2));
+      std::atomic_wait_explicit(&vt, T(1), std::memory_order_seq_cst);
+      std::thread t2 = support::make_test_thread([&]() {
+        std::atomic_store(&vt, T(4));
+        std::atomic_notify_one(&vt);
+      });
+      std::atomic_wait_explicit(&vt, T(2), std::memory_order_seq_cst);
+      assert(std::atomic_load(&vt) == T(4));
+      t2.join();
+    }
+  }
+};
+
+int main(int, char**) {
+  TestEachAtomicType<TestFn>()();
+
+  return 0;
+}