Bring atomic header closer to C++20

[__simt__]

Summary

This patch:

1. Adds missing feature test macros for atomic
2. Updates the synopsis of atomic to match what's in the file
3. Fills out the implemented features table
4. Correctly uses the dependent types on atomic free functions
5. Correctly uses memcpy in non-lock-free atomic CAS
6. Adds missing tests for atomic_flag member functions
7. Adds missing test cases for non-lock-free atomic objects

It seems to have also picked up some feature-test macro generated tests that were missing (?).

At present I have tested only on Linux but I'll test on Mac before submitting.

[__simt__]

I figured out I could abandon most of the noisy changes. Dropping them out.

[jfb]

Generally this looks good, but I didn't go into details.
It would be good to have an MS person like @STL_MSFT check that the std tests match, at least for what they've implemented.

libcxx/include/atomic

1255

Unrelated to your change, but the lock could come after __temp?

[ldionne]

LGTM, but please remove whitespace changes in generate_feature_test_macro_components.py if I read the diff right. We can do those separately and ignore that git rev when blaming.

libcxx/utils/generate_feature_test_macro_components.py

90

You seem to have whitespace changes here? Or am I reading the Phabricator diff wrong?

[__simt__]

libcxx/include/atomic

1255

Yep.

[__simt__]

libcxx/utils/generate_feature_test_macro_components.py

90

Hmm. Fixing. Not sure why this is there.

[__simt__]

Removed spurious whitespace changes

[__simt__]

This version is now clean on Mac and Linux

[STL_MSFT]

@jfb

It would be good to have an MS person like @STL_MSFT check that the std tests match, at least for what they've implemented.

Unfortunately, we are currently unable to update our llvm-project submodule because a recent change to lit broke our test infrastructure - see https://github.com/microsoft/STL/pull/1090 . When we resolve that, we'll be able to run these tests against our atomic, but don't block on us. (If we find any issues we'll report back and/or submit a Phab PR and/or skip the affected tests in https://github.com/microsoft/STL/blob/master/tests/libcxx/skipped_tests.txt .)

[ldionne]

In D87323#2262235, @STL_MSFT wrote:

@jfb

It would be good to have an MS person like @STL_MSFT check that the std tests match, at least for what they've implemented.

Unfortunately, we are currently unable to update our llvm-project submodule because a recent change to lit broke our test infrastructure - see https://github.com/microsoft/STL/pull/1090 . When we resolve that, we'll be able to run these tests against our atomic, but don't block on us. (If we find any issues we'll report back and/or submit a Phab PR and/or skip the affected tests in https://github.com/microsoft/STL/blob/master/tests/libcxx/skipped_tests.txt .)

Hmm, I wasn’t aware of that, but the breakage should have been expected. I’ll help you guys resolve the issue. The intent is to make it a lot easier to run the test suite by other vendors— actually to make such support first class.

[ldionne]

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

143

Can you please add a comment here saying #ifndef __APPLE__ // Apples doesn't ship libatomic so that we can at least enable that part of the test when/if we ship it?

[ldionne]

This was committed in fc4bff0cd37fa84ee74e6dff7170b643df3ffa42.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_variant``                             ``201606L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_void_t``                              ``201411L``      
     ------------------------------------------------- -----------------
     **C++ 2a**                                                         
     -------------------------------------------------------------------
     ``__cpp_lib_array_constexpr``                     ``201811L``      
     ------------------------------------------------- -----------------
+    ``__cpp_lib_atomic_flag_test``                    ``201907L``      
+    ------------------------------------------------- -----------------
+    ``__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_wait``                         ``201907L``      
+    ------------------------------------------------- -----------------
     ``__cpp_lib_bind_front``                          *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_bit_cast``                            *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_char8_t``                             ``201811L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_concepts``                            *unimplemented*  
     ------------------------------------------------- -----------------

