diff --git a/libcxx/docs/ReleaseNotes/21.rst b/libcxx/docs/ReleaseNotes/21.rst
index d31ca0130cb80..83a3ac96719eb 100644
--- a/libcxx/docs/ReleaseNotes/21.rst
+++ b/libcxx/docs/ReleaseNotes/21.rst
@@ -53,6 +53,7 @@ Implemented Papers
 - P2711R1: Making multi-param constructors of ``views`` ``explicit`` (`Github <https://github.com/llvm/llvm-project/issues/105252>`__)
 - P2770R0: Stashing stashing ``iterators`` for proper flattening (`Github <https://github.com/llvm/llvm-project/issues/105250>`__)
 - P2655R3: ``common_reference_t`` of ``reference_wrapper`` Should Be a Reference Type (`Github <https://github.com/llvm/llvm-project/issues/105260>`__)
+- P3323R1: cv-qualified types in ``atomic`` and ``atomic_ref`` (`Github <https://github.com/llvm/llvm-project/issues/118378>`__)
 
 Improvements and New Features
 -----------------------------
diff --git a/libcxx/docs/Status/Cxx2cPapers.csv b/libcxx/docs/Status/Cxx2cPapers.csv
index febb0c176f9c4..5f340ca57aa97 100644
--- a/libcxx/docs/Status/Cxx2cPapers.csv
+++ b/libcxx/docs/Status/Cxx2cPapers.csv
@@ -86,7 +86,7 @@
 "`P3050R2 <https://wg21.link/P3050R2>`__","Fix C++26 by optimizing ``linalg::conjugated`` for noncomplex value types","2024-11 (Wrocław)","","",""
 "`P3396R1 <https://wg21.link/P3396R1>`__","``std::execution`` wording fixes","2024-11 (Wrocław)","","",""
 "`P2835R7 <https://wg21.link/P2835R7>`__","Expose ``std::atomic_ref``'s object address","2024-11 (Wrocław)","","",""
-"`P3323R1 <https://wg21.link/P3323R1>`__","cv-qualified types in ``atomic`` and ``atomic_ref``","2024-11 (Wrocław)","","",""
+"`P3323R1 <https://wg21.link/P3323R1>`__","cv-qualified types in ``atomic`` and ``atomic_ref``","2024-11 (Wrocław)","|Complete|","21","Implemented as DR against C++20."
 "`P3508R0 <https://wg21.link/P3508R0>`__","Wording for ""constexpr for specialized memory algorithms""","2024-11 (Wrocław)","","",""
 "`P3369R0 <https://wg21.link/P3369R0>`__","constexpr for ``uninitialized_default_construct``","2024-11 (Wrocław)","","",""
 "`P3370R1 <https://wg21.link/P3370R1>`__","Add new library headers from C23","2024-11 (Wrocław)","","",""
diff --git a/libcxx/include/__atomic/atomic_ref.h b/libcxx/include/__atomic/atomic_ref.h
index b5493662c518e..8db2370dc12ee 100644
--- a/libcxx/include/__atomic/atomic_ref.h
+++ b/libcxx/include/__atomic/atomic_ref.h
@@ -29,7 +29,13 @@
 #include <__cstddef/ptrdiff_t.h>
 #include <__memory/addressof.h>
 #include <__type_traits/has_unique_object_representation.h>
+#include <__type_traits/is_const.h>
+#include <__type_traits/is_object.h>
+#include <__type_traits/is_pointer.h>
 #include <__type_traits/is_trivially_copyable.h>
+#include <__type_traits/is_volatile.h>
+#include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_pointer.h>
 #include <cstdint>
 #include <cstring>
 
@@ -59,9 +65,11 @@ struct __get_aligner_instance {
 
 template <class _Tp>
 struct __atomic_ref_base {
+  using value_type = __remove_cv_t<_Tp>;
+
 private:
-  _LIBCPP_HIDE_FROM_ABI static _Tp* __clear_padding(_Tp& __val) noexcept {
-    _Tp* __ptr = std::addressof(__val);
+  _LIBCPP_HIDE_FROM_ABI static value_type* __clear_padding(value_type& __val) noexcept {
+    value_type* __ptr = std::addressof(__val);
 #  if __has_builtin(__builtin_clear_padding)
     __builtin_clear_padding(__ptr);
 #  endif
@@ -69,18 +77,23 @@ struct __atomic_ref_base {
   }
 
   _LIBCPP_HIDE_FROM_ABI static bool __compare_exchange(
-      _Tp* __ptr, _Tp* __expected, _Tp* __desired, bool __is_weak, int __success, int __failure) noexcept {
+      _Tp* __ptr,
+      value_type* __expected,
+      value_type* __desired,
+      bool __is_weak,
+      int __success,
+      int __failure) noexcept {
     if constexpr (
 #  if __has_builtin(__builtin_clear_padding)
-        has_unique_object_representations_v<_Tp> || floating_point<_Tp>
+        has_unique_object_representations_v<value_type> || floating_point<value_type>
 #  else
         true // NOLINT(readability-simplify-boolean-expr)
 #  endif
     ) {
       return __atomic_compare_exchange(__ptr, __expected, __desired, __is_weak, __success, __failure);
-    } else { // _Tp has padding bits and __builtin_clear_padding is available
+    } else { // value_type has padding bits and __builtin_clear_padding is available
       __clear_padding(*__desired);
-      _Tp __copy = *__expected;
+      value_type __copy = *__expected;
       __clear_padding(__copy);
       // The algorithm we use here is basically to perform `__atomic_compare_exchange` on the
       // values until it has either succeeded, or failed because the value representation of the
@@ -88,15 +101,15 @@ struct __atomic_ref_base {
       // we basically loop until its failure is caused by the value representation of the objects
       // being different, not only their object representation.
       while (true) {
-        _Tp __prev = __copy;
+        value_type __prev = __copy;
         if (__atomic_compare_exchange(__ptr, std::addressof(__copy), __desired, __is_weak, __success, __failure)) {
           return true;
         }
-        _Tp __curr = __copy;
-        if (std::memcmp(__clear_padding(__prev), __clear_padding(__curr), sizeof(_Tp)) != 0) {
+        value_type __curr = __copy;
+        if (std::memcmp(__clear_padding(__prev), __clear_padding(__curr), sizeof(value_type)) != 0) {
           // Value representation without padding bits do not compare equal ->
           // write the current content of *ptr into *expected
-          std::memcpy(__expected, std::addressof(__copy), sizeof(_Tp));
+          std::memcpy(__expected, std::addressof(__copy), sizeof(value_type));
           return false;
         }
       }
@@ -110,8 +123,6 @@ struct __atomic_ref_base {
   static constexpr size_t __min_alignment = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || (sizeof(_Tp) > 16) ? 0 : sizeof(_Tp);
 
 public:
-  using value_type = _Tp;
-
   static constexpr size_t required_alignment = alignof(_Tp) > __min_alignment ? alignof(_Tp) : __min_alignment;
 
   // The __atomic_always_lock_free builtin takes into account the alignment of the pointer if provided,
@@ -123,43 +134,50 @@ struct __atomic_ref_base {
 
   _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const noexcept { return __atomic_is_lock_free(sizeof(_Tp), __ptr_); }
 
-  _LIBCPP_HIDE_FROM_ABI void store(_Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept
-      _LIBCPP_CHECK_STORE_MEMORY_ORDER(__order) {
+  _LIBCPP_HIDE_FROM_ABI void store(value_type __desired, memory_order __order = memory_order::seq_cst) const noexcept
+    requires(!is_const_v<_Tp>)
+  _LIBCPP_CHECK_STORE_MEMORY_ORDER(__order) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
         __order == memory_order::relaxed || __order == memory_order::release || __order == memory_order::seq_cst,
         "atomic_ref: memory order argument to atomic store operation is invalid");
     __atomic_store(__ptr_, __clear_padding(__desired), std::__to_gcc_order(__order));
   }
 
-  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI value_type operator=(value_type __desired) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
     store(__desired);
     return __desired;
   }
 
-  _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __order = memory_order::seq_cst) const noexcept
+  _LIBCPP_HIDE_FROM_ABI value_type load(memory_order __order = memory_order::seq_cst) const noexcept
       _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__order) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
         __order == memory_order::relaxed || __order == memory_order::consume || __order == memory_order::acquire ||
             __order == memory_order::seq_cst,
         "atomic_ref: memory order argument to atomic load operation is invalid");
-    alignas(_Tp) byte __mem[sizeof(_Tp)];
-    auto* __ret = reinterpret_cast<_Tp*>(__mem);
+    alignas(value_type) byte __mem[sizeof(value_type)];
+    auto* __ret = reinterpret_cast<value_type*>(__mem);
     __atomic_load(__ptr_, __ret, std::__to_gcc_order(__order));
     return *__ret;
   }
 
-  _LIBCPP_HIDE_FROM_ABI operator _Tp() const noexcept { return load(); }
+  _LIBCPP_HIDE_FROM_ABI operator value_type() const noexcept { return load(); }
 
-  _LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept {
-    alignas(_Tp) byte __mem[sizeof(_Tp)];
-    auto* __ret = reinterpret_cast<_Tp*>(__mem);
+  _LIBCPP_HIDE_FROM_ABI value_type
+  exchange(value_type __desired, memory_order __order = memory_order::seq_cst) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    alignas(value_type) byte __mem[sizeof(value_type)];
+    auto* __ret = reinterpret_cast<value_type*>(__mem);
     __atomic_exchange(__ptr_, __clear_padding(__desired), __ret, std::__to_gcc_order(__order));
     return *__ret;
   }
 
-  _LIBCPP_HIDE_FROM_ABI bool
-  compare_exchange_weak(_Tp& __expected, _Tp __desired, memory_order __success, memory_order __failure) const noexcept
-      _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__success, __failure) {
+  _LIBCPP_HIDE_FROM_ABI bool compare_exchange_weak(
+      value_type& __expected, value_type __desired, memory_order __success, memory_order __failure) const noexcept
+    requires(!is_const_v<_Tp>)
+  _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__success, __failure) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
         __failure == memory_order::relaxed || __failure == memory_order::consume ||
             __failure == memory_order::acquire || __failure == memory_order::seq_cst,
@@ -172,9 +190,10 @@ struct __atomic_ref_base {
         std::__to_gcc_order(__success),
         std::__to_gcc_order(__failure));
   }
-  _LIBCPP_HIDE_FROM_ABI bool
-  compare_exchange_strong(_Tp& __expected, _Tp __desired, memory_order __success, memory_order __failure) const noexcept
-      _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__success, __failure) {
+  _LIBCPP_HIDE_FROM_ABI bool compare_exchange_strong(
+      value_type& __expected, value_type __desired, memory_order __success, memory_order __failure) const noexcept
+    requires(!is_const_v<_Tp>)
+  _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__success, __failure) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
         __failure == memory_order::relaxed || __failure == memory_order::consume ||
             __failure == memory_order::acquire || __failure == memory_order::seq_cst,
@@ -188,8 +207,10 @@ struct __atomic_ref_base {
         std::__to_gcc_order(__failure));
   }
 
-  _LIBCPP_HIDE_FROM_ABI bool
-  compare_exchange_weak(_Tp& __expected, _Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI bool compare_exchange_weak(
+      value_type& __expected, value_type __desired, memory_order __order = memory_order::seq_cst) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
     return __compare_exchange(
         __ptr_,
         std::addressof(__expected),
@@ -198,8 +219,10 @@ struct __atomic_ref_base {
         std::__to_gcc_order(__order),
         std::__to_gcc_failure_order(__order));
   }
-  _LIBCPP_HIDE_FROM_ABI bool
-  compare_exchange_strong(_Tp& __expected, _Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI bool compare_exchange_strong(
+      value_type& __expected, value_type __desired, memory_order __order = memory_order::seq_cst) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
     return __compare_exchange(
         __ptr_,
         std::addressof(__expected),
@@ -209,7 +232,7 @@ struct __atomic_ref_base {
         std::__to_gcc_failure_order(__order));
   }
 
-  _LIBCPP_HIDE_FROM_ABI void wait(_Tp __old, memory_order __order = memory_order::seq_cst) const noexcept
+  _LIBCPP_HIDE_FROM_ABI void wait(value_type __old, memory_order __order = memory_order::seq_cst) const noexcept
       _LIBCPP_CHECK_WAIT_MEMORY_ORDER(__order) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
         __order == memory_order::relaxed || __order == memory_order::consume || __order == memory_order::acquire ||
@@ -217,8 +240,16 @@ struct __atomic_ref_base {
         "atomic_ref: memory order argument to atomic wait operation is invalid");
     std::__atomic_wait(*this, __old, __order);
   }
-  _LIBCPP_HIDE_FROM_ABI void notify_one() const noexcept { std::__atomic_notify_one(*this); }
-  _LIBCPP_HIDE_FROM_ABI void notify_all() const noexcept { std::__atomic_notify_all(*this); }
+  _LIBCPP_HIDE_FROM_ABI void notify_one() const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    std::__atomic_notify_one(*this);
+  }
+  _LIBCPP_HIDE_FROM_ABI void notify_all() const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    std::__atomic_notify_all(*this);
+  }
 
 protected:
   using _Aligned_Tp [[__gnu__::__aligned__(required_alignment), __gnu__::__nodebug__]] = _Tp;
