[libc] Support 32-bit ARM platform tests

[ddcc]

Summary

Set LONG_DOUBLE_IS_DOUBLE, add ifdefs for 128-bit integer types

[michaelrj]

you'll probably also need to add #ifdef conditions to src/__support/CPP/Limits.h and its corresponding test.

[ddcc]

Add more ifdef coverage

[ddcc]

In D124204#3475478, @michaelrj wrote:

you'll probably also need to add #ifdef conditions to src/__support/CPP/Limits.h and its corresponding test.

Thanks, I've been testing against an older fork and missed some of these changes.

[michaelrj]

I've added a few comments, and I've also started a thread on the LLVM discourse page for discussing plans for building LLVM-libc on arm32: https://discourse.llvm.org/t/building-llvm-libc-for-arm32/62092 if you want to join.

libc/test/src/__support/str_to_float_test.cpp

275

these shouldn't be necessary, since arm32 uses long doubles as doubles, which is caught by the condition above.

libc/test/src/stdlib/strtold_test.cpp

18

for these tests I would recommend disabling strtold as an entrypoint instead of putting the whole test file in an #ifdef. If you want, you can add a TODO for me to look into changing this test to not use uint128 when it doesn't need it.

[ddcc]

libc/test/src/stdlib/strtold_test.cpp

18

Are you referring to libc/config/darwin/arm/entrypoints.txt? Or omitting strtold_tests from libc/test/src/stdlib/CMakeLists.txt for arm?

[ddcc]

Remove unnecessary changes to str_to_float_test.cpp

[michaelrj]

libc/test/src/__support/str_to_float_test.cpp

300

these also should be handled by the LONG_DOUBLE_IS_DOUBLE condition

libc/test/src/stdlib/strtold_test.cpp

18

actually, I think this is fine for now. I'll look into cleaning it up when I get the chance.

libc/src/__support/CPP/Limits.h

public:
   static constexpr long long max() { return LLONG_MAX; }
   static constexpr long long min() { return LLONG_MIN; }
 };
 template <> class NumericLimits<unsigned long long> {
 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); }
   static constexpr __uint128_t min() { return 0; }
 };
 template <> class NumericLimits<__int128_t> {
 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
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_LIMITS_H

libc/src/__support/CPP/TypeTraits.h

 template <typename Type> struct IsIntegral {
   using TypeNoCV = RemoveCVType<Type>;
   static constexpr bool Value =
       IsSameV<char, TypeNoCV> || IsSameV<signed char, TypeNoCV> ||
       IsSameV<unsigned char, TypeNoCV> || IsSameV<short, TypeNoCV> ||
       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 {};
 template <typename T> struct IsPointerTypeNoCV<T *> : public TrueValue {};
 template <typename T> struct IsPointerType {
   static constexpr bool Value = IsPointerTypeNoCV<RemoveCVType<T>>::Value;
 };
 

libc/src/__support/FPUtil/PlatformDefs.h

 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_PLATFORM_DEFS_H
 
 #include "src/__support/architectures.h"
 
 #if defined(LLVM_LIBC_ARCH_X86)
 #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
 
 #if !defined(LONG_DOUBLE_IS_DOUBLE) && defined(X87_FPU)
 #define SPECIAL_X86_LONG_DOUBLE
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_PLATFORM_DEFS_H

libc/test/src/__support/CPP/limits_test.cpp

TEST(LlvmLibcLimitsTest, LimitsFollowSpec) {
 
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long long>::max(), LLONG_MAX);
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long long>::min(), LLONG_MIN);
 
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<unsigned long long>::max(),
             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;
   __int128_t min128 = (__int128_t(1) << 127);
   EXPECT_GT(__llvm_libc::cpp::NumericLimits<__int128_t>::max(),
             __int128_t(__llvm_libc::cpp::NumericLimits<long long>::max()));
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<__int128_t>::max(), max128);
 
   EXPECT_LT(__llvm_libc::cpp::NumericLimits<__int128_t>::min(),
             __int128_t(__llvm_libc::cpp::NumericLimits<long long>::min()));
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<__int128_t>::min(), min128);
 
   __uint128_t umax128 = ~__uint128_t(0);
   EXPECT_GT(
       __llvm_libc::cpp::NumericLimits<__uint128_t>::max(),
       __uint128_t(__llvm_libc::cpp::NumericLimits<unsigned long long>::max()));
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<__uint128_t>::max(), umax128);
 }
+#endif

libc/test/src/__support/high_precision_decimal_test.cpp

 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, RoundingTest) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal("1.2345");
 
   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)
   hpd.set_truncated(true);
 
   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.)
 
   // 1099511627776 = 2^40
   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));
 
   // 1267650600228229401496703205376 = 2^100
   hpd = __llvm_libc::internal::HighPrecisionDecimal(
       "1267650600228229401496703205376");
 
   __uint128_t result = __uint128_t(1) << 100;
 
   EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), result);
+#endif
 }

