source: patches/mpfr-3.1.2-fixes-2.patch@ 70a2865

Submitted By: William Harrington (kb0iic at cross-lfs dot org)
Date: 2014-03-10
Initial Package Version: 3.1.2
Origin: Upstream
Upstream Status: Applied
Description: Contains all upstream patches of mpfr current to patch level 5.

diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES
--- mpfr-3.1.2-a/PATCHES        2013-09-26 10:52:52.000000000 +0000
+++ mpfr-3.1.2-b/PATCHES        2013-09-26 10:52:52.000000000 +0000
@@ -0,0 +1 @@
+exp_2
diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION
--- mpfr-3.1.2-a/VERSION        2013-03-13 15:37:28.000000000 +0000
+++ mpfr-3.1.2-b/VERSION        2013-09-26 10:52:52.000000000 +0000
@@ -1 +1 @@
-3.1.2
+3.1.2-p1
diff -Naurd mpfr-3.1.2-a/src/exp_2.c mpfr-3.1.2-b/src/exp_2.c
--- mpfr-3.1.2-a/src/exp_2.c    2013-03-13 15:37:28.000000000 +0000
+++ mpfr-3.1.2-b/src/exp_2.c    2013-09-26 10:52:52.000000000 +0000
@@ -204,7 +204,7 @@
           for (k = 0; k < K; k++)
             {
               mpz_mul (ss, ss, ss);
-              exps <<= 1;
+              exps *= 2;
               exps += mpz_normalize (ss, ss, q);
             }
           mpfr_set_z (s, ss, MPFR_RNDN);
diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h
--- mpfr-3.1.2-a/src/mpfr.h     2013-03-13 15:37:37.000000000 +0000
+++ mpfr-3.1.2-b/src/mpfr.h     2013-09-26 10:52:52.000000000 +0000
@@ -27,7 +27,7 @@
 #define MPFR_VERSION_MAJOR 3
 #define MPFR_VERSION_MINOR 1
 #define MPFR_VERSION_PATCHLEVEL 2
-#define MPFR_VERSION_STRING "3.1.2"
+#define MPFR_VERSION_STRING "3.1.2-p1"
 
 /* Macros dealing with MPFR VERSION */
 #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c
--- mpfr-3.1.2-a/src/version.c  2013-03-13 15:37:34.000000000 +0000
+++ mpfr-3.1.2-b/src/version.c  2013-09-26 10:52:52.000000000 +0000
@@ -25,5 +25,5 @@
 const char *
 mpfr_get_version (void)
 {
-  return "3.1.2";
+  return "3.1.2-p1";
 }
diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES
--- mpfr-3.1.2-a/PATCHES        2013-09-26 10:56:55.000000000 +0000
+++ mpfr-3.1.2-b/PATCHES        2013-09-26 10:56:55.000000000 +0000
@@ -0,0 +1 @@
+fits-smallneg
diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION
--- mpfr-3.1.2-a/VERSION        2013-09-26 10:52:52.000000000 +0000
+++ mpfr-3.1.2-b/VERSION        2013-09-26 10:56:55.000000000 +0000
@@ -1 +1 @@
-3.1.2-p1
+3.1.2-p2
diff -Naurd mpfr-3.1.2-a/src/fits_u.h mpfr-3.1.2-b/src/fits_u.h
--- mpfr-3.1.2-a/src/fits_u.h   2013-03-13 15:37:35.000000000 +0000
+++ mpfr-3.1.2-b/src/fits_u.h   2013-09-26 10:56:55.000000000 +0000
@@ -32,17 +32,20 @@
   int res;
 
   if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
-    /* Zero always fit */
-    return MPFR_IS_ZERO (f) ? 1 : 0;
-  else if (MPFR_IS_NEG (f))
-    /* Negative numbers don't fit */
-    return 0;
-  /* now it fits if
-     (a) f <= MAXIMUM
-     (b) round(f, prec(slong), rnd) <= MAXIMUM */
+    return MPFR_IS_ZERO (f) ? 1 : 0;  /* Zero always fits */
 
   e = MPFR_GET_EXP (f);
 
