On Wed, Apr 1, 2026 at 12:07 PM Jonathan Wakely <[email protected]> wrote:
> 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.
>
LGTM
>
> 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
>
>
