[libc] Add support for 128 bit ints in limits.h

[michaelrj]

Summary

Also, this adds unit tests to check that limits.h complies with the C
standard.

[sivachandra]

libc/test/utils/CPP/limits_test.cpp

16

Instead of literals, we should use the macros like INT_MAX etc. Then, you can make these to be equality checks. The test might seem trivial at that point - we are probably only testing for copy-paste errors. But, the macros make it more robust against platform differences.

libc/utils/CPP/Limits.h

55

For completeness, should we add the limits of the signed __int128_t type?

58

Can this be ~__uint128_t(0)?

[michaelrj]

change max and add support for signed ints, although it's commented out currently due to the trest framework not supporting it.

libc/test/utils/CPP/limits_test.cpp

16

right now this is comparing against the C spec, so if they fail then the platform has not implemented its integers correctly. I can change it to use the macros, but then it's not really testing anything, other than that the macros equal themselves.

libc/utils/CPP/Limits.h

55

That would be non-trivial since the test framework doesn't support __int128_t right now.

[abrachet]

libc/utils/CPP/Limits.h

55

Just need to add a new Test::test instantiation for __int128_t like in LibcTest.cpp:245

[sivachandra]

libc/test/utils/CPP/limits_test.cpp

16

I don't disagree with your reasoning. My point is that this test is really protecting us against copy-paste errors. For example, check for int limits is satisfied by all other signed integer types. So, we are not really protecting ourselves from copy-paste errors. I can totally see the other way round problem also - the test itself has copy paste errors. So, up to you.

Whether the platform is implementing the C spec around integer sizes is beyond the scope of the libc I would think.

libc/utils/CPP/Limits.h

55

You will have to add a describeValue overload also like this: https://github.com/llvm/llvm-project/blob/main/libc/utils/UnitTest/LibcTest.cpp#L47

I will leave it up to you if you want to do it all in this change or just add a TODO in this change along with the commented out code.

63

May be just ~__uint128_t(0) - 1?

[michaelrj]

get signed 128 bit integers working.

libc/test/utils/CPP/limits_test.cpp

16

Fair enough, I've changed it to use the macros.

libc/utils/CPP/Limits.h

55

Done, and I also had to add __int128_t to TypeTraits.h.

63

That doesn't work as int max, since it comes out to 0xfffffffffffffffffffffffffffffffe, as opposed to the 0x7fffffffffffffffffffffffffffffff. I've changed it to be the most logical way I can think of that doesn't rely on overflow/underflow.

[sivachandra]

libc/utils/CPP/Limits.h

63

Uh, sorry! Not sure why I put a - instead of a >>. I wanted to say this:

return ~__uint128_t(0) >> 1;

libc/utils/UnitTest/LibcTest.cpp

57

Can we extract into a common function like this:

template <typename T128>
cpp::EnableIfType<cpp::IsSame<T128, __int128_t> || cpp::IsSame<T128, __uint128_t>, std::string>
describeValue128(...) {
  ...
}

template <> std::string describeValue<__int128_t>(__int128_t Value) { return describeValue128(Value); }
template <> std::string describeValue<__uint128_t>(__uint128_t Value) { return describeValue128(Value); }

[michaelrj]

clean up a few remaining things

[michaelrj]

libc/utils/CPP/Limits.h

63

ah, yes that does work.

[sivachandra]

LGTM

libc/test/utils/CPP/CMakeLists.txt

SUITE
     libc_cpp_utils_unittests
   SRCS
     stringview_test.cpp
   DEPENDS
     libc.utils.CPP.standalone_cpp
 )
 
 add_libc_unittest(
+  limits_test
+  SUITE
+    libc_cpp_utils_unittests
+  SRCS
+    limits_test.cpp
+  DEPENDS
+    libc.utils.CPP.standalone_cpp
+)
+
+add_libc_unittest(
   arrayref_test
   SUITE
     libc_cpp_utils_unittests
   SRCS
     arrayref_test.cpp
   DEPENDS
     libc.utils.CPP.standalone_cpp
 )

libc/test/utils/CPP/limits_test.cpp

+//===-- Unittests for Limits ----------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "utils/CPP/Limits.h"
+#include "utils/UnitTest/Test.h"
+
+// This just checks against the C spec, almost all implementations will surpass
+// this.
+TEST(LlvmLibcLimitsTest, LimitsFollowSpec) {
+  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<int>::max(), INT_MAX);
+  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<int>::min(), INT_MIN);
+
+  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<unsigned int>::max(), UINT_MAX);
+
+  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long>::max(), LONG_MAX);
+  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long>::min(), LONG_MIN);
+
+  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<unsigned long>::max(), ULONG_MAX);
+
+  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);
+}
+
+// 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);
+}

libc/utils/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; }
 };
+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; }
+};
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_CPP_LIMITS_H

libc/utils/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<__uint128_t, TypeNoCV> || IsSameV<__int128_t, TypeNoCV>;
 };
 
 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/utils/UnitTest/LibcTest.cpp

 describeValue(ValType Value) {
   return std::to_string(Value);
 }
 
 std::string describeValue(std::string Value) { return std::string(Value); }
 
 // When the value is __uint128_t, also show its hexadecimal digits.
 // Using template to force exact match, prevent ambiguous promotion.
-template <> std::string describeValue<__uint128_t>(__uint128_t Value) {
+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);
+}
+
 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, ' ');
 
   std::cout << File << ":" << Line << ": FAILURE\n"
template bool Test::test<long, 0>(TestCondition Cond, long LHS, long RHS,
                                   const char *LHSStr, const char *RHSStr,
                                   const char *File, unsigned long Line);
 
 template bool Test::test<long long, 0>(TestCondition Cond, long long LHS,
                                        long long RHS, const char *LHSStr,
                                        const char *RHSStr, const char *File,
                                        unsigned long Line);
 
+template bool Test::test<__int128_t, 0>(TestCondition Cond, __int128_t LHS,
+                                        __int128_t RHS, const char *LHSStr,
+                                        const char *RHSStr, const char *File,
+                                        unsigned long Line);
+
 template bool Test::test<unsigned char, 0>(TestCondition Cond,
                                            unsigned char LHS, unsigned char RHS,
                                            const char *LHSStr,
                                            const char *RHSStr, const char *File,
                                            unsigned long Line);
 
 template bool
 Test::test<unsigned short, 0>(TestCondition Cond, unsigned short LHS,