C++20 comments

[BenjaminTrapani]

Summary

Move constructors and assignment operators closer to top of commented decl

Clean up type names

Remove C11 atomic impl for std::atomic

Add error assertions

[BenjaminTrapani]

Rebase master

[BenjaminTrapani]

Further rebases

[ldionne]

Is this meant to be reviewed, or is this part of the atomic_ref patch? If the former, please abandon to clean up the review queue.

libcxx/include/__config

 // Thread-unsafe functions such as strtok() and localtime()
 // are not available.
 #ifdef __CloudABI__
 #define _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
 #endif
 
 #if __has_feature(cxx_atomic) || __has_extension(c_atomic) || __has_keyword(_Atomic)
 #  define _LIBCPP_HAS_C_ATOMIC_IMP
-#elif defined(_LIBCPP_COMPILER_GCC)
+#endif
+
+#if defined(_LIBCPP_COMPILER_GCC) || (__has_builtin(__atomic_load) && __has_builtin(__atomic_store) && __has_builtin(__atomic_exchange) && __has_builtin(__atomic_compare_exchange))
 #  define _LIBCPP_HAS_GCC_ATOMIC_IMP
 #endif
 
 #if (!defined(_LIBCPP_HAS_C_ATOMIC_IMP) && \
      !defined(_LIBCPP_HAS_GCC_ATOMIC_IMP) && \
      !defined(_LIBCPP_HAS_EXTERNAL_ATOMIC_IMP)) \
      || defined(_LIBCPP_HAS_NO_THREADS)
 #  define _LIBCPP_HAS_NO_ATOMIC_HEADER

libcxx/include/atomic

struct atomic
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     T operator=(T) volatile noexcept;
     T operator=(T) noexcept;
 };
 
 template <class T>
-struct atomic_ref
+struct atomic_ref // since C++20
 {
     static constexpr bool is_always_lock_free;
     static constexpr size_t required_alignment;
 
+    explicit atomic_ref(T& obj) noexcept;
+    atomic_ref(const atomic_ref&) noexcept;
+    T operator=(T desired) const noexcept;
+    atomic_ref& operator=(const atomic_ref&) = delete;
+
     bool is_lock_free() const noexcept;
     void store(T desr, memory_order m = memory_order_seq_cst) const noexcept;
     T load(memory_order m = memory_order_seq_cst) const noexcept;
     operator T() const noexcept;
     T exchange(T desr, memory_order m = memory_order_seq_cst) const noexcept;
     bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f) const noexcept;
     bool compare_exchange_strong(T& expc, T desr,
                                  memory_order s, memory_order f) const noexcept;
     bool compare_exchange_weak(T& expc, T desr,
                                memory_order m = memory_order_seq_cst) const noexcept;
     bool compare_exchange_strong(T& expc, T desr,
                                  memory_order m = memory_order_seq_cst) const noexcept;
-
-    explicit atomic_ref(T& obj) noexcept;
-    atomic_ref(const atomic_ref&) noexcept;
-    T operator=(T desired) const noexcept;
-    atomic_ref& operator=(const atomic_ref&) = delete;
 };
 
 template <>
 struct atomic<integral>
 {
     static constexpr bool is_always_lock_free;
+
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     void store(integral desr, memory_order m = memory_order_seq_cst) volatile noexcept;
     void store(integral desr, memory_order m = memory_order_seq_cst) noexcept;
     integral load(memory_order m = memory_order_seq_cst) const volatile noexcept;
     integral load(memory_order m = memory_order_seq_cst) const noexcept;
     operator integral() const volatile noexcept;
     operator integral() const noexcept;
struct atomic<integral>
     integral operator&=(integral op) noexcept;
     integral operator|=(integral op) volatile noexcept;
     integral operator|=(integral op) noexcept;
     integral operator^=(integral op) volatile noexcept;
     integral operator^=(integral op) noexcept;
 };
 
 template <>
