[d42579b] | 1 | Submitted By: William Harrington (kb0iic at cross-lfs dot org) |
---|
[c8b646b] | 2 | Date: 2014-03-10 |
---|
[d42579b] | 3 | Initial Package Version: 3.1.2 |
---|
| 4 | Origin: Upstream |
---|
| 5 | Upstream Status: Applied |
---|
[c8b646b] | 6 | Description: Contains all upstream patches of mpfr current to patch level 5. |
---|
[d42579b] | 7 | |
---|
[c8b646b] | 8 | diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES |
---|
| 9 | --- mpfr-3.1.2-a/PATCHES 2013-09-26 10:52:52.000000000 +0000 |
---|
| 10 | +++ mpfr-3.1.2-b/PATCHES 2013-09-26 10:52:52.000000000 +0000 |
---|
| 11 | @@ -0,0 +1 @@ |
---|
[d42579b] | 12 | +exp_2 |
---|
[c8b646b] | 13 | diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION |
---|
| 14 | --- mpfr-3.1.2-a/VERSION 2013-03-13 15:37:28.000000000 +0000 |
---|
| 15 | +++ mpfr-3.1.2-b/VERSION 2013-09-26 10:52:52.000000000 +0000 |
---|
[d42579b] | 16 | @@ -1 +1 @@ |
---|
| 17 | -3.1.2 |
---|
[c8b646b] | 18 | +3.1.2-p1 |
---|
| 19 | diff -Naurd mpfr-3.1.2-a/src/exp_2.c mpfr-3.1.2-b/src/exp_2.c |
---|
| 20 | --- mpfr-3.1.2-a/src/exp_2.c 2013-03-13 15:37:28.000000000 +0000 |
---|
| 21 | +++ mpfr-3.1.2-b/src/exp_2.c 2013-09-26 10:52:52.000000000 +0000 |
---|
[d42579b] | 22 | @@ -204,7 +204,7 @@ |
---|
| 23 | for (k = 0; k < K; k++) |
---|
| 24 | { |
---|
| 25 | mpz_mul (ss, ss, ss); |
---|
| 26 | - exps <<= 1; |
---|
| 27 | + exps *= 2; |
---|
| 28 | exps += mpz_normalize (ss, ss, q); |
---|
| 29 | } |
---|
| 30 | mpfr_set_z (s, ss, MPFR_RNDN); |
---|
[c8b646b] | 31 | diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h |
---|
| 32 | --- mpfr-3.1.2-a/src/mpfr.h 2013-03-13 15:37:37.000000000 +0000 |
---|
| 33 | +++ mpfr-3.1.2-b/src/mpfr.h 2013-09-26 10:52:52.000000000 +0000 |
---|
| 34 | @@ -27,7 +27,7 @@ |
---|
| 35 | #define MPFR_VERSION_MAJOR 3 |
---|
| 36 | #define MPFR_VERSION_MINOR 1 |
---|
| 37 | #define MPFR_VERSION_PATCHLEVEL 2 |
---|
| 38 | -#define MPFR_VERSION_STRING "3.1.2" |
---|
| 39 | +#define MPFR_VERSION_STRING "3.1.2-p1" |
---|
| 40 | |
---|
| 41 | /* Macros dealing with MPFR VERSION */ |
---|
| 42 | #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) |
---|
| 43 | diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c |
---|
| 44 | --- mpfr-3.1.2-a/src/version.c 2013-03-13 15:37:34.000000000 +0000 |
---|
| 45 | +++ mpfr-3.1.2-b/src/version.c 2013-09-26 10:52:52.000000000 +0000 |
---|
| 46 | @@ -25,5 +25,5 @@ |
---|
| 47 | const char * |
---|
| 48 | mpfr_get_version (void) |
---|
| 49 | { |
---|
| 50 | - return "3.1.2"; |
---|
| 51 | + return "3.1.2-p1"; |
---|
| 52 | } |
---|
| 53 | diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES |
---|
| 54 | --- mpfr-3.1.2-a/PATCHES 2013-09-26 10:56:55.000000000 +0000 |
---|
| 55 | +++ mpfr-3.1.2-b/PATCHES 2013-09-26 10:56:55.000000000 +0000 |
---|
| 56 | @@ -0,0 +1 @@ |
---|
| 57 | +fits-smallneg |
---|
| 58 | diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION |
---|
| 59 | --- mpfr-3.1.2-a/VERSION 2013-09-26 10:52:52.000000000 +0000 |
---|
| 60 | +++ mpfr-3.1.2-b/VERSION 2013-09-26 10:56:55.000000000 +0000 |
---|
| 61 | @@ -1 +1 @@ |
---|
| 62 | -3.1.2-p1 |
---|
| 63 | +3.1.2-p2 |
---|
| 64 | diff -Naurd mpfr-3.1.2-a/src/fits_u.h mpfr-3.1.2-b/src/fits_u.h |
---|
| 65 | --- mpfr-3.1.2-a/src/fits_u.h 2013-03-13 15:37:35.000000000 +0000 |
---|
| 66 | +++ mpfr-3.1.2-b/src/fits_u.h 2013-09-26 10:56:55.000000000 +0000 |
---|
[d42579b] | 67 | @@ -32,17 +32,20 @@ |
---|
| 68 | int res; |
---|
| 69 | |
---|
| 70 | if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f))) |
---|
| 71 | - /* Zero always fit */ |
---|
| 72 | - return MPFR_IS_ZERO (f) ? 1 : 0; |
---|
| 73 | - else if (MPFR_IS_NEG (f)) |
---|
| 74 | - /* Negative numbers don't fit */ |
---|
| 75 | - return 0; |
---|
| 76 | - /* now it fits if |
---|
| 77 | - (a) f <= MAXIMUM |
---|
| 78 | - (b) round(f, prec(slong), rnd) <= MAXIMUM */ |
---|
| 79 | + return MPFR_IS_ZERO (f) ? 1 : 0; /* Zero always fits */ |
---|
| 80 | |
---|
| 81 | e = MPFR_GET_EXP (f); |
---|
| 82 | |
---|
| 83 | + if (MPFR_IS_NEG (f)) |
---|
| 84 | + return e >= 1 ? 0 /* f <= -1 does not fit */ |
---|
| 85 | + : rnd != MPFR_RNDN ? MPFR_IS_LIKE_RNDU (rnd, -1) /* directed mode */ |
---|
| 86 | + : e < 0 ? 1 /* f > -1/2 fits in MPFR_RNDN */ |
---|
| 87 | + : mpfr_powerof2_raw(f); /* -1/2 fits, -1 < f < -1/2 don't */ |
---|
| 88 | + |
---|
| 89 | + /* Now it fits if |
---|
| 90 | + (a) f <= MAXIMUM |
---|
| 91 | + (b) round(f, prec(slong), rnd) <= MAXIMUM */ |
---|
| 92 | + |
---|
| 93 | /* first compute prec(MAXIMUM); fits in an int */ |
---|
| 94 | for (s = MAXIMUM, prec = 0; s != 0; s /= 2, prec ++); |
---|
| 95 | |
---|
[c8b646b] | 96 | diff -Naurd mpfr-3.1.2-a/src/fits_uintmax.c mpfr-3.1.2-b/src/fits_uintmax.c |
---|
| 97 | --- mpfr-3.1.2-a/src/fits_uintmax.c 2013-03-13 15:37:33.000000000 +0000 |
---|
| 98 | +++ mpfr-3.1.2-b/src/fits_uintmax.c 2013-09-26 10:56:55.000000000 +0000 |
---|
[d42579b] | 99 | @@ -27,51 +27,19 @@ |
---|
| 100 | #include "mpfr-intmax.h" |
---|
| 101 | #include "mpfr-impl.h" |
---|
| 102 | |
---|
| 103 | -#ifdef _MPFR_H_HAVE_INTMAX_T |
---|
| 104 | - |
---|
| 105 | -/* We can't use fits_u.h <= mpfr_cmp_ui */ |
---|
| 106 | -int |
---|
| 107 | -mpfr_fits_uintmax_p (mpfr_srcptr f, mpfr_rnd_t rnd) |
---|
| 108 | -{ |
---|
| 109 | - mpfr_exp_t e; |
---|
| 110 | - int prec; |
---|
| 111 | - uintmax_t s; |
---|
| 112 | - mpfr_t x; |
---|
| 113 | - int res; |
---|
| 114 | - |
---|
| 115 | - if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f))) |
---|
| 116 | - /* Zero always fit */ |
---|
| 117 | - return MPFR_IS_ZERO (f) ? 1 : 0; |
---|
| 118 | - else if (MPFR_IS_NEG (f)) |
---|
| 119 | - /* Negative numbers don't fit */ |
---|
| 120 | - return 0; |
---|
| 121 | - /* now it fits if |
---|
| 122 | - (a) f <= MAXIMUM |
---|
| 123 | - (b) round(f, prec(slong), rnd) <= MAXIMUM */ |
---|
| 124 | - |
---|
| 125 | - e = MPFR_GET_EXP (f); |
---|
[c8b646b] | 126 | - |
---|
[d42579b] | 127 | - /* first compute prec(MAXIMUM); fits in an int */ |
---|
| 128 | - for (s = MPFR_UINTMAX_MAX, prec = 0; s != 0; s /= 2, prec ++); |
---|
| 129 | - |
---|
| 130 | - /* MAXIMUM needs prec bits, i.e. MAXIMUM = 2^prec - 1 */ |
---|
| 131 | - |
---|
| 132 | - /* if e <= prec - 1, then f < 2^(prec-1) < MAXIMUM */ |
---|
| 133 | - if (e <= prec - 1) |
---|
| 134 | - return 1; |
---|
[c8b646b] | 135 | +/* Note: though mpfr-impl.h is included in fits_u.h, we also include it |
---|
| 136 | + above so that it gets included even when _MPFR_H_HAVE_INTMAX_T is not |
---|
| 137 | + defined; this is necessary to avoid an empty translation unit, which |
---|
| 138 | + is forbidden by ISO C. Without this, a failing test can be reproduced |
---|
| 139 | + by creating an invalid stdint.h somewhere in the default include path |
---|
| 140 | + and by compiling MPFR with "gcc -ansi -pedantic-errors". */ |
---|
| 141 | |
---|
[d42579b] | 142 | - /* if e >= prec + 1, then f >= 2^prec > MAXIMUM */ |
---|
| 143 | - if (e >= prec + 1) |
---|
| 144 | - return 0; |
---|
| 145 | +#ifdef _MPFR_H_HAVE_INTMAX_T |
---|
| 146 | |
---|
| 147 | - MPFR_ASSERTD (e == prec); |
---|
| 148 | +#define FUNCTION mpfr_fits_uintmax_p |
---|
| 149 | +#define MAXIMUM MPFR_UINTMAX_MAX |
---|
| 150 | +#define TYPE uintmax_t |
---|
| 151 | |
---|
| 152 | - /* hard case: first round to prec bits, then check */ |
---|
| 153 | - mpfr_init2 (x, prec); |
---|
| 154 | - mpfr_set (x, f, rnd); |
---|
| 155 | - res = MPFR_GET_EXP (x) == e; |
---|
| 156 | - mpfr_clear (x); |
---|
| 157 | - return res; |
---|
| 158 | -} |
---|
| 159 | +#include "fits_u.h" |
---|
| 160 | |
---|
| 161 | #endif |
---|
[c8b646b] | 162 | diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h |
---|
| 163 | --- mpfr-3.1.2-a/src/mpfr.h 2013-09-26 10:52:52.000000000 +0000 |
---|
| 164 | +++ mpfr-3.1.2-b/src/mpfr.h 2013-09-26 10:56:55.000000000 +0000 |
---|
[d42579b] | 165 | @@ -27,7 +27,7 @@ |
---|
| 166 | #define MPFR_VERSION_MAJOR 3 |
---|
| 167 | #define MPFR_VERSION_MINOR 1 |
---|
| 168 | #define MPFR_VERSION_PATCHLEVEL 2 |
---|
[c8b646b] | 169 | -#define MPFR_VERSION_STRING "3.1.2-p1" |
---|
| 170 | +#define MPFR_VERSION_STRING "3.1.2-p2" |
---|
[d42579b] | 171 | |
---|
| 172 | /* Macros dealing with MPFR VERSION */ |
---|
| 173 | #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) |
---|
[c8b646b] | 174 | diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c |
---|
| 175 | --- mpfr-3.1.2-a/src/version.c 2013-09-26 10:52:52.000000000 +0000 |
---|
| 176 | +++ mpfr-3.1.2-b/src/version.c 2013-09-26 10:56:55.000000000 +0000 |
---|
[d42579b] | 177 | @@ -25,5 +25,5 @@ |
---|
| 178 | const char * |
---|
| 179 | mpfr_get_version (void) |
---|
| 180 | { |
---|
[c8b646b] | 181 | - return "3.1.2-p1"; |
---|
| 182 | + return "3.1.2-p2"; |
---|
[d42579b] | 183 | } |
---|
[c8b646b] | 184 | diff -Naurd mpfr-3.1.2-a/tests/tfits.c mpfr-3.1.2-b/tests/tfits.c |
---|
| 185 | --- mpfr-3.1.2-a/tests/tfits.c 2013-03-13 15:37:45.000000000 +0000 |
---|
| 186 | +++ mpfr-3.1.2-b/tests/tfits.c 2013-09-26 10:56:55.000000000 +0000 |
---|
[d42579b] | 187 | @@ -33,155 +33,176 @@ |
---|
| 188 | #include "mpfr-intmax.h" |
---|
| 189 | #include "mpfr-test.h" |
---|
| 190 | |
---|
| 191 | -#define ERROR1 { printf("Initial error for x="); mpfr_dump(x); exit(1); } |
---|
| 192 | -#define ERROR2 { printf("Error for x="); mpfr_dump(x); exit(1); } |
---|
| 193 | +#define ERROR1(N) \ |
---|
| 194 | + do \ |
---|
| 195 | + { \ |
---|
| 196 | + printf("Error %d for rnd = %s and x = ", N, \ |
---|
| 197 | + mpfr_print_rnd_mode ((mpfr_rnd_t) r)); \ |
---|
| 198 | + mpfr_dump(x); \ |
---|
| 199 | + exit(1); \ |
---|
| 200 | + } \ |
---|
| 201 | + while (0) |
---|
| 202 | |
---|
| 203 | static void check_intmax (void); |
---|
| 204 | |
---|
| 205 | int |
---|
| 206 | main (void) |
---|
| 207 | { |
---|
| 208 | - mpfr_t x; |
---|
| 209 | + mpfr_t x, y; |
---|
| 210 | + int i, r; |
---|
| 211 | |
---|
| 212 | tests_start_mpfr (); |
---|
| 213 | |
---|
| 214 | mpfr_init2 (x, 256); |
---|
| 215 | + mpfr_init2 (y, 8); |
---|
| 216 | |
---|
| 217 | - /* Check NAN */ |
---|
| 218 | - mpfr_set_nan (x); |
---|
| 219 | - if (mpfr_fits_ulong_p (x, MPFR_RNDN)) |
---|
| 220 | - ERROR1; |
---|
| 221 | - if (mpfr_fits_slong_p (x, MPFR_RNDN)) |
---|
| 222 | - ERROR1; |
---|
| 223 | - if (mpfr_fits_uint_p (x, MPFR_RNDN)) |
---|
| 224 | - ERROR1; |
---|
| 225 | - if (mpfr_fits_sint_p (x, MPFR_RNDN)) |
---|
| 226 | - ERROR1; |
---|
| 227 | - if (mpfr_fits_ushort_p (x, MPFR_RNDN)) |
---|
| 228 | - ERROR1; |
---|
| 229 | - if (mpfr_fits_sshort_p (x, MPFR_RNDN)) |
---|
| 230 | - ERROR1; |
---|
[c8b646b] | 231 | + RND_LOOP (r) |
---|
| 232 | + { |
---|
| 233 | |
---|
[d42579b] | 234 | - /* Check INF */ |
---|
| 235 | - mpfr_set_inf (x, 1); |
---|
| 236 | - if (mpfr_fits_ulong_p (x, MPFR_RNDN)) |
---|
| 237 | - ERROR1; |
---|
| 238 | - if (mpfr_fits_slong_p (x, MPFR_RNDN)) |
---|
| 239 | - ERROR1; |
---|
| 240 | - if (mpfr_fits_uint_p (x, MPFR_RNDN)) |
---|
| 241 | - ERROR1; |
---|
| 242 | - if (mpfr_fits_sint_p (x, MPFR_RNDN)) |
---|
| 243 | - ERROR1; |
---|
| 244 | - if (mpfr_fits_ushort_p (x, MPFR_RNDN)) |
---|
| 245 | - ERROR1; |
---|
| 246 | - if (mpfr_fits_sshort_p (x, MPFR_RNDN)) |
---|
| 247 | - ERROR1; |
---|
[c8b646b] | 248 | + /* Check NAN */ |
---|
| 249 | + mpfr_set_nan (x); |
---|
| 250 | + if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r)) |
---|
| 251 | + ERROR1 (1); |
---|
| 252 | + if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r)) |
---|
| 253 | + ERROR1 (2); |
---|
| 254 | + if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r)) |
---|
| 255 | + ERROR1 (3); |
---|
| 256 | + if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r)) |
---|
| 257 | + ERROR1 (4); |
---|
| 258 | + if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r)) |
---|
| 259 | + ERROR1 (5); |
---|
| 260 | + if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r)) |
---|
| 261 | + ERROR1 (6); |
---|
| 262 | |
---|
[d42579b] | 263 | - /* Check Zero */ |
---|
| 264 | - MPFR_SET_ZERO (x); |
---|
| 265 | - if (!mpfr_fits_ulong_p (x, MPFR_RNDN)) |
---|
| 266 | - ERROR2; |
---|
| 267 | - if (!mpfr_fits_slong_p (x, MPFR_RNDN)) |
---|
| 268 | - ERROR2; |
---|
| 269 | - if (!mpfr_fits_uint_p (x, MPFR_RNDN)) |
---|
| 270 | - ERROR2; |
---|
| 271 | - if (!mpfr_fits_sint_p (x, MPFR_RNDN)) |
---|
| 272 | - ERROR2; |
---|
| 273 | - if (!mpfr_fits_ushort_p (x, MPFR_RNDN)) |
---|
| 274 | - ERROR2; |
---|
| 275 | - if (!mpfr_fits_sshort_p (x, MPFR_RNDN)) |
---|
| 276 | - ERROR2; |
---|
[c8b646b] | 277 | + /* Check INF */ |
---|
| 278 | + mpfr_set_inf (x, 1); |
---|
| 279 | + if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r)) |
---|
| 280 | + ERROR1 (7); |
---|
| 281 | + if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r)) |
---|
| 282 | + ERROR1 (8); |
---|
| 283 | + if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r)) |
---|
| 284 | + ERROR1 (9); |
---|
| 285 | + if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r)) |
---|
| 286 | + ERROR1 (10); |
---|
| 287 | + if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r)) |
---|
| 288 | + ERROR1 (11); |
---|
| 289 | + if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r)) |
---|
| 290 | + ERROR1 (12); |
---|
| 291 | |
---|
[d42579b] | 292 | - /* Check small op */ |
---|
| 293 | - mpfr_set_str1 (x, "1@-1"); |
---|
| 294 | - if (!mpfr_fits_ulong_p (x, MPFR_RNDN)) |
---|
| 295 | - ERROR2; |
---|
| 296 | - if (!mpfr_fits_slong_p (x, MPFR_RNDN)) |
---|
| 297 | - ERROR2; |
---|
| 298 | - if (!mpfr_fits_uint_p (x, MPFR_RNDN)) |
---|
| 299 | - ERROR2; |
---|
| 300 | - if (!mpfr_fits_sint_p (x, MPFR_RNDN)) |
---|
| 301 | - ERROR2; |
---|
| 302 | - if (!mpfr_fits_ushort_p (x, MPFR_RNDN)) |
---|
| 303 | - ERROR2; |
---|
| 304 | - if (!mpfr_fits_sshort_p (x, MPFR_RNDN)) |
---|
| 305 | - ERROR2; |
---|
[c8b646b] | 306 | + /* Check Zero */ |
---|
| 307 | + MPFR_SET_ZERO (x); |
---|
| 308 | + if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r)) |
---|
| 309 | + ERROR1 (13); |
---|
| 310 | + if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r)) |
---|
| 311 | + ERROR1 (14); |
---|
| 312 | + if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r)) |
---|
| 313 | + ERROR1 (15); |
---|
| 314 | + if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r)) |
---|
| 315 | + ERROR1 (16); |
---|
| 316 | + if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r)) |
---|
| 317 | + ERROR1 (17); |
---|
| 318 | + if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r)) |
---|
| 319 | + ERROR1 (18); |
---|
| 320 | |
---|
[d42579b] | 321 | - /* Check 17 */ |
---|
| 322 | - mpfr_set_ui (x, 17, MPFR_RNDN); |
---|
| 323 | - if (!mpfr_fits_ulong_p (x, MPFR_RNDN)) |
---|
| 324 | - ERROR2; |
---|
| 325 | - if (!mpfr_fits_slong_p (x, MPFR_RNDN)) |
---|
| 326 | - ERROR2; |
---|
| 327 | - if (!mpfr_fits_uint_p (x, MPFR_RNDN)) |
---|
| 328 | - ERROR2; |
---|
| 329 | - if (!mpfr_fits_sint_p (x, MPFR_RNDN)) |
---|
| 330 | - ERROR2; |
---|
| 331 | - if (!mpfr_fits_ushort_p (x, MPFR_RNDN)) |
---|
| 332 | - ERROR2; |
---|
| 333 | - if (!mpfr_fits_sshort_p (x, MPFR_RNDN)) |
---|
| 334 | - ERROR2; |
---|
[c8b646b] | 335 | + /* Check small positive op */ |
---|
| 336 | + mpfr_set_str1 (x, "1@-1"); |
---|
| 337 | + if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r)) |
---|
| 338 | + ERROR1 (19); |
---|
| 339 | + if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r)) |
---|
| 340 | + ERROR1 (20); |
---|
| 341 | + if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r)) |
---|
| 342 | + ERROR1 (21); |
---|
| 343 | + if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r)) |
---|
| 344 | + ERROR1 (22); |
---|
| 345 | + if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r)) |
---|
| 346 | + ERROR1 (23); |
---|
| 347 | + if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r)) |
---|
| 348 | + ERROR1 (24); |
---|
| 349 | |
---|
[d42579b] | 350 | - /* Check all other values */ |
---|
| 351 | - mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN); |
---|
| 352 | - mpfr_mul_2exp (x, x, 1, MPFR_RNDN); |
---|
| 353 | - if (mpfr_fits_ulong_p (x, MPFR_RNDN)) |
---|
| 354 | - ERROR1; |
---|
| 355 | - if (mpfr_fits_slong_p (x, MPFR_RNDN)) |
---|
| 356 | - ERROR1; |
---|
| 357 | - mpfr_mul_2exp (x, x, 40, MPFR_RNDN); |
---|
| 358 | - if (mpfr_fits_ulong_p (x, MPFR_RNDN)) |
---|
| 359 | - ERROR1; |
---|
| 360 | - if (mpfr_fits_uint_p (x, MPFR_RNDN)) |
---|
| 361 | - ERROR1; |
---|
| 362 | - if (mpfr_fits_sint_p (x, MPFR_RNDN)) |
---|
| 363 | - ERROR1; |
---|
| 364 | - if (mpfr_fits_ushort_p (x, MPFR_RNDN)) |
---|
| 365 | - ERROR1; |
---|
| 366 | - if (mpfr_fits_sshort_p (x, MPFR_RNDN)) |
---|
| 367 | - ERROR1; |
---|
[c8b646b] | 368 | + /* Check 17 */ |
---|
| 369 | + mpfr_set_ui (x, 17, MPFR_RNDN); |
---|
| 370 | + if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r)) |
---|
| 371 | + ERROR1 (25); |
---|
| 372 | + if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r)) |
---|
| 373 | + ERROR1 (26); |
---|
| 374 | + if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r)) |
---|
| 375 | + ERROR1 (27); |
---|
| 376 | + if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r)) |
---|
| 377 | + ERROR1 (28); |
---|
| 378 | + if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r)) |
---|
| 379 | + ERROR1 (29); |
---|
| 380 | + if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r)) |
---|
| 381 | + ERROR1 (30); |
---|
| 382 | |
---|
[d42579b] | 383 | - mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN); |
---|
| 384 | - if (!mpfr_fits_ulong_p (x, MPFR_RNDN)) |
---|
| 385 | - ERROR2; |
---|
| 386 | - mpfr_set_ui (x, LONG_MAX, MPFR_RNDN); |
---|
| 387 | - if (!mpfr_fits_slong_p (x, MPFR_RNDN)) |
---|
| 388 | - ERROR2; |
---|
| 389 | - mpfr_set_ui (x, UINT_MAX, MPFR_RNDN); |
---|
| 390 | - if (!mpfr_fits_uint_p (x, MPFR_RNDN)) |
---|
| 391 | - ERROR2; |
---|
| 392 | - mpfr_set_ui (x, INT_MAX, MPFR_RNDN); |
---|
| 393 | - if (!mpfr_fits_sint_p (x, MPFR_RNDN)) |
---|
| 394 | - ERROR2; |
---|
| 395 | - mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN); |
---|
| 396 | - if (!mpfr_fits_ushort_p (x, MPFR_RNDN)) |
---|
| 397 | - ERROR2; |
---|
| 398 | - mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN); |
---|
| 399 | - if (!mpfr_fits_sshort_p (x, MPFR_RNDN)) |
---|
| 400 | - ERROR2; |
---|
| 401 | + /* Check all other values */ |
---|
| 402 | + mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN); |
---|
| 403 | + mpfr_mul_2exp (x, x, 1, MPFR_RNDN); |
---|
| 404 | + if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r)) |
---|
| 405 | + ERROR1 (31); |
---|
| 406 | + if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r)) |
---|
| 407 | + ERROR1 (32); |
---|
| 408 | + mpfr_mul_2exp (x, x, 40, MPFR_RNDN); |
---|
| 409 | + if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r)) |
---|
| 410 | + ERROR1 (33); |
---|
| 411 | + if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r)) |
---|
| 412 | + ERROR1 (34); |
---|
| 413 | + if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r)) |
---|
| 414 | + ERROR1 (35); |
---|
| 415 | + if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r)) |
---|
| 416 | + ERROR1 (36); |
---|
| 417 | + if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r)) |
---|
| 418 | + ERROR1 (37); |
---|
[c8b646b] | 419 | |
---|
| 420 | - mpfr_set_si (x, 1, MPFR_RNDN); |
---|
| 421 | - if (!mpfr_fits_sint_p (x, MPFR_RNDN)) |
---|
| 422 | - ERROR2; |
---|
| 423 | - if (!mpfr_fits_sshort_p (x, MPFR_RNDN)) |
---|
| 424 | - ERROR2; |
---|
[d42579b] | 425 | + mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN); |
---|
| 426 | + if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r)) |
---|
| 427 | + ERROR1 (38); |
---|
| 428 | + mpfr_set_ui (x, LONG_MAX, MPFR_RNDN); |
---|
| 429 | + if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r)) |
---|
| 430 | + ERROR1 (39); |
---|
| 431 | + mpfr_set_ui (x, UINT_MAX, MPFR_RNDN); |
---|
| 432 | + if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r)) |
---|
| 433 | + ERROR1 (40); |
---|
| 434 | + mpfr_set_ui (x, INT_MAX, MPFR_RNDN); |
---|
| 435 | + if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r)) |
---|
| 436 | + ERROR1 (41); |
---|
| 437 | + mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN); |
---|
| 438 | + if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r)) |
---|
| 439 | + ERROR1 (42); |
---|
| 440 | + mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN); |
---|
| 441 | + if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r)) |
---|
| 442 | + ERROR1 (43); |
---|
[c8b646b] | 443 | |
---|
| 444 | - /* Check negative value */ |
---|
| 445 | - mpfr_set_si (x, -1, MPFR_RNDN); |
---|
| 446 | - if (!mpfr_fits_sint_p (x, MPFR_RNDN)) |
---|
| 447 | - ERROR2; |
---|
| 448 | - if (!mpfr_fits_sshort_p (x, MPFR_RNDN)) |
---|
| 449 | - ERROR2; |
---|
| 450 | - if (!mpfr_fits_slong_p (x, MPFR_RNDN)) |
---|
| 451 | - ERROR2; |
---|
| 452 | - if (mpfr_fits_uint_p (x, MPFR_RNDN)) |
---|
| 453 | - ERROR1; |
---|
| 454 | - if (mpfr_fits_ushort_p (x, MPFR_RNDN)) |
---|
| 455 | - ERROR1; |
---|
| 456 | - if (mpfr_fits_ulong_p (x, MPFR_RNDN)) |
---|
| 457 | - ERROR1; |
---|
[d42579b] | 458 | + mpfr_set_si (x, 1, MPFR_RNDN); |
---|
| 459 | + if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r)) |
---|
| 460 | + ERROR1 (44); |
---|
| 461 | + if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r)) |
---|
| 462 | + ERROR1 (45); |
---|
| 463 | + |
---|
| 464 | + /* Check negative op */ |
---|
| 465 | + for (i = 1; i <= 4; i++) |
---|
| 466 | + { |
---|
| 467 | + int inv; |
---|
| 468 | + |
---|
| 469 | + mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN); |
---|
| 470 | + mpfr_rint (y, x, (mpfr_rnd_t) r); |
---|
| 471 | + inv = MPFR_NOTZERO (y); |
---|
| 472 | + if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r) ^ inv) |
---|
| 473 | + ERROR1 (46); |
---|
| 474 | + if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r)) |
---|
| 475 | + ERROR1 (47); |
---|
| 476 | + if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r) ^ inv) |
---|
| 477 | + ERROR1 (48); |
---|
| 478 | + if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r)) |
---|
| 479 | + ERROR1 (49); |
---|
| 480 | + if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r) ^ inv) |
---|
| 481 | + ERROR1 (50); |
---|
| 482 | + if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r)) |
---|
| 483 | + ERROR1 (51); |
---|
| 484 | + } |
---|
| 485 | + } |
---|
| 486 | |
---|
| 487 | mpfr_clear (x); |
---|
| 488 | + mpfr_clear (y); |
---|
| 489 | |
---|
| 490 | check_intmax (); |
---|
| 491 | |
---|
| 492 | @@ -189,85 +210,98 @@ |
---|
| 493 | return 0; |
---|
| 494 | } |
---|
| 495 | |
---|
| 496 | -static void check_intmax (void) |
---|
| 497 | +static void |
---|
| 498 | +check_intmax (void) |
---|
| 499 | { |
---|
| 500 | #ifdef _MPFR_H_HAVE_INTMAX_T |
---|
| 501 | - mpfr_t x; |
---|
| 502 | + mpfr_t x, y; |
---|
| 503 | + int i, r; |
---|
| 504 | |
---|
| 505 | - mpfr_init2 (x, sizeof (uintmax_t)*CHAR_BIT); |
---|
| 506 | + mpfr_init2 (x, sizeof (uintmax_t) * CHAR_BIT); |
---|
| 507 | + mpfr_init2 (y, 8); |
---|
| 508 | |
---|
| 509 | - /* Check NAN */ |
---|
| 510 | - mpfr_set_nan (x); |
---|
| 511 | - if (mpfr_fits_uintmax_p (x, MPFR_RNDN)) |
---|
| 512 | - ERROR1; |
---|
| 513 | - if (mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 514 | - ERROR1; |
---|
[c8b646b] | 515 | + RND_LOOP (r) |
---|
| 516 | + { |
---|
| 517 | + /* Check NAN */ |
---|
| 518 | + mpfr_set_nan (x); |
---|
| 519 | + if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r)) |
---|
| 520 | + ERROR1 (52); |
---|
| 521 | + if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 522 | + ERROR1 (53); |
---|
| 523 | |
---|
[d42579b] | 524 | - /* Check INF */ |
---|
| 525 | - mpfr_set_inf (x, 1); |
---|
| 526 | - if (mpfr_fits_uintmax_p (x, MPFR_RNDN)) |
---|
| 527 | - ERROR1; |
---|
| 528 | - if (mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 529 | - ERROR1; |
---|
[c8b646b] | 530 | + /* Check INF */ |
---|
| 531 | + mpfr_set_inf (x, 1); |
---|
| 532 | + if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r)) |
---|
| 533 | + ERROR1 (54); |
---|
| 534 | + if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 535 | + ERROR1 (55); |
---|
| 536 | |
---|
[d42579b] | 537 | - /* Check Zero */ |
---|
| 538 | - MPFR_SET_ZERO (x); |
---|
| 539 | - if (!mpfr_fits_uintmax_p (x, MPFR_RNDN)) |
---|
| 540 | - ERROR2; |
---|
| 541 | - if (!mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 542 | - ERROR2; |
---|
[c8b646b] | 543 | + /* Check Zero */ |
---|
| 544 | + MPFR_SET_ZERO (x); |
---|
| 545 | + if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r)) |
---|
| 546 | + ERROR1 (56); |
---|
| 547 | + if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 548 | + ERROR1 (57); |
---|
| 549 | |
---|
[d42579b] | 550 | - /* Check small op */ |
---|
| 551 | - mpfr_set_str1 (x, "1@-1"); |
---|
| 552 | - if (!mpfr_fits_uintmax_p (x, MPFR_RNDN)) |
---|
| 553 | - ERROR2; |
---|
| 554 | - if (!mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 555 | - ERROR2; |
---|
[c8b646b] | 556 | + /* Check positive small op */ |
---|
| 557 | + mpfr_set_str1 (x, "1@-1"); |
---|
| 558 | + if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r)) |
---|
| 559 | + ERROR1 (58); |
---|
| 560 | + if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 561 | + ERROR1 (59); |
---|
| 562 | |
---|
[d42579b] | 563 | - /* Check 17 */ |
---|
| 564 | - mpfr_set_ui (x, 17, MPFR_RNDN); |
---|
| 565 | - if (!mpfr_fits_uintmax_p (x, MPFR_RNDN)) |
---|
| 566 | - ERROR2; |
---|
| 567 | - if (!mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 568 | - ERROR2; |
---|
[c8b646b] | 569 | + /* Check 17 */ |
---|
| 570 | + mpfr_set_ui (x, 17, MPFR_RNDN); |
---|
| 571 | + if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r)) |
---|
| 572 | + ERROR1 (60); |
---|
| 573 | + if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 574 | + ERROR1 (61); |
---|
| 575 | |
---|
[d42579b] | 576 | - /* Check hugest */ |
---|
| 577 | - mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN); |
---|
| 578 | - if (mpfr_fits_uintmax_p (x, MPFR_RNDN)) |
---|
| 579 | - ERROR1; |
---|
| 580 | - if (mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 581 | - ERROR1; |
---|
[c8b646b] | 582 | + /* Check hugest */ |
---|
| 583 | + mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN); |
---|
| 584 | + if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r)) |
---|
| 585 | + ERROR1 (62); |
---|
| 586 | + if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 587 | + ERROR1 (63); |
---|
| 588 | |
---|
[d42579b] | 589 | - /* Check all other values */ |
---|
| 590 | - mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN); |
---|
| 591 | - mpfr_add_ui (x, x, 1, MPFR_RNDN); |
---|
| 592 | - if (mpfr_fits_uintmax_p (x, MPFR_RNDN)) |
---|
| 593 | - ERROR1; |
---|
| 594 | - mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN); |
---|
| 595 | - if (!mpfr_fits_uintmax_p (x, MPFR_RNDN)) |
---|
| 596 | - ERROR2; |
---|
| 597 | - mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN); |
---|
| 598 | - mpfr_add_ui (x, x, 1, MPFR_RNDN); |
---|
| 599 | - if (mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 600 | - ERROR1; |
---|
| 601 | - mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN); |
---|
| 602 | - if (!mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 603 | - ERROR2; |
---|
| 604 | - mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN); |
---|
| 605 | - if (!mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 606 | - ERROR2; |
---|
| 607 | - mpfr_sub_ui (x, x, 1, MPFR_RNDN); |
---|
| 608 | - if (mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 609 | - ERROR1; |
---|
| 610 | + /* Check all other values */ |
---|
| 611 | + mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN); |
---|
| 612 | + mpfr_add_ui (x, x, 1, MPFR_RNDN); |
---|
| 613 | + if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r)) |
---|
| 614 | + ERROR1 (64); |
---|
| 615 | + mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN); |
---|
| 616 | + if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r)) |
---|
| 617 | + ERROR1 (65); |
---|
| 618 | + mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN); |
---|
| 619 | + mpfr_add_ui (x, x, 1, MPFR_RNDN); |
---|
| 620 | + if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 621 | + ERROR1 (66); |
---|
| 622 | + mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN); |
---|
| 623 | + if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 624 | + ERROR1 (67); |
---|
| 625 | + mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN); |
---|
| 626 | + if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 627 | + ERROR1 (68); |
---|
| 628 | + mpfr_sub_ui (x, x, 1, MPFR_RNDN); |
---|
| 629 | + if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 630 | + ERROR1 (69); |
---|
[c8b646b] | 631 | |
---|
| 632 | - /* Check negative value */ |
---|
| 633 | - mpfr_set_si (x, -1, MPFR_RNDN); |
---|
| 634 | - if (!mpfr_fits_intmax_p (x, MPFR_RNDN)) |
---|
| 635 | - ERROR2; |
---|
| 636 | - if (mpfr_fits_uintmax_p (x, MPFR_RNDN)) |
---|
| 637 | - ERROR1; |
---|
[d42579b] | 638 | + /* Check negative op */ |
---|
| 639 | + for (i = 1; i <= 4; i++) |
---|
| 640 | + { |
---|
| 641 | + int inv; |
---|
| 642 | + |
---|
| 643 | + mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN); |
---|
| 644 | + mpfr_rint (y, x, (mpfr_rnd_t) r); |
---|
| 645 | + inv = MPFR_NOTZERO (y); |
---|
| 646 | + if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r) ^ inv) |
---|
| 647 | + ERROR1 (70); |
---|
| 648 | + if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r)) |
---|
| 649 | + ERROR1 (71); |
---|
| 650 | + } |
---|
| 651 | + } |
---|
| 652 | |
---|
| 653 | mpfr_clear (x); |
---|
| 654 | + mpfr_clear (y); |
---|
| 655 | #endif |
---|
| 656 | } |
---|
| 657 | - |
---|
[c8b646b] | 658 | diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES |
---|
| 659 | --- mpfr-3.1.2-a/PATCHES 2013-10-09 13:34:21.000000000 +0000 |
---|
| 660 | +++ mpfr-3.1.2-b/PATCHES 2013-10-09 13:34:21.000000000 +0000 |
---|
| 661 | @@ -0,0 +1 @@ |
---|
| 662 | +clang-divby0 |
---|
| 663 | diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION |
---|
| 664 | --- mpfr-3.1.2-a/VERSION 2013-09-26 10:52:52.000000000 +0000 |
---|
| 665 | +++ mpfr-3.1.2-b/VERSION 2013-10-09 13:34:21.000000000 +0000 |
---|
| 666 | @@ -1 +1 @@ |
---|
| 667 | -3.1.2-p2 |
---|
| 668 | +3.1.2-p3 |
---|
| 669 | diff -Naurd mpfr-3.1.2-a/src/mpfr-impl.h mpfr-3.1.2-b/src/mpfr-impl.h |
---|
| 670 | --- mpfr-3.1.2-a/src/mpfr-impl.h 2013-03-13 15:37:36.000000000 +0000 |
---|
| 671 | +++ mpfr-3.1.2-b/src/mpfr-impl.h 2013-10-09 13:34:21.000000000 +0000 |
---|
| 672 | @@ -468,8 +468,16 @@ |
---|
| 673 | #define MPFR_LIMBS_PER_FLT ((IEEE_FLT_MANT_DIG-1)/GMP_NUMB_BITS+1) |
---|
| 674 | |
---|
| 675 | /* Visual C++ doesn't support +1.0/0.0, -1.0/0.0 and 0.0/0.0 |
---|
| 676 | - at compile time. */ |
---|
| 677 | -#if defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200) |
---|
| 678 | + at compile time. |
---|
| 679 | + Clang with -fsanitize=undefined is a bit similar due to a bug: |
---|
| 680 | + http://llvm.org/bugs/show_bug.cgi?id=17381 |
---|
| 681 | + but even without its sanitizer, it may be better to use the |
---|
| 682 | + double_zero version until IEEE 754 division by zero is properly |
---|
| 683 | + supported: |
---|
| 684 | + http://llvm.org/bugs/show_bug.cgi?id=17000 |
---|
| 685 | +*/ |
---|
| 686 | +#if (defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200)) || \ |
---|
| 687 | + defined(__clang__) |
---|
| 688 | static double double_zero = 0.0; |
---|
| 689 | # define DBL_NAN (double_zero/double_zero) |
---|
| 690 | # define DBL_POS_INF ((double) 1.0/double_zero) |
---|
| 691 | @@ -501,6 +509,8 @@ |
---|
| 692 | (with Xcode 2.4.1, i.e. the latest one). */ |
---|
| 693 | #define LVALUE(x) (&(x) == &(x) || &(x) != &(x)) |
---|
| 694 | #define DOUBLE_ISINF(x) (LVALUE(x) && ((x) > DBL_MAX || (x) < -DBL_MAX)) |
---|
| 695 | +/* The DOUBLE_ISNAN(x) macro is also valid on long double x |
---|
| 696 | + (assuming that the compiler isn't too broken). */ |
---|
| 697 | #ifdef MPFR_NANISNAN |
---|
| 698 | /* Avoid MIPSpro / IRIX64 / gcc -ffast-math (incorrect) optimizations. |
---|
| 699 | The + must not be replaced by a ||. With gcc -ffast-math, NaN is |
---|
| 700 | diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h |
---|
| 701 | --- mpfr-3.1.2-a/src/mpfr.h 2013-09-26 10:52:52.000000000 +0000 |
---|
| 702 | +++ mpfr-3.1.2-b/src/mpfr.h 2013-10-09 13:34:21.000000000 +0000 |
---|
| 703 | @@ -27,7 +27,7 @@ |
---|
| 704 | #define MPFR_VERSION_MAJOR 3 |
---|
| 705 | #define MPFR_VERSION_MINOR 1 |
---|
| 706 | #define MPFR_VERSION_PATCHLEVEL 2 |
---|
| 707 | -#define MPFR_VERSION_STRING "3.1.2-p2" |
---|
| 708 | +#define MPFR_VERSION_STRING "3.1.2-p3" |
---|
| 709 | |
---|
| 710 | /* Macros dealing with MPFR VERSION */ |
---|
| 711 | #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) |
---|
| 712 | diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c |
---|
| 713 | --- mpfr-3.1.2-a/src/version.c 2013-09-26 10:52:52.000000000 +0000 |
---|
| 714 | +++ mpfr-3.1.2-b/src/version.c 2013-10-09 13:34:21.000000000 +0000 |
---|
| 715 | @@ -25,5 +25,5 @@ |
---|
| 716 | const char * |
---|
| 717 | mpfr_get_version (void) |
---|
| 718 | { |
---|
| 719 | - return "3.1.2-p2"; |
---|
| 720 | + return "3.1.2-p3"; |
---|
| 721 | } |
---|
| 722 | diff -Naurd mpfr-3.1.2-a/tests/tget_flt.c mpfr-3.1.2-b/tests/tget_flt.c |
---|
| 723 | --- mpfr-3.1.2-a/tests/tget_flt.c 2013-03-13 15:37:44.000000000 +0000 |
---|
| 724 | +++ mpfr-3.1.2-b/tests/tget_flt.c 2013-10-09 13:34:21.000000000 +0000 |
---|
[d42579b] | 725 | @@ -28,9 +28,17 @@ |
---|
| 726 | main (void) |
---|
| 727 | { |
---|
| 728 | mpfr_t x, y; |
---|
| 729 | - float f, g, infp; |
---|
| 730 | + float f, g; |
---|
| 731 | int i; |
---|
| 732 | +#if !defined(MPFR_ERRDIVZERO) |
---|
| 733 | + float infp; |
---|
| 734 | +#endif |
---|
| 735 | + |
---|
[c8b646b] | 736 | + tests_start_mpfr (); |
---|
| 737 | |
---|
[d42579b] | 738 | +#if !defined(MPFR_ERRDIVZERO) |
---|
| 739 | + /* The definition of DBL_POS_INF involves a division by 0. This makes |
---|
| 740 | + "clang -O2 -fsanitize=undefined -fno-sanitize-recover" fail. */ |
---|
| 741 | infp = (float) DBL_POS_INF; |
---|
| 742 | if (infp * 0.5 != infp) |
---|
| 743 | { |
---|
| 744 | @@ -38,8 +46,7 @@ |
---|
| 745 | fprintf (stderr, "(this is probably a compiler bug, please report)\n"); |
---|
| 746 | exit (1); |
---|
| 747 | } |
---|
| 748 | - |
---|
| 749 | - tests_start_mpfr (); |
---|
| 750 | +#endif |
---|
| 751 | |
---|
| 752 | mpfr_init2 (x, 24); |
---|
| 753 | mpfr_init2 (y, 24); |
---|
| 754 | @@ -353,6 +360,7 @@ |
---|
| 755 | printf ("expected %.8e, got %.8e\n", g, f); |
---|
| 756 | exit (1); |
---|
| 757 | } |
---|
| 758 | +#if !defined(MPFR_ERRDIVZERO) |
---|
| 759 | f = mpfr_get_flt (x, MPFR_RNDN); /* first round to 2^128 (even rule), |
---|
| 760 | thus we should get +Inf */ |
---|
| 761 | g = infp; |
---|
| 762 | @@ -376,6 +384,7 @@ |
---|
| 763 | printf ("expected %.8e, got %.8e\n", g, f); |
---|
| 764 | exit (1); |
---|
| 765 | } |
---|
| 766 | +#endif |
---|
| 767 | |
---|
| 768 | mpfr_clear (x); |
---|
| 769 | mpfr_clear (y); |
---|
[c8b646b] | 770 | diff -Naurd mpfr-3.1.2-a/tests/tset_ld.c mpfr-3.1.2-b/tests/tset_ld.c |
---|
| 771 | --- mpfr-3.1.2-a/tests/tset_ld.c 2013-03-13 15:37:44.000000000 +0000 |
---|
| 772 | +++ mpfr-3.1.2-b/tests/tset_ld.c 2013-10-09 13:34:21.000000000 +0000 |
---|
[d42579b] | 773 | @@ -47,8 +47,11 @@ |
---|
| 774 | static int |
---|
| 775 | Isnan_ld (long double d) |
---|
| 776 | { |
---|
| 777 | - double e = (double) d; |
---|
| 778 | - if (DOUBLE_ISNAN (e)) |
---|
| 779 | + /* Do not convert d to double as this can give an overflow, which |
---|
| 780 | + may confuse compilers without IEEE 754 support (such as clang |
---|
| 781 | + -fsanitize=undefined), or trigger a trap if enabled. |
---|
| 782 | + The DOUBLE_ISNAN macro should work fine on long double. */ |
---|
| 783 | + if (DOUBLE_ISNAN (d)) |
---|
| 784 | return 1; |
---|
| 785 | LONGDOUBLE_NAN_ACTION (d, goto yes); |
---|
| 786 | return 0; |
---|
[c8b646b] | 787 | diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES |
---|
| 788 | --- mpfr-3.1.2-a/PATCHES 2013-11-15 00:51:49.211333830 +0000 |
---|
| 789 | +++ mpfr-3.1.2-b/PATCHES 2013-11-15 00:51:49.323334999 +0000 |
---|
| 790 | @@ -0,0 +1 @@ |
---|
| 791 | +printf-alt0 |
---|
| 792 | diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION |
---|
| 793 | --- mpfr-3.1.2-a/VERSION 2013-11-15 00:51:49.211333830 +0000 |
---|
| 794 | +++ mpfr-3.1.2-b/VERSION 2013-11-15 00:51:49.323334999 +0000 |
---|
| 795 | @@ -1 +1 @@ |
---|
| 796 | -3.1.2-p3 |
---|
| 797 | +3.1.2-p4 |
---|
| 798 | diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h |
---|
| 799 | --- mpfr-3.1.2-a/src/mpfr.h 2013-11-15 00:51:49.211333830 +0000 |
---|
| 800 | +++ mpfr-3.1.2-b/src/mpfr.h 2013-11-15 00:51:49.323334999 +0000 |
---|
| 801 | @@ -27,7 +27,7 @@ |
---|
| 802 | #define MPFR_VERSION_MAJOR 3 |
---|
| 803 | #define MPFR_VERSION_MINOR 1 |
---|
| 804 | #define MPFR_VERSION_PATCHLEVEL 2 |
---|
| 805 | -#define MPFR_VERSION_STRING "3.1.2-p3" |
---|
| 806 | +#define MPFR_VERSION_STRING "3.1.2-p4" |
---|
| 807 | |
---|
| 808 | /* Macros dealing with MPFR VERSION */ |
---|
| 809 | #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) |
---|
| 810 | diff -Naurd mpfr-3.1.2-a/src/vasprintf.c mpfr-3.1.2-b/src/vasprintf.c |
---|
| 811 | --- mpfr-3.1.2-a/src/vasprintf.c 2013-03-13 15:37:37.000000000 +0000 |
---|
| 812 | +++ mpfr-3.1.2-b/src/vasprintf.c 2013-11-15 00:51:49.267334408 +0000 |
---|
| 813 | @@ -1040,7 +1040,7 @@ |
---|
| 814 | } |
---|
| 815 | |
---|
| 816 | /* Determine the different parts of the string representation of the regular |
---|
| 817 | - number P when SPEC.SPEC is 'e', 'E', 'g', or 'G'. |
---|
| 818 | + number P when spec.spec is 'e', 'E', 'g', or 'G'. |
---|
| 819 | DEC_INFO contains the previously computed exponent and string or is NULL. |
---|
| 820 | |
---|
| 821 | return -1 if some field > INT_MAX */ |
---|
| 822 | @@ -1167,7 +1167,7 @@ |
---|
| 823 | } |
---|
| 824 | |
---|
| 825 | /* Determine the different parts of the string representation of the regular |
---|
| 826 | - number P when SPEC.SPEC is 'f', 'F', 'g', or 'G'. |
---|
| 827 | + number P when spec.spec is 'f', 'F', 'g', or 'G'. |
---|
| 828 | DEC_INFO contains the previously computed exponent and string or is NULL. |
---|
| 829 | |
---|
| 830 | return -1 if some field of number_parts is greater than INT_MAX */ |
---|
| 831 | @@ -1559,7 +1559,7 @@ |
---|
| 832 | /* fractional part */ |
---|
| 833 | { |
---|
| 834 | np->point = MPFR_DECIMAL_POINT; |
---|
| 835 | - np->fp_trailing_zeros = (spec.spec == 'g' && spec.spec == 'G') ? |
---|
| 836 | + np->fp_trailing_zeros = (spec.spec == 'g' || spec.spec == 'G') ? |
---|
| 837 | spec.prec - 1 : spec.prec; |
---|
| 838 | } |
---|
| 839 | else if (spec.alt) |
---|
| 840 | diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c |
---|
| 841 | --- mpfr-3.1.2-a/src/version.c 2013-11-15 00:51:49.211333830 +0000 |
---|
| 842 | +++ mpfr-3.1.2-b/src/version.c 2013-11-15 00:51:49.323334999 +0000 |
---|
| 843 | @@ -25,5 +25,5 @@ |
---|
| 844 | const char * |
---|
| 845 | mpfr_get_version (void) |
---|
| 846 | { |
---|
| 847 | - return "3.1.2-p3"; |
---|
| 848 | + return "3.1.2-p4"; |
---|
| 849 | } |
---|
| 850 | diff -Naurd mpfr-3.1.2-a/tests/tsprintf.c mpfr-3.1.2-b/tests/tsprintf.c |
---|
| 851 | --- mpfr-3.1.2-a/tests/tsprintf.c 2013-03-13 15:37:44.000000000 +0000 |
---|
| 852 | +++ mpfr-3.1.2-b/tests/tsprintf.c 2013-11-15 00:51:49.267334408 +0000 |
---|
| 853 | @@ -456,10 +456,16 @@ |
---|
| 854 | check_sprintf ("1.999900 ", "%-#10.7RG", x); |
---|
| 855 | check_sprintf ("1.9999 ", "%-10.7RG", x); |
---|
| 856 | mpfr_set_ui (x, 1, MPFR_RNDN); |
---|
| 857 | + check_sprintf ("1.", "%#.1Rg", x); |
---|
| 858 | + check_sprintf ("1. ", "%-#5.1Rg", x); |
---|
| 859 | + check_sprintf (" 1.0", "%#5.2Rg", x); |
---|
| 860 | check_sprintf ("1.00000000000000000000000000000", "%#.30Rg", x); |
---|
| 861 | check_sprintf ("1", "%.30Rg", x); |
---|
| 862 | mpfr_set_ui (x, 0, MPFR_RNDN); |
---|
| 863 | - check_sprintf ("0.000000000000000000000000000000", "%#.30Rg", x); |
---|
| 864 | + check_sprintf ("0.", "%#.1Rg", x); |
---|
| 865 | + check_sprintf ("0. ", "%-#5.1Rg", x); |
---|
| 866 | + check_sprintf (" 0.0", "%#5.2Rg", x); |
---|
| 867 | + check_sprintf ("0.00000000000000000000000000000", "%#.30Rg", x); |
---|
| 868 | check_sprintf ("0", "%.30Rg", x); |
---|
| 869 | |
---|
| 870 | /* following tests with precision 53 bits */ |
---|
| 871 | diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES |
---|
| 872 | --- mpfr-3.1.2-a/PATCHES 2013-12-01 11:07:49.575329762 +0000 |
---|
| 873 | +++ mpfr-3.1.2-b/PATCHES 2013-12-01 11:07:49.751331625 +0000 |
---|
| 874 | @@ -0,0 +1 @@ |
---|
| 875 | +custom_init_set |
---|
| 876 | diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION |
---|
| 877 | --- mpfr-3.1.2-a/VERSION 2013-12-01 11:07:49.571329714 +0000 |
---|
| 878 | +++ mpfr-3.1.2-b/VERSION 2013-12-01 11:07:49.747331585 +0000 |
---|
| 879 | @@ -1 +1 @@ |
---|
| 880 | -3.1.2-p4 |
---|
| 881 | +3.1.2-p5 |
---|
| 882 | diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h |
---|
| 883 | --- mpfr-3.1.2-a/src/mpfr.h 2013-12-01 11:07:49.571329714 +0000 |
---|
| 884 | +++ mpfr-3.1.2-b/src/mpfr.h 2013-12-01 11:07:49.747331585 +0000 |
---|
| 885 | @@ -27,7 +27,7 @@ |
---|
| 886 | #define MPFR_VERSION_MAJOR 3 |
---|
| 887 | #define MPFR_VERSION_MINOR 1 |
---|
| 888 | #define MPFR_VERSION_PATCHLEVEL 2 |
---|
| 889 | -#define MPFR_VERSION_STRING "3.1.2-p4" |
---|
| 890 | +#define MPFR_VERSION_STRING "3.1.2-p5" |
---|
| 891 | |
---|
| 892 | /* Macros dealing with MPFR VERSION */ |
---|
| 893 | #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) |
---|
| 894 | @@ -861,7 +861,7 @@ |
---|
| 895 | _t = (mpfr_kind_t) _k; \ |
---|
| 896 | _s = 1; \ |
---|
| 897 | } else { \ |
---|
| 898 | - _t = (mpfr_kind_t) -k; \ |
---|
| 899 | + _t = (mpfr_kind_t) - _k; \ |
---|
| 900 | _s = -1; \ |
---|
| 901 | } \ |
---|
| 902 | _e = _t == MPFR_REGULAR_KIND ? (e) : \ |
---|
| 903 | diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c |
---|
| 904 | --- mpfr-3.1.2-a/src/version.c 2013-12-01 11:07:49.575329762 +0000 |
---|
| 905 | +++ mpfr-3.1.2-b/src/version.c 2013-12-01 11:07:49.747331585 +0000 |
---|
| 906 | @@ -25,5 +25,5 @@ |
---|
| 907 | const char * |
---|
| 908 | mpfr_get_version (void) |
---|
| 909 | { |
---|
| 910 | - return "3.1.2-p4"; |
---|
| 911 | + return "3.1.2-p5"; |
---|
| 912 | } |
---|