maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[libc] Support 32-bit ARM platform tests 

Set LONG_DOUBLE_IS_DOUBLE, add ifdefs for 128-bit integer types

Differential Revision: https://reviews.llvm.org/D124204
This commit is contained in:
Dominic Chen 2022-04-21 15:08:04 -07:00
parent 8042699a30
commit ce6bfd102a
8 changed files with 33 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
libc/src/__support/CPP/Limits.h
View File

@ -52,6 +52,7 @@ public:
static constexpr unsigned long long max() { return ULLONG_MAX; }
static constexpr unsigned long long min() { return 0; }
};
#ifdef __SIZEOF_INT128__
template <> class NumericLimits<__uint128_t> {
public:
static constexpr __uint128_t max() { return ~__uint128_t(0); }
@ -62,7 +63,7 @@ public:
static constexpr __int128_t max() { return ~__uint128_t(0) >> 1; }
static constexpr __int128_t min() { return __int128_t(1) << 127; }
};
#endif
} // namespace cpp
} // namespace __llvm_libc

7
libc/src/__support/CPP/TypeTraits.h
View File

@ -49,8 +49,11 @@ template <typename Type> struct IsIntegral {
IsSameV<unsigned short, TypeNoCV> || IsSameV<int, TypeNoCV> ||
IsSameV<unsigned int, TypeNoCV> || IsSameV<long, TypeNoCV> ||
IsSameV<unsigned long, TypeNoCV> || IsSameV<long long, TypeNoCV> ||
IsSameV<unsigned long long, TypeNoCV> || IsSameV<bool, TypeNoCV> ||
IsSameV<__uint128_t, TypeNoCV> || IsSameV<__int128_t, TypeNoCV>;
IsSameV<unsigned long long, TypeNoCV> || IsSameV<bool, TypeNoCV>
#ifdef __SIZEOF_INT128__
|| IsSameV<__uint128_t, TypeNoCV> || IsSameV<__int128_t, TypeNoCV>
#endif
;
};
template <typename T> struct IsPointerTypeNoCV : public FalseValue {};

4
libc/src/__support/FPUtil/PlatformDefs.h
View File

@ -15,8 +15,10 @@
#define X87_FPU
#endif
// https://developer.arm.com/documentation/dui0491/i/C-and-C---Implementation-Details/Basic-data-types
// https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms
#if defined(_WIN32) || (defined(__APPLE__) && defined(__aarch64__))
#if defined(_WIN32) || defined(__arm__) || \
(defined(__APPLE__) && defined(__aarch64__))
#define LONG_DOUBLE_IS_DOUBLE
#endif

2
libc/test/src/__support/CPP/limits_test.cpp
View File

@ -29,6 +29,7 @@ TEST(LlvmLibcLimitsTest, LimitsFollowSpec) {
ULLONG_MAX);
}
#ifdef __SIZEOF_INT128__
// This checks that the current environment supports 128 bit integers.
TEST(LlvmLibcLimitsTest, Int128Works) {
__int128_t max128 = ~__uint128_t(0) >> 1;
@ -47,3 +48,4 @@ TEST(LlvmLibcLimitsTest, Int128Works) {
__uint128_t(__llvm_libc::cpp::NumericLimits<unsigned long long>::max()));
ASSERT_EQ(__llvm_libc::cpp::NumericLimits<__uint128_t>::max(), umax128);
}
#endif

12
libc/test/src/__support/high_precision_decimal_test.cpp
View File