-struct atomic_ref<integral>
+struct atomic_ref<integral> // since C++20
 {
     static constexpr bool is_always_lock_free;
     static constexpr size_t required_alignment;
 
+    explicit atomic_ref(integral& obj) noexcept;
+    atomic_ref(const atomic_ref&) noexcept;
+    integral operator=(integral desired) const noexcept;
+    atomic_ref& operator=(const atomic_ref&) = delete;
+
     bool is_lock_free() const noexcept;
     void store(T desr, memory_order m = memory_order_seq_cst) const noexcept;
     integral load(memory_order m = memory_order_seq_cst) const noexcept;
     operator integral() const noexcept;
     integral exchange(integral desr, memory_order m = memory_order_seq_cst) const noexcept;
     bool compare_exchange_weak(integral& expc, integral desr, memory_order s, memory_order f) const noexcept;
     bool compare_exchange_strong(integral& expc, integral desr,
                                  memory_order s, memory_order f) const noexcept;
     bool compare_exchange_weak(integral& expc, integral desr,
                                memory_order m = memory_order_seq_cst) const noexcept;
     bool compare_exchange_strong(integral& expc, integral desr,
                                  memory_order m = memory_order_seq_cst) const noexcept;
 
     integral fetch_add(integral op, memory_order m = memory_order_seq_cst) const noexcept;
     integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) const noexcept;
     integral fetch_and(integral op, memory_order m = memory_order_seq_cst) const noexcept;
     integral fetch_or(integral op, memory_order m = memory_order_seq_cst) const noexcept;
     integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) const noexcept;
 
-    explicit atomic_ref(integral& obj) noexcept;
-    atomic_ref(const atomic_ref&) noexcept;
-    integral operator=(integral desired) const noexcept;
-    atomic_ref& operator=(const atomic_ref&) = delete;
-
     integral operator++(int) const noexcept;
     integral operator--(int) const noexcept;
     integral operator++() const noexcept;
     integral operator--() const noexcept;
     integral operator+=(integral op) const noexcept;
     integral operator-=(integral op) const noexcept;
     integral operator&=(integral op) const noexcept;
     integral operator|=(integral op) const noexcept;
struct atomic<T*>
     T* operator--() noexcept;
     T* operator+=(ptrdiff_t op) volatile noexcept;
     T* operator+=(ptrdiff_t op) noexcept;
     T* operator-=(ptrdiff_t op) volatile noexcept;
     T* operator-=(ptrdiff_t op) noexcept;
 };
 
 template <class T>
-struct atomic_ref<T*>
+struct atomic_ref<T*> // since C++20
 {
     static constexpr bool is_always_lock_free;
     static constexpr size_t required_alignment;
 
+    explicit atomic_ref(T* obj) noexcept;
+    atomic_ref(const atomic_ref&) noexcept;
+    T* operator=(T* desired) const noexcept;
+    atomic_ref& operator=(const atomic_ref&) = delete;
+
     bool is_lock_free() const noexcept;
     void store(T* desr, memory_order m = memory_order_seq_cst) const noexcept;
     T* load(memory_order m = memory_order_seq_cst) const noexcept;
     operator T*() const noexcept;
     T* exchange(T* desr, memory_order m = memory_order_seq_cst) const noexcept;
     bool compare_exchange_weak(T*& expc, T* desr, memory_order s, memory_order f) const noexcept;
     bool compare_exchange_strong(T*& expc, T* desr,
                                  memory_order s, memory_order f) const noexcept;
     bool compare_exchange_weak(T*& expc, T* desr,
                                memory_order m = memory_order_seq_cst) const noexcept;
     bool compare_exchange_strong(T*& expc, T* desr,
                                  memory_order m = memory_order_seq_cst) const noexcept;
 
     T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
     T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
 
-    explicit atomic_ref(T* obj) noexcept;
-    atomic_ref(const atomic_ref&) noexcept;
-    T* operator=(T* desired) const noexcept;
-    atomic_ref& operator=(const atomic_ref&) = delete;
-
     T* operator++(int) const noexcept;
     T* operator--(int) const noexcept;
     T* operator++() const noexcept;
     T* operator--() const noexcept;
     T* operator+=(ptrdiff_t op) const noexcept;
     T* operator-=(ptrdiff_t op) const noexcept;
 };
 
#else
     __cxx_atomic_base_impl() _NOEXCEPT : __a_value() {}
 #endif // _LIBCPP_CXX03_LANG
   _LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT
     : __a_value(value) {}
   using __contained_t = _Tp;
   _Tp __a_value;
 };
 
