Re: [PATCH] libstdc++: Add _Float128 to_chars/from_chars support for x86, ia64 and ppc64le with glibc

[Jonathan Wakely <jwakely@redhat.com>]

On Wed, 2 Nov 2022 at 09:26, Jakub Jelinek <jakub@redhat.com> wrote:
>
> Hi!
>
> The following patch adds std::{to,from}_chars support for std::float128_t
> on glibc 2.26+ for {i?86,x86_64,ia64,powerpc64le}-linux.
> When long double is already IEEE quad, previous changes already handle
> it by using long double overloads in _Float128 overloads.
> The powerpc64le case (with explicit or implicit -mabi=ibmlongdouble)
> is handled by using the __float128/__ieee128 entrypoints which are
> already in the library and used for -mabi=ieeelongdouble.
> For i?86, x86_64 and ia64 this patch adds new library entrypoints,
> mostly by enabling the code that was already there for powerpc64le-linux.
> Those use __float128 or __ieee128, the patch uses _Float128 for the
> exported overloads and internally as template parameter.  While
> powerpc64le-linux uses __sprintfieee128 and __strtoieee128,
> for _Float128 the patch uses the glibc 2.26 strfromf128 and strtof128
> APIs.  So that one can build gcc against older glibc and then compile
> user programs on newer glibc, the patch uses weak references unless
> gcc is compiled against glibc 2.26+.  strfromf128 unfortunately can't
> handle %.0Lf and %.*Le, %.*Lf, %.*Lg format strings sprintf/__sprintfieee128
> use, we need to remove the L from those and replace * with actually
> directly printing the precision into the format string (i.e. it can
> handle %.0f and %.27f (floating point type is implied from the function
> name)).

Wow, nice work juggling all the pieces here.

> Unlike the std::{,b}float16_t support, this one actually exports APIs
> with std::float128_t aka _Float128 in the mangled name, because no
> standard format is superset of it.  On the other side, e.g. on i?86/x86_64
> it doesn't have restrictions like for _Float16/__bf16 which ISAs need
> to be enabled in order to use it.
>
> The denorm_min case in the testcase is temporarily commented out because
> of the ERANGE subnormal issue Patrick posted patch for.
>
> Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?

OK, thanks!


