[libc++] Teach is_integral, is_[un]signed and make_[un]signed about __[u]int128_t

[stephant]

Summary

This patch adds support for [u]int128_t to std::is_integral, std::is_[un]signed and std::make_[un]signed in <type_traits>. It also adds tests for std::numeric_limits<[u]int128_t>.

Currently, clang, GCC and compatible compilers support these 128-bit integer types. These compilers also define the SIZEOF_INT128 macro, which we use to detect the compiler support.

[majnemer]

Per the cxx_status documentation:

"__int128 is not treated as an extended integer type, because changing
intmax_t would be an ABI-incompatible change."

With this in mind, I don't think it makes sense for these intrinsics to
accept __int128.

[stephant]

IMHO, having support for int128 in the type traits can be useful irrespective of whether int128 is recognized as an extended integer type. libstdc++ does support __int128 too (except in strict ansi mode).

[majnemer]

Wouldn't that make strict ANSI mode abi incompatible when not in strict
ANSI mode?

[majnemer]

Having talked to @rsmith about this issue, I'm compelled to withdraw my concerns regarding allowing types which aren't either standard or extended integer types.

This behavior would be consistent with clang's __is_integral intrinsic.

[stephant]

Ping.

[mclow.lists]

This all looks fine to me, EXCEPT for the types as macros.
Let's give those types real names.

Lets either just use __int128_t, or bikeshed a name and have a typedef.

[stephant]

Thanks for the review!

I've added a feature check macro called _LIBCPP_HAS_NO_INT128 to config and replaced the type macros with int128_t and __uint128_t.

I've also updated the 33(!) separate test files for numeric limits with tests for std::numeric_limit<__[u]int128_t>, as discussed on IRC.

[mclow.lists]

The HugeEnum test fails when compiled with -std=c++03.

It needs to be wrapped in a "#if _LIBCPP_STD_VER > 11" block (see test/utilities/function.objects/unord.hash/enum.pass.cpp for an example)

[stephant]

Thanks for finding this!

I've surrounded the uses of typed enums with ifndef _LIBCPP_HAS_NO_STRONG_ENUMS checks.

[stephant]

I've rebased the patch.

[mclow.lists]

With a formatting change to type_traits (discussed on IRC), this looks good to me.

[stephant]

Thanks a lot for the review!

Commited as r204849.

include/__config

 
 #endif // __clang__ || __GNUC__ || _MSC_VER || __IBMCPP__
 
 #ifdef _LIBCPP_HAS_NO_UNICODE_CHARS
 typedef unsigned short char16_t;
 typedef unsigned int   char32_t;
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
 
+#ifndef __SIZEOF_INT128__
+#define _LIBCPP_HAS_NO_INT128
+#endif
+
 #ifdef _LIBCPP_HAS_NO_STATIC_ASSERT
 
 template <bool> struct __static_assert_test;
 template <> struct __static_assert_test<true> {};
 template <unsigned> struct __static_assert_check {};
 #define static_assert(__b, __m) \
     typedef __static_assert_check<sizeof(__static_assert_test<(__b)>)> \
     _LIBCPP_CONCAT(__t, __LINE__)

include/type_traits

 template <>          struct __libcpp_is_integral<short>              : public true_type {};
 template <>          struct __libcpp_is_integral<unsigned short>     : public true_type {};
 template <>          struct __libcpp_is_integral<int>                : public true_type {};
 template <>          struct __libcpp_is_integral<unsigned int>       : public true_type {};
 template <>          struct __libcpp_is_integral<long>               : public true_type {};
 template <>          struct __libcpp_is_integral<unsigned long>      : public true_type {};
 template <>          struct __libcpp_is_integral<long long>          : public true_type {};
 template <>          struct __libcpp_is_integral<unsigned long long> : public true_type {};
