[libc++][format] Implements 128-bit support.

[Mordante]

Summary

With to_chars supporting 128-bit it's possible to support the full
128-bit range in format. This only removes the previous restrictions
and updates the tests to validate proper support.

Depends on D128929.

[ldionne]

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp

92–99

This applies elsewhere in this patch too.

libcxx/include/__format/formatter_integer.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FORMAT_FORMATTER_INTEGER_H
 #define _LIBCPP___FORMAT_FORMATTER_INTEGER_H
 
 #include <__availability>
 #include <__concepts/arithmetic.h>
 #include <__config>
-#include <__format/format_error.h> // TODO FMT Remove after adding 128-bit support
 #include <__format/format_fwd.h>
 #include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
 #include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
-#include <limits> // TODO FMT Remove after adding 128-bit support
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-_LIBCPP_PUSH_MACROS // TODO FMT Remove after adding 128-bit support
-#include <__undef_macros>
-
     _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
     template <__formatter::__char_type _CharT>
     struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_integer {
 
 public:

 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long, _CharT> : public __formatter_integer<_CharT> {};
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long long, _CharT>
     : public __formatter_integer<_CharT> {};
 #  ifndef _LIBCPP_HAS_NO_INT128
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<__int128_t, _CharT>
-    : public __formatter_integer<_CharT> {
-  using _Base = __formatter_integer<_CharT>;
-
-  _LIBCPP_HIDE_FROM_ABI auto format(__int128_t __value, auto& __ctx) const -> decltype(__ctx.out()) {
-    // TODO FMT Implement full 128 bit support.
-    using _To = long long;
-    if (__value < numeric_limits<_To>::min() || __value > numeric_limits<_To>::max())
-      std::__throw_format_error("128-bit value is outside of implemented range");
-
-    return _Base::format(static_cast<_To>(__value), __ctx);
-  }
-};
+    : public __formatter_integer<_CharT> {};
 #  endif
 
 // Unsigned integral types.
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned char, _CharT>
     : public __formatter_integer<_CharT> {};
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned short, _CharT>
     : public __formatter_integer<_CharT> {};
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned, _CharT>
     : public __formatter_integer<_CharT> {};
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned long, _CharT>
     : public __formatter_integer<_CharT> {};
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned long long, _CharT>
     : public __formatter_integer<_CharT> {};
 #  ifndef _LIBCPP_HAS_NO_INT128
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<__uint128_t, _CharT>
-    : public __formatter_integer<_CharT> {
-  using _Base = __formatter_integer<_CharT>;
-
-  _LIBCPP_HIDE_FROM_ABI auto format(__uint128_t __value, auto& __ctx) const -> decltype(__ctx.out()) {
-    // TODO FMT Implement full 128 bit support.
-    using _To = unsigned long long;
-    if (__value < numeric_limits<_To>::min() || __value > numeric_limits<_To>::max())
-      std::__throw_format_error("128-bit value is outside of implemented range");
-
-    return _Base::format(static_cast<_To>(__value), __ctx);
-  }
-};
+    : public __formatter_integer<_CharT> {};
 #  endif
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
-_LIBCPP_POP_MACROS
-
 #endif // _LIBCPP___FORMAT_FORMATTER_INTEGER_H

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp

if (sizeof(A) > 1) {
     test_termination_condition(STR("-32768"), STR("}"), A(-32768));
     test_termination_condition(STR("32767"), STR("}"), A(32767));
   }
   if (sizeof(A) > 2) {
     test_termination_condition(STR("-2147483648"), STR("}"), A(-2147483648));
     test_termination_condition(STR("2147483647"), STR("}"), A(2147483647));
   }
   if (sizeof(A) > 4) {
-    // -9223372036854775808 can't be used directly, it gives the following
-    // diagnostic:
-    // integer literal is too large to be represented in a signed integer type,
-    // interpreting as unsigned [-Werror,-Wimplicitly-unsigned-literal]
-    test_termination_condition(STR("-9223372036854775808"), STR("}"),
-                               A(-9223372036854775807 - 1));
-    test_termination_condition(STR("9223372036854775807"), STR("}"),
-                               A(9223372036854775807));
+    test_termination_condition(STR("-9223372036854775808"), STR("}"), A(std::numeric_limits<int64_t>::min()));
+    test_termination_condition(STR("9223372036854775807"), STR("}"), A(std::numeric_limits<int64_t>::max()));
   }
-
-  // TODO FMT Implement the __int128_t minimum and maximum once the formatter
-  // can handle these values.
+#ifndef TEST_HAS_NO_INT128
+  if (sizeof(A) > 8) {
+    test_termination_condition(
+        STR("-170141183460469231731687303715884105728"), STR("}"), A(std::numeric_limits<__int128_t>::min()));
+    test_termination_condition(
+        STR("170141183460469231731687303715884105727"), STR("}"), A(std::numeric_limits<__int128_t>::max()));
+  }
+#endif
 }
 
 template <class CharT>
 void test_all_signed_integral_types() {
   test_signed_integral_type<signed char, CharT>();
   test_signed_integral_type<short, CharT>();
   test_signed_integral_type<int, CharT>();
   test_signed_integral_type<long, CharT>();

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.unsigned_integral.pass.cpp

void test_unsigned_integral_type() {
   test_termination_condition(STR("255"), STR("}"), A(255));
   if (sizeof(A) > 1)
     test_termination_condition(STR("65535"), STR("}"), A(65535));
   if (sizeof(A) > 2)
     test_termination_condition(STR("4294967295"), STR("}"), A(4294967295));
   if (sizeof(A) > 4)
     test_termination_condition(STR("8446744073709551615"), STR("}"),
                                A(8446744073709551615));
-
-  // TODO FMT Implement the __uint128_t maximum once the formatter can handle
-  // these values.
+#ifndef TEST_HAS_NO_INT128
+  if (sizeof(A) > 8)
+    test_termination_condition(
+        STR("340282366920938463463374607431768211455"), STR("}"), A(std::numeric_limits<__uint128_t>::max()));
+#endif
 }
 
 template <class CharT>
 void test_all_unsigned_integral_types() {
   test_unsigned_integral_type<unsigned char, CharT>();
   test_unsigned_integral_type<unsigned short, CharT>();
   test_unsigned_integral_type<unsigned, CharT>();
   test_unsigned_integral_type<unsigned long, CharT>();

libcxx/test/std/utilities/format/format.functions/format_tests.h

void format_test_integer_as_char(TestFunction check, ExceptionTest check_exception) {
   // Note it has no effect but it's allowed.
   check.template operator()<"answer is '{:Lc}'">(SV("answer is '*'"), I(42));
 
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("bBcdoxX"))
     check_exception("The format-spec type has a type not supported for an integer argument", fmt, I(42));
 
   // *** Validate range ***
-  // TODO FMT Update test after adding 128-bit support.
-  if constexpr (sizeof(I) <= sizeof(long long)) {
-    // The code has some duplications to keep the if statement readable.
-    if constexpr (std::signed_integral<CharT>) {
-      if constexpr (std::signed_integral<I> && sizeof(I) > sizeof(CharT)) {
-        check_exception("Integral value outside the range of the char type", SV("{:c}"), std::numeric_limits<I>::min());
-        check_exception("Integral value outside the range of the char type", SV("{:c}"), std::numeric_limits<I>::max());
-      } else if constexpr (std::unsigned_integral<I> && sizeof(I) >= sizeof(CharT)) {
-        check_exception("Integral value outside the range of the char type", SV("{:c}"), std::numeric_limits<I>::max());
-      }
-    } else if constexpr (sizeof(I) > sizeof(CharT)) {
-      check_exception("Integral value outside the range of the char type", SV("{:c}"), std::numeric_limits<I>::max());
-    }
-  }
-}
 
 template <class I, class CharT, class TestFunction, class ExceptionTest>
 void format_test_integer(TestFunction check, ExceptionTest check_exception) {
   format_test_integer_as_integer<I, CharT>(check, check_exception);
   format_test_integer_as_char<I, CharT>(check, check_exception);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
#endif
   check.template operator()<"{:#x}">(SV("-0x80000000"), std::numeric_limits<int32_t>::min());
 
   check.template operator()<"{:#b}">(SV("-0b1000000000000000000000000000000000000000000000000000000000000000"),
                                      std::numeric_limits<int64_t>::min());
   check.template operator()<"{:#o}">(SV("-01000000000000000000000"), std::numeric_limits<int64_t>::min());
   check.template operator()<"{:#}">(SV("-9223372036854775808"), std::numeric_limits<int64_t>::min());
   check.template operator()<"{:#x}">(SV("-0x8000000000000000"), std::numeric_limits<int64_t>::min());
 
+#ifndef TEST_HAS_NO_INT128
+  check.template operator()<"{:#b}">(
+      SV("-0b1000000000000000000000000000000000000000000000000000000000000000"
+         "0000000000000000000000000000000000000000000000000000000000000000"),
+      std::numeric_limits<__int128_t>::min());
+  check.template
+  operator()<"{:#o}">(SV("-02000000000000000000000000000000000000000000"), std::numeric_limits<__int128_t>::min());
+  check.template
+  operator()<"{:#}">(SV("-170141183460469231731687303715884105728"), std::numeric_limits<__int128_t>::min());
+  check.template operator()<"{:#x}">(SV("-0x80000000000000000000000000000000"), std::numeric_limits<__int128_t>::min());
+#endif
+
   check.template operator()<"{:#b}">(SV("0b1111111"), std::numeric_limits<int8_t>::max());
   check.template operator()<"{:#o}">(SV("0177"), std::numeric_limits<int8_t>::max());
   check.template operator()<"{:#}">(SV("127"), std::numeric_limits<int8_t>::max());
   check.template operator()<"{:#x}">(SV("0x7f"), std::numeric_limits<int8_t>::max());
 
   check.template operator()<"{:#b}">(SV("0b111111111111111"), std::numeric_limits<int16_t>::max());
   check.template operator()<"{:#o}">(SV("077777"), std::numeric_limits<int16_t>::max());
   check.template operator()<"{:#}">(SV("32767"), std::numeric_limits<int16_t>::max());
   check.template operator()<"{:#x}">(SV("0x7fff"), std::numeric_limits<int16_t>::max());
 
   check.template operator()<"{:#b}">(SV("0b1111111111111111111111111111111"), std::numeric_limits<int32_t>::max());
   check.template operator()<"{:#o}">(SV("017777777777"), std::numeric_limits<int32_t>::max());
   check.template operator()<"{:#}">(SV("2147483647"), std::numeric_limits<int32_t>::max());
   check.template operator()<"{:#x}">(SV("0x7fffffff"), std::numeric_limits<int32_t>::max());
 
   check.template operator()<"{:#b}">(SV("0b111111111111111111111111111111111111111111111111111111111111111"),
                                      std::numeric_limits<int64_t>::max());
   check.template operator()<"{:#o}">(SV("0777777777777777777777"), std::numeric_limits<int64_t>::max());
   check.template operator()<"{:#}">(SV("9223372036854775807"), std::numeric_limits<int64_t>::max());
   check.template operator()<"{:#x}">(SV("0x7fffffffffffffff"), std::numeric_limits<int64_t>::max());
 
-  // TODO FMT Add __int128_t test after implementing full range.
+#ifndef TEST_HAS_NO_INT128
+  check.template operator()<"{:#b}">(
+      SV("0b111111111111111111111111111111111111111111111111111111111111111"
+         "1111111111111111111111111111111111111111111111111111111111111111"),
+      std::numeric_limits<__int128_t>::max());
+  check.template
+  operator()<"{:#o}">(SV("01777777777777777777777777777777777777777777"), std::numeric_limits<__int128_t>::max());
+  check.template
+  operator()<"{:#}">(SV("170141183460469231731687303715884105727"), std::numeric_limits<__int128_t>::max());
+  check.template operator()<"{:#x}">(SV("0x7fffffffffffffffffffffffffffffff"), std::numeric_limits<__int128_t>::max());
+#endif
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_unsigned_integer(TestFunction check, ExceptionTest check_exception) {
   format_test_integer<unsigned char, CharT>(check, check_exception);
   format_test_integer<unsigned short, CharT>(check, check_exception);
   format_test_integer<unsigned, CharT>(check, check_exception);
   format_test_integer<unsigned long, CharT>(check, check_exception);
#endif
   check.template operator()<"{:#x}">(SV("0xffffffff"), std::numeric_limits<uint32_t>::max());
 
   check.template operator()<"{:#b}">(SV("0b1111111111111111111111111111111111111111111111111111111111111111"),
                                      std::numeric_limits<uint64_t>::max());
   check.template operator()<"{:#o}">(SV("01777777777777777777777"), std::numeric_limits<uint64_t>::max());
   check.template operator()<"{:#}">(SV("18446744073709551615"), std::numeric_limits<uint64_t>::max());
   check.template operator()<"{:#x}">(SV("0xffffffffffffffff"), std::numeric_limits<uint64_t>::max());
 
-  // TODO FMT Add __uint128_t test after implementing full range.
+#ifndef TEST_HAS_NO_INT128
+  check.template operator()<"{:#b}">(
+      SV("0b1111111111111111111111111111111111111111111111111111111111111111"
+         "1111111111111111111111111111111111111111111111111111111111111111"),
+      std::numeric_limits<__uint128_t>::max());
+  check.template
+  operator()<"{:#o}">(SV("03777777777777777777777777777777777777777777"), std::numeric_limits<__uint128_t>::max());
+  check.template
+  operator()<"{:#}">(SV("340282366920938463463374607431768211455"), std::numeric_limits<__uint128_t>::max());
+  check.template operator()<"{:#x}">(SV("0xffffffffffffffffffffffffffffffff"), std::numeric_limits<__uint128_t>::max());
+#endif
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_char(TestFunction check, ExceptionTest check_exception) {
 
   // ***** Char type *****
   // *** align-fill & width ***
   check.template operator()<"answer is '{:6}'">(SV("answer is '*     '"), CharT('*'));
void format_tests(TestFunction check, ExceptionTest check_exception) {
   // *** Test signed integral format argument ***
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<signed char>(42));
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<short>(42));
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<int>(42));
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<long>(42));
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<long long>(42));
 #ifndef TEST_HAS_NO_INT128
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<__int128_t>(42));
-  {
-    // Note 128-bit support is only partly implemented test the range
-    // conditions here.
-    static constexpr auto fmt = string_literal("{}");
-    std::basic_string<CharT> min = std::format(fmt.template sv<CharT>(), std::numeric_limits<long long>::min());
-    check.template operator()<"{}">(std::basic_string_view<CharT>(min),
-                                    static_cast<__int128_t>(std::numeric_limits<long long>::min()));
-    std::basic_string<CharT> max = std::format(fmt.template sv<CharT>(), std::numeric_limits<long long>::max());
-    check.template operator()<"{}">(std::basic_string_view<CharT>(max),
-                                    static_cast<__int128_t>(std::numeric_limits<long long>::max()));
-    check_exception("128-bit value is outside of implemented range", SV("{}"),
-                    static_cast<__int128_t>(std::numeric_limits<long long>::min()) - 1);
-    check_exception("128-bit value is outside of implemented range", SV("{}"),
-                    static_cast<__int128_t>(std::numeric_limits<long long>::max()) + 1);
-  }
 #endif
   format_test_signed_integer<CharT>(check, check_exception);
 
   // ** Test unsigned integral format argument ***
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<unsigned char>(42));
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<unsigned short>(42));
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<unsigned>(42));
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<unsigned long>(42));
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<unsigned long long>(42));
 #ifndef TEST_HAS_NO_INT128
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<__uint128_t>(42));
-  {
-    // Note 128-bit support is only partly implemented test the range
-    // conditions here.
-    static constexpr auto fmt = string_literal("{}");
-    std::basic_string<CharT> max = std::format(fmt.template sv<CharT>(), std::numeric_limits<unsigned long long>::max());
-    check.template operator()<"{}">(std::basic_string_view<CharT>(max),
-                                    static_cast<__uint128_t>(std::numeric_limits<unsigned long long>::max()));
-    check_exception("128-bit value is outside of implemented range", SV("{}"),
-                    static_cast<__uint128_t>(std::numeric_limits<unsigned long long>::max()) + 1);
-  }
 #endif
   format_test_unsigned_integer<CharT>(check, check_exception);
 
   // *** Test floating point format argument ***
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<float>(42));
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<double>(42));
   check.template operator()<"hello {}">(SV("hello 42"), static_cast<long double>(42));
   format_test_floating_point<CharT>(check, check_exception);