libcxx/include/atomic

 #define _LIBCPP_ATOMIC
 
 /*
     atomic synopsis
 
 namespace std
 {
 
-// feature test macro
+// feature test macro [version.syn]
 
-#define __cpp_lib_atomic_is_always_lock_free // as specified by SG10
+#define __cpp_lib_atomic_is_always_lock_free
+#define __cpp_lib_atomic_flag_test
+#define __cpp_lib_atomic_lock_free_type_aliases
+#define __cpp_lib_atomic_wait
 
  // order and consistency
 
  enum memory_order: unspecified // enum class in C++20
  {
     relaxed,
     consume, // load-consume
     acquire, // load-acquire
struct atomic
     void notify_all() volatile noexcept;
     void notify_all() noexcept;
 };
 
 template <>
 struct atomic<integral>
 {
     using value_type = integral;
+    using difference_type = value_type;
 
     static constexpr bool is_always_lock_free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
 
     atomic() noexcept = default;
     constexpr atomic(integral desr) noexcept;
     atomic(const atomic&) = delete;
struct atomic<integral>
     void notify_all() volatile noexcept;
     void notify_all() noexcept;
 };
 
 template <class T>
 struct atomic<T*>
 {
     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;
     constexpr atomic(T* desr) noexcept;
     atomic(const atomic&) = delete;

 }
 
 template <typename _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool __cxx_atomic_compare_exchange_strong(volatile __cxx_atomic_lock_impl<_Tp>* __a,
                                           _Tp* __expected, _Tp __value, memory_order, memory_order) {
   __a->__lock();
   _Tp __temp;
   __cxx_atomic_assign_volatile(__temp, __a->__a_value);
-  bool __ret = __temp == *__expected;
+  bool __ret = (memcmp(&__temp, __expected, sizeof(_Tp)) == 0);
   if(__ret)
     __cxx_atomic_assign_volatile(__a->__a_value, __value);
   else
     __cxx_atomic_assign_volatile(*__expected, __a->__a_value);
   __a->__unlock();
   return __ret;
 }
 template <typename _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_lock_impl<_Tp>* __a,
                                           _Tp* __expected, _Tp __value, memory_order, memory_order) {
   __a->__lock();
-  bool __ret = __a->__a_value == *__expected;
+  bool __ret = (memcmp(&__a->__a_value, __expected, sizeof(_Tp)) == 0);
   if(__ret)
-    __a->__a_value = __value;
+    memcpy(&__a->__a_value, &__value, sizeof(_Tp));
   else
-    *__expected = __a->__a_value;
+    memcpy(__expected, &__a->__a_value, sizeof(_Tp));
   __a->__unlock();
   return __ret;
 }
 
 template <typename _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool __cxx_atomic_compare_exchange_weak(volatile __cxx_atomic_lock_impl<_Tp>* __a,
                                         _Tp* __expected, _Tp __value, memory_order, memory_order) {
   __a->__lock();
   _Tp __temp;
   __cxx_atomic_assign_volatile(__temp, __a->__a_value);
-  bool __ret = __temp == *__expected;
+  bool __ret = (memcmp(&__temp, __expected, sizeof(_Tp)) == 0);
   if(__ret)
     __cxx_atomic_assign_volatile(__a->__a_value, __value);
   else
     __cxx_atomic_assign_volatile(*__expected, __a->__a_value);
   __a->__unlock();
   return __ret;
 }
 template <typename _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_lock_impl<_Tp>* __a,
                                         _Tp* __expected, _Tp __value, memory_order, memory_order) {
   __a->__lock();
-  bool __ret = __a->__a_value == *__expected;
+  bool __ret = (memcmp(&__a->__a_value, __expected, sizeof(_Tp)) == 0);
   if(__ret)
-    __a->__a_value = __value;
+    memcpy(&__a->__a_value, &__value, sizeof(_Tp));
   else
-    *__expected = __a->__a_value;
+    memcpy(__expected, &__a->__a_value, sizeof(_Tp));
   __a->__unlock();
   return __ret;
 }
 
 template <typename _Tp, typename _Td>
 _LIBCPP_INLINE_VISIBILITY
 _Tp __cxx_atomic_fetch_add(volatile __cxx_atomic_lock_impl<_Tp>* __a,
                            _Td __delta, memory_order) {

 // atomic<T>
 
 template <class _Tp>
 struct atomic
     : public __atomic_base<_Tp>
 {
     typedef __atomic_base<_Tp> __base;
     typedef _Tp value_type;
+    typedef value_type 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
         {__base::store(__d); return __d;}
 };
 
 // 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;}
atomic_is_lock_free(const atomic<_Tp>* __o) _NOEXCEPT
     return __o->is_lock_free();
 }
 
 // atomic_init
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 void
-atomic_init(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
+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
 void
-atomic_init(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
+atomic_init(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     __cxx_atomic_init(&__o->__a_, __d);
 }
 
 // atomic_store
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 void
-atomic_store(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
+atomic_store(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     __o->store(__d);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 void
-atomic_store(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
+atomic_store(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     __o->store(__d);
 }
 
 // atomic_store_explicit
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 void
-atomic_store_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
+atomic_store_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, memory_order __m) _NOEXCEPT
   _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
 {
     __o->store(__d, __m);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 void
-atomic_store_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
+atomic_store_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, memory_order __m) _NOEXCEPT
   _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
 {
     __o->store(__d, __m);
 }
 
 // atomic_load
 
 template <class _Tp>
_LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
     return __o->load(__m);
 }
 
 // atomic_exchange
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 _Tp
-atomic_exchange(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
+atomic_exchange(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     return __o->exchange(__d);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 _Tp
-atomic_exchange(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
+atomic_exchange(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     return __o->exchange(__d);
 }
 
 // atomic_exchange_explicit
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 _Tp
-atomic_exchange_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
+atomic_exchange_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, memory_order __m) _NOEXCEPT
 {
     return __o->exchange(__d, __m);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 _Tp
-atomic_exchange_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
+atomic_exchange_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, memory_order __m) _NOEXCEPT
 {
     return __o->exchange(__d, __m);
 }
 
 // atomic_compare_exchange_weak
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool
-atomic_compare_exchange_weak(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
+atomic_compare_exchange_weak(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     return __o->compare_exchange_weak(*__e, __d);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool
-atomic_compare_exchange_weak(atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
+atomic_compare_exchange_weak(atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     return __o->compare_exchange_weak(*__e, __d);
 }
 
 // atomic_compare_exchange_strong
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool
-atomic_compare_exchange_strong(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
+atomic_compare_exchange_strong(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     return __o->compare_exchange_strong(*__e, __d);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool
-atomic_compare_exchange_strong(atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
+atomic_compare_exchange_strong(atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
     return __o->compare_exchange_strong(*__e, __d);
 }
 
 // atomic_compare_exchange_weak_explicit
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool
-atomic_compare_exchange_weak_explicit(volatile atomic<_Tp>* __o, _Tp* __e,
-                                      _Tp __d,
+atomic_compare_exchange_weak_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e,
+                                      typename atomic<_Tp>::value_type __d,
                                       memory_order __s, memory_order __f) _NOEXCEPT
   _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
 {
     return __o->compare_exchange_weak(*__e, __d, __s, __f);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool
-atomic_compare_exchange_weak_explicit(atomic<_Tp>* __o, _Tp* __e, _Tp __d,
+atomic_compare_exchange_weak_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d,
                                       memory_order __s, memory_order __f) _NOEXCEPT
   _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
 {
     return __o->compare_exchange_weak(*__e, __d, __s, __f);
 }
 
 // atomic_compare_exchange_strong_explicit
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool
 atomic_compare_exchange_strong_explicit(volatile atomic<_Tp>* __o,
-                                        _Tp* __e, _Tp __d,
+                                        typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d,
                                         memory_order __s, memory_order __f) _NOEXCEPT
   _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
 {
     return __o->compare_exchange_strong(*__e, __d, __s, __f);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 bool
-atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, _Tp* __e,
-                                        _Tp __d,
+atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e,
+                                        typename atomic<_Tp>::value_type __d,
                                         memory_order __s, memory_order __f) _NOEXCEPT
   _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
 {
     return __o->compare_exchange_strong(*__e, __d, __s, __f);
 }
 
 // atomic_wait
 

 }
 
 // atomic_fetch_add
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
+    is_pointer<_Tp>::value || (is_integral<_Tp>::value && !is_same<_Tp, bool>::value),
     _Tp
 >::type
-atomic_fetch_add(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
+atomic_fetch_add(volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT
 {
     return __o->fetch_add(__op);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
+    is_pointer<_Tp>::value || (is_integral<_Tp>::value && !is_same<_Tp, bool>::value),
     _Tp
 >::type
-atomic_fetch_add(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
-{
-    return __o->fetch_add(__op);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-atomic_fetch_add(volatile atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT
-{
-    return __o->fetch_add(__op);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-atomic_fetch_add(atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT
+atomic_fetch_add(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT
 {
     return __o->fetch_add(__op);
 }
 
 // atomic_fetch_add_explicit
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
+    is_pointer<_Tp>::value || (is_integral<_Tp>::value && !is_same<_Tp, bool>::value),
     _Tp
 >::type
-atomic_fetch_add_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
+atomic_fetch_add_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_add(__op, __m);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
+    is_pointer<_Tp>::value || (is_integral<_Tp>::value && !is_same<_Tp, bool>::value),
     _Tp
 >::type
-atomic_fetch_add_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_add(__op, __m);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-atomic_fetch_add_explicit(volatile atomic<_Tp*>* __o, ptrdiff_t __op,
-                          memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_add(__op, __m);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-atomic_fetch_add_explicit(atomic<_Tp*>* __o, ptrdiff_t __op, memory_order __m) _NOEXCEPT
+atomic_fetch_add_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_add(__op, __m);
 }
 
 // atomic_fetch_sub
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
+    is_pointer<_Tp>::value || (is_integral<_Tp>::value && !is_same<_Tp, bool>::value),
     _Tp
 >::type
-atomic_fetch_sub(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
+atomic_fetch_sub(volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT
 {
     return __o->fetch_sub(__op);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
+    is_pointer<_Tp>::value || (is_integral<_Tp>::value && !is_same<_Tp, bool>::value),
     _Tp
 >::type
-atomic_fetch_sub(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
-{
-    return __o->fetch_sub(__op);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-atomic_fetch_sub(volatile atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT
-{
-    return __o->fetch_sub(__op);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-atomic_fetch_sub(atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT
+atomic_fetch_sub(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT
 {
     return __o->fetch_sub(__op);
 }
 
 // atomic_fetch_sub_explicit
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
+    is_pointer<_Tp>::value || (is_integral<_Tp>::value && !is_same<_Tp, bool>::value),
     _Tp
 >::type
-atomic_fetch_sub_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
+atomic_fetch_sub_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_sub(__op, __m);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
+    is_pointer<_Tp>::value || (is_integral<_Tp>::value && !is_same<_Tp, bool>::value),
     _Tp
 >::type
-atomic_fetch_sub_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_sub(__op, __m);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-atomic_fetch_sub_explicit(volatile atomic<_Tp*>* __o, ptrdiff_t __op,
-                          memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_sub(__op, __m);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-atomic_fetch_sub_explicit(atomic<_Tp*>* __o, ptrdiff_t __op, memory_order __m) _NOEXCEPT
+atomic_fetch_sub_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_sub(__op, __m);
 }
 
 // atomic_fetch_and
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_and(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
+atomic_fetch_and(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_and(__op);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_and(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
+atomic_fetch_and(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_and(__op);
 }
 
 // atomic_fetch_and_explicit
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_and_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
+atomic_fetch_and_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_and(__op, __m);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_and_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
+atomic_fetch_and_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_and(__op, __m);
 }
 
 // atomic_fetch_or
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_or(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
+atomic_fetch_or(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_or(__op);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_or(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
+atomic_fetch_or(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_or(__op);
 }
 
 // atomic_fetch_or_explicit
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_or_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
+atomic_fetch_or_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_or(__op, __m);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_or_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
+atomic_fetch_or_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_or(__op, __m);
 }
 
 // atomic_fetch_xor
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_xor(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
+atomic_fetch_xor(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_xor(__op);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_xor(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
+atomic_fetch_xor(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_xor(__op);
 }
 
 // atomic_fetch_xor_explicit
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_xor_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
+atomic_fetch_xor_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_xor(__op, __m);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
     _Tp
 >::type
-atomic_fetch_xor_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
+atomic_fetch_xor_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_xor(__op, __m);
 }
 
 // flag type and operations
 
 typedef struct atomic_flag
 {

libcxx/include/version

__cpp_lib_allocator_traits_is_always_equal              201411L <memory> <scoped_allocator> <string>
                                                                 <deque> <forward_list> <list>
                                                                 <vector> <map> <set>
                                                                 <unordered_map> <unordered_set>
 __cpp_lib_any                                           201606L <any>
 __cpp_lib_apply                                         201603L <tuple>
 __cpp_lib_array_constexpr                               201811L <iterator> <array>
                                                         201603L // C++17
 __cpp_lib_as_const                                      201510L <utility>
+__cpp_lib_atomic_flag_test                              201907L <atomic>
+__cpp_lib_atomic_float                                  201711L <atomic>
 __cpp_lib_atomic_is_always_lock_free                    201603L <atomic>
+__cpp_lib_atomic_lock_free_type_aliases                 201907L <atomic>
 __cpp_lib_atomic_ref                                    201806L <atomic>
+__cpp_lib_atomic_shared_ptr                             201711L <atomic>
+__cpp_lib_atomic_value_initialization                   201911L <atomic> <memory>
+__cpp_lib_atomic_wait                                   201907L <atomic>
 __cpp_lib_bind_front                                    201811L <functional>
 __cpp_lib_bit_cast                                      201806L <bit>
 __cpp_lib_bool_constant                                 201505L <type_traits>
 __cpp_lib_boyer_moore_searcher                          201603L <functional>
 __cpp_lib_byte                                          201603L <cstddef>
 __cpp_lib_char8_t                                       201811L <atomic> <filesystem> <istream>
                                                                 <limits> <locale> <ostream>
                                                                 <string> <string_view>

 # define __cpp_lib_variant                              201606L
 # define __cpp_lib_void_t                               201411L
 #endif
 
 #if _LIBCPP_STD_VER > 17
 # undef  __cpp_lib_array_constexpr
 # define __cpp_lib_array_constexpr                      201811L
 # if !defined(_LIBCPP_HAS_NO_THREADS)
+#   define __cpp_lib_atomic_flag_test                   201907L
+# endif
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+// #   define __cpp_lib_atomic_float                       201711L
+# endif
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   define __cpp_lib_atomic_lock_free_type_aliases      201907L
+# 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
+# endif
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   define __cpp_lib_atomic_wait                        201907L
+# endif
 // # define __cpp_lib_bind_front                           201811L
 // # define __cpp_lib_bit_cast                             201806L
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 // # define __cpp_lib_concepts                             201806L
 // # define __cpp_lib_constexpr_misc                       201811L
 // # define __cpp_lib_constexpr_swap_algorithms            201806L
 # define __cpp_lib_constexpr_utility                    201811L
 # if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
 #   define __cpp_lib_destroying_delete                  201806L
 # endif
 # define __cpp_lib_endian                               201907L
 # define __cpp_lib_erase_if                             202002L
 // # define __cpp_lib_generic_unordered_lookup             201811L
 # define __cpp_lib_interpolate                          201902L
 # if !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
 #   define __cpp_lib_is_constant_evaluated              201811L
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
 # if defined(__cpp_concepts) && __cpp_concepts >= 201811L
 #   define __cpp_lib_math_constants                     201907L
 # endif
  // # define __cpp_lib_ranges                               201811L
 # define __cpp_lib_span                                 202002L
 // # define __cpp_lib_three_way_comparison                 201711L
 # define __cpp_lib_to_array                             201907L
 #endif
 
 #endif // _LIBCPP_VERSIONH

libcxx/test/std/atomics/atomics.flag/atomic_flag_test.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>
+
+// struct atomic_flag
+
+// bool atomic_flag_test_and_set(volatile atomic_flag*);
+// bool atomic_flag_test_and_set(atomic_flag*);
+
+#include <atomic>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+        std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_and_set(&f) == 0);
+        assert(f.test_and_set() == 1);
+    }
+    {
+        volatile std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_and_set(&f) == 0);
+        assert(f.test_and_set() == 1);
+    }
+
+  return 0;
+}

libcxx/test/std/atomics/atomics.flag/atomic_flag_test_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>
+
+// struct atomic_flag
+
+// bool atomic_flag_test_explicit(volatile atomic_flag*, memory_order);
+// bool atomic_flag_test_explicit(atomic_flag*, memory_order);
+
+#include <atomic>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+        std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 1);
+    }
+    {
+        std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_consume) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_consume) == 1);
+    }
+    {
+        std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_acquire) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_acquire) == 1);
+    }
+    {
+        std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_release) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_release) == 1);
+    }
+    {
+        std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 1);
+    }
+    {
+        std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 1);
+    }
+    {
+        volatile std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_relaxed) == 1);
+    }
+    {
+        volatile std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_consume) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_consume) == 1);
+    }
+    {
+        volatile std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_acquire) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_acquire) == 1);
+    }
+    {
+        volatile std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_release) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_release) == 1);
+    }
+    {
+        volatile std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_acq_rel) == 1);
+    }
+    {
+        volatile std::atomic_flag f;
+        f.clear();
+        assert(atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 0);
+        assert(f.test_and_set() == 0);
+        assert(atomic_flag_test_explicit(&f, std::memory_order_seq_cst) == 1);
+    }
+
+  return 0;
+}

libcxx/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp

#endif // __has_attribute(vector_size) && defined(_LIBCPP_VERSION)
     static_assert(std::atomic<unsigned short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE), "");
     static_assert(std::atomic<int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE), "");
     static_assert(std::atomic<unsigned int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE), "");
     static_assert(std::atomic<long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE), "");
     static_assert(std::atomic<unsigned long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE), "");
     checkLongLongTypes();
     static_assert(std::atomic<void*>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE), "");
     static_assert(std::atomic<std::nullptr_t>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE), "");
+
+#if TEST_STD_VER >= 20
+    static_assert(std::atomic<std::atomic_signed_lock_free>::is_always_lock_free, "");
+    static_assert(std::atomic<std::atomic_unsigned_lock_free>::is_always_lock_free, "");
+#endif
 }
 
 int main(int, char**) { run(); return 0; }

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

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

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

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.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));
-    assert(std::atomic_exchange(&t, T(2)) == T(1));
-    assert(t == T(2));
+    std::atomic_init(&t, 1);
+    assert(std::atomic_exchange(&t, 2) == 1);
+    assert(t == 2);
     volatile A vt;
-    std::atomic_init(&vt, T(3));
-    assert(std::atomic_exchange(&vt, T(4)) == T(3));
-    assert(vt == T(4));
+    std::atomic_init(&vt, 3);
+    assert(std::atomic_exchange(&vt, 4) == 3);
+    assert(vt == 4);
   }
 };
 
+template <class T>
+struct TestFn<T*> {
+  void operator()() const {
+    typedef std::atomic<T*> A;
+    A t;
+    std::atomic_init(&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);
+    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));
-    assert(std::atomic_exchange_explicit(&t, T(2), std::memory_order_seq_cst)
-           == T(1));
-    assert(t == T(2));
+    std::atomic_init(&t, 1);
+    assert(std::atomic_exchange_explicit(&t, 2, std::memory_order_seq_cst) == 1);
+    assert(t == 2);
     volatile A vt;
-    std::atomic_init(&vt, T(3));
-    assert(std::atomic_exchange_explicit(&vt, T(4), std::memory_order_seq_cst)
-           == T(3));
-    assert(vt == T(4));
+    std::atomic_init(&vt, 3);
+    assert(std::atomic_exchange_explicit(&vt, 4, std::memory_order_seq_cst) == 3);
+    assert(vt == 4);
   }
 };
 
+template <class T>
+struct TestFn<T*> {
+  void operator()() const {
+    typedef std::atomic<T*> A;
+    A t;
+    std::atomic_init(&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);
+    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

 #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(std::atomic_fetch_add(&t, T(2)) == T(1));
-        assert(t == T(3));
+        std::atomic_init(&t, 1);
+        assert(std::atomic_fetch_add(&t, 2) == 1);
+        assert(t == 3);
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
-        std::atomic_init(&t, T(1));
-        assert(std::atomic_fetch_add(&t, T(2)) == T(1));
-        assert(t == T(3));
+        std::atomic_init(&t, 1);
+        assert(std::atomic_fetch_add(&t, 2) == 1);
+        assert(t == 3);
     }
   }
 };
 
 template <class T>
 void testp()
 {
     {

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

 
 template <class T>
 struct TestFn {
   void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(1));
-        assert(std::atomic_fetch_add_explicit(&t, T(2),
-                                            std::memory_order_seq_cst) == T(1));
-        assert(t == T(3));
+        assert(std::atomic_fetch_add_explicit(&t, 2,
+                                            std::memory_order_seq_cst) == 1);
+        assert(t == 3);
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
-        std::atomic_init(&t, T(1));
-        assert(std::atomic_fetch_add_explicit(&t, T(2),
-                                            std::memory_order_seq_cst) == T(1));
-        assert(t == T(3));
+        std::atomic_init(&t, 1);
+        assert(std::atomic_fetch_add_explicit(&t, 2,
+                                            std::memory_order_seq_cst) == 1);
+        assert(t == 3);
     }
   }
 };
 
 template <class T>
 void
 testp()
 {

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

 #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(std::atomic_fetch_and(&t, T(2)) == T(1));
-        assert(t == T(0));
+        std::atomic_init(&t, 1);
+        assert(std::atomic_fetch_and(&t, 2) == 1);
+        assert(t == 0);
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
-        std::atomic_init(&t, T(3));
-        assert(std::atomic_fetch_and(&t, T(2)) == T(3));
-        assert(t == T(2));
+        std::atomic_init(&t, 3);
+        assert(std::atomic_fetch_and(&t, 2) == 3);
+        assert(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 "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(std::atomic_fetch_and_explicit(&t, T(2),
-               std::memory_order_seq_cst) == T(1));
-        assert(t == T(0));
+        std::atomic_init(&t, 1);
+        assert(std::atomic_fetch_and_explicit(&t, 2,
+               std::memory_order_seq_cst) == 1);
+        assert(t == 0);
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
-        std::atomic_init(&t, T(3));
-        assert(std::atomic_fetch_and_explicit(&t, T(2),
-               std::memory_order_seq_cst) == T(3));
-        assert(t == T(2));
+        std::atomic_init(&t, 3);
+        assert(std::atomic_fetch_and_explicit(&t, 2,
+               std::memory_order_seq_cst) == 3);
+        assert(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 "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(std::atomic_fetch_or(&t, T(2)) == T(1));
-        assert(t == T(3));
+        std::atomic_init(&t, 1);
+        assert(std::atomic_fetch_or(&t, 2) == 1);
+        assert(t == 3);
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
-        std::atomic_init(&t, T(3));
-        assert(std::atomic_fetch_or(&t, T(2)) == T(3));
-        assert(t == T(3));
+        std::atomic_init(&t, 3);
+        assert(std::atomic_fetch_or(&t, 2) == 3);
+        assert(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 "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(std::atomic_fetch_or_explicit(&t, T(2),
-               std::memory_order_seq_cst) == T(1));
-        assert(t == T(3));
+        std::atomic_init(&t, 1);
+        assert(std::atomic_fetch_or_explicit(&t, 2,
+               std::memory_order_seq_cst) == 1);
+        assert(t == 3);
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
-        std::atomic_init(&t, T(3));
-        assert(std::atomic_fetch_or_explicit(&t, T(2),
-               std::memory_order_seq_cst) == T(3));
-        assert(t == T(3));
+        std::atomic_init(&t, 3);
+        assert(std::atomic_fetch_or_explicit(&t, 2,
+               std::memory_order_seq_cst) == 3);
+        assert(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

 #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));
-        assert(std::atomic_fetch_sub(&t, T(2)) == T(3));
-        assert(t == T(1));
+        std::atomic_init(&t, 3);
+        assert(std::atomic_fetch_sub(&t, 2) == 3);
+        assert(t == 1);
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
-        std::atomic_init(&t, T(3));
-        assert(std::atomic_fetch_sub(&t, T(2)) == T(3));
-        assert(t == T(1));
+        std::atomic_init(&t, 3);
+        assert(std::atomic_fetch_sub(&t, 2) == 3);
+        assert(t == 1);
     }
   }
 };
 
 template <class T>
 void testp()
 {
     {

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

 #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));
-        assert(std::atomic_fetch_sub_explicit(&t, T(2),
-                                            std::memory_order_seq_cst) == T(3));
+        std::atomic_init(&t, 3);
+        assert(std::atomic_fetch_sub_explicit(&t, 2,
+                                            std::memory_order_seq_cst) == 3);
         assert(t == T(1));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
-        std::atomic_init(&t, T(3));
-        assert(std::atomic_fetch_sub_explicit(&t, T(2),
-                                            std::memory_order_seq_cst) == T(3));
+        std::atomic_init(&t, 3);
+        assert(std::atomic_fetch_sub_explicit(&t, 2,
+                                            std::memory_order_seq_cst) == 3);
         assert(t == T(1));
     }
   }
 };
 
 template <class T>
 void testp()
 {

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

 #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(std::atomic_fetch_xor(&t, T(2)) == T(1));
+        std::atomic_init(&t, 1);
+        assert(std::atomic_fetch_xor(&t, 2) == 1);
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
-        std::atomic_init(&t, T(3));
-        assert(std::atomic_fetch_xor(&t, T(2)) == T(3));
+        std::atomic_init(&t, 3);
+        assert(std::atomic_fetch_xor(&t, 2) == 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 "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(std::atomic_fetch_xor_explicit(&t, T(2),
-               std::memory_order_seq_cst) == T(1));
+        std::atomic_init(&t, 1);
+        assert(std::atomic_fetch_xor_explicit(&t, 2,
+               std::memory_order_seq_cst) == 1);
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
-        std::atomic_init(&t, T(3));
-        assert(std::atomic_fetch_xor_explicit(&t, T(2),
-               std::memory_order_seq_cst) == T(3));
+        std::atomic_init(&t, 3);
+        assert(std::atomic_fetch_xor_explicit(&t, 2,
+               std::memory_order_seq_cst) == 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_helpers.h

 #include <cassert>
 
 #include "test_macros.h"
 
 struct UserAtomicType
 {
     int i;
 
-    explicit UserAtomicType(int d = 0) TEST_NOEXCEPT : i(d) {}
+    UserAtomicType(int d = 0) TEST_NOEXCEPT : i(d) {}
 
     friend bool operator==(const UserAtomicType& x, const UserAtomicType& y)
     { return x.i == y.i; }
 };
 
+struct LargeUserAtomicType
+{
+    int i, j[100];
+
+    LargeUserAtomicType(int d = 0) TEST_NOEXCEPT : i(d)
+    {}
+
+    friend bool operator==(const LargeUserAtomicType& x, const LargeUserAtomicType& y)
+    { return x.i == y.i; }
+};
+
 template < template <class TestArg> class TestFunctor >
 struct TestEachIntegralType {
     void operator()() const {
         TestFunctor<char>()();
         TestFunctor<signed char>()();
         TestFunctor<unsigned char>()();
         TestFunctor<short>()();
         TestFunctor<unsigned short>()();
#endif
     }
 };
 
 template < template <class TestArg> class TestFunctor >
 struct TestEachAtomicType {
     void operator()() const {
         TestEachIntegralType<TestFunctor>()();
         TestFunctor<UserAtomicType>()();
+        TestFunctor<LargeUserAtomicType>()();
         TestFunctor<int*>()();
         TestFunctor<const int*>()();
+        TestFunctor<float>()();
+        TestFunctor<double>()();
     }
 };
 
 
 #endif // ATOMIC_HELPER_H

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.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));
-    assert(t == T(1));
+    std::atomic_init(&t, 1);
+    assert(t == 1);
     volatile A vt;
-    std::atomic_init(&vt, T(2));
-    assert(vt == T(2));
+    std::atomic_init(&vt, 2);
+    assert(vt == 2);
+  }
+};
+
+template <class T>
+struct TestFn<T*> {
+  void operator()() const {
+    typedef std::atomic<T*> A;
+    A t;
+    std::atomic_init(&t, nullptr);
+    assert(t == nullptr);
+    volatile A vt;
+    std::atomic_init(&vt, nullptr);
+    assert(vt == nullptr);
   }
 };
 
 int main(int, char**)
 {
     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
 //  ... assertion fails line 35
+//
 
 // <atomic>
 
 // template <class T>
 //     T
 //     atomic_load(const volatile atomic<T>* obj);
 //
 // template <class T>
 //     T
 //     atomic_load(const atomic<T>* obj);
 
 #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(std::atomic_load(&t) == T(1));
+    std::atomic_init(&t, 1);
+    assert(std::atomic_load(&t) == 1);
+    volatile A vt;
+    std::atomic_init(&vt, 2);
+    assert(std::atomic_load(&vt) == 2);
+  }
+};
+
+template <class T>
+struct TestFn<T*> {
+  void operator()() const {
+    typedef std::atomic<T*> A;
+    A t;
+    std::atomic_init(&t, nullptr);
+    assert(std::atomic_load(&t) == nullptr);
     volatile A vt;
-    std::atomic_init(&vt, T(2));
-    assert(std::atomic_load(&vt) == T(2));
+    std::atomic_init(&vt, nullptr);
+    assert(std::atomic_load(&vt) == nullptr);
   }
 };
 
 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));
-    assert(std::atomic_load_explicit(&t, std::memory_order_seq_cst) == T(1));
+    std::atomic_init(&t, 1);
+    assert(std::atomic_load_explicit(&t, std::memory_order_seq_cst) == 1);
     volatile A vt;
-    std::atomic_init(&vt, T(2));
-    assert(std::atomic_load_explicit(&vt, std::memory_order_seq_cst) == T(2));
+    std::atomic_init(&vt, 2);
+    assert(std::atomic_load_explicit(&vt, std::memory_order_seq_cst) == 2);
+  }
+};
+
+template <class T>
+struct TestFn<T*> {
+  void operator()() const {
+    typedef std::atomic<T*> A;
+    A t;
+    std::atomic_init(&t, nullptr);
+    assert(std::atomic_load_explicit(&t, std::memory_order_seq_cst) == nullptr);
+    volatile A vt;
+    std::atomic_init(&vt, nullptr);
+    assert(std::atomic_load_explicit(&vt, std::memory_order_seq_cst) == nullptr);
   }
 };
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

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

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_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_store_explicit(&t, T(1), std::memory_order_seq_cst);
-    assert(t == T(1));
+    std::atomic_store_explicit(&t, 1, std::memory_order_seq_cst);
+    assert(t == 1);
     volatile A vt;
-    std::atomic_store_explicit(&vt, T(2), std::memory_order_seq_cst);
-    assert(vt == T(2));
+    std::atomic_store_explicit(&vt, 2, std::memory_order_seq_cst);
+    assert(vt == 2);
   }
 };
 
+template <class T>
+struct TestFn<T*> {
+  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);
+  }
+};
 
 int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
 
   return 0;
 }

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

 #include <thread>
 #include <chrono>
 #if TEST_STD_VER >= 20
 # include <memory>
 #endif
 
 #include "test_macros.h"
 
+template <class A, bool Integral>
+struct test_atomic
+{
+    test_atomic()
+    {
+        A a; (void)a;
+#if TEST_STD_VER >= 17
+    static_assert((std::is_same_v<typename A::value_type, decltype(a.load())>), "");
+#endif
+    }
+};
+
 template <class A>
-void
+struct test_atomic<A, true>
+{
     test_atomic()
     {
         A a; (void)a;
 #if TEST_STD_VER >= 17
-    static_assert((std::is_same<typename A::value_type, decltype(a.load())>::value), "");
+    static_assert((std::is_same_v<typename A::value_type, decltype(a.load())>), "");
+    static_assert((std::is_same_v<typename A::value_type, typename A::difference_type>), "");
 #endif
     }
+};
+
+template <class A>
+struct test_atomic<A*, false>
+{
+    test_atomic()
+    {
+        A a; (void)a;
+#if TEST_STD_VER >= 17
+    static_assert((std::is_same_v<typename A::value_type, decltype(a.load())>), "");
+    static_assert((std::is_same_v<typename A::difference_type, ptrdiff_t>), "");
+#endif
+    }
+};
 
 template <class T>
 void
 test()
 {
     using A = std::atomic<T>;
 #if TEST_STD_VER >= 17
-    static_assert((std::is_same<typename A::value_type, T>::value), "");
+    static_assert((std::is_same_v<typename A::value_type, T>), "");
 #endif
-    test_atomic<A>();
+    test_atomic<A, std::is_integral<T>::value && !std::is_same<T, bool>::value>();
 }
 
 struct TriviallyCopyable {
     int i_;
 };
 
 int main(int, char**)
 {
int main(int, char**)
     test<intmax_t>  ();
     test<uintmax_t> ();
 
     test<uintmax_t> ();
     test<uintmax_t> ();
 
     test<TriviallyCopyable>();
     test<std::thread::id>();
     test<std::chrono::nanoseconds>();
     test<float>();
 
 #if TEST_STD_VER >= 20
-    test_atomic<std::atomic_signed_lock_free>();
-    test_atomic<std::atomic_unsigned_lock_free>();
+    test<std::atomic_signed_lock_free>();
+    test<std::atomic_unsigned_lock_free>();
 /*
     test<std::shared_ptr<int>>();
 */
 #endif
 
     return 0;
 }

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

 // and should not be edited manually.
 
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <atomic>
 
 // Test the feature test macros defined by <atomic>
 