+#ifndef _LIBCPP_HAS_NO_INT128
+template <>          struct __libcpp_is_integral<__int128_t>         : public true_type {};
+template <>          struct __libcpp_is_integral<__uint128_t>        : public true_type {};
+#endif
 
 template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_integral
     : public __libcpp_is_integral<typename remove_cv<_Tp>::type> {};
 
 // is_floating_point
 
 template <class _Tp> struct __libcpp_is_floating_point              : public false_type {};
 template <>          struct __libcpp_is_floating_point<float>       : public true_type {};

 // make_signed / make_unsigned
 
 typedef
     __type_list<signed char,
     __type_list<signed short,
     __type_list<signed int,
     __type_list<signed long,
     __type_list<signed long long,
+#ifndef _LIBCPP_HAS_NO_INT128
+    __type_list<__int128_t, __nat>
+#else
     __nat
+#endif
     > > > > > __signed_types;
 
 typedef
     __type_list<unsigned char,
     __type_list<unsigned short,
     __type_list<unsigned int,
     __type_list<unsigned long,
     __type_list<unsigned long long,
+#ifndef _LIBCPP_HAS_NO_INT128
+    __type_list<__uint128_t, __nat>
+#else
     __nat
+#endif
     > > > > > __unsigned_types;
 
 template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeList::_Head)> struct __find_first;
 
 template <class _Hp, class _Tp, size_t _Size>
 struct __find_first<__type_list<_Hp, _Tp>, _Size, true>
 {
     typedef _Hp type;

 template <> struct __make_signed<  signed short,     true> {typedef short     type;};
 template <> struct __make_signed<unsigned short,     true> {typedef short     type;};
 template <> struct __make_signed<  signed int,       true> {typedef int       type;};
 template <> struct __make_signed<unsigned int,       true> {typedef int       type;};
 template <> struct __make_signed<  signed long,      true> {typedef long      type;};
 template <> struct __make_signed<unsigned long,      true> {typedef long      type;};
 template <> struct __make_signed<  signed long long, true> {typedef long long type;};
 template <> struct __make_signed<unsigned long long, true> {typedef long long type;};
+#ifndef _LIBCPP_HAS_NO_INT128
+template <> struct __make_signed<__int128_t,         true> {typedef __int128_t type;};
+template <> struct __make_signed<__uint128_t,        true> {typedef __int128_t type;};
+#endif
 
 template <class _Tp>
 struct _LIBCPP_TYPE_VIS_ONLY make_signed
 {
     typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
 };
 
 #if _LIBCPP_STD_VER > 11

 template <> struct __make_unsigned<  signed short,     true> {typedef unsigned short     type;};
 template <> struct __make_unsigned<unsigned short,     true> {typedef unsigned short     type;};
 template <> struct __make_unsigned<  signed int,       true> {typedef unsigned int       type;};
 template <> struct __make_unsigned<unsigned int,       true> {typedef unsigned int       type;};
 template <> struct __make_unsigned<  signed long,      true> {typedef unsigned long      type;};
 template <> struct __make_unsigned<unsigned long,      true> {typedef unsigned long      type;};
 template <> struct __make_unsigned<  signed long long, true> {typedef unsigned long long type;};
 template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;};
+#ifndef _LIBCPP_HAS_NO_INT128
+template <> struct __make_unsigned<__int128_t,         true> {typedef __uint128_t        type;};
+template <> struct __make_unsigned<__uint128_t,        true> {typedef __uint128_t        type;};
+#endif
 
 template <class _Tp>
 struct _LIBCPP_TYPE_VIS_ONLY make_unsigned
 {
     typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
 };
 
 #if _LIBCPP_STD_VER > 11

test/language.support/support.limits/limits/is_specialized.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<signed short>();
     test<unsigned short>();
     test<signed int>();
     test<unsigned int>();
     test<signed long>();
     test<unsigned long>();
     test<signed long long>();
     test<unsigned long long>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>();
+    test<__uint128_t>();
+#endif
     test<float>();
     test<double>();
     test<long double>();
     static_assert(!std::numeric_limits<std::complex<double> >::is_specialized,
                  "!std::numeric_limits<std::complex<double> >::is_specialized");
 }