-#elif defined(_LIBCPP_HAS_C_ATOMIC_IMP)
-
-template<typename _Tp>
-struct __choose_atomic {
-  using type = _Atomic(_Tp);
-};
-
-template<typename _Tp>
-struct __choose_underlying {
-  using type = _Tp;
-};
-
-template <typename _Tp>
-struct __cxx_atomic_base_impl {
-
-  _LIBCPP_INLINE_VISIBILITY
-#ifndef _LIBCPP_CXX03_LANG
-    __cxx_atomic_base_impl() _NOEXCEPT = default;
-#else
-    __cxx_atomic_base_impl() _NOEXCEPT : __a_value() {}
-#endif // _LIBCPP_CXX03_LANG
-  _LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT
-    : __a_value(value) {}
-  using __backing_atomic = typename conditional<is_reference<_Tp>::value, __choose_underlying<_Tp>, __choose_atomic<_Tp>>::type::type;
-  using __contained_t = _Tp;
-
-  _LIBCPP_DISABLE_EXTENSION_WARNING __backing_atomic __a_value;
-};
-
-#endif
-
-#if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP) || defined(_LIBCPP_HAS_C_ATOMIC_IMP)
-
-template<typename Tp_, template<typename> class TemplateTp_>
+template<typename _Tp, template<typename> class _TemplateTp>
 struct __is_instantiation_of : false_type { };
 
-template<typename Tp_, template<typename> class TemplateTp_>
-struct __is_instantiation_of<TemplateTp_<Tp_>, TemplateTp_> : true_type {};
+template<typename _Tp, template<typename> class _TemplateTp>
+struct __is_instantiation_of<_TemplateTp<_Tp>, _TemplateTp> : true_type {};
 
-template <typename Tp_, typename = typename enable_if<__is_instantiation_of<typename remove_volatile<typename Tp_::__base>::type, __cxx_atomic_base_impl>::value, bool>::type>
+template <typename _Tp, typename = typename enable_if<__is_instantiation_of<typename remove_volatile<typename _Tp::__base>::type, __cxx_atomic_base_impl>::value, bool>::type>
 struct __cxx_atomic_base_impl_traits {
-  static constexpr bool __is_value_volatile = is_volatile<Tp_>::value;
-  static constexpr bool __is_value_ref = is_reference<typename Tp_::__contained_t>::value;
-  using __underlying_t = typename remove_volatile<typename remove_reference<typename Tp_::__contained_t>::type>::type;
+  static constexpr bool __is_value_volatile = is_volatile<_Tp>::value;
+  static constexpr bool __is_value_ref = is_reference<typename _Tp::__contained_t>::value;
+  using __underlying_t = typename remove_volatile<typename remove_reference<typename _Tp::__contained_t>::type>::type;
   static constexpr bool __is_value_pointer = is_pointer<__underlying_t>::value;
 };
 