+  if (MPFR_IS_NEG (f))
+    return e >= 1 ? 0  /* f <= -1 does not fit */
+      : rnd != MPFR_RNDN ? MPFR_IS_LIKE_RNDU (rnd, -1)  /* directed mode */
+      : e < 0 ? 1  /* f > -1/2 fits in MPFR_RNDN */
+      : mpfr_powerof2_raw(f);  /* -1/2 fits, -1 < f < -1/2 don't */
+
+  /* Now it fits if
+     (a) f <= MAXIMUM
+     (b) round(f, prec(slong), rnd) <= MAXIMUM */
+
   /* first compute prec(MAXIMUM); fits in an int */
   for (s = MAXIMUM, prec = 0; s != 0; s /= 2, prec ++);
 
diff -Naurd mpfr-3.1.2-a/src/fits_uintmax.c mpfr-3.1.2-b/src/fits_uintmax.c
--- mpfr-3.1.2-a/src/fits_uintmax.c     2013-03-13 15:37:33.000000000 +0000
+++ mpfr-3.1.2-b/src/fits_uintmax.c     2013-09-26 10:56:55.000000000 +0000
@@ -27,51 +27,19 @@
 #include "mpfr-intmax.h"
 #include "mpfr-impl.h"
 
-#ifdef _MPFR_H_HAVE_INTMAX_T
-
-/* We can't use fits_u.h <= mpfr_cmp_ui */
-int
-mpfr_fits_uintmax_p (mpfr_srcptr f, mpfr_rnd_t rnd)
-{
-  mpfr_exp_t e;
-  int prec;
-  uintmax_t s;
-  mpfr_t x;
-  int res;
-
-  if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
-    /* Zero always fit */
-    return MPFR_IS_ZERO (f) ? 1 : 0;
-  else if (MPFR_IS_NEG (f))
-    /* Negative numbers don't fit */
-    return 0;
-  /* now it fits if
-     (a) f <= MAXIMUM
-     (b) round(f, prec(slong), rnd) <= MAXIMUM */
-
-  e = MPFR_GET_EXP (f);
-
-  /* first compute prec(MAXIMUM); fits in an int */
-  for (s = MPFR_UINTMAX_MAX, prec = 0; s != 0; s /= 2, prec ++);
-
-  /* MAXIMUM needs prec bits, i.e. MAXIMUM = 2^prec - 1 */
-
-  /* if e <= prec - 1, then f < 2^(prec-1) < MAXIMUM */
-  if (e <= prec - 1)
-    return 1;
+/* Note: though mpfr-impl.h is included in fits_u.h, we also include it
+   above so that it gets included even when _MPFR_H_HAVE_INTMAX_T is not
+   defined; this is necessary to avoid an empty translation unit, which
+   is forbidden by ISO C. Without this, a failing test can be reproduced
+   by creating an invalid stdint.h somewhere in the default include path
+   and by compiling MPFR with "gcc -ansi -pedantic-errors". */
 
-  /* if e >= prec + 1, then f >= 2^prec > MAXIMUM */
-  if (e >= prec + 1)
-    return 0;
+#ifdef _MPFR_H_HAVE_INTMAX_T
 
-  MPFR_ASSERTD (e == prec);
+#define FUNCTION   mpfr_fits_uintmax_p
+#define MAXIMUM    MPFR_UINTMAX_MAX
+#define TYPE       uintmax_t
 
-  /* hard case: first round to prec bits, then check */
-  mpfr_init2 (x, prec);
-  mpfr_set (x, f, rnd);
-  res = MPFR_GET_EXP (x) == e;
-  mpfr_clear (x);
-  return res;
-}
+#include "fits_u.h"
 
 #endif
diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h
--- mpfr-3.1.2-a/src/mpfr.h     2013-09-26 10:52:52.000000000 +0000
+++ mpfr-3.1.2-b/src/mpfr.h     2013-09-26 10:56:55.000000000 +0000
@@ -27,7 +27,7 @@
 #define MPFR_VERSION_MAJOR 3
 #define MPFR_VERSION_MINOR 1
 #define MPFR_VERSION_PATCHLEVEL 2