-/*  Constant                                Value
-    __cpp_lib_atomic_is_always_lock_free    201603L [C++17]
-    __cpp_lib_atomic_ref                    201806L [C++2a]
-    __cpp_lib_char8_t                       201811L [C++2a]
+/*  Constant                                   Value
+    __cpp_lib_atomic_flag_test                 201907L [C++2a]
+    __cpp_lib_atomic_float                     201711L [C++2a]
+    __cpp_lib_atomic_is_always_lock_free       201603L [C++17]
+    __cpp_lib_atomic_lock_free_type_aliases    201907L [C++2a]
+    __cpp_lib_atomic_ref                       201806L [C++2a]
+    __cpp_lib_atomic_shared_ptr                201711L [C++2a]
+    __cpp_lib_atomic_value_initialization      201911L [C++2a]
+    __cpp_lib_atomic_wait                      201907L [C++2a]
+    __cpp_lib_char8_t                          201811L [C++2a]
 */
 
 #include <atomic>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
+# ifdef __cpp_lib_atomic_flag_test
+#   error "__cpp_lib_atomic_flag_test should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_float
+#   error "__cpp_lib_atomic_float should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_atomic_is_always_lock_free
 #   error "__cpp_lib_atomic_is_always_lock_free should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_atomic_lock_free_type_aliases