test/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp

int main()
     TEST_NUMERIC_LIMITS(const volatile int)
 
     // long
     TEST_NUMERIC_LIMITS(long)
     TEST_NUMERIC_LIMITS(const long)
     TEST_NUMERIC_LIMITS(volatile long)
     TEST_NUMERIC_LIMITS(const volatile long)
 
+#ifndef _LIBCPP_HAS_NO_INT128
+    TEST_NUMERIC_LIMITS(__int128_t)
+    TEST_NUMERIC_LIMITS(const __int128_t)
+    TEST_NUMERIC_LIMITS(volatile __int128_t)
+    TEST_NUMERIC_LIMITS(const volatile __int128_t)
+#endif
+
     // long long
     TEST_NUMERIC_LIMITS(long long)
     TEST_NUMERIC_LIMITS(const long long)
     TEST_NUMERIC_LIMITS(volatile long long)
     TEST_NUMERIC_LIMITS(const volatile long long)
 
     // unsigned short
     TEST_NUMERIC_LIMITS(unsigned short)
#endif
     TEST_NUMERIC_LIMITS(const volatile unsigned long)
 
     // unsigned long long
     TEST_NUMERIC_LIMITS(unsigned long long)
     TEST_NUMERIC_LIMITS(const unsigned long long)
     TEST_NUMERIC_LIMITS(volatile unsigned long long)
     TEST_NUMERIC_LIMITS(const volatile unsigned long long)
 
+#ifndef _LIBCPP_HAS_NO_INT128
+    TEST_NUMERIC_LIMITS(__uint128_t)
+    TEST_NUMERIC_LIMITS(const __uint128_t)
+    TEST_NUMERIC_LIMITS(volatile __uint128_t)
+    TEST_NUMERIC_LIMITS(const volatile __uint128_t)
+#endif
+
     // float
     TEST_NUMERIC_LIMITS(float)
     TEST_NUMERIC_LIMITS(const float)
     TEST_NUMERIC_LIMITS(volatile float)
     TEST_NUMERIC_LIMITS(const volatile float)
-    
     // double
     TEST_NUMERIC_LIMITS(double)
     TEST_NUMERIC_LIMITS(const double)
     TEST_NUMERIC_LIMITS(volatile double)
     TEST_NUMERIC_LIMITS(const volatile double)
-    
     // long double
     TEST_NUMERIC_LIMITS(long double)
     TEST_NUMERIC_LIMITS(const long double)
     TEST_NUMERIC_LIMITS(volatile long double)
     TEST_NUMERIC_LIMITS(const volatile long double)
 
     // other
     TEST_NUMERIC_LIMITS(other)
     TEST_NUMERIC_LIMITS(const other)
     TEST_NUMERIC_LIMITS(volatile other)
     TEST_NUMERIC_LIMITS(const volatile other)
 }

test/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>(0);
     test<unsigned short>(0);
     test<int>(0);
     test<unsigned int>(0);
     test<long>(0);
     test<unsigned long>(0);
     test<long long>(0);
     test<unsigned long long>(0);
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>(0);
+    test<__uint128_t>(0);
+#endif
     test<float>(__FLT_DENORM_MIN__);
     test<double>(__DBL_DENORM_MIN__);
     test<long double>(__LDBL_DENORM_MIN__);
 }

test/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, 15>();
     test<unsigned short, 16>();
     test<int, 31>();
     test<unsigned int, 32>();
     test<long, sizeof(long) == 4 ? 31 : 63>();
     test<unsigned long, sizeof(long) == 4 ? 32 : 64>();
     test<long long, 63>();
     test<unsigned long long, 64>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, 127>();
+    test<__uint128_t, 128>();
+#endif
     test<float, FLT_MANT_DIG>();
     test<double, DBL_MANT_DIG>();
     test<long double, LDBL_MANT_DIG>();
 }