-#define MPFR_VERSION_STRING "3.1.2-p1"
+#define MPFR_VERSION_STRING "3.1.2-p2"
 
 /* Macros dealing with MPFR VERSION */
 #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c
--- mpfr-3.1.2-a/src/version.c  2013-09-26 10:52:52.000000000 +0000
+++ mpfr-3.1.2-b/src/version.c  2013-09-26 10:56:55.000000000 +0000
@@ -25,5 +25,5 @@
 const char *
 mpfr_get_version (void)
 {
-  return "3.1.2-p1";
+  return "3.1.2-p2";
 }
diff -Naurd mpfr-3.1.2-a/tests/tfits.c mpfr-3.1.2-b/tests/tfits.c
--- mpfr-3.1.2-a/tests/tfits.c  2013-03-13 15:37:45.000000000 +0000
+++ mpfr-3.1.2-b/tests/tfits.c  2013-09-26 10:56:55.000000000 +0000
@@ -33,155 +33,176 @@
 #include "mpfr-intmax.h"
 #include "mpfr-test.h"
 
-#define ERROR1 { printf("Initial error for x="); mpfr_dump(x); exit(1); }
-#define ERROR2 { printf("Error for x="); mpfr_dump(x); exit(1); }
+#define ERROR1(N)                                               \
+  do                                                            \
+    {                                                           \
+      printf("Error %d for rnd = %s and x = ", N,               \
+             mpfr_print_rnd_mode ((mpfr_rnd_t) r));             \
+      mpfr_dump(x);                                             \
+      exit(1);                                                  \
+    }                                                           \
+  while (0)
 
 static void check_intmax (void);
 
 int
 main (void)
 {
-  mpfr_t x;
+  mpfr_t x, y;
+  int i, r;
 
   tests_start_mpfr ();
 
   mpfr_init2 (x, 256);
+  mpfr_init2 (y, 8);
 
-  /* Check NAN */
-  mpfr_set_nan (x);
-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR1;
+  RND_LOOP (r)
+    {
 
-  /* Check INF */
-  mpfr_set_inf (x, 1);
-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check NAN */
+      mpfr_set_nan (x);
+      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (1);
+      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (2);
+      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (3);
+      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (4);
+      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (5);
+      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (6);
 
-  /* Check Zero */
-  MPFR_SET_ZERO (x);
-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check INF */
+      mpfr_set_inf (x, 1);
+      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (7);
+      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (8);
+      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (9);
+      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (10);
+      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (11);
+      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (12);
 
-  /* Check small op */
-  mpfr_set_str1 (x, "1@-1");
-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check Zero */
+      MPFR_SET_ZERO (x);
+      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (13);
+      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (14);
+      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (15);
+      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (16);
+      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (17);
+      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (18);
 
-  /* Check 17 */
-  mpfr_set_ui (x, 17, MPFR_RNDN);
-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check small positive op */
+      mpfr_set_str1 (x, "1@-1");
+      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (19);
+      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (20);
+      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (21);
+      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (22);
+      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (23);
+      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (24);
 
-  /* Check all other values */
-  mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
-  mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR1;
-  mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check 17 */
+      mpfr_set_ui (x, 17, MPFR_RNDN);
+      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (25);
+      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (26);
+      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (27);
+      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (28);
+      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (29);
+      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (30);
 
-  mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check all other values */
+      mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
+      mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
+      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (31);
+      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (32);
+      mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
+      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (33);
+      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (34);
+      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (35);
+      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (36);
+      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (37);
 
-  mpfr_set_si (x, 1, MPFR_RNDN);
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
+      mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
+      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (38);
+      mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
+      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (39);
+      mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
+      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (40);
+      mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
+      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (41);
+      mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
+      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (42);
+      mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
+      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (43);
 
-  /* Check negative value */
-  mpfr_set_si (x, -1, MPFR_RNDN);
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR1;
+      mpfr_set_si (x, 1, MPFR_RNDN);
+      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (44);
+      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (45);
+
+      /* Check negative op */
+      for (i = 1; i <= 4; i++)
+        {
+          int inv;
+
+          mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
+          mpfr_rint (y, x, (mpfr_rnd_t) r);
+          inv = MPFR_NOTZERO (y);
+          if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r) ^ inv)
+            ERROR1 (46);
+          if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+            ERROR1 (47);
+          if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r) ^ inv)
+            ERROR1 (48);
+          if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+            ERROR1 (49);
+          if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r) ^ inv)
+            ERROR1 (50);
+          if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+            ERROR1 (51);
+        }
+    }
 
   mpfr_clear (x);