+#   error "__cpp_lib_atomic_lock_free_type_aliases should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_atomic_ref
 #   error "__cpp_lib_atomic_ref should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_atomic_shared_ptr
+#   error "__cpp_lib_atomic_shared_ptr should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_value_initialization
+#   error "__cpp_lib_atomic_value_initialization should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_wait
+#   error "__cpp_lib_atomic_wait should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++2a"
 # endif
 
 #elif TEST_STD_VER == 14
 
+# ifdef __cpp_lib_atomic_flag_test
+#   error "__cpp_lib_atomic_flag_test should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_float
+#   error "__cpp_lib_atomic_float should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_atomic_is_always_lock_free
 #   error "__cpp_lib_atomic_is_always_lock_free should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_atomic_lock_free_type_aliases
+#   error "__cpp_lib_atomic_lock_free_type_aliases should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_atomic_ref
 #   error "__cpp_lib_atomic_ref should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_atomic_shared_ptr
+#   error "__cpp_lib_atomic_shared_ptr should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_value_initialization
+#   error "__cpp_lib_atomic_value_initialization should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_wait
+#   error "__cpp_lib_atomic_wait should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++2a"
 # endif
 
 #elif TEST_STD_VER == 17
 
+# ifdef __cpp_lib_atomic_flag_test
+#   error "__cpp_lib_atomic_flag_test should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_float
+#   error "__cpp_lib_atomic_float should not be defined before c++2a"
+# endif
+
 # if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_is_always_lock_free
 #     error "__cpp_lib_atomic_is_always_lock_free should be defined in c++17"
 #   endif
 #   if __cpp_lib_atomic_is_always_lock_free != 201603L
 #     error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++17"
 #   endif
 # else
 #   ifdef __cpp_lib_atomic_is_always_lock_free
 #     error "__cpp_lib_atomic_is_always_lock_free should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_atomic_lock_free_type_aliases