libc/test/src/__support/str_to_float_test.cpp

 }
 #elif defined(SPECIAL_X86_LONG_DOUBLE)
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80Simple) {
   eisel_lemire_test<long double>(123, 0, 0xf600000000000000, 16389);
   eisel_lemire_test<long double>(12345678901234568192u, 0, 0xab54a98ceb1f0c00,
                                  16446);
 }
 
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80LongerMantissa) {
   eisel_lemire_test<long double>((__uint128_t(0x1234567812345678) << 64) +
                                      __uint128_t(0x1234567812345678),
                                  0, 0x91a2b3c091a2b3c1, 16507);
   eisel_lemire_test<long double>((__uint128_t(0x1234567812345678) << 64) +
                                      __uint128_t(0x1234567812345678),
                                  300, 0xd97757de56adb65c, 17503);
   eisel_lemire_test<long double>((__uint128_t(0x1234567812345678) << 64) +
                                      __uint128_t(0x1234567812345678),
                                  -300, 0xc30feb9a7618457d, 15510);
 }
 
 // These tests check numbers at the edge of the DETAILED_POWERS_OF_TEN table.
 // This doesn't reach very far into the range for long doubles, since it's sized
 // for doubles and their 11 exponent bits, and not for long doubles and their
 // 15 exponent bits. This is a known tradeoff, and was made because a proper
 // long double table would be approximately 16 times longer (specifically the
 // maximum exponent would need to be about 5000, leading to a 10,000 entry
 // table). This would have significant memory and storage costs all the time to
 // speed up a relatively uncommon path.
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80TableLimits) {
   eisel_lemire_test<long double>(1, 347, 0xd13eb46469447567, 17535);
   eisel_lemire_test<long double>(1, -348, 0xfa8fd5a0081c0288, 15226);
 }
 
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80Fallback) {
   uint32_t outputExp2 = 0;
   __uint128_t quadOutputMantissa = 0;
 
   // This number is halfway between two possible results, and the algorithm
   // can't determine which is correct.
   ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<long double>(
       12345678901234567890u, 1, &quadOutputMantissa, &outputExp2));
 
   // These numbers' exponents are out of range for the current powers of ten
   // table.
   ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<long double>(
       1, 1000, &quadOutputMantissa, &outputExp2));
   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);
   eisel_lemire_test<long double>(12345678901234568192u, 0,
                                  (__uint128_t(0x156a95319d63e) << 64) +
                                      __uint128_t(0x1800000000000000),
                                  16446);
 }

libc/test/src/stdlib/strtold_test.cpp

 #include "src/stdlib/strtold.h"
 
 #include "utils/UnitTest/Test.h"
 
 #include <errno.h>
 #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,
                 const uint64_t expectedRawData64,
                 const __uint128_t expectedRawData80,
                 const __uint128_t expectedRawData128,
                 const int expectedErrno64 = 0, const int expectedErrno80 = 0,
                 const int expectedErrno128 = 0) {
TEST_F(LlvmLibcStrToLDTest, NaNTests) {
   run_test("NaN(0xffffffffffffffff)", 23, 0x7fffffffffffffff,
            (__uint128_t(0x7fffffffff) << 40) + __uint128_t(0xffffffffff),
            (__uint128_t(0x7fff800000000000) << 64) +
                __uint128_t(0xffffffffffffffff));
   run_test("NaN( 1234)", 3, 0x7ff8000000000000,
            (__uint128_t(0x7fffc00000) << 40),
            (__uint128_t(0x7fff800000000000) << 64));
 }
+#endif

libc/utils/UnitTest/LibcTest.cpp

 template <typename ValType>
 cpp::EnableIfType<cpp::IsIntegral<ValType>::Value, std::string>
 describeValue(ValType Value) {
   return std::to_string(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) {
   std::string S(sizeof(__uint128_t) * 2, '0');
 
   for (auto I = S.rbegin(), End = S.rend(); I != End; ++I, Value >>= 4) {
     unsigned char Mod = static_cast<unsigned char>(Value) & 15;
     *I = Mod < 10 ? '0' + Mod : 'a' + Mod - 10;
   }
 
   return "0x" + S;
 }
 
 template <> std::string describeValue<__int128_t>(__int128_t Value) {
   return describeValue128(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,
                        std::string OpString) {
   size_t OffsetLength = OpString.size() > 2 ? OpString.size() - 2 : 0;
   std::string Offset(OffsetLength, ' ');
 
template bool test<long>(RunContext *Ctx, TestCondition Cond, long LHS,
                          long RHS, const char *LHSStr, const char *RHSStr,
                          const char *File, unsigned long Line);
 
 template bool test<long long>(RunContext *Ctx, TestCondition Cond,
                               long long LHS, long long 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);
 
 template bool test<unsigned short>(RunContext *Ctx, TestCondition Cond,
                                    unsigned short LHS, unsigned short RHS,
template bool test<bool>(RunContext *Ctx, TestCondition Cond, bool LHS,
                          const char *File, unsigned long Line);
 
 template bool test<unsigned long long>(RunContext *Ctx, TestCondition Cond,
                                        unsigned long long LHS,
                                        unsigned long long 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
 
 bool Test::testStrEq(const char *LHS, const char *RHS, const char *LHSStr,
                      const char *RHSStr, const char *File, unsigned long Line) {
   return internal::test(Ctx, Cond_EQ, LHS ? std::string(LHS) : std::string(),
                         RHS ? std::string(RHS) : std::string(), LHSStr, RHSStr,
                         File, Line);