@@ -243,6 +274,8 @@ struct atomic_ref : public __atomic_ref_base<_Tp> {
 
   using __base _LIBCPP_NODEBUG = __atomic_ref_base<_Tp>;
 
+  static_assert(__base::is_always_lock_free || !is_volatile_v<_Tp>);
+
   _LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp& __obj) : __base(__obj) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
         reinterpret_cast<uintptr_t>(std::addressof(__obj)) % __base::required_alignment == 0,
@@ -251,17 +284,24 @@ struct atomic_ref : public __atomic_ref_base<_Tp> {
 
   _LIBCPP_HIDE_FROM_ABI atomic_ref(const atomic_ref&) noexcept = default;
 
-  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept { return __base::operator=(__desired); }
+  _LIBCPP_HIDE_FROM_ABI __base::value_type operator=(__base::value_type __desired) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return __base::operator=(__desired);
+  }
 
   atomic_ref& operator=(const atomic_ref&) = delete;
 };
 
 template <class _Tp>
-  requires(std::integral<_Tp> && !std::same_as<bool, _Tp>)
+  requires(integral<_Tp> && !same_as<bool, __remove_cv_t<_Tp>>)
 struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
   using __base _LIBCPP_NODEBUG = __atomic_ref_base<_Tp>;
 
+  static_assert(__base::is_always_lock_free || !is_volatile_v<_Tp>);
+
   using difference_type = __base::value_type;
+  using typename __base::value_type;
 
   _LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp& __obj) : __base(__obj) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
@@ -271,43 +311,101 @@ struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
 
   _LIBCPP_HIDE_FROM_ABI atomic_ref(const atomic_ref&) noexcept = default;
 
-  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept { return __base::operator=(__desired); }
+  _LIBCPP_HIDE_FROM_ABI value_type operator=(value_type __desired) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return __base::operator=(__desired);
+  }
 
   atomic_ref& operator=(const atomic_ref&) = delete;
 
-  _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI value_type
+  fetch_add(value_type __arg, memory_order __order = memory_order_seq_cst) const noexcept
+    requires(!is_const_v<value_type>)
+  {
     return __atomic_fetch_add(this->__ptr_, __arg, std::__to_gcc_order(__order));
   }
-  _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI value_type
+  fetch_sub(value_type __arg, memory_order __order = memory_order_seq_cst) const noexcept
+    requires(!is_const_v<value_type>)
+  {
     return __atomic_fetch_sub(this->__ptr_, __arg, std::__to_gcc_order(__order));
   }
-  _LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI value_type
+  fetch_and(value_type __arg, memory_order __order = memory_order_seq_cst) const noexcept
+    requires(!is_const_v<value_type>)
+  {
     return __atomic_fetch_and(this->__ptr_, __arg, std::__to_gcc_order(__order));
   }
-  _LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI value_type
+  fetch_or(value_type __arg, memory_order __order = memory_order_seq_cst) const noexcept
+    requires(!is_const_v<value_type>)
+  {
     return __atomic_fetch_or(this->__ptr_, __arg, std::__to_gcc_order(__order));
   }
-  _LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI value_type
+  fetch_xor(value_type __arg, memory_order __order = memory_order_seq_cst) const noexcept
+    requires(!is_const_v<value_type>)
+  {
     return __atomic_fetch_xor(this->__ptr_, __arg, std::__to_gcc_order(__order));
   }
 