>
> 2022-11-02  Jakub Jelinek  <jakub@redhat.com>
>
>         * include/std/charconv (from_chars, to_chars): Add _Float128
>         overfloads if _GLIBCXX_HAVE_FLOAT128_MATH is defined.
>         * config/abi/pre/gnu.ver (GLIBCXX_3.4.31): Export
>         _ZSt8to_charsPcS_DF128_, _ZSt8to_charsPcS_DF128_St12chars_format,
>         _ZSt8to_charsPcS_DF128_St12chars_formati and
>         _ZSt10from_charsPKcS0_RDF128_St12chars_format.
>         * src/c++17/floating_from_chars.cc (USE_STRTOF128_FOR_FROM_CHARS):
>         Define if needed.
>         (__strtof128): Declare.
>         (from_chars_impl): Handle _Float128.
>         (from_chars): New _Float128 overload if USE_STRTOF128_FOR_FROM_CHARS
>         is define.
>         * src/c++17/floating_to_chars.cc (__strfromf128): Declare.
>         (FLOAT128_TO_CHARS): Define even when _Float128 is supported and
>         wider than long double.
>         (F128_type): Use _Float128 for that case.
>         (floating_type_traits): Specialize for F128_type rather than
>         __float128.
>         (sprintf_ld): Add length argument.  Handle _Float128.
>         (__floating_to_chars_shortest, __floating_to_chars_precision):
>         Pass length to sprintf_ld.
>         (to_chars): Add _Float128 overloads for the F128_type being
>         _Float128 cases.
>         * testsuite/20_util/to_chars/float128_c++23.cc: New test.
>
> --- libstdc++-v3/include/std/charconv.jj        2022-10-31 22:20:39.475072806 +0100
> +++ libstdc++-v3/include/std/charconv   2022-11-01 16:48:50.693196228 +0100
> @@ -736,6 +736,27 @@ namespace __detail
>        __value = __val;
>      return __res;
>    }
> +#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
> +#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
> +  __extension__ from_chars_result
> +  from_chars(const char* __first, const char* __last, __ieee128& __value,
> +            chars_format __fmt = chars_format::general) noexcept;
> +
> +  inline from_chars_result
> +  from_chars(const char* __first, const char* __last, _Float128& __value,
> +            chars_format __fmt = chars_format::general) noexcept
> +  {
> +    __extension__ __ieee128 __val;
> +    from_chars_result __res = from_chars(__first, __last, __val, __fmt);
> +    if (__res.ec == errc{})
> +      __value = __val;
> +    return __res;
> +  }
> +#else
> +  from_chars_result
> +  from_chars(const char* __first, const char* __last, _Float128& __value,
> +            chars_format __fmt = chars_format::general) noexcept;
> +#endif
>  #endif
>
>  #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) \
> @@ -851,6 +872,46 @@ namespace __detail
>      return to_chars(__first, __last, static_cast<long double>(__value), __fmt,
>                     __precision);
>    }
> +#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
> +#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
> +  __extension__ to_chars_result
> +  to_chars(char* __first, char* __last, __float128 __value) noexcept;
> +  __extension__ to_chars_result
> +  to_chars(char* __first, char* __last, __float128 __value,
> +          chars_format __fmt) noexcept;
> +  __extension__ to_chars_result
> +  to_chars(char* __first, char* __last, __float128 __value,
> +          chars_format __fmt, int __precision) noexcept;
> +
> +  inline to_chars_result
> +  to_chars(char* __first, char* __last, _Float128 __value) noexcept
> +  {
> +    __extension__
> +    return to_chars(__first, __last, static_cast<__float128>(__value));
> +  }
> +  inline to_chars_result
> +  to_chars(char* __first, char* __last, _Float128 __value,
> +          chars_format __fmt) noexcept
> +  {
> +    __extension__
> +    return to_chars(__first, __last, static_cast<__float128>(__value), __fmt);
> +  }
> +  inline to_chars_result
> +  to_chars(char* __first, char* __last, _Float128 __value,
> +          chars_format __fmt, int __precision) noexcept
> +  {
> +    __extension__
> +    return to_chars(__first, __last, static_cast<__float128>(__value), __fmt,
> +                   __precision);
> +  }
> +#else
> +  to_chars_result to_chars(char* __first, char* __last, _Float128 __value)
> +    noexcept;
> +  to_chars_result to_chars(char* __first, char* __last, _Float128 __value,
> +                          chars_format __fmt) noexcept;
> +  to_chars_result to_chars(char* __first, char* __last, _Float128 __value,
> +                          chars_format __fmt, int __precision) noexcept;
> +#endif
>  #endif
>
>  #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
> --- libstdc++-v3/config/abi/pre/gnu.ver.jj      2022-10-31 22:20:39.475072806 +0100
> +++ libstdc++-v3/config/abi/pre/gnu.ver 2022-11-01 17:00:57.682346445 +0100
> @@ -2450,6 +2450,10 @@ GLIBCXX_3.4.31 {
>      _ZSt21__to_chars_bfloat16_tPcS_fSt12chars_format;
>      _ZSt22__from_chars_float16_tPKcS0_RfSt12chars_format;
>      _ZSt23__from_chars_bfloat16_tPKcS0_RfSt12chars_format;
> +    _ZSt8to_charsPcS_DF128_;
> +    _ZSt8to_charsPcS_DF128_St12chars_format;
> +    _ZSt8to_charsPcS_DF128_St12chars_formati;
> +    _ZSt10from_charsPKcS0_RDF128_St12chars_format;
>  } GLIBCXX_3.4.30;
>
>  # Symbols in the support library (libsupc++) have their own tag.
> --- libstdc++-v3/src/c++17/floating_from_chars.cc.jj    2022-10-31 22:20:39.476072793 +0100
> +++ libstdc++-v3/src/c++17/floating_from_chars.cc       2022-11-01 16:59:23.999615740 +0100
> @@ -59,6 +59,14 @@
>  #endif
>  // strtold for __ieee128
>  extern "C" __ieee128 __strtoieee128(const char*, char**);
> +#elif __FLT128_MANT_DIG__ == 113 && __LDBL_MANT_DIG__ != 113 \
> +      && defined(__GLIBC_PREREQ)
> +#define USE_STRTOF128_FOR_FROM_CHARS 1
> +extern "C" _Float128 __strtof128(const char*, char**)
> +#ifndef _GLIBCXX_HAVE_FLOAT128_MATH
> +  __attribute__((__weak__))
> +#endif
> +  __asm ("strtof128");
>  #endif
>
>  #if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
> @@ -618,6 +626,16 @@ namespace
>  # ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
>         else if constexpr (is_same_v<T, __ieee128>)
>           tmpval = __strtoieee128(str, &endptr);
> +# elif defined(USE_STRTOF128_FOR_FROM_CHARS)
> +       else if constexpr (is_same_v<T, _Float128>)
> +         {
> +#ifndef _GLIBCXX_HAVE_FLOAT128_MATH
> +           if (&__strtof128 == nullptr)
> +             tmpval = _Float128(std::strtold(str, &endptr);
> +           else
> +#endif
> +             tmpval = __strtof128(str, &endptr);
> +         }
>  # endif
>  #else
>         tmpval = std::strtod(str, &endptr);
> @@ -1232,6 +1250,14 @@ from_chars(const char* first, const char
>            chars_format fmt) noexcept
>  {
>    // fast_float doesn't support IEEE binary128 format, but we can use strtold.
> +  return from_chars_strtod(first, last, value, fmt);
> +}
> +#elif defined(USE_STRTOF128_FOR_FROM_CHARS)
> +from_chars_result
> +from_chars(const char* first, const char* last, _Float128& value,
> +          chars_format fmt) noexcept
> +{
> +  // fast_float doesn't support IEEE binary128 format, but we can use strtold.
>    return from_chars_strtod(first, last, value, fmt);
>  }
>  #endif
> --- libstdc++-v3/src/c++17/floating_to_chars.cc.jj      2022-11-01 12:16:14.352652455 +0100
> +++ libstdc++-v3/src/c++17/floating_to_chars.cc 2022-11-01 16:25:48.330968909 +0100
> @@ -43,6 +43,13 @@
>  #endif
>  // sprintf for __ieee128
>  extern "C" int __sprintfieee128(char*, const char*, ...);
> +#elif __FLT128_MANT_DIG__ == 113 && __LDBL_MANT_DIG__ != 113 \
> +      && defined(__GLIBC_PREREQ)
> +extern "C" int __strfromf128(char*, size_t, const char*, _Float128)
> +#ifndef _GLIBCXX_HAVE_FLOAT128_MATH
> +  __attribute__((__weak__))
> +#endif
> +  __asm ("strfromf128");
>  #endif
>
>  // This implementation crucially assumes float/double have the
> @@ -77,10 +84,11 @@ extern "C" int __sprintfieee128(char*, c
>  #if defined _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && __FLT128_MANT_DIG__ == 113
>  // Define overloads of std::to_chars for __float128.
>  # define FLOAT128_TO_CHARS 1
> -#endif
> -
> -#ifdef FLOAT128_TO_CHARS
>  using F128_type = __float128;
> +#elif __FLT128_MANT_DIG__ == 113 && __LDBL_MANT_DIG__ != 113 \
> +      && defined(__GLIBC_PREREQ)
> +# define FLOAT128_TO_CHARS 1
> +using F128_type = _Float128;
>  #else
>  using F128_type = void;
>  #endif
> @@ -252,7 +260,7 @@ namespace
>
>  # ifdef FLOAT128_TO_CHARS
>    template<>
> -    struct floating_type_traits<__float128> : floating_type_traits_binary128
> +    struct floating_type_traits<F128_type> : floating_type_traits_binary128
>      { };
>  # endif
>  #endif
> @@ -1035,7 +1043,8 @@ namespace
>  #pragma GCC diagnostic ignored "-Wabi"
>    template<typename T, typename... Extra>
>    inline int
> -  sprintf_ld(char* buffer, const char* format_string, T value, Extra... args)
> +  sprintf_ld(char* buffer, size_t length __attribute__((unused)),
> +            const char* format_string, T value, Extra... args)
>    {
>      int len;
>
> @@ -1045,10 +1054,31 @@ namespace
>        fesetround(FE_TONEAREST); // We want round-to-nearest behavior.
>  #endif
>
> +#ifdef FLOAT128_TO_CHARS
>  #ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
>      if constexpr (is_same_v<T, __ieee128>)
>        len = __sprintfieee128(buffer, format_string, args..., value);
>      else
> +#else
> +    if constexpr (is_same_v<T, _Float128>)
> +      {
> +#ifndef _GLIBCXX_HAVE_FLOAT128_MATH
> +       if (&__strfromf128 == nullptr)
> +         len = sprintf(buffer, format_string, args..., (long double)value);
> +       else
> +#endif
> +       if constexpr (sizeof...(args) == 0)
> +         len = __strfromf128(buffer, length, "%.0f", value);
> +       else
> +         {
> +           // strfromf128 unfortunately doesn't allow .*
> +           char fmt[3 * sizeof(int) + 6];
> +           sprintf(fmt, "%%.%d%c", args..., int(format_string[4]));
> +           len = __strfromf128(buffer, length, fmt, value);
> +         }
> +      }
> +    else
> +#endif
>  #endif
>      len = sprintf(buffer, format_string, args..., value);
>
> @@ -1206,8 +1236,10 @@ template<typename T>
>             // can avoid this if we use sprintf to write all but the last
>             // digit, and carefully compute and write the last digit
>             // ourselves.
> -           char buffer[expected_output_length+1];
> -           const int output_length = sprintf_ld(buffer, "%.0Lf", value);
> +           char buffer[expected_output_length + 1];
> +           const int output_length = sprintf_ld(buffer,
> +                                                expected_output_length + 1,
> +                                                "%.0Lf", value);
>             __glibcxx_assert(output_length == expected_output_length);
>             memcpy(first, buffer, output_length);
>             return {first + output_length, errc{}};
> @@ -1397,9 +1429,10 @@ template<typename T>
>           __builtin_unreachable();
>
>         // Do the sprintf into the local buffer.
> -       char buffer[output_length_upper_bound+1];
> +       char buffer[output_length_upper_bound + 1];
>         int output_length
> -         = sprintf_ld(buffer, output_specifier, value, effective_precision);
> +         = sprintf_ld(buffer, output_length_upper_bound + 1, output_specifier,
> +                      value, effective_precision);
>         __glibcxx_assert(output_length <= output_length_upper_bound);
>
>         if (effective_precision > 0)
> @@ -1799,6 +1832,7 @@ to_chars(char* first, char* last, long d
>  }
>
>  #ifdef FLOAT128_TO_CHARS
> +#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
>  to_chars_result
>  to_chars(char* first, char* last, __float128 value) noexcept
>  {
> @@ -1817,6 +1851,26 @@ to_chars(char* first, char* last, __floa
>  {
>    return __floating_to_chars_precision(first, last, value, fmt, precision);
>  }
> +#else
> +to_chars_result
> +to_chars(char* first, char* last, _Float128 value) noexcept
> +{
> +  return __floating_to_chars_shortest(first, last, value, chars_format{});
> +}
> +
> +to_chars_result
> +to_chars(char* first, char* last, _Float128 value, chars_format fmt) noexcept
> +{
> +  return __floating_to_chars_shortest(first, last, value, fmt);
> +}
> +
> +to_chars_result
> +to_chars(char* first, char* last, _Float128 value, chars_format fmt,
> +        int precision) noexcept
> +{
> +  return __floating_to_chars_precision(first, last, value, fmt, precision);
> +}
> +#endif
>  #endif
>
>  // Entrypoints for 16-bit floats.
> --- libstdc++-v3/testsuite/20_util/to_chars/float128_c++23.cc.jj        2022-11-01 17:04:19.895606130 +0100
> +++ libstdc++-v3/testsuite/20_util/to_chars/float128_c++23.cc   2022-11-01 20:47:15.254989646 +0100
> @@ -0,0 +1,105 @@
> +// Copyright (C) 2022 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library.  This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> +// GNU General Public License for more details.
> +
> +// You should have received a copy of the GNU General Public License along
> +// with this library; see the file COPYING3.  If not see
> +// <http://www.gnu.org/licenses/>.
> +
> +// { dg-options "-std=gnu++2b" }
> +// { dg-do run { target c++23 } }
> +// { dg-require-effective-target ieee_floats }
> +// { dg-require-effective-target size32plus }
> +// { dg-add-options ieee }
> +
> +#include <charconv>
> +#include <stdfloat>
> +#include <limits>
> +#include <numbers>
> +#include <testsuite_hooks.h>
> +
> +#if defined(__STDCPP_FLOAT128_T__) \
> +    && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
> +       || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
> +void
> +test(std::chars_format fmt = std::chars_format{})
> +{
> +  std::float128_t tests[] = {
> +//    std::numeric_limits<std::float128_t>::denorm_min(),
> +    std::numeric_limits<std::float128_t>::min(),
> +    0.0f128,
> +    -42.0f128,
> +    1234.5678912345f128,
> +    std::numbers::e_v<std::float128_t>,
> +    std::numbers::log2e_v<std::float128_t>,
> +    std::numbers::log10e_v<std::float128_t>,
> +    std::numbers::pi_v<std::float128_t>,
> +    std::numbers::inv_pi_v<std::float128_t>,
> +    std::numbers::inv_sqrtpi_v<std::float128_t>,
> +    std::numbers::ln2_v<std::float128_t>,
> +    std::numbers::ln10_v<std::float128_t>,
> +    std::numbers::sqrt2_v<std::float128_t>,
> +    std::numbers::sqrt3_v<std::float128_t>,
> +    std::numbers::inv_sqrt3_v<std::float128_t>,
> +    std::numbers::egamma_v<std::float128_t>,
> +    std::numbers::phi_v<std::float128_t>,
> +    std::numeric_limits<std::float128_t>::max()
> +  };
> +  char str1[10000], str2[10000];
> +  for (auto u : tests)
> +    {
> +      auto [ptr1, ec1] = std::to_chars(str1, str1 + sizeof(str1), u, fmt);
> +      VERIFY( ec1 == std::errc() );
> +//    std::cout << i << ' ' << std::string_view (str1, ptr1) << '\n';
> +      if (fmt == std::chars_format::fixed)
> +       {
> +         auto [ptr2, ec2] = std::to_chars(str2, str2 + (ptr1 - str1), u, fmt);
> +         VERIFY( ec2 == std::errc() && ptr2 - str2 == ptr1 - str1 );
> +         auto [ptr3, ec3] = std::to_chars(str2, str2 + (ptr1 - str1 - 1), u, fmt);
> +         VERIFY( ec3 != std::errc() );
> +       }
> +      std::float128_t v;
> +      auto [ptr4, ec4] = std::from_chars(str1, ptr1, v,
> +                                        fmt == std::chars_format{}
> +                                        ? std::chars_format::general : fmt);
> +      VERIFY( ec4 == std::errc() && ptr4 == ptr1 );
> +      VERIFY( u == v );
> +
> +      auto [ptr5, ec5] = std::to_chars(str1, str1 + sizeof(str1), u, fmt, 90);
> +      VERIFY( ec5 == std::errc() );
> +//    std::cout << i << ' ' << std::string_view (str1, ptr5) << '\n';
> +      v = 4.0f128;
> +      auto [ptr6, ec6] = std::from_chars(str1, ptr5, v,
> +                                        fmt == std::chars_format{}
> +                                        ? std::chars_format::general : fmt);
> +      VERIFY( ec6 == std::errc() && ptr6 == ptr5 );
> +      if (fmt == std::chars_format::fixed && u > 0.0f128 && u < 0.000001f128)
> +       VERIFY( v == 0.0 );
> +      else
> +       VERIFY( u == v );
> +    }
> +}
> +#endif
> +
> +int
> +main()
> +{
> +#if defined(__STDCPP_FLOAT128_T__) \
> +    && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
> +       || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
> +  test();
> +  test(std::chars_format::fixed);
> +  test(std::chars_format::scientific);
> +  test(std::chars_format::general);
> +  test(std::chars_format::hex);
> +#endif
> +}
>
>         Jakub
>