test/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, 4>();
     test<unsigned short, 4>();
     test<int, 9>();
     test<unsigned int, 9>();
     test<long, sizeof(long) == 4 ? 9 : 18>();
     test<unsigned long, sizeof(long) == 4 ? 9 : 19>();
     test<long long, 18>();
     test<unsigned long long, 19>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, 38>();
+    test<__uint128_t, 38>();
+#endif
     test<float, FLT_DIG>();
     test<double, DBL_DIG>();
     test<long double, LDBL_DIG>();
 }

test/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>(0);
     test<unsigned short>(0);
     test<int>(0);
     test<unsigned int>(0);
     test<long>(0);
     test<unsigned long>(0);
     test<long long>(0);
     test<unsigned long long>(0);
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>(0);
+    test<__uint128_t>(0);
+#endif
     test<float>(FLT_EPSILON);
     test<double>(DBL_EPSILON);
     test<long double>(LDBL_EPSILON);
 }

test/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, std::denorm_absent>();
     test<unsigned short, std::denorm_absent>();
     test<int, std::denorm_absent>();
     test<unsigned int, std::denorm_absent>();
     test<long, std::denorm_absent>();
     test<unsigned long, std::denorm_absent>();
     test<long long, std::denorm_absent>();
     test<unsigned long long, std::denorm_absent>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, std::denorm_absent>();
+    test<__uint128_t, std::denorm_absent>();
+#endif
     test<float, std::denorm_present>();
     test<double, std::denorm_present>();
     test<long double, std::denorm_present>();
 }

test/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, false>();
+    test<__uint128_t, false>();
+#endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 }

test/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, false>();
+    test<__uint128_t, false>();
+#endif
     test<float, true>();
     test<double, true>();
     test<long double, true>();
 }

test/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, false>();
+    test<__uint128_t, false>();
+#endif
     test<float, true>();
     test<double, true>();
     test<long double, true>();
 }

test/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, false>();
+    test<__uint128_t, false>();
+#endif
     test<float, true>();
     test<double, true>();
     test<long double, true>();
 }

test/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>(0);
     test<unsigned short>(0);
     test<int>(0);
     test<unsigned int>(0);
     test<long>(0);
     test<unsigned long>(0);
     test<long long>(0);
     test<unsigned long long>(0);
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>(0);
+    test<__uint128_t>(0);
+#endif
     test<float>(1./zero);
     test<double>(1./zero);
     test<long double>(1./zero);
 }
 
 float zero = 0;

test/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, true>();
     test<unsigned short, true>();
     test<int, true>();
     test<unsigned int, true>();
     test<long, true>();
     test<unsigned long, true>();
     test<long long, true>();
     test<unsigned long long, true>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, true>();
+    test<__uint128_t, true>();
+#endif
     test<float, true>();
     test<double, true>();
     test<long double, true>();
 }

test/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, true>();
     test<unsigned short, true>();
     test<int, true>();
     test<unsigned int, true>();
     test<long, true>();
     test<unsigned long, true>();
     test<long long, true>();
     test<unsigned long long, true>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, true>();
+    test<__uint128_t, true>();
+#endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 }

test/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, false>();
+    test<__uint128_t, false>();
+#endif
     test<float, true>();
     test<double, true>();
 #if (defined(__ppc__) || defined(__ppc64__))
     test<long double, false>();
 #else
     test<long double, true>();
 #endif
 }

test/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, true>();
     test<unsigned short, true>();
     test<int, true>();
     test<unsigned int, true>();
     test<long, true>();
     test<unsigned long, true>();
     test<long long, true>();
     test<unsigned long long, true>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, true>();
+    test<__uint128_t, true>();
+#endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 }

test/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, true>();
     test<unsigned short, true>();
     test<int, true>();
     test<unsigned int, true>();
     test<long, true>();
     test<unsigned long, true>();
     test<long long, true>();
     test<unsigned long long, true>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, true>();