-  _LIBCPP_HIDE_FROM_ABI _Tp operator++(int) const noexcept { return fetch_add(_Tp(1)); }
-  _LIBCPP_HIDE_FROM_ABI _Tp operator--(int) const noexcept { return fetch_sub(_Tp(1)); }
-  _LIBCPP_HIDE_FROM_ABI _Tp operator++() const noexcept { return fetch_add(_Tp(1)) + _Tp(1); }
-  _LIBCPP_HIDE_FROM_ABI _Tp operator--() const noexcept { return fetch_sub(_Tp(1)) - _Tp(1); }
-  _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __arg) const noexcept { return fetch_add(__arg) + __arg; }
-  _LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __arg) const noexcept { return fetch_sub(__arg) - __arg; }
-  _LIBCPP_HIDE_FROM_ABI _Tp operator&=(_Tp __arg) const noexcept { return fetch_and(__arg) & __arg; }
-  _LIBCPP_HIDE_FROM_ABI _Tp operator|=(_Tp __arg) const noexcept { return fetch_or(__arg) | __arg; }
-  _LIBCPP_HIDE_FROM_ABI _Tp operator^=(_Tp __arg) const noexcept { return fetch_xor(__arg) ^ __arg; }
+  _LIBCPP_HIDE_FROM_ABI value_type operator++(int) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_add(value_type(1));
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator--(int) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_sub(value_type(1));
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator++() const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_add(value_type(1)) + value_type(1);
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator--() const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_sub(value_type(1)) - value_type(1);
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator+=(value_type __arg) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_add(__arg) + __arg;
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator-=(value_type __arg) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_sub(__arg) - __arg;
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator&=(value_type __arg) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_and(__arg) & __arg;
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator|=(value_type __arg) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_or(__arg) | __arg;
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator^=(value_type __arg) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_xor(__arg) ^ __arg;
+  }
 };
 
 template <class _Tp>
-  requires std::floating_point<_Tp>
+  requires floating_point<_Tp>
 struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
   using __base _LIBCPP_NODEBUG = __atomic_ref_base<_Tp>;
 
+  static_assert(__base::is_always_lock_free || !is_volatile_v<_Tp>);
+
   using difference_type = __base::value_type;
+  using typename __base::value_type;
 
   _LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp& __obj) : __base(__obj) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
@@ -317,56 +415,112 @@ struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
 
   _LIBCPP_HIDE_FROM_ABI atomic_ref(const atomic_ref&) noexcept = default;
 
-  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept { return __base::operator=(__desired); }
+  _LIBCPP_HIDE_FROM_ABI value_type operator=(value_type __desired) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return __base::operator=(__desired);
+  }
 
   atomic_ref& operator=(const atomic_ref&) = delete;
 
-  _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
-    _Tp __old = this->load(memory_order_relaxed);
-    _Tp __new = __old + __arg;
+  _LIBCPP_HIDE_FROM_ABI value_type
+  fetch_add(value_type __arg, memory_order __order = memory_order_seq_cst) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    value_type __old = this->load(memory_order_relaxed);
+    value_type __new = __old + __arg;
     while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed)) {
       __new = __old + __arg;
     }
     return __old;
   }
-  _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
-    _Tp __old = this->load(memory_order_relaxed);
-    _Tp __new = __old - __arg;
+  _LIBCPP_HIDE_FROM_ABI value_type
+  fetch_sub(value_type __arg, memory_order __order = memory_order_seq_cst) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    value_type __old = this->load(memory_order_relaxed);
+    value_type __new = __old - __arg;
     while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed)) {
       __new = __old - __arg;
     }
     return __old;
   }
 
-  _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __arg) const noexcept { return fetch_add(__arg) + __arg; }
-  _LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __arg) const noexcept { return fetch_sub(__arg) - __arg; }
+  _LIBCPP_HIDE_FROM_ABI value_type operator+=(value_type __arg) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_add(__arg) + __arg;
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator-=(value_type __arg) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_sub(__arg) - __arg;
+  }
 };
 
 template <class _Tp>
-struct atomic_ref<_Tp*> : public __atomic_ref_base<_Tp*> {
-  using __base _LIBCPP_NODEBUG = __atomic_ref_base<_Tp*>;
+  requires(is_pointer_v<_Tp> && is_object_v<remove_pointer_t<_Tp>>)
+struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
+  using __base _LIBCPP_NODEBUG = __atomic_ref_base<_Tp>;
 
   using difference_type = ptrdiff_t;
+  using typename __base::value_type;
 
-  _LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp*& __ptr) : __base(__ptr) {}
+  _LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp& __ptr) : __base(__ptr) {}
 
-  _LIBCPP_HIDE_FROM_ABI _Tp* operator=(_Tp* __desired) const noexcept { return __base::operator=(__desired); }
+  _LIBCPP_HIDE_FROM_ABI value_type operator=(value_type __desired) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return __base::operator=(__desired);
+  }
 
   atomic_ref& operator=(const atomic_ref&) = delete;
 
-  _LIBCPP_HIDE_FROM_ABI _Tp* fetch_add(ptrdiff_t __arg, memory_order __order = memory_order_seq_cst) const noexcept {
-    return __atomic_fetch_add(this->__ptr_, __arg * sizeof(_Tp), std::__to_gcc_order(__order));
+  _LIBCPP_HIDE_FROM_ABI value_type
+  fetch_add(ptrdiff_t __arg, memory_order __order = memory_order_seq_cst) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return __atomic_fetch_add(
+        this->__ptr_, __arg * sizeof(__remove_pointer_t<value_type>), std::__to_gcc_order(__order));
   }
-  _LIBCPP_HIDE_FROM_ABI _Tp* fetch_sub(ptrdiff_t __arg, memory_order __order = memory_order_seq_cst) const noexcept {
-    return __atomic_fetch_sub(this->__ptr_, __arg * sizeof(_Tp), std::__to_gcc_order(__order));
+  _LIBCPP_HIDE_FROM_ABI value_type
+  fetch_sub(ptrdiff_t __arg, memory_order __order = memory_order_seq_cst) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return __atomic_fetch_sub(
+        this->__ptr_, __arg * sizeof(__remove_pointer_t<value_type>), std::__to_gcc_order(__order));
   }
 
-  _LIBCPP_HIDE_FROM_ABI _Tp* operator++(int) const noexcept { return fetch_add(1); }
-  _LIBCPP_HIDE_FROM_ABI _Tp* operator--(int) const noexcept { return fetch_sub(1); }
-  _LIBCPP_HIDE_FROM_ABI _Tp* operator++() const noexcept { return fetch_add(1) + 1; }
-  _LIBCPP_HIDE_FROM_ABI _Tp* operator--() const noexcept { return fetch_sub(1) - 1; }
-  _LIBCPP_HIDE_FROM_ABI _Tp* operator+=(ptrdiff_t __arg) const noexcept { return fetch_add(__arg) + __arg; }
-  _LIBCPP_HIDE_FROM_ABI _Tp* operator-=(ptrdiff_t __arg) const noexcept { return fetch_sub(__arg) - __arg; }
+  _LIBCPP_HIDE_FROM_ABI value_type operator++(int) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_add(1);
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator--(int) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_sub(1);
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator++() const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_add(1) + 1;
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator--() const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_sub(1) - 1;
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator+=(ptrdiff_t __arg) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_add(__arg) + __arg;
+  }
+  _LIBCPP_HIDE_FROM_ABI value_type operator-=(ptrdiff_t __arg) const noexcept
+    requires(!is_const_v<_Tp>)
+  {
+    return fetch_sub(__arg) - __arg;
+  }
 };
 
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(atomic_ref);
diff --git a/libcxx/include/__atomic/support.h b/libcxx/include/__atomic/support.h
index 99d0f6aa543ca..64533036125b2 100644
--- a/libcxx/include/__atomic/support.h
+++ b/libcxx/include/__atomic/support.h
@@ -10,6 +10,8 @@
 #define _LIBCPP___ATOMIC_SUPPORT_H
 
 #include <__config>
+#include <__type_traits/is_const.h>
+#include <__type_traits/is_volatile.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -112,6 +114,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <typename _Tp, typename _Base = __cxx_atomic_base_impl<_Tp> >
 struct __cxx_atomic_impl : public _Base {
+  static_assert(!is_const<_Tp>::value && !is_volatile<_Tp>::value,
+                "std::atomic<T> requires that 'T' be a cv-unqualified type");
+
   _LIBCPP_HIDE_FROM_ABI __cxx_atomic_impl() _NOEXCEPT = default;
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __cxx_atomic_impl(_Tp __value) _NOEXCEPT : _Base(__value) {}
 };