+#   error "__cpp_lib_atomic_lock_free_type_aliases should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_atomic_ref
 #   error "__cpp_lib_atomic_ref should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_atomic_shared_ptr
+#   error "__cpp_lib_atomic_shared_ptr should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_value_initialization
+#   error "__cpp_lib_atomic_value_initialization should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_wait
+#   error "__cpp_lib_atomic_wait should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++2a"
 # endif
 
 #elif TEST_STD_VER > 17
 
 # if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_atomic_flag_test
+#     error "__cpp_lib_atomic_flag_test should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_flag_test != 201907L
+#     error "__cpp_lib_atomic_flag_test should have the value 201907L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_atomic_flag_test
+#     error "__cpp_lib_atomic_flag_test should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_atomic_float
+#     error "__cpp_lib_atomic_float should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_float != 201711L
+#     error "__cpp_lib_atomic_float should have the value 201711L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_atomic_float
+#     error "__cpp_lib_atomic_float should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_is_always_lock_free
 #     error "__cpp_lib_atomic_is_always_lock_free should be defined in c++2a"
 #   endif
 #   if __cpp_lib_atomic_is_always_lock_free != 201603L
 #     error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++2a"
 #   endif
 # else
 #   ifdef __cpp_lib_atomic_is_always_lock_free
 #     error "__cpp_lib_atomic_is_always_lock_free should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
 #   endif
 # endif
 
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_atomic_lock_free_type_aliases
+#     error "__cpp_lib_atomic_lock_free_type_aliases should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_lock_free_type_aliases != 201907L
+#     error "__cpp_lib_atomic_lock_free_type_aliases should have the value 201907L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_atomic_lock_free_type_aliases
+#     error "__cpp_lib_atomic_lock_free_type_aliases should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_atomic_ref
 #     error "__cpp_lib_atomic_ref should be defined in c++2a"
 #   endif
 #   if __cpp_lib_atomic_ref != 201806L
 #     error "__cpp_lib_atomic_ref should have the value 201806L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_atomic_ref
 #     error "__cpp_lib_atomic_ref should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_atomic_shared_ptr
