mpfr: Apply the backport of Float128 patch

This is the final patch that got applied to mpfr upstream
so lets drop the version we are carrying in favour of this backported.

(From OE-Core rev: e6fa8eea0cd035623f06d51da89cf2e3b9eb7449)

Signed-off-by: Khem Raj <raj.khem@gmail.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

1 files changed, 347 insertions, 35 deletions

diff --git a/meta/recipes-support/mpfr/mpfr/0001-include-math.h-to-use-predefined-_Float128-definitio.patch b/meta/recipes-support/mpfr/mpfr/0001-include-math.h-to-use-predefined-_Float128-definitio.patch
index 0dcbdce0db..bb813ee94d 100644
--- a/meta/recipes-support/mpfr/mpfr/0001-include-math.h-to-use-predefined-_Float128-definitio.patch
+++ b/meta/recipes-support/mpfr/mpfr/0001-include-math.h-to-use-predefined-_Float128-definitio.patch
@@ -1,44 +1,356 @@
-From 4f2af1afce6edb4ba1dfc9bb4849c9f300efe213 Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Thu, 26 Dec 2024 19:44:12 -0800
-Subject: [PATCH] include math.h to use predefined _Float128 definition
+From c37c9d599b9aced92e182507bf223440bbc9a9f1 Mon Sep 17 00:00:00 2001
+From: Vincent Lefevre <vincent@vinc17.net>
+Date: Thu, 6 Mar 2025 01:34:28 +0100
+Subject: [PATCH] Portability: clean up support for binary128 (a.k.a.
+ float128).
 
-glibc has added this patch [1] which defines __HAVE_FLOAT128 for clang
-therefore include math.h to avoid defining _Float128 during configure if
-not needed.
+This fixes a configure failure with Clang and glibc 2.41:
+  https://bugs.gentoo.org/949962
+  https://sourceware.org/bugzilla/show_bug.cgi?id=32750
+  https://sympa.inria.fr/sympa/arc/mpfr/2025-02/msg00025.html
+  https://sympa.inria.fr/sympa/arc/mpfr/2025-03/msg00001.html
 
-Fixes
-cannot combine with previous '__float128' declaration specifier
+The issue is the following: in its configure script, GNU MPFR first
+tests whether _Float128 is supported (without header inclusions);
+if it isn't, MPFR then tests whether __float128 is supported, and
+in such a case, it defines _Float128 as __float128 with
 
-[1] https://sourceware.org/git/?p=glibc.git;a=blobdiff;f=sysdeps/x86/bits/floatn.h;h=ba030d270a73c71f166083b30dbaf89371ff49fa;hp=e661abaea469b8b916fd312cc42382ad4c5e220f;hb=d773aff467840f5ed305e40c180466e90bd88183;hpb=b2556550a0f952b2a841a0b4bddc999c2df1b233
+  AC_DEFINE([_Float128],[__float128],[__float128 fallback])
 