+  mpfr_clear (y);
 
   check_intmax ();
 
@@ -189,85 +210,98 @@
   return 0;
 }
 
-static void check_intmax (void)
+static void
+check_intmax (void)
 {
 #ifdef _MPFR_H_HAVE_INTMAX_T
-  mpfr_t x;
+  mpfr_t x, y;
+  int i, r;
 
-  mpfr_init2 (x, sizeof (uintmax_t)*CHAR_BIT);
+  mpfr_init2 (x, sizeof (uintmax_t) * CHAR_BIT);
+  mpfr_init2 (y, 8);
 
-  /* Check NAN */
-  mpfr_set_nan (x);
-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR1;
+  RND_LOOP (r)
+    {
+      /* Check NAN */
+      mpfr_set_nan (x);
+      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (52);
+      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (53);
 
-  /* Check INF */
-  mpfr_set_inf (x, 1);
-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check INF */
+      mpfr_set_inf (x, 1);
+      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (54);
+      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (55);
 
-  /* Check Zero */
-  MPFR_SET_ZERO (x);
-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check Zero */
+      MPFR_SET_ZERO (x);
+      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (56);
+      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (57);
 
-  /* Check small op */
-  mpfr_set_str1 (x, "1@-1");
-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check positive small op */
+      mpfr_set_str1 (x, "1@-1");
+      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (58);
+      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (59);
 
-  /* Check 17 */
-  mpfr_set_ui (x, 17, MPFR_RNDN);
-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check 17 */
+      mpfr_set_ui (x, 17, MPFR_RNDN);
+      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (60);
+      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (61);
 
-  /* Check hugest */
-  mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check hugest */
+      mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
+      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (62);
+      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (63);
 
-  /* Check all other values */
-  mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
-  mpfr_add_ui (x, x, 1, MPFR_RNDN);
-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR1;
-  mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
-  mpfr_add_ui (x, x, 1, MPFR_RNDN);
-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR1;
-  mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_sub_ui (x, x, 1, MPFR_RNDN);
-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check all other values */
+      mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
+      mpfr_add_ui (x, x, 1, MPFR_RNDN);
+      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (64);
+      mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
+      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (65);
+      mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
+      mpfr_add_ui (x, x, 1, MPFR_RNDN);
+      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (66);
+      mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
+      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (67);
+      mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
+      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (68);
+      mpfr_sub_ui (x, x, 1, MPFR_RNDN);
+      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (69);
 
-  /* Check negative value */
-  mpfr_set_si (x, -1, MPFR_RNDN);
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check negative op */
+      for (i = 1; i <= 4; i++)
+        {
+          int inv;
+
+          mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
+          mpfr_rint (y, x, (mpfr_rnd_t) r);
+          inv = MPFR_NOTZERO (y);
+          if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r) ^ inv)
+            ERROR1 (70);
+          if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+            ERROR1 (71);
+        }
+    }
 
   mpfr_clear (x);
+  mpfr_clear (y);
 #endif
 }
