[libc-commits] [libc] [libc] Fix for adding macro I (PR #111872)
Shourya Goel via libc-commits
libc-commits at lists.llvm.org
Fri Oct 11 12:01:32 PDT 2024
https://github.com/Sh0g0-1758 updated https://github.com/llvm/llvm-project/pull/111872
>From 357833beaf32bb55178b80b95ab5d7be7ca6f104 Mon Sep 17 00:00:00 2001
From: Sh0g0-1758 <shouryagoel10000 at gmail.com>
Date: Thu, 10 Oct 2024 22:28:54 +0530
Subject: [PATCH 1/6] fix
---
libc/src/__support/CPP/string_view.h | 4 ++--
libc/src/__support/CPP/utility/in_place.h | 6 +++---
2 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/libc/src/__support/CPP/string_view.h b/libc/src/__support/CPP/string_view.h
index 88f5270c3170a3..745c62c35f0a0a 100644
--- a/libc/src/__support/CPP/string_view.h
+++ b/libc/src/__support/CPP/string_view.h
@@ -31,8 +31,8 @@ class string_view {
LIBC_INLINE static int compareMemory(const char *Lhs, const char *Rhs,
size_t Length) {
- for (size_t I = 0; I < Length; ++I)
- if (int Diff = (int)Lhs[I] - (int)Rhs[I])
+ for (size_t i = 0; i < Length; ++i)
+ if (int Diff = (int)Lhs[i] - (int)Rhs[i])
return Diff;
return 0;
}
diff --git a/libc/src/__support/CPP/utility/in_place.h b/libc/src/__support/CPP/utility/in_place.h
index b5411f247d5519..3967eb1c535e45 100644
--- a/libc/src/__support/CPP/utility/in_place.h
+++ b/libc/src/__support/CPP/utility/in_place.h
@@ -27,11 +27,11 @@ template <class T> struct in_place_type_t {
};
template <class T> LIBC_INLINE_VAR constexpr in_place_type_t<T> in_place_type{};
-template <size_t I> struct in_place_index_t {
+template <size_t IDX> struct in_place_index_t {
LIBC_INLINE explicit in_place_index_t() = default;
};
-template <size_t I>
-LIBC_INLINE_VAR constexpr in_place_index_t<I> in_place_index{};
+template <size_t IDX>
+LIBC_INLINE_VAR constexpr in_place_index_t<IDX> in_place_index{};
} // namespace cpp
} // namespace LIBC_NAMESPACE_DECL
>From 1d2fe2f4c105a702d3bf10b310a1e1f11d4a7a58 Mon Sep 17 00:00:00 2001
From: Sh0g0-1758 <shouryagoel10000 at gmail.com>
Date: Fri, 11 Oct 2024 23:07:30 +0530
Subject: [PATCH 2/6] fix
---
.../FPUtil/NearestIntegerOperations.h | 43 +++++-----
libc/test/src/math/RoundToIntegerTest.h | 83 ++++++++++---------
2 files changed, 65 insertions(+), 61 deletions(-)
diff --git a/libc/src/__support/FPUtil/NearestIntegerOperations.h b/libc/src/__support/FPUtil/NearestIntegerOperations.h
index e4e497b898e83a..d8b72ae0aa3bd7 100644
--- a/libc/src/__support/FPUtil/NearestIntegerOperations.h
+++ b/libc/src/__support/FPUtil/NearestIntegerOperations.h
@@ -346,12 +346,13 @@ fromfpx(T x, int rnd, unsigned int width) {
namespace internal {
-template <typename F, typename I,
- cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
- int> = 0>
-LIBC_INLINE I rounded_float_to_signed_integer(F x) {
- constexpr I INTEGER_MIN = (I(1) << (sizeof(I) * 8 - 1));
- constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
+template <
+ typename F, typename InType,
+ cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<InType>,
+ int> = 0>
+LIBC_INLINE InType rounded_float_to_signed_integer(F x) {
+ constexpr InType INTEGER_MIN = (InType(1) << (sizeof(InType) * 8 - 1));
+ constexpr InType INTEGER_MAX = -(INTEGER_MIN + 1);
FPBits<F> bits(x);
auto set_domain_error_and_raise_invalid = []() {
set_errno_if_required(EDOM);
@@ -364,7 +365,7 @@ LIBC_INLINE I rounded_float_to_signed_integer(F x) {
}
int exponent = bits.get_exponent();
- constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1;
+ constexpr int EXPONENT_LIMIT = sizeof(InType) * 8 - 1;
if (exponent > EXPONENT_LIMIT) {
set_domain_error_and_raise_invalid();
return bits.is_neg() ? INTEGER_MIN : INTEGER_MAX;
@@ -374,29 +375,31 @@ LIBC_INLINE I rounded_float_to_signed_integer(F x) {
return bits.is_neg() ? INTEGER_MIN : INTEGER_MAX;
}
// If the control reaches here, then it means that the rounded
- // value is the most negative number for the signed integer type I.
+ // value is the most negative number for the signed integer type InType.
}
- // For all other cases, if `x` can fit in the integer type `I`,
+ // For all other cases, if `x` can fit in the integer type `InType`,
// we just return `x`. static_cast will convert the floating
// point value to the exact integer value.
- return static_cast<I>(x);
+ return static_cast<InType>(x);
}
} // namespace internal
-template <typename F, typename I,
- cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
- int> = 0>
-LIBC_INLINE I round_to_signed_integer(F x) {
- return internal::rounded_float_to_signed_integer<F, I>(round(x));
+template <
+ typename F, typename InType,
+ cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<InType>,
+ int> = 0>
+LIBC_INLINE InType round_to_signed_integer(F x) {
+ return internal::rounded_float_to_signed_integer<F, InType>(round(x));
}
-template <typename F, typename I,
- cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
- int> = 0>
-LIBC_INLINE I round_to_signed_integer_using_current_rounding_mode(F x) {
- return internal::rounded_float_to_signed_integer<F, I>(
+template <
+ typename F, typename InType,
+ cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<InType>,
+ int> = 0>
+LIBC_INLINE InType round_to_signed_integer_using_current_rounding_mode(F x) {
+ return internal::rounded_float_to_signed_integer<F, InType>(
round_using_current_rounding_mode(x));
}
diff --git a/libc/test/src/math/RoundToIntegerTest.h b/libc/test/src/math/RoundToIntegerTest.h
index 995aba7b233ec8..9ee9a40b9d26fd 100644
--- a/libc/test/src/math/RoundToIntegerTest.h
+++ b/libc/test/src/math/RoundToIntegerTest.h
@@ -26,11 +26,11 @@ using LIBC_NAMESPACE::Sign;
static constexpr int ROUNDING_MODES[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
FE_TONEAREST};
-template <typename F, typename I, bool TestModes = false>
+template <typename F, typename OutType, bool TestModes = false>
class RoundToIntegerTestTemplate
: public LIBC_NAMESPACE::testing::FEnvSafeTest {
public:
- typedef I (*RoundToIntegerFunc)(F);
+ typedef OutType (*RoundToIntegerFunc)(F);
private:
using FPBits = LIBC_NAMESPACE::fputil::FPBits<F>;
@@ -49,10 +49,11 @@ class RoundToIntegerTestTemplate
static constexpr StorageType MIN_SUBNORMAL =
FPBits::min_subnormal().uintval();
- static constexpr I INTEGER_MIN = I(1) << (sizeof(I) * 8 - 1);
- static constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
+ static constexpr OutType INTEGER_MIN = OutType(1)
+ << (sizeof(OutType) * 8 - 1);
+ static constexpr OutType INTEGER_MAX = -(INTEGER_MIN + 1);
- void test_one_input(RoundToIntegerFunc func, F input, I expected,
+ void test_one_input(RoundToIntegerFunc func, F input, OutType expected,
bool expectError) {
LIBC_NAMESPACE::libc_errno = 0;
LIBC_NAMESPACE::fputil::clear_except(FE_ALL_EXCEPT);
@@ -120,24 +121,24 @@ class RoundToIntegerTestTemplate
}
void do_round_numbers_test(RoundToIntegerFunc func) {
- test_one_input(func, zero, I(0), false);
- test_one_input(func, neg_zero, I(0), false);
- test_one_input(func, F(1.0), I(1), false);
- test_one_input(func, F(-1.0), I(-1), false);
- test_one_input(func, F(10.0), I(10), false);
- test_one_input(func, F(-10.0), I(-10), false);
- test_one_input(func, F(1234.0), I(1234), false);
- test_one_input(func, F(-1234.0), I(-1234), false);
+ test_one_input(func, zero, OutType(0), false);
+ test_one_input(func, neg_zero, OutType(0), false);
+ test_one_input(func, F(1.0), OutType(1), false);
+ test_one_input(func, F(-1.0), OutType(-1), false);
+ test_one_input(func, F(10.0), OutType(10), false);
+ test_one_input(func, F(-10.0), OutType(-10), false);
+ test_one_input(func, F(1234.0), OutType(1234), false);
+ test_one_input(func, F(-1234.0), OutType(-1234), false);
// The rest of this function compares with an equivalent MPFR function
// which rounds floating point numbers to long values. There is no MPFR
// function to round to long long or wider integer values. So, we will
- // the remaining tests only if the width of I less than equal to that of
- // long.
- if (sizeof(I) > sizeof(long))
+ // the remaining tests only if the width of OutType less than equal to that
+ // of long.
+ if (sizeof(OutType) > sizeof(long))
return;
- constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1;
+ constexpr int EXPONENT_LIMIT = sizeof(OutType) * 8 - 1;
constexpr int BIASED_EXPONENT_LIMIT = EXPONENT_LIMIT + FPBits::EXP_BIAS;
if (BIASED_EXPONENT_LIMIT > FPBits::MAX_BIASED_EXPONENT)
return;
@@ -179,7 +180,7 @@ class RoundToIntegerTestTemplate
else
erangeflag = mpfr::round_to_long(x, mpfr_long_result);
ASSERT_FALSE(erangeflag);
- I mpfr_result = mpfr_long_result;
+ OutType mpfr_result = mpfr_long_result;
test_one_input(func, x, mpfr_result, false);
}
}
@@ -201,12 +202,12 @@ class RoundToIntegerTestTemplate
// This function compares with an equivalent MPFR function which rounds
// floating point numbers to long values. There is no MPFR function to
// round to long long or wider integer values. So, we will peform the
- // comparisons in this function only if the width of I less than equal to
- // that of long.
- if (sizeof(I) > sizeof(long))
+ // comparisons in this function only if the width of OutType less than equal
+ // to that of long.
+ if (sizeof(OutType) > sizeof(long))
return;
- constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1;
+ constexpr int EXPONENT_LIMIT = sizeof(OutType) * 8 - 1;
constexpr int BIASED_EXPONENT_LIMIT = EXPONENT_LIMIT + FPBits::EXP_BIAS;
if (BIASED_EXPONENT_LIMIT > FPBits::MAX_BIASED_EXPONENT)
return;
@@ -248,22 +249,22 @@ class RoundToIntegerTestTemplate
if (TestModes) {
if (x > 0) {
LIBC_NAMESPACE::fputil::set_round(FE_UPWARD);
- test_one_input(func, x, I(1), false);
+ test_one_input(func, x, OutType(1), false);
LIBC_NAMESPACE::fputil::set_round(FE_DOWNWARD);
- test_one_input(func, x, I(0), false);
+ test_one_input(func, x, OutType(0), false);
LIBC_NAMESPACE::fputil::set_round(FE_TOWARDZERO);
- test_one_input(func, x, I(0), false);
+ test_one_input(func, x, OutType(0), false);
LIBC_NAMESPACE::fputil::set_round(FE_TONEAREST);
- test_one_input(func, x, I(0), false);
+ test_one_input(func, x, OutType(0), false);
} else {
LIBC_NAMESPACE::fputil::set_round(FE_UPWARD);
- test_one_input(func, x, I(0), false);
+ test_one_input(func, x, OutType(0), false);
LIBC_NAMESPACE::fputil::set_round(FE_DOWNWARD);
- test_one_input(func, x, I(-1), false);
+ test_one_input(func, x, OutType(-1), false);
LIBC_NAMESPACE::fputil::set_round(FE_TOWARDZERO);
- test_one_input(func, x, I(0), false);
+ test_one_input(func, x, OutType(0), false);
LIBC_NAMESPACE::fputil::set_round(FE_TONEAREST);
- test_one_input(func, x, I(0), false);
+ test_one_input(func, x, OutType(0), false);
}
} else {
test_one_input(func, x, 0L, false);
@@ -275,9 +276,9 @@ class RoundToIntegerTestTemplate
// This function compares with an equivalent MPFR function which rounds
// floating point numbers to long values. There is no MPFR function to
// round to long long or wider integer values. So, we will peform the
- // comparisons in this function only if the width of I less than equal to
- // that of long.
- if (sizeof(I) > sizeof(long))
+ // comparisons in this function only if the width of OutType less than equal
+ // to that of long.
+ if (sizeof(OutType) > sizeof(long))
return;
constexpr int COUNT = 1'000'001;
@@ -297,7 +298,7 @@ class RoundToIntegerTestTemplate
long mpfr_long_result;
bool erangeflag = mpfr::round_to_long(x, to_mpfr_rounding_mode(m),
mpfr_long_result);
- I mpfr_result = mpfr_long_result;
+ OutType mpfr_result = mpfr_long_result;
LIBC_NAMESPACE::fputil::set_round(m);
if (erangeflag)
test_one_input(func, x, x > 0 ? INTEGER_MAX : INTEGER_MIN, true);
@@ -307,7 +308,7 @@ class RoundToIntegerTestTemplate
} else {
long mpfr_long_result;
bool erangeflag = mpfr::round_to_long(x, mpfr_long_result);
- I mpfr_result = mpfr_long_result;
+ OutType mpfr_result = mpfr_long_result;
if (erangeflag)
test_one_input(func, x, x > 0 ? INTEGER_MAX : INTEGER_MIN, true);
else
@@ -317,9 +318,9 @@ class RoundToIntegerTestTemplate
}
};
-#define LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, I, func, TestModes) \
+#define LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, OutType, func, TestModes) \
using LlvmLibcRoundToIntegerTest = \
- RoundToIntegerTestTemplate<F, I, TestModes>; \
+ RoundToIntegerTestTemplate<F, OutType, TestModes>; \
TEST_F(LlvmLibcRoundToIntegerTest, InfinityAndNaN) { \
testInfinityAndNaN(&func); \
} \
@@ -335,10 +336,10 @@ class RoundToIntegerTestTemplate
} \
TEST_F(LlvmLibcRoundToIntegerTest, NormalRange) { testNormalRange(&func); }
-#define LIST_ROUND_TO_INTEGER_TESTS(F, I, func) \
- LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, I, func, false)
+#define LIST_ROUND_TO_INTEGER_TESTS(F, OutType, func) \
+ LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, OutType, func, false)
-#define LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(F, I, func) \
- LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, I, func, true)
+#define LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(F, OutType, func) \
+ LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, OutType, func, true)
#endif // LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H
>From 05a77ec9d699cf6233257741b3cd327201494a50 Mon Sep 17 00:00:00 2001
From: Sh0g0-1758 <shouryagoel10000 at gmail.com>
Date: Sat, 12 Oct 2024 00:11:22 +0530
Subject: [PATCH 3/6] nit
---
.../FPUtil/NearestIntegerOperations.h | 36 +++++++++----------
1 file changed, 18 insertions(+), 18 deletions(-)
diff --git a/libc/src/__support/FPUtil/NearestIntegerOperations.h b/libc/src/__support/FPUtil/NearestIntegerOperations.h
index d8b72ae0aa3bd7..b3653d3aba2840 100644
--- a/libc/src/__support/FPUtil/NearestIntegerOperations.h
+++ b/libc/src/__support/FPUtil/NearestIntegerOperations.h
@@ -347,13 +347,13 @@ fromfpx(T x, int rnd, unsigned int width) {
namespace internal {
template <
- typename F, typename InType,
- cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<InType>,
+ typename FloatType, typename IntType,
+ cpp::enable_if_t<cpp::is_floating_point_v<FloatType> && cpp::is_integral_v<IntType>,
int> = 0>
-LIBC_INLINE InType rounded_float_to_signed_integer(F x) {
- constexpr InType INTEGER_MIN = (InType(1) << (sizeof(InType) * 8 - 1));
- constexpr InType INTEGER_MAX = -(INTEGER_MIN + 1);
- FPBits<F> bits(x);
+LIBC_INLINE IntType rounded_float_to_signed_integer(FloatType x) {
+ constexpr IntType INTEGER_MIN = (IntType(1) << (sizeof(IntType) * 8 - 1));
+ constexpr IntType INTEGER_MAX = -(INTEGER_MIN + 1);
+ FPBits<FloatType> bits(x);
auto set_domain_error_and_raise_invalid = []() {
set_errno_if_required(EDOM);
raise_except_if_required(FE_INVALID);
@@ -365,7 +365,7 @@ LIBC_INLINE InType rounded_float_to_signed_integer(F x) {
}
int exponent = bits.get_exponent();
- constexpr int EXPONENT_LIMIT = sizeof(InType) * 8 - 1;
+ constexpr int EXPONENT_LIMIT = sizeof(IntType) * 8 - 1;
if (exponent > EXPONENT_LIMIT) {
set_domain_error_and_raise_invalid();
return bits.is_neg() ? INTEGER_MIN : INTEGER_MAX;
@@ -375,31 +375,31 @@ LIBC_INLINE InType rounded_float_to_signed_integer(F x) {
return bits.is_neg() ? INTEGER_MIN : INTEGER_MAX;
}
// If the control reaches here, then it means that the rounded
- // value is the most negative number for the signed integer type InType.
+ // value is the most negative number for the signed integer type IntType.
}
- // For all other cases, if `x` can fit in the integer type `InType`,
+ // For all other cases, if `x` can fit in the integer type `IntType`,
// we just return `x`. static_cast will convert the floating
// point value to the exact integer value.
- return static_cast<InType>(x);
+ return static_cast<IntType>(x);
}
} // namespace internal
template <
- typename F, typename InType,
- cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<InType>,
+ typename FloatType, typename IntType,
+ cpp::enable_if_t<cpp::is_floating_point_v<FloatType> && cpp::is_integral_v<IntType>,
int> = 0>
-LIBC_INLINE InType round_to_signed_integer(F x) {
- return internal::rounded_float_to_signed_integer<F, InType>(round(x));
+LIBC_INLINE IntType round_to_signed_integer(FloatType x) {
+ return internal::rounded_float_to_signed_integer<FloatType, IntType>(round(x));
}
template <
- typename F, typename InType,
- cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<InType>,
+ typename FloatType, typename IntType,
+ cpp::enable_if_t<cpp::is_floating_point_v<FloatType> && cpp::is_integral_v<IntType>,
int> = 0>
-LIBC_INLINE InType round_to_signed_integer_using_current_rounding_mode(F x) {
- return internal::rounded_float_to_signed_integer<F, InType>(
+LIBC_INLINE IntType round_to_signed_integer_using_current_rounding_mode(FloatType x) {
+ return internal::rounded_float_to_signed_integer<FloatType, IntType>(
round_using_current_rounding_mode(x));
}
>From 14b9ffdf6051a089c1df41413ebd845987f5a32f Mon Sep 17 00:00:00 2001
From: Sh0g0-1758 <shouryagoel10000 at gmail.com>
Date: Sat, 12 Oct 2024 00:11:39 +0530
Subject: [PATCH 4/6] fmt
---
.../FPUtil/NearestIntegerOperations.h | 30 ++++++++++---------
1 file changed, 16 insertions(+), 14 deletions(-)
diff --git a/libc/src/__support/FPUtil/NearestIntegerOperations.h b/libc/src/__support/FPUtil/NearestIntegerOperations.h
index b3653d3aba2840..93166614cc12a2 100644
--- a/libc/src/__support/FPUtil/NearestIntegerOperations.h
+++ b/libc/src/__support/FPUtil/NearestIntegerOperations.h
@@ -346,10 +346,10 @@ fromfpx(T x, int rnd, unsigned int width) {
namespace internal {
-template <
- typename FloatType, typename IntType,
- cpp::enable_if_t<cpp::is_floating_point_v<FloatType> && cpp::is_integral_v<IntType>,
- int> = 0>
+template <typename FloatType, typename IntType,
+ cpp::enable_if_t<cpp::is_floating_point_v<FloatType> &&
+ cpp::is_integral_v<IntType>,
+ int> = 0>
LIBC_INLINE IntType rounded_float_to_signed_integer(FloatType x) {
constexpr IntType INTEGER_MIN = (IntType(1) << (sizeof(IntType) * 8 - 1));
constexpr IntType INTEGER_MAX = -(INTEGER_MIN + 1);
@@ -386,19 +386,21 @@ LIBC_INLINE IntType rounded_float_to_signed_integer(FloatType x) {
} // namespace internal
-template <
- typename FloatType, typename IntType,
- cpp::enable_if_t<cpp::is_floating_point_v<FloatType> && cpp::is_integral_v<IntType>,
- int> = 0>
+template <typename FloatType, typename IntType,
+ cpp::enable_if_t<cpp::is_floating_point_v<FloatType> &&
+ cpp::is_integral_v<IntType>,
+ int> = 0>
LIBC_INLINE IntType round_to_signed_integer(FloatType x) {
- return internal::rounded_float_to_signed_integer<FloatType, IntType>(round(x));
+ return internal::rounded_float_to_signed_integer<FloatType, IntType>(
+ round(x));
}
-template <
- typename FloatType, typename IntType,
- cpp::enable_if_t<cpp::is_floating_point_v<FloatType> && cpp::is_integral_v<IntType>,
- int> = 0>
-LIBC_INLINE IntType round_to_signed_integer_using_current_rounding_mode(FloatType x) {
+template <typename FloatType, typename IntType,
+ cpp::enable_if_t<cpp::is_floating_point_v<FloatType> &&
+ cpp::is_integral_v<IntType>,
+ int> = 0>
+LIBC_INLINE IntType
+round_to_signed_integer_using_current_rounding_mode(FloatType x) {
return internal::rounded_float_to_signed_integer<FloatType, IntType>(
round_using_current_rounding_mode(x));
}
>From bca929a3c97567027e6710407d089e6c9244399d Mon Sep 17 00:00:00 2001
From: Sh0g0-1758 <shouryagoel10000 at gmail.com>
Date: Sat, 12 Oct 2024 00:30:51 +0530
Subject: [PATCH 5/6] nit
---
libc/test/src/math/RoundToIntegerTest.h | 110 ++++++++++++------------
1 file changed, 55 insertions(+), 55 deletions(-)
diff --git a/libc/test/src/math/RoundToIntegerTest.h b/libc/test/src/math/RoundToIntegerTest.h
index 9ee9a40b9d26fd..4b89a8fffbb8dd 100644
--- a/libc/test/src/math/RoundToIntegerTest.h
+++ b/libc/test/src/math/RoundToIntegerTest.h
@@ -26,21 +26,21 @@ using LIBC_NAMESPACE::Sign;
static constexpr int ROUNDING_MODES[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
FE_TONEAREST};
-template <typename F, typename OutType, bool TestModes = false>
+template <typename FloatType, typename IntType, bool TestModes = false>
class RoundToIntegerTestTemplate
: public LIBC_NAMESPACE::testing::FEnvSafeTest {
public:
- typedef OutType (*RoundToIntegerFunc)(F);
+ typedef IntType (*RoundToIntegerFunc)(FloatType);
private:
- using FPBits = LIBC_NAMESPACE::fputil::FPBits<F>;
+ using FPBits = LIBC_NAMESPACE::fputil::FPBits<FloatType>;
using StorageType = typename FPBits::StorageType;
- const F zero = FPBits::zero().get_val();
- const F neg_zero = FPBits::zero(Sign::NEG).get_val();
- const F inf = FPBits::inf().get_val();
- const F neg_inf = FPBits::inf(Sign::NEG).get_val();
- const F nan = FPBits::quiet_nan().get_val();
+ const FloatType zero = FPBits::zero().get_val();
+ const FloatType neg_zero = FPBits::zero(Sign::NEG).get_val();
+ const FloatType inf = FPBits::inf().get_val();
+ const FloatType neg_inf = FPBits::inf(Sign::NEG).get_val();
+ const FloatType nan = FPBits::quiet_nan().get_val();
static constexpr StorageType MAX_NORMAL = FPBits::max_normal().uintval();
static constexpr StorageType MIN_NORMAL = FPBits::min_normal().uintval();
@@ -49,11 +49,11 @@ class RoundToIntegerTestTemplate
static constexpr StorageType MIN_SUBNORMAL =
FPBits::min_subnormal().uintval();
- static constexpr OutType INTEGER_MIN = OutType(1)
- << (sizeof(OutType) * 8 - 1);
- static constexpr OutType INTEGER_MAX = -(INTEGER_MIN + 1);
+ static constexpr IntType INTEGER_MIN = IntType(1)
+ << (sizeof(IntType) * 8 - 1);
+ static constexpr IntType INTEGER_MAX = -(INTEGER_MIN + 1);
- void test_one_input(RoundToIntegerFunc func, F input, OutType expected,
+ void test_one_input(RoundToIntegerFunc func, FloatType input, IntType expected,
bool expectError) {
LIBC_NAMESPACE::libc_errno = 0;
LIBC_NAMESPACE::fputil::clear_except(FE_ALL_EXCEPT);
@@ -121,35 +121,35 @@ class RoundToIntegerTestTemplate
}
void do_round_numbers_test(RoundToIntegerFunc func) {
- test_one_input(func, zero, OutType(0), false);
- test_one_input(func, neg_zero, OutType(0), false);
- test_one_input(func, F(1.0), OutType(1), false);
- test_one_input(func, F(-1.0), OutType(-1), false);
- test_one_input(func, F(10.0), OutType(10), false);
- test_one_input(func, F(-10.0), OutType(-10), false);
- test_one_input(func, F(1234.0), OutType(1234), false);
- test_one_input(func, F(-1234.0), OutType(-1234), false);
+ test_one_input(func, zero, IntType(0), false);
+ test_one_input(func, neg_zero, IntType(0), false);
+ test_one_input(func, FloatType(1.0), IntType(1), false);
+ test_one_input(func, FloatType(-1.0), IntType(-1), false);
+ test_one_input(func, FloatType(10.0), IntType(10), false);
+ test_one_input(func, FloatType(-10.0), IntType(-10), false);
+ test_one_input(func, FloatType(1234.0), IntType(1234), false);
+ test_one_input(func, FloatType(-1234.0), IntType(-1234), false);
// The rest of this function compares with an equivalent MPFR function
// which rounds floating point numbers to long values. There is no MPFR
// function to round to long long or wider integer values. So, we will
- // the remaining tests only if the width of OutType less than equal to that
+ // the remaining tests only if the width of IntType less than equal to that
// of long.
- if (sizeof(OutType) > sizeof(long))
+ if (sizeof(IntType) > sizeof(long))
return;
- constexpr int EXPONENT_LIMIT = sizeof(OutType) * 8 - 1;
+ constexpr int EXPONENT_LIMIT = sizeof(IntType) * 8 - 1;
constexpr int BIASED_EXPONENT_LIMIT = EXPONENT_LIMIT + FPBits::EXP_BIAS;
if (BIASED_EXPONENT_LIMIT > FPBits::MAX_BIASED_EXPONENT)
return;
// We start with 1.0 so that the implicit bit for x86 long doubles
// is set.
- FPBits bits(F(1.0));
+ FPBits bits(FloatType(1.0));
bits.set_biased_exponent(BIASED_EXPONENT_LIMIT);
bits.set_sign(Sign::NEG);
bits.set_mantissa(0);
- F x = bits.get_val();
+ FloatType x = bits.get_val();
long mpfr_result;
bool erangeflag = mpfr::round_to_long(x, mpfr_result);
ASSERT_FALSE(erangeflag);
@@ -168,10 +168,10 @@ class RoundToIntegerTestTemplate
}
void do_fractions_test(RoundToIntegerFunc func, int mode) {
- constexpr F FRACTIONS[] = {
- F(0.5), F(-0.5), F(0.115), F(-0.115), F(0.715), F(-0.715),
+ constexpr FloatType FRACTIONS[] = {
+ FloatType(0.5), FloatType(-0.5), FloatType(0.115), FloatType(-0.115), FloatType(0.715), FloatType(-0.715),
};
- for (F x : FRACTIONS) {
+ for (FloatType x : FRACTIONS) {
long mpfr_long_result;
bool erangeflag;
if (TestModes)
@@ -180,7 +180,7 @@ class RoundToIntegerTestTemplate
else
erangeflag = mpfr::round_to_long(x, mpfr_long_result);
ASSERT_FALSE(erangeflag);
- OutType mpfr_result = mpfr_long_result;
+ IntType mpfr_result = mpfr_long_result;
test_one_input(func, x, mpfr_result, false);
}
}
@@ -202,23 +202,23 @@ class RoundToIntegerTestTemplate
// This function compares with an equivalent MPFR function which rounds
// floating point numbers to long values. There is no MPFR function to
// round to long long or wider integer values. So, we will peform the
- // comparisons in this function only if the width of OutType less than equal
+ // comparisons in this function only if the width of IntType less than equal
// to that of long.
- if (sizeof(OutType) > sizeof(long))
+ if (sizeof(IntType) > sizeof(long))
return;
- constexpr int EXPONENT_LIMIT = sizeof(OutType) * 8 - 1;
+ constexpr int EXPONENT_LIMIT = sizeof(IntType) * 8 - 1;
constexpr int BIASED_EXPONENT_LIMIT = EXPONENT_LIMIT + FPBits::EXP_BIAS;
if (BIASED_EXPONENT_LIMIT > FPBits::MAX_BIASED_EXPONENT)
return;
// We start with 1.0 so that the implicit bit for x86 long doubles
// is set.
- FPBits bits(F(1.0));
+ FPBits bits(FloatType(1.0));
bits.set_biased_exponent(BIASED_EXPONENT_LIMIT);
bits.set_sign(Sign::NEG);
bits.set_mantissa(FPBits::FRACTION_MASK);
- F x = bits.get_val();
+ FloatType x = bits.get_val();
if (TestModes) {
for (int m : ROUNDING_MODES) {
LIBC_NAMESPACE::fputil::set_round(m);
@@ -242,29 +242,29 @@ class RoundToIntegerTestTemplate
static_cast<StorageType>((MAX_SUBNORMAL - MIN_SUBNORMAL) / COUNT),
StorageType(1));
for (StorageType i = MIN_SUBNORMAL; i <= MAX_SUBNORMAL; i += STEP) {
- F x = FPBits(i).get_val();
- if (x == F(0.0))
+ FloatType x = FPBits(i).get_val();
+ if (x == FloatType(0.0))
continue;
// All subnormal numbers should round to zero.
if (TestModes) {
if (x > 0) {
LIBC_NAMESPACE::fputil::set_round(FE_UPWARD);
- test_one_input(func, x, OutType(1), false);
+ test_one_input(func, x, IntType(1), false);
LIBC_NAMESPACE::fputil::set_round(FE_DOWNWARD);
- test_one_input(func, x, OutType(0), false);
+ test_one_input(func, x, IntType(0), false);
LIBC_NAMESPACE::fputil::set_round(FE_TOWARDZERO);
- test_one_input(func, x, OutType(0), false);
+ test_one_input(func, x, IntType(0), false);
LIBC_NAMESPACE::fputil::set_round(FE_TONEAREST);
- test_one_input(func, x, OutType(0), false);
+ test_one_input(func, x, IntType(0), false);
} else {
LIBC_NAMESPACE::fputil::set_round(FE_UPWARD);
- test_one_input(func, x, OutType(0), false);
+ test_one_input(func, x, IntType(0), false);
LIBC_NAMESPACE::fputil::set_round(FE_DOWNWARD);
- test_one_input(func, x, OutType(-1), false);
+ test_one_input(func, x, IntType(-1), false);
LIBC_NAMESPACE::fputil::set_round(FE_TOWARDZERO);
- test_one_input(func, x, OutType(0), false);
+ test_one_input(func, x, IntType(0), false);
LIBC_NAMESPACE::fputil::set_round(FE_TONEAREST);
- test_one_input(func, x, OutType(0), false);
+ test_one_input(func, x, IntType(0), false);
}
} else {
test_one_input(func, x, 0L, false);
@@ -276,9 +276,9 @@ class RoundToIntegerTestTemplate
// This function compares with an equivalent MPFR function which rounds
// floating point numbers to long values. There is no MPFR function to
// round to long long or wider integer values. So, we will peform the
- // comparisons in this function only if the width of OutType less than equal
+ // comparisons in this function only if the width of IntType less than equal
// to that of long.
- if (sizeof(OutType) > sizeof(long))
+ if (sizeof(IntType) > sizeof(long))
return;
constexpr int COUNT = 1'000'001;
@@ -287,7 +287,7 @@ class RoundToIntegerTestTemplate
StorageType(1));
for (StorageType i = MIN_NORMAL; i <= MAX_NORMAL; i += STEP) {
FPBits xbits(i);
- F x = xbits.get_val();
+ FloatType x = xbits.get_val();
// In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. We will skip them.
if (xbits.is_nan())
@@ -298,7 +298,7 @@ class RoundToIntegerTestTemplate
long mpfr_long_result;
bool erangeflag = mpfr::round_to_long(x, to_mpfr_rounding_mode(m),
mpfr_long_result);
- OutType mpfr_result = mpfr_long_result;
+ IntType mpfr_result = mpfr_long_result;
LIBC_NAMESPACE::fputil::set_round(m);
if (erangeflag)
test_one_input(func, x, x > 0 ? INTEGER_MAX : INTEGER_MIN, true);
@@ -308,7 +308,7 @@ class RoundToIntegerTestTemplate
} else {
long mpfr_long_result;
bool erangeflag = mpfr::round_to_long(x, mpfr_long_result);
- OutType mpfr_result = mpfr_long_result;
+ IntType mpfr_result = mpfr_long_result;
if (erangeflag)
test_one_input(func, x, x > 0 ? INTEGER_MAX : INTEGER_MIN, true);
else
@@ -318,9 +318,9 @@ class RoundToIntegerTestTemplate
}
};
-#define LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, OutType, func, TestModes) \
+#define LIST_ROUND_TO_INTEGER_TESTS_HELPER(FloatType, IntType, func, TestModes) \
using LlvmLibcRoundToIntegerTest = \
- RoundToIntegerTestTemplate<F, OutType, TestModes>; \
+ RoundToIntegerTestTemplate<FloatType, IntType, TestModes>; \
TEST_F(LlvmLibcRoundToIntegerTest, InfinityAndNaN) { \
testInfinityAndNaN(&func); \
} \
@@ -336,10 +336,10 @@ class RoundToIntegerTestTemplate
} \
TEST_F(LlvmLibcRoundToIntegerTest, NormalRange) { testNormalRange(&func); }
-#define LIST_ROUND_TO_INTEGER_TESTS(F, OutType, func) \
- LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, OutType, func, false)
+#define LIST_ROUND_TO_INTEGER_TESTS(FloatType, IntType, func) \
+ LIST_ROUND_TO_INTEGER_TESTS_HELPER(FloatType, IntType, func, false)
-#define LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(F, OutType, func) \
- LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, OutType, func, true)
+#define LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(FloatType, IntType, func) \
+ LIST_ROUND_TO_INTEGER_TESTS_HELPER(FloatType, IntType, func, true)
#endif // LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H
>From bac097d8d5ab052f627158d1c9f1b78ebc12a908 Mon Sep 17 00:00:00 2001
From: Sh0g0-1758 <shouryagoel10000 at gmail.com>
Date: Sat, 12 Oct 2024 00:31:16 +0530
Subject: [PATCH 6/6] fmt
---
libc/test/src/math/RoundToIntegerTest.h | 16 +++++++++-------
1 file changed, 9 insertions(+), 7 deletions(-)
diff --git a/libc/test/src/math/RoundToIntegerTest.h b/libc/test/src/math/RoundToIntegerTest.h
index 4b89a8fffbb8dd..77b465a3a0e631 100644
--- a/libc/test/src/math/RoundToIntegerTest.h
+++ b/libc/test/src/math/RoundToIntegerTest.h
@@ -53,8 +53,8 @@ class RoundToIntegerTestTemplate
<< (sizeof(IntType) * 8 - 1);
static constexpr IntType INTEGER_MAX = -(INTEGER_MIN + 1);
- void test_one_input(RoundToIntegerFunc func, FloatType input, IntType expected,
- bool expectError) {
+ void test_one_input(RoundToIntegerFunc func, FloatType input,
+ IntType expected, bool expectError) {
LIBC_NAMESPACE::libc_errno = 0;
LIBC_NAMESPACE::fputil::clear_except(FE_ALL_EXCEPT);
@@ -169,7 +169,8 @@ class RoundToIntegerTestTemplate
void do_fractions_test(RoundToIntegerFunc func, int mode) {
constexpr FloatType FRACTIONS[] = {
- FloatType(0.5), FloatType(-0.5), FloatType(0.115), FloatType(-0.115), FloatType(0.715), FloatType(-0.715),
+ FloatType(0.5), FloatType(-0.5), FloatType(0.115),
+ FloatType(-0.115), FloatType(0.715), FloatType(-0.715),
};
for (FloatType x : FRACTIONS) {
long mpfr_long_result;
@@ -318,9 +319,10 @@ class RoundToIntegerTestTemplate
}
};
-#define LIST_ROUND_TO_INTEGER_TESTS_HELPER(FloatType, IntType, func, TestModes) \
+#define LIST_ROUND_TO_INTEGER_TESTS_HELPER(FloatType, IntType, func, \
+ TestModes) \
using LlvmLibcRoundToIntegerTest = \
- RoundToIntegerTestTemplate<FloatType, IntType, TestModes>; \
+ RoundToIntegerTestTemplate<FloatType, IntType, TestModes>; \
TEST_F(LlvmLibcRoundToIntegerTest, InfinityAndNaN) { \
testInfinityAndNaN(&func); \
} \
@@ -336,10 +338,10 @@ class RoundToIntegerTestTemplate
} \
TEST_F(LlvmLibcRoundToIntegerTest, NormalRange) { testNormalRange(&func); }
-#define LIST_ROUND_TO_INTEGER_TESTS(FloatType, IntType, func) \
+#define LIST_ROUND_TO_INTEGER_TESTS(FloatType, IntType, func) \
LIST_ROUND_TO_INTEGER_TESTS_HELPER(FloatType, IntType, func, false)
-#define LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(FloatType, IntType, func) \
+#define LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(FloatType, IntType, func) \
LIST_ROUND_TO_INTEGER_TESTS_HELPER(FloatType, IntType, func, true)
#endif // LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H
More information about the libc-commits
mailing list