Date: Saturday, May 13, 2023 @ 08:16:21
Author: arojas
Revision: 477663
archrelease: copy trunk to testing-x86_64
Added:
mpfr/repos/testing-x86_64/
mpfr/repos/testing-x86_64/PKGBUILD
(from rev 477662, mpfr/trunk/PKGBUILD)
mpfr/repos/testing-x86_64/keys/
mpfr/repos/testing-x86_64/patches.diff
(from rev 477662, mpfr/trunk/patches.diff)
--------------+
PKGBUILD | 56 ++
patches.diff | 1305 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 1361 insertions(+)
Copied: mpfr/repos/testing-x86_64/PKGBUILD (from rev 477662,
mpfr/trunk/PKGBUILD)
===================================================================
--- testing-x86_64/PKGBUILD (rev 0)
+++ testing-x86_64/PKGBUILD 2023-05-13 08:16:21 UTC (rev 477663)
@@ -0,0 +1,56 @@
+# Maintainer: David Runge <[email protected]>
+# Maintainer: Antonio Rojas <[email protected]>
+# Contributor: Allan McRae <[email protected]>
+# Contributor: damir <[email protected]>
+
+pkgname=mpfr
+_pkgver=4.2.0
+_patchver=7
+pkgrel=1
+pkgver=${_pkgver}.p${_patchver}
+#pkgver=$_pkgver
+pkgdesc='Multiple-precision floating-point library'
+arch=(x86_64)
+url='https://www.mpfr.org/'
+license=(GPL3 LGPL3)
+depends=(glibc gmp)
+source=(https://ftp.gnu.org/gnu/mpfr/mpfr-${_pkgver}.tar.xz{,.sig}
+
tsprintf.patch::https://gitlab.inria.fr/mpfr/mpfr/-/commit/5172494c09718ffcb7ef1f19b3b211e3bce8781a.patch
+ patches.diff) # wget https://www.mpfr.org/mpfr-${_pkgver}/allpatches
-O patches.diff
+sha512sums=('58e843125884ca58837ae5159cd4092af09e8f21931a2efd19c15de057c9d1dc0753ae95c592e2ce59a727fbc491af776db8b00a055320413cdcf2033b90505c'
+ 'SKIP'
+
'6d68ee5d286997c9a0bb66bf8da71a8af39e375091b743f1858dea9054b0f4f725ea0bcc37d39ac87b8a95ae508204c61413f4b2cb741807558952ee1a5d81e9'
+
'12cb553946b372da762b919a523a0dbb5c7b9f7931fd018013fb8e2a51b43d6ef421dda9c5ff6d89d7f75376d67f33205e7bcc3c69ef1aeaad5b3539218ec349')
+b2sums=('dd88ae3a6a910ad8faeb791b49c3b1085de5d0d4c49c637c124bf4d9bc79fb621d0d1d69e07d0642b9b678f6d355a5830d083dfd189e1e91d0e04c970c10bd64'
+ 'SKIP'
+
'16222c0f409d757b6cad515d13a1673be26302f48bc206f8526cb46a2d357404b181811da6180326be136a265d63b8e47b81107b01f4c8abc4637fd9d5fca4ea'
+
'bbe00cff15d382663db623e1ef834e44192df1ad22c436d5b870fcf8bf438bd618d8ae332fe7ac4c0fd1d638e0764ab84a81954b91d54e0337ccad3568a3a83b')
+validpgpkeys=('07F3DBBECC1A39605078094D980C197698C3739D'
+ 'A534BE3F83E241D918280AEB5831D11A0D4DB02A') # Vincent Lefevre
<[email protected]>
+
+prepare() {
+ cd $pkgname-${_pkgver}
+
+ patch -Np1 < ../tsprintf.patch
+ # sed -i '/check_vsprintf ("+1,234,567/d' tests/tsprintf.c
+ autoreconf -fiv
+}
+
+build() {
+ cd $pkgname-${_pkgver}
+ ./configure --prefix=/usr \
+ --enable-thread-safe \
+ --enable-shared
+ make
+}
+
+check() {
+ cd $pkgname-${_pkgver}
+ make check
+ make check-exported-symbols
+}
+
+package() {
+ cd $pkgname-${_pkgver}
+ make DESTDIR="$pkgdir" install
+}
Copied: mpfr/repos/testing-x86_64/patches.diff (from rev 477662,
mpfr/trunk/patches.diff)
===================================================================
--- testing-x86_64/patches.diff (rev 0)
+++ testing-x86_64/patches.diff 2023-05-13 08:16:21 UTC (rev 477663)
@@ -0,0 +1,1305 @@
+diff -Naurd mpfr-4.2.0-a/PATCHES mpfr-4.2.0-b/PATCHES
+--- mpfr-4.2.0-a/PATCHES 2023-04-17 21:17:39.748645280 +0000
++++ mpfr-4.2.0-b/PATCHES 2023-04-17 21:17:39.792645218 +0000
+@@ -0,0 +1 @@
++tsprintf-thousands
+diff -Naurd mpfr-4.2.0-a/VERSION mpfr-4.2.0-b/VERSION
+--- mpfr-4.2.0-a/VERSION 2023-01-06 10:55:57.000000000 +0000
++++ mpfr-4.2.0-b/VERSION 2023-04-17 21:17:39.792645218 +0000
+@@ -1 +1 @@
+-4.2.0
++4.2.0-p1
+diff -Naurd mpfr-4.2.0-a/src/mpfr.h mpfr-4.2.0-b/src/mpfr.h
+--- mpfr-4.2.0-a/src/mpfr.h 2023-01-06 10:55:57.000000000 +0000
++++ mpfr-4.2.0-b/src/mpfr.h 2023-04-17 21:17:39.788645224 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 4
+ #define MPFR_VERSION_MINOR 2
+ #define MPFR_VERSION_PATCHLEVEL 0
+-#define MPFR_VERSION_STRING "4.2.0"
++#define MPFR_VERSION_STRING "4.2.0-p1"
+
+ /* User macros:
+ MPFR_USE_FILE: Define it to make MPFR define functions dealing
+diff -Naurd mpfr-4.2.0-a/src/version.c mpfr-4.2.0-b/src/version.c
+--- mpfr-4.2.0-a/src/version.c 2023-01-06 10:55:57.000000000 +0000
++++ mpfr-4.2.0-b/src/version.c 2023-04-17 21:17:39.792645218 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+- return "4.2.0";
++ return "4.2.0-p1";
+ }
+diff -Naurd mpfr-4.2.0-a/tests/tsprintf.c mpfr-4.2.0-b/tests/tsprintf.c
+--- mpfr-4.2.0-a/tests/tsprintf.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/tests/tsprintf.c 2023-04-17 21:17:39.784645229 +0000
+@@ -1715,7 +1715,25 @@
+ check_sprintf ("000000001,000", "%'013.4Rg", x);
+
+ #ifdef PRINTF_GROUPFLAG
+- check_vsprintf ("+01,234,567 :", "%0+ -'13.10Pd:", (mpfr_prec_t) 1234567);
++ /* Do not test the thousands separator with a precision field larger
++ than the number of digits (thus needing leading zeros), such as
++ "%0+ -'13.10Pd:" (used up to MPFR 4.2.0), since the GNU libc is
++ buggy: https://sourceware.org/bugzilla/show_bug.cgi?id=23432
++ We don't know about the other implementations.
++ This new test works fine with glibc up to 2.36, but fails with 2.37
++ (as reported by Klaus Dittrich in the MPFR mailing-list); this is
++ actually a bug introduced in glibc 2.37, not in MPFR:
++ https://sourceware.org/bugzilla/show_bug.cgi?id=30068
++ Since this bug can yield a buffer overflow (CVE-2023-25139), possibly
++ affecting MPFR users, let us rather require a fix in glibc. This bug
++ has been fixed in the 2.37 branch:
++ https://sourceware.org/git/?p=glibc.git;a=commit;h=07b9521fc6
++ If we wanted to check that and avoid a failure of the test because of
++ a buggy C library (while MPFR would be consistent with the C library),
++ we could compare the MPFR output with both the correct output and the
++ output from the C library (possibly buggy). But to do that in a clean
++ way, this would require a change in the check_vsprintf() call. */
++ check_vsprintf ("+1,234,567 :", "%0+ -'13Pd:", (mpfr_prec_t) 1234567);
+ #endif
+
+ mpfr_clear (x);
+diff -Naurd mpfr-4.2.0-a/PATCHES mpfr-4.2.0-b/PATCHES
+--- mpfr-4.2.0-a/PATCHES 2023-04-17 21:18:00.464616127 +0000
++++ mpfr-4.2.0-b/PATCHES 2023-04-17 21:18:00.512616059 +0000
+@@ -0,0 +1 @@
++ui_pow_ui-overflow
+diff -Naurd mpfr-4.2.0-a/VERSION mpfr-4.2.0-b/VERSION
+--- mpfr-4.2.0-a/VERSION 2023-04-17 21:17:39.792645218 +0000
++++ mpfr-4.2.0-b/VERSION 2023-04-17 21:18:00.512616059 +0000
+@@ -1 +1 @@
+-4.2.0-p1
++4.2.0-p2
+diff -Naurd mpfr-4.2.0-a/src/mpfr.h mpfr-4.2.0-b/src/mpfr.h
+--- mpfr-4.2.0-a/src/mpfr.h 2023-04-17 21:17:39.788645224 +0000
++++ mpfr-4.2.0-b/src/mpfr.h 2023-04-17 21:18:00.508616065 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 4
+ #define MPFR_VERSION_MINOR 2
+ #define MPFR_VERSION_PATCHLEVEL 0
+-#define MPFR_VERSION_STRING "4.2.0-p1"
++#define MPFR_VERSION_STRING "4.2.0-p2"
+
+ /* User macros:
+ MPFR_USE_FILE: Define it to make MPFR define functions dealing
+diff -Naurd mpfr-4.2.0-a/src/ui_pow_ui.c mpfr-4.2.0-b/src/ui_pow_ui.c
+--- mpfr-4.2.0-a/src/ui_pow_ui.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/src/ui_pow_ui.c 2023-04-17 21:18:00.504616070 +0000
+@@ -23,7 +23,7 @@
+ #include "mpfr-impl.h"
+
+ int
+-mpfr_ui_pow_ui (mpfr_ptr x, unsigned long int y, unsigned long int n,
++mpfr_ui_pow_ui (mpfr_ptr x, unsigned long int k, unsigned long int n,
+ mpfr_rnd_t rnd)
+ {
+ mpfr_exp_t err;
+@@ -35,22 +35,28 @@
+ MPFR_ZIV_DECL (loop);
+ MPFR_SAVE_EXPO_DECL (expo);
+
++ MPFR_LOG_FUNC
++ (("k=%lu n=%lu rnd=%d", k, n, rnd),
++ ("y[%Pu]=%.*Rg inexact=%d",
++ mpfr_get_prec (x), mpfr_log_prec, x, inexact));
++
+ if (MPFR_UNLIKELY (n <= 1))
+ {
+ if (n == 1)
+- return mpfr_set_ui (x, y, rnd); /* y^1 = y */
++ return mpfr_set_ui (x, k, rnd); /* k^1 = k */
+ else
+- return mpfr_set_ui (x, 1, rnd); /* y^0 = 1 for any y */
++ return mpfr_set_ui (x, 1, rnd); /* k^0 = 1 for any k */
+ }
+- else if (MPFR_UNLIKELY (y <= 1))
++ else if (MPFR_UNLIKELY (k <= 1))
+ {
+- if (y == 1)
++ if (k == 1)
+ return mpfr_set_ui (x, 1, rnd); /* 1^n = 1 for any n > 0 */
+ else
+ return mpfr_set_ui (x, 0, rnd); /* 0^n = 0 for any n > 0 */
+ }
+
+- for (size_n = 0, m = n; m; size_n++, m >>= 1);
++ for (size_n = 0, m = n; m != 0; size_n++, m >>= 1)
++ ;
+
+ MPFR_SAVE_EXPO_MARK (expo);
+ prec = MPFR_PREC (x) + 3 + size_n;
+@@ -60,23 +66,55 @@
+ for (;;)
+ {
+ int i = size_n;
++ unsigned int inex_res;
+
+- inexact = mpfr_set_ui (res, y, MPFR_RNDU);
++ inex_res = mpfr_set_ui (res, k, MPFR_RNDU);
+ err = 1;
+ /* now 2^(i-1) <= n < 2^i: i=1+floor(log2(n)) */
+ for (i -= 2; i >= 0; i--)
+ {
+- inexact |= mpfr_sqr (res, res, MPFR_RNDU);
++ inex_res |= mpfr_sqr (res, res, MPFR_RNDU);
+ err++;
+ if (n & (1UL << i))
+- inexact |= mpfr_mul_ui (res, res, y, MPFR_RNDU);
++ inex_res |= mpfr_mul_ui (res, res, k, MPFR_RNDU);
+ }
++
++ if (MPFR_UNLIKELY (MPFR_IS_INF (res)))
++ {
++ mpfr_t kf;
++ mpz_t z;
++ int size_k;
++ MPFR_BLOCK_DECL (flags);
++
++ /* Let's handle the overflow by calling mpfr_pow_z.
++ Alternatively, we could call mpfr_pow_ui; this would
++ need a bit shorter code below, but mpfr_pow_ui handles
++ the overflow by calling mpfr_pow_z, so that calling
++ mpfr_pow_z directly should be a bit more efficient. */
++
++ MPFR_ZIV_FREE (loop);
++ mpfr_clear (res);
++ for (size_k = 0, m = k; m != 0; size_k++, m >>= 1)
++ ;
++ mpfr_init2 (kf, size_k);
++ inexact = mpfr_set_ui (kf, k, MPFR_RNDN);
++ MPFR_ASSERTD (inexact == 0);
++ mpz_init (z);
++ mpz_set_ui (z, n);
++ MPFR_BLOCK (flags, inexact = mpfr_pow_z (x, kf, z, rnd););
++ mpz_clear (z);
++ mpfr_clear (kf);
++ MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, flags);
++ goto end;
++ }
++
+ /* since the loop is executed floor(log2(n)) times,
+ we have err = 1+floor(log2(n)).
+ Since prec >= MPFR_PREC(x) + 4 + floor(log2(n)), prec > err */
+ err = prec - err;
+
+- if (MPFR_LIKELY (inexact == 0
++ MPFR_LOG_VAR (res);
++ if (MPFR_LIKELY (!inex_res
+ || MPFR_CAN_ROUND (res, err, MPFR_PREC (x), rnd)))
+ break;
+
+@@ -90,6 +128,7 @@
+
+ mpfr_clear (res);
+
++ end:
+ MPFR_SAVE_EXPO_FREE (expo);
+ return mpfr_check_range (x, inexact, rnd);
+ }
+diff -Naurd mpfr-4.2.0-a/src/version.c mpfr-4.2.0-b/src/version.c
+--- mpfr-4.2.0-a/src/version.c 2023-04-17 21:17:39.792645218 +0000
++++ mpfr-4.2.0-b/src/version.c 2023-04-17 21:18:00.512616059 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+- return "4.2.0-p1";
++ return "4.2.0-p2";
+ }
+diff -Naurd mpfr-4.2.0-a/tests/tlog10.c mpfr-4.2.0-b/tests/tlog10.c
+--- mpfr-4.2.0-a/tests/tlog10.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/tests/tlog10.c 2023-04-17 21:18:00.504616070 +0000
+@@ -49,6 +49,60 @@
+ #define TEST_RANDOM_POS 8
+ #include "tgeneric.c"
+
++/* On 2023-02-13, one gets an infinite loop in mpfr_log10 on both
++ 32-bit and 64-bit hosts when the precision is not large enough
++ (precision 12 and below). */
++static void
++bug20230213 (void)
++{
++ mpfr_exp_t old_emin, old_emax, e;
++ mpfr_t t, x, y0, y1, y2;
++ int prec;
++
++ old_emin = mpfr_get_emin ();
++ old_emax = mpfr_get_emax ();
++
++ set_emin (MPFR_EMIN_MIN);
++ set_emax (MPFR_EMAX_MAX);
++ e = mpfr_get_emax () - 1;
++
++ /* The precisions of t and y0 should be large enough to avoid
++ a hard-to-round case for the target precisions. */
++ mpfr_inits2 (64, t, y0, (mpfr_ptr) 0);
++ mpfr_set_exp_t (y0, e, MPFR_RNDN);
++ mpfr_log_ui (t, 10, MPFR_RNDN);
++ mpfr_div (y0, y0, t, MPFR_RNDN);
++ mpfr_log_ui (t, 2, MPFR_RNDN);
++ mpfr_mul (y0, y0, t, MPFR_RNDN);
++
++ for (prec = 16; prec >= MPFR_PREC_MIN; prec--)
++ {
++ mpfr_inits2 (prec, x, y1, y2, (mpfr_ptr) 0);
++ mpfr_set (y1, y0, MPFR_RNDN);
++
++ mpfr_set_ui_2exp (x, 1, e, MPFR_RNDN);
++ mpfr_log10 (y2, x, MPFR_RNDN);
++ MPFR_ASSERTN (MPFR_IS_PURE_FP (y2));
++ MPFR_ASSERTN (MPFR_IS_POS (y2));
++
++ if (! mpfr_equal_p (y1, y2))
++ {
++ printf ("Error in bug20230213.\n");
++ printf ("Expected ");
++ mpfr_dump (y1);
++ printf ("Got ");
++ mpfr_dump (y2);
++ exit (1);
++ }
++ mpfr_clears (x, y1, y2, (mpfr_ptr) 0);
++ }
++
++ mpfr_clears (t, y0, (mpfr_ptr) 0);
++
++ set_emin (old_emin);
++ set_emax (old_emax);
++}
++
+ int
+ main (int argc, char *argv[])
+ {
+@@ -112,6 +166,8 @@
+ mpfr_clear (x);
+ mpfr_clear (y);
+
++ bug20230213 ();
++
+ data_check ("data/log10", mpfr_log10, "mpfr_log10");
+
+ tests_end_mpfr ();
+diff -Naurd mpfr-4.2.0-a/tests/tui_pow.c mpfr-4.2.0-b/tests/tui_pow.c
+--- mpfr-4.2.0-a/tests/tui_pow.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/tests/tui_pow.c 2023-04-17 21:18:00.504616070 +0000
+@@ -142,6 +142,37 @@
+ mpfr_clear (t);
+ }
+
++static void
++huge (void)
++{
++ mpfr_exp_t old_emin, old_emax;
++ mpfr_t x;
++
++ old_emin = mpfr_get_emin ();
++ old_emax = mpfr_get_emax ();
++
++ set_emin (MPFR_EMIN_MIN);
++ set_emax (MPFR_EMAX_MAX);
++
++ mpfr_init2 (x, 8);
++
++ /* The purpose of this test is more to check that mpfr_ui_pow_ui
++ terminates (without taking much memory) rather than checking
++ the value of x. On 2023-02-13, the +Inf case was not handled
++ in the Ziv iteration, yielding an infinite loop, affecting
++ mpfr_log10 in particular. See
++ commit 90de094f0d9c309daca707aa227470d810866616
++ */
++ mpfr_ui_pow_ui (x, 5, ULONG_MAX, MPFR_RNDN);
++ if (MPFR_EMAX_MAX <= ULONG_MAX) /* true with default _MPFR_EXP_FORMAT */
++ MPFR_ASSERTN (MPFR_IS_INF (x));
++
++ mpfr_clear (x);
++
++ set_emin (old_emin);
++ set_emax (old_emax);
++}
++
+ int
+ main (int argc, char *argv[])
+ {
+@@ -180,6 +211,7 @@
+ }
+
+ test1 ();
++ huge ();
+
+ {
+ mpfr_t z, t;
+diff -Naurd mpfr-4.2.0-a/PATCHES mpfr-4.2.0-b/PATCHES
+--- mpfr-4.2.0-a/PATCHES 2023-04-17 21:18:26.860579184 +0000
++++ mpfr-4.2.0-b/PATCHES 2023-04-17 21:18:26.904579122 +0000
+@@ -0,0 +1 @@
++multibyte-decimal_point
+diff -Naurd mpfr-4.2.0-a/VERSION mpfr-4.2.0-b/VERSION
+--- mpfr-4.2.0-a/VERSION 2023-04-17 21:18:00.512616059 +0000
++++ mpfr-4.2.0-b/VERSION 2023-04-17 21:18:26.904579122 +0000
+@@ -1 +1 @@
+-4.2.0-p2
++4.2.0-p3
+diff -Naurd mpfr-4.2.0-a/src/mpfr.h mpfr-4.2.0-b/src/mpfr.h
+--- mpfr-4.2.0-a/src/mpfr.h 2023-04-17 21:18:00.508616065 +0000
++++ mpfr-4.2.0-b/src/mpfr.h 2023-04-17 21:18:26.900579128 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 4
+ #define MPFR_VERSION_MINOR 2
+ #define MPFR_VERSION_PATCHLEVEL 0
+-#define MPFR_VERSION_STRING "4.2.0-p2"
++#define MPFR_VERSION_STRING "4.2.0-p3"
+
+ /* User macros:
+ MPFR_USE_FILE: Define it to make MPFR define functions dealing
+diff -Naurd mpfr-4.2.0-a/src/version.c mpfr-4.2.0-b/src/version.c
+--- mpfr-4.2.0-a/src/version.c 2023-04-17 21:18:00.512616059 +0000
++++ mpfr-4.2.0-b/src/version.c 2023-04-17 21:18:26.904579122 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+- return "4.2.0-p2";
++ return "4.2.0-p3";
+ }
+diff -Naurd mpfr-4.2.0-a/tests/tfprintf.c mpfr-4.2.0-b/tests/tfprintf.c
+--- mpfr-4.2.0-a/tests/tfprintf.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/tests/tfprintf.c 2023-04-17 21:18:26.896579133 +0000
+@@ -61,6 +61,12 @@
+ exit (1); \
+ }
+
++#if MPFR_LCONV_DPTS
++#define DPLEN ((int) strlen (localeconv()->decimal_point))
++#else
++#define DPLEN 1
++#endif
++
+ /* limit for random precision in random() */
+ const int prec_max_printf = 5000;
+
+@@ -195,12 +201,12 @@
+ lo, &ulo);
+ check_length (2, ulo, 36, lu);
+ check_vfprintf (fout, "a. %hi, b. %*f, c. %Re%hn", ush, 3, f, mpfr, &ush);
+- check_length (3, ush, 46, hu);
++ check_length (3, ush, 45 + DPLEN, hu);
+ check_vfprintf (fout, "a. %hi, b. %f, c. %#.2Rf%n", sh, d, mpfr, &i);
+- check_length (4, i, 29, d);
++ check_length (4, i, 28 + DPLEN, d);
+ check_vfprintf (fout, "a. %R*A, b. %Fe, c. %i%zn", rnd, mpfr, mpf, sz,
+ &sz);
+- check_length (5, (unsigned long) sz, 34, lu); /* no format specifier "%zu"
in C90 */
++ check_length (5, (unsigned long) sz, 33 + DPLEN, lu); /* no format
specifier "%zu" in C90 */
+ check_vfprintf (fout, "a. %Pu, b. %c, c. %Zi%Zn", prec, ch, mpz, &mpz);
+ check_length_with_cmp (6, mpz, 17, mpz_cmp_ui (mpz, 17), Zi);
+ check_vfprintf (fout, "%% a. %#.0RNg, b. %Qx%Rn, c. %p", mpfr, mpq, &mpfr,
+@@ -224,7 +230,7 @@
+
+ #ifdef PRINTF_L
+ check_vfprintf (fout, "a. %RA, b. %Lf, c. %QX%zn", mpfr, ld, mpq, &sz);
+- check_length (9, (unsigned long) sz, 30, lu); /* no format specifier "%zu"
in C90 */
++ check_length (9, (unsigned long) sz, 29 + DPLEN, lu); /* no format
specifier "%zu" in C90 */
+ #endif
+
+ #ifndef NPRINTF_HH
+diff -Naurd mpfr-4.2.0-a/tests/tprintf.c mpfr-4.2.0-b/tests/tprintf.c
+--- mpfr-4.2.0-a/tests/tprintf.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/tests/tprintf.c 2023-04-17 21:18:26.896579133 +0000
+@@ -68,6 +68,12 @@
+ exit (1); \
+ }
+
++#if MPFR_LCONV_DPTS
++#define DPLEN ((int) strlen (localeconv()->decimal_point))
++#else
++#define DPLEN 1
++#endif
++
+ /* limit for random precision in random() */
+ const int prec_max_printf = 5000;
+ /* boolean: is stdout redirected to a file ? */
+@@ -316,11 +322,11 @@
+ check_vprintf ("a. %c, b. %Rb, c. %u, d. %li%ln", i, mpfr, i, lo, &ulo);
+ check_length (2, ulo, 36, lu);
+ check_vprintf ("a. %hi, b. %*f, c. %Re%hn", ush, 3, f, mpfr, &ush);
+- check_length (3, ush, 46, hu);
++ check_length (3, ush, 45 + DPLEN, hu);
+ check_vprintf ("a. %hi, b. %f, c. %#.2Rf%n", sh, d, mpfr, &i);
+- check_length (4, i, 29, d);
++ check_length (4, i, 28 + DPLEN, d);
+ check_vprintf ("a. %R*A, b. %Fe, c. %i%zn", rnd, mpfr, mpf, sz, &sz);
+- check_length (5, (unsigned long) sz, 34, lu); /* no format specifier '%zu'
in C90 */
++ check_length (5, (unsigned long) sz, 33 + DPLEN, lu); /* no format
specifier '%zu' in C90 */
+ check_vprintf ("a. %Pu, b. %c, c. %RUG, d. %Zi%Zn", prec, ch, mpfr, mpz,
&mpz);
+ check_length_with_cmp (6, mpz, 24, mpz_cmp_ui (mpz, 24), Zi);
+ check_vprintf ("%% a. %#.0RNg, b. %Qx%Rn c. %p",
+@@ -344,7 +350,7 @@
+
+ #ifdef PRINTF_L
+ check_vprintf ("a. %RA, b. %Lf, c. %QX%zn", mpfr, ld, mpq, &sz);
+- check_length (9, (unsigned long) sz, 30, lu); /* no format specifier '%zu'
in C90 */
++ check_length (9, (unsigned long) sz, 29 + DPLEN, lu); /* no format
specifier '%zu' in C90 */
+ #endif
+
+ #ifndef NPRINTF_HH
+diff -Naurd mpfr-4.2.0-a/PATCHES mpfr-4.2.0-b/PATCHES
+--- mpfr-4.2.0-a/PATCHES 2023-04-17 21:19:01.988530337 +0000
++++ mpfr-4.2.0-b/PATCHES 2023-04-17 21:19:02.032530276 +0000
+@@ -0,0 +1 @@
++rec_sqrt-zivloop
+diff -Naurd mpfr-4.2.0-a/VERSION mpfr-4.2.0-b/VERSION
+--- mpfr-4.2.0-a/VERSION 2023-04-17 21:18:26.904579122 +0000
++++ mpfr-4.2.0-b/VERSION 2023-04-17 21:19:02.032530276 +0000
+@@ -1 +1 @@
+-4.2.0-p3
++4.2.0-p4
+diff -Naurd mpfr-4.2.0-a/src/mpfr.h mpfr-4.2.0-b/src/mpfr.h
+--- mpfr-4.2.0-a/src/mpfr.h 2023-04-17 21:18:26.900579128 +0000
++++ mpfr-4.2.0-b/src/mpfr.h 2023-04-17 21:19:02.032530276 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 4
+ #define MPFR_VERSION_MINOR 2
+ #define MPFR_VERSION_PATCHLEVEL 0
+-#define MPFR_VERSION_STRING "4.2.0-p3"
++#define MPFR_VERSION_STRING "4.2.0-p4"
+
+ /* User macros:
+ MPFR_USE_FILE: Define it to make MPFR define functions dealing
+diff -Naurd mpfr-4.2.0-a/src/rec_sqrt.c mpfr-4.2.0-b/src/rec_sqrt.c
+--- mpfr-4.2.0-a/src/rec_sqrt.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/src/rec_sqrt.c 2023-04-17 21:19:02.024530287 +0000
+@@ -463,6 +463,7 @@
+ int s, cy, inex;
+ mpfr_limb_ptr x;
+ MPFR_TMP_DECL(marker);
++ MPFR_ZIV_DECL (loop);
+
+ MPFR_LOG_FUNC
+ (("x[%Pu]=%.*Rg rnd=%d", mpfr_get_prec (u), mpfr_log_prec, u, rnd_mode),
+@@ -530,6 +531,7 @@
+ wp = rp + 11;
+ if (wp < rn * GMP_NUMB_BITS)
+ wp = rn * GMP_NUMB_BITS;
++ MPFR_ZIV_INIT (loop, wp);
+ for (;;)
+ {
+ MPFR_TMP_MARK (marker);
+@@ -561,8 +563,9 @@
+ }
+ MPFR_TMP_FREE(marker);
+
+- wp += GMP_NUMB_BITS;
++ MPFR_ZIV_NEXT (loop, wp);
+ }
++ MPFR_ZIV_FREE (loop);
+ cy = mpfr_round_raw (MPFR_MANT(r), x, wp, 0, rp, rnd_mode, &inex);
+ MPFR_EXP(r) = - (MPFR_EXP(u) - 1 - s) / 2;
+ if (MPFR_UNLIKELY(cy != 0))
+diff -Naurd mpfr-4.2.0-a/src/version.c mpfr-4.2.0-b/src/version.c
+--- mpfr-4.2.0-a/src/version.c 2023-04-17 21:18:26.904579122 +0000
++++ mpfr-4.2.0-b/src/version.c 2023-04-17 21:19:02.032530276 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+- return "4.2.0-p3";
++ return "4.2.0-p4";
+ }
+diff -Naurd mpfr-4.2.0-a/tests/trec_sqrt.c mpfr-4.2.0-b/tests/trec_sqrt.c
+--- mpfr-4.2.0-a/tests/trec_sqrt.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/tests/trec_sqrt.c 2023-04-17 21:19:02.028530282 +0000
+@@ -242,6 +242,8 @@
+ data_check ("data/rec_sqrt", mpfr_rec_sqrt, "mpfr_rec_sqrt");
+ bad_cases (mpfr_rec_sqrt, pm2, "mpfr_rec_sqrt", 0, -256, 255, 4, 128,
+ 800, 50);
++ bad_cases (mpfr_rec_sqrt, pm2, "mpfr_rec_sqrt", 0, -256, 255, 9999, 9999,
++ 120000, 1);
+
+ end:
+ tests_end_mpfr ();
+diff -Naurd mpfr-4.2.0-a/PATCHES mpfr-4.2.0-b/PATCHES
+--- mpfr-4.2.0-a/PATCHES 2023-05-12 15:05:00.989811960 +0000
++++ mpfr-4.2.0-b/PATCHES 2023-05-12 15:05:01.085811835 +0000
+@@ -0,0 +1 @@
++reldiff
+diff -Naurd mpfr-4.2.0-a/VERSION mpfr-4.2.0-b/VERSION
+--- mpfr-4.2.0-a/VERSION 2023-04-17 21:19:02.032530276 +0000
++++ mpfr-4.2.0-b/VERSION 2023-05-12 15:05:01.085811835 +0000
+@@ -1 +1 @@
+-4.2.0-p4
++4.2.0-p5
+diff -Naurd mpfr-4.2.0-a/src/mpfr.h mpfr-4.2.0-b/src/mpfr.h
+--- mpfr-4.2.0-a/src/mpfr.h 2023-04-17 21:19:02.032530276 +0000
++++ mpfr-4.2.0-b/src/mpfr.h 2023-05-12 15:05:01.077811846 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 4
+ #define MPFR_VERSION_MINOR 2
+ #define MPFR_VERSION_PATCHLEVEL 0
+-#define MPFR_VERSION_STRING "4.2.0-p4"
++#define MPFR_VERSION_STRING "4.2.0-p5"
+
+ /* User macros:
+ MPFR_USE_FILE: Define it to make MPFR define functions dealing
+diff -Naurd mpfr-4.2.0-a/src/reldiff.c mpfr-4.2.0-b/src/reldiff.c
+--- mpfr-4.2.0-a/src/reldiff.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/src/reldiff.c 2023-05-12 15:05:01.069811856 +0000
+@@ -30,31 +30,25 @@
+
+ if (MPFR_ARE_SINGULAR (b, c))
+ {
+- if (MPFR_IS_NAN(b) || MPFR_IS_NAN(c))
+- {
+- MPFR_SET_NAN(a);
+- return;
+- }
+- else if (MPFR_IS_INF(b))
++ if (MPFR_IS_NAN (b) || MPFR_IS_INF (b) || MPFR_IS_NAN (c) ||
++ (MPFR_IS_ZERO (b) && MPFR_IS_ZERO (c)))
+ {
+- if (MPFR_IS_INF (c) && (MPFR_SIGN (c) == MPFR_SIGN (b)))
+- MPFR_SET_ZERO(a);
+- else
+- MPFR_SET_NAN(a);
++ MPFR_SET_NAN (a);
+ return;
+ }
+- else if (MPFR_IS_INF(c))
++ if (MPFR_IS_ZERO (b) || MPFR_IS_INF (c))
+ {
+ MPFR_SET_SAME_SIGN (a, b);
+ MPFR_SET_INF (a);
+ return;
+ }
+- else if (MPFR_IS_ZERO(b)) /* reldiff = abs(c)/c = sign(c) */
+- {
+- mpfr_set_si (a, MPFR_INT_SIGN (c), rnd_mode);
+- return;
+- }
+- /* Fall through */
++ /* The case c = 0 with b regular, which should give sign(b) exactly,
++ cannot be optimized here as it is documented in the MPFR manual
++ that this function just computes abs(b-c)/b using the precision
++ of a and the rounding mode rnd_mode for all operations. So let's
++ prefer the potentially "incorrect" result. Note that the correct
++ result is not necessarily better because if could break properties
++ (like monotonicity?) implied by the documentation. */
+ }
+
+ if (a == b)
+@@ -64,8 +58,8 @@
+ }
+
+ mpfr_sub (a, b, c, rnd_mode);
+- mpfr_abs (a, a, rnd_mode); /* for compatibility with MPF */
+- mpfr_div (a, a, (a == b) ? b_copy : b, rnd_mode);
++ MPFR_SET_SIGN (a, 1);
++ mpfr_div (a, a, a == b ? b_copy : b, rnd_mode);
+
+ if (a == b)
+ mpfr_clear (b_copy);
+diff -Naurd mpfr-4.2.0-a/src/version.c mpfr-4.2.0-b/src/version.c
+--- mpfr-4.2.0-a/src/version.c 2023-04-17 21:19:02.032530276 +0000
++++ mpfr-4.2.0-b/src/version.c 2023-05-12 15:05:01.081811839 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+- return "4.2.0-p4";
++ return "4.2.0-p5";
+ }
+diff -Naurd mpfr-4.2.0-a/PATCHES mpfr-4.2.0-b/PATCHES
+--- mpfr-4.2.0-a/PATCHES 2023-05-12 15:06:11.789722083 +0000
++++ mpfr-4.2.0-b/PATCHES 2023-05-12 15:06:11.885721962 +0000
+@@ -0,0 +1 @@
++tests-reuse
+diff -Naurd mpfr-4.2.0-a/VERSION mpfr-4.2.0-b/VERSION
+--- mpfr-4.2.0-a/VERSION 2023-05-12 15:05:01.085811835 +0000
++++ mpfr-4.2.0-b/VERSION 2023-05-12 15:06:11.885721962 +0000
+@@ -1 +1 @@
+-4.2.0-p5
++4.2.0-p6
+diff -Naurd mpfr-4.2.0-a/src/mpfr.h mpfr-4.2.0-b/src/mpfr.h
+--- mpfr-4.2.0-a/src/mpfr.h 2023-05-12 15:05:01.077811846 +0000
++++ mpfr-4.2.0-b/src/mpfr.h 2023-05-12 15:06:11.877721972 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 4
+ #define MPFR_VERSION_MINOR 2
+ #define MPFR_VERSION_PATCHLEVEL 0
+-#define MPFR_VERSION_STRING "4.2.0-p5"
++#define MPFR_VERSION_STRING "4.2.0-p6"
+
+ /* User macros:
+ MPFR_USE_FILE: Define it to make MPFR define functions dealing
+diff -Naurd mpfr-4.2.0-a/src/version.c mpfr-4.2.0-b/src/version.c
+--- mpfr-4.2.0-a/src/version.c 2023-05-12 15:05:01.081811839 +0000
++++ mpfr-4.2.0-b/src/version.c 2023-05-12 15:06:11.885721962 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+- return "4.2.0-p5";
++ return "4.2.0-p6";
+ }
+diff -Naurd mpfr-4.2.0-a/tests/reuse.c mpfr-4.2.0-b/tests/reuse.c
+--- mpfr-4.2.0-a/tests/reuse.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/tests/reuse.c 2023-05-12 15:06:11.869721983 +0000
+@@ -78,22 +78,16 @@
+ mpfr_const_pi (x, MPFR_RNDN);
+ MPFR_SET_EXP (x, MPFR_GET_EXP (x)-1);
+ break;
+- default:
++ case 11:
+ mpfr_urandomb (x, RANDS);
+ if (RAND_BOOL ())
+ mpfr_neg (x, x, MPFR_RNDN);
+ break;
++ default:
++ MPFR_ASSERTN (0);
+ }
+ }
+
+-/* same as mpfr_cmp, but returns 0 for both NaN's */
+-static int
+-mpfr_compare (mpfr_srcptr a, mpfr_srcptr b)
+-{
+- return (MPFR_IS_NAN(a)) ? !MPFR_IS_NAN(b) :
+- (MPFR_IS_NAN(b) || mpfr_cmp(a, b));
+-}
+-
+ static void
+ test3 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t),
+ const char *foo, mpfr_prec_t prec, mpfr_rnd_t rnd)
+@@ -112,10 +106,10 @@
+
+ /* for each variable, consider each of the following 6 possibilities:
+ NaN, +Infinity, -Infinity, +0, -0 or a random number */
+- for (i=0; i < SPECIAL_MAX*SPECIAL_MAX ; i++)
++ for (i = 0; i < SPECIAL_MAX * SPECIAL_MAX; i++)
+ {
+- set_special (ref2, i%SPECIAL_MAX);
+- set_special (ref3, i/SPECIAL_MAX);
++ set_special (ref2, i % SPECIAL_MAX);
++ set_special (ref3, i / SPECIAL_MAX);
+
+ /* reference call: foo(a, b, c) */
+ testfunc (ref1, ref2, ref3, rnd);
+@@ -124,11 +118,11 @@
+ mpfr_set (res1, ref2, rnd); /* exact operation */
+ testfunc (res1, res1, ref3, rnd);
+
+- if (mpfr_compare (res1, ref1))
++ if (! SAME_VAL (res1, ref1))
+ {
+ printf ("Error for %s(a, a, c) with %s for ", foo,
+ mpfr_print_rnd_mode (rnd));
+- DISP("a=",ref2); DISP2(", c=",ref3);
++ DISP("a=", ref2); DISP2(", c=", ref3);
+ printf ("expected "); mpfr_dump (ref1);
+ printf ("got "); mpfr_dump (res1);
+ exit (1);
+@@ -137,11 +131,12 @@
+ /* foo(a, b, a) */
+ mpfr_set (res1, ref3, rnd);
+ testfunc (res1, ref2, res1, rnd);
+- if (mpfr_compare (res1, ref1))
++ if (! SAME_VAL (res1, ref1))
+ {
+ printf ("Error for %s(a, b, a) for ", foo);
+- DISP("b=",ref2); DISP2(", a=", ref3);
+- DISP("expected ", ref1); DISP2(", got ",res1);
++ DISP("b=", ref2); DISP2(", a=", ref3);
++ printf ("expected "); mpfr_dump (ref1);
++ printf ("got "); mpfr_dump (res1);
+ exit (1);
+ }
+
+@@ -151,11 +146,12 @@
+ mpfr_set (res1, ref2, rnd);
+ testfunc (res1, res1, res1, rnd);
+
+- if (mpfr_compare (res1, ref1))
++ if (! SAME_VAL (res1, ref1))
+ {
+ printf ("Error for %s(a, a, a) for ", foo);
+- DISP2("a=",ref2);
+- DISP("expected ", ref1); DISP2(", got ", res1);
++ DISP2("a=", ref2);
++ printf ("expected "); mpfr_dump (ref1);
++ printf ("got "); mpfr_dump (res1);
+ exit (1);
+ }
+ }
+@@ -187,13 +183,13 @@
+ /* for each variable, consider each of the following 6 possibilities:
+ NaN, +Infinity, -Infinity, +0, -0 or a random number */
+
+- for (i=0; i<SPECIAL_MAX; i++)
++ for (i = 0; i < SPECIAL_MAX; i++)
+ {
+ set_special (op1, i);
+- for (j=0; j<SPECIAL_MAX; j++)
++ for (j = 0; j < SPECIAL_MAX; j++)
+ {
+ set_special (op2, j);
+- for (k=0; k<SPECIAL_MAX; k++)
++ for (k = 0; k < SPECIAL_MAX; k++)
+ {
+ set_special (op3, k);
+
+@@ -204,11 +200,12 @@
+ mpfr_set (res, op1, rnd); /* exact operation */
+ testfunc (res, res, op2, op3, rnd);
+
+- if (mpfr_compare (res, ref))
++ if (! SAME_VAL (res, ref))
+ {
+ printf ("Error for %s(a, a, b, c) for ", foo);
+ DISP("a=", op1); DISP(", b=", op2); DISP2(", c=", op3);
+- DISP("expected ", ref); DISP2(", got ", res);
++ printf ("expected "); mpfr_dump (ref);
++ printf ("got "); mpfr_dump (res);
+ exit (1);
+ }
+
+@@ -216,11 +213,12 @@
+ mpfr_set (res, op2, rnd);
+ testfunc (res, op1, res, op3, rnd);
+
+- if (mpfr_compare (res, ref))
++ if (! SAME_VAL (res, ref))
+ {
+ printf ("Error for %s(a, a, b, c) for ", foo);
+ DISP("a=", op1); DISP(", b=", op2); DISP2(", c=", op3);
+- DISP("expected ", ref); DISP2(", got ", res);
++ printf ("expected "); mpfr_dump (ref);
++ printf ("got "); mpfr_dump (res);
+ exit (1);
+ }
+
+@@ -228,35 +226,38 @@
+ mpfr_set (res, op3, rnd);
+ testfunc (res, op1, op2, res, rnd);
+
+- if (mpfr_compare (res, ref))
++ if (! SAME_VAL (res, ref))
+ {
+ printf ("Error for %s(a, a, b, c) for ", foo);
+ DISP("a=", op1); DISP(", b=", op2); DISP2(", c=", op3);
+- DISP("expected ", ref); DISP2(", got ", res);
++ printf ("expected "); mpfr_dump (ref);
++ printf ("got "); mpfr_dump (res);
+ exit (1);
+ }
+
+- /* foo(a, a, a,c) */
++ /* foo(a, a, a, c) */
+ testfunc (ref, op1, op1, op3, rnd);
+ mpfr_set (res, op1, rnd);
+ testfunc (res, res, res, op3, rnd);
+- if (mpfr_compare (res, ref))
++ if (! SAME_VAL (res, ref))
+ {
+ printf ("Error for %s(a, a, b, c) for ", foo);
+ DISP("a=", op1); DISP(", a=", op2); DISP2(", c=", op3);
+- DISP("expected ", ref); DISP2(", got ", res);
++ printf ("expected "); mpfr_dump (ref);
++ printf ("got "); mpfr_dump (res);
+ exit (1);
+ }
+
+- /* foo(a, a, b,a) */
++ /* foo(a, a, b, a) */
+ testfunc (ref, op1, op2, op1, rnd);
+ mpfr_set (res, op1, rnd);
+ testfunc (res, res, op2, res, rnd);
+- if (mpfr_compare (res, ref))
++ if (! SAME_VAL (res, ref))
+ {
+ printf ("Error for %s(a, a, b, c) for ", foo);
+ DISP("a=", op1); DISP(", a=", op2); DISP2(", c=", op3);
+- DISP("expected ", ref); DISP2(", got ", res);
++ printf ("expected "); mpfr_dump (ref);
++ printf ("got "); mpfr_dump (res);
+ exit (1);
+ }
+
+@@ -264,11 +265,12 @@
+ testfunc (ref, op1, op2, op2, rnd);
+ mpfr_set (res, op2, rnd);
+ testfunc (res, op1, res, res, rnd);
+- if (mpfr_compare (res, ref))
++ if (! SAME_VAL (res, ref))
+ {
+ printf ("Error for %s(a, a, b, c) for ", foo);
+ DISP("a=", op1); DISP(", a=", op2); DISP2(", c=", op3);
+- DISP("expected ", ref); DISP2(", got ", res);
++ printf ("expected "); mpfr_dump (ref);
++ printf ("got "); mpfr_dump (res);
+ exit (1);
+ }
+
+@@ -276,11 +278,12 @@
+ testfunc (ref, op1, op1, op1, rnd);
+ mpfr_set (res, op1, rnd);
+ testfunc (res, res, res, res, rnd);
+- if (mpfr_compare (res, ref))
++ if (! SAME_VAL (res, ref))
+ {
+ printf ("Error for %s(a, a, a, a) for ", foo);
+ DISP2("a=", op1);
+- DISP("expected ", ref); DISP2(", got ", res);
++ printf ("expected "); mpfr_dump (ref);
++ printf ("got "); mpfr_dump (res);
+ exit (1);
+ }
+ }
+@@ -313,10 +316,10 @@
+
+ /* ref2 can be NaN, +Inf, -Inf, +0, -0 or any number
+ ref3 can be 0 or any number */
+- for (i=0; i<SPECIAL_MAX*2; i++)
++ for (i = 0; i < SPECIAL_MAX * 2; i++)
+ {
+- set_special (ref2, i%SPECIAL_MAX);
+- ref3 = i/SPECIAL_MAX == 0 ? 0 : randlimb ();
++ set_special (ref2, i % SPECIAL_MAX);
++ ref3 = i / SPECIAL_MAX == 0 ? 0 : randlimb ();
+
+ /* reference call: foo(a, b, c) */
+ testfunc (ref1, ref2, ref3, rnd);
+@@ -325,10 +328,10 @@
+ mpfr_set (res1, ref2, rnd); /* exact operation */
+ testfunc (res1, res1, ref3, rnd);
+
+- if (mpfr_compare (res1, ref1))
++ if (! SAME_VAL (res1, ref1))
+ {
+ printf ("Error for %s(a, a, c) for c=%u\n", foo, ref3);
+- DISP2("a=",ref2);
++ DISP2("a=", ref2);
+ printf ("expected "); mpfr_dump (ref1);
+ printf ("got "); mpfr_dump (res1);
+ exit (1);
+@@ -356,10 +359,10 @@
+ mpfr_init2 (ref3, prec);
+ mpfr_init2 (res1, prec);
+
+- for (i=0; i<SPECIAL_MAX*2; i++)
++ for (i = 0; i < SPECIAL_MAX * 2; i++)
+ {
+- set_special (ref3, i%SPECIAL_MAX);
+- ref2 = i/SPECIAL_MAX==0 ? 0 : randlimb ();
++ set_special (ref3, i % SPECIAL_MAX);
++ ref2 = i / SPECIAL_MAX == 0 ? 0 : randlimb ();
+
+ /* reference call: foo(a, b, c) */
+ testfunc (ref1, ref2, ref3, rnd);
+@@ -367,7 +370,7 @@
+ /* foo(a, b, a) */
+ mpfr_set (res1, ref3, rnd); /* exact operation */
+ testfunc (res1, ref2, res1, rnd);
+- if (mpfr_compare (res1, ref1))
++ if (! SAME_VAL (res1, ref1))
+ {
+ printf ("Error for %s(a, b, a) for b=%u \n", foo, ref2);
+ DISP2("a=", ref3);
+@@ -397,7 +400,7 @@
+ mpfr_init2 (ref2, prec);
+ mpfr_init2 (res1, prec);
+
+- for (i=0; i<SPECIAL_MAX; i++)
++ for (i = 0; i < SPECIAL_MAX; i++)
+ {
+ set_special (ref2, i);
+
+@@ -407,7 +410,7 @@
+ /* foo(a, a) */
+ mpfr_set (res1, ref2, rnd); /* exact operation */
+ testfunc (res1, res1, rnd);
+- if (mpfr_compare (res1, ref1))
++ if (! SAME_VAL (res1, ref1))
+ {
+ printf ("Error for %s(a, a) for ", foo);
+ DISP2("a=", ref2);
+@@ -437,7 +440,7 @@
+ mpfr_init2 (ref2, prec);
+ mpfr_init2 (res1, prec);
+
+- for (i=0; i<SPECIAL_MAX; i++)
++ for (i = 0; i < SPECIAL_MAX; i++)
+ {
+ set_special (ref2, i);
+
+@@ -447,10 +450,10 @@
+ /* foo(a, a) */
+ mpfr_set (res1, ref2, MPFR_RNDN); /* exact operation */
+ testfunc (res1, res1);
+- if (mpfr_compare (res1, ref1))
++ if (! SAME_VAL (res1, ref1))
+ {
+ printf ("Error for %s(a, a) for ", foo);
+- DISP2("a=",ref2);
++ DISP2("a=", ref2);
+ DISP("expected", ref1); DISP2(", got ", res1);
+ exit (1);
+ }
+@@ -479,7 +482,7 @@
+ mpfr_init2 (res1, prec);
+ mpfr_init2 (res2, prec);
+
+- for (i=0; i<SPECIAL_MAX; i++)
++ for (i = 0; i < SPECIAL_MAX; i++)
+ {
+ set_special (ref3, i);
+
+@@ -489,12 +492,12 @@
+ /* foo(a, b, a) */
+ mpfr_set (res1, ref3, rnd); /* exact operation */
+ testfunc (res1, res2, res1, rnd);
+- if (mpfr_compare (res1, ref1) || mpfr_compare (res2, ref2))
++ if (! SAME_VAL (res1, ref1) || ! SAME_VAL (res2, ref2))
+ {
+ printf ("Error for %s(a, b, a) for rnd=%s, ", foo,
+ mpfr_print_rnd_mode (rnd));
+- DISP2("a=",ref3);
+- DISP("expected (", ref1); DISP(",",ref2);
++ DISP2("a=", ref3);
++ DISP("expected (", ref1); DISP(",", ref2);
+ DISP("), got (", res1); DISP(",", res2); printf(")\n");
+ exit (1);
+ }
+@@ -502,11 +505,11 @@
+ /* foo(a, b, b) */
+ mpfr_set (res2, ref3, rnd); /* exact operation */
+ testfunc (res1, res2, res2, rnd);
+- if (mpfr_compare (res1, ref1) || mpfr_compare (res2, ref2))
++ if (! SAME_VAL (res1, ref1) || ! SAME_VAL (res2, ref2))
+ {
+ printf ("Error for %s(a, b, b) for ", foo);
+- DISP2("b=",ref3);
+- DISP("expected (", ref1); DISP(",",ref2);
++ DISP2("b=", ref3);
++ DISP("expected (", ref1); DISP(",", ref2);
+ DISP("), got (", res1); DISP(",", res2); printf(")\n");
+ exit (1);
+ }
+@@ -561,10 +564,10 @@
+ mpfr_set (res1, ref2, rnd); /* exact operation */
+ mpfr_pow (res1, res1, ref3, rnd);
+
+- if (mpfr_compare (res1, ref1))
++ if (! SAME_VAL (res1, ref1))
+ {
+ printf ("Error for pow_int(a, a, c) for ");
+- DISP("a=",ref2); DISP2(", c=",ref3);
++ DISP("a=", ref2); DISP2(", c=", ref3);
+ printf ("expected "); mpfr_dump (ref1);
+ printf ("got "); mpfr_dump (res1);
+ exit (1);
+diff -Naurd mpfr-4.2.0-a/PATCHES mpfr-4.2.0-b/PATCHES
+--- mpfr-4.2.0-a/PATCHES 2023-05-12 15:08:39.233546717 +0000
++++ mpfr-4.2.0-b/PATCHES 2023-05-12 15:08:39.325546612 +0000
+@@ -0,0 +1 @@
++pow_general
+diff -Naurd mpfr-4.2.0-a/VERSION mpfr-4.2.0-b/VERSION
+--- mpfr-4.2.0-a/VERSION 2023-05-12 15:06:11.885721962 +0000
++++ mpfr-4.2.0-b/VERSION 2023-05-12 15:08:39.325546612 +0000
+@@ -1 +1 @@
+-4.2.0-p6
++4.2.0-p7
+diff -Naurd mpfr-4.2.0-a/src/mpfr.h mpfr-4.2.0-b/src/mpfr.h
+--- mpfr-4.2.0-a/src/mpfr.h 2023-05-12 15:06:11.877721972 +0000
++++ mpfr-4.2.0-b/src/mpfr.h 2023-05-12 15:08:39.321546616 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 4
+ #define MPFR_VERSION_MINOR 2
+ #define MPFR_VERSION_PATCHLEVEL 0
+-#define MPFR_VERSION_STRING "4.2.0-p6"
++#define MPFR_VERSION_STRING "4.2.0-p7"
+
+ /* User macros:
+ MPFR_USE_FILE: Define it to make MPFR define functions dealing
+diff -Naurd mpfr-4.2.0-a/src/pow.c mpfr-4.2.0-b/src/pow.c
+--- mpfr-4.2.0-a/src/pow.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/src/pow.c 2023-05-12 15:08:39.309546630 +0000
+@@ -131,7 +131,6 @@
+ /* Declaration of the size variable */
+ mpfr_prec_t Nz = MPFR_PREC(z); /* target precision */
+ mpfr_prec_t Nt; /* working precision */
+- mpfr_exp_t err; /* error */
+ MPFR_ZIV_DECL (ziv_loop);
+
+ MPFR_LOG_FUNC
+@@ -171,12 +170,14 @@
+ MPFR_ZIV_INIT (ziv_loop, Nt);
+ for (;;)
+ {
++ mpfr_exp_t err, exp_t;
+ MPFR_BLOCK_DECL (flags1);
+
+ /* compute exp(y*ln|x|), using MPFR_RNDU to get an upper bound, so
+ that we can detect underflows. */
+ mpfr_log (t, absx, MPFR_IS_NEG (y) ? MPFR_RNDD : MPFR_RNDU); /* ln|x| */
+ mpfr_mul (t, y, t, MPFR_RNDU); /* y*ln|x|
*/
++ exp_t = MPFR_GET_EXP (t);
+ if (k_non_zero)
+ {
+ MPFR_LOG_MSG (("subtract k * ln(2)\n", 0));
+@@ -188,14 +189,16 @@
+ MPFR_LOG_VAR (t);
+ }
+ /* estimate of the error -- see pow function in algorithms.tex.
+- The error on t is at most 1/2 + 3*2^(EXP(t)+1) ulps, which is
+- <= 2^(EXP(t)+3) for EXP(t) >= -1, and <= 2 ulps for EXP(t) <= -2.
++ The error on t before the subtraction of k*log(2) is at most
++ 1/2 + 3*2^(EXP(t)+1) ulps, which is <= 2^(EXP(t)+3) for EXP(t) >= -1,
++ and <= 2 ulps for EXP(t) <= -2.
+ Additional error if k_no_zero: treal = t * errk, with
+ 1 - |k| * 2^(-Nt) <= exp(-|k| * 2^(-Nt)) <= errk <= 1,
+ i.e., additional absolute error <= 2^(EXP(k)+EXP(t)-Nt).
+- Total error <= 2^err1 + 2^err2 <= 2^(max(err1,err2)+1). */
+- err = MPFR_NOTZERO (t) && MPFR_GET_EXP (t) >= -1 ?
+- MPFR_GET_EXP (t) + 3 : 1;
++ Total ulp error <= 2^err1 + 2^err2 <= 2^(max(err1,err2)+1),
++ where err1 = EXP(t)+3 for EXP(t) >= -1, and 1 otherwise,
++ and err2 = EXP(k). */
++ err = MPFR_NOTZERO (t) && exp_t >= -1 ? exp_t + 3 : 1;
+ if (k_non_zero)
+ {
+ if (MPFR_GET_EXP (k) > err)
+@@ -328,11 +331,17 @@
+ */
+ if (rnd_mode == MPFR_RNDN && inexact < 0 && lk < 0 &&
+ MPFR_GET_EXP (z) == __gmpfr_emin - 1 - lk && mpfr_powerof2_raw (z))
+- /* Rounding to nearest, real result > z * 2^k = 2^(emin - 2),
+- * underflow case: we will obtain the correct result and exceptions
+- * by replacing z by nextabove(z).
+- */
+- mpfr_nextabove (z);
++ /* Rounding to nearest, exact result > z * 2^k = 2^(emin - 2),
++ * and underflow case because the rounded result assuming an
++ * unbounded exponent range is 2^(emin - 2). We need to round
++ * to 2^(emin - 1), i.e. to round toward +inf.
++ * Note: the old code was using "mpfr_nextabove (z);" instead of
++ * setting rnd_mode to MPFR_RNDU for the call to mpfr_mul_2si, but
++ * this was incorrect in precision 1 because in this precision,
++ * mpfr_nextabove gave 2^(emin - 1), which is representable,
++ * so that mpfr_mul_2si did not generate the wanted underflow
++ * (the value was correct, but the underflow flag was missing). */
++ rnd_mode = MPFR_RNDU;
+ MPFR_CLEAR_FLAGS ();
+ inex2 = mpfr_mul_2si (z, z, lk, rnd_mode);
+ if (inex2) /* underflow or overflow */
+diff -Naurd mpfr-4.2.0-a/src/version.c mpfr-4.2.0-b/src/version.c
+--- mpfr-4.2.0-a/src/version.c 2023-05-12 15:06:11.885721962 +0000
++++ mpfr-4.2.0-b/src/version.c 2023-05-12 15:08:39.325546612 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+- return "4.2.0-p6";
++ return "4.2.0-p7";
+ }
+diff -Naurd mpfr-4.2.0-a/tests/texp10.c mpfr-4.2.0-b/tests/texp10.c
+--- mpfr-4.2.0-a/tests/texp10.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/tests/texp10.c 2023-05-12 15:08:39.309546630 +0000
+@@ -190,6 +190,187 @@
+ mpfr_clear (y);
+ }
+
++/* Bug in mpfr_pow_general found by ofuf_thresholds (on 2023-02-13 for
++ a 32-bit exponent, changed on 2023-03-06 for a 64-bit exponent too),
++ fixed in commit b62966df913f73f08b3c5252e1d0c702bc20442f.
++ With a 32-bit exponent, failure for i=0.
++ expected 0.1111E1073741823
++ got @Inf@
++ expected flags = inexact (8)
++ got flags = overflow inexact (10)
++ With a 64-bit exponent, failure for i=1.
++ expected 0.11111111111111111111111E4611686018427387903
++ got @Inf@
++ expected flags = inexact (8)
++ got flags = overflow inexact (10)
++ Note: ofuf_thresholds was added to the master branch, but for the
++ time being, there are issues with these tests.
++*/
++static void
++bug20230213 (void)
++{
++ const char *s[2] = {
++ "0x1.34413504b3ccdbd5dd8p+28",
++ "0x1.34413509f79fef2c4e0dd14a7ae0ecfbacdbp+60"
++ };
++ mpfr_t x1, x2, y1, y2;
++ mpfr_prec_t px[2] = { 74, 147 };
++ mpfr_prec_t py[2] = { 4, 23 };
++ mpfr_exp_t old_emax, emax;
++ mpfr_flags_t flags1, flags2;
++ int i;
++
++ old_emax = mpfr_get_emax ();
++
++ for (i = 0; i < 2; i++)
++ {
++ if (i != 0)
++ set_emax (MPFR_EMAX_MAX);
++
++ emax = mpfr_get_emax ();
++
++ mpfr_inits2 (px[i], x1, x2, (mpfr_ptr) 0);
++ mpfr_inits2 (py[i], y1, y2, (mpfr_ptr) 0);
++
++ mpfr_setmax (y1, emax);
++ mpfr_log10 (x1, y1, MPFR_RNDD);
++ mpfr_set_str (x2, s[i], 0, MPFR_RNDN);
++ /* For i == 0, emax == 2^30, so that the value can be checked.
++ For i != 0, check the value for the case emax == 2^62.
++ The "0UL" ensures that the shifts are valid. */
++ if (i == 0 || (((0UL + MPFR_EMAX_MAX) >> 31) >> 30) == 1)
++ {
++ /* printf ("Checking x1 for i=%d\n", i); */
++ MPFR_ASSERTN (mpfr_equal_p (x1, x2));
++ }
++
++ /* Let MAXF be the maximum finite value (y1 above).
++ Since x1 < log10(MAXF), one should have exp10(x1) < MAXF, and
++ therefore, y2 = RU(exp10(x1)) <= RU(MAXF) = MAXF (no overflow). */
++ flags1 = MPFR_FLAGS_INEXACT;
++ mpfr_clear_flags ();
++ mpfr_exp10 (y2, x1, MPFR_RNDU);
++ flags2 = __gmpfr_flags;
++
++ if (! (mpfr_lessequal_p (y2, y1) && flags2 == flags1))
++ {
++ printf ("Error in bug20230213 for i=%d\n", i);
++ printf ("emax = %" MPFR_EXP_FSPEC "d\n", (mpfr_eexp_t) emax);
++ printf ("expected "); mpfr_dump (y1);
++ printf ("got "); mpfr_dump (y2);
++ printf ("expected flags =");
++ flags_out (flags1);
++ printf ("got flags =");
++ flags_out (flags2);
++ exit (1);
++ }
++
++ mpfr_clears (x1, x2, y1, y2, (mpfr_ptr) 0);
++ }
++
++ set_emax (old_emax);
++}
++
++/* Bug in mpfr_pow_general in precision 1 in the particular case of
++ rounding to nearest, z * 2^k = 2^(emin - 2) and real result larger
++ than this value; fixed in ff5012b61d5e5fee5156c57b8aa8fc1739c2a771
++ (which is simplified in 4f5de980be290687ac1409aa02873e9e0dd1a030);
++ initially found by ofuf_thresholds (though the test was incorrect).
++ With a 32-bit exponent, failure for i=0.
++ With a 64-bit exponent, failure for i=1.
++ The result was correct, but the underflow flag was missing.
++ Note: ofuf_thresholds was added to the master branch, but for the
++ time being, there are issues with these tests.
++*/
++static void
++bug20230427 (void)
++{
++ const char *s[2] = {
++ "-0.1001101000100000100110101000011E29",
++ "-0.100110100010000010011010100001001111101111001111111101111001101E61"
++ };
++ mpfr_t x, y, z, t1, t2;
++ mpfr_exp_t old_emin;
++ mpfr_flags_t flags, ex_flags;
++ int i, inex;
++
++ old_emin = mpfr_get_emin ();
++
++ mpfr_init2 (x, 63);
++ mpfr_inits2 (1, y, z, (mpfr_ptr) 0);
++ mpfr_inits2 (128, t1, t2, (mpfr_ptr) 0);
++
++ for (i = 0; i < 2; i++)
++ {
++ if (i == 0)
++ {
++ /* Basic check: the default emin should be -2^30 (exactly). */
++ if (mpfr_get_emin () != -1073741823)
++ abort ();
++ }
++ else
++ {
++ /* This test assumes that MPFR_EMIN_MIN = -2^62 (exactly).
++ The "0UL" ensures that the shifts are valid. */
++ if ((((0UL - MPFR_EMIN_MIN) >> 31) >> 30) != 1)
++ break;
++
++ set_emin (MPFR_EMIN_MIN);
++ }
++
++ mpfr_set_str_binary (x, s[i]);
++
++ /* We will test 10^x rounded to nearest in precision 1.
++ Check that 2^(emin - 2) < 10^x < (3/2) * 2^(emin - 2).
++ This is approximate, but by outputting the values, one can check
++ that one is not too close to the boundaries:
++ emin - 2 = -4611686018427387905
++ log2(10^x) ~= -4611686018427387904.598
++ emin - 2 + log2(3/2) ~= -4611686018427387904.415
++ Thus the result should be the smallest positive number 2^(emin - 1)
++ because 10^x is closer to this number than to 0, the midpoint being
++ 2^(emin - 2). And there should be an underflow in precision 1 because
++ the result rounded to nearest in an unbounded exponent range should
++ have been 2^(emin - 2), the midpoint being (3/2) * 2^(emin - 2).
++ */
++ mpfr_set_ui (t1, 10, MPFR_RNDN);
++ mpfr_log2 (t2, t1, MPFR_RNDN);
++ mpfr_mul (t1, t2, x, MPFR_RNDN);
++ inex = mpfr_set_exp_t (t2, mpfr_get_emin () - 2, MPFR_RNDN);
++ MPFR_ASSERTN (inex == 0);
++ MPFR_ASSERTN (mpfr_greater_p (t1, t2)); /* log2(10^x) > emin - 2 */
++ inex = mpfr_sub (t1, t1, t2, MPFR_RNDN);
++ MPFR_ASSERTN (inex == 0);
++ mpfr_set_ui (t2, 3, MPFR_RNDN);
++ mpfr_log2 (t2, t2, MPFR_RNDN);
++ mpfr_sub_ui (t2, t2, 1, MPFR_RNDN); /* log2(3/2) */
++ MPFR_ASSERTN (mpfr_less_p (t1, t2));
++
++ mpfr_clear_flags ();
++ mpfr_exp10 (y, x, MPFR_RNDN);
++ flags = __gmpfr_flags;
++ ex_flags = MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT;
++
++ mpfr_setmin (z, mpfr_get_emin ()); /* z = 0.1@emin */
++ if (! (mpfr_equal_p (y, z) && flags == ex_flags))
++ {
++ printf ("Error in bug20230427 for i=%d\n", i);
++ printf ("expected "); mpfr_dump (z);
++ printf ("got "); mpfr_dump (y);
++ printf ("emin = %" MPFR_EXP_FSPEC "d\n",
++ (mpfr_eexp_t) mpfr_get_emin ());
++ printf ("expected flags =");
++ flags_out (ex_flags);
++ printf ("got flags =");
++ flags_out (flags);
++ exit (1);
++ }
++ }
++
++ mpfr_clears (x, y, z, t1, t2, (mpfr_ptr) 0);
++ set_emin (old_emin);
++}
++
+ int
+ main (int argc, char *argv[])
+ {
+@@ -199,6 +380,9 @@
+
+ tests_start_mpfr ();
+
++ bug20230213 ();
++ bug20230427 ();
++
+ special_overflow ();
+ emax_m_eps ();
+ exp_range ();
