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