Submitted By: Bruce Dubbs Date: 2014-08-04 Initial Package Version: 3.1.2 Upstream Status: Already in upstream patch repo Origin: Upstream Description: This patch contains patches for several bugs in MPFR. Note that the patch for configure.ac has been removed to prevent unneeded regeneration of build files. See http://www.mpfr.org/mpfr-current/allpatches --- a/PATCHES 2013-03-13 16:37:38.000000000 +0100 +++ b/PATCHES 2014-08-04 16:44:01.125172770 +0200 @@ -0,0 +1,10 @@ +vasprintf +div-overflow +gmp6-compat +exp3 +li2-return +custom_init_set +printf-alt0 +clang-divby0 +fits-smallneg +exp_2 --- a/src/div.c 2013-03-13 16:37:33.000000000 +0100 +++ b/src/div.c 2014-08-04 16:44:01.125172770 +0200 @@ -750,7 +750,9 @@ truncate_check_qh: if (qh) { - qexp ++; + if (MPFR_LIKELY (qexp < MPFR_EXP_MAX)) + qexp ++; + /* else qexp is now incorrect, but one will still get an overflow */ q0p[q0size - 1] = MPFR_LIMB_HIGHBIT; } goto truncate; @@ -765,7 +767,9 @@ inex = 1; /* always here */ if (mpn_add_1 (q0p, q0p, q0size, MPFR_LIMB_ONE << sh)) { - qexp ++; + if (MPFR_LIKELY (qexp < MPFR_EXP_MAX)) + qexp ++; + /* else qexp is now incorrect, but one will still get an overflow */ q0p[q0size - 1] = MPFR_LIMB_HIGHBIT; } --- a/src/exp_2.c 2013-03-13 16:37:28.000000000 +0100 +++ b/src/exp_2.c 2014-08-04 16:44:01.125172770 +0200 @@ -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); --- a/src/exp3.c 2013-03-13 16:37:34.000000000 +0100 +++ b/src/exp3.c 2014-08-04 16:44:01.125172770 +0200 @@ -283,7 +283,7 @@ } } - if (mpfr_can_round (shift_x > 0 ? t : tmp, realprec, MPFR_RNDD, MPFR_RNDZ, + if (mpfr_can_round (shift_x > 0 ? t : tmp, realprec, MPFR_RNDN, MPFR_RNDZ, MPFR_PREC(y) + (rnd_mode == MPFR_RNDN))) { inexact = mpfr_set (y, shift_x > 0 ? t : tmp, rnd_mode); --- a/src/fits_u.h 2013-03-13 16:37:35.000000000 +0100 +++ b/src/fits_u.h 2014-08-04 16:44:01.125172770 +0200 @@ -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 ++); --- a/src/fits_uintmax.c 2013-03-13 16:37:33.000000000 +0100 +++ b/src/fits_uintmax.c 2014-08-04 16:44:01.126172775 +0200 @@ -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); +/* 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". */ - /* 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; - - /* 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 --- a/src/init2.c 2013-03-13 16:37:32.000000000 +0100 +++ b/src/init2.c 2014-08-04 16:44:01.126172775 +0200 @@ -30,11 +30,11 @@ /* Check if we can represent the number of limbs * associated to the maximum of mpfr_prec_t*/ - MPFR_ASSERTN( MP_SIZE_T_MAX >= (MPFR_PREC_MAX/BYTES_PER_MP_LIMB) ); + MPFR_ASSERTN( MP_SIZE_T_MAX >= (MPFR_PREC_MAX/MPFR_BYTES_PER_MP_LIMB) ); - /* Check for correct GMP_NUMB_BITS and BYTES_PER_MP_LIMB */ - MPFR_ASSERTN( GMP_NUMB_BITS == BYTES_PER_MP_LIMB * CHAR_BIT - && sizeof(mp_limb_t) == BYTES_PER_MP_LIMB ); + /* Check for correct GMP_NUMB_BITS and MPFR_BYTES_PER_MP_LIMB */ + MPFR_ASSERTN( GMP_NUMB_BITS == MPFR_BYTES_PER_MP_LIMB * CHAR_BIT + && sizeof(mp_limb_t) == MPFR_BYTES_PER_MP_LIMB ); MPFR_ASSERTN (mp_bits_per_limb == GMP_NUMB_BITS); --- a/src/li2.c 2013-03-13 16:37:32.000000000 +0100 +++ b/src/li2.c 2014-08-04 16:44:01.126172775 +0200 @@ -630,5 +630,5 @@ return mpfr_check_range (y, inexact, rnd_mode); } - MPFR_ASSERTN (0); /* should never reach this point */ + MPFR_RET_NEVER_GO_HERE (); } --- a/src/mpfr-gmp.h 2013-03-13 16:37:32.000000000 +0100 +++ b/src/mpfr-gmp.h 2014-08-04 16:44:01.126172775 +0200 @@ -72,7 +72,6 @@ #endif /* Define some macros */ -#define BYTES_PER_MP_LIMB (GMP_NUMB_BITS/CHAR_BIT) #define MP_LIMB_T_MAX (~(mp_limb_t)0) @@ -96,19 +95,19 @@ #define SHRT_HIGHBIT SHRT_MIN /* MP_LIMB macros */ -#define MPN_ZERO(dst, n) memset((dst), 0, (n)*BYTES_PER_MP_LIMB) -#define MPN_COPY_DECR(dst,src,n) memmove((dst),(src),(n)*BYTES_PER_MP_LIMB) -#define MPN_COPY_INCR(dst,src,n) memmove((dst),(src),(n)*BYTES_PER_MP_LIMB) +#define MPN_ZERO(dst, n) memset((dst), 0, (n)*MPFR_BYTES_PER_MP_LIMB) +#define MPN_COPY_DECR(dst,src,n) memmove((dst),(src),(n)*MPFR_BYTES_PER_MP_LIMB) +#define MPN_COPY_INCR(dst,src,n) memmove((dst),(src),(n)*MPFR_BYTES_PER_MP_LIMB) #define MPN_COPY(dst,src,n) \ do \ { \ if ((dst) != (src)) \ { \ MPFR_ASSERTD ((char *) (dst) >= (char *) (src) + \ - (n) * BYTES_PER_MP_LIMB || \ + (n) * MPFR_BYTES_PER_MP_LIMB || \ (char *) (src) >= (char *) (dst) + \ - (n) * BYTES_PER_MP_LIMB); \ - memcpy ((dst), (src), (n) * BYTES_PER_MP_LIMB); \ + (n) * MPFR_BYTES_PER_MP_LIMB); \ + memcpy ((dst), (src), (n) * MPFR_BYTES_PER_MP_LIMB); \ } \ } \ while (0) --- a/src/mpfr.h 2013-03-13 16:37:37.000000000 +0100 +++ b/src/mpfr.h 2014-08-04 16:44:01.126172775 +0200 @@ -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-p10" /* 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) : \ --- a/src/mpfr-impl.h 2013-03-13 16:37:36.000000000 +0100 +++ b/src/mpfr-impl.h 2014-08-04 16:44:01.127172781 +0200 @@ -191,7 +191,7 @@ # endif #endif - +#define MPFR_BYTES_PER_MP_LIMB (GMP_NUMB_BITS/CHAR_BIT) /****************************************************** ******************** Check GMP *********************** @@ -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 @@ -920,7 +930,7 @@ #define MPFR_SET_ALLOC_SIZE(x, n) \ ( ((mp_size_t*) MPFR_MANT(x))[-1] = n) #define MPFR_MALLOC_SIZE(s) \ - ( sizeof(mpfr_size_limb_t) + BYTES_PER_MP_LIMB * ((size_t) s) ) + ( sizeof(mpfr_size_limb_t) + MPFR_BYTES_PER_MP_LIMB * ((size_t) s) ) #define MPFR_SET_MANT_PTR(x,p) \ (MPFR_MANT(x) = (mp_limb_t*) ((mpfr_size_limb_t*) p + 1)) #define MPFR_GET_REAL_PTR(x) \ @@ -954,7 +964,7 @@ #endif #define MPFR_TMP_LIMBS_ALLOC(N) \ - ((mp_limb_t *) MPFR_TMP_ALLOC ((size_t) (N) * BYTES_PER_MP_LIMB)) + ((mp_limb_t *) MPFR_TMP_ALLOC ((size_t) (N) * MPFR_BYTES_PER_MP_LIMB)) /* temporary allocate 1 limb at xp, and initialize mpfr variable x */ /* The temporary var doesn't have any size field, but it doesn't matter --- a/src/mul.c 2013-03-13 16:37:37.000000000 +0100 +++ b/src/mul.c 2014-08-04 16:44:01.127172781 +0200 @@ -106,7 +106,7 @@ MPFR_ASSERTD(tn <= k); /* Check for no size_t overflow*/ - MPFR_ASSERTD((size_t) k <= ((size_t) -1) / BYTES_PER_MP_LIMB); + MPFR_ASSERTD((size_t) k <= ((size_t) -1) / MPFR_BYTES_PER_MP_LIMB); MPFR_TMP_MARK(marker); tmp = MPFR_TMP_LIMBS_ALLOC (k); @@ -301,7 +301,7 @@ MPFR_ASSERTD (tn <= k); /* tn <= k, thus no int overflow */ /* Check for no size_t overflow*/ - MPFR_ASSERTD ((size_t) k <= ((size_t) -1) / BYTES_PER_MP_LIMB); + MPFR_ASSERTD ((size_t) k <= ((size_t) -1) / MPFR_BYTES_PER_MP_LIMB); MPFR_TMP_MARK (marker); tmp = MPFR_TMP_LIMBS_ALLOC (k); --- a/src/stack_interface.c 2013-03-13 16:37:32.000000000 +0100 +++ b/src/stack_interface.c 2014-08-04 16:44:01.127172781 +0200 @@ -26,7 +26,7 @@ size_t mpfr_custom_get_size (mpfr_prec_t prec) { - return MPFR_PREC2LIMBS (prec) * BYTES_PER_MP_LIMB; + return MPFR_PREC2LIMBS (prec) * MPFR_BYTES_PER_MP_LIMB; } #undef mpfr_custom_init --- a/src/vasprintf.c 2013-03-13 16:37:37.000000000 +0100 +++ b/src/vasprintf.c 2014-08-04 16:44:01.127172781 +0200 @@ -884,14 +884,18 @@ first digit, we want the exponent for radix two and the decimal point AFTER the first digit. */ { - MPFR_ASSERTN (exp > MPFR_EMIN_MIN /4); /* possible overflow */ + /* An integer overflow is normally not possible since MPFR_EXP_MIN + is twice as large as MPFR_EMIN_MIN. */ + MPFR_ASSERTN (exp > (MPFR_EXP_MIN + 3) / 4); exp = (exp - 1) * 4; } else /* EXP is the exponent for decimal point BEFORE the first digit, we want the exponent for decimal point AFTER the first digit. */ { - MPFR_ASSERTN (exp > MPFR_EMIN_MIN); /* possible overflow */ + /* An integer overflow is normally not possible since MPFR_EXP_MIN + is twice as large as MPFR_EMIN_MIN. */ + MPFR_ASSERTN (exp > MPFR_EXP_MIN); --exp; } } @@ -1040,7 +1044,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 +1171,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 +1563,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) --- a/src/version.c 2013-03-13 16:37:34.000000000 +0100 +++ b/src/version.c 2014-08-04 16:44:01.127172781 +0200 @@ -25,5 +25,5 @@ const char * mpfr_get_version (void) { - return "3.1.2"; + return "3.1.2-p10"; } --- a/tests/tdiv.c 2013-03-13 16:37:44.000000000 +0100 +++ b/tests/tdiv.c 2014-08-04 16:44:01.128172786 +0200 @@ -1104,6 +1104,96 @@ #define RAND_FUNCTION(x) mpfr_random2(x, MPFR_LIMB_SIZE (x), randlimb () % 100, RANDS) #include "tgeneric.c" +static void +test_extreme (void) +{ + mpfr_t x, y, z; + mpfr_exp_t emin, emax; + mpfr_prec_t p[4] = { 8, 32, 64, 256 }; + int xi, yi, zi, j, r; + unsigned int flags, ex_flags; + + emin = mpfr_get_emin (); + emax = mpfr_get_emax (); + + mpfr_set_emin (MPFR_EMIN_MIN); + mpfr_set_emax (MPFR_EMAX_MAX); + + for (xi = 0; xi < 4; xi++) + { + mpfr_init2 (x, p[xi]); + mpfr_setmax (x, MPFR_EMAX_MAX); + MPFR_ASSERTN (mpfr_check (x)); + for (yi = 0; yi < 4; yi++) + { + mpfr_init2 (y, p[yi]); + mpfr_setmin (y, MPFR_EMIN_MIN); + for (j = 0; j < 2; j++) + { + MPFR_ASSERTN (mpfr_check (y)); + for (zi = 0; zi < 4; zi++) + { + mpfr_init2 (z, p[zi]); + RND_LOOP (r) + { + mpfr_clear_flags (); + mpfr_div (z, x, y, (mpfr_rnd_t) r); + flags = __gmpfr_flags; + MPFR_ASSERTN (mpfr_check (z)); + ex_flags = MPFR_FLAGS_OVERFLOW | MPFR_FLAGS_INEXACT; + if (flags != ex_flags) + { + printf ("Bad flags in test_extreme on z = a/b" + " with %s and\n", + mpfr_print_rnd_mode ((mpfr_rnd_t) r)); + printf ("a = "); + mpfr_dump (x); + printf ("b = "); + mpfr_dump (y); + printf ("Expected flags:"); + flags_out (ex_flags); + printf ("Got flags: "); + flags_out (flags); + printf ("z = "); + mpfr_dump (z); + exit (1); + } + mpfr_clear_flags (); + mpfr_div (z, y, x, (mpfr_rnd_t) r); + flags = __gmpfr_flags; + MPFR_ASSERTN (mpfr_check (z)); + ex_flags = MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT; + if (flags != ex_flags) + { + printf ("Bad flags in test_extreme on z = a/b" + " with %s and\n", + mpfr_print_rnd_mode ((mpfr_rnd_t) r)); + printf ("a = "); + mpfr_dump (y); + printf ("b = "); + mpfr_dump (x); + printf ("Expected flags:"); + flags_out (ex_flags); + printf ("Got flags: "); + flags_out (flags); + printf ("z = "); + mpfr_dump (z); + exit (1); + } + } + mpfr_clear (z); + } /* zi */ + mpfr_nextabove (y); + } /* j */ + mpfr_clear (y); + } /* yi */ + mpfr_clear (x); + } /* xi */ + + set_emin (emin); + set_emax (emax); +} + int main (int argc, char *argv[]) { @@ -1130,6 +1220,7 @@ test_20070603 (); test_20070628 (); test_generic (2, 800, 50); + test_extreme (); tests_end_mpfr (); return 0; --- a/tests/texp.c 2013-03-13 16:37:44.000000000 +0100 +++ b/tests/texp.c 2014-08-04 16:44:01.128172786 +0200 @@ -150,6 +150,22 @@ exit (1); } + mpfr_set_prec (x, 118); + mpfr_set_str_binary (x, "0.1110010100011101010000111110011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E-86"); + mpfr_set_prec (y, 118); + mpfr_exp_2 (y, x, MPFR_RNDU); + mpfr_exp_3 (x, x, MPFR_RNDU); + if (mpfr_cmp (x, y)) + { + printf ("mpfr_exp_2 and mpfr_exp_3 differ for prec=118\n"); + printf ("mpfr_exp_2 gives "); + mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN); + printf ("\nmpfr_exp_3 gives "); + mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN); + printf ("\n"); + exit (1); + } + mpfr_clear (x); mpfr_clear (y); return 0; --- a/tests/tfits.c 2013-03-13 16:37:45.000000000 +0100 +++ b/tests/tfits.c 2014-08-04 16:44:01.128172786 +0200 @@ -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; - - /* 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 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 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 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 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; - - 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; - - 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; - - /* 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; + RND_LOOP (r) + { + + /* 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 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 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 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 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); + + /* 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_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); + + 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; - - /* 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 Zero */ - MPFR_SET_ZERO (x); - if (!mpfr_fits_uintmax_p (x, MPFR_RNDN)) - ERROR2; - if (!mpfr_fits_intmax_p (x, MPFR_RNDN)) - ERROR2; - - /* 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 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 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 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 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; + 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_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_rnd_t) r)) + ERROR1 (56); + if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) + ERROR1 (57); + + /* 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_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_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_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 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 } - --- a/tests/tget_flt.c 2013-03-13 16:37:44.000000000 +0100 +++ b/tests/tget_flt.c 2014-08-04 16:44:01.128172786 +0200 @@ -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); --- a/tests/tset_ld.c 2013-03-13 16:37:44.000000000 +0100 +++ b/tests/tset_ld.c 2014-08-04 16:44:01.129172791 +0200 @@ -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; --- a/tests/tsprintf.c 2013-03-13 16:37:44.000000000 +0100 +++ b/tests/tsprintf.c 2014-08-04 16:44:01.129172791 +0200 @@ -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 */ @@ -1178,6 +1184,69 @@ check_emax_aux (MPFR_EMAX_MAX); } +static void +check_emin_aux (mpfr_exp_t e) +{ + mpfr_t x; + char *s1, s2[256]; + int i; + mpfr_exp_t emin; + mpz_t ee; + + MPFR_ASSERTN (e >= LONG_MIN); + emin = mpfr_get_emin (); + set_emin (e); + + mpfr_init2 (x, 16); + mpz_init (ee); + + mpfr_setmin (x, e); + mpz_set_si (ee, e); + mpz_sub_ui (ee, ee, 1); + + i = mpfr_asprintf (&s1, "%Ra", x); + MPFR_ASSERTN (i > 0); + + gmp_snprintf (s2, 256, "0x1p%Zd", ee); + + if (strcmp (s1, s2) != 0) + { + printf ("Error in check_emin_aux for emin = %ld\n", (long) e); + printf ("Expected %s\n", s2); + printf ("Got %s\n", s1); + exit (1); + } + + mpfr_free_str (s1); + + i = mpfr_asprintf (&s1, "%Rb", x); + MPFR_ASSERTN (i > 0); + + gmp_snprintf (s2, 256, "1p%Zd", ee); + + if (strcmp (s1, s2) != 0) + { + printf ("Error in check_emin_aux for emin = %ld\n", (long) e); + printf ("Expected %s\n", s2); + printf ("Got %s\n", s1); + exit (1); + } + + mpfr_free_str (s1); + + mpfr_clear (x); + mpz_clear (ee); + set_emin (emin); +} + +static void +check_emin (void) +{ + check_emin_aux (-15); + check_emin_aux (mpfr_get_emin ()); + check_emin_aux (MPFR_EMIN_MIN); +} + int main (int argc, char **argv) { @@ -1197,6 +1266,7 @@ decimal (); mixed (); check_emax (); + check_emin (); #if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE) locale_da_DK (); --- a/VERSION 2013-03-13 16:37:28.000000000 +0100 +++ b/VERSION 2014-08-04 16:44:01.129172791 +0200 @@ -1 +1 @@ -3.1.2 +3.1.2-p10