@ -344,26 +344,34 @@ TEST(LlvmLibcHighPrecisionDecimalTest, RoundingTest) {
EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(1));
EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(1));
#ifdef __SIZEOF_INT128__
EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(1));
#endif
hpd.shift(1); // shift left 1 to get 2.469 (rounds to 2)
EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(2));
EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(2));
#ifdef __SIZEOF_INT128__
EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(2));
#endif
hpd.shift(1); // shift left 1 to get 4.938 (rounds to 5)
EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(5));
EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(5));
#ifdef __SIZEOF_INT128__
EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(5));
#endif
// 2.5 is right between two integers, so we round to even (2)
hpd = __llvm_libc::internal::HighPrecisionDecimal("2.5");
EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(2));
EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(2));
#ifdef __SIZEOF_INT128__
EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(2));
#endif
// unless it's marked as having truncated, which means it's actually slightly
// higher, forcing a round up (3)
@ -371,7 +379,9 @@ TEST(LlvmLibcHighPrecisionDecimalTest, RoundingTest) {
EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(3));
EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(3));
#ifdef __SIZEOF_INT128__
EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(3));
#endif
// Check that the larger int types are being handled properly (overflow is not
// handled, so int types that are too small are ignored for this test.)
@ -380,6 +390,7 @@ TEST(LlvmLibcHighPrecisionDecimalTest, RoundingTest) {
hpd = __llvm_libc::internal::HighPrecisionDecimal("1099511627776");
EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(1099511627776));
#ifdef __SIZEOF_INT128__
EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(),
__uint128_t(1099511627776));
@ -390,4 +401,5 @@ TEST(LlvmLibcHighPrecisionDecimalTest, RoundingTest) {
__uint128_t result = __uint128_t(1) << 100;
EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), result);
#endif
}

2
libc/test/src/__support/str_to_float_test.cpp
View File

@ -313,7 +313,7 @@ TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80Fallback) {
ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<long double>(
1, -1000, &quadOutputMantissa, &outputExp2));
}
#else
#elif defined(__SIZEOF_INT128__)
TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat128Simple) {
eisel_lemire_test<long double>(123, 0, (__uint128_t(0x1ec0000000000) << 64),
16389);

2
libc/test/src/stdlib/strtold_test.cpp
View File

@ -15,6 +15,7 @@
#include <limits.h>
#include <stddef.h>
#ifdef __SIZEOF_INT128__
class LlvmLibcStrToLDTest : public __llvm_libc::testing::Test {
public:
void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
@ -221,3 +222,4 @@ TEST_F(LlvmLibcStrToLDTest, NaNTests) {
(__uint128_t(0x7fffc00000) << 40),
(__uint128_t(0x7fff800000000000) << 64));
}
#endif

6
libc/utils/UnitTest/LibcTest.cpp
View File

@ -42,6 +42,7 @@ describeValue(ValType Value) {
std::string describeValue(std::string Value) { return std::string(Value); }
#ifdef __SIZEOF_INT128__
// When the value is __uint128_t, also show its hexadecimal digits.
// Using template to force exact match, prevent ambiguous promotion.
std::string describeValue128(__uint128_t Value) {
@ -61,6 +62,7 @@ template <> std::string describeValue<__int128_t>(__int128_t Value) {
template <> std::string describeValue<__uint128_t>(__uint128_t Value) {
return describeValue128(Value);
}
#endif
template <typename ValType>
void explainDifference(ValType LHS, ValType RHS, const char *LHSStr,
@ -218,10 +220,12 @@ template bool test<long long>(RunContext *Ctx, TestCondition Cond,
const char *RHSStr, const char *File,
unsigned long Line);
#ifdef __SIZEOF_INT128__
template bool test<__int128_t>(RunContext *Ctx, TestCondition Cond,
__int128_t LHS, __int128_t RHS,
const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line);
#endif
template bool test<unsigned char>(RunContext *Ctx, TestCondition Cond,
unsigned char LHS, unsigned char RHS,
@ -253,10 +257,12 @@ template bool test<unsigned long long>(RunContext *Ctx, TestCondition Cond,
const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line);
#ifdef __SIZEOF_INT128__
template bool test<__uint128_t>(RunContext *Ctx, TestCondition Cond,
__uint128_t LHS, __uint128_t RHS,
const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line);
#endif
} // namespace internal