Last week in Croydon we approved P4052R0 to rename std::add_sat etc. for
C++26
libstdc++-v3/ChangeLog:
* include/bits/sat_arith.h (add_sat, sub_sat, mul_sat, div_sat)
(saturate_cast): Rename to saturating_xxx as per P4052R0.
* include/bits/version.def (saturation_arithmetic): Bump value.
* include/bits/version.h: Regenerate.
* testsuite/26_numerics/saturation/add.cc: Use new name.
* testsuite/26_numerics/saturation/cast.cc: Likewise.
* testsuite/26_numerics/saturation/div.cc: Likewise.
* testsuite/26_numerics/saturation/extended.cc: Likewise.
* testsuite/26_numerics/saturation/mul.cc: Likewise.
* testsuite/26_numerics/saturation/sub.cc: Likewise.
* testsuite/26_numerics/saturation/version.cc: Check for updated
value.
---
Tested x86_64-linux.
libstdc++-v3/include/bits/sat_arith.h | 10 +-
libstdc++-v3/include/bits/version.def | 2 +-
libstdc++-v3/include/bits/version.h | 4 +-
.../testsuite/26_numerics/saturation/add.cc | 82 ++++++-------
.../testsuite/26_numerics/saturation/cast.cc | 30 ++---
.../testsuite/26_numerics/saturation/div.cc | 36 +++---
.../26_numerics/saturation/extended.cc | 26 ++---
.../testsuite/26_numerics/saturation/mul.cc | 38 +++---
.../testsuite/26_numerics/saturation/sub.cc | 108 +++++++++---------
.../26_numerics/saturation/version.cc | 4 +-
10 files changed, 170 insertions(+), 170 deletions(-)
diff --git a/libstdc++-v3/include/bits/sat_arith.h
b/libstdc++-v3/include/bits/sat_arith.h
index bce86d919919..7f0149de0ecf 100644
--- a/libstdc++-v3/include/bits/sat_arith.h
+++ b/libstdc++-v3/include/bits/sat_arith.h
@@ -48,7 +48,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Add two integers, with saturation in case of overflow.
template<typename _Tp> requires __is_signed_or_unsigned_integer<_Tp>::value
constexpr _Tp
- add_sat(_Tp __x, _Tp __y) noexcept
+ saturating_add(_Tp __x, _Tp __y) noexcept
{
_Tp __z;
if (!__builtin_add_overflow(__x, __y, &__z))
@@ -64,7 +64,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Subtract one integer from another, with saturation in case of overflow.
template<typename _Tp> requires __is_signed_or_unsigned_integer<_Tp>::value
constexpr _Tp
- sub_sat(_Tp __x, _Tp __y) noexcept
+ saturating_sub(_Tp __x, _Tp __y) noexcept
{
_Tp __z;
if (!__builtin_sub_overflow(__x, __y, &__z))
@@ -80,7 +80,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Multiply two integers, with saturation in case of overflow.
template<typename _Tp> requires __is_signed_or_unsigned_integer<_Tp>::value
constexpr _Tp
- mul_sat(_Tp __x, _Tp __y) noexcept
+ saturating_mul(_Tp __x, _Tp __y) noexcept
{
_Tp __z;
if (!__builtin_mul_overflow(__x, __y, &__z))
@@ -96,7 +96,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Divide one integer by another, with saturation in case of overflow.
template<typename _Tp> requires __is_signed_or_unsigned_integer<_Tp>::value
constexpr _Tp
- div_sat(_Tp __x, _Tp __y) noexcept
+ saturating_div(_Tp __x, _Tp __y) noexcept
{
__glibcxx_assert(__y != 0);
if constexpr (is_signed_v<_Tp>)
@@ -110,7 +110,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
requires __is_signed_or_unsigned_integer<_Res>::value
&& __is_signed_or_unsigned_integer<_Tp>::value
constexpr _Res
- saturate_cast(_Tp __x) noexcept
+ saturating_cast(_Tp __x) noexcept
{
constexpr int __digits_R = __gnu_cxx::__int_traits<_Res>::__digits;
constexpr int __digits_T = __gnu_cxx::__int_traits<_Tp>::__digits;
diff --git a/libstdc++-v3/include/bits/version.def
b/libstdc++-v3/include/bits/version.def
index bb513e391d76..8c9ec854d3b2 100644
--- a/libstdc++-v3/include/bits/version.def
+++ b/libstdc++-v3/include/bits/version.def
@@ -2157,7 +2157,7 @@ ftms = {
ftms = {
name = saturation_arithmetic;
values = {
- v = 202311;
+ v = 202603;
cxxmin = 26;
};
};
diff --git a/libstdc++-v3/include/bits/version.h
b/libstdc++-v3/include/bits/version.h
index e469944208a7..836aae02d773 100644
--- a/libstdc++-v3/include/bits/version.h
+++ b/libstdc++-v3/include/bits/version.h
@@ -2418,9 +2418,9 @@
#if !defined(__cpp_lib_saturation_arithmetic)
# if (__cplusplus > 202302L)
-# define __glibcxx_saturation_arithmetic 202311L
+# define __glibcxx_saturation_arithmetic 202603L
# if defined(__glibcxx_want_all) ||
defined(__glibcxx_want_saturation_arithmetic)
-# define __cpp_lib_saturation_arithmetic 202311L
+# define __cpp_lib_saturation_arithmetic 202603L
# endif
# endif
#endif /* !defined(__cpp_lib_saturation_arithmetic) */
diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/add.cc
b/libstdc++-v3/testsuite/26_numerics/saturation/add.cc
index 3eee6abca9a1..2695f7296112 100644
--- a/libstdc++-v3/testsuite/26_numerics/saturation/add.cc
+++ b/libstdc++-v3/testsuite/26_numerics/saturation/add.cc
@@ -7,67 +7,67 @@
template<typename T, typename U>
concept can_add_sat
- = requires(T t, U u) { { std::add_sat(t, u) } -> std::same_as<T>; };
+ = requires(T t, U u) { { std::saturating_add(t, u) } -> std::same_as<T>; };
static_assert( can_add_sat<int, int> );
static_assert( not can_add_sat<int, short> );
static_assert( not can_add_sat<unsigned, int> );
-static_assert( noexcept(std::add_sat(0, 0)) );
+static_assert( noexcept(std::saturating_add(0, 0)) );
-using std::add_sat;
+using std::saturating_add;
// Signed type
-static_assert(add_sat(0, 0) == 0);
-static_assert(add_sat(1, 1) == 2);
-static_assert(add_sat(-1, -1) == -2);
-static_assert(add_sat(-1, 1) == 0);
+static_assert(saturating_add(0, 0) == 0);
+static_assert(saturating_add(1, 1) == 2);
+static_assert(saturating_add(-1, -1) == -2);
+static_assert(saturating_add(-1, 1) == 0);
constexpr auto max = std::numeric_limits<int>::max();
constexpr auto min = std::numeric_limits<int>::min();
-static_assert(add_sat(max, 1) == max);
-static_assert(add_sat(1, max) == max);
-static_assert(add_sat(max, max) == max);
-static_assert(add_sat(min, -1) == min);
-static_assert(add_sat(-1, min) == min);
-static_assert(add_sat(min, min) == min);
-static_assert(add_sat(max, min) == -1);
-static_assert(add_sat(min, max) == -1);
+static_assert(saturating_add(max, 1) == max);
+static_assert(saturating_add(1, max) == max);
+static_assert(saturating_add(max, max) == max);
+static_assert(saturating_add(min, -1) == min);
+static_assert(saturating_add(-1, min) == min);
+static_assert(saturating_add(min, min) == min);
+static_assert(saturating_add(max, min) == -1);
+static_assert(saturating_add(min, max) == -1);
// Wider signed type than the args
-static_assert(add_sat<long long>(max, max) == (long long)max * 2);
-static_assert(add_sat<long long>(min, min) == (long long)min * 2);
+static_assert(saturating_add<long long>(max, max) == (long long)max * 2);
+static_assert(saturating_add<long long>(min, min) == (long long)min * 2);
// Signed type that undergoes integer promotion
constexpr auto shrt_max = std::numeric_limits<short>::max();
constexpr auto shrt_min = std::numeric_limits<short>::min();
-static_assert(add_sat<short>(0, 0) == 0);
-static_assert(add_sat<short>(1, 1) == 2);
-static_assert(add_sat<short>(shrt_max, shrt_max) == shrt_max);
-static_assert(add_sat<short>(shrt_max, 1) == shrt_max);
-static_assert(add_sat<short>(1, shrt_max) == shrt_max);
-static_assert(add_sat<short>(shrt_min, (short)-1) == shrt_min);
-static_assert(add_sat<short>((short)-1, shrt_min) == shrt_min);
-static_assert(add_sat<short>(shrt_min, (short)1) == -shrt_max);
-static_assert(add_sat<short>((short)1, shrt_min) == -shrt_max);
+static_assert(saturating_add<short>(0, 0) == 0);
+static_assert(saturating_add<short>(1, 1) == 2);
+static_assert(saturating_add<short>(shrt_max, shrt_max) == shrt_max);
+static_assert(saturating_add<short>(shrt_max, 1) == shrt_max);
+static_assert(saturating_add<short>(1, shrt_max) == shrt_max);
+static_assert(saturating_add<short>(shrt_min, (short)-1) == shrt_min);
+static_assert(saturating_add<short>((short)-1, shrt_min) == shrt_min);
+static_assert(saturating_add<short>(shrt_min, (short)1) == -shrt_max);
+static_assert(saturating_add<short>((short)1, shrt_min) == -shrt_max);
// Unsigned type
-static_assert(add_sat(0u, 0u) == 0u);
-static_assert(add_sat(1u, 1u) == 2u);
+static_assert(saturating_add(0u, 0u) == 0u);
+static_assert(saturating_add(1u, 1u) == 2u);
constexpr auto umax = std::numeric_limits<unsigned>::max();
-static_assert(add_sat(umax, 1u) == umax);
-static_assert(add_sat(1u, umax) == umax);
-static_assert(add_sat(umax, umax) == umax);
-static_assert(add_sat(0u, umax) == umax);
-static_assert(add_sat(umax, 0u) == umax);
-static_assert(add_sat(0u, 1u) == 1u);
-static_assert(add_sat(1u, 0u) == 1u);
+static_assert(saturating_add(umax, 1u) == umax);
+static_assert(saturating_add(1u, umax) == umax);
+static_assert(saturating_add(umax, umax) == umax);
+static_assert(saturating_add(0u, umax) == umax);
+static_assert(saturating_add(umax, 0u) == umax);
+static_assert(saturating_add(0u, 1u) == 1u);
+static_assert(saturating_add(1u, 0u) == 1u);
// Wider unsigned type than the args
-static_assert(add_sat<unsigned long long>(umax, umax) == (long long)umax * 2);
+static_assert(saturating_add<unsigned long long>(umax, umax) == (long
long)umax * 2);
// Unsigned type that undergoes integer promotion
constexpr auto ushrt_max = std::numeric_limits<unsigned short>::max();
-static_assert(add_sat<unsigned short>(0, 0) == 0);
-static_assert(add_sat<unsigned short>(1, 1) == 2);
-static_assert(add_sat<unsigned short>(ushrt_max, ushrt_max) == ushrt_max);
-static_assert(add_sat<unsigned short>(ushrt_max, 1) == ushrt_max);
-static_assert(add_sat<unsigned short>(1, ushrt_max) == ushrt_max);
+static_assert(saturating_add<unsigned short>(0, 0) == 0);
+static_assert(saturating_add<unsigned short>(1, 1) == 2);
+static_assert(saturating_add<unsigned short>(ushrt_max, ushrt_max) ==
ushrt_max);
+static_assert(saturating_add<unsigned short>(ushrt_max, 1) == ushrt_max);
+static_assert(saturating_add<unsigned short>(1, ushrt_max) == ushrt_max);
diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/cast.cc
b/libstdc++-v3/testsuite/26_numerics/saturation/cast.cc
index 672e9c46be1c..e23d727bdb68 100644
--- a/libstdc++-v3/testsuite/26_numerics/saturation/cast.cc
+++ b/libstdc++-v3/testsuite/26_numerics/saturation/cast.cc
@@ -6,19 +6,19 @@
#include <climits>
#if CHAR_BIT == 8
-static_assert(std::saturate_cast<unsigned char>(999) == 255);
-static_assert(std::saturate_cast<signed char>(999) == 127);
+static_assert(std::saturating_cast<unsigned char>(999) == 255);
+static_assert(std::saturating_cast<signed char>(999) == 127);
#endif
-static_assert(std::saturate_cast<unsigned short>(999) == 999);
-static_assert(std::saturate_cast<signed short>(999) == 999);
-static_assert(std::saturate_cast<short>(INT_MAX) == SHRT_MAX);
-static_assert(std::saturate_cast<short>(UINT_MAX) == SHRT_MAX);
-static_assert(std::saturate_cast<short>(UINT_MAX) == SHRT_MAX);
-static_assert(std::saturate_cast<unsigned short>(UINT_MAX) == USHRT_MAX);
-static_assert(std::saturate_cast<int>(UINT_MAX) == INT_MAX);
-static_assert(std::saturate_cast<int>(INT_MAX) == INT_MAX);
-static_assert(std::saturate_cast<unsigned>(-1) == 0);
-static_assert(std::saturate_cast<unsigned>(INT_MIN) == 0);
-static_assert(std::saturate_cast<unsigned>(UINT_MAX) == UINT_MAX);
-static_assert(std::saturate_cast<unsigned>(LLONG_MAX) == UINT_MAX);
-static_assert(std::saturate_cast<unsigned>(ULLONG_MAX) == UINT_MAX);
+static_assert(std::saturating_cast<unsigned short>(999) == 999);
+static_assert(std::saturating_cast<signed short>(999) == 999);
+static_assert(std::saturating_cast<short>(INT_MAX) == SHRT_MAX);
+static_assert(std::saturating_cast<short>(UINT_MAX) == SHRT_MAX);
+static_assert(std::saturating_cast<short>(UINT_MAX) == SHRT_MAX);
+static_assert(std::saturating_cast<unsigned short>(UINT_MAX) == USHRT_MAX);
+static_assert(std::saturating_cast<int>(UINT_MAX) == INT_MAX);
+static_assert(std::saturating_cast<int>(INT_MAX) == INT_MAX);
+static_assert(std::saturating_cast<unsigned>(-1) == 0);
+static_assert(std::saturating_cast<unsigned>(INT_MIN) == 0);
+static_assert(std::saturating_cast<unsigned>(UINT_MAX) == UINT_MAX);
+static_assert(std::saturating_cast<unsigned>(LLONG_MAX) == UINT_MAX);
+static_assert(std::saturating_cast<unsigned>(ULLONG_MAX) == UINT_MAX);
diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/div.cc
b/libstdc++-v3/testsuite/26_numerics/saturation/div.cc
index a3f43573651a..71d4970d632d 100644
--- a/libstdc++-v3/testsuite/26_numerics/saturation/div.cc
+++ b/libstdc++-v3/testsuite/26_numerics/saturation/div.cc
@@ -7,32 +7,32 @@
template<typename T, typename U>
concept can_div_sat
- = requires(T t, U u) { { std::div_sat(t, u) } -> std::same_as<T>; };
+ = requires(T t, U u) { { std::saturating_div(t, u) } -> std::same_as<T>; };
static_assert( can_div_sat<int, int> );
static_assert( not can_div_sat<int, short> );
static_assert( not can_div_sat<unsigned, int> );
-static_assert( noexcept(std::div_sat(0, 1)) );
+static_assert( noexcept(std::saturating_div(0, 1)) );
-using std::div_sat;
+using std::saturating_div;
-static_assert(std::div_sat(0, 1) == 0);
-static_assert(std::div_sat(0, -1) == 0);
-static_assert(std::div_sat(1, -1) == -1);
-static_assert(std::div_sat(10, -2) == -5);
-static_assert(std::div_sat(-10, -2) == 5);
-static_assert(std::div_sat(INT_MAX, 1) == INT_MAX);
-static_assert(std::div_sat(INT_MIN, 1) == INT_MIN);
-static_assert(std::div_sat(INT_MIN + 1, -1) == INT_MAX);
-static_assert(std::div_sat(0u, 1u) == 0u);
-static_assert(std::div_sat(UINT_MAX, 1u) == UINT_MAX);
-static_assert(std::div_sat(INT_MIN, -1) == INT_MAX);
-static_assert(std::div_sat((short)SHRT_MIN, (short)-1) == SHRT_MAX);
-static_assert(std::div_sat(LONG_MIN, -1L) == LONG_MAX);
-static_assert(std::div_sat(LLONG_MIN, -1LL) == LLONG_MAX);
+static_assert(std::saturating_div(0, 1) == 0);
+static_assert(std::saturating_div(0, -1) == 0);
+static_assert(std::saturating_div(1, -1) == -1);
+static_assert(std::saturating_div(10, -2) == -5);
+static_assert(std::saturating_div(-10, -2) == 5);
+static_assert(std::saturating_div(INT_MAX, 1) == INT_MAX);
+static_assert(std::saturating_div(INT_MIN, 1) == INT_MIN);
+static_assert(std::saturating_div(INT_MIN + 1, -1) == INT_MAX);
+static_assert(std::saturating_div(0u, 1u) == 0u);
+static_assert(std::saturating_div(UINT_MAX, 1u) == UINT_MAX);
+static_assert(std::saturating_div(INT_MIN, -1) == INT_MAX);
+static_assert(std::saturating_div((short)SHRT_MIN, (short)-1) == SHRT_MAX);
+static_assert(std::saturating_div(LONG_MIN, -1L) == LONG_MAX);
+static_assert(std::saturating_div(LLONG_MIN, -1LL) == LLONG_MAX);
template<auto N>
-std::integral_constant<decltype(N), std::div_sat(N, N-N)>
+std::integral_constant<decltype(N), std::saturating_div(N, N-N)>
div_sat_by_zero();
template<auto N>
diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/extended.cc
b/libstdc++-v3/testsuite/26_numerics/saturation/extended.cc
index fbef62826c23..8095a32d01f2 100644
--- a/libstdc++-v3/testsuite/26_numerics/saturation/extended.cc
+++ b/libstdc++-v3/testsuite/26_numerics/saturation/extended.cc
@@ -14,22 +14,22 @@ test()
constexpr S smin = std::numeric_limits<S>::min();
constexpr U umax = std::numeric_limits<U>::max();
- static_assert( std::add_sat(smax, (S)1) == smax );
- static_assert( std::add_sat(smin, (S)-2) == smin );
- static_assert( std::add_sat(umax, (U)3) == umax );
+ static_assert( std::saturating_add(smax, (S)1) == smax );
+ static_assert( std::saturating_add(smin, (S)-2) == smin );
+ static_assert( std::saturating_add(umax, (U)3) == umax );
- static_assert( std::sub_sat(smax, (S)-1) == smax );
- static_assert( std::sub_sat(smin, (S)2) == smin );
- static_assert( std::sub_sat((U)0, (U)3) == (U)0 );
+ static_assert( std::saturating_sub(smax, (S)-1) == smax );
+ static_assert( std::saturating_sub(smin, (S)2) == smin );
+ static_assert( std::saturating_sub((U)0, (U)3) == (U)0 );
- static_assert( std::mul_sat((S)(smax >> 1), (S)3) == smax );
- static_assert( std::mul_sat((S)(smin >> 1), (S)5) == smin );
- static_assert( std::mul_sat((U)(umax >> 1), (U)7) == umax );
+ static_assert( std::saturating_mul((S)(smax >> 1), (S)3) == smax );
+ static_assert( std::saturating_mul((S)(smin >> 1), (S)5) == smin );
+ static_assert( std::saturating_mul((U)(umax >> 1), (U)7) == umax );
- static_assert( std::div_sat(smax, (S)2) == (smax >> 1) );
- static_assert( std::div_sat(smin, (S)4) == (smin >> 2) );
- static_assert( std::div_sat(smin, (S)-1) == smax );
- static_assert( std::div_sat(umax, (U)8) == (umax >> 3) );
+ static_assert( std::saturating_div(smax, (S)2) == (smax >> 1) );
+ static_assert( std::saturating_div(smin, (S)4) == (smin >> 2) );
+ static_assert( std::saturating_div(smin, (S)-1) == smax );
+ static_assert( std::saturating_div(umax, (U)8) == (umax >> 3) );
return true;
}
diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/mul.cc
b/libstdc++-v3/testsuite/26_numerics/saturation/mul.cc
index 1b5538c9af3b..ea8ca2e76522 100644
--- a/libstdc++-v3/testsuite/26_numerics/saturation/mul.cc
+++ b/libstdc++-v3/testsuite/26_numerics/saturation/mul.cc
@@ -7,28 +7,28 @@
template<typename T, typename U>
concept can_mul_sat
- = requires(T t, U u) { { std::mul_sat(t, u) } -> std::same_as<T>; };
+ = requires(T t, U u) { { std::saturating_mul(t, u) } -> std::same_as<T>; };
static_assert( can_mul_sat<int, int> );
static_assert( not can_mul_sat<int, short> );
static_assert( not can_mul_sat<unsigned, int> );
-static_assert( noexcept(std::mul_sat(0, 0)) );
+static_assert( noexcept(std::saturating_mul(0, 0)) );
-using std::mul_sat;
+using std::saturating_mul;
-static_assert(mul_sat(1, 1) == 1);
-static_assert(mul_sat(10, 11) == 110);
-static_assert(mul_sat(INT_MAX / 2, 3) == INT_MAX);
-static_assert(mul_sat(INT_MAX / 2, -3) == INT_MIN);
-static_assert(mul_sat(INT_MAX / -2, 3) == INT_MIN);
-static_assert(mul_sat(INT_MIN / 2, -3) == INT_MAX);
-static_assert(mul_sat(INT_MIN, -1) == INT_MAX);
-static_assert(mul_sat(INT_MAX, -1) == INT_MIN + 1);
-static_assert(mul_sat(INT_MAX, INT_MAX) == INT_MAX);
-static_assert(mul_sat(INT_MAX, -INT_MAX) == INT_MIN);
-static_assert(mul_sat(UINT_MAX, UINT_MAX) == UINT_MAX);
-static_assert(mul_sat(UINT_MAX, 0u) == 0);
-static_assert(mul_sat(0u, UINT_MAX) == 0);
-static_assert(mul_sat((short)SHRT_MAX, (short)2) == SHRT_MAX);
-static_assert(mul_sat((short)SHRT_MAX, (short)SHRT_MIN) == SHRT_MIN);
-static_assert(mul_sat<long long>(SHRT_MAX, 2) == 2L * SHRT_MAX);
+static_assert(saturating_mul(1, 1) == 1);
+static_assert(saturating_mul(10, 11) == 110);
+static_assert(saturating_mul(INT_MAX / 2, 3) == INT_MAX);
+static_assert(saturating_mul(INT_MAX / 2, -3) == INT_MIN);
+static_assert(saturating_mul(INT_MAX / -2, 3) == INT_MIN);
+static_assert(saturating_mul(INT_MIN / 2, -3) == INT_MAX);
+static_assert(saturating_mul(INT_MIN, -1) == INT_MAX);
+static_assert(saturating_mul(INT_MAX, -1) == INT_MIN + 1);
+static_assert(saturating_mul(INT_MAX, INT_MAX) == INT_MAX);
+static_assert(saturating_mul(INT_MAX, -INT_MAX) == INT_MIN);
+static_assert(saturating_mul(UINT_MAX, UINT_MAX) == UINT_MAX);
+static_assert(saturating_mul(UINT_MAX, 0u) == 0);
+static_assert(saturating_mul(0u, UINT_MAX) == 0);
+static_assert(saturating_mul((short)SHRT_MAX, (short)2) == SHRT_MAX);
+static_assert(saturating_mul((short)SHRT_MAX, (short)SHRT_MIN) == SHRT_MIN);
+static_assert(saturating_mul<long long>(SHRT_MAX, 2) == 2L * SHRT_MAX);
diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/sub.cc
b/libstdc++-v3/testsuite/26_numerics/saturation/sub.cc
index c56154a49ff5..8b2eabc280af 100644
--- a/libstdc++-v3/testsuite/26_numerics/saturation/sub.cc
+++ b/libstdc++-v3/testsuite/26_numerics/saturation/sub.cc
@@ -7,80 +7,80 @@
template<typename T, typename U>
concept can_sub_sat
- = requires(T t, U u) { { std::sub_sat(t, u) } -> std::same_as<T>; };
+ = requires(T t, U u) { { std::saturating_sub(t, u) } -> std::same_as<T>; };
static_assert( can_sub_sat<int, int> );
static_assert( not can_sub_sat<int, short> );
static_assert( not can_sub_sat<unsigned, int> );
-static_assert( noexcept(std::sub_sat(0, 0)) );
+static_assert( noexcept(std::saturating_sub(0, 0)) );
-using std::sub_sat;
+using std::saturating_sub;
// Signed type
-static_assert(sub_sat(0, 0) == 0);
-static_assert(sub_sat(1, 1) == 0);
-static_assert(sub_sat(-1, -1) == 0);
-static_assert(sub_sat(-1, 1) == -2);
+static_assert(saturating_sub(0, 0) == 0);
+static_assert(saturating_sub(1, 1) == 0);
+static_assert(saturating_sub(-1, -1) == 0);
+static_assert(saturating_sub(-1, 1) == -2);
constexpr auto max = std::numeric_limits<int>::max();
constexpr auto min = std::numeric_limits<int>::min();
-static_assert(sub_sat(max, 1) == max - 1);
-static_assert(sub_sat(1, max) == 1 - max);
-static_assert(sub_sat(max, max) == 0);
-static_assert(sub_sat(min, 1) == min);
-static_assert(sub_sat(min, 123) == min);
-static_assert(sub_sat(0, max) == min + 1);
-static_assert(sub_sat(-1, max) == min);
-static_assert(sub_sat(-2, max) == min);
-static_assert(sub_sat(-2, min) == max - 1);
-static_assert(sub_sat(-1, min) == max);
-static_assert(sub_sat(0, min) == max);
-static_assert(sub_sat(1, min) == max);
-static_assert(sub_sat(min, -1) == min + 1);
-static_assert(sub_sat(min, min) == 0);
-static_assert(sub_sat(max, min) == max);
-static_assert(sub_sat(min, max) == min);
+static_assert(saturating_sub(max, 1) == max - 1);
+static_assert(saturating_sub(1, max) == 1 - max);
+static_assert(saturating_sub(max, max) == 0);
+static_assert(saturating_sub(min, 1) == min);
+static_assert(saturating_sub(min, 123) == min);
+static_assert(saturating_sub(0, max) == min + 1);
+static_assert(saturating_sub(-1, max) == min);
+static_assert(saturating_sub(-2, max) == min);
+static_assert(saturating_sub(-2, min) == max - 1);
+static_assert(saturating_sub(-1, min) == max);
+static_assert(saturating_sub(0, min) == max);
+static_assert(saturating_sub(1, min) == max);
+static_assert(saturating_sub(min, -1) == min + 1);
+static_assert(saturating_sub(min, min) == 0);
+static_assert(saturating_sub(max, min) == max);
+static_assert(saturating_sub(min, max) == min);
// Wider signed type than the args
-static_assert(sub_sat<long long>(max, min) == (long long)max * 2 + 1);
-static_assert(sub_sat<long long>(min, max) == (long long)min * 2 + 1);
+static_assert(saturating_sub<long long>(max, min) == (long long)max * 2 + 1);
+static_assert(saturating_sub<long long>(min, max) == (long long)min * 2 + 1);
// Signed type that undergoes integer promotion
constexpr auto shrt_max = std::numeric_limits<short>::max();
constexpr auto shrt_min = std::numeric_limits<short>::min();
-static_assert(sub_sat<short>(0, 0) == 0);
-static_assert(sub_sat<short>(1, 1) == 0);
-static_assert(sub_sat<short>(3, 1) == 2);
-static_assert(sub_sat<short>(shrt_max, shrt_max) == 0);
-static_assert(sub_sat<short>(shrt_max, 1) == shrt_max - 1);
-static_assert(sub_sat<short>(1, shrt_max) == shrt_min + 2);
-static_assert(sub_sat<short>(shrt_max, shrt_min) == shrt_max);
-static_assert(sub_sat<short>(0, shrt_min) == shrt_max);
-static_assert(sub_sat<short>(shrt_min, (short)1) == shrt_min);
-static_assert(sub_sat<short>(shrt_min, (short)-1) == shrt_min + 1);
-static_assert(sub_sat<short>((short)-1, shrt_min) == shrt_max);
-static_assert(sub_sat<short>((short)1, shrt_min) == shrt_max);
+static_assert(saturating_sub<short>(0, 0) == 0);
+static_assert(saturating_sub<short>(1, 1) == 0);
+static_assert(saturating_sub<short>(3, 1) == 2);
+static_assert(saturating_sub<short>(shrt_max, shrt_max) == 0);
+static_assert(saturating_sub<short>(shrt_max, 1) == shrt_max - 1);
+static_assert(saturating_sub<short>(1, shrt_max) == shrt_min + 2);
+static_assert(saturating_sub<short>(shrt_max, shrt_min) == shrt_max);
+static_assert(saturating_sub<short>(0, shrt_min) == shrt_max);
+static_assert(saturating_sub<short>(shrt_min, (short)1) == shrt_min);
+static_assert(saturating_sub<short>(shrt_min, (short)-1) == shrt_min + 1);
+static_assert(saturating_sub<short>((short)-1, shrt_min) == shrt_max);
+static_assert(saturating_sub<short>((short)1, shrt_min) == shrt_max);
// Unsigned type
-static_assert(sub_sat(0u, 0u) == 0u);
-static_assert(sub_sat(1u, 1u) == 0u);
-static_assert(sub_sat(-1u, -1u) == 0u);
-static_assert(sub_sat(-1u, 1u) == -2u);
+static_assert(saturating_sub(0u, 0u) == 0u);
+static_assert(saturating_sub(1u, 1u) == 0u);
+static_assert(saturating_sub(-1u, -1u) == 0u);
+static_assert(saturating_sub(-1u, 1u) == -2u);
constexpr auto umax = std::numeric_limits<unsigned>::max();
-static_assert(sub_sat(0u, 1u) == 0u);
-static_assert(sub_sat(umax, umax) == 0u);
-static_assert(sub_sat(umax, 0u) == umax);
-static_assert(sub_sat(0u, umax) == 0u);
-static_assert(sub_sat(umax, 1u) == umax - 1u);
-static_assert(sub_sat(0u, 0u) == 0u);
+static_assert(saturating_sub(0u, 1u) == 0u);
+static_assert(saturating_sub(umax, umax) == 0u);
+static_assert(saturating_sub(umax, 0u) == umax);
+static_assert(saturating_sub(0u, umax) == 0u);
+static_assert(saturating_sub(umax, 1u) == umax - 1u);
+static_assert(saturating_sub(0u, 0u) == 0u);
// Wider unsigned type than the args
-static_assert(sub_sat<unsigned long long>(0u, umax) == 0u);
+static_assert(saturating_sub<unsigned long long>(0u, umax) == 0u);
// Unsigned type that undergoes integer promotion
constexpr auto ushrt_max = std::numeric_limits<unsigned short>::max();
-static_assert(sub_sat<unsigned short>(0, 0) == 0);
-static_assert(sub_sat<unsigned short>(1, 1) == 0);
-static_assert(sub_sat<unsigned short>(3, 1) == 2);
-static_assert(sub_sat<unsigned short>(ushrt_max, ushrt_max) == 0);
-static_assert(sub_sat<unsigned short>(0, 1) == 0);
-static_assert(sub_sat<unsigned short>(1, ushrt_max) == 0);
+static_assert(saturating_sub<unsigned short>(0, 0) == 0);
+static_assert(saturating_sub<unsigned short>(1, 1) == 0);
+static_assert(saturating_sub<unsigned short>(3, 1) == 2);
+static_assert(saturating_sub<unsigned short>(ushrt_max, ushrt_max) == 0);
+static_assert(saturating_sub<unsigned short>(0, 1) == 0);
+static_assert(saturating_sub<unsigned short>(1, ushrt_max) == 0);
diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/version.cc
b/libstdc++-v3/testsuite/26_numerics/saturation/version.cc
index ca94ef1212a2..7b08820b5984 100644
--- a/libstdc++-v3/testsuite/26_numerics/saturation/version.cc
+++ b/libstdc++-v3/testsuite/26_numerics/saturation/version.cc
@@ -5,7 +5,7 @@
#ifndef __cpp_lib_saturation_arithmetic
# error "Feature test macro for saturation arithmetic is missing in <numeric>"
-#elif __cpp_lib_saturation_arithmetic < 202311L
+#elif __cpp_lib_saturation_arithmetic < 202603L
# error "Feature test macro for saturation arithmetic has wrong value in
<numeric>"
#endif
@@ -14,6 +14,6 @@
#ifndef __cpp_lib_saturation_arithmetic
# error "Feature test macro for saturation arithmetic is missing in <version>"
-#elif __cpp_lib_saturation_arithmetic < 202311L
+#elif __cpp_lib_saturation_arithmetic < 202603L
# error "Feature test macro for saturation arithmetic has wrong value in
<version>"
#endif
--
2.53.0
