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); }
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
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 {};
#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
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;
__uint128_t(__llvm_libc::cpp::NumericLimits<unsigned long long>::max()));
ASSERT_EQ(__llvm_libc::cpp::NumericLimits<__uint128_t>::max(), umax128);
}
+#endif
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)
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.)
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));
__uint128_t result = __uint128_t(1) << 100;
EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), result);
+#endif
}
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);
#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,
(__uint128_t(0x7fffc00000) << 40),
(__uint128_t(0x7fff800000000000) << 64));
}
+#endif
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) {
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,
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,
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