+#     error "__cpp_lib_atomic_shared_ptr should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_shared_ptr != 201711L
+#     error "__cpp_lib_atomic_shared_ptr should have the value 201711L in c++2a"
+#   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)
+#   ifndef __cpp_lib_atomic_value_initialization
+#     error "__cpp_lib_atomic_value_initialization should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_value_initialization != 201911L
+#     error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_atomic_value_initialization
+#     error "__cpp_lib_atomic_value_initialization should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_atomic_wait
+#     error "__cpp_lib_atomic_wait should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_wait != 201907L
+#     error "__cpp_lib_atomic_wait should have the value 201907L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_atomic_wait
+#     error "__cpp_lib_atomic_wait should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
+# endif
+
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2a"
 #   endif
 #   if __cpp_lib_char8_t != 201811L
 #     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 17
 
 int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/concepts.version.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
 //
 //===----------------------------------------------------------------------===//
 //
-// <concepts> feature macros
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
-/*  Constant                                    Value
-    __cpp_lib_concepts                          201806L
+// <concepts>
+
+// Test the feature test macros defined by <concepts>
 
+/*  Constant              Value
+    __cpp_lib_concepts    201806L [C++2a]
 */
 
-// XFAIL
-// #include <concepts>
-#include <cassert>
+#include <concepts>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-//  ensure that the macros that are supposed to be defined in <concepts> are defined.
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_concepts
+#   error "__cpp_lib_concepts should not be defined before c++2a"
+# endif
 
-  return 0;
-}
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_concepts
+#   error "__cpp_lib_concepts should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_concepts
+#   error "__cpp_lib_concepts should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_concepts
+#     error "__cpp_lib_concepts should be defined in c++2a"
+#   endif
+#   if __cpp_lib_concepts != 201806L
+#     error "__cpp_lib_concepts should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_concepts
+#     error "__cpp_lib_concepts should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/execution.version.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
 //
 //===----------------------------------------------------------------------===//
 //
-// <execution> feature macros
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
-/*  Constant                                    Value
-    __cpp_lib_execution                         201603L
+// <execution>
+
+// Test the feature test macros defined by <execution>
 
+/*  Constant               Value
+    __cpp_lib_execution    201603L [C++17]
 */
 
-// XFAIL
-// #include <execution>
-#include <cassert>
+#include <execution>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-//  ensure that the macros that are supposed to be defined in <execution> are defined.
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_execution
+#   error "__cpp_lib_execution should not be defined before c++17"
+# endif
 
-  return 0;
-}
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_execution
+#   error "__cpp_lib_execution should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_execution
+#     error "__cpp_lib_execution should be defined in c++17"
+#   endif
+#   if __cpp_lib_execution != 201603L
+#     error "__cpp_lib_execution should have the value 201603L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_execution
+#     error "__cpp_lib_execution should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#elif TEST_STD_VER > 17
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_execution
+#     error "__cpp_lib_execution should be defined in c++2a"
+#   endif
+#   if __cpp_lib_execution != 201603L
+#     error "__cpp_lib_execution should have the value 201603L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_execution
+#     error "__cpp_lib_execution should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main(int, char**) { return 0; }

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

 
 // <memory>
 
 // Test the feature test macros defined by <memory>
 
 /*  Constant                                      Value
     __cpp_lib_addressof_constexpr                 201603L [C++17]
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_atomic_value_initialization         201911L [C++2a]
     __cpp_lib_enable_shared_from_this             201603L [C++17]
     __cpp_lib_make_unique                         201304L [C++14]
     __cpp_lib_ranges                              201811L [C++2a]
     __cpp_lib_raw_memory_algorithms               201606L [C++17]
     __cpp_lib_shared_ptr_arrays                   201611L [C++17]
     __cpp_lib_shared_ptr_weak_type                201606L [C++17]
 */
 
 #include <memory>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_addressof_constexpr
 #   error "__cpp_lib_addressof_constexpr should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_allocator_traits_is_always_equal
 #   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_atomic_value_initialization
+#   error "__cpp_lib_atomic_value_initialization should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_enable_shared_from_this
 #   error "__cpp_lib_enable_shared_from_this should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_make_unique
 #   error "__cpp_lib_make_unique should not be defined before c++14"
 # endif
 

 # ifdef __cpp_lib_addressof_constexpr
 #   error "__cpp_lib_addressof_constexpr should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_allocator_traits_is_always_equal
 #   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_atomic_value_initialization
+#   error "__cpp_lib_atomic_value_initialization should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_enable_shared_from_this
 #   error "__cpp_lib_enable_shared_from_this should not be defined before c++17"
 # endif
 
 # ifndef __cpp_lib_make_unique
 #   error "__cpp_lib_make_unique should be defined in c++14"
 # endif
 # if __cpp_lib_make_unique != 201304L

 
 # ifndef __cpp_lib_allocator_traits_is_always_equal
 #   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
 # endif
 