diff --git a/libcxx/test/std/atomics/atomics.ref/assign.pass.cpp b/libcxx/test/std/atomics/atomics.ref/assign.pass.cpp
index 9b2f9042e9836..80235d9436923 100644
--- a/libcxx/test/std/atomics/atomics.ref/assign.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/assign.pass.cpp
@@ -23,29 +23,50 @@
 template <typename T>
 struct TestAssign {
   void operator()() const {
-    {
-      T x(T(1));
-      std::atomic_ref<T> const a(x);
+    using Unqualified = std::remove_cv_t<T>;
+    static_assert(std::is_assignable_v<std::atomic_ref<T>, Unqualified> == !std::is_const_v<T>);
 
-      std::same_as<T> decltype(auto) y = (a = T(2));
-      assert(y == T(2));
-      assert(x == T(2));
+    if constexpr (!std::is_const_v<T>) {
+      {
+        T x(Unqualified(1));
+        std::atomic_ref<T> const a(x);
 
-      ASSERT_NOEXCEPT(a = T(0));
-      static_assert(std::is_nothrow_assignable_v<std::atomic_ref<T>, T>);
+        std::same_as<Unqualified> decltype(auto) y = (a = Unqualified(2));
+        assert(y == Unqualified(2));
+        assert(const_cast<Unqualified const&>(x) == Unqualified(2));
 
-      static_assert(!std::is_copy_assignable_v<std::atomic_ref<T>>);
-    }
+        ASSERT_NOEXCEPT(a = Unqualified(0));
+        static_assert(std::is_nothrow_assignable_v<std::atomic_ref<T>, Unqualified>);
+        static_assert(!std::is_copy_assignable_v<std::atomic_ref<T>>);
+      }
 
-    {
-      auto assign = [](std::atomic_ref<T> const& y, T, T new_val) { y = new_val; };
-      auto load   = [](std::atomic_ref<T> const& y) { return y.load(); };
-      test_seq_cst<T>(assign, load);
+      {
+        auto assign = [](std::atomic_ref<T> const& y, T const&, T const& new_val) {
+          y = const_cast<Unqualified const&>(new_val);
+        };
+        auto load = [](std::atomic_ref<T> const& y) { return y.load(); };
+        test_seq_cst<T>(assign, load);
+      }
     }
   }
 };
 
+template <template <class...> class F>
+struct CallWithCVQualifiers {
+  template <class T>
+  struct apply {
+    void operator()() const {
+      F<T>()();
+      F<T const>()();
+      if constexpr (std::atomic_ref<T>::is_always_lock_free) {
+        F<T volatile>()();
+        F<T const volatile>()();
+      }
+    }
+  };
+};
+
 int main(int, char**) {
-  TestEachAtomicType<TestAssign>()();
+  TestEachAtomicType<CallWithCVQualifiers<TestAssign>::apply>()();
   return 0;
 }
diff --git a/libcxx/test/std/atomics/atomics.ref/compare_exchange_strong.pass.cpp b/libcxx/test/std/atomics/atomics.ref/compare_exchange_strong.pass.cpp
index 90aa5ea5b6df4..e0e577a5ce646 100644
--- a/libcxx/test/std/atomics/atomics.ref/compare_exchange_strong.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/compare_exchange_strong.pass.cpp
@@ -24,201 +24,265 @@
 #include "test_helper.h"
 #include "test_macros.h"
 
+template <typename T, typename U>
+concept has_compare_exchange_strong_1 =
+    requires(T const& x, U& expected, U desired) { x.compare_exchange_strong(expected, desired); };
+template <typename T, typename U>
+concept has_compare_exchange_strong_2 = requires(T const& x, U& expected, U desired, std::memory_order order) {
+  x.compare_exchange_strong(expected, desired, order);
+};
+template <typename T, typename U>
+concept has_compare_exchange_strong_3 =
+    requires(T const& x, U& expected, U desired, std::memory_order success, std::memory_order failure) {
+      x.compare_exchange_strong(expected, desired, success, failure);
+    };
+
+template <typename T, typename U>
+concept has_compare_exchange_strong =
+    has_compare_exchange_strong_1<T, U> && has_compare_exchange_strong_2<T, U> && has_compare_exchange_strong_3<T, U>;
+
+template <typename T, typename U>
+concept does_not_have_compare_exchange_strong =
+    !has_compare_exchange_strong_1<T, U> && !has_compare_exchange_strong_2<T, U> &&
+    !has_compare_exchange_strong_3<T, U>;
+
 template <typename T>
 struct TestCompareExchangeStrong {
   void operator()() const {
-    {
-      T x(T(1));
-      std::atomic_ref<T> const a(x);
-
-      T t(T(1));
-      std::same_as<bool> decltype(auto) y = a.compare_exchange_strong(t, T(2));
-      assert(y == true);
-      assert(a == T(2));
-      assert(t == T(1));
-      y = a.compare_exchange_strong(t, T(3));
-      assert(y == false);
-      assert(a == T(2));
-      assert(t == T(2));
-
-      ASSERT_NOEXCEPT(a.compare_exchange_strong(t, T(2)));
-    }
-    {
-      T x(T(1));
-      std::atomic_ref<T> const a(x);
-
-      T t(T(1));
-      std::same_as<bool> decltype(auto) y = a.compare_exchange_strong(t, T(2), std::memory_order_seq_cst);
-      assert(y == true);
-      assert(a == T(2));
-      assert(t == T(1));
-      y = a.compare_exchange_strong(t, T(3), std::memory_order_seq_cst);
-      assert(y == false);
-      assert(a == T(2));
-      assert(t == T(2));
-
-      ASSERT_NOEXCEPT(a.compare_exchange_strong(t, T(2), std::memory_order_seq_cst));
-    }
-    {
-      T x(T(1));
-      std::atomic_ref<T> const a(x);
-
-      T t(T(1));
-      std::same_as<bool> decltype(auto) y =
-          a.compare_exchange_strong(t, T(2), std::memory_order_release, std::memory_order_relaxed);
-      assert(y == true);
-      assert(a == T(2));
-      assert(t == T(1));
-      y = a.compare_exchange_strong(t, T(3), std::memory_order_release, std::memory_order_relaxed);
-      assert(y == false);
-      assert(a == T(2));
-      assert(t == T(2));
-
-      ASSERT_NOEXCEPT(a.compare_exchange_strong(t, T(2), std::memory_order_release, std::memory_order_relaxed));
-    }
+    using Unqualified = std::remove_cv_t<T>;
+    static_assert(has_compare_exchange_strong<std::atomic_ref<T>, Unqualified> == !std::is_const_v<T>);
+    static_assert(does_not_have_compare_exchange_strong<std::atomic_ref<T>, Unqualified> == std::is_const_v<T>);
 
-    // success memory_order::release
-    {
-      auto store = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
-        auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::release, std::memory_order::relaxed);
-        assert(r);
-      };
-
-      auto load = [](std::atomic_ref<T> const& x) { return x.load(std::memory_order::acquire); };
-      test_acquire_release<T>(store, load);
-
-      auto store_one_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
-        auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::release);
-        assert(r);
-      };
-      test_acquire_release<T>(store_one_arg, load);
-    }
+    if constexpr (!std::is_const_v<T>) {
+      {
+        T x(Unqualified(1));
+        std::atomic_ref<T> const a(x);
 
-    // success memory_order::acquire
-    {
-      auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val, std::memory_order::release); };
-
-      auto load = [](std::atomic_ref<T> const& x) {
-        auto val = x.load(std::memory_order::relaxed);
-        while (!x.compare_exchange_strong(val, val, std::memory_order::acquire, std::memory_order::relaxed)) {
-        }
-        return val;
-      };
-      test_acquire_release<T>(store, load);
-
-      auto load_one_arg = [](std::atomic_ref<T> const& x) {
-        auto val = x.load(std::memory_order::relaxed);
-        while (!x.compare_exchange_strong(val, val, std::memory_order::acquire)) {
-        }
-        return val;
-      };
-      test_acquire_release<T>(store, load_one_arg);
-    }
+        Unqualified t(Unqualified(1));
+        std::same_as<bool> decltype(auto) y = a.compare_exchange_strong(t, Unqualified(2));
+        assert(y == true);
+        assert(a == Unqualified(2));
+        assert(t == Unqualified(1));
+        y = a.compare_exchange_strong(t, Unqualified(3));
+        assert(y == false);
+        assert(a == Unqualified(2));
+        assert(t == Unqualified(2));
 
