[libcxx-commits] [libcxx] [libc++] Implement P0493R5: Atomic minimum/maximum (PR #180333)
via libcxx-commits
libcxx-commits at lists.llvm.org
Sat Feb 7 07:20:23 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-libcxx
Author: Connector Switch (c8ef)
<details>
<summary>Changes</summary>
Closes #<!-- -->105418.
Since gcc does not currently support `__atomic_fetch_min/max`, we use a CAS loop in `atomic_ref` and `support/gcc.h`.
---
Patch is 31.98 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/180333.diff
20 Files Affected:
- (modified) libcxx/docs/FeatureTestMacroTable.rst (+1-1)
- (modified) libcxx/docs/ReleaseNotes/23.rst (+1)
- (modified) libcxx/docs/Status/Cxx2cPapers.csv (+1-1)
- (modified) libcxx/include/__atomic/atomic.h (+68)
- (modified) libcxx/include/__atomic/atomic_ref.h (+18)
- (modified) libcxx/include/__atomic/support.h (+9)
- (modified) libcxx/include/__atomic/support/c11.h (+26)
- (modified) libcxx/include/__atomic/support/gcc.h (+44)
- (modified) libcxx/include/atomic (+24)
- (modified) libcxx/include/version (+1-1)
- (modified) libcxx/modules/std/atomic.inc (+6)
- (added) libcxx/test/std/atomics/atomics.ref/fetch_max.pass.cpp (+70)
- (added) libcxx/test/std/atomics/atomics.ref/fetch_min.pass.cpp (+70)
- (added) libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max.pass.cpp (+55)
- (added) libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_max_explicit.pass.cpp (+57)
- (added) libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min.pass.cpp (+55)
- (added) libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_min_explicit.pass.cpp (+57)
- (modified) libcxx/test/std/language.support/support.limits/support.limits.general/atomic.version.compile.pass.cpp (+5-11)
- (modified) libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp (+5-11)
- (modified) libcxx/utils/generate_feature_test_macro_components.py (-1)
``````````diff
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..84b9bf211b4b9 100644
--- a/libcxx/include/__atomic/atomic_ref.h
+++ b/libcxx/include/__atomic/atomic_ref.h
@@ -299,6 +299,24 @@ 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 {
+ _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 {
+ _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 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..3eaccf95e19d8 100644
--- a/libcxx/include/__atomic/support/gcc.h
+++ b/libcxx/include/__atomic/support/gcc.h
@@ -258,6 +258,50 @@ __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) {
+ _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;
+}
+
+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, 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;
+}
+
+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, 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;
+}
+
+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, 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;
+}
+
#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..38321e1a1bb64 100644
--- a/libcxx/modules/std/atomic.inc
+++ b/libcxx/modules/std/atomic.inc
@@ -50,6 +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;
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(...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/180333
More information about the libcxx-commits
mailing list