-Upstream-Status: Submitted [https://sympa.inria.fr/sympa/arc/mpfr/2024-12/msg00001.html]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
+As Clang supports __float128 but not _Float128 (at least on x86_64,
+up to version 19), this fallback is selected. But glibc 2.41 has a
+similar fallback, with a typedef:
+
+  typedef __float128 _Float128;
+
+With the MPFR _Float128 macro defined as __float128, as soon as some
+header such as <stdio.h> is included, this yields
+
+  typedef __float128 __float128;
+
+which is incorrect. This first occurs in the
+
+  AC_MSG_CHECKING(for GMP_NUMB_BITS and sizeof(mp_limb_t) consistency)
+  [...]
+
+configure test (in configure.ac), hence the failure of this test and
+the configure script.
+
+As an attempt to avoid such an issue with header inclusion, a solution
+should be to include the common headers in every configure test.
+
+But since _Float128 is a reserved identifier, we must avoid defining
+it as a macro (a typedef would also be incorrect). This is done here,
+by defining a mpfr_float128 macro instead. In the public mpfr.h header
+file, if the user has defined MPFR_WANT_FLOAT128: mpfr_float128 will
+be defined as _Float128 by default (thus this will not change the API),
+but if _Float128 is not supported, the user should define mpfr_float128
+as __float128 (or an equivalent type that is supported).
+
+* acinclude.m4: changed _Float128 to mpfr_float128 in AC_DEFINE.
+* configure.ac: updated a comment about _Float128.
+* doc/README.dev: update about MPFR_WANT_FLOAT128 and _Float128.
+* doc/mpfr.texi: in "Nomenclature and Types", added a paragraph about
+  binary128 support and the mpfr_float128 macro; update concerning the
+  functions related to binary128 (in particular, in the prototypes,
+  changed _Float128 to mpfr_float128).
+* src/mpfr.h: under "#ifdef MPFR_WANT_FLOAT128", define mpfr_float128
+  as _Float128 if not defined yet; in the prototypes, changed
+  _Float128 to mpfr_float128.
+* src/get_float128.c, src/set_float128.c, tests/tset_float128.c:
+  changed _Float128 to mpfr_float128; updated comments.
+* tests/tversion.c: for "float128 = yes", also output the actual type.
+
+Upstream-Status: Backport [https://gitlab.inria.fr/mpfr/mpfr/-/commit/c37c9d599b9aced92e182507bf223440bbc9a9f1]
+Signed-off-by: Khem Raj <raj.khem@gmail.com>                                             
 ---
- acinclude.m4 | 6 ++++--
- 1 file changed, 4 insertions(+), 2 deletions(-)
+ acinclude.m4          | 11 +++++++----
+ configure.ac          |  2 +-
+ doc/README.dev        | 11 ++---------
+ doc/mpfr.texi         | 37 ++++++++++++++++++++++++++-----------
+ src/get_float128.c    | 17 ++++++++++-------
+ src/mpfr.h            | 10 ++++++++--
+ src/set_float128.c    | 15 +++++++++------
+ tests/tset_float128.c |  8 ++++----
+ tests/tversion.c      |  8 +++++++-
+ 9 files changed, 74 insertions(+), 45 deletions(-)
 
-diff --git a/acinclude.m4 b/acinclude.m4
-index 3d7910517..65c4eb9fd 100644
 --- a/acinclude.m4
 +++ b/acinclude.m4
-@@ -805,8 +805,9 @@ dnl the "undefined reference" error disappear.
- if test "$enable_float128" != no; then
-    AC_MSG_CHECKING(if _Float128 with hex constants is supported)
-    AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[
--volatile _Float128 x = 0x1.fp+16383f128;
--return x == 0;
-+     #include <math.h>
-+     volatile _Float128 x = 0x1.fp+16383f128;
-+     return x == 0;
- ]])],
-       [AC_MSG_RESULT(yes)
-        AC_DEFINE([MPFR_WANT_FLOAT128],1,[Build float128 functions])],
-@@ -816,6 +817,7 @@ dnl Use the q suffix in this case.
-        AC_LINK_IFELSE([AC_LANG_PROGRAM([[
- #define _Float128 __float128
- ]], [[
-+#include <math.h>
- volatile _Float128 x = 0x1.fp+16383q;
- return x == 0;
+@@ -781,8 +781,11 @@ fi
+ # End of decimal float checks
+ 
+ dnl Check if _Float128 or __float128 is available. We also require the
+-dnl compiler to support hex constants with the f128 or q suffix (this
+-dnl prevents the _Float128 support with GCC's -std=c90, but who cares?).
++dnl compiler to support hex constants with the f128 or q suffix respectively.
++dnl If _Float128 is supported, then the mpfr_float128 macro should be
++dnl defined as this type. We do not define it here because this will be
++dnl done in mpfr.h, and not defining it here is the only way to ensure
++dnl that under "make check", mpfr.h really defines it.
+ dnl Note: We use AC_LINK_IFELSE instead of AC_COMPILE_IFELSE since an
+ dnl error may occur only at link time, such as under NetBSD:
+ dnl   https://mail-index.netbsd.org/pkgsrc-users/2018/02/02/msg026220.html
+@@ -809,8 +812,8 @@ return x == 0;
  ]])],
+           [AC_MSG_RESULT(yes)
+            AC_DEFINE([MPFR_WANT_FLOAT128],2,
+-                     [Build float128 functions with float128 fallback])
+-           AC_DEFINE([_Float128],[__float128],[__float128 fallback])],
++                     [Build float128 functions with __float128 fallback])
++           AC_DEFINE([mpfr_float128],[__float128],[__float128 fallback])],
+           [AC_MSG_RESULT(no)
+            if test "$enable_float128" = yes; then
+               AC_MSG_ERROR(
+--- a/configure.ac
++++ b/configure.ac
+@@ -277,7 +277,7 @@ AC_ARG_ENABLE(decimal-float,
+ 
+ dnl Warning! Not to be confused with _Decimal128. Thus it is better
+ dnl to say binary128 in the description. It can correspond to either
+-dnl _Float128 (ISO/IEC TS 18661) or __float128 (old type name).
++dnl _Float128 (ISO C23) or __float128 (old type name).
+ AC_ARG_ENABLE(float128,
+    [  --disable-float128      explicitly disable binary128 support
+   --enable-float128       build conversion functions from/to binary128
+--- a/doc/README.dev
++++ b/doc/README.dev
+@@ -836,13 +836,6 @@ does not conform to the C standard by de
+ 
+    =====================================================================
+ 
+-In MPFR, _Float128 may be defined as __float128 if the latter is provided
+-by the compiler, but not the former. In such a case, do not assume that
+-_Float128 and long double are necessarily different types (as required by
+-the WG14 N2579 draft "IEC 60559 interchange and extended types").
+-
+-   =====================================================================
+-
+ For string suffix selection, do not write expressions of the form
+ string + integer, such as
+ 
+--- a/doc/mpfr.texi
++++ b/doc/mpfr.texi
+@@ -833,6 +833,26 @@ MPFR has a global (or per-thread) flag f
+ provides operations on flags (@ref{Exceptions}). This C data type is used
+ to represent a group of flags (or a mask).
+ 
++@cindex binary128
++@cindex float128
++@tindex @code{_Float128}
++@tindex @code{__float128}
++@tindex @code{mpfr_float128}
++MPFR can be built with binary128 support (a.k.a.@: float128) for some
++conversion functions if the @samp{_Float128} type (from ISO C23) or
++the @samp{__float128} type (a common extension) is available. This is
++automatically detected, but the @samp{--enable-float128} configure option
++can also be used to ensure this support.  For this support, MPFR uses a
++@code{mpfr_float128} macro, which needs to be defined as a supported type
++for the binary128 format, typically @samp{_Float128} or @samp{__float128},
++depending on the compiler and the system used to compile the user code.
++Before including @file{mpfr.h}, the user needs to do the following (in
++any order): define the @code{MPFR_WANT_FLOAT128} macro and define the
++@code{mpfr_float128} macro as the actual float128 type; @file{mpfr.h} will
++define @code{mpfr_float128} as @samp{_Float128} by default, but mainly for
++compatibility with software written for MPFR@tie{}4.1.x and 4.2.0, where
++the prototypes used @samp{_Float128}.
++
+ @node MPFR Variable Conventions, Rounding, Nomenclature and Types, MPFR Basics
+ @comment  node-name,  next,  previous,  up
+ @section MPFR Variable Conventions
+@@ -3646,9 +3666,9 @@ return zero otherwise.
+ @end deftypefun
+ 
+ @deftypefun int mpfr_buildopt_float128_p (void)
+-Return a non-zero value if MPFR was compiled with @samp{_Float128} support
+-(that is, MPFR was built with the @samp{--enable-float128} configure option),
+-return zero otherwise.
++Return a non-zero value if MPFR was compiled with binary128 support
++(a.k.a.@: float128), return zero otherwise. @xref{Nomenclature and Types}
++for additional information.
+ @end deftypefun
+ 
+ @deftypefun int mpfr_buildopt_decimal_p (void)
+--- a/src/get_float128.c
++++ b/src/get_float128.c
+@@ -1,5 +1,5 @@
+ /* mpfr_get_float128 -- convert a multiple precision floating-point
+-                        number to a _Float128 number
++                        number to a binary128 (a.k.a. float128) number
+ 
+ Copyright 2012-2023 Free Software Foundation, Inc.
+ Contributed by the AriC and Caramba projects, INRIA.
+@@ -25,17 +25,20 @@ https://www.gnu.org/licenses/ or write t
+ 
+ #ifdef MPFR_WANT_FLOAT128
+ 
++/* Note: mpfr_get_float128 is a macro defined as the actual binary128 type:
++   either _Float128 or __float128. */
++
+ /* generic code */
+-_Float128
++mpfr_float128
+ mpfr_get_float128 (mpfr_srcptr x, mpfr_rnd_t rnd_mode)
+ {
+ 
+   if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x)))
+-    return (_Float128) mpfr_get_d (x, rnd_mode);
++    return (mpfr_float128) mpfr_get_d (x, rnd_mode);
+   else /* now x is a normal non-zero number */
+     {
+-      _Float128 r; /* result */
+-      _Float128 m;
++      mpfr_float128 r; /* result */
++      mpfr_float128 m;
+       mpfr_exp_t e;  /* exponent of x (before rounding) */
+       mpfr_exp_t sh; /* exponent shift, so that x/2^sh is in the double range */
+       const int emin = -16381;
+@@ -62,7 +65,7 @@ mpfr_get_float128 (mpfr_srcptr x, mpfr_r
+ 
+           MPFR_SAVE_EXPO_MARK (expo);
+ 
+-          /* First round x to the target _Float128 precision, taking the
++          /* First round x to the target binary128 precision, taking the
+              reduced precision of the subnormals into account, so that all
+              subsequent operations are exact (this avoids double rounding
+              problems). */
+@@ -83,7 +86,7 @@ mpfr_get_float128 (mpfr_srcptr x, mpfr_r
+                  always work if GMP_NUMB_BITS > IEEE_FLOAT128_MANT_DIG.
+                  MPFR_LIMB_HIGHBIT has the advantage to fit on 1 bit. */
+               r += yp[i];
+-              r *= 1 / (2 * (_Float128) MPFR_LIMB_HIGHBIT);
++              r *= 1 / (2 * (mpfr_float128) MPFR_LIMB_HIGHBIT);
+             }
+ 
+           mpfr_clear (y);
+--- a/src/mpfr.h
++++ b/src/mpfr.h
+@@ -476,8 +476,14 @@ __MPFR_DECLSPEC int mpfr_set_decimal128
+ #endif
+ __MPFR_DECLSPEC int mpfr_set_ld (mpfr_ptr, long double, mpfr_rnd_t);
+ #ifdef MPFR_WANT_FLOAT128
+-__MPFR_DECLSPEC int mpfr_set_float128 (mpfr_ptr, _Float128, mpfr_rnd_t);
+-__MPFR_DECLSPEC _Float128 mpfr_get_float128 (mpfr_srcptr, mpfr_rnd_t);
++/* The user is free to define mpfr_float128 as another equivalent type,
++   such as __float128 if this one is supported by the current compiler
++   but _Float128 isn't. */
++# ifndef mpfr_float128
++#  define mpfr_float128 _Float128
++# endif
++__MPFR_DECLSPEC int mpfr_set_float128 (mpfr_ptr, mpfr_float128, mpfr_rnd_t);
++__MPFR_DECLSPEC mpfr_float128 mpfr_get_float128 (mpfr_srcptr, mpfr_rnd_t);
+ #endif
+ __MPFR_DECLSPEC int mpfr_set_z (mpfr_ptr, mpz_srcptr, mpfr_rnd_t);
+ __MPFR_DECLSPEC int mpfr_set_z_2exp (mpfr_ptr, mpz_srcptr, mpfr_exp_t,
+--- a/src/set_float128.c
++++ b/src/set_float128.c
+@@ -1,4 +1,4 @@
+-/* mpfr_set_float128 -- convert a machine _Float128 number to
++/* mpfr_set_float128 -- convert a binary128 (a.k.a. float128) number to
+                         a multiple precision floating-point number
+ 
+ Copyright 2012-2023 Free Software Foundation, Inc.
+@@ -26,8 +26,11 @@ https://www.gnu.org/licenses/ or write t
+ 
+ #ifdef MPFR_WANT_FLOAT128
+ 
++/* Note: mpfr_get_float128 is a macro defined as the actual binary128 type:
++   either _Float128 or __float128. */
++
+ #if MPFR_WANT_FLOAT128 == 1
+-/* _Float128 type from ISO/IEC TS 18661 */
++/* _Float128 type from ISO C23 */
+ # define MPFR_FLOAT128_MAX 0x1.ffffffffffffffffffffffffffffp+16383f128
+ #elif MPFR_WANT_FLOAT128 == 2
+ /* __float128 type (GNU C extension) */
+@@ -37,12 +40,12 @@ https://www.gnu.org/licenses/ or write t
+ #endif
+ 
+ int
+-mpfr_set_float128 (mpfr_ptr r, _Float128 d, mpfr_rnd_t rnd_mode)
++mpfr_set_float128 (mpfr_ptr r, mpfr_float128 d, mpfr_rnd_t rnd_mode)
+ {
+   mpfr_t t;
+   mp_limb_t *tp;
+   int inexact, shift_exp, neg, e, i;
+-  _Float128 p[14], q[14];
++  mpfr_float128 p[14], q[14];
+   MPFR_SAVE_EXPO_DECL (expo);
+ 
+   /* Check for NaN */
+@@ -66,7 +69,7 @@ mpfr_set_float128 (mpfr_ptr r, _Float128
+       return 0;
+     }
+   /* Check for ZERO */
+-  else if (MPFR_UNLIKELY (d == (_Float128) 0.0))
++  else if (MPFR_UNLIKELY (d == (mpfr_float128) 0.0))
+     return mpfr_set_d (r, (double) d, rnd_mode);
+ 
+   shift_exp = 0; /* invariant: remainder to deal with is d*2^shift_exp */
+@@ -129,7 +132,7 @@ mpfr_set_float128 (mpfr_ptr r, _Float128
+ 
+   for (i = MPFR_LAST_LIMB (t); i >= 0; i--)
+     {
+-      d *= 2 * (_Float128) MPFR_LIMB_HIGHBIT;
++      d *= 2 * (mpfr_float128) MPFR_LIMB_HIGHBIT;
+       tp[i] = (mp_limb_t) d;
+       d -= tp[i];
+     }
+--- a/tests/tset_float128.c
++++ b/tests/tset_float128.c
+@@ -33,7 +33,7 @@ https://www.gnu.org/licenses/ or write t
+ static void
+ check_special (void)
+ {
+-  _Float128 f;
++  mpfr_float128 f;
+   mpfr_t x;
+ 
+   mpfr_init2 (x, 113);
+@@ -162,7 +162,7 @@ static void
+ check_large (void)
+ {
+   mpfr_exp_t emin, emax;
+-  _Float128 f, e;
++  mpfr_float128 f, e;
+   int i;
+   mpfr_t x, y;
+   int r;
+@@ -177,7 +177,7 @@ check_large (void)
+   /* check with the largest float128 number 2^16384*(1-2^(-113)) */
+   for (f = 1.0, i = 0; i < 113; i++)
+     f = f + f;
+-  f = f - (_Float128) 1.0;
++  f = f - (mpfr_float128) 1.0;
+   mpfr_set_ui (y, 1, MPFR_RNDN);
+   mpfr_mul_2ui (y, y, 113, MPFR_RNDN);
+   mpfr_sub_ui (y, y, 1, MPFR_RNDN);
+@@ -258,7 +258,7 @@ check_small (void)
+ {
+   int t[5] = { 1, 2, 17, 111, 112 };
+   mpfr_exp_t emin;
+-  _Float128 e, f;
++  mpfr_float128 e, f;
+   int i, j, neg, inex, r;
+   mpfr_t w, x, y, z;
+ 
+--- a/tests/tversion.c
++++ b/tests/tversion.c
+@@ -309,10 +309,16 @@ main (void)
+       err = 1;
+     }
+ 
++#ifdef MPFR_WANT_FLOAT128
++# define MPFR_F128 "yes (" MAKE_STR(mpfr_float128) ")"
++#else
++# define MPFR_F128 "no"
++#endif
++
+   (printf) ("[tversion] TLS = %s, float128 = %s, decimal = %s,"
+             " GMP internals = %s\n",
+             mpfr_buildopt_tls_p () ? "yes" : "no",
+-            mpfr_buildopt_float128_p () ? "yes" : "no",
++            MPFR_F128,
+             mpfr_buildopt_decimal_p () ? "yes"
+ #if defined(DECIMAL_BID_FORMAT)
+             " (BID)"