+# ifdef __cpp_lib_atomic_value_initialization
+#   error "__cpp_lib_atomic_value_initialization should not be defined before c++2a"
+# endif
+
 # ifndef __cpp_lib_enable_shared_from_this
 #   error "__cpp_lib_enable_shared_from_this should be defined in c++17"
 # endif
 # if __cpp_lib_enable_shared_from_this != 201603L
 #   error "__cpp_lib_enable_shared_from_this should have the value 201603L in c++17"
 # endif
 
 # ifndef __cpp_lib_make_unique

 
 # ifndef __cpp_lib_allocator_traits_is_always_equal
 #   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
 # endif
 
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_atomic_value_initialization
+#     error "__cpp_lib_atomic_value_initialization should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_value_initialization != 201911L
+#     error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_atomic_value_initialization
+#     error "__cpp_lib_atomic_value_initialization should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
 # ifndef __cpp_lib_enable_shared_from_this
 #   error "__cpp_lib_enable_shared_from_this should be defined in c++2a"
 # endif
 # if __cpp_lib_enable_shared_from_this != 201603L
 #   error "__cpp_lib_enable_shared_from_this should have the value 201603L in c++2a"
 # endif
 
 # ifndef __cpp_lib_make_unique

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

 /*  Constant                                       Value
     __cpp_lib_addressof_constexpr                  201603L [C++17]
     __cpp_lib_allocator_traits_is_always_equal     201411L [C++17]
     __cpp_lib_any                                  201606L [C++17]
     __cpp_lib_apply                                201603L [C++17]
     __cpp_lib_array_constexpr                      201603L [C++17]
                                                    201811L [C++2a]
     __cpp_lib_as_const                             201510L [C++17]
+    __cpp_lib_atomic_flag_test                     201907L [C++2a]
+    __cpp_lib_atomic_float                         201711L [C++2a]
     __cpp_lib_atomic_is_always_lock_free           201603L [C++17]
+    __cpp_lib_atomic_lock_free_type_aliases        201907L [C++2a]
     __cpp_lib_atomic_ref                           201806L [C++2a]
+    __cpp_lib_atomic_shared_ptr                    201711L [C++2a]
+    __cpp_lib_atomic_value_initialization          201911L [C++2a]
+    __cpp_lib_atomic_wait                          201907L [C++2a]
     __cpp_lib_bind_front                           201811L [C++2a]
     __cpp_lib_bit_cast                             201806L [C++2a]
     __cpp_lib_bool_constant                        201505L [C++17]
     __cpp_lib_boyer_moore_searcher                 201603L [C++17]
     __cpp_lib_byte                                 201603L [C++17]
     __cpp_lib_char8_t                              201811L [C++2a]
     __cpp_lib_chrono                               201611L [C++17]
     __cpp_lib_chrono_udls                          201304L [C++14]

 # ifdef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_atomic_flag_test
+#   error "__cpp_lib_atomic_flag_test should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_float
+#   error "__cpp_lib_atomic_float should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_atomic_is_always_lock_free
 #   error "__cpp_lib_atomic_is_always_lock_free should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_atomic_lock_free_type_aliases
+#   error "__cpp_lib_atomic_lock_free_type_aliases should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_atomic_ref
 #   error "__cpp_lib_atomic_ref should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_atomic_shared_ptr
+#   error "__cpp_lib_atomic_shared_ptr should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_value_initialization
+#   error "__cpp_lib_atomic_value_initialization should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_wait
+#   error "__cpp_lib_atomic_wait should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_bind_front
 #   error "__cpp_lib_bind_front should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_bit_cast
 #   error "__cpp_lib_bit_cast should not be defined before c++2a"
 # endif
 

 # ifdef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_atomic_flag_test
+#   error "__cpp_lib_atomic_flag_test should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_float
+#   error "__cpp_lib_atomic_float should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_atomic_is_always_lock_free
 #   error "__cpp_lib_atomic_is_always_lock_free should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_atomic_lock_free_type_aliases
+#   error "__cpp_lib_atomic_lock_free_type_aliases should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_atomic_ref
 #   error "__cpp_lib_atomic_ref should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_atomic_shared_ptr
+#   error "__cpp_lib_atomic_shared_ptr should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_value_initialization
+#   error "__cpp_lib_atomic_value_initialization should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_wait
+#   error "__cpp_lib_atomic_wait should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_bind_front
 #   error "__cpp_lib_bind_front should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_bit_cast
 #   error "__cpp_lib_bit_cast should not be defined before c++2a"
 # endif
 

 
 # ifndef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should be defined in c++17"
 # endif
 # if __cpp_lib_as_const != 201510L
 #   error "__cpp_lib_as_const should have the value 201510L in c++17"
 # endif
 
+# ifdef __cpp_lib_atomic_flag_test
+#   error "__cpp_lib_atomic_flag_test should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_float
+#   error "__cpp_lib_atomic_float should not be defined before c++2a"
+# endif
+
 # if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_is_always_lock_free
 #     error "__cpp_lib_atomic_is_always_lock_free should be defined in c++17"
 #   endif
 #   if __cpp_lib_atomic_is_always_lock_free != 201603L
 #     error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++17"
 #   endif
 # else
 #   ifdef __cpp_lib_atomic_is_always_lock_free
 #     error "__cpp_lib_atomic_is_always_lock_free should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_atomic_lock_free_type_aliases
+#   error "__cpp_lib_atomic_lock_free_type_aliases should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_atomic_ref
 #   error "__cpp_lib_atomic_ref should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_atomic_shared_ptr
+#   error "__cpp_lib_atomic_shared_ptr should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_value_initialization
+#   error "__cpp_lib_atomic_value_initialization should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_atomic_wait
+#   error "__cpp_lib_atomic_wait should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_bind_front
 #   error "__cpp_lib_bind_front should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_bit_cast
 #   error "__cpp_lib_bit_cast should not be defined before c++2a"
 # endif
 

 # ifndef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should be defined in c++2a"
 # endif
 # if __cpp_lib_as_const != 201510L
 #   error "__cpp_lib_as_const should have the value 201510L in c++2a"
 # endif
 
 # if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_atomic_flag_test
+#     error "__cpp_lib_atomic_flag_test should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_flag_test != 201907L
+#     error "__cpp_lib_atomic_flag_test should have the value 201907L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_atomic_flag_test
+#     error "__cpp_lib_atomic_flag_test should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_atomic_float
+#     error "__cpp_lib_atomic_float should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_float != 201711L
+#     error "__cpp_lib_atomic_float should have the value 201711L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_atomic_float
+#     error "__cpp_lib_atomic_float should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_is_always_lock_free
 #     error "__cpp_lib_atomic_is_always_lock_free should be defined in c++2a"
 #   endif
 #   if __cpp_lib_atomic_is_always_lock_free != 201603L
 #     error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++2a"
 #   endif
 # else
 #   ifdef __cpp_lib_atomic_is_always_lock_free
 #     error "__cpp_lib_atomic_is_always_lock_free should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
 #   endif
 # endif
 
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_atomic_lock_free_type_aliases
+#     error "__cpp_lib_atomic_lock_free_type_aliases should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_lock_free_type_aliases != 201907L
+#     error "__cpp_lib_atomic_lock_free_type_aliases should have the value 201907L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_atomic_lock_free_type_aliases
+#     error "__cpp_lib_atomic_lock_free_type_aliases should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_atomic_ref
 #     error "__cpp_lib_atomic_ref should be defined in c++2a"
 #   endif
 #   if __cpp_lib_atomic_ref != 201806L
 #     error "__cpp_lib_atomic_ref should have the value 201806L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_atomic_ref
 #     error "__cpp_lib_atomic_ref should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_atomic_shared_ptr
+#     error "__cpp_lib_atomic_shared_ptr should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_shared_ptr != 201711L
+#     error "__cpp_lib_atomic_shared_ptr should have the value 201711L in c++2a"
+#   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)
+#   ifndef __cpp_lib_atomic_value_initialization
+#     error "__cpp_lib_atomic_value_initialization should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_value_initialization != 201911L
+#     error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_atomic_value_initialization
+#     error "__cpp_lib_atomic_value_initialization should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_atomic_wait
+#     error "__cpp_lib_atomic_wait should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_wait != 201907L
+#     error "__cpp_lib_atomic_wait should have the value 201907L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_atomic_wait
+#     error "__cpp_lib_atomic_wait should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bind_front
 #     error "__cpp_lib_bind_front should be defined in c++2a"
 #   endif
 #   if __cpp_lib_bind_front != 201811L
 #     error "__cpp_lib_bind_front should have the value 201811L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_bind_front

libcxx/test/support/cmpxchg_loop.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <atomic>
 
-template <class A, class T>
-bool cmpxchg_weak_loop(A& atomic, T& expected, T desired) {
+template <class A>
+bool cmpxchg_weak_loop(A& atomic, typename A::value_type& expected, typename A::value_type desired) {
   for (int i = 0; i < 10; i++) {
     if (atomic.compare_exchange_weak(expected, desired) == true) {
       return true;
     }
   }
 
   return false;
 }
 
-template <class A, class T>
-bool cmpxchg_weak_loop(A& atomic, T& expected, T desired,
+template <class A>
+bool cmpxchg_weak_loop(A& atomic, typename A::value_type& expected, typename A::value_type desired,
                        std::memory_order success,
                        std::memory_order failure) {
   for (int i = 0; i < 10; i++) {
     if (atomic.compare_exchange_weak(expected, desired, success,
                                      failure) == true) {
       return true;
     }
   }
 
   return false;
 }
 
-template <class A, class T>
-bool c_cmpxchg_weak_loop(A* atomic, T* expected, T desired) {
+template <class A>
+bool c_cmpxchg_weak_loop(A* atomic, typename A::value_type* expected, typename A::value_type desired) {
   for (int i = 0; i < 10; i++) {
     if (std::atomic_compare_exchange_weak(atomic, expected, desired) == true) {
       return true;
     }
   }
 
   return false;
 }
 
-template <class A, class T>
-bool c_cmpxchg_weak_loop(A* atomic, T* expected, T desired,
+template <class A>
+bool c_cmpxchg_weak_loop(A* atomic, typename A::value_type* expected, typename A::value_type desired,
                          std::memory_order success,
                          std::memory_order failure) {
   for (int i = 0; i < 10; i++) {
     if (std::atomic_compare_exchange_weak_explicit(atomic, expected, desired,
                                                    success, failure) == true) {
       return true;
     }
   }
 
   return false;
 }

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = sorted([ add_version_header(x) for x in [
   {"name": "__cpp_lib_integer_sequence",
    "values": {
       "c++14": int(201304)
     },
     "headers": ["utility"],
   },
   {"name": "__cpp_lib_exchange_function",
    "values": {
        "c++14": int(201304)
      },
      "headers": ["utility"],
     },
   {"name": "__cpp_lib_tuples_by_type",
    "values": {
      "c++14": int(201304)
    },
    "headers": ["utility", "tuple"],
     },
   {"name": "__cpp_lib_tuple_element_t",
    "values": {
      "c++14": int(201402)
    },
    "headers": ["tuple"],
     },
   {"name": "__cpp_lib_make_unique",
    "values": {
      "c++14": int(201304)
    },
    "headers": ["memory"],
     },
   {"name": "__cpp_lib_transparent_operators",
    "values": {
      "c++14": int(201210),
      "c++17": int(201510),
    },
    "headers": ["functional"],
     },
   {"name": "__cpp_lib_integral_constant_callable",
    "values": {
      "c++14": int(201304)
    },
    "headers": ["type_traits"],
     },
   {"name": "__cpp_lib_transformation_trait_aliases",
    "values": {
      "c++14": int(201304),
    },
    "headers": ["type_traits"]
     },
   {"name": "__cpp_lib_result_of_sfinae",
    "values": {
      "c++14": int(201210),
    },
    "headers": ["functional", "type_traits"]
     },
   {"name": "__cpp_lib_is_final",
    "values": {
      "c++14": int(201402),
    },
    "headers": ["type_traits"]
     },
   {"name": "__cpp_lib_is_null_pointer",
    "values": {
      "c++14": int(201309),
    },
    "headers": ["type_traits"]
     },
   {"name": "__cpp_lib_chrono_udls",
    "values": {
      "c++14": int(201304),
    },
    "headers": ["chrono"]
     },
   {"name": "__cpp_lib_string_udls",
    "values": {
      "c++14": int(201304),
    },
    "headers": ["string"]
     },
   {"name": "__cpp_lib_generic_associative_lookup",
    "values": {
      "c++14": int(201304),
    },
    "headers": ["map", "set"]
     },
   {"name": "__cpp_lib_null_iterators",
    "values": {
      "c++14": int(201304),
    },
    "headers": ["iterator"]
     },
   {"name": "__cpp_lib_make_reverse_iterator",
    "values": {
      "c++14": int(201402),
    },
    "headers": ["iterator"]
     },
   {"name": "__cpp_lib_robust_nonmodifying_seq_ops",
    "values": {
      "c++14": int(201304),
    },
    "headers": ["algorithm"]
     },
   {"name": "__cpp_lib_complex_udls",
    "values": {
      "c++14": int(201309),
    },
    "headers": ["complex"]
     },
   {"name": "__cpp_lib_quoted_string_io",
    "values": {
      "c++14": int(201304),
    },
    "headers": ["iomanip"]
     },
   {"name": "__cpp_lib_shared_timed_mutex",
    "values": {
      "c++14": int(201402),
    },
    "headers": ["shared_mutex"],
    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
   },
   # C++17 macros
   {"name": "__cpp_lib_atomic_is_always_lock_free",
    "values": {
      "c++17": int(201603),
    },
    "headers": ["atomic"],
    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
     },
   {"name": "__cpp_lib_filesystem",
    "values": {
      "c++17": int(201703),
    },
    "headers": ["filesystem"]
     },
   {"name": "__cpp_lib_invoke",
    "values": {
      "c++17": int(201411),
    },
    "headers": ["functional"]
     },
   {"name": "__cpp_lib_void_t",
    "values": {
      "c++17": int(201411),
    },
    "headers": ["type_traits"]
     },
   {"name": "__cpp_lib_node_extract",
    "values": {
      "c++17": int(201606),
    },
    "headers": ["map", "set", "unordered_map", "unordered_set"]
     },
   {"name": "__cpp_lib_byte",
    "values": {
      "c++17": int(201603),
    },
    "headers": ["cstddef"],
    },
   {"name": "__cpp_lib_hardware_interference_size",
    "values": {
feature_test_macros = sorted([ add_version_header(x) for x in [
    "internal_depends": "!defined(_LIBCPP_NO_HAS_CHAR8_T)",
    },
   {"name": "__cpp_lib_erase_if",
    "values": {
      "c++2a": int(202002),
    },
    "headers": ["string", "deque", "forward_list", "list", "vector", "map",
                "set", "unordered_map", "unordered_set"]
     },
   {"name": "__cpp_lib_destroying_delete",
    "values": {
      "c++2a": int(201806),
    },
    "headers": ["new"],
    "depends":
       "TEST_STD_VER > 17"
       " && defined(__cpp_impl_destroying_delete)"
feature_test_macros = sorted([ add_version_header(x) for x in [
    "headers": ["array"],
    },
   {"name": "__cpp_lib_span",
    "values": {
      "c++2a": int(202002),
    },
    "headers": ["span"],
    },
    {"name": "__cpp_lib_math_constants",
     "values": {
       "c++2a": int(201907),
     },
     "headers": ["numbers"],
     "depends": "defined(__cpp_concepts) && __cpp_concepts >= 201811L",
     "internal_depends": "defined(__cpp_concepts) && __cpp_concepts >= 201811L",
     },
-  {"name": "__cpp_lib_constexpr_utility",
    "values": {
      "c++2a": int(201811),
    },
    "headers": ["utility"],
    },
+     {"name": "__cpp_lib_atomic_flag_test",
+   "values": {
+     "c++2a": int(201907),
+   },
+   "headers": ["atomic"],
+   "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   },
+  {"name": "__cpp_lib_atomic_lock_free_type_aliases",
+   "values": {
+     "c++2a": int(201907),
+   },
+   "headers": ["atomic"],
+   "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   },
+  {"name": "__cpp_lib_atomic_wait",
+   "values": {
+     "c++2a": int(201907),
+   },
+   "headers": ["atomic"],
+   "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   },
+  {"name": "__cpp_lib_atomic_float",
+   "values": {
+     "c++2a": int(201711),
+   },
+   "headers": ["atomic"],
+   "unimplemented": True,
+   "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   },
+  {"name": "__cpp_lib_atomic_shared_ptr",
+   "values": {
+     "c++2a": int(201711),
+   },
+   "headers": ["atomic"],
+   "unimplemented": True,
+   "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   },
+  {"name": "__cpp_lib_atomic_value_initialization",
+   "values": {
+     "c++2a": int(201911),
+   },
+   "headers": ["atomic", "memory"],
+   "unimplemented": True,
+   "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   },
 ]], key=lambda tc: tc["name"])
 
 def get_std_dialects():
   std_dialects = ['c++14', 'c++17', 'c++2a']
   return list(std_dialects)
 
 def get_first_std(d):
     for s in get_std_dialects():