-    // success memory_order::acq_rel
-    {
-      auto store = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
-        auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::acq_rel, std::memory_order::relaxed);
-        assert(r);
-      };
-      auto load = [](std::atomic_ref<T> const& x) {
-        auto val = x.load(std::memory_order::relaxed);
-        while (!x.compare_exchange_strong(val, val, std::memory_order::acq_rel, std::memory_order::relaxed)) {
-        }
-        return val;
-      };
-      test_acquire_release<T>(store, load);
-
-      auto store_one_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
-        auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::acq_rel);
-        assert(r);
-      };
-      auto load_one_arg = [](std::atomic_ref<T> const& x) {
-        auto val = x.load(std::memory_order::relaxed);
-        while (!x.compare_exchange_strong(val, val, std::memory_order::acq_rel)) {
-        }
-        return val;
-      };
-      test_acquire_release<T>(store_one_arg, load_one_arg);
-    }
+        ASSERT_NOEXCEPT(a.compare_exchange_strong(t, T(2)));
+      }
+      {
+        T x(Unqualified(1));
+        std::atomic_ref<T> const a(x);
 
-    // success memory_order::seq_cst
-    {
-      auto store = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
-        auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::seq_cst, std::memory_order::relaxed);
-        assert(r);
-      };
-      auto load = [](std::atomic_ref<T> const& x) {
-        auto val = x.load(std::memory_order::relaxed);
-        while (!x.compare_exchange_strong(val, val, std::memory_order::seq_cst, std::memory_order::relaxed)) {
-        }
-        return val;
-      };
-      test_seq_cst<T>(store, load);
-
-      auto store_one_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
-        auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::seq_cst);
-        assert(r);
-      };
-      auto load_one_arg = [](std::atomic_ref<T> const& x) {
-        auto val = x.load(std::memory_order::relaxed);
-        while (!x.compare_exchange_strong(val, val, std::memory_order::seq_cst)) {
-        }
-        return val;
-      };
-      test_seq_cst<T>(store_one_arg, load_one_arg);
-    }
+        Unqualified t(Unqualified(1));
+        std::same_as<bool> decltype(auto) y = a.compare_exchange_strong(t, Unqualified(2), std::memory_order_seq_cst);
+        assert(y == true);
+        assert(a == Unqualified(2));
+        assert(t == Unqualified(1));
+        y = a.compare_exchange_strong(t, T(3), std::memory_order_seq_cst);
+        assert(y == false);
+        assert(a == Unqualified(2));
+        assert(t == Unqualified(2));
 
-    // failure memory_order::acquire
-    {
-      auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val, std::memory_order::release); };
-      auto load  = [](std::atomic_ref<T> const& x) {
-        auto result = x.load(std::memory_order::relaxed);
-        T unexpected(T(255));
-        bool r =
-            x.compare_exchange_strong(unexpected, unexpected, std::memory_order::relaxed, std::memory_order::acquire);
-        assert(!r);
-        return result;
-      };
-      test_acquire_release<T>(store, load);
-
-      auto load_one_arg = [](std::atomic_ref<T> const& x) {
-        auto result = x.load(std::memory_order::relaxed);
-        T unexpected(T(255));
-        bool r = x.compare_exchange_strong(unexpected, unexpected, std::memory_order::acquire);
-        assert(!r);
-        return result;
-      };
-      test_acquire_release<T>(store, load_one_arg);
-
-      // acq_rel replaced by acquire
-      auto load_one_arg_acq_rel = [](std::atomic_ref<T> const& x) {
-        auto result = x.load(std::memory_order::relaxed);
-        T unexpected(T(255));
-        bool r = x.compare_exchange_strong(unexpected, unexpected, std::memory_order::acq_rel);
-        assert(!r);
-        return result;
-      };
-      test_acquire_release<T>(store, load_one_arg_acq_rel);
-    }
+        ASSERT_NOEXCEPT(a.compare_exchange_strong(t, Unqualified(2), std::memory_order_seq_cst));
+      }
+      {
+        T x(Unqualified(1));
+        std::atomic_ref<T> const a(x);
+
+        Unqualified t(Unqualified(1));
+        std::same_as<bool> decltype(auto) y =
+            a.compare_exchange_strong(t, Unqualified(2), std::memory_order_release, std::memory_order_relaxed);
+        assert(y == true);
+        assert(a == Unqualified(2));
+        assert(t == Unqualified(1));
+        y = a.compare_exchange_strong(t, Unqualified(3), std::memory_order_release, std::memory_order_relaxed);
+        assert(y == false);
+        assert(a == Unqualified(2));
+        assert(t == Unqualified(2));
+
+        ASSERT_NOEXCEPT(
+            a.compare_exchange_strong(t, Unqualified(2), std::memory_order_release, std::memory_order_relaxed));
+      }
+
+      // success memory_order::release
+      {
+        auto store = [](std::atomic_ref<T> const& x, T const& old_val, T const& new_val) {
+          auto r = x.compare_exchange_strong(
+              const_cast<Unqualified&>(old_val),
+              const_cast<Unqualified const&>(new_val),
+              std::memory_order::release,
+              std::memory_order::relaxed);
+          assert(r);
+        };
 
-    // failure memory_order::seq_cst
-    {
-      auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val, std::memory_order::seq_cst); };
-      auto load  = [](std::atomic_ref<T> const& x) {
-        auto result = x.load(std::memory_order::relaxed);
-        T unexpected(T(255));
-        bool r =
-            x.compare_exchange_strong(unexpected, unexpected, std::memory_order::relaxed, std::memory_order::seq_cst);
-        assert(!r);
-        return result;
-      };
-      test_seq_cst<T>(store, load);
+        auto load = [](std::atomic_ref<T> const& x) { return x.load(std::memory_order::acquire); };
+        test_acquire_release<T>(store, load);
+        auto store_one_arg = [](std::atomic_ref<T> const& x, T const& old_val, T const& new_val) {
+          auto r = x.compare_exchange_strong(
+              const_cast<Unqualified&>(old_val), const_cast<Unqualified const&>(new_val), std::memory_order::release);
+          assert(r);
+        };
+        test_acquire_release<T>(store_one_arg, load);
+      }
+
+      // success memory_order::acquire
+      {
+        auto store = [](std::atomic_ref<T> const& x, T const&, T const& new_val) {
+          x.store(const_cast<Unqualified const&>(new_val), std::memory_order::release);
+        };
+
+        auto load = [](std::atomic_ref<T> const& x) {
+          auto val = x.load(std::memory_order::relaxed);
+          while (!x.compare_exchange_strong(val, val, std::memory_order::acquire, std::memory_order::relaxed)) {
+          }
+          return val;
+        };
+        test_acquire_release<T>(store, load);
+
+        auto load_one_arg = [](std::atomic_ref<T> const& x) {
+          auto val = x.load(std::memory_order::relaxed);
+          while (!x.compare_exchange_strong(val, val, std::memory_order::acquire)) {
+          }
+          return val;
+        };
+        test_acquire_release<T>(store, load_one_arg);
+      }
+
+      // success memory_order::acq_rel
+      {
+        auto store = [](std::atomic_ref<T> const& x, T const& old_val, T const& new_val) {
+          auto r = x.compare_exchange_strong(
+              const_cast<Unqualified&>(old_val),
+              const_cast<Unqualified const&>(new_val),
+              std::memory_order::acq_rel,
+              std::memory_order::relaxed);
+          assert(r);
+        };
+        auto load = [](std::atomic_ref<T> const& x) {
+          auto val = x.load(std::memory_order::relaxed);
+          while (!x.compare_exchange_strong(val, val, std::memory_order::acq_rel, std::memory_order::relaxed)) {
+          }
+          return val;
+        };
+        test_acquire_release<T>(store, load);
+
+        auto store_one_arg = [](std::atomic_ref<T> const& x, T const& old_val, T const& new_val) {
+          auto r = x.compare_exchange_strong(
+              const_cast<Unqualified&>(old_val), const_cast<Unqualified const&>(new_val), std::memory_order::acq_rel);
+          assert(r);
+        };
+        auto load_one_arg = [](std::atomic_ref<T> const& x) {
+          auto val = x.load(std::memory_order::relaxed);
+          while (!x.compare_exchange_strong(val, val, std::memory_order::acq_rel)) {
+          }
+          return val;
+        };
+        test_acquire_release<T>(store_one_arg, load_one_arg);
+      }
+
+      // success memory_order::seq_cst
+      {
+        auto store = [](std::atomic_ref<T> const& x, T const& old_val, T const& new_val) {
+          auto r = x.compare_exchange_strong(
+              const_cast<Unqualified&>(old_val),
+              const_cast<Unqualified const&>(new_val),
+              std::memory_order::seq_cst,
+              std::memory_order::relaxed);
+          assert(r);
+        };
+        auto load = [](std::atomic_ref<T> const& x) {
+          auto val = x.load(std::memory_order::relaxed);
+          while (!x.compare_exchange_strong(val, val, std::memory_order::seq_cst, std::memory_order::relaxed)) {
+          }
+          return val;
+        };
+        test_seq_cst<T>(store, load);
+
+        auto store_one_arg = [](std::atomic_ref<T> const& x, T const& old_val, T const& new_val) {
+          auto r = x.compare_exchange_strong(
+              const_cast<Unqualified&>(old_val), const_cast<Unqualified const&>(new_val), std::memory_order::seq_cst);
+          assert(r);
+        };
+        auto load_one_arg = [](std::atomic_ref<T> const& x) {
+          auto val = x.load(std::memory_order::relaxed);
+          while (!x.compare_exchange_strong(val, val, std::memory_order::seq_cst)) {
+          }
+          return val;
+        };
+        test_seq_cst<T>(store_one_arg, load_one_arg);
+      }
+
+      // failure memory_order::acquire
+      {
+        auto store = [](std::atomic_ref<T> const& x, T const&, T const& new_val) {
+          x.store(const_cast<Unqualified const&>(new_val), std::memory_order::release);
+        };
+        auto load = [](std::atomic_ref<T> const& x) {
+          auto result = x.load(std::memory_order::relaxed);
+          Unqualified unexpected(Unqualified(255));
+          bool r =
+              x.compare_exchange_strong(unexpected, unexpected, std::memory_order::relaxed, std::memory_order::acquire);
+          assert(!r);
+          return result;
+        };
+        test_acquire_release<T>(store, load);
+
+        auto load_one_arg = [](std::atomic_ref<T> const& x) {
+          auto result = x.load(std::memory_order::relaxed);
+          Unqualified unexpected(Unqualified(255));
+          bool r = x.compare_exchange_strong(unexpected, unexpected, std::memory_order::acquire);
+          assert(!r);
+          return result;
+        };
+        test_acquire_release<T>(store, load_one_arg);
+
+        // acq_rel replaced by acquire
+        auto load_one_arg_acq_rel = [](std::atomic_ref<T> const& x) {
+          auto result = x.load(std::memory_order::relaxed);
+          Unqualified unexpected(Unqualified(255));
+          bool r = x.compare_exchange_strong(unexpected, unexpected, std::memory_order::acq_rel);
+          assert(!r);
+          return result;
+        };
+        test_acquire_release<T>(store, load_one_arg_acq_rel);
+      }
+
+      // failure memory_order::seq_cst
+      {
+        auto store = [](std::atomic_ref<T> const& x, T const&, T const& new_val) {
+          x.store(const_cast<Unqualified const&>(new_val), std::memory_order::seq_cst);
+        };
+        auto load = [](std::atomic_ref<T> const& x) {
+          auto result = x.load(std::memory_order::relaxed);
+          Unqualified unexpected(Unqualified(255));
+          bool r =
+              x.compare_exchange_strong(unexpected, unexpected, std::memory_order::relaxed, std::memory_order::seq_cst);
+          assert(!r);
+          return result;
+        };
+        test_seq_cst<T>(store, load);
+      }
     }
   }
 };
 