+    test<__uint128_t, true>();
+#endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 }

test/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, true>();
     test<unsigned short, false>();
     test<int, true>();
     test<unsigned int, false>();
     test<long, true>();
     test<unsigned long, false>();
     test<long long, true>();
     test<unsigned long long, false>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, true>();
+    test<__uint128_t, false>();
+#endif
     test<float, true>();
     test<double, true>();
     test<long double, true>();
 }

test/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>(SHRT_MIN);
     test<unsigned short>(0);
     test<int>(INT_MIN);
     test<unsigned int>(0);
     test<long>(LONG_MIN);
     test<unsigned long>(0);
     test<long long>(LLONG_MIN);
     test<unsigned long long>(0);
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>(-__int128_t(__uint128_t(-1)/2) - 1);
+    test<__uint128_t>(0);
+#endif
     test<float>(-FLT_MAX);
     test<double>(-DBL_MAX);
     test<long double>(-LDBL_MAX);
 }

test/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>(SHRT_MAX);
     test<unsigned short>(USHRT_MAX);
     test<int>(INT_MAX);
     test<unsigned int>(UINT_MAX);
     test<long>(LONG_MAX);
     test<unsigned long>(ULONG_MAX);
     test<long long>(LLONG_MAX);
     test<unsigned long long>(ULLONG_MAX);
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>(__int128_t(__uint128_t(-1)/2));
+    test<__uint128_t>(__uint128_t(-1));
+#endif
     test<float>(FLT_MAX);
     test<double>(DBL_MAX);
     test<long double>(LDBL_MAX);
 }

test/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, 0>();
     test<unsigned short, 0>();
     test<int, 0>();
     test<unsigned int, 0>();
     test<long, 0>();
     test<unsigned long, 0>();
     test<long long, 0>();
     test<unsigned long long, 0>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, 0>();
+    test<__uint128_t, 0>();
+#endif
     test<float, 2+(FLT_MANT_DIG * 30103)/100000>();
     test<double, 2+(DBL_MANT_DIG * 30103)/100000>();
     test<long double, 2+(LDBL_MANT_DIG * 30103)/100000>();
 }

test/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, 0>();
     test<unsigned short, 0>();
     test<int, 0>();
     test<unsigned int, 0>();
     test<long, 0>();
     test<unsigned long, 0>();
     test<long long, 0>();
     test<unsigned long long, 0>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, 0>();
+    test<__uint128_t, 0>();
+#endif
     test<float, FLT_MAX_EXP>();
     test<double, DBL_MAX_EXP>();
     test<long double, LDBL_MAX_EXP>();
 }

test/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, 0>();
     test<unsigned short, 0>();
     test<int, 0>();
     test<unsigned int, 0>();
     test<long, 0>();
     test<unsigned long, 0>();
     test<long long, 0>();
     test<unsigned long long, 0>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, 0>();
+    test<__uint128_t, 0>();
+#endif
     test<float, FLT_MAX_10_EXP>();
     test<double, DBL_MAX_10_EXP>();
     test<long double, LDBL_MAX_10_EXP>();
 }

test/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>(SHRT_MIN);
     test<unsigned short>(0);
     test<int>(INT_MIN);
     test<unsigned int>(0);
     test<long>(LONG_MIN);
     test<unsigned long>(0);
     test<long long>(LLONG_MIN);
     test<unsigned long long>(0);
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>(-__int128_t(__uint128_t(-1)/2) - 1);
+    test<__uint128_t>(0);
+#endif
     test<float>(FLT_MIN);
     test<double>(DBL_MIN);
     test<long double>(LDBL_MIN);
 }

test/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, 0>();
     test<unsigned short, 0>();
     test<int, 0>();
     test<unsigned int, 0>();
     test<long, 0>();
     test<unsigned long, 0>();
     test<long long, 0>();
     test<unsigned long long, 0>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, 0>();
