wok rev 17581

Up: elfutils 0.161
author Alexander Medvedev <devl547@gmail.com>
date Sun Feb 08 18:13:43 2015 +0000 (2015-02-08)
parents 63c5da92bdb1
children e1141f224d98
files elfutils-dev/receipt elfutils/receipt mpfr/stuff/mpfr-3.1.2-upstream_fixes-3.patch
line diff
     1.1 --- a/elfutils-dev/receipt	Sun Feb 08 18:11:18 2015 +0000
     1.2 +++ b/elfutils-dev/receipt	Sun Feb 08 18:13:43 2015 +0000
     1.3 @@ -1,7 +1,7 @@
     1.4  # SliTaz package receipt.
     1.5  
     1.6  PACKAGE="elfutils-dev"
     1.7 -VERSION="0.153"
     1.8 +VERSION="0.161"
     1.9  CATEGORY="development"
    1.10  SHORT_DESC="ELF object file access library, development files."
    1.11  MAINTAINER="pascal.bellard@slitaz.org"
     2.1 --- a/elfutils/receipt	Sun Feb 08 18:11:18 2015 +0000
     2.2 +++ b/elfutils/receipt	Sun Feb 08 18:13:43 2015 +0000
     2.3 @@ -1,7 +1,7 @@
     2.4  # SliTaz package receipt.
     2.5  
     2.6  PACKAGE="elfutils"
     2.7 -VERSION="0.153"
     2.8 +VERSION="0.161"
     2.9  CATEGORY="development"
    2.10  SHORT_DESC="ELF object file access library."
    2.11  MAINTAINER="pascal.bellard@slitaz.org"
    2.12 @@ -23,18 +23,8 @@
    2.13  compile_rules()
    2.14  {
    2.15  	cd $src
    2.16 -	mkdir -p src/.deps
    2.17 -	touch src/.deps/none_ld.Po
    2.18 -	sed -i	-e 's/strcmp.*symtab")/(&\n\t\t\t\t\&\& strcmp (section_name (ebl, idx), ".dynsym"))/' \
    2.19 -		-e 's/__fini_array_start.*/&\n\t\t\t\t\&\& strcmp (name, "__bss_start") != 0\n\t\t\t\t\&\& strcmp (name, "__TMC_END__") != 0/' \
    2.20 -			src/elflint.c
    2.21 -	sed -i 's/run-strip-reloc.sh//' tests/Makefile* # Need cc -g !
    2.22  	./configure $CONFIGURE_ARGS &&
    2.23 -	# Disable check/tests when cross-compiling
    2.24 -	case "$ARCH" in
    2.25 -		arm) make && make install ;;
    2.26 -		*) make && make check && make install ;;
    2.27 -	esac
    2.28 +	make && make install
    2.29  }
    2.30  
    2.31  # Rules to gen a SliTaz package suitable for Tazpkg.
     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/mpfr/stuff/mpfr-3.1.2-upstream_fixes-3.patch	Sun Feb 08 18:13:43 2015 +0000
     3.3 @@ -0,0 +1,1199 @@
     3.4 +Submitted By:            Bruce Dubbs <bdubbs_at_linuxfromscratch_dot_org>
     3.5 +Updated By:              Armin K. <krejzi at email dot com>
     3.6 +Date:                    2015-02-06
     3.7 +Initial Package Version: 3.1.2
     3.8 +Upstream Status:         Already in upstream patch repo
     3.9 +Origin:                  Upstream
    3.10 +Description:             This patch contains patches for several bugs in MPFR.
    3.11 +                         Note that the patch for configure.ac has been 
    3.12 +                         removed to prevent unneeded regeneration of build
    3.13 +                         files.
    3.14 +                         See http://www.mpfr.org/mpfr-current/allpatches
    3.15 +
    3.16 +--- a/PATCHES	2013-03-13 16:37:38.000000000 +0100
    3.17 ++++ b/PATCHES	2014-12-31 14:56:02.685641958 +0100
    3.18 +@@ -0,0 +1,11 @@
    3.19 ++strtofr
    3.20 ++vasprintf
    3.21 ++div-overflow
    3.22 ++gmp6-compat
    3.23 ++exp3
    3.24 ++li2-return
    3.25 ++custom_init_set
    3.26 ++printf-alt0
    3.27 ++clang-divby0
    3.28 ++fits-smallneg
    3.29 ++exp_2
    3.30 +--- a/src/div.c	2013-03-13 16:37:33.000000000 +0100
    3.31 ++++ b/src/div.c	2014-12-31 14:56:02.686641971 +0100
    3.32 +@@ -750,7 +750,9 @@
    3.33 +  truncate_check_qh:
    3.34 +   if (qh)
    3.35 +     {
    3.36 +-      qexp ++;
    3.37 ++      if (MPFR_LIKELY (qexp < MPFR_EXP_MAX))
    3.38 ++        qexp ++;
    3.39 ++      /* else qexp is now incorrect, but one will still get an overflow */
    3.40 +       q0p[q0size - 1] = MPFR_LIMB_HIGHBIT;
    3.41 +     }
    3.42 +   goto truncate;
    3.43 +@@ -765,7 +767,9 @@
    3.44 +   inex = 1; /* always here */
    3.45 +   if (mpn_add_1 (q0p, q0p, q0size, MPFR_LIMB_ONE << sh))
    3.46 +     {
    3.47 +-      qexp ++;
    3.48 ++      if (MPFR_LIKELY (qexp < MPFR_EXP_MAX))
    3.49 ++        qexp ++;
    3.50 ++      /* else qexp is now incorrect, but one will still get an overflow */
    3.51 +       q0p[q0size - 1] = MPFR_LIMB_HIGHBIT;
    3.52 +     }
    3.53 + 
    3.54 +--- a/src/exp_2.c	2013-03-13 16:37:28.000000000 +0100
    3.55 ++++ b/src/exp_2.c	2014-12-31 14:56:02.686641971 +0100
    3.56 +@@ -204,7 +204,7 @@
    3.57 +           for (k = 0; k < K; k++)
    3.58 +             {
    3.59 +               mpz_mul (ss, ss, ss);
    3.60 +-              exps <<= 1;
    3.61 ++              exps *= 2;
    3.62 +               exps += mpz_normalize (ss, ss, q);
    3.63 +             }
    3.64 +           mpfr_set_z (s, ss, MPFR_RNDN);
    3.65 +--- a/src/exp3.c	2013-03-13 16:37:34.000000000 +0100
    3.66 ++++ b/src/exp3.c	2014-12-31 14:56:02.686641971 +0100
    3.67 +@@ -283,7 +283,7 @@
    3.68 +             }
    3.69 +         }
    3.70 + 
    3.71 +-      if (mpfr_can_round (shift_x > 0 ? t : tmp, realprec, MPFR_RNDD, MPFR_RNDZ,
    3.72 ++      if (mpfr_can_round (shift_x > 0 ? t : tmp, realprec, MPFR_RNDN, MPFR_RNDZ,
    3.73 +                           MPFR_PREC(y) + (rnd_mode == MPFR_RNDN)))
    3.74 +         {
    3.75 +           inexact = mpfr_set (y, shift_x > 0 ? t : tmp, rnd_mode);
    3.76 +--- a/src/fits_u.h	2013-03-13 16:37:35.000000000 +0100
    3.77 ++++ b/src/fits_u.h	2014-12-31 14:56:02.686641971 +0100
    3.78 +@@ -32,17 +32,20 @@
    3.79 +   int res;
    3.80 + 
    3.81 +   if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
    3.82 +-    /* Zero always fit */
    3.83 +-    return MPFR_IS_ZERO (f) ? 1 : 0;
    3.84 +-  else if (MPFR_IS_NEG (f))
    3.85 +-    /* Negative numbers don't fit */
    3.86 +-    return 0;
    3.87 +-  /* now it fits if
    3.88 +-     (a) f <= MAXIMUM
    3.89 +-     (b) round(f, prec(slong), rnd) <= MAXIMUM */
    3.90 ++    return MPFR_IS_ZERO (f) ? 1 : 0;  /* Zero always fits */
    3.91 + 
    3.92 +   e = MPFR_GET_EXP (f);
    3.93 + 
    3.94 ++  if (MPFR_IS_NEG (f))
    3.95 ++    return e >= 1 ? 0  /* f <= -1 does not fit */
    3.96 ++      : rnd != MPFR_RNDN ? MPFR_IS_LIKE_RNDU (rnd, -1)  /* directed mode */
    3.97 ++      : e < 0 ? 1  /* f > -1/2 fits in MPFR_RNDN */
    3.98 ++      : mpfr_powerof2_raw(f);  /* -1/2 fits, -1 < f < -1/2 don't */
    3.99 ++
   3.100 ++  /* Now it fits if
   3.101 ++     (a) f <= MAXIMUM
   3.102 ++     (b) round(f, prec(slong), rnd) <= MAXIMUM */
   3.103 ++
   3.104 +   /* first compute prec(MAXIMUM); fits in an int */
   3.105 +   for (s = MAXIMUM, prec = 0; s != 0; s /= 2, prec ++);
   3.106 + 
   3.107 +--- a/src/fits_uintmax.c	2013-03-13 16:37:33.000000000 +0100
   3.108 ++++ b/src/fits_uintmax.c	2014-12-31 14:56:02.686641971 +0100
   3.109 +@@ -27,51 +27,19 @@
   3.110 + #include "mpfr-intmax.h"
   3.111 + #include "mpfr-impl.h"
   3.112 + 
   3.113 +-#ifdef _MPFR_H_HAVE_INTMAX_T
   3.114 +-
   3.115 +-/* We can't use fits_u.h <= mpfr_cmp_ui */
   3.116 +-int
   3.117 +-mpfr_fits_uintmax_p (mpfr_srcptr f, mpfr_rnd_t rnd)
   3.118 +-{
   3.119 +-  mpfr_exp_t e;
   3.120 +-  int prec;
   3.121 +-  uintmax_t s;
   3.122 +-  mpfr_t x;
   3.123 +-  int res;
   3.124 +-
   3.125 +-  if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
   3.126 +-    /* Zero always fit */
   3.127 +-    return MPFR_IS_ZERO (f) ? 1 : 0;
   3.128 +-  else if (MPFR_IS_NEG (f))
   3.129 +-    /* Negative numbers don't fit */
   3.130 +-    return 0;
   3.131 +-  /* now it fits if
   3.132 +-     (a) f <= MAXIMUM
   3.133 +-     (b) round(f, prec(slong), rnd) <= MAXIMUM */
   3.134 +-
   3.135 +-  e = MPFR_GET_EXP (f);
   3.136 ++/* Note: though mpfr-impl.h is included in fits_u.h, we also include it
   3.137 ++   above so that it gets included even when _MPFR_H_HAVE_INTMAX_T is not
   3.138 ++   defined; this is necessary to avoid an empty translation unit, which
   3.139 ++   is forbidden by ISO C. Without this, a failing test can be reproduced
   3.140 ++   by creating an invalid stdint.h somewhere in the default include path
   3.141 ++   and by compiling MPFR with "gcc -ansi -pedantic-errors". */
   3.142 + 
   3.143 +-  /* first compute prec(MAXIMUM); fits in an int */
   3.144 +-  for (s = MPFR_UINTMAX_MAX, prec = 0; s != 0; s /= 2, prec ++);
   3.145 +-
   3.146 +-  /* MAXIMUM needs prec bits, i.e. MAXIMUM = 2^prec - 1 */
   3.147 +-
   3.148 +-  /* if e <= prec - 1, then f < 2^(prec-1) < MAXIMUM */
   3.149 +-  if (e <= prec - 1)
   3.150 +-    return 1;
   3.151 +-
   3.152 +-  /* if e >= prec + 1, then f >= 2^prec > MAXIMUM */
   3.153 +-  if (e >= prec + 1)
   3.154 +-    return 0;
   3.155 ++#ifdef _MPFR_H_HAVE_INTMAX_T
   3.156 + 
   3.157 +-  MPFR_ASSERTD (e == prec);
   3.158 ++#define FUNCTION   mpfr_fits_uintmax_p
   3.159 ++#define MAXIMUM    MPFR_UINTMAX_MAX
   3.160 ++#define TYPE       uintmax_t
   3.161 + 
   3.162 +-  /* hard case: first round to prec bits, then check */
   3.163 +-  mpfr_init2 (x, prec);
   3.164 +-  mpfr_set (x, f, rnd);
   3.165 +-  res = MPFR_GET_EXP (x) == e;
   3.166 +-  mpfr_clear (x);
   3.167 +-  return res;
   3.168 +-}
   3.169 ++#include "fits_u.h"
   3.170 + 
   3.171 + #endif
   3.172 +--- a/src/init2.c	2013-03-13 16:37:32.000000000 +0100
   3.173 ++++ b/src/init2.c	2014-12-31 14:56:02.686641971 +0100
   3.174 +@@ -30,11 +30,11 @@
   3.175 + 
   3.176 +   /* Check if we can represent the number of limbs
   3.177 +    * associated to the maximum of mpfr_prec_t*/
   3.178 +-  MPFR_ASSERTN( MP_SIZE_T_MAX >= (MPFR_PREC_MAX/BYTES_PER_MP_LIMB) );
   3.179 ++  MPFR_ASSERTN( MP_SIZE_T_MAX >= (MPFR_PREC_MAX/MPFR_BYTES_PER_MP_LIMB) );
   3.180 + 
   3.181 +-  /* Check for correct GMP_NUMB_BITS and BYTES_PER_MP_LIMB */
   3.182 +-  MPFR_ASSERTN( GMP_NUMB_BITS == BYTES_PER_MP_LIMB * CHAR_BIT
   3.183 +-                && sizeof(mp_limb_t) == BYTES_PER_MP_LIMB );
   3.184 ++  /* Check for correct GMP_NUMB_BITS and MPFR_BYTES_PER_MP_LIMB */
   3.185 ++  MPFR_ASSERTN( GMP_NUMB_BITS == MPFR_BYTES_PER_MP_LIMB * CHAR_BIT
   3.186 ++                && sizeof(mp_limb_t) == MPFR_BYTES_PER_MP_LIMB );
   3.187 + 
   3.188 +   MPFR_ASSERTN (mp_bits_per_limb == GMP_NUMB_BITS);
   3.189 + 
   3.190 +--- a/src/li2.c	2013-03-13 16:37:32.000000000 +0100
   3.191 ++++ b/src/li2.c	2014-12-31 14:56:02.686641971 +0100
   3.192 +@@ -630,5 +630,5 @@
   3.193 +       return mpfr_check_range (y, inexact, rnd_mode);
   3.194 +     }
   3.195 + 
   3.196 +-  MPFR_ASSERTN (0);             /* should never reach this point */
   3.197 ++  MPFR_RET_NEVER_GO_HERE ();
   3.198 + }
   3.199 +--- a/src/mpfr-gmp.h	2013-03-13 16:37:32.000000000 +0100
   3.200 ++++ b/src/mpfr-gmp.h	2014-12-31 14:56:02.687641984 +0100
   3.201 +@@ -72,7 +72,6 @@
   3.202 + #endif
   3.203 + 
   3.204 + /* Define some macros */
   3.205 +-#define BYTES_PER_MP_LIMB (GMP_NUMB_BITS/CHAR_BIT)
   3.206 + 
   3.207 + #define MP_LIMB_T_MAX (~(mp_limb_t)0)
   3.208 + 
   3.209 +@@ -96,19 +95,19 @@
   3.210 + #define SHRT_HIGHBIT       SHRT_MIN
   3.211 + 
   3.212 + /* MP_LIMB macros */
   3.213 +-#define MPN_ZERO(dst, n) memset((dst), 0, (n)*BYTES_PER_MP_LIMB)
   3.214 +-#define MPN_COPY_DECR(dst,src,n) memmove((dst),(src),(n)*BYTES_PER_MP_LIMB)
   3.215 +-#define MPN_COPY_INCR(dst,src,n) memmove((dst),(src),(n)*BYTES_PER_MP_LIMB)
   3.216 ++#define MPN_ZERO(dst, n) memset((dst), 0, (n)*MPFR_BYTES_PER_MP_LIMB)
   3.217 ++#define MPN_COPY_DECR(dst,src,n) memmove((dst),(src),(n)*MPFR_BYTES_PER_MP_LIMB)
   3.218 ++#define MPN_COPY_INCR(dst,src,n) memmove((dst),(src),(n)*MPFR_BYTES_PER_MP_LIMB)
   3.219 + #define MPN_COPY(dst,src,n) \
   3.220 +   do                                                                  \
   3.221 +     {                                                                 \
   3.222 +       if ((dst) != (src))                                             \
   3.223 +         {                                                             \
   3.224 +           MPFR_ASSERTD ((char *) (dst) >= (char *) (src) +            \
   3.225 +-                                          (n) * BYTES_PER_MP_LIMB ||  \
   3.226 ++                                     (n) * MPFR_BYTES_PER_MP_LIMB ||  \
   3.227 +                         (char *) (src) >= (char *) (dst) +            \
   3.228 +-                                          (n) * BYTES_PER_MP_LIMB);   \
   3.229 +-          memcpy ((dst), (src), (n) * BYTES_PER_MP_LIMB);             \
   3.230 ++                                     (n) * MPFR_BYTES_PER_MP_LIMB);   \
   3.231 ++          memcpy ((dst), (src), (n) * MPFR_BYTES_PER_MP_LIMB);        \
   3.232 +         }                                                             \
   3.233 +     }                                                                 \
   3.234 +   while (0)
   3.235 +--- a/src/mpfr.h	2013-03-13 16:37:37.000000000 +0100
   3.236 ++++ b/src/mpfr.h	2014-12-31 14:56:02.687641984 +0100
   3.237 +@@ -27,7 +27,7 @@
   3.238 + #define MPFR_VERSION_MAJOR 3
   3.239 + #define MPFR_VERSION_MINOR 1
   3.240 + #define MPFR_VERSION_PATCHLEVEL 2
   3.241 +-#define MPFR_VERSION_STRING "3.1.2"
   3.242 ++#define MPFR_VERSION_STRING "3.1.2-p11"
   3.243 + 
   3.244 + /* Macros dealing with MPFR VERSION */
   3.245 + #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
   3.246 +@@ -861,7 +861,7 @@
   3.247 +     _t = (mpfr_kind_t) _k;                                     \
   3.248 +     _s = 1;                                                    \
   3.249 +   } else {                                                     \
   3.250 +-    _t = (mpfr_kind_t) -k;                                     \
   3.251 ++    _t = (mpfr_kind_t) - _k;                                   \
   3.252 +     _s = -1;                                                   \
   3.253 +   }                                                            \
   3.254 +   _e = _t == MPFR_REGULAR_KIND ? (e) :                         \
   3.255 +--- a/src/mpfr-impl.h	2013-03-13 16:37:36.000000000 +0100
   3.256 ++++ b/src/mpfr-impl.h	2014-12-31 14:56:02.687641984 +0100
   3.257 +@@ -191,7 +191,7 @@
   3.258 + # endif
   3.259 + #endif
   3.260 + 
   3.261 +-
   3.262 ++#define MPFR_BYTES_PER_MP_LIMB (GMP_NUMB_BITS/CHAR_BIT)
   3.263 + 
   3.264 + /******************************************************
   3.265 +  ******************** Check GMP ***********************
   3.266 +@@ -468,8 +468,16 @@
   3.267 + #define MPFR_LIMBS_PER_FLT ((IEEE_FLT_MANT_DIG-1)/GMP_NUMB_BITS+1)
   3.268 + 
   3.269 + /* Visual C++ doesn't support +1.0/0.0, -1.0/0.0 and 0.0/0.0
   3.270 +-   at compile time. */
   3.271 +-#if defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200)
   3.272 ++   at compile time.
   3.273 ++   Clang with -fsanitize=undefined is a bit similar due to a bug:
   3.274 ++     http://llvm.org/bugs/show_bug.cgi?id=17381
   3.275 ++   but even without its sanitizer, it may be better to use the
   3.276 ++   double_zero version until IEEE 754 division by zero is properly
   3.277 ++   supported:
   3.278 ++     http://llvm.org/bugs/show_bug.cgi?id=17000
   3.279 ++*/
   3.280 ++#if (defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200)) || \
   3.281 ++    defined(__clang__)
   3.282 + static double double_zero = 0.0;
   3.283 + # define DBL_NAN (double_zero/double_zero)
   3.284 + # define DBL_POS_INF ((double) 1.0/double_zero)
   3.285 +@@ -501,6 +509,8 @@
   3.286 +    (with Xcode 2.4.1, i.e. the latest one). */
   3.287 + #define LVALUE(x) (&(x) == &(x) || &(x) != &(x))
   3.288 + #define DOUBLE_ISINF(x) (LVALUE(x) && ((x) > DBL_MAX || (x) < -DBL_MAX))
   3.289 ++/* The DOUBLE_ISNAN(x) macro is also valid on long double x
   3.290 ++   (assuming that the compiler isn't too broken). */
   3.291 + #ifdef MPFR_NANISNAN
   3.292 + /* Avoid MIPSpro / IRIX64 / gcc -ffast-math (incorrect) optimizations.
   3.293 +    The + must not be replaced by a ||. With gcc -ffast-math, NaN is
   3.294 +@@ -920,7 +930,7 @@
   3.295 + #define MPFR_SET_ALLOC_SIZE(x, n) \
   3.296 +  ( ((mp_size_t*) MPFR_MANT(x))[-1] = n)
   3.297 + #define MPFR_MALLOC_SIZE(s) \
   3.298 +-  ( sizeof(mpfr_size_limb_t) + BYTES_PER_MP_LIMB * ((size_t) s) )
   3.299 ++  ( sizeof(mpfr_size_limb_t) + MPFR_BYTES_PER_MP_LIMB * ((size_t) s) )
   3.300 + #define MPFR_SET_MANT_PTR(x,p) \
   3.301 +    (MPFR_MANT(x) = (mp_limb_t*) ((mpfr_size_limb_t*) p + 1))
   3.302 + #define MPFR_GET_REAL_PTR(x) \
   3.303 +@@ -954,7 +964,7 @@
   3.304 + #endif
   3.305 + 
   3.306 + #define MPFR_TMP_LIMBS_ALLOC(N) \
   3.307 +-  ((mp_limb_t *) MPFR_TMP_ALLOC ((size_t) (N) * BYTES_PER_MP_LIMB))
   3.308 ++  ((mp_limb_t *) MPFR_TMP_ALLOC ((size_t) (N) * MPFR_BYTES_PER_MP_LIMB))
   3.309 + 
   3.310 + /* temporary allocate 1 limb at xp, and initialize mpfr variable x */
   3.311 + /* The temporary var doesn't have any size field, but it doesn't matter
   3.312 +--- a/src/mul.c	2013-03-13 16:37:37.000000000 +0100
   3.313 ++++ b/src/mul.c	2014-12-31 14:56:02.688641997 +0100
   3.314 +@@ -106,7 +106,7 @@
   3.315 +   MPFR_ASSERTD(tn <= k);
   3.316 + 
   3.317 +   /* Check for no size_t overflow*/
   3.318 +-  MPFR_ASSERTD((size_t) k <= ((size_t) -1) / BYTES_PER_MP_LIMB);
   3.319 ++  MPFR_ASSERTD((size_t) k <= ((size_t) -1) / MPFR_BYTES_PER_MP_LIMB);
   3.320 +   MPFR_TMP_MARK(marker);
   3.321 +   tmp = MPFR_TMP_LIMBS_ALLOC (k);
   3.322 + 
   3.323 +@@ -301,7 +301,7 @@
   3.324 +   MPFR_ASSERTD (tn <= k); /* tn <= k, thus no int overflow */
   3.325 + 
   3.326 +   /* Check for no size_t overflow*/
   3.327 +-  MPFR_ASSERTD ((size_t) k <= ((size_t) -1) / BYTES_PER_MP_LIMB);
   3.328 ++  MPFR_ASSERTD ((size_t) k <= ((size_t) -1) / MPFR_BYTES_PER_MP_LIMB);
   3.329 +   MPFR_TMP_MARK (marker);
   3.330 +   tmp = MPFR_TMP_LIMBS_ALLOC (k);
   3.331 + 
   3.332 +--- a/src/stack_interface.c	2013-03-13 16:37:32.000000000 +0100
   3.333 ++++ b/src/stack_interface.c	2014-12-31 14:56:02.688641997 +0100
   3.334 +@@ -26,7 +26,7 @@
   3.335 + size_t
   3.336 + mpfr_custom_get_size (mpfr_prec_t prec)
   3.337 + {
   3.338 +-  return MPFR_PREC2LIMBS (prec) * BYTES_PER_MP_LIMB;
   3.339 ++  return MPFR_PREC2LIMBS (prec) * MPFR_BYTES_PER_MP_LIMB;
   3.340 + }
   3.341 + 
   3.342 + #undef mpfr_custom_init
   3.343 +--- a/src/strtofr.c	2013-03-13 16:37:32.000000000 +0100
   3.344 ++++ b/src/strtofr.c	2014-12-31 14:56:02.688641997 +0100
   3.345 +@@ -473,8 +473,10 @@
   3.346 +       /* prec bits corresponds to ysize limbs */
   3.347 +       ysize_bits = ysize * GMP_NUMB_BITS;
   3.348 +       /* and to ysize_bits >= prec > MPFR_PREC (x) bits */
   3.349 +-      y = MPFR_TMP_LIMBS_ALLOC (2 * ysize + 1);
   3.350 +-      y += ysize; /* y has (ysize+1) allocated limbs */
   3.351 ++      /* we need to allocate one more limb to work around bug
   3.352 ++         https://gmplib.org/list-archives/gmp-bugs/2013-December/003267.html */
   3.353 ++      y = MPFR_TMP_LIMBS_ALLOC (2 * ysize + 2);
   3.354 ++      y += ysize; /* y has (ysize+2) allocated limbs */
   3.355 + 
   3.356 +       /* pstr_size is the number of characters we read in pstr->mant
   3.357 +          to have at least ysize full limbs.
   3.358 +--- a/src/vasprintf.c	2013-03-13 16:37:37.000000000 +0100
   3.359 ++++ b/src/vasprintf.c	2014-12-31 14:56:02.688641997 +0100
   3.360 +@@ -884,14 +884,18 @@
   3.361 +            first digit, we want the exponent for radix two and the decimal
   3.362 +            point AFTER the first digit. */
   3.363 +         {
   3.364 +-          MPFR_ASSERTN (exp > MPFR_EMIN_MIN /4); /* possible overflow */
   3.365 ++          /* An integer overflow is normally not possible since MPFR_EXP_MIN
   3.366 ++             is twice as large as MPFR_EMIN_MIN. */
   3.367 ++          MPFR_ASSERTN (exp > (MPFR_EXP_MIN + 3) / 4);
   3.368 +           exp = (exp - 1) * 4;
   3.369 +         }
   3.370 +       else
   3.371 +         /* EXP is the exponent for decimal point BEFORE the first digit, we
   3.372 +            want the exponent for decimal point AFTER the first digit. */
   3.373 +         {
   3.374 +-          MPFR_ASSERTN (exp > MPFR_EMIN_MIN); /* possible overflow */
   3.375 ++          /* An integer overflow is normally not possible since MPFR_EXP_MIN
   3.376 ++             is twice as large as MPFR_EMIN_MIN. */
   3.377 ++          MPFR_ASSERTN (exp > MPFR_EXP_MIN);
   3.378 +           --exp;
   3.379 +         }
   3.380 +     }
   3.381 +@@ -1040,7 +1044,7 @@
   3.382 + }
   3.383 + 
   3.384 + /* Determine the different parts of the string representation of the regular
   3.385 +-   number P when SPEC.SPEC is 'e', 'E', 'g', or 'G'.
   3.386 ++   number P when spec.spec is 'e', 'E', 'g', or 'G'.
   3.387 +    DEC_INFO contains the previously computed exponent and string or is NULL.
   3.388 + 
   3.389 +    return -1 if some field > INT_MAX */
   3.390 +@@ -1167,7 +1171,7 @@
   3.391 + }
   3.392 + 
   3.393 + /* Determine the different parts of the string representation of the regular
   3.394 +-   number P when SPEC.SPEC is 'f', 'F', 'g', or 'G'.
   3.395 ++   number P when spec.spec is 'f', 'F', 'g', or 'G'.
   3.396 +    DEC_INFO contains the previously computed exponent and string or is NULL.
   3.397 + 
   3.398 +    return -1 if some field of number_parts is greater than INT_MAX */
   3.399 +@@ -1559,7 +1563,7 @@
   3.400 +             /* fractional part */
   3.401 +             {
   3.402 +               np->point = MPFR_DECIMAL_POINT;
   3.403 +-              np->fp_trailing_zeros = (spec.spec == 'g' && spec.spec == 'G') ?
   3.404 ++              np->fp_trailing_zeros = (spec.spec == 'g' || spec.spec == 'G') ?
   3.405 +                 spec.prec - 1 : spec.prec;
   3.406 +             }
   3.407 +           else if (spec.alt)
   3.408 +--- a/src/version.c	2013-03-13 16:37:34.000000000 +0100
   3.409 ++++ b/src/version.c	2014-12-31 14:56:02.688641997 +0100
   3.410 +@@ -25,5 +25,5 @@
   3.411 + const char *
   3.412 + mpfr_get_version (void)
   3.413 + {
   3.414 +-  return "3.1.2";
   3.415 ++  return "3.1.2-p11";
   3.416 + }
   3.417 +--- a/tests/tdiv.c	2013-03-13 16:37:44.000000000 +0100
   3.418 ++++ b/tests/tdiv.c	2014-12-31 14:56:02.689642010 +0100
   3.419 +@@ -1104,6 +1104,96 @@
   3.420 + #define RAND_FUNCTION(x) mpfr_random2(x, MPFR_LIMB_SIZE (x), randlimb () % 100, RANDS)
   3.421 + #include "tgeneric.c"
   3.422 + 
   3.423 ++static void
   3.424 ++test_extreme (void)
   3.425 ++{
   3.426 ++  mpfr_t x, y, z;
   3.427 ++  mpfr_exp_t emin, emax;
   3.428 ++  mpfr_prec_t p[4] = { 8, 32, 64, 256 };
   3.429 ++  int xi, yi, zi, j, r;
   3.430 ++  unsigned int flags, ex_flags;
   3.431 ++
   3.432 ++  emin = mpfr_get_emin ();
   3.433 ++  emax = mpfr_get_emax ();
   3.434 ++
   3.435 ++  mpfr_set_emin (MPFR_EMIN_MIN);
   3.436 ++  mpfr_set_emax (MPFR_EMAX_MAX);
   3.437 ++
   3.438 ++  for (xi = 0; xi < 4; xi++)
   3.439 ++    {
   3.440 ++      mpfr_init2 (x, p[xi]);
   3.441 ++      mpfr_setmax (x, MPFR_EMAX_MAX);
   3.442 ++      MPFR_ASSERTN (mpfr_check (x));
   3.443 ++      for (yi = 0; yi < 4; yi++)
   3.444 ++        {
   3.445 ++          mpfr_init2 (y, p[yi]);
   3.446 ++          mpfr_setmin (y, MPFR_EMIN_MIN);
   3.447 ++          for (j = 0; j < 2; j++)
   3.448 ++            {
   3.449 ++              MPFR_ASSERTN (mpfr_check (y));
   3.450 ++              for (zi = 0; zi < 4; zi++)
   3.451 ++                {
   3.452 ++                  mpfr_init2 (z, p[zi]);
   3.453 ++                  RND_LOOP (r)
   3.454 ++                    {
   3.455 ++                      mpfr_clear_flags ();
   3.456 ++                      mpfr_div (z, x, y, (mpfr_rnd_t) r);
   3.457 ++                      flags = __gmpfr_flags;
   3.458 ++                      MPFR_ASSERTN (mpfr_check (z));
   3.459 ++                      ex_flags = MPFR_FLAGS_OVERFLOW | MPFR_FLAGS_INEXACT;
   3.460 ++                      if (flags != ex_flags)
   3.461 ++                        {
   3.462 ++                          printf ("Bad flags in test_extreme on z = a/b"
   3.463 ++                                  " with %s and\n",
   3.464 ++                                  mpfr_print_rnd_mode ((mpfr_rnd_t) r));
   3.465 ++                          printf ("a = ");
   3.466 ++                          mpfr_dump (x);
   3.467 ++                          printf ("b = ");
   3.468 ++                          mpfr_dump (y);
   3.469 ++                          printf ("Expected flags:");
   3.470 ++                          flags_out (ex_flags);
   3.471 ++                          printf ("Got flags:     ");
   3.472 ++                          flags_out (flags);
   3.473 ++                          printf ("z = ");
   3.474 ++                          mpfr_dump (z);
   3.475 ++                          exit (1);
   3.476 ++                        }
   3.477 ++                      mpfr_clear_flags ();
   3.478 ++                      mpfr_div (z, y, x, (mpfr_rnd_t) r);
   3.479 ++                      flags = __gmpfr_flags;
   3.480 ++                      MPFR_ASSERTN (mpfr_check (z));
   3.481 ++                      ex_flags = MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT;
   3.482 ++                      if (flags != ex_flags)
   3.483 ++                        {
   3.484 ++                          printf ("Bad flags in test_extreme on z = a/b"
   3.485 ++                                  " with %s and\n",
   3.486 ++                                  mpfr_print_rnd_mode ((mpfr_rnd_t) r));
   3.487 ++                          printf ("a = ");
   3.488 ++                          mpfr_dump (y);
   3.489 ++                          printf ("b = ");
   3.490 ++                          mpfr_dump (x);
   3.491 ++                          printf ("Expected flags:");
   3.492 ++                          flags_out (ex_flags);
   3.493 ++                          printf ("Got flags:     ");
   3.494 ++                          flags_out (flags);
   3.495 ++                          printf ("z = ");
   3.496 ++                          mpfr_dump (z);
   3.497 ++                          exit (1);
   3.498 ++                        }
   3.499 ++                    }
   3.500 ++                  mpfr_clear (z);
   3.501 ++                }  /* zi */
   3.502 ++              mpfr_nextabove (y);
   3.503 ++            }  /* j */
   3.504 ++          mpfr_clear (y);
   3.505 ++        }  /* yi */
   3.506 ++      mpfr_clear (x);
   3.507 ++    }  /* xi */
   3.508 ++
   3.509 ++  set_emin (emin);
   3.510 ++  set_emax (emax);
   3.511 ++}
   3.512 ++
   3.513 + int
   3.514 + main (int argc, char *argv[])
   3.515 + {
   3.516 +@@ -1130,6 +1220,7 @@
   3.517 +   test_20070603 ();
   3.518 +   test_20070628 ();
   3.519 +   test_generic (2, 800, 50);
   3.520 ++  test_extreme ();
   3.521 + 
   3.522 +   tests_end_mpfr ();
   3.523 +   return 0;
   3.524 +--- a/tests/texp.c	2013-03-13 16:37:44.000000000 +0100
   3.525 ++++ b/tests/texp.c	2014-12-31 14:56:02.689642010 +0100
   3.526 +@@ -150,6 +150,22 @@
   3.527 +       exit (1);
   3.528 +     }
   3.529 + 
   3.530 ++  mpfr_set_prec (x, 118);
   3.531 ++  mpfr_set_str_binary (x, "0.1110010100011101010000111110011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E-86");
   3.532 ++  mpfr_set_prec (y, 118);
   3.533 ++  mpfr_exp_2 (y, x, MPFR_RNDU);
   3.534 ++  mpfr_exp_3 (x, x, MPFR_RNDU);
   3.535 ++  if (mpfr_cmp (x, y))
   3.536 ++    {
   3.537 ++      printf ("mpfr_exp_2 and mpfr_exp_3 differ for prec=118\n");
   3.538 ++      printf ("mpfr_exp_2 gives ");
   3.539 ++      mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
   3.540 ++      printf ("\nmpfr_exp_3 gives ");
   3.541 ++      mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
   3.542 ++      printf ("\n");
   3.543 ++      exit (1);
   3.544 ++    }
   3.545 ++
   3.546 +   mpfr_clear (x);
   3.547 +   mpfr_clear (y);
   3.548 +   return 0;
   3.549 +--- a/tests/tfits.c	2013-03-13 16:37:45.000000000 +0100
   3.550 ++++ b/tests/tfits.c	2014-12-31 14:56:02.689642010 +0100
   3.551 +@@ -33,155 +33,176 @@
   3.552 + #include "mpfr-intmax.h"
   3.553 + #include "mpfr-test.h"
   3.554 + 
   3.555 +-#define ERROR1 { printf("Initial error for x="); mpfr_dump(x); exit(1); }
   3.556 +-#define ERROR2 { printf("Error for x="); mpfr_dump(x); exit(1); }
   3.557 ++#define ERROR1(N)                                               \
   3.558 ++  do                                                            \
   3.559 ++    {                                                           \
   3.560 ++      printf("Error %d for rnd = %s and x = ", N,               \
   3.561 ++             mpfr_print_rnd_mode ((mpfr_rnd_t) r));             \
   3.562 ++      mpfr_dump(x);                                             \
   3.563 ++      exit(1);                                                  \
   3.564 ++    }                                                           \
   3.565 ++  while (0)
   3.566 + 
   3.567 + static void check_intmax (void);
   3.568 + 
   3.569 + int
   3.570 + main (void)
   3.571 + {
   3.572 +-  mpfr_t x;
   3.573 ++  mpfr_t x, y;
   3.574 ++  int i, r;
   3.575 + 
   3.576 +   tests_start_mpfr ();
   3.577 + 
   3.578 +   mpfr_init2 (x, 256);
   3.579 ++  mpfr_init2 (y, 8);
   3.580 + 
   3.581 +-  /* Check NAN */
   3.582 +-  mpfr_set_nan (x);
   3.583 +-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
   3.584 +-    ERROR1;
   3.585 +-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
   3.586 +-    ERROR1;
   3.587 +-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
   3.588 +-    ERROR1;
   3.589 +-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
   3.590 +-    ERROR1;
   3.591 +-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
   3.592 +-    ERROR1;
   3.593 +-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
   3.594 +-    ERROR1;
   3.595 +-
   3.596 +-  /* Check INF */
   3.597 +-  mpfr_set_inf (x, 1);
   3.598 +-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
   3.599 +-    ERROR1;
   3.600 +-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
   3.601 +-    ERROR1;
   3.602 +-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
   3.603 +-    ERROR1;
   3.604 +-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
   3.605 +-    ERROR1;
   3.606 +-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
   3.607 +-    ERROR1;
   3.608 +-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
   3.609 +-    ERROR1;
   3.610 +-
   3.611 +-  /* Check Zero */
   3.612 +-  MPFR_SET_ZERO (x);
   3.613 +-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
   3.614 +-    ERROR2;
   3.615 +-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
   3.616 +-    ERROR2;
   3.617 +-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
   3.618 +-    ERROR2;
   3.619 +-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
   3.620 +-    ERROR2;
   3.621 +-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
   3.622 +-    ERROR2;
   3.623 +-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
   3.624 +-    ERROR2;
   3.625 +-
   3.626 +-  /* Check small op */
   3.627 +-  mpfr_set_str1 (x, "1@-1");
   3.628 +-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
   3.629 +-    ERROR2;
   3.630 +-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
   3.631 +-    ERROR2;
   3.632 +-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
   3.633 +-    ERROR2;
   3.634 +-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
   3.635 +-    ERROR2;
   3.636 +-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
   3.637 +-    ERROR2;
   3.638 +-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
   3.639 +-    ERROR2;
   3.640 +-
   3.641 +-  /* Check 17 */
   3.642 +-  mpfr_set_ui (x, 17, MPFR_RNDN);
   3.643 +-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
   3.644 +-    ERROR2;
   3.645 +-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
   3.646 +-    ERROR2;
   3.647 +-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
   3.648 +-    ERROR2;
   3.649 +-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
   3.650 +-    ERROR2;
   3.651 +-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
   3.652 +-    ERROR2;
   3.653 +-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
   3.654 +-    ERROR2;
   3.655 +-
   3.656 +-  /* Check all other values */
   3.657 +-  mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
   3.658 +-  mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
   3.659 +-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
   3.660 +-    ERROR1;
   3.661 +-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
   3.662 +-    ERROR1;
   3.663 +-  mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
   3.664 +-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
   3.665 +-    ERROR1;
   3.666 +-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
   3.667 +-    ERROR1;
   3.668 +-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
   3.669 +-    ERROR1;
   3.670 +-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
   3.671 +-    ERROR1;
   3.672 +-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
   3.673 +-    ERROR1;
   3.674 +-
   3.675 +-  mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
   3.676 +-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
   3.677 +-    ERROR2;
   3.678 +-  mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
   3.679 +-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
   3.680 +-    ERROR2;
   3.681 +-  mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
   3.682 +-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
   3.683 +-    ERROR2;
   3.684 +-  mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
   3.685 +-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
   3.686 +-    ERROR2;
   3.687 +-  mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
   3.688 +-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
   3.689 +-    ERROR2;
   3.690 +-  mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
   3.691 +-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
   3.692 +-    ERROR2;
   3.693 +-
   3.694 +-  mpfr_set_si (x, 1, MPFR_RNDN);
   3.695 +-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
   3.696 +-    ERROR2;
   3.697 +-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
   3.698 +-    ERROR2;
   3.699 +-
   3.700 +-  /* Check negative value */
   3.701 +-  mpfr_set_si (x, -1, MPFR_RNDN);
   3.702 +-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
   3.703 +-    ERROR2;
   3.704 +-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
   3.705 +-    ERROR2;
   3.706 +-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
   3.707 +-    ERROR2;
   3.708 +-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
   3.709 +-    ERROR1;
   3.710 +-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
   3.711 +-    ERROR1;
   3.712 +-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
   3.713 +-    ERROR1;
   3.714 ++  RND_LOOP (r)
   3.715 ++    {
   3.716 ++
   3.717 ++      /* Check NAN */
   3.718 ++      mpfr_set_nan (x);
   3.719 ++      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
   3.720 ++        ERROR1 (1);
   3.721 ++      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
   3.722 ++        ERROR1 (2);
   3.723 ++      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
   3.724 ++        ERROR1 (3);
   3.725 ++      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
   3.726 ++        ERROR1 (4);
   3.727 ++      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
   3.728 ++        ERROR1 (5);
   3.729 ++      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
   3.730 ++        ERROR1 (6);
   3.731 ++
   3.732 ++      /* Check INF */
   3.733 ++      mpfr_set_inf (x, 1);
   3.734 ++      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
   3.735 ++        ERROR1 (7);
   3.736 ++      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
   3.737 ++        ERROR1 (8);
   3.738 ++      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
   3.739 ++        ERROR1 (9);
   3.740 ++      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
   3.741 ++        ERROR1 (10);
   3.742 ++      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
   3.743 ++        ERROR1 (11);
   3.744 ++      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
   3.745 ++        ERROR1 (12);
   3.746 ++
   3.747 ++      /* Check Zero */
   3.748 ++      MPFR_SET_ZERO (x);
   3.749 ++      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
   3.750 ++        ERROR1 (13);
   3.751 ++      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
   3.752 ++        ERROR1 (14);
   3.753 ++      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
   3.754 ++        ERROR1 (15);
   3.755 ++      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
   3.756 ++        ERROR1 (16);
   3.757 ++      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
   3.758 ++        ERROR1 (17);
   3.759 ++      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
   3.760 ++        ERROR1 (18);
   3.761 ++
   3.762 ++      /* Check small positive op */
   3.763 ++      mpfr_set_str1 (x, "1@-1");
   3.764 ++      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
   3.765 ++        ERROR1 (19);
   3.766 ++      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
   3.767 ++        ERROR1 (20);
   3.768 ++      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
   3.769 ++        ERROR1 (21);
   3.770 ++      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
   3.771 ++        ERROR1 (22);
   3.772 ++      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
   3.773 ++        ERROR1 (23);
   3.774 ++      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
   3.775 ++        ERROR1 (24);
   3.776 ++
   3.777 ++      /* Check 17 */
   3.778 ++      mpfr_set_ui (x, 17, MPFR_RNDN);
   3.779 ++      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
   3.780 ++        ERROR1 (25);
   3.781 ++      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
   3.782 ++        ERROR1 (26);
   3.783 ++      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
   3.784 ++        ERROR1 (27);
   3.785 ++      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
   3.786 ++        ERROR1 (28);
   3.787 ++      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
   3.788 ++        ERROR1 (29);
   3.789 ++      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
   3.790 ++        ERROR1 (30);
   3.791 ++
   3.792 ++      /* Check all other values */
   3.793 ++      mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
   3.794 ++      mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
   3.795 ++      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
   3.796 ++        ERROR1 (31);
   3.797 ++      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
   3.798 ++        ERROR1 (32);
   3.799 ++      mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
   3.800 ++      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
   3.801 ++        ERROR1 (33);
   3.802 ++      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
   3.803 ++        ERROR1 (34);
   3.804 ++      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
   3.805 ++        ERROR1 (35);
   3.806 ++      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
   3.807 ++        ERROR1 (36);
   3.808 ++      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
   3.809 ++        ERROR1 (37);
   3.810 ++
   3.811 ++      mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
   3.812 ++      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
   3.813 ++        ERROR1 (38);
   3.814 ++      mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
   3.815 ++      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
   3.816 ++        ERROR1 (39);
   3.817 ++      mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
   3.818 ++      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
   3.819 ++        ERROR1 (40);
   3.820 ++      mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
   3.821 ++      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
   3.822 ++        ERROR1 (41);
   3.823 ++      mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
   3.824 ++      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
   3.825 ++        ERROR1 (42);
   3.826 ++      mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
   3.827 ++      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
   3.828 ++        ERROR1 (43);
   3.829 ++
   3.830 ++      mpfr_set_si (x, 1, MPFR_RNDN);
   3.831 ++      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
   3.832 ++        ERROR1 (44);
   3.833 ++      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
   3.834 ++        ERROR1 (45);
   3.835 ++
   3.836 ++      /* Check negative op */
   3.837 ++      for (i = 1; i <= 4; i++)
   3.838 ++        {
   3.839 ++          int inv;
   3.840 ++
   3.841 ++          mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
   3.842 ++          mpfr_rint (y, x, (mpfr_rnd_t) r);
   3.843 ++          inv = MPFR_NOTZERO (y);
   3.844 ++          if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r) ^ inv)
   3.845 ++            ERROR1 (46);
   3.846 ++          if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
   3.847 ++            ERROR1 (47);
   3.848 ++          if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r) ^ inv)
   3.849 ++            ERROR1 (48);
   3.850 ++          if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
   3.851 ++            ERROR1 (49);
   3.852 ++          if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r) ^ inv)
   3.853 ++            ERROR1 (50);
   3.854 ++          if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
   3.855 ++            ERROR1 (51);
   3.856 ++        }
   3.857 ++    }
   3.858 + 
   3.859 +   mpfr_clear (x);
   3.860 ++  mpfr_clear (y);
   3.861 + 
   3.862 +   check_intmax ();
   3.863 + 
   3.864 +@@ -189,85 +210,98 @@
   3.865 +   return 0;
   3.866 + }
   3.867 + 
   3.868 +-static void check_intmax (void)
   3.869 ++static void
   3.870 ++check_intmax (void)
   3.871 + {
   3.872 + #ifdef _MPFR_H_HAVE_INTMAX_T
   3.873 +-  mpfr_t x;
   3.874 ++  mpfr_t x, y;
   3.875 ++  int i, r;
   3.876 + 
   3.877 +-  mpfr_init2 (x, sizeof (uintmax_t)*CHAR_BIT);
   3.878 ++  mpfr_init2 (x, sizeof (uintmax_t) * CHAR_BIT);
   3.879 ++  mpfr_init2 (y, 8);
   3.880 + 
   3.881 +-  /* Check NAN */
   3.882 +-  mpfr_set_nan (x);
   3.883 +-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
   3.884 +-    ERROR1;
   3.885 +-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.886 +-    ERROR1;
   3.887 +-
   3.888 +-  /* Check INF */
   3.889 +-  mpfr_set_inf (x, 1);
   3.890 +-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
   3.891 +-    ERROR1;
   3.892 +-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.893 +-    ERROR1;
   3.894 +-
   3.895 +-  /* Check Zero */
   3.896 +-  MPFR_SET_ZERO (x);
   3.897 +-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
   3.898 +-    ERROR2;
   3.899 +-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.900 +-    ERROR2;
   3.901 +-
   3.902 +-  /* Check small op */
   3.903 +-  mpfr_set_str1 (x, "1@-1");
   3.904 +-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
   3.905 +-    ERROR2;
   3.906 +-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.907 +-    ERROR2;
   3.908 +-
   3.909 +-  /* Check 17 */
   3.910 +-  mpfr_set_ui (x, 17, MPFR_RNDN);
   3.911 +-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
   3.912 +-    ERROR2;
   3.913 +-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.914 +-    ERROR2;
   3.915 +-
   3.916 +-  /* Check hugest */
   3.917 +-  mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
   3.918 +-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
   3.919 +-    ERROR1;
   3.920 +-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.921 +-    ERROR1;
   3.922 +-
   3.923 +-  /* Check all other values */
   3.924 +-  mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
   3.925 +-  mpfr_add_ui (x, x, 1, MPFR_RNDN);
   3.926 +-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
   3.927 +-    ERROR1;
   3.928 +-  mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
   3.929 +-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
   3.930 +-    ERROR2;
   3.931 +-  mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
   3.932 +-  mpfr_add_ui (x, x, 1, MPFR_RNDN);
   3.933 +-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.934 +-    ERROR1;
   3.935 +-  mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
   3.936 +-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.937 +-    ERROR2;
   3.938 +-  mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
   3.939 +-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.940 +-    ERROR2;
   3.941 +-  mpfr_sub_ui (x, x, 1, MPFR_RNDN);
   3.942 +-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.943 +-    ERROR1;
   3.944 +-
   3.945 +-  /* Check negative value */
   3.946 +-  mpfr_set_si (x, -1, MPFR_RNDN);
   3.947 +-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
   3.948 +-    ERROR2;
   3.949 +-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
   3.950 +-    ERROR1;
   3.951 ++  RND_LOOP (r)
   3.952 ++    {
   3.953 ++      /* Check NAN */
   3.954 ++      mpfr_set_nan (x);
   3.955 ++      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
   3.956 ++        ERROR1 (52);
   3.957 ++      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
   3.958 ++        ERROR1 (53);
   3.959 ++
   3.960 ++      /* Check INF */
   3.961 ++      mpfr_set_inf (x, 1);
   3.962 ++      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
   3.963 ++        ERROR1 (54);
   3.964 ++      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
   3.965 ++        ERROR1 (55);
   3.966 ++
   3.967 ++      /* Check Zero */
   3.968 ++      MPFR_SET_ZERO (x);
   3.969 ++      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
   3.970 ++        ERROR1 (56);
   3.971 ++      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
   3.972 ++        ERROR1 (57);
   3.973 ++
   3.974 ++      /* Check positive small op */
   3.975 ++      mpfr_set_str1 (x, "1@-1");
   3.976 ++      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
   3.977 ++        ERROR1 (58);
   3.978 ++      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
   3.979 ++        ERROR1 (59);
   3.980 ++
   3.981 ++      /* Check 17 */
   3.982 ++      mpfr_set_ui (x, 17, MPFR_RNDN);
   3.983 ++      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
   3.984 ++        ERROR1 (60);
   3.985 ++      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
   3.986 ++        ERROR1 (61);
   3.987 ++
   3.988 ++      /* Check hugest */
   3.989 ++      mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
   3.990 ++      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
   3.991 ++        ERROR1 (62);
   3.992 ++      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
   3.993 ++        ERROR1 (63);
   3.994 ++
   3.995 ++      /* Check all other values */
   3.996 ++      mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
   3.997 ++      mpfr_add_ui (x, x, 1, MPFR_RNDN);
   3.998 ++      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
   3.999 ++        ERROR1 (64);
  3.1000 ++      mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
  3.1001 ++      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
  3.1002 ++        ERROR1 (65);
  3.1003 ++      mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
  3.1004 ++      mpfr_add_ui (x, x, 1, MPFR_RNDN);
  3.1005 ++      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
  3.1006 ++        ERROR1 (66);
  3.1007 ++      mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
  3.1008 ++      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
  3.1009 ++        ERROR1 (67);
  3.1010 ++      mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
  3.1011 ++      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
  3.1012 ++        ERROR1 (68);
  3.1013 ++      mpfr_sub_ui (x, x, 1, MPFR_RNDN);
  3.1014 ++      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
  3.1015 ++        ERROR1 (69);
  3.1016 ++
  3.1017 ++      /* Check negative op */
  3.1018 ++      for (i = 1; i <= 4; i++)
  3.1019 ++        {
  3.1020 ++          int inv;
  3.1021 ++
  3.1022 ++          mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
  3.1023 ++          mpfr_rint (y, x, (mpfr_rnd_t) r);
  3.1024 ++          inv = MPFR_NOTZERO (y);
  3.1025 ++          if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r) ^ inv)
  3.1026 ++            ERROR1 (70);
  3.1027 ++          if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
  3.1028 ++            ERROR1 (71);
  3.1029 ++        }
  3.1030 ++    }
  3.1031 + 
  3.1032 +   mpfr_clear (x);
  3.1033 ++  mpfr_clear (y);
  3.1034 + #endif
  3.1035 + }
  3.1036 +-
  3.1037 +--- a/tests/tget_flt.c	2013-03-13 16:37:44.000000000 +0100
  3.1038 ++++ b/tests/tget_flt.c	2014-12-31 14:56:02.690642023 +0100
  3.1039 +@@ -28,9 +28,17 @@
  3.1040 + main (void)
  3.1041 + {
  3.1042 +   mpfr_t x, y;
  3.1043 +-  float f, g, infp;
  3.1044 ++  float f, g;
  3.1045 +   int i;
  3.1046 ++#if !defined(MPFR_ERRDIVZERO)
  3.1047 ++  float infp;
  3.1048 ++#endif
  3.1049 + 
  3.1050 ++  tests_start_mpfr ();
  3.1051 ++
  3.1052 ++#if !defined(MPFR_ERRDIVZERO)
  3.1053 ++  /* The definition of DBL_POS_INF involves a division by 0. This makes
  3.1054 ++     "clang -O2 -fsanitize=undefined -fno-sanitize-recover" fail. */
  3.1055 +   infp = (float) DBL_POS_INF;
  3.1056 +   if (infp * 0.5 != infp)
  3.1057 +     {
  3.1058 +@@ -38,8 +46,7 @@
  3.1059 +       fprintf (stderr, "(this is probably a compiler bug, please report)\n");
  3.1060 +       exit (1);
  3.1061 +     }
  3.1062 +-
  3.1063 +-  tests_start_mpfr ();
  3.1064 ++#endif
  3.1065 + 
  3.1066 +   mpfr_init2 (x, 24);
  3.1067 +   mpfr_init2 (y, 24);
  3.1068 +@@ -353,6 +360,7 @@
  3.1069 +       printf ("expected %.8e, got %.8e\n", g, f);
  3.1070 +       exit (1);
  3.1071 +     }
  3.1072 ++#if !defined(MPFR_ERRDIVZERO)
  3.1073 +   f = mpfr_get_flt (x, MPFR_RNDN); /* first round to 2^128 (even rule),
  3.1074 +                                       thus we should get +Inf */
  3.1075 +   g = infp;
  3.1076 +@@ -376,6 +384,7 @@
  3.1077 +       printf ("expected %.8e, got %.8e\n", g, f);
  3.1078 +       exit (1);
  3.1079 +     }
  3.1080 ++#endif
  3.1081 + 
  3.1082 +   mpfr_clear (x);
  3.1083 +   mpfr_clear (y);
  3.1084 +--- a/tests/tset_ld.c	2013-03-13 16:37:44.000000000 +0100
  3.1085 ++++ b/tests/tset_ld.c	2014-12-31 14:56:02.690642023 +0100
  3.1086 +@@ -47,8 +47,11 @@
  3.1087 + static int
  3.1088 + Isnan_ld (long double d)
  3.1089 + {
  3.1090 +-  double e = (double) d;
  3.1091 +-  if (DOUBLE_ISNAN (e))
  3.1092 ++  /* Do not convert d to double as this can give an overflow, which
  3.1093 ++     may confuse compilers without IEEE 754 support (such as clang
  3.1094 ++     -fsanitize=undefined), or trigger a trap if enabled.
  3.1095 ++     The DOUBLE_ISNAN macro should work fine on long double. */
  3.1096 ++  if (DOUBLE_ISNAN (d))
  3.1097 +     return 1;
  3.1098 +   LONGDOUBLE_NAN_ACTION (d, goto yes);
  3.1099 +   return 0;
  3.1100 +--- a/tests/tsprintf.c	2013-03-13 16:37:44.000000000 +0100
  3.1101 ++++ b/tests/tsprintf.c	2014-12-31 14:56:02.690642023 +0100
  3.1102 +@@ -456,10 +456,16 @@
  3.1103 +   check_sprintf ("1.999900  ", "%-#10.7RG", x);
  3.1104 +   check_sprintf ("1.9999    ", "%-10.7RG", x);
  3.1105 +   mpfr_set_ui (x, 1, MPFR_RNDN);
  3.1106 ++  check_sprintf ("1.", "%#.1Rg", x);
  3.1107 ++  check_sprintf ("1.   ", "%-#5.1Rg", x);
  3.1108 ++  check_sprintf ("  1.0", "%#5.2Rg", x);
  3.1109 +   check_sprintf ("1.00000000000000000000000000000", "%#.30Rg", x);
  3.1110 +   check_sprintf ("1", "%.30Rg", x);
  3.1111 +   mpfr_set_ui (x, 0, MPFR_RNDN);
  3.1112 +-  check_sprintf ("0.000000000000000000000000000000", "%#.30Rg", x);
  3.1113 ++  check_sprintf ("0.", "%#.1Rg", x);
  3.1114 ++  check_sprintf ("0.   ", "%-#5.1Rg", x);
  3.1115 ++  check_sprintf ("  0.0", "%#5.2Rg", x);
  3.1116 ++  check_sprintf ("0.00000000000000000000000000000", "%#.30Rg", x);
  3.1117 +   check_sprintf ("0", "%.30Rg", x);
  3.1118 + 
  3.1119 +   /* following tests with precision 53 bits */
  3.1120 +@@ -1178,6 +1184,69 @@
  3.1121 +   check_emax_aux (MPFR_EMAX_MAX);
  3.1122 + }
  3.1123 + 
  3.1124 ++static void
  3.1125 ++check_emin_aux (mpfr_exp_t e)
  3.1126 ++{
  3.1127 ++  mpfr_t x;
  3.1128 ++  char *s1, s2[256];
  3.1129 ++  int i;
  3.1130 ++  mpfr_exp_t emin;
  3.1131 ++  mpz_t ee;
  3.1132 ++
  3.1133 ++  MPFR_ASSERTN (e >= LONG_MIN);
  3.1134 ++  emin = mpfr_get_emin ();
  3.1135 ++  set_emin (e);
  3.1136 ++
  3.1137 ++  mpfr_init2 (x, 16);
  3.1138 ++  mpz_init (ee);
  3.1139 ++
  3.1140 ++  mpfr_setmin (x, e);
  3.1141 ++  mpz_set_si (ee, e);
  3.1142 ++  mpz_sub_ui (ee, ee, 1);
  3.1143 ++
  3.1144 ++  i = mpfr_asprintf (&s1, "%Ra", x);
  3.1145 ++  MPFR_ASSERTN (i > 0);
  3.1146 ++
  3.1147 ++  gmp_snprintf (s2, 256, "0x1p%Zd", ee);
  3.1148 ++
  3.1149 ++  if (strcmp (s1, s2) != 0)
  3.1150 ++    {
  3.1151 ++      printf ("Error in check_emin_aux for emin = %ld\n", (long) e);
  3.1152 ++      printf ("Expected %s\n", s2);
  3.1153 ++      printf ("Got      %s\n", s1);
  3.1154 ++      exit (1);
  3.1155 ++    }
  3.1156 ++
  3.1157 ++  mpfr_free_str (s1);
  3.1158 ++
  3.1159 ++  i = mpfr_asprintf (&s1, "%Rb", x);
  3.1160 ++  MPFR_ASSERTN (i > 0);
  3.1161 ++
  3.1162 ++  gmp_snprintf (s2, 256, "1p%Zd", ee);
  3.1163 ++
  3.1164 ++  if (strcmp (s1, s2) != 0)
  3.1165 ++    {
  3.1166 ++      printf ("Error in check_emin_aux for emin = %ld\n", (long) e);
  3.1167 ++      printf ("Expected %s\n", s2);
  3.1168 ++      printf ("Got      %s\n", s1);
  3.1169 ++      exit (1);
  3.1170 ++    }
  3.1171 ++
  3.1172 ++  mpfr_free_str (s1);
  3.1173 ++
  3.1174 ++  mpfr_clear (x);
  3.1175 ++  mpz_clear (ee);
  3.1176 ++  set_emin (emin);
  3.1177 ++}
  3.1178 ++
  3.1179 ++static void
  3.1180 ++check_emin (void)
  3.1181 ++{
  3.1182 ++  check_emin_aux (-15);
  3.1183 ++  check_emin_aux (mpfr_get_emin ());
  3.1184 ++  check_emin_aux (MPFR_EMIN_MIN);
  3.1185 ++}
  3.1186 ++
  3.1187 + int
  3.1188 + main (int argc, char **argv)
  3.1189 + {
  3.1190 +@@ -1197,6 +1266,7 @@
  3.1191 +   decimal ();
  3.1192 +   mixed ();
  3.1193 +   check_emax ();
  3.1194 ++  check_emin ();
  3.1195 + 
  3.1196 + #if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
  3.1197 +   locale_da_DK ();
  3.1198 +--- a/VERSION	2013-03-13 16:37:28.000000000 +0100
  3.1199 ++++ b/VERSION	2014-12-31 14:56:02.690642023 +0100
  3.1200 +@@ -1 +1 @@
  3.1201 +-3.1.2
  3.1202 ++3.1.2-p11