-
diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES
--- mpfr-3.1.2-a/PATCHES        2013-10-09 13:34:21.000000000 +0000
+++ mpfr-3.1.2-b/PATCHES        2013-10-09 13:34:21.000000000 +0000
@@ -0,0 +1 @@
+clang-divby0
diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION
--- mpfr-3.1.2-a/VERSION        2013-09-26 10:52:52.000000000 +0000
+++ mpfr-3.1.2-b/VERSION        2013-10-09 13:34:21.000000000 +0000
@@ -1 +1 @@
-3.1.2-p2
+3.1.2-p3
diff -Naurd mpfr-3.1.2-a/src/mpfr-impl.h mpfr-3.1.2-b/src/mpfr-impl.h
--- mpfr-3.1.2-a/src/mpfr-impl.h        2013-03-13 15:37:36.000000000 +0000
+++ mpfr-3.1.2-b/src/mpfr-impl.h        2013-10-09 13:34:21.000000000 +0000
@@ -468,8 +468,16 @@
 #define MPFR_LIMBS_PER_FLT ((IEEE_FLT_MANT_DIG-1)/GMP_NUMB_BITS+1)
 
 /* Visual C++ doesn't support +1.0/0.0, -1.0/0.0 and 0.0/0.0
-   at compile time. */
-#if defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200)
+   at compile time.
+   Clang with -fsanitize=undefined is a bit similar due to a bug:
+     http://llvm.org/bugs/show_bug.cgi?id=17381
+   but even without its sanitizer, it may be better to use the
+   double_zero version until IEEE 754 division by zero is properly
+   supported:
+     http://llvm.org/bugs/show_bug.cgi?id=17000
+*/
+#if (defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200)) || \
+    defined(__clang__)
 static double double_zero = 0.0;
 # define DBL_NAN (double_zero/double_zero)
 # define DBL_POS_INF ((double) 1.0/double_zero)
@@ -501,6 +509,8 @@
    (with Xcode 2.4.1, i.e. the latest one). */
 #define LVALUE(x) (&(x) == &(x) || &(x) != &(x))
 #define DOUBLE_ISINF(x) (LVALUE(x) && ((x) > DBL_MAX || (x) < -DBL_MAX))
+/* The DOUBLE_ISNAN(x) macro is also valid on long double x
+   (assuming that the compiler isn't too broken). */
 #ifdef MPFR_NANISNAN
 /* Avoid MIPSpro / IRIX64 / gcc -ffast-math (incorrect) optimizations.
    The + must not be replaced by a ||. With gcc -ffast-math, NaN is
diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h
--- mpfr-3.1.2-a/src/mpfr.h     2013-09-26 10:52:52.000000000 +0000
+++ mpfr-3.1.2-b/src/mpfr.h     2013-10-09 13:34:21.000000000 +0000
@@ -27,7 +27,7 @@
 #define MPFR_VERSION_MAJOR 3
 #define MPFR_VERSION_MINOR 1
 #define MPFR_VERSION_PATCHLEVEL 2
-#define MPFR_VERSION_STRING "3.1.2-p2"
+#define MPFR_VERSION_STRING "3.1.2-p3"
 
 /* Macros dealing with MPFR VERSION */
 #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c
--- mpfr-3.1.2-a/src/version.c  2013-09-26 10:52:52.000000000 +0000
+++ mpfr-3.1.2-b/src/version.c  2013-10-09 13:34:21.000000000 +0000
@@ -25,5 +25,5 @@
 const char *
 mpfr_get_version (void)
 {
-  return "3.1.2-p2";
+  return "3.1.2-p3";
 }
diff -Naurd mpfr-3.1.2-a/tests/tget_flt.c mpfr-3.1.2-b/tests/tget_flt.c
--- mpfr-3.1.2-a/tests/tget_flt.c       2013-03-13 15:37:44.000000000 +0000
+++ mpfr-3.1.2-b/tests/tget_flt.c       2013-10-09 13:34:21.000000000 +0000
@@ -28,9 +28,17 @@
 main (void)
 {
   mpfr_t x, y;
-  float f, g, infp;
+  float f, g;
   int i;
+#if !defined(MPFR_ERRDIVZERO)
+  float infp;
+#endif
+
+  tests_start_mpfr ();
 
+#if !defined(MPFR_ERRDIVZERO)
+  /* The definition of DBL_POS_INF involves a division by 0. This makes
+     "clang -O2 -fsanitize=undefined -fno-sanitize-recover" fail. */
   infp = (float) DBL_POS_INF;
   if (infp * 0.5 != infp)
     {
@@ -38,8 +46,7 @@
       fprintf (stderr, "(this is probably a compiler bug, please report)\n");
       exit (1);
     }
-
-  tests_start_mpfr ();
+#endif
 
   mpfr_init2 (x, 24);
   mpfr_init2 (y, 24);
@@ -353,6 +360,7 @@
       printf ("expected %.8e, got %.8e\n", g, f);
       exit (1);
     }