+    test<__uint128_t, 0>();
+#endif
     test<float, FLT_MIN_EXP>();
     test<double, DBL_MIN_EXP>();
     test<long double, LDBL_MIN_EXP>();
 }

test/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, 0>();
     test<unsigned short, 0>();
     test<int, 0>();
     test<unsigned int, 0>();
     test<long, 0>();
     test<unsigned long, 0>();
     test<long long, 0>();
     test<unsigned long long, 0>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, 0>();
+    test<__uint128_t, 0>();
+#endif
     test<float, FLT_MIN_10_EXP>();
     test<double, DBL_MIN_10_EXP>();
     test<long double, LDBL_MIN_10_EXP>();
 }

test/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>();
     test<unsigned short>();
     test<int>();
     test<unsigned int>();
     test<long>();
     test<unsigned long>();
     test<long long>();
     test<unsigned long long>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>();
+    test<__uint128_t>();
+#endif
     test<float>();
     test<double>();
     test<long double>();
 }

test/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, 2>();
     test<unsigned short, 2>();
     test<int, 2>();
     test<unsigned int, 2>();
     test<long, 2>();
     test<unsigned long, 2>();
     test<long long, 2>();
     test<unsigned long long, 2>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, 2>();
+    test<__uint128_t, 2>();
+#endif
     test<float, FLT_RADIX>();
     test<double, FLT_RADIX>();
     test<long double, FLT_RADIX>();
 }

test/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>(0);
     test<unsigned short>(0);
     test<int>(0);
     test<unsigned int>(0);
     test<long>(0);
     test<unsigned long>(0);
     test<long long>(0);
     test<unsigned long long>(0);
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>(0);
+    test<__uint128_t>(0);
+#endif
     test<float>(0.5);
     test<double>(0.5);
     test<long double>(0.5);
 }

test/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, std::round_toward_zero>();
     test<unsigned short, std::round_toward_zero>();
     test<int, std::round_toward_zero>();
     test<unsigned int, std::round_toward_zero>();
     test<long, std::round_toward_zero>();
     test<unsigned long, std::round_toward_zero>();
     test<long long, std::round_toward_zero>();
     test<unsigned long long, std::round_toward_zero>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, std::round_toward_zero>();
+    test<__uint128_t, std::round_toward_zero>();
+#endif
     test<float, std::round_to_nearest>();
     test<double, std::round_to_nearest>();
     test<long double, std::round_to_nearest>();
 }

test/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>();
     test<unsigned short>();
     test<int>();
     test<unsigned int>();
     test<long>();
     test<unsigned long>();
     test<long long>();
     test<unsigned long long>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>();
+    test<__uint128_t>();
+#endif
     test<float>();
     test<double>();
     test<long double>();
 }

test/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, false>();
+    test<__uint128_t, false>();
+#endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 }

test/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short, integral_types_trap>();
     test<unsigned short, integral_types_trap>();
     test<int, integral_types_trap>();
     test<unsigned int, integral_types_trap>();
     test<long, integral_types_trap>();
     test<unsigned long, integral_types_trap>();
     test<long long, integral_types_trap>();
     test<unsigned long long, integral_types_trap>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t, integral_types_trap>();
+    test<__uint128_t, integral_types_trap>();
+#endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 }

test/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp

 enum Enum {zero, one_};
 
 enum BigEnum
 {
     bigzero,
     big = 0xFFFFFFFFFFFFFFFFULL
 };
 
+#ifndef _LIBCPP_HAS_NO_INT128
+enum HugeEnum : __uint128_t
+{
+    hugezero
+};
+#endif
+
 template <class T, class U>
 void test_make_signed()
 {
     static_assert((std::is_same<typename std::make_signed<T>::type, U>::value), "");
 #if _LIBCPP_STD_VER > 11
     static_assert((std::is_same<std::make_signed_t<T>, U>::value), "");
 #endif
 }
