[libcxx-commits] [libcxx] [libc++] Implement P0493R5: Atomic minimum/maximum (PR #180333)
Connector Switch via libcxx-commits
libcxx-commits at lists.llvm.org
Sun Feb 22 05:15:20 PST 2026
https://github.com/c8ef updated https://github.com/llvm/llvm-project/pull/180333
>From ab79abbd1c14a305de4c16b791bf5e22384d543a Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sat, 7 Feb 2026 17:10:11 +0800
Subject: [PATCH 01/19] implement atomic max/min
---
libcxx/docs/FeatureTestMacroTable.rst | 2 +-
libcxx/docs/ReleaseNotes/23.rst | 1 +
libcxx/docs/Status/Cxx2cPapers.csv | 2 +-
libcxx/include/__atomic/atomic.h | 68 ++++++++++++++++++
libcxx/include/__atomic/atomic_ref.h | 8 +++
libcxx/include/__atomic/support.h | 9 +++
libcxx/include/__atomic/support/c11.h | 26 +++++++
libcxx/include/__atomic/support/gcc.h | 24 +++++++
libcxx/include/atomic | 24 +++++++
libcxx/include/version | 2 +-
libcxx/modules/std/atomic.inc | 4 ++
.../atomics/atomics.ref/fetch_max.pass.cpp | 70 +++++++++++++++++++
.../atomics/atomics.ref/fetch_min.pass.cpp | 70 +++++++++++++++++++
.../atomic_fetch_max.pass.cpp | 55 +++++++++++++++
.../atomic_fetch_max_explicit.pass.cpp | 57 +++++++++++++++
.../atomic_fetch_min.pass.cpp | 55 +++++++++++++++
.../atomic_fetch_min_explicit.pass.cpp | 57 +++++++++++++++
.../atomic.version.compile.pass.cpp | 16 ++---
.../version.version.compile.pass.cpp | 16 ++---
.../generate_feature_test_macro_components.py | 1 -
20 files changed, 541 insertions(+), 26 deletions(-)
create mode 100644 libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
create mode 100644 libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
create mode 100644 libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
create mode 100644 libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
create mode 100644 libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
create mode 100644 libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
diff --git a/libcxx/docs/FeatureTestMacroTable.rst b/libcxx/docs/FeatureTestMacroTable.rst
index d2b76cb96e866..701775e051f9a 100644
--- a/libcxx/docs/FeatureTestMacroTable.rst
+++ b/libcxx/docs/FeatureTestMacroTable.rst
@@ -416,7 +416,7 @@ Status
---------------------------------------------------------- -----------------
``__cpp_lib_associative_heterogeneous_insertion`` *unimplemented*
---------------------------------------------------------- -----------------
- ``__cpp_lib_atomic_min_max`` *unimplemented*
+ ``__cpp_lib_atomic_min_max`` ``202403L``
---------------------------------------------------------- -----------------
``__cpp_lib_atomic_ref`` ``202411L``
---------------------------------------------------------- -----------------
diff --git a/libcxx/docs/ReleaseNotes/23.rst b/libcxx/docs/ReleaseNotes/23.rst
index a1d62a367f33c..ce2eee5ed852a 100644
--- a/libcxx/docs/ReleaseNotes/23.rst
+++ b/libcxx/docs/ReleaseNotes/23.rst
@@ -39,6 +39,7 @@ Implemented Papers
------------------
- P2440R1 (partial): ``ranges::iota`` and ``ranges::shift_left`` are supported (`Github <https://llvm.org/PR105184>`__)
+- P0493R5: Atomic minimum/maximum are supported (`Github <https://llvm.org/PR105418>`__)
Improvements and New Features
-----------------------------
diff --git a/libcxx/docs/Status/Cxx2cPapers.csv b/libcxx/docs/Status/Cxx2cPapers.csv
index 29642fc53cac6..50819f1b47a27 100644
--- a/libcxx/docs/Status/Cxx2cPapers.csv
+++ b/libcxx/docs/Status/Cxx2cPapers.csv
@@ -53,7 +53,7 @@
"`P3107R5 <https://wg21.link/P3107R5>`__","Permit an efficient implementation of ``std::print``","2024-03 (Tokyo)","","","`#105414 <https://github.com/llvm/llvm-project/issues/105414>`__",""
"`P3142R0 <https://wg21.link/P3142R0>`__","Printing Blank Lines with ``println``","2024-03 (Tokyo)","|Complete|","19","`#105415 <https://github.com/llvm/llvm-project/issues/105415>`__","Implemented as a DR against C++23. (MSVC STL and libstdc++ will do the same.)"
"`P2845R8 <https://wg21.link/P2845R8>`__","Formatting of ``std::filesystem::path``","2024-03 (Tokyo)","","","`#105416 <https://github.com/llvm/llvm-project/issues/105416>`__",""
-"`P0493R5 <https://wg21.link/P0493R5>`__","Atomic minimum/maximum","2024-03 (Tokyo)","","","`#105418 <https://github.com/llvm/llvm-project/issues/105418>`__",""
+"`P0493R5 <https://wg21.link/P0493R5>`__","Atomic minimum/maximum","2024-03 (Tokyo)","|Complete|","23","`#105418 <https://github.com/llvm/llvm-project/issues/105418>`__",""
"`P2542R8 <https://wg21.link/P2542R8>`__","``views::concat``","2024-03 (Tokyo)","","","`#105419 <https://github.com/llvm/llvm-project/issues/105419>`__",""
"`P2591R5 <https://wg21.link/P2591R5>`__","Concatenation of strings and string views","2024-03 (Tokyo)","|Complete|","19","`#105420 <https://github.com/llvm/llvm-project/issues/105420>`__",""
"`P2248R8 <https://wg21.link/P2248R8>`__","Enabling list-initialization for algorithms","2024-03 (Tokyo)","","","`#105421 <https://github.com/llvm/llvm-project/issues/105421>`__",""
diff --git a/libcxx/include/__atomic/atomic.h b/libcxx/include/__atomic/atomic.h
index ea1d28fbf850a..f1c7492590d61 100644
--- a/libcxx/include/__atomic/atomic.h
+++ b/libcxx/include/__atomic/atomic.h
@@ -178,6 +178,20 @@ struct __atomic_base<_Tp, true> : public __atomic_base<_Tp, false> {
_LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
return std::__cxx_atomic_fetch_xor(std::addressof(this->__a_), __op, __m);
}
+#if _LIBCPP_STD_VER >= 26
+ _LIBCPP_HIDE_FROM_ABI _Tp fetch_max(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+ return std::__cxx_atomic_fetch_max(std::addressof(this->__a_), __op, __m);
+ }
+ _LIBCPP_HIDE_FROM_ABI _Tp fetch_max(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+ return std::__cxx_atomic_fetch_max(std::addressof(this->__a_), __op, __m);
+ }
+ _LIBCPP_HIDE_FROM_ABI _Tp fetch_min(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+ return std::__cxx_atomic_fetch_min(std::addressof(this->__a_), __op, __m);
+ }
+ _LIBCPP_HIDE_FROM_ABI _Tp fetch_min(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+ return std::__cxx_atomic_fetch_min(std::addressof(this->__a_), __op, __m);
+ }
+#endif
_LIBCPP_HIDE_FROM_ABI _Tp operator++(int) volatile _NOEXCEPT { return fetch_add(_Tp(1)); }
_LIBCPP_HIDE_FROM_ABI _Tp operator++(int) _NOEXCEPT { return fetch_add(_Tp(1)); }
@@ -799,6 +813,60 @@ atomic_fetch_xor_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __o
return __o->fetch_xor(__op, __m);
}
+#if _LIBCPP_STD_VER >= 26
+// atomic_fetch_max
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_max(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
+ return __o->fetch_max(__op);
+}
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_max(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
+ return __o->fetch_max(__op);
+}
+
+// atomic_fetch_max_explicit
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_max_explicit(
+ volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
+ return __o->fetch_max(__op, __m);
+}
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_fetch_max_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
+ return __o->fetch_max(__op, __m);
+}
+
+// atomic_fetch_min
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_min(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
+ return __o->fetch_min(__op);
+}
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_min(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
+ return __o->fetch_min(__op);
+}
+
+// atomic_fetch_min_explicit
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_min_explicit(
+ volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
+ return __o->fetch_min(__op, __m);
+}
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_fetch_min_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
+ return __o->fetch_min(__op, __m);
+}
+#endif
+
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ATOMIC_ATOMIC_H
diff --git a/libcxx/include/__atomic/atomic_ref.h b/libcxx/include/__atomic/atomic_ref.h
index 69edbfe6ecadd..cedd4248eb200 100644
--- a/libcxx/include/__atomic/atomic_ref.h
+++ b/libcxx/include/__atomic/atomic_ref.h
@@ -299,6 +299,14 @@ struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
_LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
return __atomic_fetch_xor(this->__ptr_, __arg, std::__to_gcc_order(__order));
}
+# if _LIBCPP_STD_VER >= 26
+ _LIBCPP_HIDE_FROM_ABI _Tp fetch_max(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+ return __atomic_fetch_max(this->__ptr_, __arg, std::__to_gcc_order(__order));
+ }
+ _LIBCPP_HIDE_FROM_ABI _Tp fetch_min(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+ return __atomic_fetch_min(this->__ptr_, __arg, std::__to_gcc_order(__order));
+ }
+# endif
_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)); }
diff --git a/libcxx/include/__atomic/support.h b/libcxx/include/__atomic/support.h
index 99d0f6aa543ca..eda38705acd32 100644
--- a/libcxx/include/__atomic/support.h
+++ b/libcxx/include/__atomic/support.h
@@ -99,6 +99,15 @@
// template <class _Tp>
// _Tp __cxx_atomic_fetch_xor(_Atmc<_Tp>* __a, _Tp __pattern, memory_order __order) noexcept;
//
+// template <class _Tp>
+// _Tp __cxx_atomic_fetch_max(_Atmc<_Tp> volatile* __a, _Tp __pattern, memory_order __order) noexcept;
+// template <class _Tp>
+// _Tp __cxx_atomic_fetch_max(_Atmc<_Tp>* __a, _Tp __pattern, memory_order __order) noexcept;
+// template <class _Tp>
+// _Tp __cxx_atomic_fetch_min(_Atmc<_Tp> volatile* __a, _Tp __pattern, memory_order __order) noexcept;
+// template <class _Tp>
+// _Tp __cxx_atomic_fetch_min(_Atmc<_Tp>* __a, _Tp __pattern, memory_order __order) noexcept;
+//
// clang-format on
//
diff --git a/libcxx/include/__atomic/support/c11.h b/libcxx/include/__atomic/support/c11.h
index 1ad299882a12a..f28b5e461c18a 100644
--- a/libcxx/include/__atomic/support/c11.h
+++ b/libcxx/include/__atomic/support/c11.h
@@ -259,6 +259,32 @@ __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
}
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+ return __c11_atomic_fetch_max(
+ std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
+}
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+ return __c11_atomic_fetch_max(
+ std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+ return __c11_atomic_fetch_min(
+ std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
+}
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+ return __c11_atomic_fetch_min(
+ std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
+}
+
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ATOMIC_SUPPORT_C11_H
diff --git a/libcxx/include/__atomic/support/gcc.h b/libcxx/include/__atomic/support/gcc.h
index 73c1b1c8070a4..dfaebb68ced74 100644
--- a/libcxx/include/__atomic/support/gcc.h
+++ b/libcxx/include/__atomic/support/gcc.h
@@ -258,6 +258,30 @@ __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
return __atomic_fetch_xor(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
}
+template <typename _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_max(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+ return __atomic_fetch_max(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+}
+
+template <typename _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+ return __atomic_fetch_max(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+}
+
+template <typename _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_min(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+ return __atomic_fetch_min(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+}
+
+template <typename _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+ return __atomic_fetch_min(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+}
+
#define __cxx_atomic_is_lock_free(__s) __atomic_is_lock_free(__s, 0)
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/atomic b/libcxx/include/atomic
index 23a3db5d35029..4cf93b6bfbd85 100644
--- a/libcxx/include/atomic
+++ b/libcxx/include/atomic
@@ -164,6 +164,10 @@ struct atomic<integral>
integral fetch_or(integral op, memory_order m = memory_order_seq_cst) noexcept;
integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) noexcept;
+ integral fetch_max(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
+ integral fetch_max(integral op, memory_order m = memory_order_seq_cst) noexcept;
+ integral fetch_min(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
+ integral fetch_min(integral op, memory_order m = memory_order_seq_cst) noexcept;
integral operator++(int) volatile noexcept;
integral operator++(int) noexcept;
@@ -441,6 +445,26 @@ template<class T>
template<class T>
T atomic_fetch_xor_explicit(atomic<T>*, atomic<T>::value_type,
memory_order) noexcept;
+template<class T>
+ T atomic_fetch_max(volatile atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+ T atomic_fetch_max(atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+ T atomic_fetch_max_explicit(volatile atomic<T>*, atomic<T>::value_type,
+ memory_order) noexcept;
+template<class T>
+ T atomic_fetch_max_explicit(atomic<T>*, atomic<T>::value_type,
+ memory_order) noexcept;
+template<class T>
+ T atomic_fetch_min(volatile atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+ T atomic_fetch_min(atomic<T>*, atomic<T>::value_type) noexcept;
+template<class T>
+ T atomic_fetch_min_explicit(volatile atomic<T>*, atomic<T>::value_type,
+ memory_order) noexcept;
+template<class T>
+ T atomic_fetch_min_explicit(atomic<T>*, atomic<T>::value_type,
+ memory_order) noexcept;
template<class T>
void atomic_wait(const volatile atomic<T>*, atomic<T>::value_type) noexcept; // since C++20
diff --git a/libcxx/include/version b/libcxx/include/version
index 7d77677a012ce..a00e9441202bd 100644
--- a/libcxx/include/version
+++ b/libcxx/include/version
@@ -546,7 +546,7 @@ __cpp_lib_void_t 201411L <type_traits>
#if _LIBCPP_STD_VER >= 26
# define __cpp_lib_aligned_accessor 202411L
// # define __cpp_lib_associative_heterogeneous_insertion 202306L
-// # define __cpp_lib_atomic_min_max 202403L
+# define __cpp_lib_atomic_min_max 202403L
# undef __cpp_lib_atomic_ref
# define __cpp_lib_atomic_ref 202411L
# undef __cpp_lib_bind_front
diff --git a/libcxx/modules/std/atomic.inc b/libcxx/modules/std/atomic.inc
index 9a30fb7affe71..11f77991068c1 100644
--- a/libcxx/modules/std/atomic.inc
+++ b/libcxx/modules/std/atomic.inc
@@ -50,6 +50,10 @@ export namespace std {
using std::atomic_fetch_sub_explicit _LIBCPP_USING_IF_EXISTS;
using std::atomic_fetch_xor _LIBCPP_USING_IF_EXISTS;
using std::atomic_fetch_xor_explicit _LIBCPP_USING_IF_EXISTS;
+ using std::atomic_fetch_max _LIBCPP_USING_IF_EXISTS;
+ using std::atomic_fetch_max_explicit _LIBCPP_USING_IF_EXISTS;
+ using std::atomic_fetch_min _LIBCPP_USING_IF_EXISTS;
+ using std::atomic_fetch_min_explicit _LIBCPP_USING_IF_EXISTS;
using std::atomic_notify_all _LIBCPP_USING_IF_EXISTS;
using std::atomic_notify_one _LIBCPP_USING_IF_EXISTS;
using std::atomic_wait _LIBCPP_USING_IF_EXISTS;
diff --git a/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
new file mode 100644
index 0000000000000..6c1b69dce1595
--- /dev/null
+++ b/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++26
+// XFAIL: !has-64-bit-atomics
+
+// integral-type fetch_max(integral-type, memory_order = memory_order::seq_cst) const noexcept;
+
+#include <atomic>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+#include "atomic_helpers.h"
+#include "test_macros.h"
+
+template <typename T>
+concept has_fetch_max = requires {
+ std::declval<T const>().fetch_max(std::declval<T>());
+ std::declval<T const>().fetch_max(std::declval<T>(), std::declval<std::memory_order>());
+};
+
+template <typename T>
+struct TestDoesNotHaveFetchMax {
+ void operator()() const { static_assert(!has_fetch_max<std::atomic_ref<T>>); }
+};
+
+template <typename T>
+struct TestFetchMax {
+ void operator()() const {
+ static_assert(std::is_integral_v<T>);
+
+ alignas(std::atomic_ref<T>::required_alignment) T x(T(1));
+ std::atomic_ref<T> const a(x);
+
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_max(T(2));
+ assert(y == T(1));
+ assert(x == T(2));
+ ASSERT_NOEXCEPT(a.fetch_max(T(0)));
+ }
+
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_max(T(1), std::memory_order_relaxed);
+ assert(y == T(2));
+ assert(x == T(2));
+ ASSERT_NOEXCEPT(a.fetch_max(T(0), std::memory_order_relaxed));
+ }
+ }
+};
+
+int main(int, char**) {
+ TestEachIntegralType<TestFetchMax>()();
+
+ TestEachFloatingPointType<TestDoesNotHaveFetchMax>()();
+
+ TestEachPointerType<TestDoesNotHaveFetchMax>()();
+
+ TestDoesNotHaveFetchMax<bool>()();
+ TestDoesNotHaveFetchMax<UserAtomicType>()();
+ TestDoesNotHaveFetchMax<LargeUserAtomicType>()();
+
+ return 0;
+}
diff --git a/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
new file mode 100644
index 0000000000000..1fa2d32c4d7d8
--- /dev/null
+++ b/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++26
+// XFAIL: !has-64-bit-atomics
+
+// integral-type fetch_min(integral-type, memory_order = memory_order::seq_cst) const noexcept;
+
+#include <atomic>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+#include "atomic_helpers.h"
+#include "test_macros.h"
+
+template <typename T>
+concept has_fetch_min = requires {
+ std::declval<T const>().fetch_min(std::declval<T>());
+ std::declval<T const>().fetch_min(std::declval<T>(), std::declval<std::memory_order>());
+};
+
+template <typename T>
+struct TestDoesNotHaveFetchMin {
+ void operator()() const { static_assert(!has_fetch_min<std::atomic_ref<T>>); }
+};
+
+template <typename T>
+struct TestFetchMin {
+ void operator()() const {
+ static_assert(std::is_integral_v<T>);
+
+ alignas(std::atomic_ref<T>::required_alignment) T x(T(3));
+ std::atomic_ref<T> const a(x);
+
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_min(T(2));
+ assert(y == T(3));
+ assert(x == T(2));
+ ASSERT_NOEXCEPT(a.fetch_min(T(0)));
+ }
+
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_min(T(1), std::memory_order_relaxed);
+ assert(y == T(2));
+ assert(x == T(1));
+ ASSERT_NOEXCEPT(a.fetch_min(T(0), std::memory_order_relaxed));
+ }
+ }
+};
+
+int main(int, char**) {
+ TestEachIntegralType<TestFetchMin>()();
+
+ TestEachFloatingPointType<TestDoesNotHaveFetchMin>()();
+
+ TestEachPointerType<TestDoesNotHaveFetchMin>()();
+
+ TestDoesNotHaveFetchMin<bool>()();
+ TestDoesNotHaveFetchMin<UserAtomicType>()();
+ TestDoesNotHaveFetchMin<LargeUserAtomicType>()();
+
+ return 0;
+}
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
new file mode 100644
index 0000000000000..25411767ca8ad
--- /dev/null
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++26
+// XFAIL: !has-64-bit-atomics
+
+// <atomic>
+
+// template<class T>
+// T
+// atomic_fetch_max(volatile atomic<T>*, atomic<T>::value_type) noexcept;
+//
+// template<class T>
+// T
+// atomic_fetch_max(atomic<T>*, atomic<T>::value_type) noexcept;
+
+#include <atomic>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "atomic_helpers.h"
+
+template <class T>
+struct TestFn {
+ void operator()() const {
+ {
+ typedef std::atomic<T> A;
+ A t(T(1));
+ assert(std::atomic_fetch_max(&t, T(2)) == T(1));
+ assert(t == T(2));
+
+ ASSERT_NOEXCEPT(std::atomic_fetch_max(&t, T(2)));
+ }
+ {
+ typedef std::atomic<T> A;
+ volatile A t(T(3));
+ assert(std::atomic_fetch_max(&t, T(2)) == T(3));
+ assert(t == T(3));
+
+ ASSERT_NOEXCEPT(std::atomic_fetch_max(&t, T(2)));
+ }
+ }
+};
+
+int main(int, char**) {
+ TestEachIntegralType<TestFn>()();
+
+ return 0;
+}
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
new file mode 100644
index 0000000000000..a670f1c10ce60
--- /dev/null
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++26
+// XFAIL: !has-64-bit-atomics
+
+// <atomic>
+
+// template<class T>
+// T
+// atomic_fetch_max_explicit(volatile atomic<T>*, atomic<T>::value_type,
+// memory_order) noexcept;
+//
+// template<class T>
+// T
+// atomic_fetch_max_explicit(atomic<T>*, atomic<T>::value_type,
+// memory_order) noexcept;
+
+#include <atomic>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "atomic_helpers.h"
+
+template <class T>
+struct TestFn {
+ void operator()() const {
+ {
+ typedef std::atomic<T> A;
+ A t(T(1));
+ assert(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst) == T(1));
+ assert(t == T(2));
+
+ ASSERT_NOEXCEPT(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst));
+ }
+ {
+ typedef std::atomic<T> A;
+ volatile A t(T(3));
+ assert(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst) == T(3));
+ assert(t == T(3));
+
+ ASSERT_NOEXCEPT(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst));
+ }
+ }
+};
+
+int main(int, char**) {
+ TestEachIntegralType<TestFn>()();
+
+ return 0;
+}
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
new file mode 100644
index 0000000000000..242355120c28d
--- /dev/null
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++26
+// XFAIL: !has-64-bit-atomics
+
+// <atomic>
+
+// template<class T>
+// T
+// atomic_fetch_min(volatile atomic<T>*, atomic<T>::value_type) noexcept;
+//
+// template<class T>
+// T
+// atomic_fetch_min(atomic<T>*, atomic<T>::value_type) noexcept;
+
+#include <atomic>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "atomic_helpers.h"
+
+template <class T>
+struct TestFn {
+ void operator()() const {
+ {
+ typedef std::atomic<T> A;
+ A t(T(1));
+ assert(std::atomic_fetch_min(&t, T(2)) == T(1));
+ assert(t == T(1));
+
+ ASSERT_NOEXCEPT(std::atomic_fetch_min(&t, T(2)));
+ }
+ {
+ typedef std::atomic<T> A;
+ volatile A t(T(3));
+ assert(std::atomic_fetch_min(&t, T(2)) == T(3));
+ assert(t == T(2));
+
+ ASSERT_NOEXCEPT(std::atomic_fetch_min(&t, T(2)));
+ }
+ }
+};
+
+int main(int, char**) {
+ TestEachIntegralType<TestFn>()();
+
+ return 0;
+}
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
new file mode 100644
index 0000000000000..46b7531b1f727
--- /dev/null
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++26
+// XFAIL: !has-64-bit-atomics
+
+// <atomic>
+
+// template<class T>
+// T
+// atomic_fetch_min_explicit(volatile atomic<T>*, atomic<T>::value_type,
+// memory_order) noexcept;
+//
+// template<class T>
+// T
+// atomic_fetch_min_explicit(atomic<T>*, atomic<T>::value_type,
+// memory_order) noexcept;
+
+#include <atomic>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "atomic_helpers.h"
+
+template <class T>
+struct TestFn {
+ void operator()() const {
+ {
+ typedef std::atomic<T> A;
+ A t(T(1));
+ assert(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst) == T(1));
+ assert(t == T(1));
+
+ ASSERT_NOEXCEPT(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst));
+ }
+ {
+ typedef std::atomic<T> A;
+ volatile A t(T(3));
+ assert(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst) == T(3));
+ assert(t == T(2));
+
+ ASSERT_NOEXCEPT(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst));
+ }
+ }
+};
+
+int main(int, char**) {
+ TestEachIntegralType<TestFn>()();
+
+ return 0;
+}
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/atomic.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/atomic.version.compile.pass.cpp
index 8bd027445c85b..9e620317c35c8 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/atomic.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/atomic.version.compile.pass.cpp
@@ -339,17 +339,11 @@
# error "__cpp_lib_atomic_lock_free_type_aliases should have the value 201907L in c++26"
# endif
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_atomic_min_max
-# error "__cpp_lib_atomic_min_max should be defined in c++26"
-# endif
-# if __cpp_lib_atomic_min_max != 202403L
-# error "__cpp_lib_atomic_min_max should have the value 202403L in c++26"
-# endif
-# else
-# ifdef __cpp_lib_atomic_min_max
-# error "__cpp_lib_atomic_min_max should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_atomic_min_max
+# error "__cpp_lib_atomic_min_max should be defined in c++26"
+# endif
+# if __cpp_lib_atomic_min_max != 202403L
+# error "__cpp_lib_atomic_min_max should have the value 202403L in c++26"
# endif
# ifndef __cpp_lib_atomic_ref
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
index f442b22c6d752..33f402b6422f6 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
@@ -6325,17 +6325,11 @@
# error "__cpp_lib_atomic_lock_free_type_aliases should have the value 201907L in c++26"
# endif
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_atomic_min_max
-# error "__cpp_lib_atomic_min_max should be defined in c++26"
-# endif
-# if __cpp_lib_atomic_min_max != 202403L
-# error "__cpp_lib_atomic_min_max should have the value 202403L in c++26"
-# endif
-# else
-# ifdef __cpp_lib_atomic_min_max
-# error "__cpp_lib_atomic_min_max should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_atomic_min_max
+# error "__cpp_lib_atomic_min_max should be defined in c++26"
+# endif
+# if __cpp_lib_atomic_min_max != 202403L
+# error "__cpp_lib_atomic_min_max should have the value 202403L in c++26"
# endif
# ifndef __cpp_lib_atomic_ref
diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py
index 88431c76a00f5..799bb088f061e 100644
--- a/libcxx/utils/generate_feature_test_macro_components.py
+++ b/libcxx/utils/generate_feature_test_macro_components.py
@@ -191,7 +191,6 @@ def add_version_header(tc):
"name": "__cpp_lib_atomic_min_max",
"values": {"c++26": 202403}, # P0493R5: Atomic minimum/maximum
"headers": ["atomic"],
- "unimplemented": True,
},
{
"name": "__cpp_lib_atomic_ref",
>From fb39fd535b1714f6d422d9b0f1810102a763a1b3 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sat, 7 Feb 2026 19:20:50 +0800
Subject: [PATCH 02/19] fix gcc build
---
libcxx/include/__atomic/support/gcc.h | 28 +++++++++++++++++++++++----
1 file changed, 24 insertions(+), 4 deletions(-)
diff --git a/libcxx/include/__atomic/support/gcc.h b/libcxx/include/__atomic/support/gcc.h
index dfaebb68ced74..e50143bb2bfa9 100644
--- a/libcxx/include/__atomic/support/gcc.h
+++ b/libcxx/include/__atomic/support/gcc.h
@@ -261,25 +261,45 @@ __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_max(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
- return __atomic_fetch_max(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+ _Tp __ret = __cxx_atomic_load(__a, __order);
+ _Tp __value;
+ do {
+ __value = __ret > __pattern ? __ret : __pattern;
+ } while (__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
+ return __ret;
}
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
- return __atomic_fetch_max(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+ _Tp __ret = __cxx_atomic_load(__a, __order);
+ _Tp __value;
+ do {
+ __value = __ret > __pattern ? __ret : __pattern;
+ } while (__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
+ return __ret;
}
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_min(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
- return __atomic_fetch_min(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+ _Tp __ret = __cxx_atomic_load(__a, __order);
+ _Tp __value;
+ do {
+ __value = __ret < __pattern ? __ret : __pattern;
+ } while (__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
+ return __ret;
}
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
- return __atomic_fetch_min(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+ _Tp __ret = __cxx_atomic_load(__a, __order);
+ _Tp __value;
+ do {
+ __value = __ret < __pattern ? __ret : __pattern;
+ } while (__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
+ return __ret;
}
#define __cxx_atomic_is_lock_free(__s) __atomic_is_lock_free(__s, 0)
>From 906a95e15e4bdd1136be7bfc1f14731e6a3a3135 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sat, 7 Feb 2026 19:36:17 +0800
Subject: [PATCH 03/19] fix gcc atomic_ref
---
libcxx/include/__atomic/atomic_ref.h | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/libcxx/include/__atomic/atomic_ref.h b/libcxx/include/__atomic/atomic_ref.h
index cedd4248eb200..6ea270dc3b902 100644
--- a/libcxx/include/__atomic/atomic_ref.h
+++ b/libcxx/include/__atomic/atomic_ref.h
@@ -23,6 +23,7 @@
#include <__atomic/check_memory_order.h>
#include <__atomic/floating_point_helper.h>
#include <__atomic/memory_order.h>
+#include <__atomic/support.h>
#include <__atomic/to_gcc_order.h>
#include <__concepts/arithmetic.h>
#include <__concepts/same_as.h>
@@ -301,10 +302,10 @@ struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
}
# if _LIBCPP_STD_VER >= 26
_LIBCPP_HIDE_FROM_ABI _Tp fetch_max(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
- return __atomic_fetch_max(this->__ptr_, __arg, std::__to_gcc_order(__order));
+ return std::__cxx_atomic_fetch_max(this->__ptr_, __arg, __m);
}
_LIBCPP_HIDE_FROM_ABI _Tp fetch_min(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
- return __atomic_fetch_min(this->__ptr_, __arg, std::__to_gcc_order(__order));
+ return std::__cxx_atomic_fetch_min(this->__ptr_, __arg, __m);
}
# endif
>From a64208d9c117ccbd5a4cc5677a662b6e4f972f59 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sat, 7 Feb 2026 19:55:43 +0800
Subject: [PATCH 04/19] fix gcc
---
libcxx/include/__atomic/atomic_ref.h | 14 ++++++++++++--
libcxx/include/__atomic/support/gcc.h | 8 ++++----
2 files changed, 16 insertions(+), 6 deletions(-)
diff --git a/libcxx/include/__atomic/atomic_ref.h b/libcxx/include/__atomic/atomic_ref.h
index 6ea270dc3b902..11d74f71e6de1 100644
--- a/libcxx/include/__atomic/atomic_ref.h
+++ b/libcxx/include/__atomic/atomic_ref.h
@@ -302,10 +302,20 @@ struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
}
# if _LIBCPP_STD_VER >= 26
_LIBCPP_HIDE_FROM_ABI _Tp fetch_max(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
- return std::__cxx_atomic_fetch_max(this->__ptr_, __arg, __m);
+ _Tp __old = this->load(memory_order_relaxed);
+ _Tp __new;
+ do {
+ __new = __old > __arg ? __old : __arg;
+ } while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed));
+ return __old;
}
_LIBCPP_HIDE_FROM_ABI _Tp fetch_min(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
- return std::__cxx_atomic_fetch_min(this->__ptr_, __arg, __m);
+ _Tp __old = this->load(memory_order_relaxed);
+ _Tp __new;
+ do {
+ __new = __old < __arg ? __old : __arg;
+ } while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed));
+ return __old;
}
# endif
diff --git a/libcxx/include/__atomic/support/gcc.h b/libcxx/include/__atomic/support/gcc.h
index e50143bb2bfa9..c224bb6c95391 100644
--- a/libcxx/include/__atomic/support/gcc.h
+++ b/libcxx/include/__atomic/support/gcc.h
@@ -261,7 +261,7 @@ __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_max(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
- _Tp __ret = __cxx_atomic_load(__a, __order);
+ _Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
__value = __ret > __pattern ? __ret : __pattern;
@@ -272,7 +272,7 @@ __cxx_atomic_fetch_max(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern,
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
- _Tp __ret = __cxx_atomic_load(__a, __order);
+ _Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
__value = __ret > __pattern ? __ret : __pattern;
@@ -283,7 +283,7 @@ __cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_min(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
- _Tp __ret = __cxx_atomic_load(__a, __order);
+ _Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
__value = __ret < __pattern ? __ret : __pattern;
@@ -294,7 +294,7 @@ __cxx_atomic_fetch_min(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern,
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
- _Tp __ret = __cxx_atomic_load(__a, __order);
+ _Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
__value = __ret < __pattern ? __ret : __pattern;
>From 5eeeeea250032dd5ae65ec4a1868158cefe3c650 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sat, 7 Feb 2026 20:12:55 +0800
Subject: [PATCH 05/19] fix gcc
---
libcxx/include/__atomic/support/gcc.h | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/libcxx/include/__atomic/support/gcc.h b/libcxx/include/__atomic/support/gcc.h
index c224bb6c95391..3eaccf95e19d8 100644
--- a/libcxx/include/__atomic/support/gcc.h
+++ b/libcxx/include/__atomic/support/gcc.h
@@ -265,7 +265,7 @@ __cxx_atomic_fetch_max(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern,
_Tp __value;
do {
__value = __ret > __pattern ? __ret : __pattern;
- } while (__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
+ } while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
}
@@ -276,7 +276,7 @@ __cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
_Tp __value;
do {
__value = __ret > __pattern ? __ret : __pattern;
- } while (__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
+ } while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
}
@@ -287,7 +287,7 @@ __cxx_atomic_fetch_min(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern,
_Tp __value;
do {
__value = __ret < __pattern ? __ret : __pattern;
- } while (__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
+ } while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
}
@@ -298,7 +298,7 @@ __cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
_Tp __value;
do {
__value = __ret < __pattern ? __ret : __pattern;
- } while (__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
+ } while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
}
>From 46257efd512cc8bd741cc9dd3157b59ab1ce1ca1 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sat, 7 Feb 2026 20:39:31 +0800
Subject: [PATCH 06/19] remove unused include
---
libcxx/include/__atomic/atomic_ref.h | 1 -
1 file changed, 1 deletion(-)
diff --git a/libcxx/include/__atomic/atomic_ref.h b/libcxx/include/__atomic/atomic_ref.h
index 11d74f71e6de1..84b9bf211b4b9 100644
--- a/libcxx/include/__atomic/atomic_ref.h
+++ b/libcxx/include/__atomic/atomic_ref.h
@@ -23,7 +23,6 @@
#include <__atomic/check_memory_order.h>
#include <__atomic/floating_point_helper.h>
#include <__atomic/memory_order.h>
-#include <__atomic/support.h>
#include <__atomic/to_gcc_order.h>
#include <__concepts/arithmetic.h>
#include <__concepts/same_as.h>
>From dc1cb331ddcb980cce4a8deeef8d1c21b08b0eb7 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sat, 7 Feb 2026 21:29:39 +0800
Subject: [PATCH 07/19] guard modules
---
libcxx/modules/std/atomic.inc | 2 ++
1 file changed, 2 insertions(+)
diff --git a/libcxx/modules/std/atomic.inc b/libcxx/modules/std/atomic.inc
index 11f77991068c1..38321e1a1bb64 100644
--- a/libcxx/modules/std/atomic.inc
+++ b/libcxx/modules/std/atomic.inc
@@ -50,10 +50,12 @@ export namespace std {
using std::atomic_fetch_sub_explicit _LIBCPP_USING_IF_EXISTS;
using std::atomic_fetch_xor _LIBCPP_USING_IF_EXISTS;
using std::atomic_fetch_xor_explicit _LIBCPP_USING_IF_EXISTS;
+#if _LIBCPP_STD_VER >= 26
using std::atomic_fetch_max _LIBCPP_USING_IF_EXISTS;
using std::atomic_fetch_max_explicit _LIBCPP_USING_IF_EXISTS;
using std::atomic_fetch_min _LIBCPP_USING_IF_EXISTS;
using std::atomic_fetch_min_explicit _LIBCPP_USING_IF_EXISTS;
+#endif
using std::atomic_notify_all _LIBCPP_USING_IF_EXISTS;
using std::atomic_notify_one _LIBCPP_USING_IF_EXISTS;
using std::atomic_wait _LIBCPP_USING_IF_EXISTS;
>From dfce3c7d45c1dca9e1ac85b293321ef19e007b23 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sun, 8 Feb 2026 19:37:33 +0800
Subject: [PATCH 08/19] address review comments: use builtin if possible
---
libcxx/include/__atomic/atomic_ref.h | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/libcxx/include/__atomic/atomic_ref.h b/libcxx/include/__atomic/atomic_ref.h
index 84b9bf211b4b9..88c7d7dbc5dfb 100644
--- a/libcxx/include/__atomic/atomic_ref.h
+++ b/libcxx/include/__atomic/atomic_ref.h
@@ -301,20 +301,28 @@ struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
}
# if _LIBCPP_STD_VER >= 26
_LIBCPP_HIDE_FROM_ABI _Tp fetch_max(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+# if __has_builtin(__atomic_fetch_max)
+ return __atomic_fetch_max(this->__ptr_, __arg, std::__to_gcc_order(__order));
+# else
_Tp __old = this->load(memory_order_relaxed);
_Tp __new;
do {
__new = __old > __arg ? __old : __arg;
} while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed));
return __old;
+# endif
}
_LIBCPP_HIDE_FROM_ABI _Tp fetch_min(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+# if __has_builtin(__atomic_fetch_min)
+ return __atomic_fetch_min(this->__ptr_, __arg, std::__to_gcc_order(__order));
+# else
_Tp __old = this->load(memory_order_relaxed);
_Tp __new;
do {
__new = __old < __arg ? __old : __arg;
} while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed));
return __old;
+# endif
}
# endif
>From a3cabfda1b316f2514df394232a4e504f38159eb Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sun, 8 Feb 2026 23:12:48 +0800
Subject: [PATCH 09/19] address review comments: use builtin if possible
---
libcxx/include/__atomic/support/gcc.h | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/libcxx/include/__atomic/support/gcc.h b/libcxx/include/__atomic/support/gcc.h
index 3eaccf95e19d8..754c60406cbf6 100644
--- a/libcxx/include/__atomic/support/gcc.h
+++ b/libcxx/include/__atomic/support/gcc.h
@@ -261,45 +261,61 @@ __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_max(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+#if __has_builtin(__atomic_fetch_max)
+ return __atomic_fetch_max(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+#else
_Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
__value = __ret > __pattern ? __ret : __pattern;
} while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
+#endif
}
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+#if __has_builtin(__atomic_fetch_max)
+ return __atomic_fetch_max(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+#else
_Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
__value = __ret > __pattern ? __ret : __pattern;
} while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
+#endif
}
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_min(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+#if __has_builtin(__atomic_fetch_min)
+ return __atomic_fetch_min(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+#else
_Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
__value = __ret < __pattern ? __ret : __pattern;
} while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
+#endif
}
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+#if __has_builtin(__atomic_fetch_min)
+ return __atomic_fetch_min(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+#else
_Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
__value = __ret < __pattern ? __ret : __pattern;
} while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
+#endif
}
#define __cxx_atomic_is_lock_free(__s) __atomic_is_lock_free(__s, 0)
>From f01144d60576864032d1204a7662ddcb9540059a Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Mon, 9 Feb 2026 20:33:05 +0800
Subject: [PATCH 10/19] codestyle
---
libcxx/include/__atomic/atomic.h | 24 ++++++++++++-------
.../atomic_fetch_max.pass.cpp | 13 ++++------
.../atomic_fetch_max_explicit.pass.cpp | 15 ++++--------
.../atomic_fetch_min.pass.cpp | 13 ++++------
.../atomic_fetch_min_explicit.pass.cpp | 15 ++++--------
5 files changed, 34 insertions(+), 46 deletions(-)
diff --git a/libcxx/include/__atomic/atomic.h b/libcxx/include/__atomic/atomic.h
index f1c7492590d61..e4be21cfd2d84 100644
--- a/libcxx/include/__atomic/atomic.h
+++ b/libcxx/include/__atomic/atomic.h
@@ -816,25 +816,29 @@ atomic_fetch_xor_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __o
#if _LIBCPP_STD_VER >= 26
// atomic_fetch_max
-template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+template <class _Tp>
+ requires(integral<_Tp> && !same_as<_Tp, bool>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_max(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
return __o->fetch_max(__op);
}
-template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+template <class _Tp>
+ requires(integral<_Tp> && !same_as<_Tp, bool>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_max(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
return __o->fetch_max(__op);
}
// atomic_fetch_max_explicit
-template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+template <class _Tp>
+ requires(integral<_Tp> && !same_as<_Tp, bool>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_max_explicit(
volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
return __o->fetch_max(__op, __m);
}
-template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+template <class _Tp>
+ requires(integral<_Tp> && !same_as<_Tp, bool>)
_LIBCPP_HIDE_FROM_ABI _Tp
atomic_fetch_max_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
return __o->fetch_max(__op, __m);
@@ -842,25 +846,29 @@ atomic_fetch_max_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __o
// atomic_fetch_min
-template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+template <class _Tp>
+ requires(integral<_Tp> && !same_as<_Tp, bool>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_min(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
return __o->fetch_min(__op);
}
-template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+template <class _Tp>
+ requires(integral<_Tp> && !same_as<_Tp, bool>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_min(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
return __o->fetch_min(__op);
}
// atomic_fetch_min_explicit
-template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+template <class _Tp>
+ requires(integral<_Tp> && !same_as<_Tp, bool>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_min_explicit(
volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
return __o->fetch_min(__op, __m);
}
-template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+template <class _Tp>
+ requires(integral<_Tp> && !same_as<_Tp, bool>)
_LIBCPP_HIDE_FROM_ABI _Tp
atomic_fetch_min_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
return __o->fetch_min(__op, __m);
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
index 25411767ca8ad..8aa66f68a23d7 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
@@ -12,12 +12,9 @@
// <atomic>
// template<class T>
-// T
-// atomic_fetch_max(volatile atomic<T>*, atomic<T>::value_type) noexcept;
-//
+// T atomic_fetch_max(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
// template<class T>
-// T
-// atomic_fetch_max(atomic<T>*, atomic<T>::value_type) noexcept;
+// constexpr T atomic_fetch_max(atomic<T>*, typename atomic<T>::value_type) noexcept;
#include <atomic>
#include <type_traits>
@@ -30,16 +27,14 @@ template <class T>
struct TestFn {
void operator()() const {
{
- typedef std::atomic<T> A;
- A t(T(1));
+ std::atomic<T> t(T(1));
assert(std::atomic_fetch_max(&t, T(2)) == T(1));
assert(t == T(2));
ASSERT_NOEXCEPT(std::atomic_fetch_max(&t, T(2)));
}
{
- typedef std::atomic<T> A;
- volatile A t(T(3));
+ volatile std::atomic<T> t(T(3));
assert(std::atomic_fetch_max(&t, T(2)) == T(3));
assert(t == T(3));
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
index a670f1c10ce60..1d04bb737fe1f 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
@@ -12,14 +12,11 @@
// <atomic>
// template<class T>
-// T
-// atomic_fetch_max_explicit(volatile atomic<T>*, atomic<T>::value_type,
+// T atomic_fetch_max_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
// memory_order) noexcept;
-//
// template<class T>
-// T
-// atomic_fetch_max_explicit(atomic<T>*, atomic<T>::value_type,
-// memory_order) noexcept;
+// constexpr T atomic_fetch_max_explicit(atomic<T>*, typename atomic<T>::value_type,
+// memory_order) noexcept;
#include <atomic>
#include <type_traits>
@@ -32,16 +29,14 @@ template <class T>
struct TestFn {
void operator()() const {
{
- typedef std::atomic<T> A;
- A t(T(1));
+ std::atomic<T> t(T(1));
assert(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst) == T(1));
assert(t == T(2));
ASSERT_NOEXCEPT(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst));
}
{
- typedef std::atomic<T> A;
- volatile A t(T(3));
+ volatile std::atomic<T> t(T(3));
assert(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst) == T(3));
assert(t == T(3));
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
index 242355120c28d..43b979144b19b 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
@@ -12,12 +12,9 @@
// <atomic>
// template<class T>
-// T
-// atomic_fetch_min(volatile atomic<T>*, atomic<T>::value_type) noexcept;
-//
+// T atomic_fetch_min(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
// template<class T>
-// T
-// atomic_fetch_min(atomic<T>*, atomic<T>::value_type) noexcept;
+// constexpr T atomic_fetch_min(atomic<T>*, typename atomic<T>::value_type) noexcept;
#include <atomic>
#include <type_traits>
@@ -30,16 +27,14 @@ template <class T>
struct TestFn {
void operator()() const {
{
- typedef std::atomic<T> A;
- A t(T(1));
+ std::atomic<T> t(T(1));
assert(std::atomic_fetch_min(&t, T(2)) == T(1));
assert(t == T(1));
ASSERT_NOEXCEPT(std::atomic_fetch_min(&t, T(2)));
}
{
- typedef std::atomic<T> A;
- volatile A t(T(3));
+ volatile std::atomic<T> t(T(3));
assert(std::atomic_fetch_min(&t, T(2)) == T(3));
assert(t == T(2));
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
index 46b7531b1f727..309489f91f126 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
@@ -12,14 +12,11 @@
// <atomic>
// template<class T>
-// T
-// atomic_fetch_min_explicit(volatile atomic<T>*, atomic<T>::value_type,
+// T atomic_fetch_min_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
// memory_order) noexcept;
-//
// template<class T>
-// T
-// atomic_fetch_min_explicit(atomic<T>*, atomic<T>::value_type,
-// memory_order) noexcept;
+// constexpr T atomic_fetch_min_explicit(atomic<T>*, typename atomic<T>::value_type,
+// memory_order) noexcept;
#include <atomic>
#include <type_traits>
@@ -32,16 +29,14 @@ template <class T>
struct TestFn {
void operator()() const {
{
- typedef std::atomic<T> A;
- A t(T(1));
+ std::atomic<T> t(T(1));
assert(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst) == T(1));
assert(t == T(1));
ASSERT_NOEXCEPT(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst));
}
{
- typedef std::atomic<T> A;
- volatile A t(T(3));
+ volatile std::atomic<T> t(T(3));
assert(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst) == T(3));
assert(t == T(2));
>From 4a4735ee1ec8f356a2c73570d289beb93dce9354 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Mon, 9 Feb 2026 20:46:52 +0800
Subject: [PATCH 11/19] ci
---
libcxx/include/__atomic/atomic.h | 2 ++
libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp | 10 ++++++++--
libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp | 6 ++++++
3 files changed, 16 insertions(+), 2 deletions(-)
diff --git a/libcxx/include/__atomic/atomic.h b/libcxx/include/__atomic/atomic.h
index e4be21cfd2d84..455acb8fca2ad 100644
--- a/libcxx/include/__atomic/atomic.h
+++ b/libcxx/include/__atomic/atomic.h
@@ -16,6 +16,8 @@
#include <__atomic/is_always_lock_free.h>
#include <__atomic/memory_order.h>
#include <__atomic/support.h>
+#include <__concepts/arithmetic.h>
+#include <__concepts/same_as.h>
#include <__config>
#include <__cstddef/ptrdiff_t.h>
#include <__memory/addressof.h>
diff --git a/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
index 6c1b69dce1595..6e96baaaf6e2c 100644
--- a/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
@@ -43,13 +43,19 @@ struct TestFetchMax {
std::same_as<T> decltype(auto) y = a.fetch_max(T(2));
assert(y == T(1));
assert(x == T(2));
+ y = a.fetch_max(T(0));
+ assert(y == T(2));
+ assert(x == T(2));
ASSERT_NOEXCEPT(a.fetch_max(T(0)));
}
{
- std::same_as<T> decltype(auto) y = a.fetch_max(T(1), std::memory_order_relaxed);
+ std::same_as<T> decltype(auto) y = a.fetch_max(T(3), std::memory_order_relaxed);
assert(y == T(2));
- assert(x == T(2));
+ assert(x == T(3));
+ y = a.fetch_max(T(0));
+ assert(y == T(3));
+ assert(x == T(3));
ASSERT_NOEXCEPT(a.fetch_max(T(0), std::memory_order_relaxed));
}
}
diff --git a/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
index 1fa2d32c4d7d8..92b7f1ed39cb1 100644
--- a/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
@@ -43,6 +43,9 @@ struct TestFetchMin {
std::same_as<T> decltype(auto) y = a.fetch_min(T(2));
assert(y == T(3));
assert(x == T(2));
+ y = a.fetch_min(T(4));
+ assert(y == T(2));
+ assert(x == T(2));
ASSERT_NOEXCEPT(a.fetch_min(T(0)));
}
@@ -50,6 +53,9 @@ struct TestFetchMin {
std::same_as<T> decltype(auto) y = a.fetch_min(T(1), std::memory_order_relaxed);
assert(y == T(2));
assert(x == T(1));
+ y = a.fetch_min(T(4));
+ assert(y == T(1));
+ assert(x == T(1));
ASSERT_NOEXCEPT(a.fetch_min(T(0), std::memory_order_relaxed));
}
}
>From cfce0bec4a759eea1786642fd3a309032aecb2fc Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Tue, 17 Feb 2026 15:26:50 +0800
Subject: [PATCH 12/19] revise testcases
---
.../atomics/atomics.ref/fetch_max.pass.cpp | 11 ++-
.../atomics/atomics.ref/fetch_min.pass.cpp | 11 ++-
.../atomic_fetch_max.pass.cpp | 85 +++++++++++++++---
.../atomic_fetch_max_explicit.pass.cpp | 86 ++++++++++++++++---
.../atomic_fetch_min.pass.cpp | 85 +++++++++++++++---
.../atomic_fetch_min_explicit.pass.cpp | 86 ++++++++++++++++---
6 files changed, 296 insertions(+), 68 deletions(-)
diff --git a/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
index 6e96baaaf6e2c..17930c5d97e65 100644
--- a/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
@@ -15,26 +15,25 @@
#include <cassert>
#include <concepts>
#include <type_traits>
-#include <utility>
#include "atomic_helpers.h"
#include "test_macros.h"
template <typename T>
-concept has_fetch_max = requires {
- std::declval<T const>().fetch_max(std::declval<T>());
- std::declval<T const>().fetch_max(std::declval<T>(), std::declval<std::memory_order>());
+concept has_fetch_max = requires(std::atomic_ref<T> const& a, T v) {
+ { a.fetch_max(v) } -> std::same_as<T>;
+ { a.fetch_max(v, std::memory_order::relaxed) } -> std::same_as<T>;
};
template <typename T>
struct TestDoesNotHaveFetchMax {
- void operator()() const { static_assert(!has_fetch_max<std::atomic_ref<T>>); }
+ void operator()() const { static_assert(!has_fetch_max<T>); }
};
template <typename T>
struct TestFetchMax {
void operator()() const {
- static_assert(std::is_integral_v<T>);
+ static_assert(std::is_integral_v<T> && has_fetch_max<T>);
alignas(std::atomic_ref<T>::required_alignment) T x(T(1));
std::atomic_ref<T> const a(x);
diff --git a/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
index 92b7f1ed39cb1..e930d83a2b819 100644
--- a/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
@@ -15,26 +15,25 @@
#include <cassert>
#include <concepts>
#include <type_traits>
-#include <utility>
#include "atomic_helpers.h"
#include "test_macros.h"
template <typename T>
-concept has_fetch_min = requires {
- std::declval<T const>().fetch_min(std::declval<T>());
- std::declval<T const>().fetch_min(std::declval<T>(), std::declval<std::memory_order>());
+concept has_fetch_min = requires(std::atomic_ref<T> const& a, T v) {
+ { a.fetch_min(v) } -> std::same_as<T>;
+ { a.fetch_min(v, std::memory_order::relaxed) } -> std::same_as<T>;
};
template <typename T>
struct TestDoesNotHaveFetchMin {
- void operator()() const { static_assert(!has_fetch_min<std::atomic_ref<T>>); }
+ void operator()() const { static_assert(!has_fetch_min<T>); }
};
template <typename T>
struct TestFetchMin {
void operator()() const {
- static_assert(std::is_integral_v<T>);
+ static_assert(std::is_integral_v<T> && has_fetch_min<T>);
alignas(std::atomic_ref<T>::required_alignment) T x(T(3));
std::atomic_ref<T> const a(x);
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
index 8aa66f68a23d7..cbd8f147f5931 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
@@ -9,6 +9,9 @@
// REQUIRES: std-at-least-c++26
// XFAIL: !has-64-bit-atomics
+// https://llvm.org/PR72893
+// XFAIL: target={{x86_64-.*}} && tsan
+
// <atomic>
// template<class T>
@@ -17,28 +20,82 @@
// constexpr T atomic_fetch_max(atomic<T>*, typename atomic<T>::value_type) noexcept;
#include <atomic>
-#include <type_traits>
#include <cassert>
+#include <type_traits>
+#include <vector>
-#include "test_macros.h"
#include "atomic_helpers.h"
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_THREADS
+# include <thread>
+
+# include "make_test_thread.h"
+#endif
template <class T>
-struct TestFn {
- void operator()() const {
- {
- std::atomic<T> t(T(1));
- assert(std::atomic_fetch_max(&t, T(2)) == T(1));
- assert(t == T(2));
+concept HasVolatileFetchMax = requires(volatile std::atomic<T>& a, T t) {
+ { std::atomic_fetch_max(&a, t) } -> std::same_as<T>;
+};
- ASSERT_NOEXCEPT(std::atomic_fetch_max(&t, T(2)));
+template <class T, template <class> class MaybeVolatile = std::type_identity_t>
+void test_impl() {
+ static_assert(HasVolatileFetchMax<T> == std::atomic<T>::is_always_lock_free);
+ static_assert(noexcept(std::atomic_fetch_max(std::declval<MaybeVolatile<std::atomic<T>>*>(), T(0))));
+
+ // atomic_fetch_max
+ {
+ MaybeVolatile<std::atomic<T>> t(T(1));
+ assert(std::atomic_fetch_max(&t, T(2)) == T(1));
+ assert(t == T(2));
+ }
+ {
+ MaybeVolatile<std::atomic<T>> t(T(3));
+ assert(std::atomic_fetch_max(&t, T(2)) == T(3));
+ assert(t == T(3));
+ }
+
+#ifndef TEST_HAS_NO_THREADS
+ // atomic_fetch_max concurrent
+ {
+ constexpr auto number_of_threads = 4;
+ constexpr auto loop = 30;
+
+ MaybeVolatile<std::atomic<T>> at(0);
+
+ std::vector<std::thread> threads;
+ threads.reserve(number_of_threads);
+ for (auto i = 0; i < number_of_threads; ++i) {
+ threads.push_back(support::make_test_thread([&at, i]() {
+ for (auto j = 0; j < loop; ++j) {
+ std::atomic_fetch_max(&at, T(i * loop + j));
+ }
+ }));
}
- {
- volatile std::atomic<T> t(T(3));
- assert(std::atomic_fetch_max(&t, T(2)) == T(3));
- assert(t == T(3));
- ASSERT_NOEXCEPT(std::atomic_fetch_max(&t, T(2)));
+ for (auto& thread : threads) {
+ thread.join();
+ }
+
+ const auto times = [](int n) {
+ T res(0);
+ for (auto i = 0; i < n; ++i) {
+ res = std::max<T>(res, i);
+ }
+ return res;
+ };
+
+ assert(at.load() == times(number_of_threads * loop));
+ }
+#endif
+}
+
+template <class T>
+struct TestFn {
+ void operator()() const {
+ test_impl<T>();
+ if constexpr (std::atomic<T>::is_always_lock_free) {
+ test_impl<T, std::add_volatile_t>();
}
}
};
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
index 1d04bb737fe1f..ddae555670f17 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
@@ -9,6 +9,9 @@
// REQUIRES: std-at-least-c++26
// XFAIL: !has-64-bit-atomics
+// https://llvm.org/PR72893
+// XFAIL: target={{x86_64-.*}} && tsan
+
// <atomic>
// template<class T>
@@ -19,28 +22,83 @@
// memory_order) noexcept;
#include <atomic>
-#include <type_traits>
#include <cassert>
+#include <type_traits>
+#include <vector>
-#include "test_macros.h"
#include "atomic_helpers.h"
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_THREADS
+# include <thread>
+
+# include "make_test_thread.h"
+#endif
template <class T>
-struct TestFn {
- void operator()() const {
- {
- std::atomic<T> t(T(1));
- assert(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst) == T(1));
- assert(t == T(2));
+concept HasVolatileFetchMaxExplicit = requires(volatile std::atomic<T>& a, T t) {
+ { std::atomic_fetch_max_explicit(&a, t, std::memory_order_seq_cst) } -> std::same_as<T>;
+};
- ASSERT_NOEXCEPT(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst));
+template <class T, template <class> class MaybeVolatile = std::type_identity_t>
+void test_impl() {
+ static_assert(HasVolatileFetchMaxExplicit<T> == std::atomic<T>::is_always_lock_free);
+ static_assert(noexcept(
+ std::atomic_fetch_max_explicit(std::declval<MaybeVolatile<std::atomic<T>>*>(), T(0), std::memory_order_seq_cst)));
+
+ // atomic_fetch_max_explicit
+ {
+ MaybeVolatile<std::atomic<T>> t(T(1));
+ assert(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst) == T(1));
+ assert(t == T(2));
+ }
+ {
+ MaybeVolatile<std::atomic<T>> t(T(3));
+ assert(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst) == T(3));
+ assert(t == T(3));
+ }
+
+#ifndef TEST_HAS_NO_THREADS
+ // atomic_fetch_max_explicit concurrent
+ {
+ constexpr auto number_of_threads = 4;
+ constexpr auto loop = 30;
+
+ MaybeVolatile<std::atomic<T>> at(0);
+
+ std::vector<std::thread> threads;
+ threads.reserve(number_of_threads);
+ for (auto i = 0; i < number_of_threads; ++i) {
+ threads.push_back(support::make_test_thread([&at, i]() {
+ for (auto j = 0; j < loop; ++j) {
+ std::atomic_fetch_max_explicit(&at, T(i * loop + j), std::memory_order_relaxed);
+ }
+ }));
}
- {
- volatile std::atomic<T> t(T(3));
- assert(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst) == T(3));
- assert(t == T(3));
- ASSERT_NOEXCEPT(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst));
+ for (auto& thread : threads) {
+ thread.join();
+ }
+
+ const auto times = [](int n) {
+ T res(0);
+ for (auto i = 0; i < n; ++i) {
+ res = std::max<T>(res, i);
+ }
+ return res;
+ };
+
+ assert(at.load() == times(number_of_threads * loop));
+ }
+#endif
+}
+
+template <class T>
+struct TestFn {
+ void operator()() const {
+ test_impl<T>();
+ if constexpr (std::atomic<T>::is_always_lock_free) {
+ test_impl<T, std::add_volatile_t>();
}
}
};
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
index 43b979144b19b..33ca27f3de262 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
@@ -9,6 +9,9 @@
// REQUIRES: std-at-least-c++26
// XFAIL: !has-64-bit-atomics
+// https://llvm.org/PR72893
+// XFAIL: target={{x86_64-.*}} && tsan
+
// <atomic>
// template<class T>
@@ -17,28 +20,82 @@
// constexpr T atomic_fetch_min(atomic<T>*, typename atomic<T>::value_type) noexcept;
#include <atomic>
-#include <type_traits>
#include <cassert>
+#include <type_traits>
+#include <vector>
-#include "test_macros.h"
#include "atomic_helpers.h"
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_THREADS
+# include <thread>
+
+# include "make_test_thread.h"
+#endif
template <class T>
-struct TestFn {
- void operator()() const {
- {
- std::atomic<T> t(T(1));
- assert(std::atomic_fetch_min(&t, T(2)) == T(1));
- assert(t == T(1));
+concept HasVolatileFetchMin = requires(volatile std::atomic<T>& a, T t) {
+ { std::atomic_fetch_min(&a, t) } -> std::same_as<T>;
+};
- ASSERT_NOEXCEPT(std::atomic_fetch_min(&t, T(2)));
+template <class T, template <class> class MaybeVolatile = std::type_identity_t>
+void test_impl() {
+ static_assert(HasVolatileFetchMin<T> == std::atomic<T>::is_always_lock_free);
+ static_assert(noexcept(std::atomic_fetch_min(std::declval<MaybeVolatile<std::atomic<T>>*>(), T(0))));
+
+ // atomic_fetch_min
+ {
+ MaybeVolatile<std::atomic<T>> t(T(1));
+ assert(std::atomic_fetch_min(&t, T(2)) == T(1));
+ assert(t == T(1));
+ }
+ {
+ MaybeVolatile<std::atomic<T>> t(T(3));
+ assert(std::atomic_fetch_min(&t, T(2)) == T(3));
+ assert(t == T(2));
+ }
+
+#ifndef TEST_HAS_NO_THREADS
+ // atomic_fetch_min concurrent
+ {
+ constexpr auto number_of_threads = 4;
+ constexpr auto loop = 30;
+
+ MaybeVolatile<std::atomic<T>> at(number_of_threads * loop);
+
+ std::vector<std::thread> threads;
+ threads.reserve(number_of_threads);
+ for (auto i = 0; i < number_of_threads; ++i) {
+ threads.push_back(support::make_test_thread([&at, i]() {
+ for (auto j = loop - 1; j >= 0; --j) {
+ std::atomic_fetch_min(&at, T(i * loop + j));
+ }
+ }));
}
- {
- volatile std::atomic<T> t(T(3));
- assert(std::atomic_fetch_min(&t, T(2)) == T(3));
- assert(t == T(2));
- ASSERT_NOEXCEPT(std::atomic_fetch_min(&t, T(2)));
+ for (auto& thread : threads) {
+ thread.join();
+ }
+
+ const auto times = [](int n) {
+ T res(n);
+ for (auto i = n - 1; i >= 0; --i) {
+ res = std::min<T>(res, i);
+ }
+ return res;
+ };
+
+ assert(at.load() == times(number_of_threads * loop));
+ }
+#endif
+}
+
+template <class T>
+struct TestFn {
+ void operator()() const {
+ test_impl<T>();
+ if constexpr (std::atomic<T>::is_always_lock_free) {
+ test_impl<T, std::add_volatile_t>();
}
}
};
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
index 309489f91f126..99d20c0c544fb 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
@@ -9,6 +9,9 @@
// REQUIRES: std-at-least-c++26
// XFAIL: !has-64-bit-atomics
+// https://llvm.org/PR72893
+// XFAIL: target={{x86_64-.*}} && tsan
+
// <atomic>
// template<class T>
@@ -19,28 +22,83 @@
// memory_order) noexcept;
#include <atomic>
-#include <type_traits>
#include <cassert>
+#include <type_traits>
+#include <vector>
-#include "test_macros.h"
#include "atomic_helpers.h"
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_THREADS
+# include <thread>
+
+# include "make_test_thread.h"
+#endif
template <class T>
-struct TestFn {
- void operator()() const {
- {
- std::atomic<T> t(T(1));
- assert(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst) == T(1));
- assert(t == T(1));
+concept HasVolatileFetchMinExplicit = requires(volatile std::atomic<T>& a, T t) {
+ { std::atomic_fetch_min_explicit(&a, t, std::memory_order_seq_cst) } -> std::same_as<T>;
+};
- ASSERT_NOEXCEPT(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst));
+template <class T, template <class> class MaybeVolatile = std::type_identity_t>
+void test_impl() {
+ static_assert(HasVolatileFetchMinExplicit<T> == std::atomic<T>::is_always_lock_free);
+ static_assert(noexcept(
+ std::atomic_fetch_min_explicit(std::declval<MaybeVolatile<std::atomic<T>>*>(), T(0), std::memory_order_seq_cst)));
+
+ // atomic_fetch_min_explicit
+ {
+ MaybeVolatile<std::atomic<T>> t(T(1));
+ assert(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst) == T(1));
+ assert(t == T(1));
+ }
+ {
+ MaybeVolatile<std::atomic<T>> t(T(3));
+ assert(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst) == T(3));
+ assert(t == T(2));
+ }
+
+#ifndef TEST_HAS_NO_THREADS
+ // atomic_fetch_min_explicit concurrent
+ {
+ constexpr auto number_of_threads = 4;
+ constexpr auto loop = 30;
+
+ MaybeVolatile<std::atomic<T>> at(number_of_threads * loop);
+
+ std::vector<std::thread> threads;
+ threads.reserve(number_of_threads);
+ for (auto i = 0; i < number_of_threads; ++i) {
+ threads.push_back(support::make_test_thread([&at, i]() {
+ for (auto j = loop - 1; j >= 0; --j) {
+ std::atomic_fetch_min_explicit(&at, T(i * loop + j), std::memory_order_relaxed);
+ }
+ }));
}
- {
- volatile std::atomic<T> t(T(3));
- assert(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst) == T(3));
- assert(t == T(2));
- ASSERT_NOEXCEPT(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst));
+ for (auto& thread : threads) {
+ thread.join();
+ }
+
+ const auto times = [](int n) {
+ T res(n);
+ for (auto i = n - 1; i >= 0; --i) {
+ res = std::min<T>(res, i);
+ }
+ return res;
+ };
+
+ assert(at.load() == times(number_of_threads * loop));
+ }
+#endif
+}
+
+template <class T>
+struct TestFn {
+ void operator()() const {
+ test_impl<T>();
+ if constexpr (std::atomic<T>::is_always_lock_free) {
+ test_impl<T, std::add_volatile_t>();
}
}
};
>From 71961be2c3c55d2ff0f0224ada38814fe004c972 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Tue, 17 Feb 2026 15:42:24 +0800
Subject: [PATCH 13/19] fix ci for aix
---
.../atomics.types.operations.req/atomic_fetch_max.pass.cpp | 6 ------
.../atomic_fetch_max_explicit.pass.cpp | 6 ------
.../atomics.types.operations.req/atomic_fetch_min.pass.cpp | 6 ------
.../atomic_fetch_min_explicit.pass.cpp | 6 ------
4 files changed, 24 deletions(-)
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
index cbd8f147f5931..6f89cd719a2ef 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
@@ -33,14 +33,8 @@
# include "make_test_thread.h"
#endif
-template <class T>
-concept HasVolatileFetchMax = requires(volatile std::atomic<T>& a, T t) {
- { std::atomic_fetch_max(&a, t) } -> std::same_as<T>;
-};
-
template <class T, template <class> class MaybeVolatile = std::type_identity_t>
void test_impl() {
- static_assert(HasVolatileFetchMax<T> == std::atomic<T>::is_always_lock_free);
static_assert(noexcept(std::atomic_fetch_max(std::declval<MaybeVolatile<std::atomic<T>>*>(), T(0))));
// atomic_fetch_max
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
index ddae555670f17..931c5a482ed58 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
@@ -35,14 +35,8 @@
# include "make_test_thread.h"
#endif
-template <class T>
-concept HasVolatileFetchMaxExplicit = requires(volatile std::atomic<T>& a, T t) {
- { std::atomic_fetch_max_explicit(&a, t, std::memory_order_seq_cst) } -> std::same_as<T>;
-};
-
template <class T, template <class> class MaybeVolatile = std::type_identity_t>
void test_impl() {
- static_assert(HasVolatileFetchMaxExplicit<T> == std::atomic<T>::is_always_lock_free);
static_assert(noexcept(
std::atomic_fetch_max_explicit(std::declval<MaybeVolatile<std::atomic<T>>*>(), T(0), std::memory_order_seq_cst)));
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
index 33ca27f3de262..e7a4d4e7bc798 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
@@ -33,14 +33,8 @@
# include "make_test_thread.h"
#endif
-template <class T>
-concept HasVolatileFetchMin = requires(volatile std::atomic<T>& a, T t) {
- { std::atomic_fetch_min(&a, t) } -> std::same_as<T>;
-};
-
template <class T, template <class> class MaybeVolatile = std::type_identity_t>
void test_impl() {
- static_assert(HasVolatileFetchMin<T> == std::atomic<T>::is_always_lock_free);
static_assert(noexcept(std::atomic_fetch_min(std::declval<MaybeVolatile<std::atomic<T>>*>(), T(0))));
// atomic_fetch_min
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
index 99d20c0c544fb..acf47f0d89567 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
@@ -35,14 +35,8 @@
# include "make_test_thread.h"
#endif
-template <class T>
-concept HasVolatileFetchMinExplicit = requires(volatile std::atomic<T>& a, T t) {
- { std::atomic_fetch_min_explicit(&a, t, std::memory_order_seq_cst) } -> std::same_as<T>;
-};
-
template <class T, template <class> class MaybeVolatile = std::type_identity_t>
void test_impl() {
- static_assert(HasVolatileFetchMinExplicit<T> == std::atomic<T>::is_always_lock_free);
static_assert(noexcept(
std::atomic_fetch_min_explicit(std::declval<MaybeVolatile<std::atomic<T>>*>(), T(0), std::memory_order_seq_cst)));
>From 8844e1581d89f537673084b04236710aa1a41ec5 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Tue, 17 Feb 2026 15:48:50 +0800
Subject: [PATCH 14/19] fix modules build
---
.../atomics.types.operations.req/atomic_fetch_max.pass.cpp | 1 +
.../atomic_fetch_max_explicit.pass.cpp | 1 +
.../atomics.types.operations.req/atomic_fetch_min.pass.cpp | 1 +
.../atomic_fetch_min_explicit.pass.cpp | 1 +
4 files changed, 4 insertions(+)
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
index 6f89cd719a2ef..93bd767cbab35 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
@@ -19,6 +19,7 @@
// template<class T>
// constexpr T atomic_fetch_max(atomic<T>*, typename atomic<T>::value_type) noexcept;
+#include <algorithm>
#include <atomic>
#include <cassert>
#include <type_traits>
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
index 931c5a482ed58..7fb2a702be337 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
@@ -21,6 +21,7 @@
// constexpr T atomic_fetch_max_explicit(atomic<T>*, typename atomic<T>::value_type,
// memory_order) noexcept;
+#include <algorithm>
#include <atomic>
#include <cassert>
#include <type_traits>
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
index e7a4d4e7bc798..a5adda9487897 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
@@ -19,6 +19,7 @@
// template<class T>
// constexpr T atomic_fetch_min(atomic<T>*, typename atomic<T>::value_type) noexcept;
+#include <algorithm>
#include <atomic>
#include <cassert>
#include <type_traits>
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
index acf47f0d89567..f5a23b153fdbe 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
@@ -21,6 +21,7 @@
// constexpr T atomic_fetch_min_explicit(atomic<T>*, typename atomic<T>::value_type,
// memory_order) noexcept;
+#include <algorithm>
#include <atomic>
#include <cassert>
#include <type_traits>
>From 7bfd5438857639f2d3b627c18fe56e57a1165067 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Tue, 17 Feb 2026 17:24:43 +0800
Subject: [PATCH 15/19] declval
---
.../atomics.types.operations.req/atomic_fetch_max.pass.cpp | 1 +
.../atomic_fetch_max_explicit.pass.cpp | 1 +
.../atomics.types.operations.req/atomic_fetch_min.pass.cpp | 1 +
.../atomic_fetch_min_explicit.pass.cpp | 1 +
4 files changed, 4 insertions(+)
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
index 93bd767cbab35..af249355811a5 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
@@ -23,6 +23,7 @@
#include <atomic>
#include <cassert>
#include <type_traits>
+#include <utility>
#include <vector>
#include "atomic_helpers.h"
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
index 7fb2a702be337..45df7c240dfa2 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
@@ -25,6 +25,7 @@
#include <atomic>
#include <cassert>
#include <type_traits>
+#include <utility>
#include <vector>
#include "atomic_helpers.h"
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
index a5adda9487897..e326d4a4e5b7a 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
@@ -23,6 +23,7 @@
#include <atomic>
#include <cassert>
#include <type_traits>
+#include <utility>
#include <vector>
#include "atomic_helpers.h"
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
index f5a23b153fdbe..4e110f7f34944 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
@@ -25,6 +25,7 @@
#include <atomic>
#include <cassert>
#include <type_traits>
+#include <utility>
#include <vector>
#include "atomic_helpers.h"
>From a844bd2596f09f8eda9af8bf9fca7c67997816f8 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Tue, 17 Feb 2026 19:51:19 +0800
Subject: [PATCH 16/19] remove xfail
---
.../atomics.types.operations.req/atomic_fetch_max.pass.cpp | 3 ---
.../atomic_fetch_max_explicit.pass.cpp | 3 ---
.../atomics.types.operations.req/atomic_fetch_min.pass.cpp | 3 ---
.../atomic_fetch_min_explicit.pass.cpp | 3 ---
4 files changed, 12 deletions(-)
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
index af249355811a5..e4aba6ebbdd20 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
@@ -9,9 +9,6 @@
// REQUIRES: std-at-least-c++26
// XFAIL: !has-64-bit-atomics
-// https://llvm.org/PR72893
-// XFAIL: target={{x86_64-.*}} && tsan
-
// <atomic>
// template<class T>
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
index 45df7c240dfa2..441fb57c3b332 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
@@ -9,9 +9,6 @@
// REQUIRES: std-at-least-c++26
// XFAIL: !has-64-bit-atomics
-// https://llvm.org/PR72893
-// XFAIL: target={{x86_64-.*}} && tsan
-
// <atomic>
// template<class T>
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
index e326d4a4e5b7a..3a4a15290b407 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
@@ -9,9 +9,6 @@
// REQUIRES: std-at-least-c++26
// XFAIL: !has-64-bit-atomics
-// https://llvm.org/PR72893
-// XFAIL: target={{x86_64-.*}} && tsan
-
// <atomic>
// template<class T>
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
index 4e110f7f34944..fd208162b9c07 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
@@ -9,9 +9,6 @@
// REQUIRES: std-at-least-c++26
// XFAIL: !has-64-bit-atomics
-// https://llvm.org/PR72893
-// XFAIL: target={{x86_64-.*}} && tsan
-
// <atomic>
// template<class T>
>From a85a1dfa40440160f7910933e899250e8c6409f9 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sat, 21 Feb 2026 20:30:08 +0800
Subject: [PATCH 17/19] address review comments
---
libcxx/include/__atomic/atomic.h | 39 ++++++++--
libcxx/include/__atomic/atomic_ref.h | 28 +++++++
libcxx/include/__atomic/support/c11.h | 16 ++--
libcxx/include/__atomic/support/gcc.h | 26 +++----
libcxx/include/atomic | 4 +
.../atomics/atomics.ref/fetch_max.pass.cpp | 73 +++++++++++++------
.../atomics/atomics.ref/fetch_min.pass.cpp | 73 +++++++++++++------
.../atomic_fetch_max.pass.cpp | 3 +-
.../atomic_fetch_max_explicit.pass.cpp | 3 +-
.../atomic_fetch_min.pass.cpp | 3 +-
.../atomic_fetch_min_explicit.pass.cpp | 3 +-
11 files changed, 191 insertions(+), 80 deletions(-)
diff --git a/libcxx/include/__atomic/atomic.h b/libcxx/include/__atomic/atomic.h
index 455acb8fca2ad..5fb9e0db72f51 100644
--- a/libcxx/include/__atomic/atomic.h
+++ b/libcxx/include/__atomic/atomic.h
@@ -26,6 +26,7 @@
#include <__type_traits/is_function.h>
#include <__type_traits/is_integral.h>
#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_pointer.h>
#include <__type_traits/is_same.h>
#include <__type_traits/is_trivially_copyable.h>
#include <__type_traits/remove_pointer.h>
@@ -322,6 +323,28 @@ struct atomic<_Tp*> : public __atomic_base<_Tp*> {
return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
}
+#if _LIBCPP_STD_VER >= 26
+ _LIBCPP_HIDE_FROM_ABI _Tp* fetch_max(_Tp* __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+ static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
+ return std::__cxx_atomic_fetch_max(std::addressof(this->__a_), __op, __m);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI _Tp* fetch_max(_Tp* __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+ static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
+ return std::__cxx_atomic_fetch_max(std::addressof(this->__a_), __op, __m);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI _Tp* fetch_min(_Tp* __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+ static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
+ return std::__cxx_atomic_fetch_min(std::addressof(this->__a_), __op, __m);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI _Tp* fetch_min(_Tp* __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+ static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
+ return std::__cxx_atomic_fetch_min(std::addressof(this->__a_), __op, __m);
+ }
+#endif
+
_LIBCPP_HIDE_FROM_ABI _Tp* operator++(int) volatile _NOEXCEPT { return fetch_add(1); }
_LIBCPP_HIDE_FROM_ABI _Tp* operator++(int) _NOEXCEPT { return fetch_add(1); }
_LIBCPP_HIDE_FROM_ABI _Tp* operator--(int) volatile _NOEXCEPT { return fetch_sub(1); }
@@ -819,13 +842,13 @@ atomic_fetch_xor_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __o
// atomic_fetch_max
template <class _Tp>
- requires(integral<_Tp> && !same_as<_Tp, bool>)
+ requires((integral<_Tp> && !same_as<_Tp, bool>) || is_pointer_v<_Tp>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_max(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
return __o->fetch_max(__op);
}
template <class _Tp>
- requires(integral<_Tp> && !same_as<_Tp, bool>)
+ requires((integral<_Tp> && !same_as<_Tp, bool>) || is_pointer_v<_Tp>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_max(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
return __o->fetch_max(__op);
}
@@ -833,14 +856,14 @@ _LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_max(atomic<_Tp>* __o, typename atomic<_Tp
// atomic_fetch_max_explicit
template <class _Tp>
- requires(integral<_Tp> && !same_as<_Tp, bool>)
+ requires((integral<_Tp> && !same_as<_Tp, bool>) || is_pointer_v<_Tp>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_max_explicit(
volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
return __o->fetch_max(__op, __m);
}
template <class _Tp>
- requires(integral<_Tp> && !same_as<_Tp, bool>)
+ requires((integral<_Tp> && !same_as<_Tp, bool>) || is_pointer_v<_Tp>)
_LIBCPP_HIDE_FROM_ABI _Tp
atomic_fetch_max_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
return __o->fetch_max(__op, __m);
@@ -849,13 +872,13 @@ atomic_fetch_max_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __o
// atomic_fetch_min
template <class _Tp>
- requires(integral<_Tp> && !same_as<_Tp, bool>)
+ requires((integral<_Tp> && !same_as<_Tp, bool>) || is_pointer_v<_Tp>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_min(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
return __o->fetch_min(__op);
}
template <class _Tp>
- requires(integral<_Tp> && !same_as<_Tp, bool>)
+ requires((integral<_Tp> && !same_as<_Tp, bool>) || is_pointer_v<_Tp>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_min(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
return __o->fetch_min(__op);
}
@@ -863,14 +886,14 @@ _LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_min(atomic<_Tp>* __o, typename atomic<_Tp
// atomic_fetch_min_explicit
template <class _Tp>
- requires(integral<_Tp> && !same_as<_Tp, bool>)
+ requires((integral<_Tp> && !same_as<_Tp, bool>) || is_pointer_v<_Tp>)
_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_min_explicit(
volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
return __o->fetch_min(__op, __m);
}
template <class _Tp>
- requires(integral<_Tp> && !same_as<_Tp, bool>)
+ requires((integral<_Tp> && !same_as<_Tp, bool>) || is_pointer_v<_Tp>)
_LIBCPP_HIDE_FROM_ABI _Tp
atomic_fetch_min_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
return __o->fetch_min(__op, __m);
diff --git a/libcxx/include/__atomic/atomic_ref.h b/libcxx/include/__atomic/atomic_ref.h
index 88c7d7dbc5dfb..ec98fab310c7c 100644
--- a/libcxx/include/__atomic/atomic_ref.h
+++ b/libcxx/include/__atomic/atomic_ref.h
@@ -403,6 +403,34 @@ struct atomic_ref<_Tp*> : public __atomic_ref_base<_Tp*> {
_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));
}
+# if _LIBCPP_STD_VER >= 26
+ _LIBCPP_HIDE_FROM_ABI _Tp* fetch_max(_Tp* __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+# if __has_builtin(__atomic_fetch_max)
+ return reinterpret_cast<_Tp*>(__atomic_fetch_max(
+ reinterpret_cast<uintptr_t*>(this->__ptr_), reinterpret_cast<uintptr_t>(__arg), std::__to_gcc_order(__order)));
+# else
+ _Tp __old = this->load(memory_order_relaxed);
+ _Tp __new;
+ do {
+ __new = __old > __arg ? __old : __arg;
+ } while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed));
+ return __old;
+# endif
+ }
+ _LIBCPP_HIDE_FROM_ABI _Tp* fetch_min(_Tp* __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+# if __has_builtin(__atomic_fetch_min)
+ return reinterpret_cast<_Tp*>(__atomic_fetch_min(
+ reinterpret_cast<uintptr_t*>(this->__ptr_), reinterpret_cast<uintptr_t>(__arg), std::__to_gcc_order(__order)));
+# else
+ _Tp __old = this->load(memory_order_relaxed);
+ _Tp __new;
+ do {
+ __new = __old < __arg ? __old : __arg;
+ } while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed));
+ return __old;
+# endif
+ }
+# endif
_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); }
diff --git a/libcxx/include/__atomic/support/c11.h b/libcxx/include/__atomic/support/c11.h
index f28b5e461c18a..0d74d55188a3d 100644
--- a/libcxx/include/__atomic/support/c11.h
+++ b/libcxx/include/__atomic/support/c11.h
@@ -261,28 +261,28 @@ __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
-__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __val, memory_order __order) _NOEXCEPT {
return __c11_atomic_fetch_max(
- std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
+ std::addressof(__a->__a_value), __val, static_cast<__memory_order_underlying_t>(__order));
}
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
-__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __val, memory_order __order) _NOEXCEPT {
return __c11_atomic_fetch_max(
- std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
+ std::addressof(__a->__a_value), __val, static_cast<__memory_order_underlying_t>(__order));
}
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
-__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __val, memory_order __order) _NOEXCEPT {
return __c11_atomic_fetch_min(
- std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
+ std::addressof(__a->__a_value), __val, static_cast<__memory_order_underlying_t>(__order));
}
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
-__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp>* __a, _Tp __val, memory_order __order) _NOEXCEPT {
return __c11_atomic_fetch_min(
- std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
+ std::addressof(__a->__a_value), __val, static_cast<__memory_order_underlying_t>(__order));
}
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__atomic/support/gcc.h b/libcxx/include/__atomic/support/gcc.h
index 754c60406cbf6..37c38d25012c6 100644
--- a/libcxx/include/__atomic/support/gcc.h
+++ b/libcxx/include/__atomic/support/gcc.h
@@ -260,29 +260,28 @@ __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
-__cxx_atomic_fetch_max(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+__cxx_atomic_fetch_max(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __val, memory_order __order) {
#if __has_builtin(__atomic_fetch_max)
- return __atomic_fetch_max(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+ return __atomic_fetch_max(std::addressof(__a->__a_value), __val, __to_gcc_order(__order));
#else
_Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
- __value = __ret > __pattern ? __ret : __pattern;
+ __value = __ret > __val ? __ret : __val;
} while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
#endif
}
template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp
-__cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp __cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __val, memory_order __order) {
#if __has_builtin(__atomic_fetch_max)
- return __atomic_fetch_max(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+ return __atomic_fetch_max(std::addressof(__a->__a_value), __val, __to_gcc_order(__order));
#else
_Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
- __value = __ret > __pattern ? __ret : __pattern;
+ __value = __ret > __val ? __ret : __val;
} while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
#endif
@@ -290,29 +289,28 @@ __cxx_atomic_fetch_max(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_o
template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp
-__cxx_atomic_fetch_min(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+__cxx_atomic_fetch_min(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __val, memory_order __order) {
#if __has_builtin(__atomic_fetch_min)
- return __atomic_fetch_min(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+ return __atomic_fetch_min(std::addressof(__a->__a_value), __val, __to_gcc_order(__order));
#else
_Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
- __value = __ret < __pattern ? __ret : __pattern;
+ __value = __ret < __val ? __ret : __val;
} while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
#endif
}
template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp
-__cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp __cxx_atomic_fetch_min(__cxx_atomic_base_impl<_Tp>* __a, _Tp __val, memory_order __order) {
#if __has_builtin(__atomic_fetch_min)
- return __atomic_fetch_min(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
+ return __atomic_fetch_min(std::addressof(__a->__a_value), __val, __to_gcc_order(__order));
#else
_Tp __ret = __cxx_atomic_load(__a, memory_order_relaxed);
_Tp __value;
do {
- __value = __ret < __pattern ? __ret : __pattern;
+ __value = __ret < __val ? __ret : __val;
} while (!__cxx_atomic_compare_exchange_weak(__a, std::addressof(__ret), __value, __order, memory_order_relaxed));
return __ret;
#endif
diff --git a/libcxx/include/atomic b/libcxx/include/atomic
index 4cf93b6bfbd85..bcf831fedc192 100644
--- a/libcxx/include/atomic
+++ b/libcxx/include/atomic
@@ -244,6 +244,10 @@ struct atomic<T*>
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) volatile noexcept;
T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
+ T* fetch_max(T*, memory_order = memory_order_seq_cst) volatile noexcept;
+ T* fetch_max(T*, memory_order = memory_order_seq_cst) noexcept;
+ T* fetch_min(T*, memory_order = memory_order_seq_cst) volatile noexcept;
+ T* fetch_min(T*, memory_order = memory_order_seq_cst) noexcept;
T* operator++(int) volatile noexcept;
T* operator++(int) noexcept;
diff --git a/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
index 17930c5d97e65..2ba748486d950 100644
--- a/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp
@@ -33,29 +33,56 @@ struct TestDoesNotHaveFetchMax {
template <typename T>
struct TestFetchMax {
void operator()() const {
- static_assert(std::is_integral_v<T> && has_fetch_max<T>);
-
- alignas(std::atomic_ref<T>::required_alignment) T x(T(1));
- std::atomic_ref<T> const a(x);
-
- {
- std::same_as<T> decltype(auto) y = a.fetch_max(T(2));
- assert(y == T(1));
- assert(x == T(2));
- y = a.fetch_max(T(0));
- assert(y == T(2));
- assert(x == T(2));
- ASSERT_NOEXCEPT(a.fetch_max(T(0)));
- }
+ static_assert((std::is_integral_v<T> || std::is_pointer_v<T>) && has_fetch_max<T>);
+
+ if constexpr (std::is_integral_v<T>) {
+ alignas(std::atomic_ref<T>::required_alignment) T x(T(1));
+ std::atomic_ref<T> const a(x);
+
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_max(T(2));
+ assert(y == T(1));
+ assert(x == T(2));
+ y = a.fetch_max(T(0));
+ assert(y == T(2));
+ assert(x == T(2));
+ ASSERT_NOEXCEPT(a.fetch_max(T(0)));
+ }
+
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_max(T(3), std::memory_order_relaxed);
+ assert(y == T(2));
+ assert(x == T(3));
+ y = a.fetch_max(T(0));
+ assert(y == T(3));
+ assert(x == T(3));
+ ASSERT_NOEXCEPT(a.fetch_max(T(0), std::memory_order_relaxed));
+ }
+ } else if constexpr (std::is_pointer_v<T>) {
+ using U = std::remove_pointer_t<T>;
+ U t[9] = {};
+ alignas(std::atomic_ref<T>::required_alignment) T x{&t[1]};
+ std::atomic_ref<T> const a(x);
+
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_max(&t[2]);
+ assert(y == &t[1]);
+ assert(x == &t[2]);
+ y = a.fetch_max(&t[0]);
+ assert(y == &t[2]);
+ assert(x == &t[2]);
+ ASSERT_NOEXCEPT(a.fetch_max(&t[0]));
+ }
- {
- std::same_as<T> decltype(auto) y = a.fetch_max(T(3), std::memory_order_relaxed);
- assert(y == T(2));
- assert(x == T(3));
- y = a.fetch_max(T(0));
- assert(y == T(3));
- assert(x == T(3));
- ASSERT_NOEXCEPT(a.fetch_max(T(0), std::memory_order_relaxed));
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_max(&t[3], std::memory_order_relaxed);
+ assert(y == &t[2]);
+ assert(a == &t[3]);
+ y = a.fetch_max(&t[0]);
+ assert(y == &t[3]);
+ assert(x == &t[3]);
+ ASSERT_NOEXCEPT(a.fetch_max(&t[0], std::memory_order_relaxed));
+ }
}
}
};
@@ -65,7 +92,7 @@ int main(int, char**) {
TestEachFloatingPointType<TestDoesNotHaveFetchMax>()();
- TestEachPointerType<TestDoesNotHaveFetchMax>()();
+ TestEachPointerType<TestFetchMax>()();
TestDoesNotHaveFetchMax<bool>()();
TestDoesNotHaveFetchMax<UserAtomicType>()();
diff --git a/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
index e930d83a2b819..b178996b06085 100644
--- a/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp
@@ -33,29 +33,56 @@ struct TestDoesNotHaveFetchMin {
template <typename T>
struct TestFetchMin {
void operator()() const {
- static_assert(std::is_integral_v<T> && has_fetch_min<T>);
-
- alignas(std::atomic_ref<T>::required_alignment) T x(T(3));
- std::atomic_ref<T> const a(x);
-
- {
- std::same_as<T> decltype(auto) y = a.fetch_min(T(2));
- assert(y == T(3));
- assert(x == T(2));
- y = a.fetch_min(T(4));
- assert(y == T(2));
- assert(x == T(2));
- ASSERT_NOEXCEPT(a.fetch_min(T(0)));
- }
+ static_assert((std::is_integral_v<T> || std::is_pointer_v<T>) && has_fetch_min<T>);
+
+ if constexpr (std::is_integral_v<T>) {
+ alignas(std::atomic_ref<T>::required_alignment) T x(T(3));
+ std::atomic_ref<T> const a(x);
+
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_min(T(2));
+ assert(y == T(3));
+ assert(x == T(2));
+ y = a.fetch_min(T(4));
+ assert(y == T(2));
+ assert(x == T(2));
+ ASSERT_NOEXCEPT(a.fetch_min(T(0)));
+ }
+
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_min(T(1), std::memory_order_relaxed);
+ assert(y == T(2));
+ assert(x == T(1));
+ y = a.fetch_min(T(4));
+ assert(y == T(1));
+ assert(x == T(1));
+ ASSERT_NOEXCEPT(a.fetch_min(T(0), std::memory_order_relaxed));
+ }
+ } else if constexpr (std::is_pointer_v<T>) {
+ using U = std::remove_pointer_t<T>;
+ U t[9] = {};
+ alignas(std::atomic_ref<T>::required_alignment) T x{&t[3]};
+ std::atomic_ref<T> const a(x);
+
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_min(&t[2]);
+ assert(y == &t[3]);
+ assert(x == &t[2]);
+ y = a.fetch_min(&t[4]);
+ assert(y == &t[2]);
+ assert(x == &t[2]);
+ ASSERT_NOEXCEPT(a.fetch_min(&t[0]));
+ }
- {
- std::same_as<T> decltype(auto) y = a.fetch_min(T(1), std::memory_order_relaxed);
- assert(y == T(2));
- assert(x == T(1));
- y = a.fetch_min(T(4));
- assert(y == T(1));
- assert(x == T(1));
- ASSERT_NOEXCEPT(a.fetch_min(T(0), std::memory_order_relaxed));
+ {
+ std::same_as<T> decltype(auto) y = a.fetch_min(&t[1], std::memory_order_relaxed);
+ assert(y == &t[2]);
+ assert(a == &t[1]);
+ y = a.fetch_min(&t[4]);
+ assert(y == &t[1]);
+ assert(x == &t[1]);
+ ASSERT_NOEXCEPT(a.fetch_min(&t[0], std::memory_order_relaxed));
+ }
}
}
};
@@ -65,7 +92,7 @@ int main(int, char**) {
TestEachFloatingPointType<TestDoesNotHaveFetchMin>()();
- TestEachPointerType<TestDoesNotHaveFetchMin>()();
+ TestEachPointerType<TestFetchMin>()();
TestDoesNotHaveFetchMin<bool>()();
TestDoesNotHaveFetchMin<UserAtomicType>()();
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
index e4aba6ebbdd20..a7596b6ff2bf5 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
@@ -44,7 +44,8 @@ void test_impl() {
}
{
MaybeVolatile<std::atomic<T>> t(T(3));
- assert(std::atomic_fetch_max(&t, T(2)) == T(3));
+ std::same_as<T> decltype(auto) r = t.fetch_max(T(2));
+ assert(r == T(3));
assert(t == T(3));
}
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
index 441fb57c3b332..52c4ac137c709 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
@@ -47,7 +47,8 @@ void test_impl() {
}
{
MaybeVolatile<std::atomic<T>> t(T(3));
- assert(std::atomic_fetch_max_explicit(&t, T(2), std::memory_order_seq_cst) == T(3));
+ std::same_as<T> decltype(auto) r = t.fetch_max(T(2), std::memory_order_seq_cst);
+ assert(r == T(3));
assert(t == T(3));
}
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
index 3a4a15290b407..1ffc92f3c2300 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
@@ -44,7 +44,8 @@ void test_impl() {
}
{
MaybeVolatile<std::atomic<T>> t(T(3));
- assert(std::atomic_fetch_min(&t, T(2)) == T(3));
+ std::same_as<T> decltype(auto) r = t.fetch_min(T(2));
+ assert(r == T(3));
assert(t == T(2));
}
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
index fd208162b9c07..f5732b5d977cc 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
@@ -47,7 +47,8 @@ void test_impl() {
}
{
MaybeVolatile<std::atomic<T>> t(T(3));
- assert(std::atomic_fetch_min_explicit(&t, T(2), std::memory_order_seq_cst) == T(3));
+ std::same_as<T> decltype(auto) r = t.fetch_min(T(2), std::memory_order_seq_cst);
+ assert(r == T(3));
assert(t == T(2));
}
>From c3e318d67841e8076a2e99f9c79d64873178dab2 Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sat, 21 Feb 2026 21:07:13 +0800
Subject: [PATCH 18/19] header
---
.../atomics.types.operations.req/atomic_fetch_max.pass.cpp | 1 +
.../atomic_fetch_max_explicit.pass.cpp | 1 +
.../atomics.types.operations.req/atomic_fetch_min.pass.cpp | 1 +
.../atomic_fetch_min_explicit.pass.cpp | 1 +
4 files changed, 4 insertions(+)
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
index a7596b6ff2bf5..dc2274a1056cb 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp
@@ -19,6 +19,7 @@
#include <algorithm>
#include <atomic>
#include <cassert>
+#include <concepts>
#include <type_traits>
#include <utility>
#include <vector>
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
index 52c4ac137c709..d878f6abd246d 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp
@@ -21,6 +21,7 @@
#include <algorithm>
#include <atomic>
#include <cassert>
+#include <concepts>
#include <type_traits>
#include <utility>
#include <vector>
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
index 1ffc92f3c2300..43277f6a7977a 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp
@@ -19,6 +19,7 @@
#include <algorithm>
#include <atomic>
#include <cassert>
+#include <concepts>
#include <type_traits>
#include <utility>
#include <vector>
diff --git a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
index f5732b5d977cc..75bf200812ab0 100644
--- a/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp
@@ -21,6 +21,7 @@
#include <algorithm>
#include <atomic>
#include <cassert>
+#include <concepts>
#include <type_traits>
#include <utility>
#include <vector>
>From 609e1196aa5098cbbd3e27a02d21beb42c98ecfe Mon Sep 17 00:00:00 2001
From: c8ef <c8ef at outlook.com>
Date: Sun, 22 Feb 2026 21:14:58 +0800
Subject: [PATCH 19/19] fix gcc ci
---
libcxx/include/__atomic/atomic_ref.h | 14 ++++++--------
1 file changed, 6 insertions(+), 8 deletions(-)
diff --git a/libcxx/include/__atomic/atomic_ref.h b/libcxx/include/__atomic/atomic_ref.h
index ec98fab310c7c..e0f28f4a3e204 100644
--- a/libcxx/include/__atomic/atomic_ref.h
+++ b/libcxx/include/__atomic/atomic_ref.h
@@ -406,11 +406,10 @@ struct atomic_ref<_Tp*> : public __atomic_ref_base<_Tp*> {
# if _LIBCPP_STD_VER >= 26
_LIBCPP_HIDE_FROM_ABI _Tp* fetch_max(_Tp* __arg, memory_order __order = memory_order_seq_cst) const noexcept {
# if __has_builtin(__atomic_fetch_max)
- return reinterpret_cast<_Tp*>(__atomic_fetch_max(
- reinterpret_cast<uintptr_t*>(this->__ptr_), reinterpret_cast<uintptr_t>(__arg), std::__to_gcc_order(__order)));
+ return __atomic_fetch_max(this->__ptr_, __arg * sizeof(_Tp), std::__to_gcc_order(__order));
# else
- _Tp __old = this->load(memory_order_relaxed);
- _Tp __new;
+ _Tp* __old = this->load(memory_order_relaxed);
+ _Tp* __new;
do {
__new = __old > __arg ? __old : __arg;
} while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed));
@@ -419,11 +418,10 @@ struct atomic_ref<_Tp*> : public __atomic_ref_base<_Tp*> {
}
_LIBCPP_HIDE_FROM_ABI _Tp* fetch_min(_Tp* __arg, memory_order __order = memory_order_seq_cst) const noexcept {
# if __has_builtin(__atomic_fetch_min)
- return reinterpret_cast<_Tp*>(__atomic_fetch_min(
- reinterpret_cast<uintptr_t*>(this->__ptr_), reinterpret_cast<uintptr_t>(__arg), std::__to_gcc_order(__order)));
+ return __atomic_fetch_min(this->__ptr_, __arg * sizeof(_Tp), std::__to_gcc_order(__order));
# else
- _Tp __old = this->load(memory_order_relaxed);
- _Tp __new;
+ _Tp* __old = this->load(memory_order_relaxed);
+ _Tp* __new;
do {
__new = __old < __arg ? __old : __arg;
} while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed));
More information about the libcxx-commits
mailing list