mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2024-11-23 05:40:09 +00:00
[libc++][numeric] P0543R3: Saturation arithmetic (#77967)
Implements: https://wg21.link/P0543R3 - https://eel.is/c++draft/numeric.sat Additional references: - Division: https://eel.is/c++draft/expr.mul#4 - Arithmetic conversions: https://eel.is/c++draft/expr.arith.conv#1 - Clang builtins: https://clang.llvm.org/docs/LanguageExtensions.html#builtin-functions Depends on: https://github.com/llvm/llvm-project/pull/78086 --------- Co-authored-by: Zingam <zingam@outlook.com> Co-authored-by: Mark de Wever <zar-rpg@xs4all.nl>
This commit is contained in:
Hristo Hristov
GitHub
parent
85337df9e3
commit
03c19e91e8
@ -432,7 +432,7 @@ Status
|
||||
--------------------------------------------------- -----------------
|
||||
``__cpp_lib_rcu`` *unimplemented*
|
||||
--------------------------------------------------- -----------------
|
||||
``__cpp_lib_saturation_arithmetic`` *unimplemented*
|
||||
``__cpp_lib_saturation_arithmetic`` ``202311L``
|
||||
--------------------------------------------------- -----------------
|
||||
``__cpp_lib_smart_ptr_owner_equality`` *unimplemented*
|
||||
--------------------------------------------------- -----------------
|
||||
|
||||
@ -75,6 +75,7 @@ Implemented Papers
|
||||
- P2909R4 - Fix formatting of code units as integers (Dude, where’s my ``char``?)
|
||||
- P2821R5 - ``span.at()``
|
||||
- P0521R0 - Proposed Resolution for CA 14 (``shared_ptr`` ``use_count/unique``)
|
||||
- P0543R3 - Saturation arithmetic
|
||||
- P1759R6 - Native handles and file streams
|
||||
- P2868R3 - Remove Deprecated ``std::allocator`` Typedef From C++26
|
||||
- P2517R1 - Add a conditional ``noexcept`` specification to ``std::apply``
|
||||
|
||||
@ -27,7 +27,7 @@
|
||||
"`P2714R1 <https://wg21.link/P2714R1>`__","LWG","Bind front and back to NTTP callables","Varna June 2023","","",""
|
||||
"`P2630R4 <https://wg21.link/P2630R4>`__","LWG","``submdspan``","Varna June 2023","","",""
|
||||
"","","","","","",""
|
||||
"`P0543R3 <https://wg21.link/P0543R3>`__","LWG","Saturation arithmetic","Kona November 2023","","",""
|
||||
"`P0543R3 <https://wg21.link/P0543R3>`__","LWG","Saturation arithmetic","Kona November 2023","|Complete|","18.0",""
|
||||
"`P2407R5 <https://wg21.link/P2407R5>`__","LWG","Freestanding Library: Partial Classes","Kona November 2023","","",""
|
||||
"`P2546R5 <https://wg21.link/P2546R5>`__","LWG","Debugging Support","Kona November 2023","","",""
|
||||
"`P2905R2 <https://wg21.link/P2905R2>`__","LWG","Runtime format strings","Kona November 2023","|Complete|","18.0","|format| |DR|"
|
||||
|
||||
|
@ -569,6 +569,7 @@ set(files
|
||||
__numeric/pstl_reduce.h
|
||||
__numeric/pstl_transform_reduce.h
|
||||
__numeric/reduce.h
|
||||
__numeric/saturation_arithmetic.h
|
||||
__numeric/transform_exclusive_scan.h
|
||||
__numeric/transform_inclusive_scan.h
|
||||
__numeric/transform_reduce.h
|
||||
|
||||
110
libcxx/include/__numeric/saturation_arithmetic.h
Normal file
110
libcxx/include/__numeric/saturation_arithmetic.h
Normal file
@ -0,0 +1,110 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___NUMERIC_SATURATION_ARITHMETIC_H
|
||||
#define _LIBCPP___NUMERIC_SATURATION_ARITHMETIC_H
|
||||
|
||||
#include <__concepts/arithmetic.h>
|
||||
#include <__config>
|
||||
#include <__utility/cmp.h>
|
||||
#include <limits>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
# pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
#if _LIBCPP_STD_VER >= 26
|
||||
|
||||
template <__libcpp_integer _Tp>
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr _Tp add_sat(_Tp __x, _Tp __y) noexcept {
|
||||
if (_Tp __sum; !__builtin_add_overflow(__x, __y, &__sum))
|
||||
return __sum;
|
||||
// Handle overflow
|
||||
if constexpr (__libcpp_unsigned_integer<_Tp>) {
|
||||
return std::numeric_limits<_Tp>::max();
|
||||
} else {
|
||||
// Signed addition overflow
|
||||
if (__x > 0)
|
||||
// Overflows if (x > 0 && y > 0)
|
||||
return std::numeric_limits<_Tp>::max();
|
||||
else
|
||||
// Overflows if (x < 0 && y < 0)
|
||||
return std::numeric_limits<_Tp>::min();
|
||||
}
|
||||
}
|
||||
|
||||
template <__libcpp_integer _Tp>
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr _Tp sub_sat(_Tp __x, _Tp __y) noexcept {
|
||||
if (_Tp __sub; !__builtin_sub_overflow(__x, __y, &__sub))
|
||||
return __sub;
|
||||
// Handle overflow
|
||||
if constexpr (__libcpp_unsigned_integer<_Tp>) {
|
||||
// Overflows if (x < y)
|
||||
return std::numeric_limits<_Tp>::min();
|
||||
} else {
|
||||
// Signed subtration overflow
|
||||
if (__x >= 0)
|
||||
// Overflows if (x >= 0 && y < 0)
|
||||
return std::numeric_limits<_Tp>::max();
|
||||
else
|
||||
// Overflows if (x < 0 && y > 0)
|
||||
return std::numeric_limits<_Tp>::min();
|
||||
}
|
||||
}
|
||||
|
||||
template <__libcpp_integer _Tp>
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr _Tp mul_sat(_Tp __x, _Tp __y) noexcept {
|
||||
if (_Tp __mul; !__builtin_mul_overflow(__x, __y, &__mul))
|
||||
return __mul;
|
||||
// Handle overflow
|
||||
if constexpr (__libcpp_unsigned_integer<_Tp>) {
|
||||
return std::numeric_limits<_Tp>::max();
|
||||
} else {
|
||||
// Signed multiplication overflow
|
||||
if ((__x > 0 && __y > 0) || (__x < 0 && __y < 0))
|
||||
return std::numeric_limits<_Tp>::max();
|
||||
// Overflows if (x < 0 && y > 0) || (x > 0 && y < 0)
|
||||
return std::numeric_limits<_Tp>::min();
|
||||
}
|
||||
}
|
||||
|
||||
template <__libcpp_integer _Tp>
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr _Tp div_sat(_Tp __x, _Tp __y) noexcept {
|
||||
_LIBCPP_ASSERT_UNCATEGORIZED(__y != 0, "Division by 0 is undefined");
|
||||
if constexpr (__libcpp_unsigned_integer<_Tp>) {
|
||||
return __x / __y;
|
||||
} else {
|
||||
// Handle signed division overflow
|
||||
if (__x == std::numeric_limits<_Tp>::min() && __y == _Tp{-1})
|
||||
return std::numeric_limits<_Tp>::max();
|
||||
return __x / __y;
|
||||
}
|
||||
}
|
||||
|
||||
template <__libcpp_integer _Rp, __libcpp_integer _Tp>
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr _Rp saturate_cast(_Tp __x) noexcept {
|
||||
// Saturation is impossible edge case when ((min _Rp) < (min _Tp) && (max _Rp) > (max _Tp)) and it is expected to be
|
||||
// optimized out by the compiler.
|
||||
|
||||
// Handle overflow
|
||||
if (std::cmp_less(__x, std::numeric_limits<_Rp>::min()))
|
||||
return std::numeric_limits<_Rp>::min();
|
||||
if (std::cmp_greater(__x, std::numeric_limits<_Rp>::max()))
|
||||
return std::numeric_limits<_Rp>::max();
|
||||
// No overflow
|
||||
return static_cast<_Rp>(__x);
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_STD_VER >= 26
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP___NUMERIC_SATURATION_ARITHMETIC_H
|
||||
@ -559,6 +559,7 @@
|
||||
{ include: [ "<__numeric/pstl_reduce.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/pstl_transform_reduce.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/reduce.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/saturation_arithmetic.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/transform_exclusive_scan.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/transform_inclusive_scan.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/transform_reduce.h>", "private", "<numeric>", "public" ] },
|
||||
|
||||
@ -1580,6 +1580,7 @@ module std_private_numeric_pstl_transform_reduce [system] {
|
||||
export *
|
||||
}
|
||||
module std_private_numeric_reduce [system] { header "__numeric/reduce.h" }
|
||||
module std_private_numeric_saturation_arithmetic [system] { header "__numeric/saturation_arithmetic.h" }
|
||||
module std_private_numeric_transform_exclusive_scan [system] { header "__numeric/transform_exclusive_scan.h" }
|
||||
module std_private_numeric_transform_inclusive_scan [system] { header "__numeric/transform_inclusive_scan.h" }
|
||||
module std_private_numeric_transform_reduce [system] { header "__numeric/transform_reduce.h" }
|
||||
|
||||
@ -140,6 +140,18 @@ template<class T>
|
||||
template<class T>
|
||||
constexpr T* midpoint(T* a, T* b); // C++20
|
||||
|
||||
// [numeric.sat], saturation arithmetic
|
||||
template<class T>
|
||||
constexpr T add_sat(T x, T y) noexcept; // freestanding, Since C++26
|
||||
template<class T>
|
||||
constexpr T sub_sat(T x, T y) noexcept; // freestanding, Since C++26
|
||||
template<class T>
|
||||
constexpr T mul_sat(T x, T y) noexcept; // freestanding, Since C++26
|
||||
template<class T>
|
||||
constexpr T div_sat(T x, T y) noexcept; // freestanding, Since C++26
|
||||
template<class T, class U>
|
||||
constexpr T saturate_cast(U x) noexcept; // freestanding, Since C++26
|
||||
|
||||
} // std
|
||||
|
||||
*/
|
||||
@ -160,6 +172,7 @@ template<class T>
|
||||
#include <__numeric/pstl_reduce.h>
|
||||
#include <__numeric/pstl_transform_reduce.h>
|
||||
#include <__numeric/reduce.h>
|
||||
#include <__numeric/saturation_arithmetic.h>
|
||||
#include <__numeric/transform_exclusive_scan.h>
|
||||
#include <__numeric/transform_inclusive_scan.h>
|
||||
#include <__numeric/transform_reduce.h>
|
||||
|
||||
@ -504,7 +504,7 @@ __cpp_lib_within_lifetime 202306L <type_traits>
|
||||
// # define __cpp_lib_out_ptr 202311L
|
||||
# define __cpp_lib_ratio 202306L
|
||||
// # define __cpp_lib_rcu 202306L
|
||||
// # define __cpp_lib_saturation_arithmetic 202311L
|
||||
# define __cpp_lib_saturation_arithmetic 202311L
|
||||
// # define __cpp_lib_smart_ptr_owner_equality 202306L
|
||||
# define __cpp_lib_span_at 202311L
|
||||
# define __cpp_lib_span_initializer_list 202311L
|
||||
|
||||
@ -54,4 +54,14 @@ export namespace std {
|
||||
|
||||
// [numeric.ops.midpoint], midpoint
|
||||
using std::midpoint;
|
||||
|
||||
#if _LIBCPP_STD_VER >= 26
|
||||
// [numeric.sat], saturation arithmetic
|
||||
using std::add_sat;
|
||||
using std::div_sat;
|
||||
using std::mul_sat;
|
||||
using std::saturate_cast;
|
||||
using std::sub_sat;
|
||||
#endif
|
||||
|
||||
} // namespace std
|
||||
|
||||
@ -263,17 +263,11 @@
|
||||
# endif
|
||||
# endif
|
||||
|
||||
# if !defined(_LIBCPP_VERSION)
|
||||
# ifndef __cpp_lib_saturation_arithmetic
|
||||
# error "__cpp_lib_saturation_arithmetic should be defined in c++26"
|
||||
# endif
|
||||
# if __cpp_lib_saturation_arithmetic != 202311L
|
||||
# error "__cpp_lib_saturation_arithmetic should have the value 202311L in c++26"
|
||||
# endif
|
||||
# else // _LIBCPP_VERSION
|
||||
# ifdef __cpp_lib_saturation_arithmetic
|
||||
# error "__cpp_lib_saturation_arithmetic should not be defined because it is unimplemented in libc++!"
|
||||
# endif
|
||||
# ifndef __cpp_lib_saturation_arithmetic
|
||||
# error "__cpp_lib_saturation_arithmetic should be defined in c++26"
|
||||
# endif
|
||||
# if __cpp_lib_saturation_arithmetic != 202311L
|
||||
# error "__cpp_lib_saturation_arithmetic should have the value 202311L in c++26"
|
||||
# endif
|
||||
|
||||
#endif // TEST_STD_VER > 23
|
||||
|
||||
@ -7167,17 +7167,11 @@
|
||||
# error "__cpp_lib_sample should have the value 201603L in c++26"
|
||||
# endif
|
||||
|
||||
# if !defined(_LIBCPP_VERSION)
|
||||
# ifndef __cpp_lib_saturation_arithmetic
|
||||
# error "__cpp_lib_saturation_arithmetic should be defined in c++26"
|
||||
# endif
|
||||
# if __cpp_lib_saturation_arithmetic != 202311L
|
||||
# error "__cpp_lib_saturation_arithmetic should have the value 202311L in c++26"
|
||||
# endif
|
||||
# else // _LIBCPP_VERSION
|
||||
# ifdef __cpp_lib_saturation_arithmetic
|
||||
# error "__cpp_lib_saturation_arithmetic should not be defined because it is unimplemented in libc++!"
|
||||
# endif
|
||||
# ifndef __cpp_lib_saturation_arithmetic
|
||||
# error "__cpp_lib_saturation_arithmetic should be defined in c++26"
|
||||
# endif
|
||||
# if __cpp_lib_saturation_arithmetic != 202311L
|
||||
# error "__cpp_lib_saturation_arithmetic should have the value 202311L in c++26"
|
||||
# endif
|
||||
|
||||
# ifndef __cpp_lib_scoped_lock
|
||||
|
||||
@ -0,0 +1,77 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class T>
|
||||
// constexpr T add_sat(T x, T y) noexcept; // freestanding
|
||||
|
||||
#include <concepts>
|
||||
#include <numeric>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T, typename U>
|
||||
concept CanDo = requires(T x, U y) {
|
||||
{ std::add_sat(x, y) } -> std::same_as<T>;
|
||||
};
|
||||
|
||||
template <typename T, typename U>
|
||||
constexpr void test_constraint_success() {
|
||||
static_assert(CanDo<T, T>);
|
||||
static_assert(!CanDo<U, T>);
|
||||
static_assert(!CanDo<T, U>);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr void test_constraint_fail() {
|
||||
using I = int;
|
||||
static_assert(!CanDo<T, T>);
|
||||
static_assert(!CanDo<I, T>);
|
||||
static_assert(!CanDo<T, I>);
|
||||
}
|
||||
|
||||
constexpr void test() {
|
||||
// Contraint success - Signed
|
||||
using SI = long long int;
|
||||
test_constraint_success<signed char, SI>();
|
||||
test_constraint_success<short int, SI>();
|
||||
test_constraint_success<signed char, SI>();
|
||||
test_constraint_success<short int, SI>();
|
||||
test_constraint_success<int, SI>();
|
||||
test_constraint_success<long int, SI>();
|
||||
test_constraint_success<long long int, int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_success<__int128_t, SI>();
|
||||
#endif
|
||||
// Contraint success - Unsigned
|
||||
using UI = unsigned long long int;
|
||||
test_constraint_success<unsigned char, UI>();
|
||||
test_constraint_success<unsigned short int, UI>();
|
||||
test_constraint_success<unsigned int, UI>();
|
||||
test_constraint_success<unsigned long int, UI>();
|
||||
test_constraint_success<unsigned long long int, unsigned int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_success<__uint128_t, UI>();
|
||||
#endif
|
||||
|
||||
// Contraint failure
|
||||
test_constraint_fail<bool>();
|
||||
test_constraint_fail<char>();
|
||||
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
|
||||
test_constraint_fail<wchar_t>();
|
||||
#endif
|
||||
test_constraint_fail<char8_t>();
|
||||
test_constraint_fail<char16_t>();
|
||||
test_constraint_fail<char32_t>();
|
||||
test_constraint_fail<float>();
|
||||
test_constraint_fail<double>();
|
||||
test_constraint_fail<long double>();
|
||||
}
|
||||
@ -0,0 +1,173 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class T>
|
||||
// constexpr T add_sat(T x, T y) noexcept; // freestanding
|
||||
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <limits>
|
||||
#include <numeric>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename IntegerT>
|
||||
constexpr bool test_signed() {
|
||||
constexpr auto minVal = std::numeric_limits<IntegerT>::min();
|
||||
constexpr auto maxVal = std::numeric_limits<IntegerT>::max();
|
||||
|
||||
// TODO(LLVM-20) remove [[maybe_unused]] since all supported compilers support "Placeholder variables with no name"
|
||||
[[maybe_unused]] std::same_as<IntegerT> decltype(auto) _ = std::add_sat(minVal, maxVal);
|
||||
|
||||
static_assert(noexcept(std::add_sat(minVal, maxVal)));
|
||||
|
||||
// clang-format off
|
||||
|
||||
// Limit values (-1, 0, 1, min, max)
|
||||
|
||||
assert(std::add_sat(IntegerT{-1}, IntegerT{-1}) == IntegerT{-2});
|
||||
assert(std::add_sat(IntegerT{-1}, IntegerT{ 0}) == IntegerT{-1});
|
||||
assert(std::add_sat(IntegerT{-1}, IntegerT{ 1}) == IntegerT{ 0});
|
||||
assert(std::add_sat(IntegerT{-1}, minVal) == minVal); // saturated
|
||||
assert(std::add_sat(IntegerT{-1}, maxVal) == IntegerT{-1} + maxVal);
|
||||
|
||||
assert(std::add_sat(IntegerT{ 0}, IntegerT{-1}) == IntegerT{-1});
|
||||
assert(std::add_sat(IntegerT{ 0}, IntegerT{ 0}) == IntegerT{ 0});
|
||||
assert(std::add_sat(IntegerT{ 0}, IntegerT{ 1}) == IntegerT{ 1});
|
||||
assert(std::add_sat(IntegerT{ 0}, minVal) == minVal);
|
||||
assert(std::add_sat(IntegerT{ 0}, maxVal) == maxVal);
|
||||
|
||||
assert(std::add_sat(IntegerT{ 1}, IntegerT{-1}) == IntegerT{ 0});
|
||||
assert(std::add_sat(IntegerT{ 1}, IntegerT{ 0}) == IntegerT{ 1});
|
||||
assert(std::add_sat(IntegerT{ 1}, IntegerT{ 1}) == IntegerT{ 2});
|
||||
assert(std::add_sat(IntegerT{ 1}, minVal) == IntegerT{ 1} + minVal);
|
||||
assert(std::add_sat(IntegerT{ 1}, maxVal) == maxVal); // saturated
|
||||
|
||||
assert(std::add_sat( minVal, IntegerT{-1}) == minVal); // saturated
|
||||
assert(std::add_sat( minVal, IntegerT{ 0}) == minVal);
|
||||
assert(std::add_sat( minVal, IntegerT{ 1}) == minVal + IntegerT{ 1});
|
||||
assert(std::add_sat( minVal, minVal) == minVal); // saturated
|
||||
assert(std::add_sat( minVal, maxVal) == IntegerT{-1});
|
||||
|
||||
assert(std::add_sat( maxVal, IntegerT{-1}) == maxVal + IntegerT{-1});
|
||||
assert(std::add_sat( maxVal, IntegerT{ 0}) == maxVal);
|
||||
assert(std::add_sat( maxVal, IntegerT{ 1}) == maxVal); // saturated
|
||||
assert(std::add_sat( maxVal, minVal) == IntegerT{-1});
|
||||
assert(std::add_sat( maxVal, maxVal) == maxVal); // saturated
|
||||
|
||||
// No saturation (no limit values)
|
||||
|
||||
assert(std::add_sat(IntegerT{-27}, IntegerT{28})== IntegerT{ 1});
|
||||
assert(std::add_sat(IntegerT{ 27}, IntegerT{28})== IntegerT{55});
|
||||
{
|
||||
constexpr IntegerT x = maxVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT y = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::add_sat(x, y) == maxVal);
|
||||
}
|
||||
|
||||
// Saturation (no limit values)
|
||||
|
||||
{
|
||||
constexpr IntegerT x = minVal / IntegerT{2} + IntegerT{-27};
|
||||
constexpr IntegerT y = minVal / IntegerT{2} + IntegerT{-28};
|
||||
assert(std::add_sat(x, y) == minVal); // saturated
|
||||
}
|
||||
{
|
||||
constexpr IntegerT x = maxVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT y = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::add_sat(x, y) == maxVal); // saturated
|
||||
}
|
||||
|
||||
// clang-format on
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename IntegerT>
|
||||
constexpr bool test_unsigned() {
|
||||
constexpr auto minVal = std::numeric_limits<IntegerT>::min();
|
||||
constexpr auto maxVal = std::numeric_limits<IntegerT>::max();
|
||||
|
||||
// TODO(LLVM-20) remove [[maybe_unused]] since all supported compilers support "Placeholder variables with no name"
|
||||
[[maybe_unused]] std::same_as<IntegerT> decltype(auto) _ = std::add_sat(minVal, maxVal);
|
||||
|
||||
static_assert(noexcept(std::add_sat(minVal, maxVal)));
|
||||
|
||||
// clang-format off
|
||||
|
||||
// Litmit values (0, 1, min, max)
|
||||
|
||||
assert(std::add_sat(IntegerT{0}, IntegerT{0}) == IntegerT{0});
|
||||
assert(std::add_sat(IntegerT{0}, IntegerT{1}) == IntegerT{1});
|
||||
assert(std::add_sat(IntegerT{0}, minVal) == IntegerT{0});
|
||||
assert(std::add_sat(IntegerT{0}, maxVal) == maxVal);
|
||||
assert(std::add_sat(IntegerT{1}, IntegerT{0}) == IntegerT{1});
|
||||
assert(std::add_sat(IntegerT{1}, IntegerT{1}) == IntegerT{2});
|
||||
assert(std::add_sat(IntegerT{1}, minVal) == IntegerT{1});
|
||||
assert(std::add_sat(IntegerT{1}, maxVal) == maxVal); // saturated
|
||||
assert(std::add_sat( minVal, IntegerT{0}) == IntegerT{0});
|
||||
assert(std::add_sat( minVal, IntegerT{1}) == IntegerT{1});
|
||||
assert(std::add_sat( minVal, minVal) == minVal);
|
||||
assert(std::add_sat( minVal, maxVal) == maxVal);
|
||||
assert(std::add_sat( maxVal, IntegerT{0}) == maxVal);
|
||||
assert(std::add_sat( maxVal, IntegerT{1}) == maxVal); // saturated
|
||||
assert(std::add_sat( maxVal, minVal) == maxVal);
|
||||
assert(std::add_sat( maxVal, maxVal) == maxVal); // saturated
|
||||
|
||||
// No saturation (no limit values)
|
||||
|
||||
assert(std::add_sat(IntegerT{27}, IntegerT{28}) == IntegerT{55});
|
||||
|
||||
// Saturation (no limit values)
|
||||
|
||||
{
|
||||
constexpr IntegerT x = maxVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT y = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::add_sat( x, y) == maxVal); // saturated
|
||||
assert(std::add_sat( x, maxVal) == maxVal); // saturated
|
||||
assert(std::add_sat(maxVal, y) == maxVal); // saturated
|
||||
}
|
||||
|
||||
// clang-format on
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
constexpr bool test() {
|
||||
// Signed
|
||||
test_signed<signed char>();
|
||||
test_signed<short int>();
|
||||
test_signed<int>();
|
||||
test_signed<long int>();
|
||||
test_signed<long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_signed<__int128_t>();
|
||||
#endif
|
||||
// Unsigned
|
||||
test_unsigned<unsigned char>();
|
||||
test_unsigned<unsigned short int>();
|
||||
test_unsigned<unsigned int>();
|
||||
test_unsigned<unsigned long int>();
|
||||
test_unsigned<unsigned long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_unsigned<__uint128_t>();
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int main(int, char**) {
|
||||
test();
|
||||
static_assert(test());
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,58 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
|
||||
// REQUIRES: has-unix-headers
|
||||
// REQUIRES: libcpp-hardening-mode={{extensive|debug}}
|
||||
// XFAIL: availability-verbose_abort-missing
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class T>
|
||||
// constexpr T div_sat(T x, T y) noexcept; // freestanding
|
||||
|
||||
#include <cassert>
|
||||
#include <numeric>
|
||||
|
||||
#include "check_assertion.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename IntegerT>
|
||||
void test_runtime_assertion() {
|
||||
TEST_LIBCPP_ASSERT_FAILURE((void)std::div_sat(IntegerT{27}, IntegerT{0}), "Division by 0 is undefined");
|
||||
}
|
||||
|
||||
bool test() {
|
||||
// Signed
|
||||
test_runtime_assertion<signed char>();
|
||||
test_runtime_assertion<short int>();
|
||||
test_runtime_assertion<int>();
|
||||
test_runtime_assertion<long int>();
|
||||
test_runtime_assertion<long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_runtime_assertion<__int128_t>();
|
||||
#endif
|
||||
// Unsigned
|
||||
test_runtime_assertion<unsigned char>();
|
||||
test_runtime_assertion<unsigned short int>();
|
||||
test_runtime_assertion<unsigned int>();
|
||||
test_runtime_assertion<unsigned long int>();
|
||||
test_runtime_assertion<unsigned long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_runtime_assertion<__uint128_t>();
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int main(int, char**) {
|
||||
test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,108 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class T>
|
||||
// constexpr T div_sat(T x, T y) noexcept; // freestanding
|
||||
|
||||
#include <concepts>
|
||||
#include <numeric>
|
||||
#include <type_traits>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
// Constraints
|
||||
|
||||
template <typename T, typename U>
|
||||
concept CanDo = requires(T x, U y) {
|
||||
{ std::div_sat(x, y) } -> std::same_as<T>;
|
||||
};
|
||||
|
||||
template <typename T, typename U>
|
||||
constexpr void test_constraint_success() {
|
||||
static_assert(CanDo<T, T>);
|
||||
static_assert(!CanDo<U, T>);
|
||||
static_assert(!CanDo<T, U>);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr void test_constraint_fail() {
|
||||
using I = int;
|
||||
static_assert(!CanDo<T, T>);
|
||||
static_assert(!CanDo<I, T>);
|
||||
static_assert(!CanDo<T, I>);
|
||||
}
|
||||
|
||||
constexpr void test() {
|
||||
// Contraint success - Signed
|
||||
using SI = long long int;
|
||||
test_constraint_success<signed char, SI>();
|
||||
test_constraint_success<short int, SI>();
|
||||
test_constraint_success<signed char, SI>();
|
||||
test_constraint_success<short int, SI>();
|
||||
test_constraint_success<int, SI>();
|
||||
test_constraint_success<long int, SI>();
|
||||
test_constraint_success<long long int, int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_success<__int128_t, SI>();
|
||||
#endif
|
||||
// Contraint success - Unsigned
|
||||
using UI = unsigned long long int;
|
||||
test_constraint_success<unsigned char, UI>();
|
||||
test_constraint_success<unsigned short int, UI>();
|
||||
test_constraint_success<unsigned int, UI>();
|
||||
test_constraint_success<unsigned long int, UI>();
|
||||
test_constraint_success<unsigned long long int, unsigned int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_success<__uint128_t, UI>();
|
||||
#endif
|
||||
|
||||
// Contraint failure
|
||||
test_constraint_fail<bool>();
|
||||
test_constraint_fail<char>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_fail<wchar_t>();
|
||||
#endif
|
||||
test_constraint_fail<char8_t>();
|
||||
test_constraint_fail<char16_t>();
|
||||
test_constraint_fail<char32_t>();
|
||||
test_constraint_fail<float>();
|
||||
test_constraint_fail<double>();
|
||||
test_constraint_fail<long double>();
|
||||
}
|
||||
|
||||
// A function call expression that violates the precondition in the Preconditions: element is not a core constant expression (7.7 [expr.const]).
|
||||
|
||||
template <auto N>
|
||||
using QuotT = std::integral_constant<decltype(N), std::div_sat(N, N)>;
|
||||
|
||||
template <auto N>
|
||||
QuotT<N> div_by_zero();
|
||||
|
||||
template <auto N>
|
||||
concept CanDivByZero = requires { div_by_zero<N>(); };
|
||||
|
||||
static_assert(!CanDivByZero<static_cast<signed char>(0)>);
|
||||
static_assert(!CanDivByZero<static_cast<short int>(0)>);
|
||||
static_assert(!CanDivByZero<0>);
|
||||
static_assert(!CanDivByZero<0L>);
|
||||
static_assert(!CanDivByZero<0LL>);
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
static_assert(!CanDivByZero<static_cast<__int128_t>(0)>);
|
||||
#endif
|
||||
static_assert(!CanDivByZero<static_cast<unsigned char>(0)>);
|
||||
static_assert(!CanDivByZero<static_cast<unsigned short int>(0)>);
|
||||
static_assert(!CanDivByZero<0U>);
|
||||
static_assert(!CanDivByZero<0UL>);
|
||||
static_assert(!CanDivByZero<0ULL>);
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
static_assert(!CanDivByZero<static_cast<__uint128_t>(0)>);
|
||||
#endif
|
||||
@ -0,0 +1,158 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
// The test uses "Placeholder variables with no name"
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class T>
|
||||
// constexpr T div_sat(T x, T y) noexcept; // freestanding
|
||||
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <limits>
|
||||
#include <numeric>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename IntegerT>
|
||||
constexpr bool test_signed() {
|
||||
constexpr auto minVal = std::numeric_limits<IntegerT>::min();
|
||||
constexpr auto maxVal = std::numeric_limits<IntegerT>::max();
|
||||
|
||||
// TODO(LLVM-20) remove [[maybe_unused]] and `{}` scope since all supported compilers support "Placeholder variables with no name"
|
||||
[[maybe_unused]] std::same_as<IntegerT> decltype(auto) _ = std::div_sat(minVal, maxVal);
|
||||
|
||||
static_assert(noexcept(std::div_sat(minVal, maxVal)));
|
||||
|
||||
// clang-format off
|
||||
|
||||
// Limit values (-1, 0, 1, min, max)
|
||||
|
||||
assert(std::div_sat(IntegerT{-1}, IntegerT{-1}) == IntegerT{ 1});
|
||||
assert(std::div_sat(IntegerT{-1}, IntegerT{ 1}) == IntegerT{-1});
|
||||
assert(std::div_sat(IntegerT{-1}, minVal) == IntegerT{ 0});
|
||||
assert(std::div_sat(IntegerT{-1}, maxVal) == IntegerT{ 0});
|
||||
assert(std::div_sat(IntegerT{ 0}, IntegerT{-1}) == IntegerT{ 0});
|
||||
assert(std::div_sat(IntegerT{ 0}, IntegerT{ 1}) == IntegerT{ 0});
|
||||
assert(std::div_sat(IntegerT{ 0}, minVal) == IntegerT{ 0});
|
||||
assert(std::div_sat(IntegerT{ 0}, maxVal) == IntegerT{ 0});
|
||||
assert(std::div_sat(IntegerT{ 1}, IntegerT{-1}) == IntegerT{-1});
|
||||
assert(std::div_sat(IntegerT{ 1}, IntegerT{ 1}) == IntegerT{ 1});
|
||||
assert(std::div_sat(IntegerT{ 1}, minVal) == IntegerT{ 0});
|
||||
assert(std::div_sat(IntegerT{ 1}, maxVal) == IntegerT{ 0});
|
||||
assert(std::div_sat( minVal, IntegerT{ 1}) == minVal);
|
||||
assert(std::div_sat( minVal, IntegerT{-1}) == maxVal); // saturated
|
||||
assert(std::div_sat( minVal, minVal) == IntegerT{ 1});
|
||||
assert(std::div_sat( minVal, maxVal) == (minVal / maxVal));
|
||||
assert(std::div_sat( maxVal, IntegerT{-1}) == -maxVal);
|
||||
assert(std::div_sat( maxVal, IntegerT{ 1}) == maxVal);
|
||||
assert(std::div_sat( maxVal, minVal) == IntegerT{ 0});
|
||||
assert(std::div_sat( maxVal, maxVal) == IntegerT{ 1});
|
||||
|
||||
// No saturation (no limit values)
|
||||
|
||||
assert(std::div_sat(IntegerT{27}, IntegerT{28}) == IntegerT{0});
|
||||
assert(std::div_sat(IntegerT{28}, IntegerT{27}) == IntegerT{1});
|
||||
{
|
||||
constexpr IntegerT lesserVal = minVal / IntegerT{2} + IntegerT{-28};
|
||||
constexpr IntegerT biggerVal = minVal / IntegerT{2} + IntegerT{-27};
|
||||
assert(std::div_sat(lesserVal, biggerVal) == IntegerT{1});
|
||||
assert(std::div_sat(biggerVal, lesserVal) == IntegerT{0});
|
||||
}
|
||||
{
|
||||
constexpr IntegerT lesserVal = minVal / IntegerT{2} + IntegerT{-27};
|
||||
constexpr IntegerT biggerVal = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::div_sat(lesserVal, biggerVal) == IntegerT{-1});
|
||||
assert(std::div_sat(biggerVal, lesserVal) == IntegerT{-1});
|
||||
}
|
||||
{
|
||||
constexpr IntegerT lesserVal = maxVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT biggerVal = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::div_sat(lesserVal, biggerVal) == IntegerT{0});
|
||||
assert(std::div_sat(biggerVal, lesserVal) == IntegerT{1});
|
||||
}
|
||||
|
||||
// clang-format on
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename IntegerT>
|
||||
constexpr bool test_unsigned() {
|
||||
constexpr auto minVal = std::numeric_limits<IntegerT>::min();
|
||||
constexpr auto maxVal = std::numeric_limits<IntegerT>::max();
|
||||
|
||||
// TODO(LLVM-20) remove [[maybe_unused]] since all supported compilers support "Placeholder variables with no name"
|
||||
[[maybe_unused]] std::same_as<IntegerT> decltype(auto) _ = std::div_sat(minVal, maxVal);
|
||||
static_assert(noexcept(std::div_sat(minVal, maxVal)));
|
||||
|
||||
// clang-format off
|
||||
|
||||
// No limit values (0, 1, min, max)
|
||||
|
||||
assert(std::div_sat(IntegerT{0}, IntegerT{1}) == IntegerT{0});
|
||||
assert(std::div_sat(IntegerT{0}, maxVal) == IntegerT{0});
|
||||
|
||||
assert(std::div_sat(IntegerT{1}, IntegerT{1}) == IntegerT{1});
|
||||
assert(std::div_sat(IntegerT{1}, maxVal) == IntegerT{0});
|
||||
|
||||
assert(std::div_sat( minVal, IntegerT{1}) == minVal);
|
||||
assert(std::div_sat( minVal, maxVal) == IntegerT{0});
|
||||
|
||||
assert(std::div_sat( maxVal, IntegerT{1}) == maxVal);
|
||||
assert(std::div_sat( maxVal, maxVal) == IntegerT{1});
|
||||
|
||||
// No saturation (no limit values)
|
||||
|
||||
assert(std::div_sat(IntegerT{27}, IntegerT{28}) == IntegerT{0});
|
||||
assert(std::div_sat(IntegerT{28}, IntegerT{27}) == IntegerT{1});
|
||||
{
|
||||
constexpr IntegerT lesserVal = maxVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT biggerVal = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::div_sat(lesserVal, biggerVal) == IntegerT{0});
|
||||
assert(std::div_sat(biggerVal, lesserVal) == IntegerT{1});
|
||||
}
|
||||
|
||||
// Unsigned integer division never overflows
|
||||
|
||||
// clang-format on
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
constexpr bool test() {
|
||||
// Signed
|
||||
test_signed<signed char>();
|
||||
test_signed<short int>();
|
||||
test_signed<int>();
|
||||
test_signed<long int>();
|
||||
test_signed<long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_signed<__int128_t>();
|
||||
#endif
|
||||
// Unsigned
|
||||
test_unsigned<unsigned char>();
|
||||
test_unsigned<unsigned short int>();
|
||||
test_unsigned<unsigned int>();
|
||||
test_unsigned<unsigned long int>();
|
||||
test_unsigned<unsigned long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_unsigned<__uint128_t>();
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int main(int, char**) {
|
||||
test();
|
||||
static_assert(test());
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,77 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class T>
|
||||
// constexpr T mul_sat(T x, T y) noexcept; // freestanding
|
||||
|
||||
#include <concepts>
|
||||
#include <numeric>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T, typename U>
|
||||
concept CanDo = requires(T x, U y) {
|
||||
{ std::mul_sat(x, y) } -> std::same_as<T>;
|
||||
};
|
||||
|
||||
template <typename T, typename U>
|
||||
constexpr void test_constraint_success() {
|
||||
static_assert(CanDo<T, T>);
|
||||
static_assert(!CanDo<U, T>);
|
||||
static_assert(!CanDo<T, U>);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr void test_constraint_fail() {
|
||||
using I = int;
|
||||
static_assert(!CanDo<T, T>);
|
||||
static_assert(!CanDo<I, T>);
|
||||
static_assert(!CanDo<T, I>);
|
||||
}
|
||||
|
||||
constexpr void test() {
|
||||
// Contraint success - Signed
|
||||
using SI = long long int;
|
||||
test_constraint_success<signed char, SI>();
|
||||
test_constraint_success<short int, SI>();
|
||||
test_constraint_success<signed char, SI>();
|
||||
test_constraint_success<short int, SI>();
|
||||
test_constraint_success<int, SI>();
|
||||
test_constraint_success<long int, SI>();
|
||||
test_constraint_success<long long int, int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_success<__int128_t, SI>();
|
||||
#endif
|
||||
// Contraint success - Unsigned
|
||||
using UI = unsigned long long int;
|
||||
test_constraint_success<unsigned char, UI>();
|
||||
test_constraint_success<unsigned short int, UI>();
|
||||
test_constraint_success<unsigned int, UI>();
|
||||
test_constraint_success<unsigned long int, UI>();
|
||||
test_constraint_success<unsigned long long int, unsigned int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_success<__uint128_t, UI>();
|
||||
#endif
|
||||
|
||||
// Contraint failure
|
||||
test_constraint_fail<bool>();
|
||||
test_constraint_fail<char>();
|
||||
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
|
||||
test_constraint_fail<wchar_t>();
|
||||
#endif
|
||||
test_constraint_fail<char8_t>();
|
||||
test_constraint_fail<char16_t>();
|
||||
test_constraint_fail<char32_t>();
|
||||
test_constraint_fail<float>();
|
||||
test_constraint_fail<double>();
|
||||
test_constraint_fail<long double>();
|
||||
}
|
||||
@ -0,0 +1,180 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
// The test uses "Placeholder variables with no name"
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class T>
|
||||
// constexpr T mul_sat(T x, T y) noexcept; // freestanding
|
||||
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <limits>
|
||||
#include <numeric>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename IntegerT>
|
||||
constexpr bool test_signed() {
|
||||
constexpr auto minVal = std::numeric_limits<IntegerT>::min();
|
||||
constexpr auto maxVal = std::numeric_limits<IntegerT>::max();
|
||||
|
||||
// TODO(LLVM-20) remove [[maybe_unused]] since all supported compilers support "Placeholder variables with no name"
|
||||
[[maybe_unused]] std::same_as<IntegerT> decltype(auto) _ = std::mul_sat(minVal, maxVal);
|
||||
|
||||
static_assert(noexcept(std::mul_sat(minVal, maxVal)));
|
||||
|
||||
// clang-format off
|
||||
|
||||
// Limit values (-1, 0, 1, min, max)
|
||||
|
||||
assert(std::mul_sat(IntegerT{-1}, IntegerT{-1}) == IntegerT{ 1});
|
||||
assert(std::mul_sat(IntegerT{-1}, IntegerT{ 0}) == IntegerT{ 0});
|
||||
assert(std::mul_sat(IntegerT{-1}, IntegerT{ 1}) == IntegerT{-1});
|
||||
assert(std::mul_sat(IntegerT{-1}, minVal) == maxVal); // saturated
|
||||
assert(std::mul_sat(IntegerT{-1}, maxVal) == -maxVal);
|
||||
|
||||
assert(std::mul_sat(IntegerT{ 0}, IntegerT{-1}) == IntegerT{ 0});
|
||||
assert(std::mul_sat(IntegerT{ 0}, IntegerT{ 0}) == IntegerT{ 0});
|
||||
assert(std::mul_sat(IntegerT{ 0}, IntegerT{ 1}) == IntegerT{ 0});
|
||||
assert(std::mul_sat(IntegerT{ 0}, minVal) == IntegerT{ 0});
|
||||
assert(std::mul_sat(IntegerT{ 0}, maxVal) == IntegerT{ 0});
|
||||
|
||||
assert(std::mul_sat(IntegerT{ 1}, IntegerT{-1}) == IntegerT{-1});
|
||||
assert(std::mul_sat(IntegerT{ 1}, IntegerT{ 0}) == IntegerT{ 0});
|
||||
assert(std::mul_sat(IntegerT{ 1}, IntegerT{ 1}) == IntegerT{ 1});
|
||||
assert(std::mul_sat(IntegerT{ 1}, minVal) == minVal);
|
||||
assert(std::mul_sat(IntegerT{ 1}, maxVal) == maxVal);
|
||||
|
||||
assert(std::mul_sat( minVal, IntegerT{-1}) == maxVal); // saturated
|
||||
assert(std::mul_sat( minVal, IntegerT{ 0}) == IntegerT{ 0});
|
||||
assert(std::mul_sat( minVal, IntegerT{ 1}) == minVal);
|
||||
assert(std::mul_sat( minVal, minVal) == maxVal); // saturated
|
||||
assert(std::mul_sat( minVal, maxVal) == minVal); // saturated
|
||||
|
||||
assert(std::mul_sat( maxVal, IntegerT{-1}) == -maxVal);
|
||||
assert(std::mul_sat( maxVal, IntegerT{ 0}) == IntegerT{ 0});
|
||||
assert(std::mul_sat( maxVal, IntegerT{ 1}) == maxVal); // saturated
|
||||
assert(std::mul_sat( maxVal, minVal) == minVal); // saturated
|
||||
assert(std::mul_sat( maxVal, maxVal) == maxVal); // saturated
|
||||
|
||||
// No saturation (no limit values)
|
||||
|
||||
assert(std::mul_sat(IntegerT{27}, IntegerT{ 2}) == IntegerT{54});
|
||||
assert(std::mul_sat(IntegerT{ 2}, IntegerT{28}) == IntegerT{56});
|
||||
|
||||
// Saturation (no limit values)
|
||||
|
||||
{
|
||||
constexpr IntegerT x = minVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT y = minVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::mul_sat(x, y) == maxVal); // saturated
|
||||
}
|
||||
{
|
||||
constexpr IntegerT x = minVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT y = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::mul_sat(x, y) == minVal); // saturated
|
||||
}
|
||||
{
|
||||
constexpr IntegerT x = maxVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT y = minVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::mul_sat(x, y) == minVal); // saturated
|
||||
}
|
||||
{
|
||||
constexpr IntegerT x = maxVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT y = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::mul_sat(x, y) == maxVal); // saturated
|
||||
}
|
||||
|
||||
// clang-format on
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename IntegerT>
|
||||
constexpr bool test_unsigned() {
|
||||
constexpr auto minVal = std::numeric_limits<IntegerT>::min();
|
||||
constexpr auto maxVal = std::numeric_limits<IntegerT>::max();
|
||||
|
||||
// TODO(LLVM-20) remove [[maybe_unused]] since all supported compilers support "Placeholder variables with no name"
|
||||
[[maybe_unused]] std::same_as<IntegerT> decltype(auto) _ = std::mul_sat(minVal, maxVal);
|
||||
|
||||
static_assert(noexcept(std::mul_sat(minVal, maxVal)));
|
||||
|
||||
// clang-format off
|
||||
|
||||
// No saturation (0, 1)
|
||||
|
||||
assert(std::mul_sat(IntegerT{0}, IntegerT{0}) == IntegerT{0});
|
||||
assert(std::mul_sat(IntegerT{0}, IntegerT{1}) == IntegerT{0});
|
||||
assert(std::mul_sat(IntegerT{0}, minVal) == IntegerT{0});
|
||||
assert(std::mul_sat(IntegerT{0}, maxVal) == IntegerT{0});
|
||||
|
||||
assert(std::mul_sat(IntegerT{1}, IntegerT{0}) == IntegerT{0});
|
||||
assert(std::mul_sat(IntegerT{1}, IntegerT{1}) == IntegerT{1});
|
||||
assert(std::mul_sat(IntegerT{1}, minVal) == minVal);
|
||||
assert(std::mul_sat(IntegerT{1}, maxVal) == maxVal);
|
||||
|
||||
assert(std::mul_sat( minVal, IntegerT{0}) == IntegerT{0});
|
||||
assert(std::mul_sat( minVal, IntegerT{1}) == minVal);
|
||||
assert(std::mul_sat( minVal, maxVal) == minVal);
|
||||
assert(std::mul_sat( minVal, maxVal) == minVal);
|
||||
|
||||
assert(std::mul_sat( maxVal, IntegerT{0}) == IntegerT{0});
|
||||
assert(std::mul_sat( maxVal, IntegerT{1}) == maxVal);
|
||||
assert(std::mul_sat( maxVal, minVal) == IntegerT{0});
|
||||
assert(std::mul_sat( maxVal, maxVal) == maxVal); // saturated
|
||||
|
||||
// No saturation (no limit values)
|
||||
|
||||
assert(std::mul_sat(IntegerT{28}, IntegerT{2}) == IntegerT{56});
|
||||
|
||||
// Saturation (no limit values
|
||||
|
||||
{
|
||||
constexpr IntegerT x = maxVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT y = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::mul_sat(x, y) == maxVal); // saturated
|
||||
}
|
||||
|
||||
// clang-format on
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
constexpr bool test() {
|
||||
// Signed
|
||||
test_signed<signed char>();
|
||||
test_signed<short int>();
|
||||
test_signed<int>();
|
||||
test_signed<long int>();
|
||||
test_signed<long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_signed<__int128_t>();
|
||||
#endif
|
||||
// Unsigned
|
||||
test_unsigned<unsigned char>();
|
||||
test_unsigned<unsigned short int>();
|
||||
test_unsigned<unsigned int>();
|
||||
test_unsigned<unsigned long int>();
|
||||
test_unsigned<unsigned long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_unsigned<__uint128_t>();
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int main(int, char**) {
|
||||
test();
|
||||
static_assert(test());
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,79 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class R, class T>
|
||||
// constexpr R saturate_cast(T x) noexcept; // freestanding
|
||||
|
||||
#include <concepts>
|
||||
#include <numeric>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename R, typename T>
|
||||
concept CanDo = requires(T x) {
|
||||
{ std::saturate_cast<R>(x) } -> std::same_as<R>;
|
||||
};
|
||||
|
||||
template <typename R, typename T>
|
||||
constexpr void test_constraint_success() {
|
||||
static_assert(CanDo<R, T>);
|
||||
static_assert(CanDo<T, T>);
|
||||
static_assert(CanDo<T, R>);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr void test_constraint_fail() {
|
||||
using I = int;
|
||||
using R = T;
|
||||
static_assert(!CanDo<R, T>);
|
||||
static_assert(!CanDo<T, R>);
|
||||
static_assert(!CanDo<I, T>);
|
||||
static_assert(!CanDo<T, I>);
|
||||
}
|
||||
|
||||
constexpr void test() {
|
||||
// Contraint success - Signed
|
||||
using SI = long long int;
|
||||
test_constraint_success<SI, signed char>();
|
||||
test_constraint_success<SI, short int>();
|
||||
test_constraint_success<SI, signed char>();
|
||||
test_constraint_success<SI, short int>();
|
||||
test_constraint_success<SI, int>();
|
||||
test_constraint_success<SI, long int>();
|
||||
test_constraint_success<int, long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_success<__int128_t, SI>();
|
||||
#endif
|
||||
// Contraint success - Unsigned
|
||||
using UI = unsigned long long int;
|
||||
test_constraint_success<UI, unsigned char>();
|
||||
test_constraint_success<UI, unsigned short int>();
|
||||
test_constraint_success<UI, unsigned int>();
|
||||
test_constraint_success<UI, unsigned long int>();
|
||||
test_constraint_success<unsigned int, unsigned long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_success<UI, __uint128_t>();
|
||||
#endif
|
||||
|
||||
// Contraint failure
|
||||
test_constraint_fail<bool>();
|
||||
test_constraint_fail<char>();
|
||||
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
|
||||
test_constraint_fail<wchar_t>();
|
||||
#endif
|
||||
test_constraint_fail<char8_t>();
|
||||
test_constraint_fail<char16_t>();
|
||||
test_constraint_fail<char32_t>();
|
||||
test_constraint_fail<float>();
|
||||
test_constraint_fail<double>();
|
||||
test_constraint_fail<long double>();
|
||||
}
|
||||
@ -0,0 +1,397 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class R, class T>
|
||||
// constexpr R saturate_cast(T x) noexcept; // freestanding
|
||||
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <concepts>
|
||||
#include <limits>
|
||||
#include <numeric>
|
||||
|
||||
#include "test_macros.h"
|
||||
#include <print>
|
||||
|
||||
// Smaller to larger
|
||||
static_assert(noexcept(std::saturate_cast<signed int>(std::numeric_limits<signed char>::max())));
|
||||
static_assert(noexcept(std::saturate_cast<signed int>(std::numeric_limits<unsigned char>::max())));
|
||||
|
||||
static_assert(noexcept(std::saturate_cast<unsigned int>(std::numeric_limits<signed char>::max())));
|
||||
static_assert(noexcept(std::saturate_cast<unsigned int>(std::numeric_limits<unsigned char>::max())));
|
||||
|
||||
// Same type
|
||||
static_assert(noexcept(std::saturate_cast<signed long int>(std::numeric_limits<signed long int>::max())));
|
||||
static_assert(noexcept(std::saturate_cast<unsigned long int>(std::numeric_limits<unsigned long int>::max())));
|
||||
|
||||
// Larger to smaller
|
||||
static_assert(noexcept(std::saturate_cast<signed char>(std::numeric_limits<signed int>::max())));
|
||||
static_assert(noexcept(std::saturate_cast<signed char>(std::numeric_limits<unsigned int>::max())));
|
||||
|
||||
static_assert(noexcept(std::saturate_cast<unsigned char>(std::numeric_limits<signed int>::max())));
|
||||
static_assert(noexcept(std::saturate_cast<unsigned char>(std::numeric_limits<unsigned int>::max())));
|
||||
|
||||
// Tests
|
||||
|
||||
constexpr bool test() {
|
||||
// clang-format off
|
||||
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
using SIntT = __int128_t;
|
||||
using UIntT = __uint128_t;
|
||||
#else
|
||||
using SIntT = long long int;
|
||||
using UIntT = unsigned long long int;
|
||||
#endif
|
||||
|
||||
// Constants the values of which depend on the context (platform)
|
||||
|
||||
constexpr auto sBigMin = std::numeric_limits<SIntT>::min();
|
||||
constexpr auto sZero = SIntT{0};
|
||||
constexpr auto sBigMax = std::numeric_limits<SIntT>::max();
|
||||
|
||||
constexpr auto uZero = UIntT{0};
|
||||
constexpr auto uBigMax = std::numeric_limits<UIntT>::max();
|
||||
|
||||
// Constants to avoid casting in place
|
||||
|
||||
constexpr auto O_C = static_cast<signed char>(0);
|
||||
constexpr auto O_UC = static_cast<unsigned char>(0);
|
||||
|
||||
constexpr auto O_S = static_cast<signed short int>(0);
|
||||
constexpr auto O_US = static_cast<unsigned short int>(0);
|
||||
|
||||
// signed char
|
||||
|
||||
// TODO(LLVM-20) remove [[maybe_unused]] and `{}` scope since all supported compilers support "Placeholder variables with no name",
|
||||
// here and below...
|
||||
{ [[maybe_unused]] std::same_as<signed char> decltype(auto) _ = std::saturate_cast<signed char>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<signed char>(SCHAR_MIN) == SCHAR_MIN);
|
||||
assert(std::saturate_cast<signed char>( O_C) == O_C);
|
||||
assert(std::saturate_cast<signed char>(SCHAR_MAX) == SCHAR_MAX);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed char> decltype(auto) _ = std::saturate_cast<signed char>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<signed char>( O_UC) == O_C);
|
||||
assert(std::saturate_cast<signed char>(UCHAR_MAX) == SCHAR_MAX);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed char> decltype(auto) _ = std::saturate_cast<signed char>(sBigMax); }
|
||||
assert(std::saturate_cast<signed char>(sBigMin) == SCHAR_MIN); // saturated
|
||||
assert(std::saturate_cast<signed char>( sZero) == O_C);
|
||||
assert(std::saturate_cast<signed char>(sBigMax) == SCHAR_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed char> decltype(auto) _ = std::saturate_cast<signed char>(uBigMax); }
|
||||
assert(std::saturate_cast<signed char>( uZero) == O_C);
|
||||
assert(std::saturate_cast<signed char>(uBigMax) == SCHAR_MAX); // saturated
|
||||
|
||||
// short
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed short int> decltype(auto) _ = std::saturate_cast<signed short int>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<signed short int>(SCHAR_MIN) == static_cast<signed short int>(SCHAR_MIN));
|
||||
assert(std::saturate_cast<signed short int>( O_C) == O_S);
|
||||
assert(std::saturate_cast<signed short int>(SCHAR_MAX) == static_cast<signed short int>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed short int> decltype(auto) _ = std::saturate_cast<signed short int>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<signed short int>( O_UC) == O_S);
|
||||
assert(std::saturate_cast<signed short int>(UCHAR_MAX) == static_cast<signed short int>(UCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed short int> decltype(auto) _ = std::saturate_cast<signed short int>(SHRT_MAX); }
|
||||
assert(std::saturate_cast<signed short int>( SHRT_MIN) == SHRT_MIN);
|
||||
assert(std::saturate_cast<signed short int>( O_S) == O_S);
|
||||
assert(std::saturate_cast<signed short int>( SHRT_MAX) == SHRT_MAX);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed short int> decltype(auto) _ = std::saturate_cast<signed short int>(USHRT_MAX); }
|
||||
assert(std::saturate_cast<signed short int>( O_US) == O_S);
|
||||
assert(std::saturate_cast<signed short int>(USHRT_MAX) == SHRT_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed short int> decltype(auto) _ = std::saturate_cast<signed short int>(sBigMax); }
|
||||
assert(std::saturate_cast<signed short int>( sBigMin) == SHRT_MIN); // saturated
|
||||
assert(std::saturate_cast<signed short int>( sZero) == O_S);
|
||||
assert(std::saturate_cast<signed short int>( sBigMax) == SHRT_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed short int> decltype(auto) _ = std::saturate_cast<signed short int>(uBigMax); }
|
||||
assert(std::saturate_cast<signed short int>( uZero) == O_S);
|
||||
assert(std::saturate_cast<signed short int>( uBigMax) == SHRT_MAX); // saturated
|
||||
|
||||
// int
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed int> decltype(auto) _ = std::saturate_cast<signed int>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<signed int>(SCHAR_MIN) == static_cast<signed int>(SCHAR_MIN));
|
||||
assert(std::saturate_cast<signed int>( O_C) == 0);
|
||||
assert(std::saturate_cast<signed int>(SCHAR_MAX) == static_cast<signed int>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed int> decltype(auto) _ = std::saturate_cast<signed int>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<signed int>( O_UC) == 0);
|
||||
assert(std::saturate_cast<signed int>(UCHAR_MAX) == static_cast<signed int>(UCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed int> decltype(auto) _ = std::saturate_cast<signed int>(INT_MAX); }
|
||||
assert(std::saturate_cast<signed int>( INT_MIN) == INT_MIN);
|
||||
assert(std::saturate_cast<signed int>( 0) == 0);
|
||||
assert(std::saturate_cast<signed int>( INT_MAX) == INT_MAX);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed int> decltype(auto) _ = std::saturate_cast<signed int>(UINT_MAX); }
|
||||
assert(std::saturate_cast<signed int>( 0) == 0);
|
||||
assert(std::saturate_cast<signed int>(UINT_MAX) == INT_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed int> decltype(auto) _ = std::saturate_cast<signed int>(sBigMax); }
|
||||
assert(std::saturate_cast<signed int>( sBigMin) == INT_MIN); // saturated
|
||||
assert(std::saturate_cast<signed int>( sZero) == 0);
|
||||
assert(std::saturate_cast<signed int>( sBigMax) == INT_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed int> decltype(auto) _ = std::saturate_cast<signed int>(uBigMax); }
|
||||
assert(std::saturate_cast<signed int>( uZero) == 0);
|
||||
assert(std::saturate_cast<signed int>( uBigMax) == INT_MAX); // saturated
|
||||
|
||||
// long
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long int> decltype(auto) _ = std::saturate_cast<signed long int>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<signed long int>(SCHAR_MIN) == static_cast<signed long int>(SCHAR_MIN));
|
||||
assert(std::saturate_cast<signed long int>( O_C) == 0L);
|
||||
assert(std::saturate_cast<signed long int>(SCHAR_MAX) == static_cast<signed long int>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long int> decltype(auto) _ = std::saturate_cast<signed long int>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<signed long int>( O_UC) == 0L);
|
||||
assert(std::saturate_cast<signed long int>(UCHAR_MAX) == static_cast<signed long int>(UCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long int> decltype(auto) _ = std::saturate_cast<signed long int>(LONG_MAX); }
|
||||
assert(std::saturate_cast<signed long int>( LONG_MIN) == LONG_MIN);
|
||||
assert(std::saturate_cast<signed long int>( 0L) == 0L);
|
||||
assert(std::saturate_cast<signed long int>( LONG_MAX) == LONG_MAX);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long int> decltype(auto) _ = std::saturate_cast<signed long int>(ULONG_MAX); }
|
||||
assert(std::saturate_cast<signed long int>( 0UL) == 0L);
|
||||
assert(std::saturate_cast<signed long int>(ULONG_MAX) == LONG_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long int> decltype(auto) _ = std::saturate_cast<signed long int>(sBigMax); }
|
||||
assert(std::saturate_cast<signed long int>( sBigMin) == LONG_MIN); // saturated
|
||||
assert(std::saturate_cast<signed long int>( sZero) == 0L);
|
||||
assert(std::saturate_cast<signed long int>( sBigMax) == LONG_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long int> decltype(auto) _ = std::saturate_cast<signed long int>(uBigMax); }
|
||||
assert(std::saturate_cast<signed long int>( uZero) == 0L);
|
||||
assert(std::saturate_cast<signed long int>( uBigMax) == LONG_MAX); // saturated
|
||||
|
||||
// long long
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long long int> decltype(auto) _ = std::saturate_cast<signed long long int>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<signed long long int>(SCHAR_MIN) == static_cast<signed long long int>(SCHAR_MIN));
|
||||
assert(std::saturate_cast<signed long long int>( 0LL) == 0LL);
|
||||
assert(std::saturate_cast<signed long long int>(SCHAR_MAX) == static_cast<signed long long int>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long long int> decltype(auto) _ = std::saturate_cast<signed long long int>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<signed long long int>( O_UC) == 0LL);
|
||||
assert(std::saturate_cast<signed long long int>(UCHAR_MAX) == static_cast<signed long long int>(UCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long long int> decltype(auto) _ = std::saturate_cast<signed long long int>(LLONG_MIN); }
|
||||
assert(std::saturate_cast<signed long long int>(LLONG_MIN) == LLONG_MIN);
|
||||
assert(std::saturate_cast<signed long long int>( 0LL) == 0LL);
|
||||
assert(std::saturate_cast<signed long long int>(LLONG_MAX) == LLONG_MAX);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long long int> decltype(auto) _ = std::saturate_cast<signed long long int>(ULLONG_MAX); }
|
||||
assert(std::saturate_cast<signed long long int>( 0ULL) == 0LL);
|
||||
assert(std::saturate_cast<signed long long int>(ULLONG_MAX) == LLONG_MAX); // saturated
|
||||
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
{ [[maybe_unused]] std::same_as<signed long long int> decltype(auto) _ = std::saturate_cast<signed long long int>(sBigMax); }
|
||||
assert(std::saturate_cast<signed long long int>( sBigMin) == LLONG_MIN); // (128-bit) saturated
|
||||
assert(std::saturate_cast<signed long long int>( sZero) == 0LL);
|
||||
assert(std::saturate_cast<signed long long int>( sBigMax) == LLONG_MAX); // (128-bit) saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<signed long long int> decltype(auto) _ = std::saturate_cast<signed long long int>(uBigMax); }
|
||||
assert(std::saturate_cast<signed long long int>( uZero) == 0LL);
|
||||
assert(std::saturate_cast<signed long long int>( uBigMax) == LLONG_MAX); // (128-bit) saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<__int128_t> decltype(auto) _ = std::saturate_cast<__int128_t>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<__int128_t>(SCHAR_MIN) == static_cast<__int128_t>(SCHAR_MIN));
|
||||
assert(std::saturate_cast<__int128_t>( O_C) == sZero);
|
||||
assert(std::saturate_cast<__int128_t>(SCHAR_MAX) == static_cast<__int128_t>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<__int128_t> decltype(auto) _ = std::saturate_cast<__int128_t>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<__int128_t>( O_UC) == sZero);
|
||||
assert(std::saturate_cast<__int128_t>(UCHAR_MAX) == static_cast<__int128_t>(UCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<__int128_t> decltype(auto) _ = std::saturate_cast<__int128_t>(sBigMax); }
|
||||
assert(std::saturate_cast<__int128_t>( sBigMin) == sBigMin);
|
||||
assert(std::saturate_cast<__int128_t>( sZero) == sZero);
|
||||
assert(std::saturate_cast<__int128_t>( sBigMax) == sBigMax);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<__int128_t> decltype(auto) _ = std::saturate_cast<__int128_t>(uBigMax); }
|
||||
assert(std::saturate_cast<__int128_t>( uZero) == sZero);
|
||||
assert(std::saturate_cast<__int128_t>( uBigMax) == sBigMax); // saturated
|
||||
#endif
|
||||
|
||||
// unsigned char
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned char> decltype(auto) _ = std::saturate_cast<unsigned char>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned char>(SCHAR_MIN) == O_UC);
|
||||
assert(std::saturate_cast<unsigned char>( O_C) == O_UC);
|
||||
assert(std::saturate_cast<unsigned char>(SCHAR_MAX) == static_cast<unsigned char>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned char> decltype(auto) _ = std::saturate_cast<unsigned char>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned char>( O_UC) == O_UC);
|
||||
assert(std::saturate_cast<unsigned char>(UCHAR_MAX) == UCHAR_MAX);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned char> decltype(auto) _ = std::saturate_cast<unsigned char>(sBigMax); }
|
||||
assert(std::saturate_cast<unsigned char>( sBigMin) == O_UC); // saturated
|
||||
assert(std::saturate_cast<unsigned char>( sZero) == O_UC);
|
||||
assert(std::saturate_cast<unsigned char>( sBigMax) == UCHAR_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned char> decltype(auto) _ = std::saturate_cast<unsigned char>(uBigMax); }
|
||||
assert(std::saturate_cast<unsigned char>( uZero) == O_UC);
|
||||
assert(std::saturate_cast<unsigned char>( uBigMax) == UCHAR_MAX); // saturated
|
||||
|
||||
// unsigned short
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned short int> decltype(auto) _ = std::saturate_cast<unsigned short int>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned short int>(SCHAR_MIN) == O_US);
|
||||
assert(std::saturate_cast<unsigned short int>( O_C) == O_US);
|
||||
assert(std::saturate_cast<unsigned short int>(SCHAR_MAX) == static_cast<unsigned short int>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned short int> decltype(auto) _ = std::saturate_cast<unsigned short int>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned short int>( O_UC) == O_US);
|
||||
assert(std::saturate_cast<unsigned short int>(UCHAR_MAX) == static_cast<unsigned short int>(UCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned short int> decltype(auto) _ = std::saturate_cast<unsigned short int>(SCHAR_MIN); }
|
||||
assert(std::saturate_cast<unsigned short int>( SHRT_MIN) == O_US);
|
||||
assert(std::saturate_cast<unsigned short int>( O_S) == O_US);
|
||||
assert(std::saturate_cast<unsigned short int>( SHRT_MAX) == static_cast<unsigned short int>(SHRT_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned short int> decltype(auto) _ = std::saturate_cast<unsigned short int>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned short int>( O_US) == O_US);
|
||||
assert(std::saturate_cast<unsigned short int>(USHRT_MAX) == USHRT_MAX);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned short int> decltype(auto) _ = std::saturate_cast<unsigned short int>(sBigMax); }
|
||||
assert(std::saturate_cast<unsigned short int>( sBigMin) == O_US); // saturated
|
||||
assert(std::saturate_cast<unsigned short int>( sZero) == O_US);
|
||||
assert(std::saturate_cast<unsigned short int>( sBigMax) == USHRT_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned short int> decltype(auto) _ = std::saturate_cast<unsigned short int>(uBigMax); }
|
||||
assert(std::saturate_cast<unsigned short int>( uZero) == O_US);
|
||||
assert(std::saturate_cast<unsigned short int>( uBigMax) == USHRT_MAX); // saturated
|
||||
|
||||
// unsigned int
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned int> decltype(auto) _ = std::saturate_cast<unsigned int>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned int>(SCHAR_MIN) == O_US);
|
||||
assert(std::saturate_cast<unsigned int>( O_UC) == 0U);
|
||||
assert(std::saturate_cast<unsigned int>(SCHAR_MAX) == static_cast<unsigned int>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned int> decltype(auto) _ = std::saturate_cast<unsigned int>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned int>( O_UC) == 0U);
|
||||
assert(std::saturate_cast<unsigned int>(UCHAR_MAX) == static_cast<unsigned int>(UCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned int> decltype(auto) _ = std::saturate_cast<unsigned int>(INT_MAX); }
|
||||
assert(std::saturate_cast<unsigned int>( INT_MIN) == 0U);
|
||||
assert(std::saturate_cast<unsigned int>( 0) == 0U);
|
||||
assert(std::saturate_cast<unsigned int>( INT_MAX) == static_cast<unsigned int>(INT_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned int> decltype(auto) _ = std::saturate_cast<unsigned int>(UINT_MAX); }
|
||||
assert(std::saturate_cast<unsigned int>( 0U) == 0U);
|
||||
assert(std::saturate_cast<unsigned int>( UINT_MAX) == UINT_MAX);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned int> decltype(auto) _ = std::saturate_cast<unsigned int>(sBigMax); }
|
||||
assert(std::saturate_cast<unsigned int>( sBigMin) == 0U); // saturated
|
||||
assert(std::saturate_cast<unsigned int>( sZero) == 0U);
|
||||
assert(std::saturate_cast<unsigned int>( sBigMax) == UINT_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned int> decltype(auto) _ = std::saturate_cast<unsigned int>(uBigMax); }
|
||||
assert(std::saturate_cast<unsigned int>( uZero) == 0U);
|
||||
assert(std::saturate_cast<unsigned int>( uBigMax) == UINT_MAX); // saturated
|
||||
|
||||
// unsigned long
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long int> decltype(auto) _ = std::saturate_cast<unsigned long int>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned long int>(SCHAR_MIN) == 0UL);
|
||||
assert(std::saturate_cast<unsigned long int>( O_C) == 0UL);
|
||||
assert(std::saturate_cast<unsigned long int>(SCHAR_MAX) == static_cast<unsigned long int>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long int> decltype(auto) _ = std::saturate_cast<unsigned long int>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned long int>( O_UC) == 0UL);
|
||||
assert(std::saturate_cast<unsigned long int>(UCHAR_MAX) == static_cast<unsigned long int>(UCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long int> decltype(auto) _ = std::saturate_cast<unsigned long int>(LONG_MAX); }
|
||||
assert(std::saturate_cast<unsigned long int>( LONG_MIN) == 0UL);
|
||||
assert(std::saturate_cast<unsigned long int>( 0L) == 0UL);
|
||||
assert(std::saturate_cast<unsigned long int>( LONG_MAX) == static_cast<unsigned long int>(LONG_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long int> decltype(auto) _ = std::saturate_cast<unsigned long int>(ULONG_MAX); }
|
||||
assert(std::saturate_cast<unsigned long int>( 0UL) == 0UL);
|
||||
assert(std::saturate_cast<unsigned long int>(ULONG_MAX) == ULONG_MAX);
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long int> decltype(auto) _ = std::saturate_cast<unsigned long int>(sBigMax); }
|
||||
assert(std::saturate_cast<unsigned long int>( sBigMin) == 0UL); // saturated
|
||||
assert(std::saturate_cast<unsigned long int>( sZero) == 0UL);
|
||||
assert(std::saturate_cast<unsigned long int>( sBigMax) == ULONG_MAX); // saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long int> decltype(auto) _ = std::saturate_cast<unsigned long int>(uBigMax); }
|
||||
assert(std::saturate_cast<unsigned long int>( uZero) == 0UL);
|
||||
assert(std::saturate_cast<unsigned long int>( uBigMax) == ULONG_MAX); // saturated
|
||||
|
||||
// unsigned long long
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long long int> decltype(auto) _ = std::saturate_cast<unsigned long long int>(SCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned long long int>( SCHAR_MIN) == 0ULL);
|
||||
assert(std::saturate_cast<unsigned long long int>( O_C) == 0ULL);
|
||||
assert(std::saturate_cast<unsigned long long int>( SCHAR_MAX) == static_cast<unsigned long long int>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long long int> decltype(auto) _ = std::saturate_cast<unsigned long long int>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<unsigned long long int>( O_UC) == 0ULL);
|
||||
assert(std::saturate_cast<unsigned long long int>( UCHAR_MAX) == static_cast<unsigned long long int>(UCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long long int> decltype(auto) _ = std::saturate_cast<unsigned long long int>(LLONG_MAX); }
|
||||
assert(std::saturate_cast<unsigned long long int>( LLONG_MIN) == 0ULL);
|
||||
assert(std::saturate_cast<unsigned long long int>( 0LL) == 0ULL);
|
||||
assert(std::saturate_cast<unsigned long long int>( LLONG_MAX) == static_cast<unsigned long long int>(LLONG_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long long int> decltype(auto) _ = std::saturate_cast<unsigned long long int>(ULLONG_MAX); }
|
||||
assert(std::saturate_cast<unsigned long long int>( 0ULL) == 0ULL);
|
||||
assert(std::saturate_cast<unsigned long long int>(ULLONG_MAX) == ULLONG_MAX);
|
||||
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
{ [[maybe_unused]] std::same_as<unsigned long long int> decltype(auto) _ = std::saturate_cast<unsigned long long int>(sBigMax); }
|
||||
assert(std::saturate_cast<unsigned long long int>( sBigMin) == 0ULL); // (128-bit) saturated
|
||||
assert(std::saturate_cast<unsigned long long int>( sZero) == 0ULL);
|
||||
assert(std::saturate_cast<unsigned long long int>( sBigMax) == ULLONG_MAX); // (128-bit) saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<unsigned long long int> decltype(auto) _ = std::saturate_cast<unsigned long long int>(uBigMax); }
|
||||
assert(std::saturate_cast<unsigned long long int>( uZero) == 0ULL);
|
||||
assert(std::saturate_cast<unsigned long long int>( uBigMax) == ULLONG_MAX); // (128-bit) saturated
|
||||
|
||||
{ [[maybe_unused]] std::same_as<__uint128_t> decltype(auto) _ = std::saturate_cast<__uint128_t>(SCHAR_MIN); }
|
||||
assert(std::saturate_cast<__uint128_t>(SCHAR_MIN) == uZero);
|
||||
assert(std::saturate_cast<__uint128_t>( O_C) == uZero);
|
||||
assert(std::saturate_cast<__uint128_t>(SCHAR_MAX) == static_cast<__uint128_t>(SCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<__uint128_t> decltype(auto) _ = std::saturate_cast<__uint128_t>(UCHAR_MAX); }
|
||||
assert(std::saturate_cast<__uint128_t>( O_UC) == uZero);
|
||||
assert(std::saturate_cast<__uint128_t>(UCHAR_MAX) == static_cast<__uint128_t>(UCHAR_MAX));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<__uint128_t> decltype(auto) _ = std::saturate_cast<__uint128_t>(sBigMax); }
|
||||
assert(std::saturate_cast<__uint128_t>( sBigMin) == uZero); // saturated
|
||||
assert(std::saturate_cast<__uint128_t>( sZero) == uZero);
|
||||
assert(std::saturate_cast<__uint128_t>( sBigMax) == static_cast<__uint128_t>(sBigMax));
|
||||
|
||||
{ [[maybe_unused]] std::same_as<__uint128_t> decltype(auto) _ = std::saturate_cast<__uint128_t>(uBigMax); }
|
||||
assert(std::saturate_cast<__uint128_t>( uZero) == uZero);
|
||||
assert(std::saturate_cast<__uint128_t>( uBigMax) == uBigMax);
|
||||
#endif
|
||||
|
||||
// clang-format on
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int main(int, char**) {
|
||||
test();
|
||||
static_assert(test());
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,77 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class T>
|
||||
// constexpr T sub_sat(T x, T y) noexcept; // freestanding
|
||||
|
||||
#include <concepts>
|
||||
#include <numeric>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T, typename U>
|
||||
concept CanDo = requires(T x, U y) {
|
||||
{ std::sub_sat(x, y) } -> std::same_as<T>;
|
||||
};
|
||||
|
||||
template <typename T, typename U>
|
||||
constexpr void test_constraint_success() {
|
||||
static_assert(CanDo<T, T>);
|
||||
static_assert(!CanDo<U, T>);
|
||||
static_assert(!CanDo<T, U>);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr void test_constraint_fail() {
|
||||
using I = int;
|
||||
static_assert(!CanDo<T, T>);
|
||||
static_assert(!CanDo<I, T>);
|
||||
static_assert(!CanDo<T, I>);
|
||||
}
|
||||
|
||||
constexpr void test() {
|
||||
// Contraint success - Signed
|
||||
using SI = long long int;
|
||||
test_constraint_success<signed char, SI>();
|
||||
test_constraint_success<short int, SI>();
|
||||
test_constraint_success<signed char, SI>();
|
||||
test_constraint_success<short int, SI>();
|
||||
test_constraint_success<int, SI>();
|
||||
test_constraint_success<long int, SI>();
|
||||
test_constraint_success<long long int, int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_success<__int128_t, SI>();
|
||||
#endif
|
||||
// Contraint success - Unsigned
|
||||
using UI = unsigned long long int;
|
||||
test_constraint_success<unsigned char, UI>();
|
||||
test_constraint_success<unsigned short int, UI>();
|
||||
test_constraint_success<unsigned int, UI>();
|
||||
test_constraint_success<unsigned long int, UI>();
|
||||
test_constraint_success<unsigned long long int, unsigned int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_success<__uint128_t, UI>();
|
||||
#endif
|
||||
|
||||
// Contraint failure
|
||||
test_constraint_fail<bool>();
|
||||
test_constraint_fail<char>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_constraint_fail<wchar_t>();
|
||||
#endif
|
||||
test_constraint_fail<char8_t>();
|
||||
test_constraint_fail<char16_t>();
|
||||
test_constraint_fail<char32_t>();
|
||||
test_constraint_fail<float>();
|
||||
test_constraint_fail<double>();
|
||||
test_constraint_fail<long double>();
|
||||
}
|
||||
@ -0,0 +1,162 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
|
||||
// The test uses "Placeholder variables with no name"
|
||||
|
||||
// <numeric>
|
||||
|
||||
// template<class T>
|
||||
// constexpr T sub_sat(T x, T y) noexcept; // freestanding
|
||||
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <limits>
|
||||
#include <numeric>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename IntegerT>
|
||||
constexpr bool test_signed() {
|
||||
constexpr auto minVal = std::numeric_limits<IntegerT>::min();
|
||||
constexpr auto maxVal = std::numeric_limits<IntegerT>::max();
|
||||
|
||||
// TODO(LLVM-20) remove [[maybe_unused]] since all supported compilers support "Placeholder variables with no name"
|
||||
[[maybe_unused]] std::same_as<IntegerT> decltype(auto) _ = std::sub_sat(minVal, maxVal);
|
||||
|
||||
static_assert(noexcept(std::sub_sat(minVal, maxVal)));
|
||||
|
||||
// clang-format off
|
||||
|
||||
// Limit values (-1, 0, 1, min, max)
|
||||
|
||||
assert(std::sub_sat(IntegerT{-1}, IntegerT{-1}) == IntegerT{ 0});
|
||||
assert(std::sub_sat(IntegerT{-1}, IntegerT{ 0}) == IntegerT{-1});
|
||||
assert(std::sub_sat(IntegerT{-1}, IntegerT{ 1}) == IntegerT{-2});
|
||||
assert(std::sub_sat(IntegerT{-1}, minVal) == IntegerT{-1} - minVal);
|
||||
assert(std::sub_sat(IntegerT{-1}, maxVal) == IntegerT{-1} - maxVal);
|
||||
|
||||
assert(std::sub_sat(IntegerT{ 0}, IntegerT{-1}) == IntegerT{ 1});
|
||||
assert(std::sub_sat(IntegerT{ 0}, IntegerT{ 0}) == IntegerT{ 0});
|
||||
assert(std::sub_sat(IntegerT{ 0}, IntegerT{ 1}) == IntegerT{-1});
|
||||
assert(std::sub_sat(IntegerT{ 0}, minVal) == maxVal); // saturated
|
||||
assert(std::sub_sat(IntegerT{ 0}, maxVal) == -maxVal);
|
||||
|
||||
assert(std::sub_sat( minVal, IntegerT{-1}) == minVal - IntegerT{-1});
|
||||
assert(std::sub_sat( minVal, IntegerT{ 0}) == minVal);
|
||||
assert(std::sub_sat( minVal, IntegerT{ 1}) == minVal); // saturated
|
||||
assert(std::sub_sat( minVal, minVal) == IntegerT{0});
|
||||
assert(std::sub_sat( minVal, maxVal) == minVal); // saturated
|
||||
|
||||
assert(std::sub_sat( maxVal, IntegerT{-1}) == maxVal); // saturated
|
||||
assert(std::sub_sat( maxVal, IntegerT{ 0}) == maxVal);
|
||||
assert(std::sub_sat( maxVal, IntegerT{ 1}) == maxVal - IntegerT{ 1});
|
||||
assert(std::sub_sat( maxVal, minVal) == maxVal); // saturated
|
||||
assert(std::sub_sat( maxVal, maxVal) == IntegerT{0});
|
||||
|
||||
// No saturation (no limit values)
|
||||
|
||||
assert(std::sub_sat(IntegerT{ 27}, IntegerT{-28}) == 55);
|
||||
assert(std::sub_sat(IntegerT{ 27}, IntegerT{ 28}) == -1);
|
||||
assert(std::sub_sat(IntegerT{-27}, IntegerT{ 28}) == -55);
|
||||
assert(std::sub_sat(IntegerT{-27}, IntegerT{-28}) == 1);
|
||||
|
||||
// Saturation (no limit values)
|
||||
|
||||
{
|
||||
constexpr IntegerT lesserVal = minVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT biggerVal = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::sub_sat(lesserVal, biggerVal) == minVal); // saturated
|
||||
}
|
||||
{
|
||||
constexpr IntegerT biggerVal = maxVal / IntegerT{2} + IntegerT{28};
|
||||
constexpr IntegerT lesserVal = minVal / IntegerT{2} + IntegerT{27};
|
||||
assert(std::sub_sat(biggerVal, lesserVal) == maxVal); // saturated
|
||||
}
|
||||
|
||||
// clang-format on
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename IntegerT>
|
||||
constexpr bool test_unsigned() {
|
||||
constexpr auto minVal = std::numeric_limits<IntegerT>::min();
|
||||
constexpr auto maxVal = std::numeric_limits<IntegerT>::max();
|
||||
|
||||
// TODO(LLVM-20) remove [[maybe_unused]] since all supported compilers support "Placeholder variables with no name"
|
||||
[[maybe_unused]] std::same_as<IntegerT> decltype(auto) _ = std::sub_sat(minVal, maxVal);
|
||||
|
||||
static_assert(noexcept(std::sub_sat(minVal, maxVal)));
|
||||
|
||||
// clang-format off
|
||||
|
||||
// Limit values (0, 1, min, max)
|
||||
|
||||
assert(std::sub_sat(IntegerT{0}, IntegerT{0}) == IntegerT{0});
|
||||
assert(std::sub_sat(IntegerT{0}, IntegerT{1}) == minVal); // saturated
|
||||
assert(std::sub_sat(IntegerT{0}, minVal) == minVal);
|
||||
assert(std::sub_sat(IntegerT{0}, maxVal) == minVal); // saturated
|
||||
|
||||
assert(std::sub_sat(IntegerT{1}, IntegerT{0}) == IntegerT{1});
|
||||
assert(std::sub_sat(IntegerT{1}, IntegerT{1}) == IntegerT{0});
|
||||
assert(std::sub_sat(IntegerT{1}, minVal) == IntegerT{1});
|
||||
assert(std::sub_sat(IntegerT{1}, maxVal) == minVal); // saturated
|
||||
|
||||
assert(std::sub_sat( minVal, IntegerT{0}) == IntegerT{0});
|
||||
assert(std::sub_sat( minVal, IntegerT{1}) == minVal);
|
||||
assert(std::sub_sat( minVal, maxVal) == minVal);
|
||||
assert(std::sub_sat( minVal, maxVal) == minVal);
|
||||
|
||||
assert(std::sub_sat( maxVal, IntegerT{0}) == maxVal);
|
||||
assert(std::sub_sat( maxVal, IntegerT{1}) == maxVal - IntegerT{1});
|
||||
assert(std::sub_sat( maxVal, minVal) == maxVal);
|
||||
assert(std::sub_sat( maxVal, maxVal) == IntegerT{0});
|
||||
|
||||
// Saturation (no limit values)
|
||||
|
||||
{
|
||||
constexpr IntegerT lesserVal = minVal / IntegerT{2} + IntegerT{27};
|
||||
constexpr IntegerT biggerVal = maxVal / IntegerT{2} + IntegerT{28};
|
||||
assert(std::sub_sat(lesserVal, biggerVal) == minVal); // saturated
|
||||
}
|
||||
|
||||
// clang-format on
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
constexpr bool test() {
|
||||
// Signed
|
||||
test_signed<signed char>();
|
||||
test_signed<short int>();
|
||||
test_signed<int>();
|
||||
test_signed<long int>();
|
||||
test_signed<long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_signed<__int128_t>();
|
||||
#endif
|
||||
// Unsigned
|
||||
test_unsigned<unsigned char>();
|
||||
test_unsigned<unsigned short int>();
|
||||
test_unsigned<unsigned int>();
|
||||
test_unsigned<unsigned long int>();
|
||||
test_unsigned<unsigned long long int>();
|
||||
#ifndef TEST_HAS_NO_INT128
|
||||
test_unsigned<__uint128_t>();
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int main(int, char**) {
|
||||
test();
|
||||
static_assert(test());
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1011,10 +1011,7 @@ feature_test_macros = [
|
||||
{
|
||||
"name": "__cpp_lib_saturation_arithmetic",
|
||||
"values": {"c++26": 202311}, # P0543R3 Saturation arithmetic
|
||||
"headers": [
|
||||
"numeric" # TODO verify this entry since the paper was underspecified.
|
||||
],
|
||||
"unimplemented": True,
|
||||
"headers": ["numeric"],
|
||||
},
|
||||
{
|
||||
"name": "__cpp_lib_scoped_lock",
|
||||
|
||||
Loading…
Reference in New Issue
Block a user