1 /* real.c - software floating point emulation. 2 Copyright (C) 1993-2018 Free Software Foundation, Inc. 3 Contributed by Stephen L. Moshier (moshier@world.std.com). 4 Re-written by Richard Henderson <rth@redhat.com> 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "tm.h" 26 #include "rtl.h" 27 #include "tree.h" 28 #include "realmpfr.h" 29 #include "dfp.h" 30 31 /* The floating point model used internally is not exactly IEEE 754 32 compliant, and close to the description in the ISO C99 standard, 33 section 5.2.4.2.2 Characteristics of floating types. 34 35 Specifically 36 37 x = s * b^e * \sum_{k=1}^p f_k * b^{-k} 38 39 where 40 s = sign (+- 1) 41 b = base or radix, here always 2 42 e = exponent 43 p = precision (the number of base-b digits in the significand) 44 f_k = the digits of the significand. 45 46 We differ from typical IEEE 754 encodings in that the entire 47 significand is fractional. Normalized significands are in the 48 range [0.5, 1.0). 49 50 A requirement of the model is that P be larger than the largest 51 supported target floating-point type by at least 2 bits. This gives 52 us proper rounding when we truncate to the target type. In addition, 53 E must be large enough to hold the smallest supported denormal number 54 in a normalized form. 55 56 Both of these requirements are easily satisfied. The largest target 57 significand is 113 bits; we store at least 160. The smallest 58 denormal number fits in 17 exponent bits; we store 26. */ 59 60 61 /* Used to classify two numbers simultaneously. */ 62 #define CLASS2(A, B) ((A) << 2 | (B)) 63 64 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32 65 #error "Some constant folding done by hand to avoid shift count warnings" 66 #endif 67 68 static void get_zero (REAL_VALUE_TYPE *, int); 69 static void get_canonical_qnan (REAL_VALUE_TYPE *, int); 70 static void get_canonical_snan (REAL_VALUE_TYPE *, int); 71 static void get_inf (REAL_VALUE_TYPE *, int); 72 static bool sticky_rshift_significand (REAL_VALUE_TYPE *, 73 const REAL_VALUE_TYPE *, unsigned int); 74 static void rshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, 75 unsigned int); 76 static void lshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, 77 unsigned int); 78 static void lshift_significand_1 (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 79 static bool add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *, 80 const REAL_VALUE_TYPE *); 81 static bool sub_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, 82 const REAL_VALUE_TYPE *, int); 83 static void neg_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 84 static int cmp_significands (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 85 static int cmp_significand_0 (const REAL_VALUE_TYPE *); 86 static void set_significand_bit (REAL_VALUE_TYPE *, unsigned int); 87 static void clear_significand_bit (REAL_VALUE_TYPE *, unsigned int); 88 static bool test_significand_bit (REAL_VALUE_TYPE *, unsigned int); 89 static void clear_significand_below (REAL_VALUE_TYPE *, unsigned int); 90 static bool div_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, 91 const REAL_VALUE_TYPE *); 92 static void normalize (REAL_VALUE_TYPE *); 93 94 static bool do_add (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, 95 const REAL_VALUE_TYPE *, int); 96 static bool do_multiply (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, 97 const REAL_VALUE_TYPE *); 98 static bool do_divide (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, 99 const REAL_VALUE_TYPE *); 100 static int do_compare (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int); 101 static void do_fix_trunc (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 102 103 static unsigned long rtd_divmod (REAL_VALUE_TYPE *, REAL_VALUE_TYPE *); 104 static void decimal_from_integer (REAL_VALUE_TYPE *); 105 static void decimal_integer_string (char *, const REAL_VALUE_TYPE *, 106 size_t); 107 108 static const REAL_VALUE_TYPE * ten_to_ptwo (int); 109 static const REAL_VALUE_TYPE * ten_to_mptwo (int); 110 static const REAL_VALUE_TYPE * real_digit (int); 111 static void times_pten (REAL_VALUE_TYPE *, int); 112 113 static void round_for_format (const struct real_format *, REAL_VALUE_TYPE *); 114 115 /* Initialize R with a positive zero. */ 116 117 static inline void 118 get_zero (REAL_VALUE_TYPE *r, int sign) 119 { 120 memset (r, 0, sizeof (*r)); 121 r->sign = sign; 122 } 123 124 /* Initialize R with the canonical quiet NaN. */ 125 126 static inline void 127 get_canonical_qnan (REAL_VALUE_TYPE *r, int sign) 128 { 129 memset (r, 0, sizeof (*r)); 130 r->cl = rvc_nan; 131 r->sign = sign; 132 r->canonical = 1; 133 } 134 135 static inline void 136 get_canonical_snan (REAL_VALUE_TYPE *r, int sign) 137 { 138 memset (r, 0, sizeof (*r)); 139 r->cl = rvc_nan; 140 r->sign = sign; 141 r->signalling = 1; 142 r->canonical = 1; 143 } 144 145 static inline void 146 get_inf (REAL_VALUE_TYPE *r, int sign) 147 { 148 memset (r, 0, sizeof (*r)); 149 r->cl = rvc_inf; 150 r->sign = sign; 151 } 152 153 154 /* Right-shift the significand of A by N bits; put the result in the 155 significand of R. If any one bits are shifted out, return true. */ 156 157 static bool 158 sticky_rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a, 159 unsigned int n) 160 { 161 unsigned long sticky = 0; 162 unsigned int i, ofs = 0; 163 164 if (n >= HOST_BITS_PER_LONG) 165 { 166 for (i = 0, ofs = n / HOST_BITS_PER_LONG; i < ofs; ++i) 167 sticky |= a->sig[i]; 168 n &= HOST_BITS_PER_LONG - 1; 169 } 170 171 if (n != 0) 172 { 173 sticky |= a->sig[ofs] & (((unsigned long)1 << n) - 1); 174 for (i = 0; i < SIGSZ; ++i) 175 { 176 r->sig[i] 177 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n) 178 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1]) 179 << (HOST_BITS_PER_LONG - n))); 180 } 181 } 182 else 183 { 184 for (i = 0; ofs + i < SIGSZ; ++i) 185 r->sig[i] = a->sig[ofs + i]; 186 for (; i < SIGSZ; ++i) 187 r->sig[i] = 0; 188 } 189 190 return sticky != 0; 191 } 192 193 /* Right-shift the significand of A by N bits; put the result in the 194 significand of R. */ 195 196 static void 197 rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a, 198 unsigned int n) 199 { 200 unsigned int i, ofs = n / HOST_BITS_PER_LONG; 201 202 n &= HOST_BITS_PER_LONG - 1; 203 if (n != 0) 204 { 205 for (i = 0; i < SIGSZ; ++i) 206 { 207 r->sig[i] 208 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n) 209 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1]) 210 << (HOST_BITS_PER_LONG - n))); 211 } 212 } 213 else 214 { 215 for (i = 0; ofs + i < SIGSZ; ++i) 216 r->sig[i] = a->sig[ofs + i]; 217 for (; i < SIGSZ; ++i) 218 r->sig[i] = 0; 219 } 220 } 221 222 /* Left-shift the significand of A by N bits; put the result in the 223 significand of R. */ 224 225 static void 226 lshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a, 227 unsigned int n) 228 { 229 unsigned int i, ofs = n / HOST_BITS_PER_LONG; 230 231 n &= HOST_BITS_PER_LONG - 1; 232 if (n == 0) 233 { 234 for (i = 0; ofs + i < SIGSZ; ++i) 235 r->sig[SIGSZ-1-i] = a->sig[SIGSZ-1-i-ofs]; 236 for (; i < SIGSZ; ++i) 237 r->sig[SIGSZ-1-i] = 0; 238 } 239 else 240 for (i = 0; i < SIGSZ; ++i) 241 { 242 r->sig[SIGSZ-1-i] 243 = (((ofs + i >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs]) << n) 244 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs-1]) 245 >> (HOST_BITS_PER_LONG - n))); 246 } 247 } 248 249 /* Likewise, but N is specialized to 1. */ 250 251 static inline void 252 lshift_significand_1 (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a) 253 { 254 unsigned int i; 255 256 for (i = SIGSZ - 1; i > 0; --i) 257 r->sig[i] = (a->sig[i] << 1) | (a->sig[i-1] >> (HOST_BITS_PER_LONG - 1)); 258 r->sig[0] = a->sig[0] << 1; 259 } 260 261 /* Add the significands of A and B, placing the result in R. Return 262 true if there was carry out of the most significant word. */ 263 264 static inline bool 265 add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a, 266 const REAL_VALUE_TYPE *b) 267 { 268 bool carry = false; 269 int i; 270 271 for (i = 0; i < SIGSZ; ++i) 272 { 273 unsigned long ai = a->sig[i]; 274 unsigned long ri = ai + b->sig[i]; 275 276 if (carry) 277 { 278 carry = ri < ai; 279 carry |= ++ri == 0; 280 } 281 else 282 carry = ri < ai; 283 284 r->sig[i] = ri; 285 } 286 287 return carry; 288 } 289 290 /* Subtract the significands of A and B, placing the result in R. CARRY is 291 true if there's a borrow incoming to the least significant word. 292 Return true if there was borrow out of the most significant word. */ 293 294 static inline bool 295 sub_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a, 296 const REAL_VALUE_TYPE *b, int carry) 297 { 298 int i; 299 300 for (i = 0; i < SIGSZ; ++i) 301 { 302 unsigned long ai = a->sig[i]; 303 unsigned long ri = ai - b->sig[i]; 304 305 if (carry) 306 { 307 carry = ri > ai; 308 carry |= ~--ri == 0; 309 } 310 else 311 carry = ri > ai; 312 313 r->sig[i] = ri; 314 } 315 316 return carry; 317 } 318 319 /* Negate the significand A, placing the result in R. */ 320 321 static inline void 322 neg_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a) 323 { 324 bool carry = true; 325 int i; 326 327 for (i = 0; i < SIGSZ; ++i) 328 { 329 unsigned long ri, ai = a->sig[i]; 330 331 if (carry) 332 { 333 if (ai) 334 { 335 ri = -ai; 336 carry = false; 337 } 338 else 339 ri = ai; 340 } 341 else 342 ri = ~ai; 343 344 r->sig[i] = ri; 345 } 346 } 347 348 /* Compare significands. Return tri-state vs zero. */ 349 350 static inline int 351 cmp_significands (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b) 352 { 353 int i; 354 355 for (i = SIGSZ - 1; i >= 0; --i) 356 { 357 unsigned long ai = a->sig[i]; 358 unsigned long bi = b->sig[i]; 359 360 if (ai > bi) 361 return 1; 362 if (ai < bi) 363 return -1; 364 } 365 366 return 0; 367 } 368 369 /* Return true if A is nonzero. */ 370 371 static inline int 372 cmp_significand_0 (const REAL_VALUE_TYPE *a) 373 { 374 int i; 375 376 for (i = SIGSZ - 1; i >= 0; --i) 377 if (a->sig[i]) 378 return 1; 379 380 return 0; 381 } 382 383 /* Set bit N of the significand of R. */ 384 385 static inline void 386 set_significand_bit (REAL_VALUE_TYPE *r, unsigned int n) 387 { 388 r->sig[n / HOST_BITS_PER_LONG] 389 |= (unsigned long)1 << (n % HOST_BITS_PER_LONG); 390 } 391 392 /* Clear bit N of the significand of R. */ 393 394 static inline void 395 clear_significand_bit (REAL_VALUE_TYPE *r, unsigned int n) 396 { 397 r->sig[n / HOST_BITS_PER_LONG] 398 &= ~((unsigned long)1 << (n % HOST_BITS_PER_LONG)); 399 } 400 401 /* Test bit N of the significand of R. */ 402 403 static inline bool 404 test_significand_bit (REAL_VALUE_TYPE *r, unsigned int n) 405 { 406 /* ??? Compiler bug here if we return this expression directly. 407 The conversion to bool strips the "&1" and we wind up testing 408 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */ 409 int t = (r->sig[n / HOST_BITS_PER_LONG] >> (n % HOST_BITS_PER_LONG)) & 1; 410 return t; 411 } 412 413 /* Clear bits 0..N-1 of the significand of R. */ 414 415 static void 416 clear_significand_below (REAL_VALUE_TYPE *r, unsigned int n) 417 { 418 int i, w = n / HOST_BITS_PER_LONG; 419 420 for (i = 0; i < w; ++i) 421 r->sig[i] = 0; 422 423 r->sig[w] &= ~(((unsigned long)1 << (n % HOST_BITS_PER_LONG)) - 1); 424 } 425 426 /* Divide the significands of A and B, placing the result in R. Return 427 true if the division was inexact. */ 428 429 static inline bool 430 div_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a, 431 const REAL_VALUE_TYPE *b) 432 { 433 REAL_VALUE_TYPE u; 434 int i, bit = SIGNIFICAND_BITS - 1; 435 unsigned long msb, inexact; 436 437 u = *a; 438 memset (r->sig, 0, sizeof (r->sig)); 439 440 msb = 0; 441 goto start; 442 do 443 { 444 msb = u.sig[SIGSZ-1] & SIG_MSB; 445 lshift_significand_1 (&u, &u); 446 start: 447 if (msb || cmp_significands (&u, b) >= 0) 448 { 449 sub_significands (&u, &u, b, 0); 450 set_significand_bit (r, bit); 451 } 452 } 453 while (--bit >= 0); 454 455 for (i = 0, inexact = 0; i < SIGSZ; i++) 456 inexact |= u.sig[i]; 457 458 return inexact != 0; 459 } 460 461 /* Adjust the exponent and significand of R such that the most 462 significant bit is set. We underflow to zero and overflow to 463 infinity here, without denormals. (The intermediate representation 464 exponent is large enough to handle target denormals normalized.) */ 465 466 static void 467 normalize (REAL_VALUE_TYPE *r) 468 { 469 int shift = 0, exp; 470 int i, j; 471 472 if (r->decimal) 473 return; 474 475 /* Find the first word that is nonzero. */ 476 for (i = SIGSZ - 1; i >= 0; i--) 477 if (r->sig[i] == 0) 478 shift += HOST_BITS_PER_LONG; 479 else 480 break; 481 482 /* Zero significand flushes to zero. */ 483 if (i < 0) 484 { 485 r->cl = rvc_zero; 486 SET_REAL_EXP (r, 0); 487 return; 488 } 489 490 /* Find the first bit that is nonzero. */ 491 for (j = 0; ; j++) 492 if (r->sig[i] & ((unsigned long)1 << (HOST_BITS_PER_LONG - 1 - j))) 493 break; 494 shift += j; 495 496 if (shift > 0) 497 { 498 exp = REAL_EXP (r) - shift; 499 if (exp > MAX_EXP) 500 get_inf (r, r->sign); 501 else if (exp < -MAX_EXP) 502 get_zero (r, r->sign); 503 else 504 { 505 SET_REAL_EXP (r, exp); 506 lshift_significand (r, r, shift); 507 } 508 } 509 } 510 511 /* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the 512 result may be inexact due to a loss of precision. */ 513 514 static bool 515 do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a, 516 const REAL_VALUE_TYPE *b, int subtract_p) 517 { 518 int dexp, sign, exp; 519 REAL_VALUE_TYPE t; 520 bool inexact = false; 521 522 /* Determine if we need to add or subtract. */ 523 sign = a->sign; 524 subtract_p = (sign ^ b->sign) ^ subtract_p; 525 526 switch (CLASS2 (a->cl, b->cl)) 527 { 528 case CLASS2 (rvc_zero, rvc_zero): 529 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */ 530 get_zero (r, sign & !subtract_p); 531 return false; 532 533 case CLASS2 (rvc_zero, rvc_normal): 534 case CLASS2 (rvc_zero, rvc_inf): 535 case CLASS2 (rvc_zero, rvc_nan): 536 /* 0 + ANY = ANY. */ 537 case CLASS2 (rvc_normal, rvc_nan): 538 case CLASS2 (rvc_inf, rvc_nan): 539 case CLASS2 (rvc_nan, rvc_nan): 540 /* ANY + NaN = NaN. */ 541 case CLASS2 (rvc_normal, rvc_inf): 542 /* R + Inf = Inf. */ 543 *r = *b; 544 /* Make resulting NaN value to be qNaN. The caller has the 545 responsibility to avoid the operation if flag_signaling_nans 546 is on. */ 547 r->signalling = 0; 548 r->sign = sign ^ subtract_p; 549 return false; 550 551 case CLASS2 (rvc_normal, rvc_zero): 552 case CLASS2 (rvc_inf, rvc_zero): 553 case CLASS2 (rvc_nan, rvc_zero): 554 /* ANY + 0 = ANY. */ 555 case CLASS2 (rvc_nan, rvc_normal): 556 case CLASS2 (rvc_nan, rvc_inf): 557 /* NaN + ANY = NaN. */ 558 case CLASS2 (rvc_inf, rvc_normal): 559 /* Inf + R = Inf. */ 560 *r = *a; 561 /* Make resulting NaN value to be qNaN. The caller has the 562 responsibility to avoid the operation if flag_signaling_nans 563 is on. */ 564 r->signalling = 0; 565 return false; 566 567 case CLASS2 (rvc_inf, rvc_inf): 568 if (subtract_p) 569 /* Inf - Inf = NaN. */ 570 get_canonical_qnan (r, 0); 571 else 572 /* Inf + Inf = Inf. */ 573 *r = *a; 574 return false; 575 576 case CLASS2 (rvc_normal, rvc_normal): 577 break; 578 579 default: 580 gcc_unreachable (); 581 } 582 583 /* Swap the arguments such that A has the larger exponent. */ 584 dexp = REAL_EXP (a) - REAL_EXP (b); 585 if (dexp < 0) 586 { 587 const REAL_VALUE_TYPE *t; 588 t = a, a = b, b = t; 589 dexp = -dexp; 590 sign ^= subtract_p; 591 } 592 exp = REAL_EXP (a); 593 594 /* If the exponents are not identical, we need to shift the 595 significand of B down. */ 596 if (dexp > 0) 597 { 598 /* If the exponents are too far apart, the significands 599 do not overlap, which makes the subtraction a noop. */ 600 if (dexp >= SIGNIFICAND_BITS) 601 { 602 *r = *a; 603 r->sign = sign; 604 return true; 605 } 606 607 inexact |= sticky_rshift_significand (&t, b, dexp); 608 b = &t; 609 } 610 611 if (subtract_p) 612 { 613 if (sub_significands (r, a, b, inexact)) 614 { 615 /* We got a borrow out of the subtraction. That means that 616 A and B had the same exponent, and B had the larger 617 significand. We need to swap the sign and negate the 618 significand. */ 619 sign ^= 1; 620 neg_significand (r, r); 621 } 622 } 623 else 624 { 625 if (add_significands (r, a, b)) 626 { 627 /* We got carry out of the addition. This means we need to 628 shift the significand back down one bit and increase the 629 exponent. */ 630 inexact |= sticky_rshift_significand (r, r, 1); 631 r->sig[SIGSZ-1] |= SIG_MSB; 632 if (++exp > MAX_EXP) 633 { 634 get_inf (r, sign); 635 return true; 636 } 637 } 638 } 639 640 r->cl = rvc_normal; 641 r->sign = sign; 642 SET_REAL_EXP (r, exp); 643 /* Zero out the remaining fields. */ 644 r->signalling = 0; 645 r->canonical = 0; 646 r->decimal = 0; 647 648 /* Re-normalize the result. */ 649 normalize (r); 650 651 /* Special case: if the subtraction results in zero, the result 652 is positive. */ 653 if (r->cl == rvc_zero) 654 r->sign = 0; 655 else 656 r->sig[0] |= inexact; 657 658 return inexact; 659 } 660 661 /* Calculate R = A * B. Return true if the result may be inexact. */ 662 663 static bool 664 do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a, 665 const REAL_VALUE_TYPE *b) 666 { 667 REAL_VALUE_TYPE u, t, *rr; 668 unsigned int i, j, k; 669 int sign = a->sign ^ b->sign; 670 bool inexact = false; 671 672 switch (CLASS2 (a->cl, b->cl)) 673 { 674 case CLASS2 (rvc_zero, rvc_zero): 675 case CLASS2 (rvc_zero, rvc_normal): 676 case CLASS2 (rvc_normal, rvc_zero): 677 /* +-0 * ANY = 0 with appropriate sign. */ 678 get_zero (r, sign); 679 return false; 680 681 case CLASS2 (rvc_zero, rvc_nan): 682 case CLASS2 (rvc_normal, rvc_nan): 683 case CLASS2 (rvc_inf, rvc_nan): 684 case CLASS2 (rvc_nan, rvc_nan): 685 /* ANY * NaN = NaN. */ 686 *r = *b; 687 /* Make resulting NaN value to be qNaN. The caller has the 688 responsibility to avoid the operation if flag_signaling_nans 689 is on. */ 690 r->signalling = 0; 691 r->sign = sign; 692 return false; 693 694 case CLASS2 (rvc_nan, rvc_zero): 695 case CLASS2 (rvc_nan, rvc_normal): 696 case CLASS2 (rvc_nan, rvc_inf): 697 /* NaN * ANY = NaN. */ 698 *r = *a; 699 /* Make resulting NaN value to be qNaN. The caller has the 700 responsibility to avoid the operation if flag_signaling_nans 701 is on. */ 702 r->signalling = 0; 703 r->sign = sign; 704 return false; 705 706 case CLASS2 (rvc_zero, rvc_inf): 707 case CLASS2 (rvc_inf, rvc_zero): 708 /* 0 * Inf = NaN */ 709 get_canonical_qnan (r, sign); 710 return false; 711 712 case CLASS2 (rvc_inf, rvc_inf): 713 case CLASS2 (rvc_normal, rvc_inf): 714 case CLASS2 (rvc_inf, rvc_normal): 715 /* Inf * Inf = Inf, R * Inf = Inf */ 716 get_inf (r, sign); 717 return false; 718 719 case CLASS2 (rvc_normal, rvc_normal): 720 break; 721 722 default: 723 gcc_unreachable (); 724 } 725 726 if (r == a || r == b) 727 rr = &t; 728 else 729 rr = r; 730 get_zero (rr, 0); 731 732 /* Collect all the partial products. Since we don't have sure access 733 to a widening multiply, we split each long into two half-words. 734 735 Consider the long-hand form of a four half-word multiplication: 736 737 A B C D 738 * E F G H 739 -------------- 740 DE DF DG DH 741 CE CF CG CH 742 BE BF BG BH 743 AE AF AG AH 744 745 We construct partial products of the widened half-word products 746 that are known to not overlap, e.g. DF+DH. Each such partial 747 product is given its proper exponent, which allows us to sum them 748 and obtain the finished product. */ 749 750 for (i = 0; i < SIGSZ * 2; ++i) 751 { 752 unsigned long ai = a->sig[i / 2]; 753 if (i & 1) 754 ai >>= HOST_BITS_PER_LONG / 2; 755 else 756 ai &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1; 757 758 if (ai == 0) 759 continue; 760 761 for (j = 0; j < 2; ++j) 762 { 763 int exp = (REAL_EXP (a) - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2) 764 + (REAL_EXP (b) - (1-j)*(HOST_BITS_PER_LONG/2))); 765 766 if (exp > MAX_EXP) 767 { 768 get_inf (r, sign); 769 return true; 770 } 771 if (exp < -MAX_EXP) 772 { 773 /* Would underflow to zero, which we shouldn't bother adding. */ 774 inexact = true; 775 continue; 776 } 777 778 memset (&u, 0, sizeof (u)); 779 u.cl = rvc_normal; 780 SET_REAL_EXP (&u, exp); 781 782 for (k = j; k < SIGSZ * 2; k += 2) 783 { 784 unsigned long bi = b->sig[k / 2]; 785 if (k & 1) 786 bi >>= HOST_BITS_PER_LONG / 2; 787 else 788 bi &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1; 789 790 u.sig[k / 2] = ai * bi; 791 } 792 793 normalize (&u); 794 inexact |= do_add (rr, rr, &u, 0); 795 } 796 } 797 798 rr->sign = sign; 799 if (rr != r) 800 *r = t; 801 802 return inexact; 803 } 804 805 /* Calculate R = A / B. Return true if the result may be inexact. */ 806 807 static bool 808 do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a, 809 const REAL_VALUE_TYPE *b) 810 { 811 int exp, sign = a->sign ^ b->sign; 812 REAL_VALUE_TYPE t, *rr; 813 bool inexact; 814 815 switch (CLASS2 (a->cl, b->cl)) 816 { 817 case CLASS2 (rvc_zero, rvc_zero): 818 /* 0 / 0 = NaN. */ 819 case CLASS2 (rvc_inf, rvc_inf): 820 /* Inf / Inf = NaN. */ 821 get_canonical_qnan (r, sign); 822 return false; 823 824 case CLASS2 (rvc_zero, rvc_normal): 825 case CLASS2 (rvc_zero, rvc_inf): 826 /* 0 / ANY = 0. */ 827 case CLASS2 (rvc_normal, rvc_inf): 828 /* R / Inf = 0. */ 829 get_zero (r, sign); 830 return false; 831 832 case CLASS2 (rvc_normal, rvc_zero): 833 /* R / 0 = Inf. */ 834 case CLASS2 (rvc_inf, rvc_zero): 835 /* Inf / 0 = Inf. */ 836 get_inf (r, sign); 837 return false; 838 839 case CLASS2 (rvc_zero, rvc_nan): 840 case CLASS2 (rvc_normal, rvc_nan): 841 case CLASS2 (rvc_inf, rvc_nan): 842 case CLASS2 (rvc_nan, rvc_nan): 843 /* ANY / NaN = NaN. */ 844 *r = *b; 845 /* Make resulting NaN value to be qNaN. The caller has the 846 responsibility to avoid the operation if flag_signaling_nans 847 is on. */ 848 r->signalling = 0; 849 r->sign = sign; 850 return false; 851 852 case CLASS2 (rvc_nan, rvc_zero): 853 case CLASS2 (rvc_nan, rvc_normal): 854 case CLASS2 (rvc_nan, rvc_inf): 855 /* NaN / ANY = NaN. */ 856 *r = *a; 857 /* Make resulting NaN value to be qNaN. The caller has the 858 responsibility to avoid the operation if flag_signaling_nans 859 is on. */ 860 r->signalling = 0; 861 r->sign = sign; 862 return false; 863 864 case CLASS2 (rvc_inf, rvc_normal): 865 /* Inf / R = Inf. */ 866 get_inf (r, sign); 867 return false; 868 869 case CLASS2 (rvc_normal, rvc_normal): 870 break; 871 872 default: 873 gcc_unreachable (); 874 } 875 876 if (r == a || r == b) 877 rr = &t; 878 else 879 rr = r; 880 881 /* Make sure all fields in the result are initialized. */ 882 get_zero (rr, 0); 883 rr->cl = rvc_normal; 884 rr->sign = sign; 885 886 exp = REAL_EXP (a) - REAL_EXP (b) + 1; 887 if (exp > MAX_EXP) 888 { 889 get_inf (r, sign); 890 return true; 891 } 892 if (exp < -MAX_EXP) 893 { 894 get_zero (r, sign); 895 return true; 896 } 897 SET_REAL_EXP (rr, exp); 898 899 inexact = div_significands (rr, a, b); 900 901 /* Re-normalize the result. */ 902 normalize (rr); 903 rr->sig[0] |= inexact; 904 905 if (rr != r) 906 *r = t; 907 908 return inexact; 909 } 910 911 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if 912 one of the two operands is a NaN. */ 913 914 static int 915 do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b, 916 int nan_result) 917 { 918 int ret; 919 920 switch (CLASS2 (a->cl, b->cl)) 921 { 922 case CLASS2 (rvc_zero, rvc_zero): 923 /* Sign of zero doesn't matter for compares. */ 924 return 0; 925 926 case CLASS2 (rvc_normal, rvc_zero): 927 /* Decimal float zero is special and uses rvc_normal, not rvc_zero. */ 928 if (a->decimal) 929 return decimal_do_compare (a, b, nan_result); 930 /* Fall through. */ 931 case CLASS2 (rvc_inf, rvc_zero): 932 case CLASS2 (rvc_inf, rvc_normal): 933 return (a->sign ? -1 : 1); 934 935 case CLASS2 (rvc_inf, rvc_inf): 936 return -a->sign - -b->sign; 937 938 case CLASS2 (rvc_zero, rvc_normal): 939 /* Decimal float zero is special and uses rvc_normal, not rvc_zero. */ 940 if (b->decimal) 941 return decimal_do_compare (a, b, nan_result); 942 /* Fall through. */ 943 case CLASS2 (rvc_zero, rvc_inf): 944 case CLASS2 (rvc_normal, rvc_inf): 945 return (b->sign ? 1 : -1); 946 947 case CLASS2 (rvc_zero, rvc_nan): 948 case CLASS2 (rvc_normal, rvc_nan): 949 case CLASS2 (rvc_inf, rvc_nan): 950 case CLASS2 (rvc_nan, rvc_nan): 951 case CLASS2 (rvc_nan, rvc_zero): 952 case CLASS2 (rvc_nan, rvc_normal): 953 case CLASS2 (rvc_nan, rvc_inf): 954 return nan_result; 955 956 case CLASS2 (rvc_normal, rvc_normal): 957 break; 958 959 default: 960 gcc_unreachable (); 961 } 962 963 if (a->decimal || b->decimal) 964 return decimal_do_compare (a, b, nan_result); 965 966 if (a->sign != b->sign) 967 return -a->sign - -b->sign; 968 969 if (REAL_EXP (a) > REAL_EXP (b)) 970 ret = 1; 971 else if (REAL_EXP (a) < REAL_EXP (b)) 972 ret = -1; 973 else 974 ret = cmp_significands (a, b); 975 976 return (a->sign ? -ret : ret); 977 } 978 979 /* Return A truncated to an integral value toward zero. */ 980 981 static void 982 do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a) 983 { 984 *r = *a; 985 986 switch (r->cl) 987 { 988 case rvc_zero: 989 case rvc_inf: 990 case rvc_nan: 991 /* Make resulting NaN value to be qNaN. The caller has the 992 responsibility to avoid the operation if flag_signaling_nans 993 is on. */ 994 r->signalling = 0; 995 break; 996 997 case rvc_normal: 998 if (r->decimal) 999 { 1000 decimal_do_fix_trunc (r, a); 1001 return; 1002 } 1003 if (REAL_EXP (r) <= 0) 1004 get_zero (r, r->sign); 1005 else if (REAL_EXP (r) < SIGNIFICAND_BITS) 1006 clear_significand_below (r, SIGNIFICAND_BITS - REAL_EXP (r)); 1007 break; 1008 1009 default: 1010 gcc_unreachable (); 1011 } 1012 } 1013 1014 /* Perform the binary or unary operation described by CODE. 1015 For a unary operation, leave OP1 NULL. This function returns 1016 true if the result may be inexact due to loss of precision. */ 1017 1018 bool 1019 real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0, 1020 const REAL_VALUE_TYPE *op1) 1021 { 1022 enum tree_code code = (enum tree_code) icode; 1023 1024 if (op0->decimal || (op1 && op1->decimal)) 1025 return decimal_real_arithmetic (r, code, op0, op1); 1026 1027 switch (code) 1028 { 1029 case PLUS_EXPR: 1030 /* Clear any padding areas in *r if it isn't equal to one of the 1031 operands so that we can later do bitwise comparisons later on. */ 1032 if (r != op0 && r != op1) 1033 memset (r, '\0', sizeof (*r)); 1034 return do_add (r, op0, op1, 0); 1035 1036 case MINUS_EXPR: 1037 if (r != op0 && r != op1) 1038 memset (r, '\0', sizeof (*r)); 1039 return do_add (r, op0, op1, 1); 1040 1041 case MULT_EXPR: 1042 if (r != op0 && r != op1) 1043 memset (r, '\0', sizeof (*r)); 1044 return do_multiply (r, op0, op1); 1045 1046 case RDIV_EXPR: 1047 if (r != op0 && r != op1) 1048 memset (r, '\0', sizeof (*r)); 1049 return do_divide (r, op0, op1); 1050 1051 case MIN_EXPR: 1052 if (op1->cl == rvc_nan) 1053 { 1054 *r = *op1; 1055 /* Make resulting NaN value to be qNaN. The caller has the 1056 responsibility to avoid the operation if flag_signaling_nans 1057 is on. */ 1058 r->signalling = 0; 1059 } 1060 else if (do_compare (op0, op1, -1) < 0) 1061 *r = *op0; 1062 else 1063 *r = *op1; 1064 break; 1065 1066 case MAX_EXPR: 1067 if (op1->cl == rvc_nan) 1068 { 1069 *r = *op1; 1070 /* Make resulting NaN value to be qNaN. The caller has the 1071 responsibility to avoid the operation if flag_signaling_nans 1072 is on. */ 1073 r->signalling = 0; 1074 } 1075 else if (do_compare (op0, op1, 1) < 0) 1076 *r = *op1; 1077 else 1078 *r = *op0; 1079 break; 1080 1081 case NEGATE_EXPR: 1082 *r = *op0; 1083 r->sign ^= 1; 1084 break; 1085 1086 case ABS_EXPR: 1087 *r = *op0; 1088 r->sign = 0; 1089 break; 1090 1091 case FIX_TRUNC_EXPR: 1092 do_fix_trunc (r, op0); 1093 break; 1094 1095 default: 1096 gcc_unreachable (); 1097 } 1098 return false; 1099 } 1100 1101 REAL_VALUE_TYPE 1102 real_value_negate (const REAL_VALUE_TYPE *op0) 1103 { 1104 REAL_VALUE_TYPE r; 1105 real_arithmetic (&r, NEGATE_EXPR, op0, NULL); 1106 return r; 1107 } 1108 1109 REAL_VALUE_TYPE 1110 real_value_abs (const REAL_VALUE_TYPE *op0) 1111 { 1112 REAL_VALUE_TYPE r; 1113 real_arithmetic (&r, ABS_EXPR, op0, NULL); 1114 return r; 1115 } 1116 1117 /* Return whether OP0 == OP1. */ 1118 1119 bool 1120 real_equal (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1) 1121 { 1122 return do_compare (op0, op1, -1) == 0; 1123 } 1124 1125 /* Return whether OP0 < OP1. */ 1126 1127 bool 1128 real_less (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1) 1129 { 1130 return do_compare (op0, op1, 1) < 0; 1131 } 1132 1133 bool 1134 real_compare (int icode, const REAL_VALUE_TYPE *op0, 1135 const REAL_VALUE_TYPE *op1) 1136 { 1137 enum tree_code code = (enum tree_code) icode; 1138 1139 switch (code) 1140 { 1141 case LT_EXPR: 1142 return real_less (op0, op1); 1143 case LE_EXPR: 1144 return do_compare (op0, op1, 1) <= 0; 1145 case GT_EXPR: 1146 return do_compare (op0, op1, -1) > 0; 1147 case GE_EXPR: 1148 return do_compare (op0, op1, -1) >= 0; 1149 case EQ_EXPR: 1150 return real_equal (op0, op1); 1151 case NE_EXPR: 1152 return do_compare (op0, op1, -1) != 0; 1153 case UNORDERED_EXPR: 1154 return op0->cl == rvc_nan || op1->cl == rvc_nan; 1155 case ORDERED_EXPR: 1156 return op0->cl != rvc_nan && op1->cl != rvc_nan; 1157 case UNLT_EXPR: 1158 return do_compare (op0, op1, -1) < 0; 1159 case UNLE_EXPR: 1160 return do_compare (op0, op1, -1) <= 0; 1161 case UNGT_EXPR: 1162 return do_compare (op0, op1, 1) > 0; 1163 case UNGE_EXPR: 1164 return do_compare (op0, op1, 1) >= 0; 1165 case UNEQ_EXPR: 1166 return do_compare (op0, op1, 0) == 0; 1167 case LTGT_EXPR: 1168 return do_compare (op0, op1, 0) != 0; 1169 1170 default: 1171 gcc_unreachable (); 1172 } 1173 } 1174 1175 /* Return floor log2(R). */ 1176 1177 int 1178 real_exponent (const REAL_VALUE_TYPE *r) 1179 { 1180 switch (r->cl) 1181 { 1182 case rvc_zero: 1183 return 0; 1184 case rvc_inf: 1185 case rvc_nan: 1186 return (unsigned int)-1 >> 1; 1187 case rvc_normal: 1188 return REAL_EXP (r); 1189 default: 1190 gcc_unreachable (); 1191 } 1192 } 1193 1194 /* R = OP0 * 2**EXP. */ 1195 1196 void 1197 real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp) 1198 { 1199 *r = *op0; 1200 switch (r->cl) 1201 { 1202 case rvc_zero: 1203 case rvc_inf: 1204 case rvc_nan: 1205 /* Make resulting NaN value to be qNaN. The caller has the 1206 responsibility to avoid the operation if flag_signaling_nans 1207 is on. */ 1208 r->signalling = 0; 1209 break; 1210 1211 case rvc_normal: 1212 exp += REAL_EXP (op0); 1213 if (exp > MAX_EXP) 1214 get_inf (r, r->sign); 1215 else if (exp < -MAX_EXP) 1216 get_zero (r, r->sign); 1217 else 1218 SET_REAL_EXP (r, exp); 1219 break; 1220 1221 default: 1222 gcc_unreachable (); 1223 } 1224 } 1225 1226 /* Determine whether a floating-point value X is infinite. */ 1227 1228 bool 1229 real_isinf (const REAL_VALUE_TYPE *r) 1230 { 1231 return (r->cl == rvc_inf); 1232 } 1233 1234 /* Determine whether a floating-point value X is a NaN. */ 1235 1236 bool 1237 real_isnan (const REAL_VALUE_TYPE *r) 1238 { 1239 return (r->cl == rvc_nan); 1240 } 1241 1242 /* Determine whether a floating-point value X is a signaling NaN. */ 1243 bool real_issignaling_nan (const REAL_VALUE_TYPE *r) 1244 { 1245 return real_isnan (r) && r->signalling; 1246 } 1247 1248 /* Determine whether a floating-point value X is finite. */ 1249 1250 bool 1251 real_isfinite (const REAL_VALUE_TYPE *r) 1252 { 1253 return (r->cl != rvc_nan) && (r->cl != rvc_inf); 1254 } 1255 1256 /* Determine whether a floating-point value X is negative. */ 1257 1258 bool 1259 real_isneg (const REAL_VALUE_TYPE *r) 1260 { 1261 return r->sign; 1262 } 1263 1264 /* Determine whether a floating-point value X is minus zero. */ 1265 1266 bool 1267 real_isnegzero (const REAL_VALUE_TYPE *r) 1268 { 1269 return r->sign && r->cl == rvc_zero; 1270 } 1271 1272 /* Compare two floating-point objects for bitwise identity. */ 1273 1274 bool 1275 real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b) 1276 { 1277 int i; 1278 1279 if (a->cl != b->cl) 1280 return false; 1281 if (a->sign != b->sign) 1282 return false; 1283 1284 switch (a->cl) 1285 { 1286 case rvc_zero: 1287 case rvc_inf: 1288 return true; 1289 1290 case rvc_normal: 1291 if (a->decimal != b->decimal) 1292 return false; 1293 if (REAL_EXP (a) != REAL_EXP (b)) 1294 return false; 1295 break; 1296 1297 case rvc_nan: 1298 if (a->signalling != b->signalling) 1299 return false; 1300 /* The significand is ignored for canonical NaNs. */ 1301 if (a->canonical || b->canonical) 1302 return a->canonical == b->canonical; 1303 break; 1304 1305 default: 1306 gcc_unreachable (); 1307 } 1308 1309 for (i = 0; i < SIGSZ; ++i) 1310 if (a->sig[i] != b->sig[i]) 1311 return false; 1312 1313 return true; 1314 } 1315 1316 /* Try to change R into its exact multiplicative inverse in format FMT. 1317 Return true if successful. */ 1318 1319 bool 1320 exact_real_inverse (format_helper fmt, REAL_VALUE_TYPE *r) 1321 { 1322 const REAL_VALUE_TYPE *one = real_digit (1); 1323 REAL_VALUE_TYPE u; 1324 int i; 1325 1326 if (r->cl != rvc_normal) 1327 return false; 1328 1329 /* Check for a power of two: all significand bits zero except the MSB. */ 1330 for (i = 0; i < SIGSZ-1; ++i) 1331 if (r->sig[i] != 0) 1332 return false; 1333 if (r->sig[SIGSZ-1] != SIG_MSB) 1334 return false; 1335 1336 /* Find the inverse and truncate to the required format. */ 1337 do_divide (&u, one, r); 1338 real_convert (&u, fmt, &u); 1339 1340 /* The rounding may have overflowed. */ 1341 if (u.cl != rvc_normal) 1342 return false; 1343 for (i = 0; i < SIGSZ-1; ++i) 1344 if (u.sig[i] != 0) 1345 return false; 1346 if (u.sig[SIGSZ-1] != SIG_MSB) 1347 return false; 1348 1349 *r = u; 1350 return true; 1351 } 1352 1353 /* Return true if arithmetic on values in IMODE that were promoted 1354 from values in TMODE is equivalent to direct arithmetic on values 1355 in TMODE. */ 1356 1357 bool 1358 real_can_shorten_arithmetic (machine_mode imode, machine_mode tmode) 1359 { 1360 const struct real_format *tfmt, *ifmt; 1361 tfmt = REAL_MODE_FORMAT (tmode); 1362 ifmt = REAL_MODE_FORMAT (imode); 1363 /* These conditions are conservative rather than trying to catch the 1364 exact boundary conditions; the main case to allow is IEEE float 1365 and double. */ 1366 return (ifmt->b == tfmt->b 1367 && ifmt->p > 2 * tfmt->p 1368 && ifmt->emin < 2 * tfmt->emin - tfmt->p - 2 1369 && ifmt->emin < tfmt->emin - tfmt->emax - tfmt->p - 2 1370 && ifmt->emax > 2 * tfmt->emax + 2 1371 && ifmt->emax > tfmt->emax - tfmt->emin + tfmt->p + 2 1372 && ifmt->round_towards_zero == tfmt->round_towards_zero 1373 && (ifmt->has_sign_dependent_rounding 1374 == tfmt->has_sign_dependent_rounding) 1375 && ifmt->has_nans >= tfmt->has_nans 1376 && ifmt->has_inf >= tfmt->has_inf 1377 && ifmt->has_signed_zero >= tfmt->has_signed_zero 1378 && !MODE_COMPOSITE_P (tmode) 1379 && !MODE_COMPOSITE_P (imode)); 1380 } 1381 1382 /* Render R as an integer. */ 1383 1384 HOST_WIDE_INT 1385 real_to_integer (const REAL_VALUE_TYPE *r) 1386 { 1387 unsigned HOST_WIDE_INT i; 1388 1389 switch (r->cl) 1390 { 1391 case rvc_zero: 1392 underflow: 1393 return 0; 1394 1395 case rvc_inf: 1396 case rvc_nan: 1397 overflow: 1398 i = HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1); 1399 if (!r->sign) 1400 i--; 1401 return i; 1402 1403 case rvc_normal: 1404 if (r->decimal) 1405 return decimal_real_to_integer (r); 1406 1407 if (REAL_EXP (r) <= 0) 1408 goto underflow; 1409 /* Only force overflow for unsigned overflow. Signed overflow is 1410 undefined, so it doesn't matter what we return, and some callers 1411 expect to be able to use this routine for both signed and 1412 unsigned conversions. */ 1413 if (REAL_EXP (r) > HOST_BITS_PER_WIDE_INT) 1414 goto overflow; 1415 1416 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG) 1417 i = r->sig[SIGSZ-1]; 1418 else 1419 { 1420 gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG); 1421 i = r->sig[SIGSZ-1]; 1422 i = i << (HOST_BITS_PER_LONG - 1) << 1; 1423 i |= r->sig[SIGSZ-2]; 1424 } 1425 1426 i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r); 1427 1428 if (r->sign) 1429 i = -i; 1430 return i; 1431 1432 default: 1433 gcc_unreachable (); 1434 } 1435 } 1436 1437 /* Likewise, but producing a wide-int of PRECISION. If the value cannot 1438 be represented in precision, *FAIL is set to TRUE. */ 1439 1440 wide_int 1441 real_to_integer (const REAL_VALUE_TYPE *r, bool *fail, int precision) 1442 { 1443 HOST_WIDE_INT val[2 * WIDE_INT_MAX_ELTS]; 1444 int exp; 1445 int words, w; 1446 wide_int result; 1447 1448 switch (r->cl) 1449 { 1450 case rvc_zero: 1451 underflow: 1452 return wi::zero (precision); 1453 1454 case rvc_inf: 1455 case rvc_nan: 1456 overflow: 1457 *fail = true; 1458 1459 if (r->sign) 1460 return wi::set_bit_in_zero (precision - 1, precision); 1461 else 1462 return ~wi::set_bit_in_zero (precision - 1, precision); 1463 1464 case rvc_normal: 1465 if (r->decimal) 1466 return decimal_real_to_integer (r, fail, precision); 1467 1468 exp = REAL_EXP (r); 1469 if (exp <= 0) 1470 goto underflow; 1471 /* Only force overflow for unsigned overflow. Signed overflow is 1472 undefined, so it doesn't matter what we return, and some callers 1473 expect to be able to use this routine for both signed and 1474 unsigned conversions. */ 1475 if (exp > precision) 1476 goto overflow; 1477 1478 /* Put the significand into a wide_int that has precision W, which 1479 is the smallest HWI-multiple that has at least PRECISION bits. 1480 This ensures that the top bit of the significand is in the 1481 top bit of the wide_int. */ 1482 words = (precision + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT; 1483 w = words * HOST_BITS_PER_WIDE_INT; 1484 1485 #if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG) 1486 for (int i = 0; i < words; i++) 1487 { 1488 int j = SIGSZ - words + i; 1489 val[i] = (j < 0) ? 0 : r->sig[j]; 1490 } 1491 #else 1492 gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG); 1493 for (int i = 0; i < words; i++) 1494 { 1495 int j = SIGSZ - (words * 2) + (i * 2); 1496 if (j < 0) 1497 val[i] = 0; 1498 else 1499 val[i] = r->sig[j]; 1500 j += 1; 1501 if (j >= 0) 1502 val[i] |= (unsigned HOST_WIDE_INT) r->sig[j] << HOST_BITS_PER_LONG; 1503 } 1504 #endif 1505 /* Shift the value into place and truncate to the desired precision. */ 1506 result = wide_int::from_array (val, words, w); 1507 result = wi::lrshift (result, w - exp); 1508 result = wide_int::from (result, precision, UNSIGNED); 1509 1510 if (r->sign) 1511 return -result; 1512 else 1513 return result; 1514 1515 default: 1516 gcc_unreachable (); 1517 } 1518 } 1519 1520 /* A subroutine of real_to_decimal. Compute the quotient and remainder 1521 of NUM / DEN. Return the quotient and place the remainder in NUM. 1522 It is expected that NUM / DEN are close enough that the quotient is 1523 small. */ 1524 1525 static unsigned long 1526 rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den) 1527 { 1528 unsigned long q, msb; 1529 int expn = REAL_EXP (num), expd = REAL_EXP (den); 1530 1531 if (expn < expd) 1532 return 0; 1533 1534 q = msb = 0; 1535 goto start; 1536 do 1537 { 1538 msb = num->sig[SIGSZ-1] & SIG_MSB; 1539 q <<= 1; 1540 lshift_significand_1 (num, num); 1541 start: 1542 if (msb || cmp_significands (num, den) >= 0) 1543 { 1544 sub_significands (num, num, den, 0); 1545 q |= 1; 1546 } 1547 } 1548 while (--expn >= expd); 1549 1550 SET_REAL_EXP (num, expd); 1551 normalize (num); 1552 1553 return q; 1554 } 1555 1556 /* Render R as a decimal floating point constant. Emit DIGITS significant 1557 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the 1558 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing 1559 zeros. If MODE is VOIDmode, round to nearest value. Otherwise, round 1560 to a string that, when parsed back in mode MODE, yields the same value. */ 1561 1562 #define M_LOG10_2 0.30102999566398119521 1563 1564 void 1565 real_to_decimal_for_mode (char *str, const REAL_VALUE_TYPE *r_orig, 1566 size_t buf_size, size_t digits, 1567 int crop_trailing_zeros, machine_mode mode) 1568 { 1569 const struct real_format *fmt = NULL; 1570 const REAL_VALUE_TYPE *one, *ten; 1571 REAL_VALUE_TYPE r, pten, u, v; 1572 int dec_exp, cmp_one, digit; 1573 size_t max_digits; 1574 char *p, *first, *last; 1575 bool sign; 1576 bool round_up; 1577 1578 if (mode != VOIDmode) 1579 { 1580 fmt = REAL_MODE_FORMAT (mode); 1581 gcc_assert (fmt); 1582 } 1583 1584 r = *r_orig; 1585 switch (r.cl) 1586 { 1587 case rvc_zero: 1588 strcpy (str, (r.sign ? "-0.0" : "0.0")); 1589 return; 1590 case rvc_normal: 1591 break; 1592 case rvc_inf: 1593 strcpy (str, (r.sign ? "-Inf" : "+Inf")); 1594 return; 1595 case rvc_nan: 1596 /* ??? Print the significand as well, if not canonical? */ 1597 sprintf (str, "%c%cNaN", (r_orig->sign ? '-' : '+'), 1598 (r_orig->signalling ? 'S' : 'Q')); 1599 return; 1600 default: 1601 gcc_unreachable (); 1602 } 1603 1604 if (r.decimal) 1605 { 1606 decimal_real_to_decimal (str, &r, buf_size, digits, crop_trailing_zeros); 1607 return; 1608 } 1609 1610 /* Bound the number of digits printed by the size of the representation. */ 1611 max_digits = SIGNIFICAND_BITS * M_LOG10_2; 1612 if (digits == 0 || digits > max_digits) 1613 digits = max_digits; 1614 1615 /* Estimate the decimal exponent, and compute the length of the string it 1616 will print as. Be conservative and add one to account for possible 1617 overflow or rounding error. */ 1618 dec_exp = REAL_EXP (&r) * M_LOG10_2; 1619 for (max_digits = 1; dec_exp ; max_digits++) 1620 dec_exp /= 10; 1621 1622 /* Bound the number of digits printed by the size of the output buffer. */ 1623 max_digits = buf_size - 1 - 1 - 2 - max_digits - 1; 1624 gcc_assert (max_digits <= buf_size); 1625 if (digits > max_digits) 1626 digits = max_digits; 1627 1628 one = real_digit (1); 1629 ten = ten_to_ptwo (0); 1630 1631 sign = r.sign; 1632 r.sign = 0; 1633 1634 dec_exp = 0; 1635 pten = *one; 1636 1637 cmp_one = do_compare (&r, one, 0); 1638 if (cmp_one > 0) 1639 { 1640 int m; 1641 1642 /* Number is greater than one. Convert significand to an integer 1643 and strip trailing decimal zeros. */ 1644 1645 u = r; 1646 SET_REAL_EXP (&u, SIGNIFICAND_BITS - 1); 1647 1648 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */ 1649 m = floor_log2 (max_digits); 1650 1651 /* Iterate over the bits of the possible powers of 10 that might 1652 be present in U and eliminate them. That is, if we find that 1653 10**2**M divides U evenly, keep the division and increase 1654 DEC_EXP by 2**M. */ 1655 do 1656 { 1657 REAL_VALUE_TYPE t; 1658 1659 do_divide (&t, &u, ten_to_ptwo (m)); 1660 do_fix_trunc (&v, &t); 1661 if (cmp_significands (&v, &t) == 0) 1662 { 1663 u = t; 1664 dec_exp += 1 << m; 1665 } 1666 } 1667 while (--m >= 0); 1668 1669 /* Revert the scaling to integer that we performed earlier. */ 1670 SET_REAL_EXP (&u, REAL_EXP (&u) + REAL_EXP (&r) 1671 - (SIGNIFICAND_BITS - 1)); 1672 r = u; 1673 1674 /* Find power of 10. Do this by dividing out 10**2**M when 1675 this is larger than the current remainder. Fill PTEN with 1676 the power of 10 that we compute. */ 1677 if (REAL_EXP (&r) > 0) 1678 { 1679 m = floor_log2 ((int)(REAL_EXP (&r) * M_LOG10_2)) + 1; 1680 do 1681 { 1682 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m); 1683 if (do_compare (&u, ptentwo, 0) >= 0) 1684 { 1685 do_divide (&u, &u, ptentwo); 1686 do_multiply (&pten, &pten, ptentwo); 1687 dec_exp += 1 << m; 1688 } 1689 } 1690 while (--m >= 0); 1691 } 1692 else 1693 /* We managed to divide off enough tens in the above reduction 1694 loop that we've now got a negative exponent. Fall into the 1695 less-than-one code to compute the proper value for PTEN. */ 1696 cmp_one = -1; 1697 } 1698 if (cmp_one < 0) 1699 { 1700 int m; 1701 1702 /* Number is less than one. Pad significand with leading 1703 decimal zeros. */ 1704 1705 v = r; 1706 while (1) 1707 { 1708 /* Stop if we'd shift bits off the bottom. */ 1709 if (v.sig[0] & 7) 1710 break; 1711 1712 do_multiply (&u, &v, ten); 1713 1714 /* Stop if we're now >= 1. */ 1715 if (REAL_EXP (&u) > 0) 1716 break; 1717 1718 v = u; 1719 dec_exp -= 1; 1720 } 1721 r = v; 1722 1723 /* Find power of 10. Do this by multiplying in P=10**2**M when 1724 the current remainder is smaller than 1/P. Fill PTEN with the 1725 power of 10 that we compute. */ 1726 m = floor_log2 ((int)(-REAL_EXP (&r) * M_LOG10_2)) + 1; 1727 do 1728 { 1729 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m); 1730 const REAL_VALUE_TYPE *ptenmtwo = ten_to_mptwo (m); 1731 1732 if (do_compare (&v, ptenmtwo, 0) <= 0) 1733 { 1734 do_multiply (&v, &v, ptentwo); 1735 do_multiply (&pten, &pten, ptentwo); 1736 dec_exp -= 1 << m; 1737 } 1738 } 1739 while (--m >= 0); 1740 1741 /* Invert the positive power of 10 that we've collected so far. */ 1742 do_divide (&pten, one, &pten); 1743 } 1744 1745 p = str; 1746 if (sign) 1747 *p++ = '-'; 1748 first = p++; 1749 1750 /* At this point, PTEN should contain the nearest power of 10 smaller 1751 than R, such that this division produces the first digit. 1752 1753 Using a divide-step primitive that returns the complete integral 1754 remainder avoids the rounding error that would be produced if 1755 we were to use do_divide here and then simply multiply by 10 for 1756 each subsequent digit. */ 1757 1758 digit = rtd_divmod (&r, &pten); 1759 1760 /* Be prepared for error in that division via underflow ... */ 1761 if (digit == 0 && cmp_significand_0 (&r)) 1762 { 1763 /* Multiply by 10 and try again. */ 1764 do_multiply (&r, &r, ten); 1765 digit = rtd_divmod (&r, &pten); 1766 dec_exp -= 1; 1767 gcc_assert (digit != 0); 1768 } 1769 1770 /* ... or overflow. */ 1771 if (digit == 10) 1772 { 1773 *p++ = '1'; 1774 if (--digits > 0) 1775 *p++ = '0'; 1776 dec_exp += 1; 1777 } 1778 else 1779 { 1780 gcc_assert (digit <= 10); 1781 *p++ = digit + '0'; 1782 } 1783 1784 /* Generate subsequent digits. */ 1785 while (--digits > 0) 1786 { 1787 do_multiply (&r, &r, ten); 1788 digit = rtd_divmod (&r, &pten); 1789 *p++ = digit + '0'; 1790 } 1791 last = p; 1792 1793 /* Generate one more digit with which to do rounding. */ 1794 do_multiply (&r, &r, ten); 1795 digit = rtd_divmod (&r, &pten); 1796 1797 /* Round the result. */ 1798 if (fmt && fmt->round_towards_zero) 1799 { 1800 /* If the format uses round towards zero when parsing the string 1801 back in, we need to always round away from zero here. */ 1802 if (cmp_significand_0 (&r)) 1803 digit++; 1804 round_up = digit > 0; 1805 } 1806 else 1807 { 1808 if (digit == 5) 1809 { 1810 /* Round to nearest. If R is nonzero there are additional 1811 nonzero digits to be extracted. */ 1812 if (cmp_significand_0 (&r)) 1813 digit++; 1814 /* Round to even. */ 1815 else if ((p[-1] - '0') & 1) 1816 digit++; 1817 } 1818 1819 round_up = digit > 5; 1820 } 1821 1822 if (round_up) 1823 { 1824 while (p > first) 1825 { 1826 digit = *--p; 1827 if (digit == '9') 1828 *p = '0'; 1829 else 1830 { 1831 *p = digit + 1; 1832 break; 1833 } 1834 } 1835 1836 /* Carry out of the first digit. This means we had all 9's and 1837 now have all 0's. "Prepend" a 1 by overwriting the first 0. */ 1838 if (p == first) 1839 { 1840 first[1] = '1'; 1841 dec_exp++; 1842 } 1843 } 1844 1845 /* Insert the decimal point. */ 1846 first[0] = first[1]; 1847 first[1] = '.'; 1848 1849 /* If requested, drop trailing zeros. Never crop past "1.0". */ 1850 if (crop_trailing_zeros) 1851 while (last > first + 3 && last[-1] == '0') 1852 last--; 1853 1854 /* Append the exponent. */ 1855 sprintf (last, "e%+d", dec_exp); 1856 1857 /* Verify that we can read the original value back in. */ 1858 if (flag_checking && mode != VOIDmode) 1859 { 1860 real_from_string (&r, str); 1861 real_convert (&r, mode, &r); 1862 gcc_assert (real_identical (&r, r_orig)); 1863 } 1864 } 1865 1866 /* Likewise, except always uses round-to-nearest. */ 1867 1868 void 1869 real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size, 1870 size_t digits, int crop_trailing_zeros) 1871 { 1872 real_to_decimal_for_mode (str, r_orig, buf_size, 1873 digits, crop_trailing_zeros, VOIDmode); 1874 } 1875 1876 /* Render R as a hexadecimal floating point constant. Emit DIGITS 1877 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0, 1878 choose the maximum for the representation. If CROP_TRAILING_ZEROS, 1879 strip trailing zeros. */ 1880 1881 void 1882 real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size, 1883 size_t digits, int crop_trailing_zeros) 1884 { 1885 int i, j, exp = REAL_EXP (r); 1886 char *p, *first; 1887 char exp_buf[16]; 1888 size_t max_digits; 1889 1890 switch (r->cl) 1891 { 1892 case rvc_zero: 1893 exp = 0; 1894 break; 1895 case rvc_normal: 1896 break; 1897 case rvc_inf: 1898 strcpy (str, (r->sign ? "-Inf" : "+Inf")); 1899 return; 1900 case rvc_nan: 1901 /* ??? Print the significand as well, if not canonical? */ 1902 sprintf (str, "%c%cNaN", (r->sign ? '-' : '+'), 1903 (r->signalling ? 'S' : 'Q')); 1904 return; 1905 default: 1906 gcc_unreachable (); 1907 } 1908 1909 if (r->decimal) 1910 { 1911 /* Hexadecimal format for decimal floats is not interesting. */ 1912 strcpy (str, "N/A"); 1913 return; 1914 } 1915 1916 if (digits == 0) 1917 digits = SIGNIFICAND_BITS / 4; 1918 1919 /* Bound the number of digits printed by the size of the output buffer. */ 1920 1921 sprintf (exp_buf, "p%+d", exp); 1922 max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1; 1923 gcc_assert (max_digits <= buf_size); 1924 if (digits > max_digits) 1925 digits = max_digits; 1926 1927 p = str; 1928 if (r->sign) 1929 *p++ = '-'; 1930 *p++ = '0'; 1931 *p++ = 'x'; 1932 *p++ = '0'; 1933 *p++ = '.'; 1934 first = p; 1935 1936 for (i = SIGSZ - 1; i >= 0; --i) 1937 for (j = HOST_BITS_PER_LONG - 4; j >= 0; j -= 4) 1938 { 1939 *p++ = "0123456789abcdef"[(r->sig[i] >> j) & 15]; 1940 if (--digits == 0) 1941 goto out; 1942 } 1943 1944 out: 1945 if (crop_trailing_zeros) 1946 while (p > first + 1 && p[-1] == '0') 1947 p--; 1948 1949 sprintf (p, "p%+d", exp); 1950 } 1951 1952 /* Initialize R from a decimal or hexadecimal string. The string is 1953 assumed to have been syntax checked already. Return -1 if the 1954 value underflows, +1 if overflows, and 0 otherwise. */ 1955 1956 int 1957 real_from_string (REAL_VALUE_TYPE *r, const char *str) 1958 { 1959 int exp = 0; 1960 bool sign = false; 1961 1962 get_zero (r, 0); 1963 1964 if (*str == '-') 1965 { 1966 sign = true; 1967 str++; 1968 } 1969 else if (*str == '+') 1970 str++; 1971 1972 if (!strncmp (str, "QNaN", 4)) 1973 { 1974 get_canonical_qnan (r, sign); 1975 return 0; 1976 } 1977 else if (!strncmp (str, "SNaN", 4)) 1978 { 1979 get_canonical_snan (r, sign); 1980 return 0; 1981 } 1982 else if (!strncmp (str, "Inf", 3)) 1983 { 1984 get_inf (r, sign); 1985 return 0; 1986 } 1987 1988 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) 1989 { 1990 /* Hexadecimal floating point. */ 1991 int pos = SIGNIFICAND_BITS - 4, d; 1992 1993 str += 2; 1994 1995 while (*str == '0') 1996 str++; 1997 while (1) 1998 { 1999 d = hex_value (*str); 2000 if (d == _hex_bad) 2001 break; 2002 if (pos >= 0) 2003 { 2004 r->sig[pos / HOST_BITS_PER_LONG] 2005 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG); 2006 pos -= 4; 2007 } 2008 else if (d) 2009 /* Ensure correct rounding by setting last bit if there is 2010 a subsequent nonzero digit. */ 2011 r->sig[0] |= 1; 2012 exp += 4; 2013 str++; 2014 } 2015 if (*str == '.') 2016 { 2017 str++; 2018 if (pos == SIGNIFICAND_BITS - 4) 2019 { 2020 while (*str == '0') 2021 str++, exp -= 4; 2022 } 2023 while (1) 2024 { 2025 d = hex_value (*str); 2026 if (d == _hex_bad) 2027 break; 2028 if (pos >= 0) 2029 { 2030 r->sig[pos / HOST_BITS_PER_LONG] 2031 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG); 2032 pos -= 4; 2033 } 2034 else if (d) 2035 /* Ensure correct rounding by setting last bit if there is 2036 a subsequent nonzero digit. */ 2037 r->sig[0] |= 1; 2038 str++; 2039 } 2040 } 2041 2042 /* If the mantissa is zero, ignore the exponent. */ 2043 if (!cmp_significand_0 (r)) 2044 goto is_a_zero; 2045 2046 if (*str == 'p' || *str == 'P') 2047 { 2048 bool exp_neg = false; 2049 2050 str++; 2051 if (*str == '-') 2052 { 2053 exp_neg = true; 2054 str++; 2055 } 2056 else if (*str == '+') 2057 str++; 2058 2059 d = 0; 2060 while (ISDIGIT (*str)) 2061 { 2062 d *= 10; 2063 d += *str - '0'; 2064 if (d > MAX_EXP) 2065 { 2066 /* Overflowed the exponent. */ 2067 if (exp_neg) 2068 goto underflow; 2069 else 2070 goto overflow; 2071 } 2072 str++; 2073 } 2074 if (exp_neg) 2075 d = -d; 2076 2077 exp += d; 2078 } 2079 2080 r->cl = rvc_normal; 2081 SET_REAL_EXP (r, exp); 2082 2083 normalize (r); 2084 } 2085 else 2086 { 2087 /* Decimal floating point. */ 2088 const char *cstr = str; 2089 mpfr_t m; 2090 bool inexact; 2091 2092 while (*cstr == '0') 2093 cstr++; 2094 if (*cstr == '.') 2095 { 2096 cstr++; 2097 while (*cstr == '0') 2098 cstr++; 2099 } 2100 2101 /* If the mantissa is zero, ignore the exponent. */ 2102 if (!ISDIGIT (*cstr)) 2103 goto is_a_zero; 2104 2105 /* Nonzero value, possibly overflowing or underflowing. */ 2106 mpfr_init2 (m, SIGNIFICAND_BITS); 2107 inexact = mpfr_strtofr (m, str, NULL, 10, GMP_RNDZ); 2108 /* The result should never be a NaN, and because the rounding is 2109 toward zero should never be an infinity. */ 2110 gcc_assert (!mpfr_nan_p (m) && !mpfr_inf_p (m)); 2111 if (mpfr_zero_p (m) || mpfr_get_exp (m) < -MAX_EXP + 4) 2112 { 2113 mpfr_clear (m); 2114 goto underflow; 2115 } 2116 else if (mpfr_get_exp (m) > MAX_EXP - 4) 2117 { 2118 mpfr_clear (m); 2119 goto overflow; 2120 } 2121 else 2122 { 2123 real_from_mpfr (r, m, NULL_TREE, GMP_RNDZ); 2124 /* 1 to 3 bits may have been shifted off (with a sticky bit) 2125 because the hex digits used in real_from_mpfr did not 2126 start with a digit 8 to f, but the exponent bounds above 2127 should have avoided underflow or overflow. */ 2128 gcc_assert (r->cl == rvc_normal); 2129 /* Set a sticky bit if mpfr_strtofr was inexact. */ 2130 r->sig[0] |= inexact; 2131 mpfr_clear (m); 2132 } 2133 } 2134 2135 r->sign = sign; 2136 return 0; 2137 2138 is_a_zero: 2139 get_zero (r, sign); 2140 return 0; 2141 2142 underflow: 2143 get_zero (r, sign); 2144 return -1; 2145 2146 overflow: 2147 get_inf (r, sign); 2148 return 1; 2149 } 2150 2151 /* Legacy. Similar, but return the result directly. */ 2152 2153 REAL_VALUE_TYPE 2154 real_from_string2 (const char *s, format_helper fmt) 2155 { 2156 REAL_VALUE_TYPE r; 2157 2158 real_from_string (&r, s); 2159 if (fmt) 2160 real_convert (&r, fmt, &r); 2161 2162 return r; 2163 } 2164 2165 /* Initialize R from string S and desired format FMT. */ 2166 2167 void 2168 real_from_string3 (REAL_VALUE_TYPE *r, const char *s, format_helper fmt) 2169 { 2170 if (fmt.decimal_p ()) 2171 decimal_real_from_string (r, s); 2172 else 2173 real_from_string (r, s); 2174 2175 if (fmt) 2176 real_convert (r, fmt, r); 2177 } 2178 2179 /* Initialize R from the wide_int VAL_IN. Round it to format FMT if 2180 FMT is nonnull. */ 2181 2182 void 2183 real_from_integer (REAL_VALUE_TYPE *r, format_helper fmt, 2184 const wide_int_ref &val_in, signop sgn) 2185 { 2186 if (val_in == 0) 2187 get_zero (r, 0); 2188 else 2189 { 2190 unsigned int len = val_in.get_precision (); 2191 int i, j, e = 0; 2192 int maxbitlen = MAX_BITSIZE_MODE_ANY_INT + HOST_BITS_PER_WIDE_INT; 2193 const unsigned int realmax = (SIGNIFICAND_BITS / HOST_BITS_PER_WIDE_INT 2194 * HOST_BITS_PER_WIDE_INT); 2195 2196 memset (r, 0, sizeof (*r)); 2197 r->cl = rvc_normal; 2198 r->sign = wi::neg_p (val_in, sgn); 2199 2200 /* We have to ensure we can negate the largest negative number. */ 2201 wide_int val = wide_int::from (val_in, maxbitlen, sgn); 2202 2203 if (r->sign) 2204 val = -val; 2205 2206 /* Ensure a multiple of HOST_BITS_PER_WIDE_INT, ceiling, as elt 2207 won't work with precisions that are not a multiple of 2208 HOST_BITS_PER_WIDE_INT. */ 2209 len += HOST_BITS_PER_WIDE_INT - 1; 2210 2211 /* Ensure we can represent the largest negative number. */ 2212 len += 1; 2213 2214 len = len/HOST_BITS_PER_WIDE_INT * HOST_BITS_PER_WIDE_INT; 2215 2216 /* Cap the size to the size allowed by real.h. */ 2217 if (len > realmax) 2218 { 2219 HOST_WIDE_INT cnt_l_z; 2220 cnt_l_z = wi::clz (val); 2221 2222 if (maxbitlen - cnt_l_z > realmax) 2223 { 2224 e = maxbitlen - cnt_l_z - realmax; 2225 2226 /* This value is too large, we must shift it right to 2227 preserve all the bits we can, and then bump the 2228 exponent up by that amount. */ 2229 val = wi::lrshift (val, e); 2230 } 2231 len = realmax; 2232 } 2233 2234 /* Clear out top bits so elt will work with precisions that aren't 2235 a multiple of HOST_BITS_PER_WIDE_INT. */ 2236 val = wide_int::from (val, len, sgn); 2237 len = len / HOST_BITS_PER_WIDE_INT; 2238 2239 SET_REAL_EXP (r, len * HOST_BITS_PER_WIDE_INT + e); 2240 2241 j = SIGSZ - 1; 2242 if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT) 2243 for (i = len - 1; i >= 0; i--) 2244 { 2245 r->sig[j--] = val.elt (i); 2246 if (j < 0) 2247 break; 2248 } 2249 else 2250 { 2251 gcc_assert (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT); 2252 for (i = len - 1; i >= 0; i--) 2253 { 2254 HOST_WIDE_INT e = val.elt (i); 2255 r->sig[j--] = e >> (HOST_BITS_PER_LONG - 1) >> 1; 2256 if (j < 0) 2257 break; 2258 r->sig[j--] = e; 2259 if (j < 0) 2260 break; 2261 } 2262 } 2263 2264 normalize (r); 2265 } 2266 2267 if (fmt.decimal_p ()) 2268 decimal_from_integer (r); 2269 if (fmt) 2270 real_convert (r, fmt, r); 2271 } 2272 2273 /* Render R, an integral value, as a floating point constant with no 2274 specified exponent. */ 2275 2276 static void 2277 decimal_integer_string (char *str, const REAL_VALUE_TYPE *r_orig, 2278 size_t buf_size) 2279 { 2280 int dec_exp, digit, digits; 2281 REAL_VALUE_TYPE r, pten; 2282 char *p; 2283 bool sign; 2284 2285 r = *r_orig; 2286 2287 if (r.cl == rvc_zero) 2288 { 2289 strcpy (str, "0."); 2290 return; 2291 } 2292 2293 sign = r.sign; 2294 r.sign = 0; 2295 2296 dec_exp = REAL_EXP (&r) * M_LOG10_2; 2297 digits = dec_exp + 1; 2298 gcc_assert ((digits + 2) < (int)buf_size); 2299 2300 pten = *real_digit (1); 2301 times_pten (&pten, dec_exp); 2302 2303 p = str; 2304 if (sign) 2305 *p++ = '-'; 2306 2307 digit = rtd_divmod (&r, &pten); 2308 gcc_assert (digit >= 0 && digit <= 9); 2309 *p++ = digit + '0'; 2310 while (--digits > 0) 2311 { 2312 times_pten (&r, 1); 2313 digit = rtd_divmod (&r, &pten); 2314 *p++ = digit + '0'; 2315 } 2316 *p++ = '.'; 2317 *p++ = '\0'; 2318 } 2319 2320 /* Convert a real with an integral value to decimal float. */ 2321 2322 static void 2323 decimal_from_integer (REAL_VALUE_TYPE *r) 2324 { 2325 char str[256]; 2326 2327 decimal_integer_string (str, r, sizeof (str) - 1); 2328 decimal_real_from_string (r, str); 2329 } 2330 2331 /* Returns 10**2**N. */ 2332 2333 static const REAL_VALUE_TYPE * 2334 ten_to_ptwo (int n) 2335 { 2336 static REAL_VALUE_TYPE tens[EXP_BITS]; 2337 2338 gcc_assert (n >= 0); 2339 gcc_assert (n < EXP_BITS); 2340 2341 if (tens[n].cl == rvc_zero) 2342 { 2343 if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4)) 2344 { 2345 HOST_WIDE_INT t = 10; 2346 int i; 2347 2348 for (i = 0; i < n; ++i) 2349 t *= t; 2350 2351 real_from_integer (&tens[n], VOIDmode, t, UNSIGNED); 2352 } 2353 else 2354 { 2355 const REAL_VALUE_TYPE *t = ten_to_ptwo (n - 1); 2356 do_multiply (&tens[n], t, t); 2357 } 2358 } 2359 2360 return &tens[n]; 2361 } 2362 2363 /* Returns 10**(-2**N). */ 2364 2365 static const REAL_VALUE_TYPE * 2366 ten_to_mptwo (int n) 2367 { 2368 static REAL_VALUE_TYPE tens[EXP_BITS]; 2369 2370 gcc_assert (n >= 0); 2371 gcc_assert (n < EXP_BITS); 2372 2373 if (tens[n].cl == rvc_zero) 2374 do_divide (&tens[n], real_digit (1), ten_to_ptwo (n)); 2375 2376 return &tens[n]; 2377 } 2378 2379 /* Returns N. */ 2380 2381 static const REAL_VALUE_TYPE * 2382 real_digit (int n) 2383 { 2384 static REAL_VALUE_TYPE num[10]; 2385 2386 gcc_assert (n >= 0); 2387 gcc_assert (n <= 9); 2388 2389 if (n > 0 && num[n].cl == rvc_zero) 2390 real_from_integer (&num[n], VOIDmode, n, UNSIGNED); 2391 2392 return &num[n]; 2393 } 2394 2395 /* Multiply R by 10**EXP. */ 2396 2397 static void 2398 times_pten (REAL_VALUE_TYPE *r, int exp) 2399 { 2400 REAL_VALUE_TYPE pten, *rr; 2401 bool negative = (exp < 0); 2402 int i; 2403 2404 if (negative) 2405 { 2406 exp = -exp; 2407 pten = *real_digit (1); 2408 rr = &pten; 2409 } 2410 else 2411 rr = r; 2412 2413 for (i = 0; exp > 0; ++i, exp >>= 1) 2414 if (exp & 1) 2415 do_multiply (rr, rr, ten_to_ptwo (i)); 2416 2417 if (negative) 2418 do_divide (r, r, &pten); 2419 } 2420 2421 /* Returns the special REAL_VALUE_TYPE corresponding to 'e'. */ 2422 2423 const REAL_VALUE_TYPE * 2424 dconst_e_ptr (void) 2425 { 2426 static REAL_VALUE_TYPE value; 2427 2428 /* Initialize mathematical constants for constant folding builtins. 2429 These constants need to be given to at least 160 bits precision. */ 2430 if (value.cl == rvc_zero) 2431 { 2432 mpfr_t m; 2433 mpfr_init2 (m, SIGNIFICAND_BITS); 2434 mpfr_set_ui (m, 1, GMP_RNDN); 2435 mpfr_exp (m, m, GMP_RNDN); 2436 real_from_mpfr (&value, m, NULL_TREE, GMP_RNDN); 2437 mpfr_clear (m); 2438 2439 } 2440 return &value; 2441 } 2442 2443 /* Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n. */ 2444 2445 #define CACHED_FRACTION(NAME, N) \ 2446 const REAL_VALUE_TYPE * \ 2447 NAME (void) \ 2448 { \ 2449 static REAL_VALUE_TYPE value; \ 2450 \ 2451 /* Initialize mathematical constants for constant folding builtins. \ 2452 These constants need to be given to at least 160 bits \ 2453 precision. */ \ 2454 if (value.cl == rvc_zero) \ 2455 real_arithmetic (&value, RDIV_EXPR, &dconst1, real_digit (N)); \ 2456 return &value; \ 2457 } 2458 2459 CACHED_FRACTION (dconst_third_ptr, 3) 2460 CACHED_FRACTION (dconst_quarter_ptr, 4) 2461 CACHED_FRACTION (dconst_sixth_ptr, 6) 2462 CACHED_FRACTION (dconst_ninth_ptr, 9) 2463 2464 /* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2). */ 2465 2466 const REAL_VALUE_TYPE * 2467 dconst_sqrt2_ptr (void) 2468 { 2469 static REAL_VALUE_TYPE value; 2470 2471 /* Initialize mathematical constants for constant folding builtins. 2472 These constants need to be given to at least 160 bits precision. */ 2473 if (value.cl == rvc_zero) 2474 { 2475 mpfr_t m; 2476 mpfr_init2 (m, SIGNIFICAND_BITS); 2477 mpfr_sqrt_ui (m, 2, GMP_RNDN); 2478 real_from_mpfr (&value, m, NULL_TREE, GMP_RNDN); 2479 mpfr_clear (m); 2480 } 2481 return &value; 2482 } 2483 2484 /* Fills R with +Inf. */ 2485 2486 void 2487 real_inf (REAL_VALUE_TYPE *r) 2488 { 2489 get_inf (r, 0); 2490 } 2491 2492 /* Fills R with a NaN whose significand is described by STR. If QUIET, 2493 we force a QNaN, else we force an SNaN. The string, if not empty, 2494 is parsed as a number and placed in the significand. Return true 2495 if the string was successfully parsed. */ 2496 2497 bool 2498 real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet, 2499 format_helper fmt) 2500 { 2501 if (*str == 0) 2502 { 2503 if (quiet) 2504 get_canonical_qnan (r, 0); 2505 else 2506 get_canonical_snan (r, 0); 2507 } 2508 else 2509 { 2510 int base = 10, d; 2511 2512 memset (r, 0, sizeof (*r)); 2513 r->cl = rvc_nan; 2514 2515 /* Parse akin to strtol into the significand of R. */ 2516 2517 while (ISSPACE (*str)) 2518 str++; 2519 if (*str == '-') 2520 str++; 2521 else if (*str == '+') 2522 str++; 2523 if (*str == '0') 2524 { 2525 str++; 2526 if (*str == 'x' || *str == 'X') 2527 { 2528 base = 16; 2529 str++; 2530 } 2531 else 2532 base = 8; 2533 } 2534 2535 while ((d = hex_value (*str)) < base) 2536 { 2537 REAL_VALUE_TYPE u; 2538 2539 switch (base) 2540 { 2541 case 8: 2542 lshift_significand (r, r, 3); 2543 break; 2544 case 16: 2545 lshift_significand (r, r, 4); 2546 break; 2547 case 10: 2548 lshift_significand_1 (&u, r); 2549 lshift_significand (r, r, 3); 2550 add_significands (r, r, &u); 2551 break; 2552 default: 2553 gcc_unreachable (); 2554 } 2555 2556 get_zero (&u, 0); 2557 u.sig[0] = d; 2558 add_significands (r, r, &u); 2559 2560 str++; 2561 } 2562 2563 /* Must have consumed the entire string for success. */ 2564 if (*str != 0) 2565 return false; 2566 2567 /* Shift the significand into place such that the bits 2568 are in the most significant bits for the format. */ 2569 lshift_significand (r, r, SIGNIFICAND_BITS - fmt->pnan); 2570 2571 /* Our MSB is always unset for NaNs. */ 2572 r->sig[SIGSZ-1] &= ~SIG_MSB; 2573 2574 /* Force quiet or signaling NaN. */ 2575 r->signalling = !quiet; 2576 } 2577 2578 return true; 2579 } 2580 2581 /* Fills R with the largest finite value representable in mode MODE. 2582 If SIGN is nonzero, R is set to the most negative finite value. */ 2583 2584 void 2585 real_maxval (REAL_VALUE_TYPE *r, int sign, machine_mode mode) 2586 { 2587 const struct real_format *fmt; 2588 int np2; 2589 2590 fmt = REAL_MODE_FORMAT (mode); 2591 gcc_assert (fmt); 2592 memset (r, 0, sizeof (*r)); 2593 2594 if (fmt->b == 10) 2595 decimal_real_maxval (r, sign, mode); 2596 else 2597 { 2598 r->cl = rvc_normal; 2599 r->sign = sign; 2600 SET_REAL_EXP (r, fmt->emax); 2601 2602 np2 = SIGNIFICAND_BITS - fmt->p; 2603 memset (r->sig, -1, SIGSZ * sizeof (unsigned long)); 2604 clear_significand_below (r, np2); 2605 2606 if (fmt->pnan < fmt->p) 2607 /* This is an IBM extended double format made up of two IEEE 2608 doubles. The value of the long double is the sum of the 2609 values of the two parts. The most significant part is 2610 required to be the value of the long double rounded to the 2611 nearest double. Rounding means we need a slightly smaller 2612 value for LDBL_MAX. */ 2613 clear_significand_bit (r, SIGNIFICAND_BITS - fmt->pnan - 1); 2614 } 2615 } 2616 2617 /* Fills R with 2**N. */ 2618 2619 void 2620 real_2expN (REAL_VALUE_TYPE *r, int n, format_helper fmt) 2621 { 2622 memset (r, 0, sizeof (*r)); 2623 2624 n++; 2625 if (n > MAX_EXP) 2626 r->cl = rvc_inf; 2627 else if (n < -MAX_EXP) 2628 ; 2629 else 2630 { 2631 r->cl = rvc_normal; 2632 SET_REAL_EXP (r, n); 2633 r->sig[SIGSZ-1] = SIG_MSB; 2634 } 2635 if (fmt.decimal_p ()) 2636 decimal_real_convert (r, fmt, r); 2637 } 2638 2639 2640 static void 2641 round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r) 2642 { 2643 int p2, np2, i, w; 2644 int emin2m1, emax2; 2645 bool round_up = false; 2646 2647 if (r->decimal) 2648 { 2649 if (fmt->b == 10) 2650 { 2651 decimal_round_for_format (fmt, r); 2652 return; 2653 } 2654 /* FIXME. We can come here via fp_easy_constant 2655 (e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not 2656 investigated whether this convert needs to be here, or 2657 something else is missing. */ 2658 decimal_real_convert (r, REAL_MODE_FORMAT (DFmode), r); 2659 } 2660 2661 p2 = fmt->p; 2662 emin2m1 = fmt->emin - 1; 2663 emax2 = fmt->emax; 2664 2665 np2 = SIGNIFICAND_BITS - p2; 2666 switch (r->cl) 2667 { 2668 underflow: 2669 get_zero (r, r->sign); 2670 /* FALLTHRU */ 2671 case rvc_zero: 2672 if (!fmt->has_signed_zero) 2673 r->sign = 0; 2674 return; 2675 2676 overflow: 2677 get_inf (r, r->sign); 2678 case rvc_inf: 2679 return; 2680 2681 case rvc_nan: 2682 clear_significand_below (r, np2); 2683 return; 2684 2685 case rvc_normal: 2686 break; 2687 2688 default: 2689 gcc_unreachable (); 2690 } 2691 2692 /* Check the range of the exponent. If we're out of range, 2693 either underflow or overflow. */ 2694 if (REAL_EXP (r) > emax2) 2695 goto overflow; 2696 else if (REAL_EXP (r) <= emin2m1) 2697 { 2698 int diff; 2699 2700 if (!fmt->has_denorm) 2701 { 2702 /* Don't underflow completely until we've had a chance to round. */ 2703 if (REAL_EXP (r) < emin2m1) 2704 goto underflow; 2705 } 2706 else 2707 { 2708 diff = emin2m1 - REAL_EXP (r) + 1; 2709 if (diff > p2) 2710 goto underflow; 2711 2712 /* De-normalize the significand. */ 2713 r->sig[0] |= sticky_rshift_significand (r, r, diff); 2714 SET_REAL_EXP (r, REAL_EXP (r) + diff); 2715 } 2716 } 2717 2718 if (!fmt->round_towards_zero) 2719 { 2720 /* There are P2 true significand bits, followed by one guard bit, 2721 followed by one sticky bit, followed by stuff. Fold nonzero 2722 stuff into the sticky bit. */ 2723 unsigned long sticky; 2724 bool guard, lsb; 2725 2726 sticky = 0; 2727 for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i) 2728 sticky |= r->sig[i]; 2729 sticky |= r->sig[w] 2730 & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1); 2731 2732 guard = test_significand_bit (r, np2 - 1); 2733 lsb = test_significand_bit (r, np2); 2734 2735 /* Round to even. */ 2736 round_up = guard && (sticky || lsb); 2737 } 2738 2739 if (round_up) 2740 { 2741 REAL_VALUE_TYPE u; 2742 get_zero (&u, 0); 2743 set_significand_bit (&u, np2); 2744 2745 if (add_significands (r, r, &u)) 2746 { 2747 /* Overflow. Means the significand had been all ones, and 2748 is now all zeros. Need to increase the exponent, and 2749 possibly re-normalize it. */ 2750 SET_REAL_EXP (r, REAL_EXP (r) + 1); 2751 if (REAL_EXP (r) > emax2) 2752 goto overflow; 2753 r->sig[SIGSZ-1] = SIG_MSB; 2754 } 2755 } 2756 2757 /* Catch underflow that we deferred until after rounding. */ 2758 if (REAL_EXP (r) <= emin2m1) 2759 goto underflow; 2760 2761 /* Clear out trailing garbage. */ 2762 clear_significand_below (r, np2); 2763 } 2764 2765 /* Extend or truncate to a new format. */ 2766 2767 void 2768 real_convert (REAL_VALUE_TYPE *r, format_helper fmt, 2769 const REAL_VALUE_TYPE *a) 2770 { 2771 *r = *a; 2772 2773 if (a->decimal || fmt->b == 10) 2774 decimal_real_convert (r, fmt, a); 2775 2776 round_for_format (fmt, r); 2777 2778 /* Make resulting NaN value to be qNaN. The caller has the 2779 responsibility to avoid the operation if flag_signaling_nans 2780 is on. */ 2781 if (r->cl == rvc_nan) 2782 r->signalling = 0; 2783 2784 /* round_for_format de-normalizes denormals. Undo just that part. */ 2785 if (r->cl == rvc_normal) 2786 normalize (r); 2787 } 2788 2789 /* Legacy. Likewise, except return the struct directly. */ 2790 2791 REAL_VALUE_TYPE 2792 real_value_truncate (format_helper fmt, REAL_VALUE_TYPE a) 2793 { 2794 REAL_VALUE_TYPE r; 2795 real_convert (&r, fmt, &a); 2796 return r; 2797 } 2798 2799 /* Return true if truncating to FMT is exact. */ 2800 2801 bool 2802 exact_real_truncate (format_helper fmt, const REAL_VALUE_TYPE *a) 2803 { 2804 REAL_VALUE_TYPE t; 2805 int emin2m1; 2806 2807 /* Don't allow conversion to denormals. */ 2808 emin2m1 = fmt->emin - 1; 2809 if (REAL_EXP (a) <= emin2m1) 2810 return false; 2811 2812 /* After conversion to the new format, the value must be identical. */ 2813 real_convert (&t, fmt, a); 2814 return real_identical (&t, a); 2815 } 2816 2817 /* Write R to the given target format. Place the words of the result 2818 in target word order in BUF. There are always 32 bits in each 2819 long, no matter the size of the host long. 2820 2821 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */ 2822 2823 long 2824 real_to_target (long *buf, const REAL_VALUE_TYPE *r_orig, 2825 format_helper fmt) 2826 { 2827 REAL_VALUE_TYPE r; 2828 long buf1; 2829 2830 r = *r_orig; 2831 round_for_format (fmt, &r); 2832 2833 if (!buf) 2834 buf = &buf1; 2835 (*fmt->encode) (fmt, buf, &r); 2836 2837 return *buf; 2838 } 2839 2840 /* Read R from the given target format. Read the words of the result 2841 in target word order in BUF. There are always 32 bits in each 2842 long, no matter the size of the host long. */ 2843 2844 void 2845 real_from_target (REAL_VALUE_TYPE *r, const long *buf, format_helper fmt) 2846 { 2847 (*fmt->decode) (fmt, r, buf); 2848 } 2849 2850 /* Return the number of bits of the largest binary value that the 2851 significand of FMT will hold. */ 2852 /* ??? Legacy. Should get access to real_format directly. */ 2853 2854 int 2855 significand_size (format_helper fmt) 2856 { 2857 if (fmt == NULL) 2858 return 0; 2859 2860 if (fmt->b == 10) 2861 { 2862 /* Return the size in bits of the largest binary value that can be 2863 held by the decimal coefficient for this format. This is one more 2864 than the number of bits required to hold the largest coefficient 2865 of this format. */ 2866 double log2_10 = 3.3219281; 2867 return fmt->p * log2_10; 2868 } 2869 return fmt->p; 2870 } 2871 2872 /* Return a hash value for the given real value. */ 2873 /* ??? The "unsigned int" return value is intended to be hashval_t, 2874 but I didn't want to pull hashtab.h into real.h. */ 2875 2876 unsigned int 2877 real_hash (const REAL_VALUE_TYPE *r) 2878 { 2879 unsigned int h; 2880 size_t i; 2881 2882 h = r->cl | (r->sign << 2); 2883 switch (r->cl) 2884 { 2885 case rvc_zero: 2886 case rvc_inf: 2887 return h; 2888 2889 case rvc_normal: 2890 h |= (unsigned int)REAL_EXP (r) << 3; 2891 break; 2892 2893 case rvc_nan: 2894 if (r->signalling) 2895 h ^= (unsigned int)-1; 2896 if (r->canonical) 2897 return h; 2898 break; 2899 2900 default: 2901 gcc_unreachable (); 2902 } 2903 2904 if (sizeof (unsigned long) > sizeof (unsigned int)) 2905 for (i = 0; i < SIGSZ; ++i) 2906 { 2907 unsigned long s = r->sig[i]; 2908 h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2)); 2909 } 2910 else 2911 for (i = 0; i < SIGSZ; ++i) 2912 h ^= r->sig[i]; 2913 2914 return h; 2915 } 2916 2917 /* IEEE single-precision format. */ 2918 2919 static void encode_ieee_single (const struct real_format *fmt, 2920 long *, const REAL_VALUE_TYPE *); 2921 static void decode_ieee_single (const struct real_format *, 2922 REAL_VALUE_TYPE *, const long *); 2923 2924 static void 2925 encode_ieee_single (const struct real_format *fmt, long *buf, 2926 const REAL_VALUE_TYPE *r) 2927 { 2928 unsigned long image, sig, exp; 2929 unsigned long sign = r->sign; 2930 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0; 2931 2932 image = sign << 31; 2933 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff; 2934 2935 switch (r->cl) 2936 { 2937 case rvc_zero: 2938 break; 2939 2940 case rvc_inf: 2941 if (fmt->has_inf) 2942 image |= 255 << 23; 2943 else 2944 image |= 0x7fffffff; 2945 break; 2946 2947 case rvc_nan: 2948 if (fmt->has_nans) 2949 { 2950 if (r->canonical) 2951 sig = (fmt->canonical_nan_lsbs_set ? (1 << 22) - 1 : 0); 2952 if (r->signalling == fmt->qnan_msb_set) 2953 sig &= ~(1 << 22); 2954 else 2955 sig |= 1 << 22; 2956 if (sig == 0) 2957 sig = 1 << 21; 2958 2959 image |= 255 << 23; 2960 image |= sig; 2961 } 2962 else 2963 image |= 0x7fffffff; 2964 break; 2965 2966 case rvc_normal: 2967 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp, 2968 whereas the intermediate representation is 0.F x 2**exp. 2969 Which means we're off by one. */ 2970 if (denormal) 2971 exp = 0; 2972 else 2973 exp = REAL_EXP (r) + 127 - 1; 2974 image |= exp << 23; 2975 image |= sig; 2976 break; 2977 2978 default: 2979 gcc_unreachable (); 2980 } 2981 2982 buf[0] = image; 2983 } 2984 2985 static void 2986 decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r, 2987 const long *buf) 2988 { 2989 unsigned long image = buf[0] & 0xffffffff; 2990 bool sign = (image >> 31) & 1; 2991 int exp = (image >> 23) & 0xff; 2992 2993 memset (r, 0, sizeof (*r)); 2994 image <<= HOST_BITS_PER_LONG - 24; 2995 image &= ~SIG_MSB; 2996 2997 if (exp == 0) 2998 { 2999 if (image && fmt->has_denorm) 3000 { 3001 r->cl = rvc_normal; 3002 r->sign = sign; 3003 SET_REAL_EXP (r, -126); 3004 r->sig[SIGSZ-1] = image << 1; 3005 normalize (r); 3006 } 3007 else if (fmt->has_signed_zero) 3008 r->sign = sign; 3009 } 3010 else if (exp == 255 && (fmt->has_nans || fmt->has_inf)) 3011 { 3012 if (image) 3013 { 3014 r->cl = rvc_nan; 3015 r->sign = sign; 3016 r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1) 3017 ^ fmt->qnan_msb_set); 3018 r->sig[SIGSZ-1] = image; 3019 } 3020 else 3021 { 3022 r->cl = rvc_inf; 3023 r->sign = sign; 3024 } 3025 } 3026 else 3027 { 3028 r->cl = rvc_normal; 3029 r->sign = sign; 3030 SET_REAL_EXP (r, exp - 127 + 1); 3031 r->sig[SIGSZ-1] = image | SIG_MSB; 3032 } 3033 } 3034 3035 const struct real_format ieee_single_format = 3036 { 3037 encode_ieee_single, 3038 decode_ieee_single, 3039 2, 3040 24, 3041 24, 3042 -125, 3043 128, 3044 31, 3045 31, 3046 32, 3047 false, 3048 true, 3049 true, 3050 true, 3051 true, 3052 true, 3053 true, 3054 false, 3055 "ieee_single" 3056 }; 3057 3058 const struct real_format mips_single_format = 3059 { 3060 encode_ieee_single, 3061 decode_ieee_single, 3062 2, 3063 24, 3064 24, 3065 -125, 3066 128, 3067 31, 3068 31, 3069 32, 3070 false, 3071 true, 3072 true, 3073 true, 3074 true, 3075 true, 3076 false, 3077 true, 3078 "mips_single" 3079 }; 3080 3081 const struct real_format motorola_single_format = 3082 { 3083 encode_ieee_single, 3084 decode_ieee_single, 3085 2, 3086 24, 3087 24, 3088 -125, 3089 128, 3090 31, 3091 31, 3092 32, 3093 false, 3094 true, 3095 true, 3096 true, 3097 true, 3098 true, 3099 true, 3100 true, 3101 "motorola_single" 3102 }; 3103 3104 /* SPU Single Precision (Extended-Range Mode) format is the same as IEEE 3105 single precision with the following differences: 3106 - Infinities are not supported. Instead MAX_FLOAT or MIN_FLOAT 3107 are generated. 3108 - NaNs are not supported. 3109 - The range of non-zero numbers in binary is 3110 (001)[1.]000...000 to (255)[1.]111...111. 3111 - Denormals can be represented, but are treated as +0.0 when 3112 used as an operand and are never generated as a result. 3113 - -0.0 can be represented, but a zero result is always +0.0. 3114 - the only supported rounding mode is trunction (towards zero). */ 3115 const struct real_format spu_single_format = 3116 { 3117 encode_ieee_single, 3118 decode_ieee_single, 3119 2, 3120 24, 3121 24, 3122 -125, 3123 129, 3124 31, 3125 31, 3126 0, 3127 true, 3128 false, 3129 false, 3130 false, 3131 true, 3132 true, 3133 false, 3134 false, 3135 "spu_single" 3136 }; 3137 3138 /* IEEE double-precision format. */ 3139 3140 static void encode_ieee_double (const struct real_format *fmt, 3141 long *, const REAL_VALUE_TYPE *); 3142 static void decode_ieee_double (const struct real_format *, 3143 REAL_VALUE_TYPE *, const long *); 3144 3145 static void 3146 encode_ieee_double (const struct real_format *fmt, long *buf, 3147 const REAL_VALUE_TYPE *r) 3148 { 3149 unsigned long image_lo, image_hi, sig_lo, sig_hi, exp; 3150 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0; 3151 3152 image_hi = r->sign << 31; 3153 image_lo = 0; 3154 3155 if (HOST_BITS_PER_LONG == 64) 3156 { 3157 sig_hi = r->sig[SIGSZ-1]; 3158 sig_lo = (sig_hi >> (64 - 53)) & 0xffffffff; 3159 sig_hi = (sig_hi >> (64 - 53 + 1) >> 31) & 0xfffff; 3160 } 3161 else 3162 { 3163 sig_hi = r->sig[SIGSZ-1]; 3164 sig_lo = r->sig[SIGSZ-2]; 3165 sig_lo = (sig_hi << 21) | (sig_lo >> 11); 3166 sig_hi = (sig_hi >> 11) & 0xfffff; 3167 } 3168 3169 switch (r->cl) 3170 { 3171 case rvc_zero: 3172 break; 3173 3174 case rvc_inf: 3175 if (fmt->has_inf) 3176 image_hi |= 2047 << 20; 3177 else 3178 { 3179 image_hi |= 0x7fffffff; 3180 image_lo = 0xffffffff; 3181 } 3182 break; 3183 3184 case rvc_nan: 3185 if (fmt->has_nans) 3186 { 3187 if (r->canonical) 3188 { 3189 if (fmt->canonical_nan_lsbs_set) 3190 { 3191 sig_hi = (1 << 19) - 1; 3192 sig_lo = 0xffffffff; 3193 } 3194 else 3195 { 3196 sig_hi = 0; 3197 sig_lo = 0; 3198 } 3199 } 3200 if (r->signalling == fmt->qnan_msb_set) 3201 sig_hi &= ~(1 << 19); 3202 else 3203 sig_hi |= 1 << 19; 3204 if (sig_hi == 0 && sig_lo == 0) 3205 sig_hi = 1 << 18; 3206 3207 image_hi |= 2047 << 20; 3208 image_hi |= sig_hi; 3209 image_lo = sig_lo; 3210 } 3211 else 3212 { 3213 image_hi |= 0x7fffffff; 3214 image_lo = 0xffffffff; 3215 } 3216 break; 3217 3218 case rvc_normal: 3219 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp, 3220 whereas the intermediate representation is 0.F x 2**exp. 3221 Which means we're off by one. */ 3222 if (denormal) 3223 exp = 0; 3224 else 3225 exp = REAL_EXP (r) + 1023 - 1; 3226 image_hi |= exp << 20; 3227 image_hi |= sig_hi; 3228 image_lo = sig_lo; 3229 break; 3230 3231 default: 3232 gcc_unreachable (); 3233 } 3234 3235 if (FLOAT_WORDS_BIG_ENDIAN) 3236 buf[0] = image_hi, buf[1] = image_lo; 3237 else 3238 buf[0] = image_lo, buf[1] = image_hi; 3239 } 3240 3241 static void 3242 decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r, 3243 const long *buf) 3244 { 3245 unsigned long image_hi, image_lo; 3246 bool sign; 3247 int exp; 3248 3249 if (FLOAT_WORDS_BIG_ENDIAN) 3250 image_hi = buf[0], image_lo = buf[1]; 3251 else 3252 image_lo = buf[0], image_hi = buf[1]; 3253 image_lo &= 0xffffffff; 3254 image_hi &= 0xffffffff; 3255 3256 sign = (image_hi >> 31) & 1; 3257 exp = (image_hi >> 20) & 0x7ff; 3258 3259 memset (r, 0, sizeof (*r)); 3260 3261 image_hi <<= 32 - 21; 3262 image_hi |= image_lo >> 21; 3263 image_hi &= 0x7fffffff; 3264 image_lo <<= 32 - 21; 3265 3266 if (exp == 0) 3267 { 3268 if ((image_hi || image_lo) && fmt->has_denorm) 3269 { 3270 r->cl = rvc_normal; 3271 r->sign = sign; 3272 SET_REAL_EXP (r, -1022); 3273 if (HOST_BITS_PER_LONG == 32) 3274 { 3275 image_hi = (image_hi << 1) | (image_lo >> 31); 3276 image_lo <<= 1; 3277 r->sig[SIGSZ-1] = image_hi; 3278 r->sig[SIGSZ-2] = image_lo; 3279 } 3280 else 3281 { 3282 image_hi = (image_hi << 31 << 2) | (image_lo << 1); 3283 r->sig[SIGSZ-1] = image_hi; 3284 } 3285 normalize (r); 3286 } 3287 else if (fmt->has_signed_zero) 3288 r->sign = sign; 3289 } 3290 else if (exp == 2047 && (fmt->has_nans || fmt->has_inf)) 3291 { 3292 if (image_hi || image_lo) 3293 { 3294 r->cl = rvc_nan; 3295 r->sign = sign; 3296 r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set; 3297 if (HOST_BITS_PER_LONG == 32) 3298 { 3299 r->sig[SIGSZ-1] = image_hi; 3300 r->sig[SIGSZ-2] = image_lo; 3301 } 3302 else 3303 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo; 3304 } 3305 else 3306 { 3307 r->cl = rvc_inf; 3308 r->sign = sign; 3309 } 3310 } 3311 else 3312 { 3313 r->cl = rvc_normal; 3314 r->sign = sign; 3315 SET_REAL_EXP (r, exp - 1023 + 1); 3316 if (HOST_BITS_PER_LONG == 32) 3317 { 3318 r->sig[SIGSZ-1] = image_hi | SIG_MSB; 3319 r->sig[SIGSZ-2] = image_lo; 3320 } 3321 else 3322 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo | SIG_MSB; 3323 } 3324 } 3325 3326 const struct real_format ieee_double_format = 3327 { 3328 encode_ieee_double, 3329 decode_ieee_double, 3330 2, 3331 53, 3332 53, 3333 -1021, 3334 1024, 3335 63, 3336 63, 3337 64, 3338 false, 3339 true, 3340 true, 3341 true, 3342 true, 3343 true, 3344 true, 3345 false, 3346 "ieee_double" 3347 }; 3348 3349 const struct real_format mips_double_format = 3350 { 3351 encode_ieee_double, 3352 decode_ieee_double, 3353 2, 3354 53, 3355 53, 3356 -1021, 3357 1024, 3358 63, 3359 63, 3360 64, 3361 false, 3362 true, 3363 true, 3364 true, 3365 true, 3366 true, 3367 false, 3368 true, 3369 "mips_double" 3370 }; 3371 3372 const struct real_format motorola_double_format = 3373 { 3374 encode_ieee_double, 3375 decode_ieee_double, 3376 2, 3377 53, 3378 53, 3379 -1021, 3380 1024, 3381 63, 3382 63, 3383 64, 3384 false, 3385 true, 3386 true, 3387 true, 3388 true, 3389 true, 3390 true, 3391 true, 3392 "motorola_double" 3393 }; 3394 3395 /* IEEE extended real format. This comes in three flavors: Intel's as 3396 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel 3397 12- and 16-byte images may be big- or little endian; Motorola's is 3398 always big endian. */ 3399 3400 /* Helper subroutine which converts from the internal format to the 3401 12-byte little-endian Intel format. Functions below adjust this 3402 for the other possible formats. */ 3403 static void 3404 encode_ieee_extended (const struct real_format *fmt, long *buf, 3405 const REAL_VALUE_TYPE *r) 3406 { 3407 unsigned long image_hi, sig_hi, sig_lo; 3408 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0; 3409 3410 image_hi = r->sign << 15; 3411 sig_hi = sig_lo = 0; 3412 3413 switch (r->cl) 3414 { 3415 case rvc_zero: 3416 break; 3417 3418 case rvc_inf: 3419 if (fmt->has_inf) 3420 { 3421 image_hi |= 32767; 3422 3423 /* Intel requires the explicit integer bit to be set, otherwise 3424 it considers the value a "pseudo-infinity". Motorola docs 3425 say it doesn't care. */ 3426 sig_hi = 0x80000000; 3427 } 3428 else 3429 { 3430 image_hi |= 32767; 3431 sig_lo = sig_hi = 0xffffffff; 3432 } 3433 break; 3434 3435 case rvc_nan: 3436 if (fmt->has_nans) 3437 { 3438 image_hi |= 32767; 3439 if (r->canonical) 3440 { 3441 if (fmt->canonical_nan_lsbs_set) 3442 { 3443 sig_hi = (1 << 30) - 1; 3444 sig_lo = 0xffffffff; 3445 } 3446 } 3447 else if (HOST_BITS_PER_LONG == 32) 3448 { 3449 sig_hi = r->sig[SIGSZ-1]; 3450 sig_lo = r->sig[SIGSZ-2]; 3451 } 3452 else 3453 { 3454 sig_lo = r->sig[SIGSZ-1]; 3455 sig_hi = sig_lo >> 31 >> 1; 3456 sig_lo &= 0xffffffff; 3457 } 3458 if (r->signalling == fmt->qnan_msb_set) 3459 sig_hi &= ~(1 << 30); 3460 else 3461 sig_hi |= 1 << 30; 3462 if ((sig_hi & 0x7fffffff) == 0 && sig_lo == 0) 3463 sig_hi = 1 << 29; 3464 3465 /* Intel requires the explicit integer bit to be set, otherwise 3466 it considers the value a "pseudo-nan". Motorola docs say it 3467 doesn't care. */ 3468 sig_hi |= 0x80000000; 3469 } 3470 else 3471 { 3472 image_hi |= 32767; 3473 sig_lo = sig_hi = 0xffffffff; 3474 } 3475 break; 3476 3477 case rvc_normal: 3478 { 3479 int exp = REAL_EXP (r); 3480 3481 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp, 3482 whereas the intermediate representation is 0.F x 2**exp. 3483 Which means we're off by one. 3484 3485 Except for Motorola, which consider exp=0 and explicit 3486 integer bit set to continue to be normalized. In theory 3487 this discrepancy has been taken care of by the difference 3488 in fmt->emin in round_for_format. */ 3489 3490 if (denormal) 3491 exp = 0; 3492 else 3493 { 3494 exp += 16383 - 1; 3495 gcc_assert (exp >= 0); 3496 } 3497 image_hi |= exp; 3498 3499 if (HOST_BITS_PER_LONG == 32) 3500 { 3501 sig_hi = r->sig[SIGSZ-1]; 3502 sig_lo = r->sig[SIGSZ-2]; 3503 } 3504 else 3505 { 3506 sig_lo = r->sig[SIGSZ-1]; 3507 sig_hi = sig_lo >> 31 >> 1; 3508 sig_lo &= 0xffffffff; 3509 } 3510 } 3511 break; 3512 3513 default: 3514 gcc_unreachable (); 3515 } 3516 3517 buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi; 3518 } 3519 3520 /* Convert from the internal format to the 12-byte Motorola format 3521 for an IEEE extended real. */ 3522 static void 3523 encode_ieee_extended_motorola (const struct real_format *fmt, long *buf, 3524 const REAL_VALUE_TYPE *r) 3525 { 3526 long intermed[3]; 3527 encode_ieee_extended (fmt, intermed, r); 3528 3529 if (r->cl == rvc_inf) 3530 /* For infinity clear the explicit integer bit again, so that the 3531 format matches the canonical infinity generated by the FPU. */ 3532 intermed[1] = 0; 3533 3534 /* Motorola chips are assumed always to be big-endian. Also, the 3535 padding in a Motorola extended real goes between the exponent and 3536 the mantissa. At this point the mantissa is entirely within 3537 elements 0 and 1 of intermed, and the exponent entirely within 3538 element 2, so all we have to do is swap the order around, and 3539 shift element 2 left 16 bits. */ 3540 buf[0] = intermed[2] << 16; 3541 buf[1] = intermed[1]; 3542 buf[2] = intermed[0]; 3543 } 3544 3545 /* Convert from the internal format to the 12-byte Intel format for 3546 an IEEE extended real. */ 3547 static void 3548 encode_ieee_extended_intel_96 (const struct real_format *fmt, long *buf, 3549 const REAL_VALUE_TYPE *r) 3550 { 3551 if (FLOAT_WORDS_BIG_ENDIAN) 3552 { 3553 /* All the padding in an Intel-format extended real goes at the high 3554 end, which in this case is after the mantissa, not the exponent. 3555 Therefore we must shift everything down 16 bits. */ 3556 long intermed[3]; 3557 encode_ieee_extended (fmt, intermed, r); 3558 buf[0] = ((intermed[2] << 16) | ((unsigned long)(intermed[1] & 0xFFFF0000) >> 16)); 3559 buf[1] = ((intermed[1] << 16) | ((unsigned long)(intermed[0] & 0xFFFF0000) >> 16)); 3560 buf[2] = (intermed[0] << 16); 3561 } 3562 else 3563 /* encode_ieee_extended produces what we want directly. */ 3564 encode_ieee_extended (fmt, buf, r); 3565 } 3566 3567 /* Convert from the internal format to the 16-byte Intel format for 3568 an IEEE extended real. */ 3569 static void 3570 encode_ieee_extended_intel_128 (const struct real_format *fmt, long *buf, 3571 const REAL_VALUE_TYPE *r) 3572 { 3573 /* All the padding in an Intel-format extended real goes at the high end. */ 3574 encode_ieee_extended_intel_96 (fmt, buf, r); 3575 buf[3] = 0; 3576 } 3577 3578 /* As above, we have a helper function which converts from 12-byte 3579 little-endian Intel format to internal format. Functions below 3580 adjust for the other possible formats. */ 3581 static void 3582 decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r, 3583 const long *buf) 3584 { 3585 unsigned long image_hi, sig_hi, sig_lo; 3586 bool sign; 3587 int exp; 3588 3589 sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2]; 3590 sig_lo &= 0xffffffff; 3591 sig_hi &= 0xffffffff; 3592 image_hi &= 0xffffffff; 3593 3594 sign = (image_hi >> 15) & 1; 3595 exp = image_hi & 0x7fff; 3596 3597 memset (r, 0, sizeof (*r)); 3598 3599 if (exp == 0) 3600 { 3601 if ((sig_hi || sig_lo) && fmt->has_denorm) 3602 { 3603 r->cl = rvc_normal; 3604 r->sign = sign; 3605 3606 /* When the IEEE format contains a hidden bit, we know that 3607 it's zero at this point, and so shift up the significand 3608 and decrease the exponent to match. In this case, Motorola 3609 defines the explicit integer bit to be valid, so we don't 3610 know whether the msb is set or not. */ 3611 SET_REAL_EXP (r, fmt->emin); 3612 if (HOST_BITS_PER_LONG == 32) 3613 { 3614 r->sig[SIGSZ-1] = sig_hi; 3615 r->sig[SIGSZ-2] = sig_lo; 3616 } 3617 else 3618 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo; 3619 3620 normalize (r); 3621 } 3622 else if (fmt->has_signed_zero) 3623 r->sign = sign; 3624 } 3625 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf)) 3626 { 3627 /* See above re "pseudo-infinities" and "pseudo-nans". 3628 Short summary is that the MSB will likely always be 3629 set, and that we don't care about it. */ 3630 sig_hi &= 0x7fffffff; 3631 3632 if (sig_hi || sig_lo) 3633 { 3634 r->cl = rvc_nan; 3635 r->sign = sign; 3636 r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set; 3637 if (HOST_BITS_PER_LONG == 32) 3638 { 3639 r->sig[SIGSZ-1] = sig_hi; 3640 r->sig[SIGSZ-2] = sig_lo; 3641 } 3642 else 3643 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo; 3644 } 3645 else 3646 { 3647 r->cl = rvc_inf; 3648 r->sign = sign; 3649 } 3650 } 3651 else 3652 { 3653 r->cl = rvc_normal; 3654 r->sign = sign; 3655 SET_REAL_EXP (r, exp - 16383 + 1); 3656 if (HOST_BITS_PER_LONG == 32) 3657 { 3658 r->sig[SIGSZ-1] = sig_hi; 3659 r->sig[SIGSZ-2] = sig_lo; 3660 } 3661 else 3662 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo; 3663 } 3664 } 3665 3666 /* Convert from the internal format to the 12-byte Motorola format 3667 for an IEEE extended real. */ 3668 static void 3669 decode_ieee_extended_motorola (const struct real_format *fmt, REAL_VALUE_TYPE *r, 3670 const long *buf) 3671 { 3672 long intermed[3]; 3673 3674 /* Motorola chips are assumed always to be big-endian. Also, the 3675 padding in a Motorola extended real goes between the exponent and 3676 the mantissa; remove it. */ 3677 intermed[0] = buf[2]; 3678 intermed[1] = buf[1]; 3679 intermed[2] = (unsigned long)buf[0] >> 16; 3680 3681 decode_ieee_extended (fmt, r, intermed); 3682 } 3683 3684 /* Convert from the internal format to the 12-byte Intel format for 3685 an IEEE extended real. */ 3686 static void 3687 decode_ieee_extended_intel_96 (const struct real_format *fmt, REAL_VALUE_TYPE *r, 3688 const long *buf) 3689 { 3690 if (FLOAT_WORDS_BIG_ENDIAN) 3691 { 3692 /* All the padding in an Intel-format extended real goes at the high 3693 end, which in this case is after the mantissa, not the exponent. 3694 Therefore we must shift everything up 16 bits. */ 3695 long intermed[3]; 3696 3697 intermed[0] = (((unsigned long)buf[2] >> 16) | (buf[1] << 16)); 3698 intermed[1] = (((unsigned long)buf[1] >> 16) | (buf[0] << 16)); 3699 intermed[2] = ((unsigned long)buf[0] >> 16); 3700 3701 decode_ieee_extended (fmt, r, intermed); 3702 } 3703 else 3704 /* decode_ieee_extended produces what we want directly. */ 3705 decode_ieee_extended (fmt, r, buf); 3706 } 3707 3708 /* Convert from the internal format to the 16-byte Intel format for 3709 an IEEE extended real. */ 3710 static void 3711 decode_ieee_extended_intel_128 (const struct real_format *fmt, REAL_VALUE_TYPE *r, 3712 const long *buf) 3713 { 3714 /* All the padding in an Intel-format extended real goes at the high end. */ 3715 decode_ieee_extended_intel_96 (fmt, r, buf); 3716 } 3717 3718 const struct real_format ieee_extended_motorola_format = 3719 { 3720 encode_ieee_extended_motorola, 3721 decode_ieee_extended_motorola, 3722 2, 3723 64, 3724 64, 3725 -16382, 3726 16384, 3727 95, 3728 95, 3729 0, 3730 false, 3731 true, 3732 true, 3733 true, 3734 true, 3735 true, 3736 true, 3737 true, 3738 "ieee_extended_motorola" 3739 }; 3740 3741 const struct real_format ieee_extended_intel_96_format = 3742 { 3743 encode_ieee_extended_intel_96, 3744 decode_ieee_extended_intel_96, 3745 2, 3746 64, 3747 64, 3748 -16381, 3749 16384, 3750 79, 3751 79, 3752 65, 3753 false, 3754 true, 3755 true, 3756 true, 3757 true, 3758 true, 3759 true, 3760 false, 3761 "ieee_extended_intel_96" 3762 }; 3763 3764 const struct real_format ieee_extended_intel_128_format = 3765 { 3766 encode_ieee_extended_intel_128, 3767 decode_ieee_extended_intel_128, 3768 2, 3769 64, 3770 64, 3771 -16381, 3772 16384, 3773 79, 3774 79, 3775 65, 3776 false, 3777 true, 3778 true, 3779 true, 3780 true, 3781 true, 3782 true, 3783 false, 3784 "ieee_extended_intel_128" 3785 }; 3786 3787 /* The following caters to i386 systems that set the rounding precision 3788 to 53 bits instead of 64, e.g. FreeBSD. */ 3789 const struct real_format ieee_extended_intel_96_round_53_format = 3790 { 3791 encode_ieee_extended_intel_96, 3792 decode_ieee_extended_intel_96, 3793 2, 3794 53, 3795 53, 3796 -16381, 3797 16384, 3798 79, 3799 79, 3800 33, 3801 false, 3802 true, 3803 true, 3804 true, 3805 true, 3806 true, 3807 true, 3808 false, 3809 "ieee_extended_intel_96_round_53" 3810 }; 3811 3812 /* IBM 128-bit extended precision format: a pair of IEEE double precision 3813 numbers whose sum is equal to the extended precision value. The number 3814 with greater magnitude is first. This format has the same magnitude 3815 range as an IEEE double precision value, but effectively 106 bits of 3816 significand precision. Infinity and NaN are represented by their IEEE 3817 double precision value stored in the first number, the second number is 3818 +0.0 or -0.0 for Infinity and don't-care for NaN. */ 3819 3820 static void encode_ibm_extended (const struct real_format *fmt, 3821 long *, const REAL_VALUE_TYPE *); 3822 static void decode_ibm_extended (const struct real_format *, 3823 REAL_VALUE_TYPE *, const long *); 3824 3825 static void 3826 encode_ibm_extended (const struct real_format *fmt, long *buf, 3827 const REAL_VALUE_TYPE *r) 3828 { 3829 REAL_VALUE_TYPE u, normr, v; 3830 const struct real_format *base_fmt; 3831 3832 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format; 3833 3834 /* Renormalize R before doing any arithmetic on it. */ 3835 normr = *r; 3836 if (normr.cl == rvc_normal) 3837 normalize (&normr); 3838 3839 /* u = IEEE double precision portion of significand. */ 3840 u = normr; 3841 round_for_format (base_fmt, &u); 3842 encode_ieee_double (base_fmt, &buf[0], &u); 3843 3844 if (u.cl == rvc_normal) 3845 { 3846 do_add (&v, &normr, &u, 1); 3847 /* Call round_for_format since we might need to denormalize. */ 3848 round_for_format (base_fmt, &v); 3849 encode_ieee_double (base_fmt, &buf[2], &v); 3850 } 3851 else 3852 { 3853 /* Inf, NaN, 0 are all representable as doubles, so the 3854 least-significant part can be 0.0. */ 3855 buf[2] = 0; 3856 buf[3] = 0; 3857 } 3858 } 3859 3860 static void 3861 decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_TYPE *r, 3862 const long *buf) 3863 { 3864 REAL_VALUE_TYPE u, v; 3865 const struct real_format *base_fmt; 3866 3867 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format; 3868 decode_ieee_double (base_fmt, &u, &buf[0]); 3869 3870 if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan) 3871 { 3872 decode_ieee_double (base_fmt, &v, &buf[2]); 3873 do_add (r, &u, &v, 0); 3874 } 3875 else 3876 *r = u; 3877 } 3878 3879 const struct real_format ibm_extended_format = 3880 { 3881 encode_ibm_extended, 3882 decode_ibm_extended, 3883 2, 3884 53 + 53, 3885 53, 3886 -1021 + 53, 3887 1024, 3888 127, 3889 -1, 3890 0, 3891 false, 3892 true, 3893 true, 3894 true, 3895 true, 3896 true, 3897 true, 3898 false, 3899 "ibm_extended" 3900 }; 3901 3902 const struct real_format mips_extended_format = 3903 { 3904 encode_ibm_extended, 3905 decode_ibm_extended, 3906 2, 3907 53 + 53, 3908 53, 3909 -1021 + 53, 3910 1024, 3911 127, 3912 -1, 3913 0, 3914 false, 3915 true, 3916 true, 3917 true, 3918 true, 3919 true, 3920 false, 3921 true, 3922 "mips_extended" 3923 }; 3924 3925 3926 /* IEEE quad precision format. */ 3927 3928 static void encode_ieee_quad (const struct real_format *fmt, 3929 long *, const REAL_VALUE_TYPE *); 3930 static void decode_ieee_quad (const struct real_format *, 3931 REAL_VALUE_TYPE *, const long *); 3932 3933 static void 3934 encode_ieee_quad (const struct real_format *fmt, long *buf, 3935 const REAL_VALUE_TYPE *r) 3936 { 3937 unsigned long image3, image2, image1, image0, exp; 3938 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0; 3939 REAL_VALUE_TYPE u; 3940 3941 image3 = r->sign << 31; 3942 image2 = 0; 3943 image1 = 0; 3944 image0 = 0; 3945 3946 rshift_significand (&u, r, SIGNIFICAND_BITS - 113); 3947 3948 switch (r->cl) 3949 { 3950 case rvc_zero: 3951 break; 3952 3953 case rvc_inf: 3954 if (fmt->has_inf) 3955 image3 |= 32767 << 16; 3956 else 3957 { 3958 image3 |= 0x7fffffff; 3959 image2 = 0xffffffff; 3960 image1 = 0xffffffff; 3961 image0 = 0xffffffff; 3962 } 3963 break; 3964 3965 case rvc_nan: 3966 if (fmt->has_nans) 3967 { 3968 image3 |= 32767 << 16; 3969 3970 if (r->canonical) 3971 { 3972 if (fmt->canonical_nan_lsbs_set) 3973 { 3974 image3 |= 0x7fff; 3975 image2 = image1 = image0 = 0xffffffff; 3976 } 3977 } 3978 else if (HOST_BITS_PER_LONG == 32) 3979 { 3980 image0 = u.sig[0]; 3981 image1 = u.sig[1]; 3982 image2 = u.sig[2]; 3983 image3 |= u.sig[3] & 0xffff; 3984 } 3985 else 3986 { 3987 image0 = u.sig[0]; 3988 image1 = image0 >> 31 >> 1; 3989 image2 = u.sig[1]; 3990 image3 |= (image2 >> 31 >> 1) & 0xffff; 3991 image0 &= 0xffffffff; 3992 image2 &= 0xffffffff; 3993 } 3994 if (r->signalling == fmt->qnan_msb_set) 3995 image3 &= ~0x8000; 3996 else 3997 image3 |= 0x8000; 3998 if (((image3 & 0xffff) | image2 | image1 | image0) == 0) 3999 image3 |= 0x4000; 4000 } 4001 else 4002 { 4003 image3 |= 0x7fffffff; 4004 image2 = 0xffffffff; 4005 image1 = 0xffffffff; 4006 image0 = 0xffffffff; 4007 } 4008 break; 4009 4010 case rvc_normal: 4011 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp, 4012 whereas the intermediate representation is 0.F x 2**exp. 4013 Which means we're off by one. */ 4014 if (denormal) 4015 exp = 0; 4016 else 4017 exp = REAL_EXP (r) + 16383 - 1; 4018 image3 |= exp << 16; 4019 4020 if (HOST_BITS_PER_LONG == 32) 4021 { 4022 image0 = u.sig[0]; 4023 image1 = u.sig[1]; 4024 image2 = u.sig[2]; 4025 image3 |= u.sig[3] & 0xffff; 4026 } 4027 else 4028 { 4029 image0 = u.sig[0]; 4030 image1 = image0 >> 31 >> 1; 4031 image2 = u.sig[1]; 4032 image3 |= (image2 >> 31 >> 1) & 0xffff; 4033 image0 &= 0xffffffff; 4034 image2 &= 0xffffffff; 4035 } 4036 break; 4037 4038 default: 4039 gcc_unreachable (); 4040 } 4041 4042 if (FLOAT_WORDS_BIG_ENDIAN) 4043 { 4044 buf[0] = image3; 4045 buf[1] = image2; 4046 buf[2] = image1; 4047 buf[3] = image0; 4048 } 4049 else 4050 { 4051 buf[0] = image0; 4052 buf[1] = image1; 4053 buf[2] = image2; 4054 buf[3] = image3; 4055 } 4056 } 4057 4058 static void 4059 decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r, 4060 const long *buf) 4061 { 4062 unsigned long image3, image2, image1, image0; 4063 bool sign; 4064 int exp; 4065 4066 if (FLOAT_WORDS_BIG_ENDIAN) 4067 { 4068 image3 = buf[0]; 4069 image2 = buf[1]; 4070 image1 = buf[2]; 4071 image0 = buf[3]; 4072 } 4073 else 4074 { 4075 image0 = buf[0]; 4076 image1 = buf[1]; 4077 image2 = buf[2]; 4078 image3 = buf[3]; 4079 } 4080 image0 &= 0xffffffff; 4081 image1 &= 0xffffffff; 4082 image2 &= 0xffffffff; 4083 4084 sign = (image3 >> 31) & 1; 4085 exp = (image3 >> 16) & 0x7fff; 4086 image3 &= 0xffff; 4087 4088 memset (r, 0, sizeof (*r)); 4089 4090 if (exp == 0) 4091 { 4092 if ((image3 | image2 | image1 | image0) && fmt->has_denorm) 4093 { 4094 r->cl = rvc_normal; 4095 r->sign = sign; 4096 4097 SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112)); 4098 if (HOST_BITS_PER_LONG == 32) 4099 { 4100 r->sig[0] = image0; 4101 r->sig[1] = image1; 4102 r->sig[2] = image2; 4103 r->sig[3] = image3; 4104 } 4105 else 4106 { 4107 r->sig[0] = (image1 << 31 << 1) | image0; 4108 r->sig[1] = (image3 << 31 << 1) | image2; 4109 } 4110 4111 normalize (r); 4112 } 4113 else if (fmt->has_signed_zero) 4114 r->sign = sign; 4115 } 4116 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf)) 4117 { 4118 if (image3 | image2 | image1 | image0) 4119 { 4120 r->cl = rvc_nan; 4121 r->sign = sign; 4122 r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set; 4123 4124 if (HOST_BITS_PER_LONG == 32) 4125 { 4126 r->sig[0] = image0; 4127 r->sig[1] = image1; 4128 r->sig[2] = image2; 4129 r->sig[3] = image3; 4130 } 4131 else 4132 { 4133 r->sig[0] = (image1 << 31 << 1) | image0; 4134 r->sig[1] = (image3 << 31 << 1) | image2; 4135 } 4136 lshift_significand (r, r, SIGNIFICAND_BITS - 113); 4137 } 4138 else 4139 { 4140 r->cl = rvc_inf; 4141 r->sign = sign; 4142 } 4143 } 4144 else 4145 { 4146 r->cl = rvc_normal; 4147 r->sign = sign; 4148 SET_REAL_EXP (r, exp - 16383 + 1); 4149 4150 if (HOST_BITS_PER_LONG == 32) 4151 { 4152 r->sig[0] = image0; 4153 r->sig[1] = image1; 4154 r->sig[2] = image2; 4155 r->sig[3] = image3; 4156 } 4157 else 4158 { 4159 r->sig[0] = (image1 << 31 << 1) | image0; 4160 r->sig[1] = (image3 << 31 << 1) | image2; 4161 } 4162 lshift_significand (r, r, SIGNIFICAND_BITS - 113); 4163 r->sig[SIGSZ-1] |= SIG_MSB; 4164 } 4165 } 4166 4167 const struct real_format ieee_quad_format = 4168 { 4169 encode_ieee_quad, 4170 decode_ieee_quad, 4171 2, 4172 113, 4173 113, 4174 -16381, 4175 16384, 4176 127, 4177 127, 4178 128, 4179 false, 4180 true, 4181 true, 4182 true, 4183 true, 4184 true, 4185 true, 4186 false, 4187 "ieee_quad" 4188 }; 4189 4190 const struct real_format mips_quad_format = 4191 { 4192 encode_ieee_quad, 4193 decode_ieee_quad, 4194 2, 4195 113, 4196 113, 4197 -16381, 4198 16384, 4199 127, 4200 127, 4201 128, 4202 false, 4203 true, 4204 true, 4205 true, 4206 true, 4207 true, 4208 false, 4209 true, 4210 "mips_quad" 4211 }; 4212 4213 /* Descriptions of VAX floating point formats can be found beginning at 4214 4215 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format 4216 4217 The thing to remember is that they're almost IEEE, except for word 4218 order, exponent bias, and the lack of infinities, nans, and denormals. 4219 4220 We don't implement the H_floating format here, simply because neither 4221 the VAX or Alpha ports use it. */ 4222 4223 static void encode_vax_f (const struct real_format *fmt, 4224 long *, const REAL_VALUE_TYPE *); 4225 static void decode_vax_f (const struct real_format *, 4226 REAL_VALUE_TYPE *, const long *); 4227 static void encode_vax_d (const struct real_format *fmt, 4228 long *, const REAL_VALUE_TYPE *); 4229 static void decode_vax_d (const struct real_format *, 4230 REAL_VALUE_TYPE *, const long *); 4231 static void encode_vax_g (const struct real_format *fmt, 4232 long *, const REAL_VALUE_TYPE *); 4233 static void decode_vax_g (const struct real_format *, 4234 REAL_VALUE_TYPE *, const long *); 4235 4236 static void 4237 encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf, 4238 const REAL_VALUE_TYPE *r) 4239 { 4240 unsigned long sign, exp, sig, image; 4241 4242 sign = r->sign << 15; 4243 4244 switch (r->cl) 4245 { 4246 case rvc_zero: 4247 image = 0; 4248 break; 4249 4250 case rvc_inf: 4251 case rvc_nan: 4252 image = 0xffff7fff | sign; 4253 break; 4254 4255 case rvc_normal: 4256 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff; 4257 exp = REAL_EXP (r) + 128; 4258 4259 image = (sig << 16) & 0xffff0000; 4260 image |= sign; 4261 image |= exp << 7; 4262 image |= sig >> 16; 4263 break; 4264 4265 default: 4266 gcc_unreachable (); 4267 } 4268 4269 buf[0] = image; 4270 } 4271 4272 static void 4273 decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, 4274 REAL_VALUE_TYPE *r, const long *buf) 4275 { 4276 unsigned long image = buf[0] & 0xffffffff; 4277 int exp = (image >> 7) & 0xff; 4278 4279 memset (r, 0, sizeof (*r)); 4280 4281 if (exp != 0) 4282 { 4283 r->cl = rvc_normal; 4284 r->sign = (image >> 15) & 1; 4285 SET_REAL_EXP (r, exp - 128); 4286 4287 image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff); 4288 r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB; 4289 } 4290 } 4291 4292 static void 4293 encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf, 4294 const REAL_VALUE_TYPE *r) 4295 { 4296 unsigned long image0, image1, sign = r->sign << 15; 4297 4298 switch (r->cl) 4299 { 4300 case rvc_zero: 4301 image0 = image1 = 0; 4302 break; 4303 4304 case rvc_inf: 4305 case rvc_nan: 4306 image0 = 0xffff7fff | sign; 4307 image1 = 0xffffffff; 4308 break; 4309 4310 case rvc_normal: 4311 /* Extract the significand into straight hi:lo. */ 4312 if (HOST_BITS_PER_LONG == 64) 4313 { 4314 image0 = r->sig[SIGSZ-1]; 4315 image1 = (image0 >> (64 - 56)) & 0xffffffff; 4316 image0 = (image0 >> (64 - 56 + 1) >> 31) & 0x7fffff; 4317 } 4318 else 4319 { 4320 image0 = r->sig[SIGSZ-1]; 4321 image1 = r->sig[SIGSZ-2]; 4322 image1 = (image0 << 24) | (image1 >> 8); 4323 image0 = (image0 >> 8) & 0xffffff; 4324 } 4325 4326 /* Rearrange the half-words of the significand to match the 4327 external format. */ 4328 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff007f; 4329 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff; 4330 4331 /* Add the sign and exponent. */ 4332 image0 |= sign; 4333 image0 |= (REAL_EXP (r) + 128) << 7; 4334 break; 4335 4336 default: 4337 gcc_unreachable (); 4338 } 4339 4340 if (FLOAT_WORDS_BIG_ENDIAN) 4341 buf[0] = image1, buf[1] = image0; 4342 else 4343 buf[0] = image0, buf[1] = image1; 4344 } 4345 4346 static void 4347 decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, 4348 REAL_VALUE_TYPE *r, const long *buf) 4349 { 4350 unsigned long image0, image1; 4351 int exp; 4352 4353 if (FLOAT_WORDS_BIG_ENDIAN) 4354 image1 = buf[0], image0 = buf[1]; 4355 else 4356 image0 = buf[0], image1 = buf[1]; 4357 image0 &= 0xffffffff; 4358 image1 &= 0xffffffff; 4359 4360 exp = (image0 >> 7) & 0xff; 4361 4362 memset (r, 0, sizeof (*r)); 4363 4364 if (exp != 0) 4365 { 4366 r->cl = rvc_normal; 4367 r->sign = (image0 >> 15) & 1; 4368 SET_REAL_EXP (r, exp - 128); 4369 4370 /* Rearrange the half-words of the external format into 4371 proper ascending order. */ 4372 image0 = ((image0 & 0x7f) << 16) | ((image0 >> 16) & 0xffff); 4373 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff); 4374 4375 if (HOST_BITS_PER_LONG == 64) 4376 { 4377 image0 = (image0 << 31 << 1) | image1; 4378 image0 <<= 64 - 56; 4379 image0 |= SIG_MSB; 4380 r->sig[SIGSZ-1] = image0; 4381 } 4382 else 4383 { 4384 r->sig[SIGSZ-1] = image0; 4385 r->sig[SIGSZ-2] = image1; 4386 lshift_significand (r, r, 2*HOST_BITS_PER_LONG - 56); 4387 r->sig[SIGSZ-1] |= SIG_MSB; 4388 } 4389 } 4390 } 4391 4392 static void 4393 encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf, 4394 const REAL_VALUE_TYPE *r) 4395 { 4396 unsigned long image0, image1, sign = r->sign << 15; 4397 4398 switch (r->cl) 4399 { 4400 case rvc_zero: 4401 image0 = image1 = 0; 4402 break; 4403 4404 case rvc_inf: 4405 case rvc_nan: 4406 image0 = 0xffff7fff | sign; 4407 image1 = 0xffffffff; 4408 break; 4409 4410 case rvc_normal: 4411 /* Extract the significand into straight hi:lo. */ 4412 if (HOST_BITS_PER_LONG == 64) 4413 { 4414 image0 = r->sig[SIGSZ-1]; 4415 image1 = (image0 >> (64 - 53)) & 0xffffffff; 4416 image0 = (image0 >> (64 - 53 + 1) >> 31) & 0xfffff; 4417 } 4418 else 4419 { 4420 image0 = r->sig[SIGSZ-1]; 4421 image1 = r->sig[SIGSZ-2]; 4422 image1 = (image0 << 21) | (image1 >> 11); 4423 image0 = (image0 >> 11) & 0xfffff; 4424 } 4425 4426 /* Rearrange the half-words of the significand to match the 4427 external format. */ 4428 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff000f; 4429 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff; 4430 4431 /* Add the sign and exponent. */ 4432 image0 |= sign; 4433 image0 |= (REAL_EXP (r) + 1024) << 4; 4434 break; 4435 4436 default: 4437 gcc_unreachable (); 4438 } 4439 4440 if (FLOAT_WORDS_BIG_ENDIAN) 4441 buf[0] = image1, buf[1] = image0; 4442 else 4443 buf[0] = image0, buf[1] = image1; 4444 } 4445 4446 static void 4447 decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, 4448 REAL_VALUE_TYPE *r, const long *buf) 4449 { 4450 unsigned long image0, image1; 4451 int exp; 4452 4453 if (FLOAT_WORDS_BIG_ENDIAN) 4454 image1 = buf[0], image0 = buf[1]; 4455 else 4456 image0 = buf[0], image1 = buf[1]; 4457 image0 &= 0xffffffff; 4458 image1 &= 0xffffffff; 4459 4460 exp = (image0 >> 4) & 0x7ff; 4461 4462 memset (r, 0, sizeof (*r)); 4463 4464 if (exp != 0) 4465 { 4466 r->cl = rvc_normal; 4467 r->sign = (image0 >> 15) & 1; 4468 SET_REAL_EXP (r, exp - 1024); 4469 4470 /* Rearrange the half-words of the external format into 4471 proper ascending order. */ 4472 image0 = ((image0 & 0xf) << 16) | ((image0 >> 16) & 0xffff); 4473 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff); 4474 4475 if (HOST_BITS_PER_LONG == 64) 4476 { 4477 image0 = (image0 << 31 << 1) | image1; 4478 image0 <<= 64 - 53; 4479 image0 |= SIG_MSB; 4480 r->sig[SIGSZ-1] = image0; 4481 } 4482 else 4483 { 4484 r->sig[SIGSZ-1] = image0; 4485 r->sig[SIGSZ-2] = image1; 4486 lshift_significand (r, r, 64 - 53); 4487 r->sig[SIGSZ-1] |= SIG_MSB; 4488 } 4489 } 4490 } 4491 4492 const struct real_format vax_f_format = 4493 { 4494 encode_vax_f, 4495 decode_vax_f, 4496 2, 4497 24, 4498 24, 4499 -127, 4500 127, 4501 15, 4502 15, 4503 0, 4504 false, 4505 false, 4506 false, 4507 false, 4508 false, 4509 false, 4510 false, 4511 false, 4512 "vax_f" 4513 }; 4514 4515 const struct real_format vax_d_format = 4516 { 4517 encode_vax_d, 4518 decode_vax_d, 4519 2, 4520 56, 4521 56, 4522 -127, 4523 127, 4524 15, 4525 15, 4526 0, 4527 false, 4528 false, 4529 false, 4530 false, 4531 false, 4532 false, 4533 false, 4534 false, 4535 "vax_d" 4536 }; 4537 4538 const struct real_format vax_g_format = 4539 { 4540 encode_vax_g, 4541 decode_vax_g, 4542 2, 4543 53, 4544 53, 4545 -1023, 4546 1023, 4547 15, 4548 15, 4549 0, 4550 false, 4551 false, 4552 false, 4553 false, 4554 false, 4555 false, 4556 false, 4557 false, 4558 "vax_g" 4559 }; 4560 4561 /* Encode real R into a single precision DFP value in BUF. */ 4562 static void 4563 encode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED, 4564 long *buf ATTRIBUTE_UNUSED, 4565 const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED) 4566 { 4567 encode_decimal32 (fmt, buf, r); 4568 } 4569 4570 /* Decode a single precision DFP value in BUF into a real R. */ 4571 static void 4572 decode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED, 4573 REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED, 4574 const long *buf ATTRIBUTE_UNUSED) 4575 { 4576 decode_decimal32 (fmt, r, buf); 4577 } 4578 4579 /* Encode real R into a double precision DFP value in BUF. */ 4580 static void 4581 encode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED, 4582 long *buf ATTRIBUTE_UNUSED, 4583 const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED) 4584 { 4585 encode_decimal64 (fmt, buf, r); 4586 } 4587 4588 /* Decode a double precision DFP value in BUF into a real R. */ 4589 static void 4590 decode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED, 4591 REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED, 4592 const long *buf ATTRIBUTE_UNUSED) 4593 { 4594 decode_decimal64 (fmt, r, buf); 4595 } 4596 4597 /* Encode real R into a quad precision DFP value in BUF. */ 4598 static void 4599 encode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED, 4600 long *buf ATTRIBUTE_UNUSED, 4601 const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED) 4602 { 4603 encode_decimal128 (fmt, buf, r); 4604 } 4605 4606 /* Decode a quad precision DFP value in BUF into a real R. */ 4607 static void 4608 decode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED, 4609 REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED, 4610 const long *buf ATTRIBUTE_UNUSED) 4611 { 4612 decode_decimal128 (fmt, r, buf); 4613 } 4614 4615 /* Single precision decimal floating point (IEEE 754). */ 4616 const struct real_format decimal_single_format = 4617 { 4618 encode_decimal_single, 4619 decode_decimal_single, 4620 10, 4621 7, 4622 7, 4623 -94, 4624 97, 4625 31, 4626 31, 4627 32, 4628 false, 4629 true, 4630 true, 4631 true, 4632 true, 4633 true, 4634 true, 4635 false, 4636 "decimal_single" 4637 }; 4638 4639 /* Double precision decimal floating point (IEEE 754). */ 4640 const struct real_format decimal_double_format = 4641 { 4642 encode_decimal_double, 4643 decode_decimal_double, 4644 10, 4645 16, 4646 16, 4647 -382, 4648 385, 4649 63, 4650 63, 4651 64, 4652 false, 4653 true, 4654 true, 4655 true, 4656 true, 4657 true, 4658 true, 4659 false, 4660 "decimal_double" 4661 }; 4662 4663 /* Quad precision decimal floating point (IEEE 754). */ 4664 const struct real_format decimal_quad_format = 4665 { 4666 encode_decimal_quad, 4667 decode_decimal_quad, 4668 10, 4669 34, 4670 34, 4671 -6142, 4672 6145, 4673 127, 4674 127, 4675 128, 4676 false, 4677 true, 4678 true, 4679 true, 4680 true, 4681 true, 4682 true, 4683 false, 4684 "decimal_quad" 4685 }; 4686 4687 /* Encode half-precision floats. This routine is used both for the IEEE 4688 ARM alternative encodings. */ 4689 static void 4690 encode_ieee_half (const struct real_format *fmt, long *buf, 4691 const REAL_VALUE_TYPE *r) 4692 { 4693 unsigned long image, sig, exp; 4694 unsigned long sign = r->sign; 4695 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0; 4696 4697 image = sign << 15; 4698 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 11)) & 0x3ff; 4699 4700 switch (r->cl) 4701 { 4702 case rvc_zero: 4703 break; 4704 4705 case rvc_inf: 4706 if (fmt->has_inf) 4707 image |= 31 << 10; 4708 else 4709 image |= 0x7fff; 4710 break; 4711 4712 case rvc_nan: 4713 if (fmt->has_nans) 4714 { 4715 if (r->canonical) 4716 sig = (fmt->canonical_nan_lsbs_set ? (1 << 9) - 1 : 0); 4717 if (r->signalling == fmt->qnan_msb_set) 4718 sig &= ~(1 << 9); 4719 else 4720 sig |= 1 << 9; 4721 if (sig == 0) 4722 sig = 1 << 8; 4723 4724 image |= 31 << 10; 4725 image |= sig; 4726 } 4727 else 4728 image |= 0x3ff; 4729 break; 4730 4731 case rvc_normal: 4732 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp, 4733 whereas the intermediate representation is 0.F x 2**exp. 4734 Which means we're off by one. */ 4735 if (denormal) 4736 exp = 0; 4737 else 4738 exp = REAL_EXP (r) + 15 - 1; 4739 image |= exp << 10; 4740 image |= sig; 4741 break; 4742 4743 default: 4744 gcc_unreachable (); 4745 } 4746 4747 buf[0] = image; 4748 } 4749 4750 /* Decode half-precision floats. This routine is used both for the IEEE 4751 ARM alternative encodings. */ 4752 static void 4753 decode_ieee_half (const struct real_format *fmt, REAL_VALUE_TYPE *r, 4754 const long *buf) 4755 { 4756 unsigned long image = buf[0] & 0xffff; 4757 bool sign = (image >> 15) & 1; 4758 int exp = (image >> 10) & 0x1f; 4759 4760 memset (r, 0, sizeof (*r)); 4761 image <<= HOST_BITS_PER_LONG - 11; 4762 image &= ~SIG_MSB; 4763 4764 if (exp == 0) 4765 { 4766 if (image && fmt->has_denorm) 4767 { 4768 r->cl = rvc_normal; 4769 r->sign = sign; 4770 SET_REAL_EXP (r, -14); 4771 r->sig[SIGSZ-1] = image << 1; 4772 normalize (r); 4773 } 4774 else if (fmt->has_signed_zero) 4775 r->sign = sign; 4776 } 4777 else if (exp == 31 && (fmt->has_nans || fmt->has_inf)) 4778 { 4779 if (image) 4780 { 4781 r->cl = rvc_nan; 4782 r->sign = sign; 4783 r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1) 4784 ^ fmt->qnan_msb_set); 4785 r->sig[SIGSZ-1] = image; 4786 } 4787 else 4788 { 4789 r->cl = rvc_inf; 4790 r->sign = sign; 4791 } 4792 } 4793 else 4794 { 4795 r->cl = rvc_normal; 4796 r->sign = sign; 4797 SET_REAL_EXP (r, exp - 15 + 1); 4798 r->sig[SIGSZ-1] = image | SIG_MSB; 4799 } 4800 } 4801 4802 /* Half-precision format, as specified in IEEE 754R. */ 4803 const struct real_format ieee_half_format = 4804 { 4805 encode_ieee_half, 4806 decode_ieee_half, 4807 2, 4808 11, 4809 11, 4810 -13, 4811 16, 4812 15, 4813 15, 4814 16, 4815 false, 4816 true, 4817 true, 4818 true, 4819 true, 4820 true, 4821 true, 4822 false, 4823 "ieee_half" 4824 }; 4825 4826 /* ARM's alternative half-precision format, similar to IEEE but with 4827 no reserved exponent value for NaNs and infinities; rather, it just 4828 extends the range of exponents by one. */ 4829 const struct real_format arm_half_format = 4830 { 4831 encode_ieee_half, 4832 decode_ieee_half, 4833 2, 4834 11, 4835 11, 4836 -13, 4837 17, 4838 15, 4839 15, 4840 0, 4841 false, 4842 true, 4843 false, 4844 false, 4845 true, 4846 true, 4847 false, 4848 false, 4849 "arm_half" 4850 }; 4851 4852 /* A synthetic "format" for internal arithmetic. It's the size of the 4853 internal significand minus the two bits needed for proper rounding. 4854 The encode and decode routines exist only to satisfy our paranoia 4855 harness. */ 4856 4857 static void encode_internal (const struct real_format *fmt, 4858 long *, const REAL_VALUE_TYPE *); 4859 static void decode_internal (const struct real_format *, 4860 REAL_VALUE_TYPE *, const long *); 4861 4862 static void 4863 encode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf, 4864 const REAL_VALUE_TYPE *r) 4865 { 4866 memcpy (buf, r, sizeof (*r)); 4867 } 4868 4869 static void 4870 decode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED, 4871 REAL_VALUE_TYPE *r, const long *buf) 4872 { 4873 memcpy (r, buf, sizeof (*r)); 4874 } 4875 4876 const struct real_format real_internal_format = 4877 { 4878 encode_internal, 4879 decode_internal, 4880 2, 4881 SIGNIFICAND_BITS - 2, 4882 SIGNIFICAND_BITS - 2, 4883 -MAX_EXP, 4884 MAX_EXP, 4885 -1, 4886 -1, 4887 0, 4888 false, 4889 false, 4890 true, 4891 true, 4892 false, 4893 true, 4894 true, 4895 false, 4896 "real_internal" 4897 }; 4898 4899 /* Calculate X raised to the integer exponent N in format FMT and store 4900 the result in R. Return true if the result may be inexact due to 4901 loss of precision. The algorithm is the classic "left-to-right binary 4902 method" described in section 4.6.3 of Donald Knuth's "Seminumerical 4903 Algorithms", "The Art of Computer Programming", Volume 2. */ 4904 4905 bool 4906 real_powi (REAL_VALUE_TYPE *r, format_helper fmt, 4907 const REAL_VALUE_TYPE *x, HOST_WIDE_INT n) 4908 { 4909 unsigned HOST_WIDE_INT bit; 4910 REAL_VALUE_TYPE t; 4911 bool inexact = false; 4912 bool init = false; 4913 bool neg; 4914 int i; 4915 4916 if (n == 0) 4917 { 4918 *r = dconst1; 4919 return false; 4920 } 4921 else if (n < 0) 4922 { 4923 /* Don't worry about overflow, from now on n is unsigned. */ 4924 neg = true; 4925 n = -n; 4926 } 4927 else 4928 neg = false; 4929 4930 t = *x; 4931 bit = HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1); 4932 for (i = 0; i < HOST_BITS_PER_WIDE_INT; i++) 4933 { 4934 if (init) 4935 { 4936 inexact |= do_multiply (&t, &t, &t); 4937 if (n & bit) 4938 inexact |= do_multiply (&t, &t, x); 4939 } 4940 else if (n & bit) 4941 init = true; 4942 bit >>= 1; 4943 } 4944 4945 if (neg) 4946 inexact |= do_divide (&t, &dconst1, &t); 4947 4948 real_convert (r, fmt, &t); 4949 return inexact; 4950 } 4951 4952 /* Round X to the nearest integer not larger in absolute value, i.e. 4953 towards zero, placing the result in R in format FMT. */ 4954 4955 void 4956 real_trunc (REAL_VALUE_TYPE *r, format_helper fmt, 4957 const REAL_VALUE_TYPE *x) 4958 { 4959 do_fix_trunc (r, x); 4960 if (fmt) 4961 real_convert (r, fmt, r); 4962 } 4963 4964 /* Round X to the largest integer not greater in value, i.e. round 4965 down, placing the result in R in format FMT. */ 4966 4967 void 4968 real_floor (REAL_VALUE_TYPE *r, format_helper fmt, 4969 const REAL_VALUE_TYPE *x) 4970 { 4971 REAL_VALUE_TYPE t; 4972 4973 do_fix_trunc (&t, x); 4974 if (! real_identical (&t, x) && x->sign) 4975 do_add (&t, &t, &dconstm1, 0); 4976 if (fmt) 4977 real_convert (r, fmt, &t); 4978 else 4979 *r = t; 4980 } 4981 4982 /* Round X to the smallest integer not less then argument, i.e. round 4983 up, placing the result in R in format FMT. */ 4984 4985 void 4986 real_ceil (REAL_VALUE_TYPE *r, format_helper fmt, 4987 const REAL_VALUE_TYPE *x) 4988 { 4989 REAL_VALUE_TYPE t; 4990 4991 do_fix_trunc (&t, x); 4992 if (! real_identical (&t, x) && ! x->sign) 4993 do_add (&t, &t, &dconst1, 0); 4994 if (fmt) 4995 real_convert (r, fmt, &t); 4996 else 4997 *r = t; 4998 } 4999 5000 /* Round X to the nearest integer, but round halfway cases away from 5001 zero. */ 5002 5003 void 5004 real_round (REAL_VALUE_TYPE *r, format_helper fmt, 5005 const REAL_VALUE_TYPE *x) 5006 { 5007 do_add (r, x, &dconsthalf, x->sign); 5008 do_fix_trunc (r, r); 5009 if (fmt) 5010 real_convert (r, fmt, r); 5011 } 5012 5013 /* Set the sign of R to the sign of X. */ 5014 5015 void 5016 real_copysign (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *x) 5017 { 5018 r->sign = x->sign; 5019 } 5020 5021 /* Check whether the real constant value given is an integer. 5022 Returns false for signaling NaN. */ 5023 5024 bool 5025 real_isinteger (const REAL_VALUE_TYPE *c, format_helper fmt) 5026 { 5027 REAL_VALUE_TYPE cint; 5028 5029 real_trunc (&cint, fmt, c); 5030 return real_identical (c, &cint); 5031 } 5032 5033 /* Check whether C is an integer that fits in a HOST_WIDE_INT, 5034 storing it in *INT_OUT if so. */ 5035 5036 bool 5037 real_isinteger (const REAL_VALUE_TYPE *c, HOST_WIDE_INT *int_out) 5038 { 5039 REAL_VALUE_TYPE cint; 5040 5041 HOST_WIDE_INT n = real_to_integer (c); 5042 real_from_integer (&cint, VOIDmode, n, SIGNED); 5043 if (real_identical (c, &cint)) 5044 { 5045 *int_out = n; 5046 return true; 5047 } 5048 return false; 5049 } 5050 5051 /* Write into BUF the maximum representable finite floating-point 5052 number, (1 - b**-p) * b**emax for a given FP format FMT as a hex 5053 float string. LEN is the size of BUF, and the buffer must be large 5054 enough to contain the resulting string. */ 5055 5056 void 5057 get_max_float (const struct real_format *fmt, char *buf, size_t len) 5058 { 5059 int i, n; 5060 char *p; 5061 5062 strcpy (buf, "0x0."); 5063 n = fmt->p; 5064 for (i = 0, p = buf + 4; i + 3 < n; i += 4) 5065 *p++ = 'f'; 5066 if (i < n) 5067 *p++ = "08ce"[n - i]; 5068 sprintf (p, "p%d", fmt->emax); 5069 if (fmt->pnan < fmt->p) 5070 { 5071 /* This is an IBM extended double format made up of two IEEE 5072 doubles. The value of the long double is the sum of the 5073 values of the two parts. The most significant part is 5074 required to be the value of the long double rounded to the 5075 nearest double. Rounding means we need a slightly smaller 5076 value for LDBL_MAX. */ 5077 buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4]; 5078 } 5079 5080 gcc_assert (strlen (buf) < len); 5081 } 5082 5083 /* True if mode M has a NaN representation and 5084 the treatment of NaN operands is important. */ 5085 5086 bool 5087 HONOR_NANS (machine_mode m) 5088 { 5089 return MODE_HAS_NANS (m) && !flag_finite_math_only; 5090 } 5091 5092 bool 5093 HONOR_NANS (const_tree t) 5094 { 5095 return HONOR_NANS (element_mode (t)); 5096 } 5097 5098 bool 5099 HONOR_NANS (const_rtx x) 5100 { 5101 return HONOR_NANS (GET_MODE (x)); 5102 } 5103 5104 /* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs). */ 5105 5106 bool 5107 HONOR_SNANS (machine_mode m) 5108 { 5109 return flag_signaling_nans && HONOR_NANS (m); 5110 } 5111 5112 bool 5113 HONOR_SNANS (const_tree t) 5114 { 5115 return HONOR_SNANS (element_mode (t)); 5116 } 5117 5118 bool 5119 HONOR_SNANS (const_rtx x) 5120 { 5121 return HONOR_SNANS (GET_MODE (x)); 5122 } 5123 5124 /* As for HONOR_NANS, but true if the mode can represent infinity and 5125 the treatment of infinite values is important. */ 5126 5127 bool 5128 HONOR_INFINITIES (machine_mode m) 5129 { 5130 return MODE_HAS_INFINITIES (m) && !flag_finite_math_only; 5131 } 5132 5133 bool 5134 HONOR_INFINITIES (const_tree t) 5135 { 5136 return HONOR_INFINITIES (element_mode (t)); 5137 } 5138 5139 bool 5140 HONOR_INFINITIES (const_rtx x) 5141 { 5142 return HONOR_INFINITIES (GET_MODE (x)); 5143 } 5144 5145 /* Like HONOR_NANS, but true if the given mode distinguishes between 5146 positive and negative zero, and the sign of zero is important. */ 5147 5148 bool 5149 HONOR_SIGNED_ZEROS (machine_mode m) 5150 { 5151 return MODE_HAS_SIGNED_ZEROS (m) && flag_signed_zeros; 5152 } 5153 5154 bool 5155 HONOR_SIGNED_ZEROS (const_tree t) 5156 { 5157 return HONOR_SIGNED_ZEROS (element_mode (t)); 5158 } 5159 5160 bool 5161 HONOR_SIGNED_ZEROS (const_rtx x) 5162 { 5163 return HONOR_SIGNED_ZEROS (GET_MODE (x)); 5164 } 5165 5166 /* Like HONOR_NANS, but true if given mode supports sign-dependent rounding, 5167 and the rounding mode is important. */ 5168 5169 bool 5170 HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode m) 5171 { 5172 return MODE_HAS_SIGN_DEPENDENT_ROUNDING (m) && flag_rounding_math; 5173 } 5174 5175 bool 5176 HONOR_SIGN_DEPENDENT_ROUNDING (const_tree t) 5177 { 5178 return HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (t)); 5179 } 5180 5181 bool 5182 HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx x) 5183 { 5184 return HONOR_SIGN_DEPENDENT_ROUNDING (GET_MODE (x)); 5185 } 5186