int main()
     test_make_signed< long, signed long >();
     test_make_signed< unsigned long, long >();
     test_make_signed< long long, signed long long >();
     test_make_signed< unsigned long long, signed long long >();
     test_make_signed< wchar_t, std::conditional<sizeof(wchar_t) == 4, int, short>::type >();
     test_make_signed< const wchar_t, std::conditional<sizeof(wchar_t) == 4, const int, const short>::type >();
     test_make_signed< const Enum, const int >();
     test_make_signed< BigEnum, std::conditional<sizeof(long) == 4, long long, long>::type >();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test_make_signed< __int128_t, __int128_t >();
+    test_make_signed< __uint128_t, __int128_t >();
+    test_make_signed< HugeEnum, __int128_t >();
+#endif
 }

test/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp

 enum Enum {zero, one_};
 
 enum BigEnum
 {
     bigzero,
     big = 0xFFFFFFFFFFFFFFFFULL
 };
 
+#ifndef _LIBCPP_HAS_NO_INT128
+enum HugeEnum : __int128_t
+{
+    hugezero
+};
+#endif
+
 template <class T, class U>
 void test_make_unsigned()
 {
     static_assert((std::is_same<typename std::make_unsigned<T>::type, U>::value), "");
 #if _LIBCPP_STD_VER > 11
     static_assert((std::is_same<std::make_unsigned_t<T>, U>::value), "");
 #endif
 }
int main()
     test_make_unsigned<unsigned long, unsigned long> ();
     test_make_unsigned<long long, unsigned long long> ();
     test_make_unsigned<unsigned long long, unsigned long long> ();
     test_make_unsigned<wchar_t, std::conditional<sizeof(wchar_t) == 4, unsigned int, unsigned short>::type> ();
     test_make_unsigned<const wchar_t, std::conditional<sizeof(wchar_t) == 4, const unsigned int, const unsigned short>::type> ();
     test_make_unsigned<const Enum, const unsigned int> ();
     test_make_unsigned<BigEnum,
                    std::conditional<sizeof(long) == 4, unsigned long long, unsigned long>::type> ();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test_make_unsigned<__int128_t, __uint128_t>();
+    test_make_unsigned<__uint128_t, __uint128_t>();
+    test_make_unsigned<HugeEnum, __uint128_t>();
+#endif
 }

test/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp

int main()
     test_integral<short>();
     test_integral<unsigned short>();
     test_integral<int>();
     test_integral<unsigned int>();
     test_integral<long>();
     test_integral<unsigned long>();
     test_integral<long long>();
     test_integral<unsigned long long>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test_integral<__int128_t>();
+    test_integral<__uint128_t>();
+#endif
 }

test/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp

int main()
     test_integral<short>();
     test_integral<unsigned short>();
     test_integral<int>();
     test_integral<unsigned int>();
     test_integral<long>();
     test_integral<unsigned long>();
     test_integral<long long>();
     test_integral<unsigned long long>();
+#ifndef _LIBCPP_HAS_NO_INT128
+    test_integral<__int128_t>();
+    test_integral<__uint128_t>();
+#endif
 }

test/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp

int main()
     test_is_not_signed<const int*>();
     test_is_not_signed<char[3]>();
     test_is_not_signed<char[3]>();
     test_is_not_signed<bool>();
     test_is_not_signed<unsigned>();
 
     test_is_signed<int>();
     test_is_signed<double>();
+
+#ifndef _LIBCPP_HAS_NO_INT128
+    test_is_signed<__int128_t>();
+    test_is_not_signed<__uint128_t>();
+#endif
 }

test/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp

int main()
     test_is_not_unsigned<const int*>();
     test_is_not_unsigned<char[3]>();
     test_is_not_unsigned<char[3]>();
     test_is_not_unsigned<int>();
     test_is_not_unsigned<double>();
 
     test_is_unsigned<bool>();
     test_is_unsigned<unsigned>();
+
+#ifndef _LIBCPP_HAS_NO_INT128
+    test_is_unsigned<__uint128_t>();
+    test_is_not_unsigned<__int128_t>();
+#endif
 }