+template <template <class...> class F>
+struct CallWithCVQualifiers {
+  template <class T>
+  struct apply {
+    void operator()() const {
+      F<T>()();
+      F<T const>()();
+      if constexpr (std::atomic_ref<T>::is_always_lock_free) {
+        F<T volatile>()();
+        F<T const volatile>()();
+      }
+    }
+  };
+};
+
 int main(int, char**) {
-  TestEachAtomicType<TestCompareExchangeStrong>()();
+  TestEachAtomicType<CallWithCVQualifiers<TestCompareExchangeStrong>::apply>()();
   return 0;
 }
diff --git a/libcxx/test/std/atomics/atomics.ref/convert.pass.cpp b/libcxx/test/std/atomics/atomics.ref/convert.pass.cpp
index 2a58a5ea6ae2a..cd7a5f72b05bb 100644
--- a/libcxx/test/std/atomics/atomics.ref/convert.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/convert.pass.cpp
@@ -22,24 +22,47 @@
 template <typename T>
 struct TestConvert {
   void operator()() const {
-    T x(T(1));
+    using Unqualified = std::remove_cv_t<T>;
+    static_assert(std::is_nothrow_convertible_v<std::atomic_ref<T>, Unqualified>);
 
-    T copy = x;
-    std::atomic_ref<T> const a(copy);
+    {
+      T x(Unqualified(1));
 
-    T converted = a;
-    assert(converted == x);
+      T copy = const_cast<Unqualified const&>(x);
+      std::atomic_ref<T> const a(copy);
 
-    ASSERT_NOEXCEPT(T(a));
-    static_assert(std::is_nothrow_convertible_v<std::atomic_ref<T>, T>);
+      Unqualified converted = a;
+      assert(converted == const_cast<Unqualified const&>(x));
 
-    auto store = [](std::atomic_ref<T> const& y, T, T new_val) { y.store(new_val); };
-    auto load  = [](std::atomic_ref<T> const& y) { return static_cast<T>(y); };
-    test_seq_cst<T>(store, load);
+      ASSERT_NOEXCEPT(T(a));
+    }
+
+    if constexpr (!std::is_const_v<T>) { // FIXME
+      auto store = [](std::atomic_ref<T> const& y, T const&, T const& new_val) {
+        y.store(const_cast<Unqualified const&>(new_val));
+      };
+      auto load = [](std::atomic_ref<T> const& y) { return static_cast<Unqualified>(y); };
+      test_seq_cst<T>(store, load);
+    }
   }
 };
 
+template <template <class...> class F>
+struct CallWithCVQualifiers {
+  template <class T>
+  struct apply {
+    void operator()() const {
+      F<T>()();
+      F<T const>()();
+      if constexpr (std::atomic_ref<T>::is_always_lock_free) {
+        F<T volatile>()();
+        F<T const volatile>()();
+      }
+    }
+  };
+};
+
 int main(int, char**) {
-  TestEachAtomicType<TestConvert>()();
+  TestEachAtomicType<CallWithCVQualifiers<TestConvert>::apply>()();
   return 0;
 }
diff --git a/libcxx/test/std/atomics/atomics.ref/deduction.pass.cpp b/libcxx/test/std/atomics/atomics.ref/deduction.pass.cpp
index 24a399ac4711e..326954f62c519 100644
--- a/libcxx/test/std/atomics/atomics.ref/deduction.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/deduction.pass.cpp
@@ -21,13 +21,30 @@
 template <typename T>
 struct TestDeduction {
   void operator()() const {
-    T x(T(0));
+    using Unqualified = std::remove_cv_t<T>;
+
+    T x(Unqualified(0));
     std::atomic_ref a(x);
     ASSERT_SAME_TYPE(decltype(a), std::atomic_ref<T>);
   }
 };
 
+template <template <class...> class F>
+struct CallWithCVQualifiers {
+  template <class T>
+  struct apply {
+    void operator()() const {
+      F<T>()();
+      F<T const>()();
+      if constexpr (std::atomic_ref<T>::is_always_lock_free) {
+        F<T volatile>()();
+        F<T const volatile>()();
+      }
+    }
+  };
+};
+
 int main(int, char**) {
-  TestEachAtomicType<TestDeduction>()();
+  TestEachAtomicType<CallWithCVQualifiers<TestDeduction>::apply>()();
   return 0;
 }