-#endif
-
-#if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP)
 _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_CONSTEXPR int __to_gcc_order(memory_order __order) {
   // Avoid switch statement to make this a constexpr.
   return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
          (__order == memory_order_acquire ? __ATOMIC_ACQUIRE:
           (__order == memory_order_release ? __ATOMIC_RELEASE:
            (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST:
             (__order == memory_order_acq_rel ? __ATOMIC_ACQ_REL:
               __ATOMIC_CONSUME))));
__cxx_atomic_fetch_xor(_Tp* __a,
                        typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __pattern,
            memory_order __order) {
   return __atomic_fetch_xor(&__a->__a_value, __pattern,
                             __to_gcc_order(__order));
 }
 
 #define __cxx_atomic_is_lock_free(__s) __atomic_is_lock_free(__s, 0)
 
-#elif defined(_LIBCPP_HAS_C_ATOMIC_IMP)
-
-#define __cxx_atomic_is_lock_free(__s) __c11_atomic_is_lock_free(__s)
-
-_LIBCPP_INLINE_VISIBILITY inline
-void __cxx_atomic_thread_fence(memory_order __order) _NOEXCEPT {
-    __c11_atomic_thread_fence(static_cast<__memory_order_underlying_t>(__order));
-}
-
-_LIBCPP_INLINE_VISIBILITY inline
-void __cxx_atomic_signal_fence(memory_order __order) _NOEXCEPT {
-    __c11_atomic_signal_fence(static_cast<__memory_order_underlying_t>(__order));
-}
-
-template <typename Tp_, typename Original_>
-struct __annotate_with_qualifiers {
-  using __const_qualified = typename conditional<is_const<Original_>::value, const Tp_, Tp_>::type;
-  using __type = typename conditional<is_volatile<Original_>::value, volatile __const_qualified, __const_qualified>::type;
-};
-
-template<typename _Tp, typename enable_if<!__cxx_atomic_base_impl_traits<_Tp>::__is_value_ref, bool>::type = 0>
-_LIBCPP_INLINE_VISIBILITY inline
-typename __annotate_with_qualifiers<_Atomic(typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t), _Tp>::__type*
-__cxx_atomic_pointer_to_data(_Tp* __value) {
-  return &__value->__a_value;
-}
-
-template<typename _Tp, typename enable_if<__cxx_atomic_base_impl_traits<_Tp>::__is_value_ref, bool>::type = 0>
-_LIBCPP_INLINE_VISIBILITY inline
-typename __annotate_with_qualifiers<_Atomic(typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t), _Tp>::__type*
-__cxx_atomic_pointer_to_data(_Tp* __value) {
-  return reinterpret_cast<typename __annotate_with_qualifiers<_Atomic(typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t), _Tp>::__type*>(&__value->__a_value);
-}
-
-template<class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-void __cxx_atomic_init(_Tp* __a, typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __val) _NOEXCEPT {
-  __c11_atomic_init(__cxx_atomic_pointer_to_data(__a), __val);
-}
-
-template<class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-void __cxx_atomic_store(_Tp* __a, typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __val, memory_order __order) _NOEXCEPT {
-  __c11_atomic_store(__cxx_atomic_pointer_to_data(__a), __val, static_cast<__memory_order_underlying_t>(__order));
-}
-
-template<class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t
-__cxx_atomic_load(_Tp const* __a, memory_order __order) _NOEXCEPT {
-    auto __ptr_to_atomic_val = __cxx_atomic_pointer_to_data(__a);
-    using __ptr_type = typename remove_const<decltype(__ptr_to_atomic_val)>::type;
-    return __c11_atomic_load(const_cast<__ptr_type>(__ptr_to_atomic_val), static_cast<__memory_order_underlying_t>(__order));
-}
-
-template<class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t
-__cxx_atomic_exchange(_Tp* __a, typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __value, memory_order __order) _NOEXCEPT {
-  return __c11_atomic_exchange(__cxx_atomic_pointer_to_data(__a), __value, static_cast<__memory_order_underlying_t>(__order));
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY bool __cxx_atomic_compare_exchange_strong(
-    _Tp* __a,
-    typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t* __expected,
-    typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __value,
-    memory_order __success, memory_order __failure) _NOEXCEPT {
-  return __c11_atomic_compare_exchange_strong(
-      __cxx_atomic_pointer_to_data(__a), __expected, __value,
-      static_cast<__memory_order_underlying_t>(__success),
-      static_cast<__memory_order_underlying_t>(__failure));
-}
-
-template<class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-bool __cxx_atomic_compare_exchange_weak(_Tp* __a, typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t* __expected,
-          typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __value,
-          memory_order __success, memory_order __failure) _NOEXCEPT {
-  return __c11_atomic_compare_exchange_weak(__cxx_atomic_pointer_to_data(__a), __expected, __value,
-              static_cast<__memory_order_underlying_t>(__success),
-              static_cast<__memory_order_underlying_t>(__failure));
-}
-
-template<class _Tp, typename enable_if<!__cxx_atomic_base_impl_traits<_Tp>::__is_value_pointer, bool>::type = 0>
-_LIBCPP_INLINE_VISIBILITY
-typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t
-__cxx_atomic_fetch_add(_Tp* __a, typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __delta,
-         memory_order __order) _NOEXCEPT {
-  return __c11_atomic_fetch_add(__cxx_atomic_pointer_to_data(__a), __delta, static_cast<__memory_order_underlying_t>(__order));
-}
-template<class _Tp, typename enable_if<__cxx_atomic_base_impl_traits<_Tp>::__is_value_pointer, bool>::type = 0>
-_LIBCPP_INLINE_VISIBILITY
-typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t
-__cxx_atomic_fetch_add(_Tp* __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
-  return __c11_atomic_fetch_add(__cxx_atomic_pointer_to_data(__a), __delta, static_cast<__memory_order_underlying_t>(__order));
-}
-
-template<class _Tp, typename enable_if<!__cxx_atomic_base_impl_traits<_Tp>::__is_value_pointer, bool>::type = 0>
-_LIBCPP_INLINE_VISIBILITY
-typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t
-__cxx_atomic_fetch_sub(_Tp* __a, typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __delta,
-           memory_order __order) _NOEXCEPT {
-  return __c11_atomic_fetch_sub(__cxx_atomic_pointer_to_data(__a), __delta, static_cast<__memory_order_underlying_t>(__order));
-}
-template<class _Tp, typename enable_if<__cxx_atomic_base_impl_traits<_Tp>::__is_value_pointer, bool>::type = 0>
-_LIBCPP_INLINE_VISIBILITY
-typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t
-__cxx_atomic_fetch_sub(_Tp* __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
-  return __c11_atomic_fetch_sub(__cxx_atomic_pointer_to_data(__a), __delta, static_cast<__memory_order_underlying_t>(__order));
-}
-
-template<class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t
-__cxx_atomic_fetch_and(_Tp* __a, typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __pattern,
-           memory_order __order) _NOEXCEPT {
-  return __c11_atomic_fetch_and(__cxx_atomic_pointer_to_data(__a), __pattern, static_cast<__memory_order_underlying_t>(__order));
-}
-
-template<class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t
-__cxx_atomic_fetch_or(_Tp* __a, typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __pattern,
-          memory_order __order) _NOEXCEPT {
-  return __c11_atomic_fetch_or(__cxx_atomic_pointer_to_data(__a), __pattern, static_cast<__memory_order_underlying_t>(__order));
-}
-
-template<class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t
-__cxx_atomic_fetch_xor(_Tp* __a, typename __cxx_atomic_base_impl_traits<_Tp>::__underlying_t __pattern,
-           memory_order __order) _NOEXCEPT {
-  return __c11_atomic_fetch_xor(__cxx_atomic_pointer_to_data(__a), __pattern, static_cast<__memory_order_underlying_t>(__order));
-}
-
-#endif // _LIBCPP_HAS_GCC_ATOMIC_IMP, _LIBCPP_HAS_C_ATOMIC_IMP
+#endif // _LIBCPP_HAS_GCC_ATOMIC_IMP
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 _Tp kill_dependency(_Tp __y) _NOEXCEPT
 {
     return __y;
 }
 

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

 
 /*
 template <class T>
 struct atomic_ref<T*>
 {
     static constexpr bool is_always_lock_free;
     static constexpr size_t required_alignment;
 
+    explicit atomic_ref(T* obj) noexcept;
+    atomic_ref(const atomic_ref&) noexcept;
+    T* operator=(T* desired) const noexcept;
+    atomic_ref& operator=(const atomic_ref&) = delete;
+
     bool is_lock_free() const noexcept;
     void store(T* desr, memory_order m = memory_order_seq_cst) const noexcept;
     T* load(memory_order m = memory_order_seq_cst) const noexcept;
     operator T*() const noexcept;
     T* exchange(T* desr, memory_order m = memory_order_seq_cst) const noexcept;
     bool compare_exchange_weak(T*& expc, T* desr, memory_order s, memory_order f) const noexcept;
     bool compare_exchange_strong(T*& expc, T* desr,
                                  memory_order s, memory_order f) const noexcept;
     bool compare_exchange_weak(T*& expc, T* desr,
                                memory_order m = memory_order_seq_cst) const noexcept;
     bool compare_exchange_strong(T*& expc, T* desr,
                                  memory_order m = memory_order_seq_cst) const noexcept;
 
     T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
     T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
 
-    explicit atomic_ref(T* obj) noexcept;
-    atomic_ref(const atomic_ref&) noexcept;
-    T* operator=(T* desired) const noexcept;
-    atomic_ref& operator=(const atomic_ref&) = delete;
-
     T* operator++(int) const noexcept;
     T* operator--(int) const noexcept;
     T* operator++() const noexcept;
     T* operator--() const noexcept;
     T* operator+=(ptrdiff_t op) const noexcept;
     T* operator-=(ptrdiff_t op) const noexcept;
 }; */
 

libcxx/test/std/atomics/atomics.types.generic/assign_to_atomic_ref_deleted.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <atomic>
 
 // template <class T>
 // struct atomic_ref
 // {
 //     static constexpr bool is_always_lock_free;
 //     static constexpr size_t required_alignment;
-
+//
+//     explicit atomic_ref(T& obj) noexcept;
+//     atomic_ref(const atomic_ref&) noexcept;
+//     T operator=(T desired) const noexcept;
+//     atomic_ref& operator=(const atomic_ref&) = delete;
+//
 //     bool is_lock_free() const noexcept;
 //     void store(T desr, memory_order m = memory_order_seq_cst) const noexcept;
 //     T load(memory_order m = memory_order_seq_cst) const noexcept;
 //     operator T() const noexcept;
 //     T exchange(T desr, memory_order m = memory_order_seq_cst) const noexcept;
 //     bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f) const noexcept;
 //     bool compare_exchange_strong(T& expc, T desr,
 //                                  memory_order s, memory_order f) const noexcept;
 //     bool compare_exchange_weak(T& expc, T desr,
 //                                memory_order m = memory_order_seq_cst) const noexcept;
 //     bool compare_exchange_strong(T& expc, T desr,
 //                                  memory_order m = memory_order_seq_cst) const noexcept;
-
-//     explicit atomic_ref(T& obj) noexcept;
-//     atomic_ref(const atomic_ref&) noexcept;
-//     T operator=(T desired) const noexcept;
-//     atomic_ref& operator=(const atomic_ref&) = delete;
 // };
 
 #include <atomic>
 #include <new>
 #include <cassert>
 
 int main(int, char**) {
   int val = 1;
   std::atomic_ref<int> t0(val);
   std::atomic_ref<int> t1(val);
-  t0 = t1;
+  t0 = t1;  // expected-error {{object of type 'std::atomic_ref<int>' cannot be assigned because its copy assignment operator is implicitly deleted}}
 
   return 0;
 }

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

 //     T operator=(T) noexcept;
 // };
 
 // template <class T>
 // struct atomic_ref
 // {
 //     static constexpr bool is_always_lock_free;
 //     static constexpr size_t required_alignment;
-
+//
+//     explicit atomic_ref(T& obj) noexcept;
+//     atomic_ref(const atomic_ref&) noexcept;
+//     T operator=(T desired) const noexcept;
+//     atomic_ref& operator=(const atomic_ref&) = delete;
+//
 //     bool is_lock_free() const noexcept;
 //     void store(T desr, memory_order m = memory_order_seq_cst) const noexcept;
 //     T load(memory_order m = memory_order_seq_cst) const noexcept;
 //     operator T() const noexcept;
 //     T exchange(T desr, memory_order m = memory_order_seq_cst) const noexcept;
 //     bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f) const noexcept;
 //     bool compare_exchange_strong(T& expc, T desr,
 //                                  memory_order s, memory_order f) const noexcept;
 //     bool compare_exchange_weak(T& expc, T desr,
 //                                memory_order m = memory_order_seq_cst) const noexcept;
 //     bool compare_exchange_strong(T& expc, T desr,
 //                                  memory_order m = memory_order_seq_cst) const noexcept;
-
-//     explicit atomic_ref(T& obj) noexcept;
-//     atomic_ref(const atomic_ref&) noexcept;
-//     T operator=(T desired) const noexcept;
-//     atomic_ref& operator=(const atomic_ref&) = delete;
 // };
 
 #include <atomic>
 #include <new>
 #include <cassert>
 #include <thread> // for thread_id
 #include <chrono> // for nanoseconds
 

libcxx/test/std/atomics/atomics.types.generic/trivially_copyable_ref.fail.cpp

 #include <chrono> // for nanoseconds
 
 struct NotTriviallyCopyable {
   NotTriviallyCopyable(int i) : i_(i) {}
   NotTriviallyCopyable(const NotTriviallyCopyable& rhs) : i_(rhs.i_) {}
   int i_;
 };
 
-template <class T, class>
+template <class T>
 void test(T t) {
-  std::atomic_ref<T> t0(t);
+  std::atomic_ref<T> t0(t); // expected-error@atomic:* {{static_assert failed due to requirement 'is_trivially_copyable<NotTriviallyCopyable>::value' "std::atomic_ref<_Tp> requires that '_Tp' be a trivially copyable type"}}
 }
 
 int main(int, char**) {
   test(NotTriviallyCopyable(42));
 
   return 0;
 }