+#if !defined(MPFR_ERRDIVZERO)
   f = mpfr_get_flt (x, MPFR_RNDN); /* first round to 2^128 (even rule),
                                       thus we should get +Inf */
   g = infp;
@@ -376,6 +384,7 @@
       printf ("expected %.8e, got %.8e\n", g, f);
       exit (1);
     }
+#endif
 
   mpfr_clear (x);
   mpfr_clear (y);
diff -Naurd mpfr-3.1.2-a/tests/tset_ld.c mpfr-3.1.2-b/tests/tset_ld.c
--- mpfr-3.1.2-a/tests/tset_ld.c        2013-03-13 15:37:44.000000000 +0000
+++ mpfr-3.1.2-b/tests/tset_ld.c        2013-10-09 13:34:21.000000000 +0000
@@ -47,8 +47,11 @@
 static int
 Isnan_ld (long double d)
 {
-  double e = (double) d;
-  if (DOUBLE_ISNAN (e))
+  /* Do not convert d to double as this can give an overflow, which
+     may confuse compilers without IEEE 754 support (such as clang
+     -fsanitize=undefined), or trigger a trap if enabled.
+     The DOUBLE_ISNAN macro should work fine on long double. */
+  if (DOUBLE_ISNAN (d))
     return 1;
   LONGDOUBLE_NAN_ACTION (d, goto yes);
   return 0;
diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES
--- mpfr-3.1.2-a/PATCHES        2013-11-15 00:51:49.211333830 +0000
+++ mpfr-3.1.2-b/PATCHES        2013-11-15 00:51:49.323334999 +0000
@@ -0,0 +1 @@
+printf-alt0
diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION
--- mpfr-3.1.2-a/VERSION        2013-11-15 00:51:49.211333830 +0000
+++ mpfr-3.1.2-b/VERSION        2013-11-15 00:51:49.323334999 +0000
@@ -1 +1 @@
-3.1.2-p3
+3.1.2-p4
diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h
--- mpfr-3.1.2-a/src/mpfr.h     2013-11-15 00:51:49.211333830 +0000
+++ mpfr-3.1.2-b/src/mpfr.h     2013-11-15 00:51:49.323334999 +0000
@@ -27,7 +27,7 @@
 #define MPFR_VERSION_MAJOR 3
 #define MPFR_VERSION_MINOR 1
 #define MPFR_VERSION_PATCHLEVEL 2
-#define MPFR_VERSION_STRING "3.1.2-p3"
+#define MPFR_VERSION_STRING "3.1.2-p4"
 
 /* Macros dealing with MPFR VERSION */
 #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
diff -Naurd mpfr-3.1.2-a/src/vasprintf.c mpfr-3.1.2-b/src/vasprintf.c
--- mpfr-3.1.2-a/src/vasprintf.c        2013-03-13 15:37:37.000000000 +0000
+++ mpfr-3.1.2-b/src/vasprintf.c        2013-11-15 00:51:49.267334408 +0000
@@ -1040,7 +1040,7 @@
 }
 
 /* Determine the different parts of the string representation of the regular
-   number P when SPEC.SPEC is 'e', 'E', 'g', or 'G'.
+   number P when spec.spec is 'e', 'E', 'g', or 'G'.
    DEC_INFO contains the previously computed exponent and string or is NULL.
 
    return -1 if some field > INT_MAX */
@@ -1167,7 +1167,7 @@
 }
 
 /* Determine the different parts of the string representation of the regular
-   number P when SPEC.SPEC is 'f', 'F', 'g', or 'G'.
+   number P when spec.spec is 'f', 'F', 'g', or 'G'.
    DEC_INFO contains the previously computed exponent and string or is NULL.
 
    return -1 if some field of number_parts is greater than INT_MAX */
@@ -1559,7 +1559,7 @@
             /* fractional part */
             {
               np->point = MPFR_DECIMAL_POINT;
-              np->fp_trailing_zeros = (spec.spec == 'g' && spec.spec == 'G') ?
+              np->fp_trailing_zeros = (spec.spec == 'g' || spec.spec == 'G') ?
                 spec.prec - 1 : spec.prec;
             }
           else if (spec.alt)
diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c
--- mpfr-3.1.2-a/src/version.c  2013-11-15 00:51:49.211333830 +0000
+++ mpfr-3.1.2-b/src/version.c  2013-11-15 00:51:49.323334999 +0000
@@ -25,5 +25,5 @@
 const char *
 mpfr_get_version (void)
 {
-  return "3.1.2-p3";
+  return "3.1.2-p4";
 }
diff -Naurd mpfr-3.1.2-a/tests/tsprintf.c mpfr-3.1.2-b/tests/tsprintf.c
--- mpfr-3.1.2-a/tests/tsprintf.c       2013-03-13 15:37:44.000000000 +0000
+++ mpfr-3.1.2-b/tests/tsprintf.c       2013-11-15 00:51:49.267334408 +0000
@@ -456,10 +456,16 @@
   check_sprintf ("1.999900  ", "%-#10.7RG", x);
   check_sprintf ("1.9999    ", "%-10.7RG", x);
   mpfr_set_ui (x, 1, MPFR_RNDN);
+  check_sprintf ("1.", "%#.1Rg", x);
+  check_sprintf ("1.   ", "%-#5.1Rg", x);
+  check_sprintf ("  1.0", "%#5.2Rg", x);
   check_sprintf ("1.00000000000000000000000000000", "%#.30Rg", x);
   check_sprintf ("1", "%.30Rg", x);
   mpfr_set_ui (x, 0, MPFR_RNDN);
-  check_sprintf ("0.000000000000000000000000000000", "%#.30Rg", x);
+  check_sprintf ("0.", "%#.1Rg", x);
+  check_sprintf ("0.   ", "%-#5.1Rg", x);
+  check_sprintf ("  0.0", "%#5.2Rg", x);
+  check_sprintf ("0.00000000000000000000000000000", "%#.30Rg", x);
   check_sprintf ("0", "%.30Rg", x);
 
   /* following tests with precision 53 bits */
diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES
--- mpfr-3.1.2-a/PATCHES        2013-12-01 11:07:49.575329762 +0000
+++ mpfr-3.1.2-b/PATCHES        2013-12-01 11:07:49.751331625 +0000
@@ -0,0 +1 @@
+custom_init_set
diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION
--- mpfr-3.1.2-a/VERSION        2013-12-01 11:07:49.571329714 +0000
+++ mpfr-3.1.2-b/VERSION        2013-12-01 11:07:49.747331585 +0000
@@ -1 +1 @@
-3.1.2-p4
+3.1.2-p5
diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h
--- mpfr-3.1.2-a/src/mpfr.h     2013-12-01 11:07:49.571329714 +0000
+++ mpfr-3.1.2-b/src/mpfr.h     2013-12-01 11:07:49.747331585 +0000
@@ -27,7 +27,7 @@
 #define MPFR_VERSION_MAJOR 3
 #define MPFR_VERSION_MINOR 1
 #define MPFR_VERSION_PATCHLEVEL 2
-#define MPFR_VERSION_STRING "3.1.2-p4"
+#define MPFR_VERSION_STRING "3.1.2-p5"
 
 /* Macros dealing with MPFR VERSION */
 #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
@@ -861,7 +861,7 @@
     _t = (mpfr_kind_t) _k;                                     \
     _s = 1;                                                    \
   } else {                                                     \
-    _t = (mpfr_kind_t) -k;                                     \
+    _t = (mpfr_kind_t) - _k;                                   \
     _s = -1;                                                   \
   }                                                            \
   _e = _t == MPFR_REGULAR_KIND ? (e) :                         \
diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c
--- mpfr-3.1.2-a/src/version.c  2013-12-01 11:07:49.575329762 +0000
+++ mpfr-3.1.2-b/src/version.c  2013-12-01 11:07:49.747331585 +0000
@@ -25,5 +25,5 @@
 const char *
 mpfr_get_version (void)
 {
-  return "3.1.2-p4";
+  return "3.1.2-p5";
 }