diff --git a/libcxx/test/std/atomics/atomics.ref/fetch_add.pass.cpp b/libcxx/test/std/atomics/atomics.ref/fetch_add.pass.cpp
index 8e2605fef9d31..63a4775b97496 100644
--- a/libcxx/test/std/atomics/atomics.ref/fetch_add.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/fetch_add.pass.cpp
@@ -105,6 +105,8 @@ int main(int, char**) {
   TestFetchAdd<double>()();
 
   TestEachPointerType<TestFetchAdd>()();
+  TestDoesNotHaveFetchAdd<void*>()();
+  TestDoesNotHaveFetchAdd<void const*>()();
 
   TestDoesNotHaveFetchAdd<bool>()();
   TestDoesNotHaveFetchAdd<UserAtomicType>()();
diff --git a/libcxx/test/std/atomics/atomics.ref/fetch_sub.pass.cpp b/libcxx/test/std/atomics/atomics.ref/fetch_sub.pass.cpp
index 04def076a301f..c82bcfede195d 100644
--- a/libcxx/test/std/atomics/atomics.ref/fetch_sub.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/fetch_sub.pass.cpp
@@ -105,6 +105,8 @@ int main(int, char**) {
   TestFetchSub<double>()();
 
   TestEachPointerType<TestFetchSub>()();
+  TestDoesNotHaveFetchSub<void*>()();
+  TestDoesNotHaveFetchSub<void const*>()();
 
   TestDoesNotHaveFetchSub<bool>()();
   TestDoesNotHaveFetchSub<UserAtomicType>()();
diff --git a/libcxx/test/std/atomics/atomics.ref/increment_decrement.pass.cpp b/libcxx/test/std/atomics/atomics.ref/increment_decrement.pass.cpp
index 15bf0ecda5363..ef8b2f6ede8b7 100644
--- a/libcxx/test/std/atomics/atomics.ref/increment_decrement.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/increment_decrement.pass.cpp
@@ -124,6 +124,8 @@ int main(int, char**) {
   TestEachFloatingPointType<TestDoesNotHaveIncrementDecrement>()();
 
   TestEachPointerType<TestIncrementDecrement>()();
+  TestDoesNotHaveIncrementDecrement<void*>()();
+  TestDoesNotHaveIncrementDecrement<void const*>()();
 
   TestDoesNotHaveIncrementDecrement<bool>()();
   TestDoesNotHaveIncrementDecrement<UserAtomicType>()();
diff --git a/libcxx/test/std/atomics/atomics.ref/load.pass.cpp b/libcxx/test/std/atomics/atomics.ref/load.pass.cpp
index feed0fbaed842..ab4826c72ef08 100644
--- a/libcxx/test/std/atomics/atomics.ref/load.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/load.pass.cpp
@@ -23,40 +23,63 @@
 template <typename T>
 struct TestLoad {
   void operator()() const {
-    T x(T(1));
+    using Unqualified = std::remove_cv_t<T>;
+
+    T x(Unqualified(1));
     std::atomic_ref<T> const a(x);
 
     {
-      std::same_as<T> decltype(auto) y = a.load();
-      assert(y == T(1));
+      std::same_as<Unqualified> decltype(auto) y = a.load();
+      assert(y == Unqualified(1));
       ASSERT_NOEXCEPT(a.load());
     }
 
     {
-      std::same_as<T> decltype(auto) y = a.load(std::memory_order_seq_cst);
-      assert(y == T(1));
+      std::same_as<Unqualified> decltype(auto) y = a.load(std::memory_order_seq_cst);
+      assert(y == Unqualified(1));
       ASSERT_NOEXCEPT(a.load(std::memory_order_seq_cst));
     }
 
-    // memory_order::seq_cst
-    {
-      auto store           = [](std::atomic_ref<T> const& y, T, T new_val) { y.store(new_val); };
-      auto load_no_arg     = [](std::atomic_ref<T> const& y) { return y.load(); };
-      auto load_with_order = [](std::atomic_ref<T> const& y) { return y.load(std::memory_order::seq_cst); };
-      test_seq_cst<T>(store, load_no_arg);
-      test_seq_cst<T>(store, load_with_order);
-    }
+    if constexpr (!std::is_const_v<T>) { // FIXME
+      // memory_order::seq_cst
+      {
+        auto store = [](std::atomic_ref<T> const& y, T const&, T const& new_val) {
+          y.store(const_cast<Unqualified const&>(new_val));
+        };
+        auto load_no_arg     = [](std::atomic_ref<T> const& y) { return y.load(); };
+        auto load_with_order = [](std::atomic_ref<T> const& y) { return y.load(std::memory_order::seq_cst); };
+        test_seq_cst<T>(store, load_no_arg);
+        test_seq_cst<T>(store, load_with_order);
+      }
 
-    // memory_order::release
-    {
-      auto store = [](std::atomic_ref<T> const& y, T, T new_val) { y.store(new_val, std::memory_order::release); };
-      auto load  = [](std::atomic_ref<T> const& y) { return y.load(std::memory_order::acquire); };
-      test_acquire_release<T>(store, load);
+      // memory_order::release
+      {
+        auto store = [](std::atomic_ref<T> const& y, T const&, T const& new_val) {
+          y.store(const_cast<Unqualified const&>(new_val), std::memory_order::release);
+        };
+        auto load = [](std::atomic_ref<T> const& y) { return y.load(std::memory_order::acquire); };
+        test_acquire_release<T>(store, load);
+      }
     }
   }
 };
 
+template <template <class...> class F>
+struct CallWithCVQualifiers {
+  template <class T>
+  struct apply {
+    void operator()() const {
+      F<T>()();
+      F<T const>()();
+      if constexpr (std::atomic_ref<T>::is_always_lock_free) {
+        F<T volatile>()();
+        F<T const volatile>()();
+      }
+    }
+  };
+};
+
 int main(int, char**) {
-  TestEachAtomicType<TestLoad>()();
+  TestEachAtomicType<CallWithCVQualifiers<TestLoad>::apply>()();
   return 0;
 }
diff --git a/libcxx/test/std/atomics/atomics.ref/member_types.compile.pass.cpp b/libcxx/test/std/atomics/atomics.ref/member_types.compile.pass.cpp
index d0e0313434114..5791a3f341be9 100644
--- a/libcxx/test/std/atomics/atomics.ref/member_types.compile.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/member_types.compile.pass.cpp
@@ -37,7 +37,7 @@ void check_member_types() {
   if constexpr ((std::is_integral_v<T> && !std::is_same_v<T, bool>) || std::is_floating_point_v<T>) {
     ASSERT_SAME_TYPE(typename std::atomic_ref<T>::value_type, T);
     ASSERT_SAME_TYPE(typename std::atomic_ref<T>::difference_type, T);
-  } else if constexpr (std::is_pointer_v<T>) {
+  } else if constexpr (std::is_pointer_v<T> && std::is_object_v<std::remove_pointer_t<T>>) {
     ASSERT_SAME_TYPE(typename std::atomic_ref<T>::value_type, T);
     ASSERT_SAME_TYPE(typename std::atomic_ref<T>::difference_type, std::ptrdiff_t);
   } else {
@@ -70,9 +70,12 @@ void testall() {
   };
   test<Trivial>();
   test<bool>();
-
-  // Partial specialization for pointer types
   test<void*>();
+  test<void const*>();
+
+  // Partial specialization for pointer-to-object types
+  test<int*>();
+  test<int const*>();
 
   // Specialization for integral types
   // + character types
diff --git a/libcxx/test/std/atomics/atomics.ref/operator_minus_equals.pass.cpp b/libcxx/test/std/atomics/atomics.ref/operator_minus_equals.pass.cpp
index 502eff772ab76..6c97d4d010532 100644
--- a/libcxx/test/std/atomics/atomics.ref/operator_minus_equals.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/operator_minus_equals.pass.cpp
@@ -71,6 +71,8 @@ int main(int, char**) {
   TestOperatorMinusEquals<double>()();
 
   TestEachPointerType<TestOperatorMinusEquals>()();
+  TestDoesNotHaveOperatorMinusEquals<void*>()();
+  TestDoesNotHaveOperatorMinusEquals<void const*>()();
 
   TestDoesNotHaveOperatorMinusEquals<bool>()();
   TestDoesNotHaveOperatorMinusEquals<UserAtomicType>()();
diff --git a/libcxx/test/std/atomics/atomics.ref/operator_plus_equals.pass.cpp b/libcxx/test/std/atomics/atomics.ref/operator_plus_equals.pass.cpp
index 1f287f6945bda..a148ec1c9b62e 100644
--- a/libcxx/test/std/atomics/atomics.ref/operator_plus_equals.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/operator_plus_equals.pass.cpp
@@ -71,6 +71,8 @@ int main(int, char**) {
   TestOperatorPlusEquals<double>()();
 
   TestEachPointerType<TestOperatorPlusEquals>()();
+  TestDoesNotHaveOperatorPlusEquals<void*>()();
+  TestDoesNotHaveOperatorPlusEquals<void const*>()();
 
   TestDoesNotHaveOperatorPlusEquals<bool>()();
   TestDoesNotHaveOperatorPlusEquals<UserAtomicType>()();
diff --git a/libcxx/test/std/atomics/atomics.ref/store.pass.cpp b/libcxx/test/std/atomics/atomics.ref/store.pass.cpp
index ea01a3d02a34f..bdf528d181531 100644
--- a/libcxx/test/std/atomics/atomics.ref/store.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/store.pass.cpp
@@ -19,43 +19,72 @@
 #include "test_helper.h"
 #include "test_macros.h"
 
+template <typename T, typename U>
+concept has_store = requires(T const& x, U v) { x.store(v); };
+
 template <typename T>
 struct TestStore {
   void operator()() const {
-    T x(T(1));
-    std::atomic_ref<T> const a(x);
-
-    a.store(T(2));
-    assert(x == T(2));
-    ASSERT_NOEXCEPT(a.store(T(1)));
-
-    a.store(T(3), std::memory_order_seq_cst);
-    assert(x == T(3));
-    ASSERT_NOEXCEPT(a.store(T(0), std::memory_order_seq_cst));
-
-    // TODO memory_order::relaxed
-
-    // memory_order::seq_cst
-    {
-      auto store_no_arg     = [](std::atomic_ref<T> const& y, T, T new_val) { y.store(new_val); };
-      auto store_with_order = [](std::atomic_ref<T> const& y, T, T new_val) {
-        y.store(new_val, std::memory_order::seq_cst);
-      };
-      auto load = [](std::atomic_ref<T> const& y) { return y.load(); };
-      test_seq_cst<T>(store_no_arg, load);
-      test_seq_cst<T>(store_with_order, load);
-    }
+    using Unqualified = std::remove_cv_t<T>;
+    static_assert(has_store<std::atomic_ref<T>, Unqualified> == !std::is_const_v<T>);
+
+    if constexpr (!std::is_const_v<T>) {
+      {
+        T x(Unqualified(1));
+        std::atomic_ref<T> const a(x);
+
+        a.store(T(2));
+        assert(const_cast<Unqualified const&>(x) == Unqualified(2));
+        ASSERT_NOEXCEPT(a.store(T(1)));
+
+        a.store(T(3), std::memory_order_seq_cst);
+        assert(const_cast<Unqualified const&>(x) == Unqualified(3));
+        ASSERT_NOEXCEPT(a.store(T(0), std::memory_order_seq_cst));
+      }
 
-    // memory_order::release
-    {
-      auto store = [](std::atomic_ref<T> const& y, T, T new_val) { y.store(new_val, std::memory_order::release); };
-      auto load  = [](std::atomic_ref<T> const& y) { return y.load(std::memory_order::acquire); };
-      test_acquire_release<T>(store, load);
+      // TODO memory_order::relaxed
+
+      // memory_order::seq_cst
+      {
+        auto store_no_arg = [](std::atomic_ref<T> const& y, T const&, T const& new_val) {
+          y.store(const_cast<Unqualified const&>(new_val));
+        };
+        auto store_with_order = [](std::atomic_ref<T> const& y, T const&, T const& new_val) {
+          y.store(const_cast<Unqualified const&>(new_val), std::memory_order::seq_cst);
+        };
+        auto load = [](std::atomic_ref<T> const& y) { return y.load(); };
+        test_seq_cst<T>(store_no_arg, load);
+        test_seq_cst<T>(store_with_order, load);
+      }
+
+      // memory_order::release
+      {
+        auto store = [](std::atomic_ref<T> const& y, T const&, T const& new_val) {
+          y.store(const_cast<Unqualified const&>(new_val), std::memory_order::release);
+        };
+        auto load = [](std::atomic_ref<T> const& y) { return y.load(std::memory_order::acquire); };
+        test_acquire_release<T>(store, load);
+      }
     }
   }
 };
 
+template <template <class...> class F>
+struct CallWithCVQualifiers {
+  template <class T>
+  struct apply {
+    void operator()() const {
+      F<T>()();
+      F<T const>()();
+      if constexpr (std::atomic_ref<T>::is_always_lock_free) {
+        F<T volatile>()();
+        F<T const volatile>()();
+      }
+    }
+  };
+};
+
 int main(int, char**) {
-  TestEachAtomicType<TestStore>()();
+  TestEachAtomicType<CallWithCVQualifiers<TestStore>::apply>()();
   return 0;
 }
diff --git a/libcxx/test/std/atomics/atomics.ref/test_helper.h b/libcxx/test/std/atomics/atomics.ref/test_helper.h
index 225a70c5a16ca..4f6c6b16b3dd1 100644
--- a/libcxx/test/std/atomics/atomics.ref/test_helper.h
+++ b/libcxx/test/std/atomics/atomics.ref/test_helper.h
@@ -45,12 +45,12 @@ template <class T, class StoreOp, class LoadOp>
 void test_seq_cst(StoreOp store_op, LoadOp load_op) {
 #ifndef TEST_HAS_NO_THREADS
   for (int i = 0; i < 100; ++i) {
-    T old_value(make_value<T>(0));
-    T new_value(make_value<T>(1));
+    T old_value(make_value<std::remove_cv_t<T>>(0));
+    T new_value(make_value<std::remove_cv_t<T>>(1));
 
-    T copy_x = old_value;
+    T copy_x = const_cast<std::remove_cv_t<T> const&>(old_value);
     std::atomic_ref<T> const x(copy_x);
-    T copy_y = old_value;
+    T copy_y = const_cast<std::remove_cv_t<T> const&>(old_value);
     std::atomic_ref<T> const y(copy_y);
 
     std::atomic_bool x_updated_first(false);
@@ -61,19 +61,19 @@ void test_seq_cst(StoreOp store_op, LoadOp load_op) {
     auto t2 = support::make_test_thread([&] { store_op(y, old_value, new_value); });
 
     auto t3 = support::make_test_thread([&] {
-      while (!equals(load_op(x), new_value)) {
+      while (!equals(load_op(x), const_cast<std::remove_cv_t<T> const&>(new_value))) {
         std::this_thread::yield();
       }
-      if (!equals(load_op(y), new_value)) {
+      if (!equals(load_op(y), const_cast<std::remove_cv_t<T> const&>(new_value))) {
         x_updated_first.store(true, std::memory_order_relaxed);
       }
     });
 
     auto t4 = support::make_test_thread([&] {
-      while (!equals(load_op(y), new_value)) {
+      while (!equals(load_op(y), const_cast<std::remove_cv_t<T> const&>(new_value))) {
         std::this_thread::yield();
       }
-      if (!equals(load_op(x), new_value)) {
+      if (!equals(load_op(x), const_cast<std::remove_cv_t<T> const&>(new_value))) {
         y_updated_first.store(true, std::memory_order_relaxed);
       }
     });
@@ -98,10 +98,10 @@ template <class T, class StoreOp, class LoadOp>
 void test_acquire_release(StoreOp store_op, LoadOp load_op) {
 #ifndef TEST_HAS_NO_THREADS
   for (auto i = 0; i < 100; ++i) {
-    T old_value(make_value<T>(0));
-    T new_value(make_value<T>(1));
+    T old_value(make_value<std::remove_cv_t<T>>(0));
+    T new_value(make_value<std::remove_cv_t<T>>(1));
 
-    T copy = old_value;
+    T copy = const_cast<std::remove_cv_t<T> const&>(old_value);
     std::atomic_ref<T> const at(copy);
     int non_atomic = 5;
 
@@ -110,14 +110,15 @@ void test_acquire_release(StoreOp store_op, LoadOp load_op) {
     threads.reserve(number_of_threads);
 
     for (auto j = 0; j < number_of_threads; ++j) {
-      threads.push_back(support::make_test_thread([&at, &non_atomic, load_op, new_value] {
-        while (!equals(load_op(at), new_value)) {
-          std::this_thread::yield();
-        }
-        // Other thread's writes before the release store are visible
-        // in this thread's read after the acquire load
-        assert(non_atomic == 6);
-      }));
+      threads.push_back(support::make_test_thread(
+          [&at, &non_atomic, load_op, new_value = const_cast<std::remove_cv_t<T> const&>(new_value)] {
+            while (!equals(load_op(at), new_value)) {
+              std::this_thread::yield();
+            }
+            // Other thread's writes before the release store are visible
+            // in this thread's read after the acquire load
+            assert(non_atomic == 6);
+          }));
     }
 
     non_atomic = 6;
diff --git a/libcxx/test/std/atomics/atomics.types.generic/cv_unqualified.verify.cpp b/libcxx/test/std/atomics/atomics.types.generic/cv_unqualified.verify.cpp
new file mode 100644
index 0000000000000..b245b89d4ac11
--- /dev/null
+++ b/libcxx/test/std/atomics/atomics.types.generic/cv_unqualified.verify.cpp
@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// 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;
+
+// This test checks that we static_assert inside std::atomic<T> when T
+// is cv-qualified, however Clang will sometimes emit additional
+// errors while trying to instantiate the rest of std::atomic<T>.
+// We silence those to make the test more robust.
+// ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error -Wno-deprecated-volatile
+
+#include <atomic>
+
+std::atomic<const int> aci;      // expected-error@*:* {{std::atomic<T> requires that 'T' be a cv-unqualified type}}
+std::atomic<volatile float> avf; // expected-error@*:* {{std::atomic<T> requires that 'T' be a cv-unqualified type}}