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