diff options
Diffstat (limited to 'core/mpfr/mpfr-3.1.2-p3.patch')
| -rw-r--r-- | core/mpfr/mpfr-3.1.2-p3.patch | 779 |
1 files changed, 779 insertions, 0 deletions
diff --git a/core/mpfr/mpfr-3.1.2-p3.patch b/core/mpfr/mpfr-3.1.2-p3.patch new file mode 100644 index 000000000..0339944b6 --- /dev/null +++ b/core/mpfr/mpfr-3.1.2-p3.patch @@ -0,0 +1,779 @@ +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; |