1 /* real.c - software floating point emulation.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2002, 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
4 Contributed by Stephen L. Moshier (moshier@world.std.com).
5 Re-written by Richard Henderson <rth@redhat.com>
7 This file is part of GCC.
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 3, or (at your option) any later
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
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
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.
39 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
43 b = base or radix, here always 2
45 p = precision (the number of base-b digits in the significand)
46 f_k = the digits of the significand.
48 We differ from typical IEEE 754 encodings in that the entire
49 significand is fractional. Normalized significands are in the
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
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.
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. */
70 /* Used to classify two numbers simultaneously. */
71 #define CLASS2(A, B) ((A) << 2 | (B))
73 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
74 #error "Some constant folding done by hand to avoid shift count warnings"
77 static void get_zero (REAL_VALUE_TYPE *, int);
78 static void get_canonical_qnan (REAL_VALUE_TYPE *, int);
79 static void get_canonical_snan (REAL_VALUE_TYPE *, int);
80 static void get_inf (REAL_VALUE_TYPE *, int);
81 static bool sticky_rshift_significand (REAL_VALUE_TYPE *,
82 const REAL_VALUE_TYPE *, unsigned int);
83 static void rshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
85 static void lshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
87 static void lshift_significand_1 (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
88 static bool add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *,
89 const REAL_VALUE_TYPE *);
90 static bool sub_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
91 const REAL_VALUE_TYPE *, int);
92 static void neg_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
93 static int cmp_significands (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
94 static int cmp_significand_0 (const REAL_VALUE_TYPE *);
95 static void set_significand_bit (REAL_VALUE_TYPE *, unsigned int);
96 static void clear_significand_bit (REAL_VALUE_TYPE *, unsigned int);
97 static bool test_significand_bit (REAL_VALUE_TYPE *, unsigned int);
98 static void clear_significand_below (REAL_VALUE_TYPE *, unsigned int);
99 static bool div_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
100 const REAL_VALUE_TYPE *);
101 static void normalize (REAL_VALUE_TYPE *);
103 static bool do_add (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
104 const REAL_VALUE_TYPE *, int);
105 static bool do_multiply (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
106 const REAL_VALUE_TYPE *);
107 static bool do_divide (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
108 const REAL_VALUE_TYPE *);
109 static int do_compare (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
110 static void do_fix_trunc (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
112 static unsigned long rtd_divmod (REAL_VALUE_TYPE *, REAL_VALUE_TYPE *);
114 static const REAL_VALUE_TYPE * ten_to_ptwo (int);
115 static const REAL_VALUE_TYPE * ten_to_mptwo (int);
116 static const REAL_VALUE_TYPE * real_digit (int);
117 static void times_pten (REAL_VALUE_TYPE *, int);
119 static void round_for_format (const struct real_format *, REAL_VALUE_TYPE *);
121 /* Initialize R with a positive zero. */
124 get_zero (REAL_VALUE_TYPE *r, int sign)
126 memset (r, 0, sizeof (*r));
130 /* Initialize R with the canonical quiet NaN. */
133 get_canonical_qnan (REAL_VALUE_TYPE *r, int sign)
135 memset (r, 0, sizeof (*r));
142 get_canonical_snan (REAL_VALUE_TYPE *r, int sign)
144 memset (r, 0, sizeof (*r));
152 get_inf (REAL_VALUE_TYPE *r, int sign)
154 memset (r, 0, sizeof (*r));
160 /* Right-shift the significand of A by N bits; put the result in the
161 significand of R. If any one bits are shifted out, return true. */
164 sticky_rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
167 unsigned long sticky = 0;
168 unsigned int i, ofs = 0;
170 if (n >= HOST_BITS_PER_LONG)
172 for (i = 0, ofs = n / HOST_BITS_PER_LONG; i < ofs; ++i)
174 n &= HOST_BITS_PER_LONG - 1;
179 sticky |= a->sig[ofs] & (((unsigned long)1 << n) - 1);
180 for (i = 0; i < SIGSZ; ++i)
183 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
184 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
185 << (HOST_BITS_PER_LONG - n)));
190 for (i = 0; ofs + i < SIGSZ; ++i)
191 r->sig[i] = a->sig[ofs + i];
192 for (; i < SIGSZ; ++i)
199 /* Right-shift the significand of A by N bits; put the result in the
203 rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
206 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
208 n &= HOST_BITS_PER_LONG - 1;
211 for (i = 0; i < SIGSZ; ++i)
214 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
215 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
216 << (HOST_BITS_PER_LONG - n)));
221 for (i = 0; ofs + i < SIGSZ; ++i)
222 r->sig[i] = a->sig[ofs + i];
223 for (; i < SIGSZ; ++i)
228 /* Left-shift the significand of A by N bits; put the result in the
232 lshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
235 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
237 n &= HOST_BITS_PER_LONG - 1;
240 for (i = 0; ofs + i < SIGSZ; ++i)
241 r->sig[SIGSZ-1-i] = a->sig[SIGSZ-1-i-ofs];
242 for (; i < SIGSZ; ++i)
243 r->sig[SIGSZ-1-i] = 0;
246 for (i = 0; i < SIGSZ; ++i)
249 = (((ofs + i >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs]) << n)
250 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs-1])
251 >> (HOST_BITS_PER_LONG - n)));
255 /* Likewise, but N is specialized to 1. */
258 lshift_significand_1 (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
262 for (i = SIGSZ - 1; i > 0; --i)
263 r->sig[i] = (a->sig[i] << 1) | (a->sig[i-1] >> (HOST_BITS_PER_LONG - 1));
264 r->sig[0] = a->sig[0] << 1;
267 /* Add the significands of A and B, placing the result in R. Return
268 true if there was carry out of the most significant word. */
271 add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
272 const REAL_VALUE_TYPE *b)
277 for (i = 0; i < SIGSZ; ++i)
279 unsigned long ai = a->sig[i];
280 unsigned long ri = ai + b->sig[i];
296 /* Subtract the significands of A and B, placing the result in R. CARRY is
297 true if there's a borrow incoming to the least significant word.
298 Return true if there was borrow out of the most significant word. */
301 sub_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
302 const REAL_VALUE_TYPE *b, int carry)
306 for (i = 0; i < SIGSZ; ++i)
308 unsigned long ai = a->sig[i];
309 unsigned long ri = ai - b->sig[i];
325 /* Negate the significand A, placing the result in R. */
328 neg_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
333 for (i = 0; i < SIGSZ; ++i)
335 unsigned long ri, ai = a->sig[i];
354 /* Compare significands. Return tri-state vs zero. */
357 cmp_significands (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
361 for (i = SIGSZ - 1; i >= 0; --i)
363 unsigned long ai = a->sig[i];
364 unsigned long bi = b->sig[i];
375 /* Return true if A is nonzero. */
378 cmp_significand_0 (const REAL_VALUE_TYPE *a)
382 for (i = SIGSZ - 1; i >= 0; --i)
389 /* Set bit N of the significand of R. */
392 set_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
394 r->sig[n / HOST_BITS_PER_LONG]
395 |= (unsigned long)1 << (n % HOST_BITS_PER_LONG);
398 /* Clear bit N of the significand of R. */
401 clear_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
403 r->sig[n / HOST_BITS_PER_LONG]
404 &= ~((unsigned long)1 << (n % HOST_BITS_PER_LONG));
407 /* Test bit N of the significand of R. */
410 test_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
412 /* ??? Compiler bug here if we return this expression directly.
413 The conversion to bool strips the "&1" and we wind up testing
414 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
415 int t = (r->sig[n / HOST_BITS_PER_LONG] >> (n % HOST_BITS_PER_LONG)) & 1;
419 /* Clear bits 0..N-1 of the significand of R. */
422 clear_significand_below (REAL_VALUE_TYPE *r, unsigned int n)
424 int i, w = n / HOST_BITS_PER_LONG;
426 for (i = 0; i < w; ++i)
429 r->sig[w] &= ~(((unsigned long)1 << (n % HOST_BITS_PER_LONG)) - 1);
432 /* Divide the significands of A and B, placing the result in R. Return
433 true if the division was inexact. */
436 div_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
437 const REAL_VALUE_TYPE *b)
440 int i, bit = SIGNIFICAND_BITS - 1;
441 unsigned long msb, inexact;
444 memset (r->sig, 0, sizeof (r->sig));
450 msb = u.sig[SIGSZ-1] & SIG_MSB;
451 lshift_significand_1 (&u, &u);
453 if (msb || cmp_significands (&u, b) >= 0)
455 sub_significands (&u, &u, b, 0);
456 set_significand_bit (r, bit);
461 for (i = 0, inexact = 0; i < SIGSZ; i++)
467 /* Adjust the exponent and significand of R such that the most
468 significant bit is set. We underflow to zero and overflow to
469 infinity here, without denormals. (The intermediate representation
470 exponent is large enough to handle target denormals normalized.) */
473 normalize (REAL_VALUE_TYPE *r)
481 /* Find the first word that is nonzero. */
482 for (i = SIGSZ - 1; i >= 0; i--)
484 shift += HOST_BITS_PER_LONG;
488 /* Zero significand flushes to zero. */
496 /* Find the first bit that is nonzero. */
498 if (r->sig[i] & ((unsigned long)1 << (HOST_BITS_PER_LONG - 1 - j)))
504 exp = REAL_EXP (r) - shift;
506 get_inf (r, r->sign);
507 else if (exp < -MAX_EXP)
508 get_zero (r, r->sign);
511 SET_REAL_EXP (r, exp);
512 lshift_significand (r, r, shift);
517 /* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the
518 result may be inexact due to a loss of precision. */
521 do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
522 const REAL_VALUE_TYPE *b, int subtract_p)
526 bool inexact = false;
528 /* Determine if we need to add or subtract. */
530 subtract_p = (sign ^ b->sign) ^ subtract_p;
532 switch (CLASS2 (a->cl, b->cl))
534 case CLASS2 (rvc_zero, rvc_zero):
535 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
536 get_zero (r, sign & !subtract_p);
539 case CLASS2 (rvc_zero, rvc_normal):
540 case CLASS2 (rvc_zero, rvc_inf):
541 case CLASS2 (rvc_zero, rvc_nan):
543 case CLASS2 (rvc_normal, rvc_nan):
544 case CLASS2 (rvc_inf, rvc_nan):
545 case CLASS2 (rvc_nan, rvc_nan):
546 /* ANY + NaN = NaN. */
547 case CLASS2 (rvc_normal, rvc_inf):
550 r->sign = sign ^ subtract_p;
553 case CLASS2 (rvc_normal, rvc_zero):
554 case CLASS2 (rvc_inf, rvc_zero):
555 case CLASS2 (rvc_nan, rvc_zero):
557 case CLASS2 (rvc_nan, rvc_normal):
558 case CLASS2 (rvc_nan, rvc_inf):
559 /* NaN + ANY = NaN. */
560 case CLASS2 (rvc_inf, rvc_normal):
565 case CLASS2 (rvc_inf, rvc_inf):
567 /* Inf - Inf = NaN. */
568 get_canonical_qnan (r, 0);
570 /* Inf + Inf = Inf. */
574 case CLASS2 (rvc_normal, rvc_normal):
581 /* Swap the arguments such that A has the larger exponent. */
582 dexp = REAL_EXP (a) - REAL_EXP (b);
585 const REAL_VALUE_TYPE *t;
592 /* If the exponents are not identical, we need to shift the
593 significand of B down. */
596 /* If the exponents are too far apart, the significands
597 do not overlap, which makes the subtraction a noop. */
598 if (dexp >= SIGNIFICAND_BITS)
605 inexact |= sticky_rshift_significand (&t, b, dexp);
611 if (sub_significands (r, a, b, inexact))
613 /* We got a borrow out of the subtraction. That means that
614 A and B had the same exponent, and B had the larger
615 significand. We need to swap the sign and negate the
618 neg_significand (r, r);
623 if (add_significands (r, a, b))
625 /* We got carry out of the addition. This means we need to
626 shift the significand back down one bit and increase the
628 inexact |= sticky_rshift_significand (r, r, 1);
629 r->sig[SIGSZ-1] |= SIG_MSB;
640 SET_REAL_EXP (r, exp);
641 /* Zero out the remaining fields. */
646 /* Re-normalize the result. */
649 /* Special case: if the subtraction results in zero, the result
651 if (r->cl == rvc_zero)
654 r->sig[0] |= inexact;
659 /* Calculate R = A * B. Return true if the result may be inexact. */
662 do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
663 const REAL_VALUE_TYPE *b)
665 REAL_VALUE_TYPE u, t, *rr;
666 unsigned int i, j, k;
667 int sign = a->sign ^ b->sign;
668 bool inexact = false;
670 switch (CLASS2 (a->cl, b->cl))
672 case CLASS2 (rvc_zero, rvc_zero):
673 case CLASS2 (rvc_zero, rvc_normal):
674 case CLASS2 (rvc_normal, rvc_zero):
675 /* +-0 * ANY = 0 with appropriate sign. */
679 case CLASS2 (rvc_zero, rvc_nan):
680 case CLASS2 (rvc_normal, rvc_nan):
681 case CLASS2 (rvc_inf, rvc_nan):
682 case CLASS2 (rvc_nan, rvc_nan):
683 /* ANY * NaN = NaN. */
688 case CLASS2 (rvc_nan, rvc_zero):
689 case CLASS2 (rvc_nan, rvc_normal):
690 case CLASS2 (rvc_nan, rvc_inf):
691 /* NaN * ANY = NaN. */
696 case CLASS2 (rvc_zero, rvc_inf):
697 case CLASS2 (rvc_inf, rvc_zero):
699 get_canonical_qnan (r, sign);
702 case CLASS2 (rvc_inf, rvc_inf):
703 case CLASS2 (rvc_normal, rvc_inf):
704 case CLASS2 (rvc_inf, rvc_normal):
705 /* Inf * Inf = Inf, R * Inf = Inf */
709 case CLASS2 (rvc_normal, rvc_normal):
716 if (r == a || r == b)
722 /* Collect all the partial products. Since we don't have sure access
723 to a widening multiply, we split each long into two half-words.
725 Consider the long-hand form of a four half-word multiplication:
735 We construct partial products of the widened half-word products
736 that are known to not overlap, e.g. DF+DH. Each such partial
737 product is given its proper exponent, which allows us to sum them
738 and obtain the finished product. */
740 for (i = 0; i < SIGSZ * 2; ++i)
742 unsigned long ai = a->sig[i / 2];
744 ai >>= HOST_BITS_PER_LONG / 2;
746 ai &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
751 for (j = 0; j < 2; ++j)
753 int exp = (REAL_EXP (a) - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2)
754 + (REAL_EXP (b) - (1-j)*(HOST_BITS_PER_LONG/2)));
763 /* Would underflow to zero, which we shouldn't bother adding. */
768 memset (&u, 0, sizeof (u));
770 SET_REAL_EXP (&u, exp);
772 for (k = j; k < SIGSZ * 2; k += 2)
774 unsigned long bi = b->sig[k / 2];
776 bi >>= HOST_BITS_PER_LONG / 2;
778 bi &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
780 u.sig[k / 2] = ai * bi;
784 inexact |= do_add (rr, rr, &u, 0);
795 /* Calculate R = A / B. Return true if the result may be inexact. */
798 do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
799 const REAL_VALUE_TYPE *b)
801 int exp, sign = a->sign ^ b->sign;
802 REAL_VALUE_TYPE t, *rr;
805 switch (CLASS2 (a->cl, b->cl))
807 case CLASS2 (rvc_zero, rvc_zero):
809 case CLASS2 (rvc_inf, rvc_inf):
810 /* Inf / Inf = NaN. */
811 get_canonical_qnan (r, sign);
814 case CLASS2 (rvc_zero, rvc_normal):
815 case CLASS2 (rvc_zero, rvc_inf):
817 case CLASS2 (rvc_normal, rvc_inf):
822 case CLASS2 (rvc_normal, rvc_zero):
824 case CLASS2 (rvc_inf, rvc_zero):
829 case CLASS2 (rvc_zero, rvc_nan):
830 case CLASS2 (rvc_normal, rvc_nan):
831 case CLASS2 (rvc_inf, rvc_nan):
832 case CLASS2 (rvc_nan, rvc_nan):
833 /* ANY / NaN = NaN. */
838 case CLASS2 (rvc_nan, rvc_zero):
839 case CLASS2 (rvc_nan, rvc_normal):
840 case CLASS2 (rvc_nan, rvc_inf):
841 /* NaN / ANY = NaN. */
846 case CLASS2 (rvc_inf, rvc_normal):
851 case CLASS2 (rvc_normal, rvc_normal):
858 if (r == a || r == b)
863 /* Make sure all fields in the result are initialized. */
868 exp = REAL_EXP (a) - REAL_EXP (b) + 1;
879 SET_REAL_EXP (rr, exp);
881 inexact = div_significands (rr, a, b);
883 /* Re-normalize the result. */
885 rr->sig[0] |= inexact;
893 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
894 one of the two operands is a NaN. */
897 do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
902 switch (CLASS2 (a->cl, b->cl))
904 case CLASS2 (rvc_zero, rvc_zero):
905 /* Sign of zero doesn't matter for compares. */
908 case CLASS2 (rvc_inf, rvc_zero):
909 case CLASS2 (rvc_inf, rvc_normal):
910 case CLASS2 (rvc_normal, rvc_zero):
911 return (a->sign ? -1 : 1);
913 case CLASS2 (rvc_inf, rvc_inf):
914 return -a->sign - -b->sign;
916 case CLASS2 (rvc_zero, rvc_normal):
917 case CLASS2 (rvc_zero, rvc_inf):
918 case CLASS2 (rvc_normal, rvc_inf):
919 return (b->sign ? 1 : -1);
921 case CLASS2 (rvc_zero, rvc_nan):
922 case CLASS2 (rvc_normal, rvc_nan):
923 case CLASS2 (rvc_inf, rvc_nan):
924 case CLASS2 (rvc_nan, rvc_nan):
925 case CLASS2 (rvc_nan, rvc_zero):
926 case CLASS2 (rvc_nan, rvc_normal):
927 case CLASS2 (rvc_nan, rvc_inf):
930 case CLASS2 (rvc_normal, rvc_normal):
937 if (a->sign != b->sign)
938 return -a->sign - -b->sign;
940 if (a->decimal || b->decimal)
941 return decimal_do_compare (a, b, nan_result);
943 if (REAL_EXP (a) > REAL_EXP (b))
945 else if (REAL_EXP (a) < REAL_EXP (b))
948 ret = cmp_significands (a, b);
950 return (a->sign ? -ret : ret);
953 /* Return A truncated to an integral value toward zero. */
956 do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
970 decimal_do_fix_trunc (r, a);
973 if (REAL_EXP (r) <= 0)
974 get_zero (r, r->sign);
975 else if (REAL_EXP (r) < SIGNIFICAND_BITS)
976 clear_significand_below (r, SIGNIFICAND_BITS - REAL_EXP (r));
984 /* Perform the binary or unary operation described by CODE.
985 For a unary operation, leave OP1 NULL. This function returns
986 true if the result may be inexact due to loss of precision. */
989 real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
990 const REAL_VALUE_TYPE *op1)
992 enum tree_code code = icode;
994 if (op0->decimal || (op1 && op1->decimal))
995 return decimal_real_arithmetic (r, icode, op0, op1);
1000 return do_add (r, op0, op1, 0);
1003 return do_add (r, op0, op1, 1);
1006 return do_multiply (r, op0, op1);
1009 return do_divide (r, op0, op1);
1012 if (op1->cl == rvc_nan)
1014 else if (do_compare (op0, op1, -1) < 0)
1021 if (op1->cl == rvc_nan)
1023 else if (do_compare (op0, op1, 1) < 0)
1039 case FIX_TRUNC_EXPR:
1040 do_fix_trunc (r, op0);
1049 /* Legacy. Similar, but return the result directly. */
1052 real_arithmetic2 (int icode, const REAL_VALUE_TYPE *op0,
1053 const REAL_VALUE_TYPE *op1)
1056 real_arithmetic (&r, icode, op0, op1);
1061 real_compare (int icode, const REAL_VALUE_TYPE *op0,
1062 const REAL_VALUE_TYPE *op1)
1064 enum tree_code code = icode;
1069 return do_compare (op0, op1, 1) < 0;
1071 return do_compare (op0, op1, 1) <= 0;
1073 return do_compare (op0, op1, -1) > 0;
1075 return do_compare (op0, op1, -1) >= 0;
1077 return do_compare (op0, op1, -1) == 0;
1079 return do_compare (op0, op1, -1) != 0;
1080 case UNORDERED_EXPR:
1081 return op0->cl == rvc_nan || op1->cl == rvc_nan;
1083 return op0->cl != rvc_nan && op1->cl != rvc_nan;
1085 return do_compare (op0, op1, -1) < 0;
1087 return do_compare (op0, op1, -1) <= 0;
1089 return do_compare (op0, op1, 1) > 0;
1091 return do_compare (op0, op1, 1) >= 0;
1093 return do_compare (op0, op1, 0) == 0;
1095 return do_compare (op0, op1, 0) != 0;
1102 /* Return floor log2(R). */
1105 real_exponent (const REAL_VALUE_TYPE *r)
1113 return (unsigned int)-1 >> 1;
1115 return REAL_EXP (r);
1121 /* R = OP0 * 2**EXP. */
1124 real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
1135 exp += REAL_EXP (op0);
1137 get_inf (r, r->sign);
1138 else if (exp < -MAX_EXP)
1139 get_zero (r, r->sign);
1141 SET_REAL_EXP (r, exp);
1149 /* Determine whether a floating-point value X is infinite. */
1152 real_isinf (const REAL_VALUE_TYPE *r)
1154 return (r->cl == rvc_inf);
1157 /* Determine whether a floating-point value X is a NaN. */
1160 real_isnan (const REAL_VALUE_TYPE *r)
1162 return (r->cl == rvc_nan);
1165 /* Determine whether a floating-point value X is finite. */
1168 real_isfinite (const REAL_VALUE_TYPE *r)
1170 return (r->cl != rvc_nan) && (r->cl != rvc_inf);
1173 /* Determine whether a floating-point value X is negative. */
1176 real_isneg (const REAL_VALUE_TYPE *r)
1181 /* Determine whether a floating-point value X is minus zero. */
1184 real_isnegzero (const REAL_VALUE_TYPE *r)
1186 return r->sign && r->cl == rvc_zero;
1189 /* Compare two floating-point objects for bitwise identity. */
1192 real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
1198 if (a->sign != b->sign)
1208 if (a->decimal != b->decimal)
1210 if (REAL_EXP (a) != REAL_EXP (b))
1215 if (a->signalling != b->signalling)
1217 /* The significand is ignored for canonical NaNs. */
1218 if (a->canonical || b->canonical)
1219 return a->canonical == b->canonical;
1226 for (i = 0; i < SIGSZ; ++i)
1227 if (a->sig[i] != b->sig[i])
1233 /* Try to change R into its exact multiplicative inverse in machine
1234 mode MODE. Return true if successful. */
1237 exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
1239 const REAL_VALUE_TYPE *one = real_digit (1);
1243 if (r->cl != rvc_normal)
1246 /* Check for a power of two: all significand bits zero except the MSB. */
1247 for (i = 0; i < SIGSZ-1; ++i)
1250 if (r->sig[SIGSZ-1] != SIG_MSB)
1253 /* Find the inverse and truncate to the required mode. */
1254 do_divide (&u, one, r);
1255 real_convert (&u, mode, &u);
1257 /* The rounding may have overflowed. */
1258 if (u.cl != rvc_normal)
1260 for (i = 0; i < SIGSZ-1; ++i)
1263 if (u.sig[SIGSZ-1] != SIG_MSB)
1270 /* Render R as an integer. */
1273 real_to_integer (const REAL_VALUE_TYPE *r)
1275 unsigned HOST_WIDE_INT i;
1286 i = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1293 return decimal_real_to_integer (r);
1295 if (REAL_EXP (r) <= 0)
1297 /* Only force overflow for unsigned overflow. Signed overflow is
1298 undefined, so it doesn't matter what we return, and some callers
1299 expect to be able to use this routine for both signed and
1300 unsigned conversions. */
1301 if (REAL_EXP (r) > HOST_BITS_PER_WIDE_INT)
1304 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1305 i = r->sig[SIGSZ-1];
1308 gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
1309 i = r->sig[SIGSZ-1];
1310 i = i << (HOST_BITS_PER_LONG - 1) << 1;
1311 i |= r->sig[SIGSZ-2];
1314 i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
1325 /* Likewise, but to an integer pair, HI+LOW. */
1328 real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
1329 const REAL_VALUE_TYPE *r)
1332 HOST_WIDE_INT low, high;
1345 high = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1358 decimal_real_to_integer2 (plow, phigh, r);
1365 /* Only force overflow for unsigned overflow. Signed overflow is
1366 undefined, so it doesn't matter what we return, and some callers
1367 expect to be able to use this routine for both signed and
1368 unsigned conversions. */
1369 if (exp > 2*HOST_BITS_PER_WIDE_INT)
1372 rshift_significand (&t, r, 2*HOST_BITS_PER_WIDE_INT - exp);
1373 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1375 high = t.sig[SIGSZ-1];
1376 low = t.sig[SIGSZ-2];
1380 gcc_assert (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG);
1381 high = t.sig[SIGSZ-1];
1382 high = high << (HOST_BITS_PER_LONG - 1) << 1;
1383 high |= t.sig[SIGSZ-2];
1385 low = t.sig[SIGSZ-3];
1386 low = low << (HOST_BITS_PER_LONG - 1) << 1;
1387 low |= t.sig[SIGSZ-4];
1395 low = -low, high = ~high;
1407 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1408 of NUM / DEN. Return the quotient and place the remainder in NUM.
1409 It is expected that NUM / DEN are close enough that the quotient is
1412 static unsigned long
1413 rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den)
1415 unsigned long q, msb;
1416 int expn = REAL_EXP (num), expd = REAL_EXP (den);
1425 msb = num->sig[SIGSZ-1] & SIG_MSB;
1427 lshift_significand_1 (num, num);
1429 if (msb || cmp_significands (num, den) >= 0)
1431 sub_significands (num, num, den, 0);
1435 while (--expn >= expd);
1437 SET_REAL_EXP (num, expd);
1443 /* Render R as a decimal floating point constant. Emit DIGITS significant
1444 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1445 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1446 zeros. If MODE is VOIDmode, round to nearest value. Otherwise, round
1447 to a string that, when parsed back in mode MODE, yields the same value. */
1449 #define M_LOG10_2 0.30102999566398119521
1452 real_to_decimal_for_mode (char *str, const REAL_VALUE_TYPE *r_orig,
1453 size_t buf_size, size_t digits,
1454 int crop_trailing_zeros, enum machine_mode mode)
1456 const struct real_format *fmt = NULL;
1457 const REAL_VALUE_TYPE *one, *ten;
1458 REAL_VALUE_TYPE r, pten, u, v;
1459 int dec_exp, cmp_one, digit;
1461 char *p, *first, *last;
1465 if (mode != VOIDmode)
1467 fmt = REAL_MODE_FORMAT (mode);
1475 strcpy (str, (r.sign ? "-0.0" : "0.0"));
1480 strcpy (str, (r.sign ? "-Inf" : "+Inf"));
1483 /* ??? Print the significand as well, if not canonical? */
1484 sprintf (str, "%c%cNaN", (r_orig->sign ? '-' : '+'),
1485 (r_orig->signalling ? 'S' : 'Q'));
1493 decimal_real_to_decimal (str, &r, buf_size, digits, crop_trailing_zeros);
1497 /* Bound the number of digits printed by the size of the representation. */
1498 max_digits = SIGNIFICAND_BITS * M_LOG10_2;
1499 if (digits == 0 || digits > max_digits)
1500 digits = max_digits;
1502 /* Estimate the decimal exponent, and compute the length of the string it
1503 will print as. Be conservative and add one to account for possible
1504 overflow or rounding error. */
1505 dec_exp = REAL_EXP (&r) * M_LOG10_2;
1506 for (max_digits = 1; dec_exp ; max_digits++)
1509 /* Bound the number of digits printed by the size of the output buffer. */
1510 max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
1511 gcc_assert (max_digits <= buf_size);
1512 if (digits > max_digits)
1513 digits = max_digits;
1515 one = real_digit (1);
1516 ten = ten_to_ptwo (0);
1524 cmp_one = do_compare (&r, one, 0);
1529 /* Number is greater than one. Convert significand to an integer
1530 and strip trailing decimal zeros. */
1533 SET_REAL_EXP (&u, SIGNIFICAND_BITS - 1);
1535 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1536 m = floor_log2 (max_digits);
1538 /* Iterate over the bits of the possible powers of 10 that might
1539 be present in U and eliminate them. That is, if we find that
1540 10**2**M divides U evenly, keep the division and increase
1546 do_divide (&t, &u, ten_to_ptwo (m));
1547 do_fix_trunc (&v, &t);
1548 if (cmp_significands (&v, &t) == 0)
1556 /* Revert the scaling to integer that we performed earlier. */
1557 SET_REAL_EXP (&u, REAL_EXP (&u) + REAL_EXP (&r)
1558 - (SIGNIFICAND_BITS - 1));
1561 /* Find power of 10. Do this by dividing out 10**2**M when
1562 this is larger than the current remainder. Fill PTEN with
1563 the power of 10 that we compute. */
1564 if (REAL_EXP (&r) > 0)
1566 m = floor_log2 ((int)(REAL_EXP (&r) * M_LOG10_2)) + 1;
1569 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1570 if (do_compare (&u, ptentwo, 0) >= 0)
1572 do_divide (&u, &u, ptentwo);
1573 do_multiply (&pten, &pten, ptentwo);
1580 /* We managed to divide off enough tens in the above reduction
1581 loop that we've now got a negative exponent. Fall into the
1582 less-than-one code to compute the proper value for PTEN. */
1589 /* Number is less than one. Pad significand with leading
1595 /* Stop if we'd shift bits off the bottom. */
1599 do_multiply (&u, &v, ten);
1601 /* Stop if we're now >= 1. */
1602 if (REAL_EXP (&u) > 0)
1610 /* Find power of 10. Do this by multiplying in P=10**2**M when
1611 the current remainder is smaller than 1/P. Fill PTEN with the
1612 power of 10 that we compute. */
1613 m = floor_log2 ((int)(-REAL_EXP (&r) * M_LOG10_2)) + 1;
1616 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1617 const REAL_VALUE_TYPE *ptenmtwo = ten_to_mptwo (m);
1619 if (do_compare (&v, ptenmtwo, 0) <= 0)
1621 do_multiply (&v, &v, ptentwo);
1622 do_multiply (&pten, &pten, ptentwo);
1628 /* Invert the positive power of 10 that we've collected so far. */
1629 do_divide (&pten, one, &pten);
1637 /* At this point, PTEN should contain the nearest power of 10 smaller
1638 than R, such that this division produces the first digit.
1640 Using a divide-step primitive that returns the complete integral
1641 remainder avoids the rounding error that would be produced if
1642 we were to use do_divide here and then simply multiply by 10 for
1643 each subsequent digit. */
1645 digit = rtd_divmod (&r, &pten);
1647 /* Be prepared for error in that division via underflow ... */
1648 if (digit == 0 && cmp_significand_0 (&r))
1650 /* Multiply by 10 and try again. */
1651 do_multiply (&r, &r, ten);
1652 digit = rtd_divmod (&r, &pten);
1654 gcc_assert (digit != 0);
1657 /* ... or overflow. */
1667 gcc_assert (digit <= 10);
1671 /* Generate subsequent digits. */
1672 while (--digits > 0)
1674 do_multiply (&r, &r, ten);
1675 digit = rtd_divmod (&r, &pten);
1680 /* Generate one more digit with which to do rounding. */
1681 do_multiply (&r, &r, ten);
1682 digit = rtd_divmod (&r, &pten);
1684 /* Round the result. */
1685 if (fmt && fmt->round_towards_zero)
1687 /* If the format uses round towards zero when parsing the string
1688 back in, we need to always round away from zero here. */
1689 if (cmp_significand_0 (&r))
1691 round_up = digit > 0;
1697 /* Round to nearest. If R is nonzero there are additional
1698 nonzero digits to be extracted. */
1699 if (cmp_significand_0 (&r))
1701 /* Round to even. */
1702 else if ((p[-1] - '0') & 1)
1706 round_up = digit > 5;
1723 /* Carry out of the first digit. This means we had all 9's and
1724 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1732 /* Insert the decimal point. */
1733 first[0] = first[1];
1736 /* If requested, drop trailing zeros. Never crop past "1.0". */
1737 if (crop_trailing_zeros)
1738 while (last > first + 3 && last[-1] == '0')
1741 /* Append the exponent. */
1742 sprintf (last, "e%+d", dec_exp);
1744 #ifdef ENABLE_CHECKING
1745 /* Verify that we can read the original value back in. */
1746 if (mode != VOIDmode)
1748 real_from_string (&r, str);
1749 real_convert (&r, mode, &r);
1750 gcc_assert (real_identical (&r, r_orig));
1755 /* Likewise, except always uses round-to-nearest. */
1758 real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
1759 size_t digits, int crop_trailing_zeros)
1761 real_to_decimal_for_mode (str, r_orig, buf_size,
1762 digits, crop_trailing_zeros, VOIDmode);
1765 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1766 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1767 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1768 strip trailing zeros. */
1771 real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
1772 size_t digits, int crop_trailing_zeros)
1774 int i, j, exp = REAL_EXP (r);
1787 strcpy (str, (r->sign ? "-Inf" : "+Inf"));
1790 /* ??? Print the significand as well, if not canonical? */
1791 sprintf (str, "%c%cNaN", (r->sign ? '-' : '+'),
1792 (r->signalling ? 'S' : 'Q'));
1800 /* Hexadecimal format for decimal floats is not interesting. */
1801 strcpy (str, "N/A");
1806 digits = SIGNIFICAND_BITS / 4;
1808 /* Bound the number of digits printed by the size of the output buffer. */
1810 sprintf (exp_buf, "p%+d", exp);
1811 max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1;
1812 gcc_assert (max_digits <= buf_size);
1813 if (digits > max_digits)
1814 digits = max_digits;
1825 for (i = SIGSZ - 1; i >= 0; --i)
1826 for (j = HOST_BITS_PER_LONG - 4; j >= 0; j -= 4)
1828 *p++ = "0123456789abcdef"[(r->sig[i] >> j) & 15];
1834 if (crop_trailing_zeros)
1835 while (p > first + 1 && p[-1] == '0')
1838 sprintf (p, "p%+d", exp);
1841 /* Initialize R from a decimal or hexadecimal string. The string is
1842 assumed to have been syntax checked already. Return -1 if the
1843 value underflows, +1 if overflows, and 0 otherwise. */
1846 real_from_string (REAL_VALUE_TYPE *r, const char *str)
1858 else if (*str == '+')
1861 if (!strncmp (str, "QNaN", 4))
1863 get_canonical_qnan (r, sign);
1866 else if (!strncmp (str, "SNaN", 4))
1868 get_canonical_snan (r, sign);
1871 else if (!strncmp (str, "Inf", 3))
1877 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
1879 /* Hexadecimal floating point. */
1880 int pos = SIGNIFICAND_BITS - 4, d;
1888 d = hex_value (*str);
1893 r->sig[pos / HOST_BITS_PER_LONG]
1894 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1898 /* Ensure correct rounding by setting last bit if there is
1899 a subsequent nonzero digit. */
1907 if (pos == SIGNIFICAND_BITS - 4)
1914 d = hex_value (*str);
1919 r->sig[pos / HOST_BITS_PER_LONG]
1920 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1924 /* Ensure correct rounding by setting last bit if there is
1925 a subsequent nonzero digit. */
1931 /* If the mantissa is zero, ignore the exponent. */
1932 if (!cmp_significand_0 (r))
1935 if (*str == 'p' || *str == 'P')
1937 bool exp_neg = false;
1945 else if (*str == '+')
1949 while (ISDIGIT (*str))
1955 /* Overflowed the exponent. */
1970 SET_REAL_EXP (r, exp);
1976 /* Decimal floating point. */
1977 const REAL_VALUE_TYPE *ten = ten_to_ptwo (0);
1982 while (ISDIGIT (*str))
1985 do_multiply (r, r, ten);
1987 do_add (r, r, real_digit (d), 0);
1992 if (r->cl == rvc_zero)
1997 while (ISDIGIT (*str))
2000 do_multiply (r, r, ten);
2002 do_add (r, r, real_digit (d), 0);
2007 /* If the mantissa is zero, ignore the exponent. */
2008 if (r->cl == rvc_zero)
2011 if (*str == 'e' || *str == 'E')
2013 bool exp_neg = false;
2021 else if (*str == '+')
2025 while (ISDIGIT (*str))
2031 /* Overflowed the exponent. */
2045 times_pten (r, exp);
2064 /* Legacy. Similar, but return the result directly. */
2067 real_from_string2 (const char *s, enum machine_mode mode)
2071 real_from_string (&r, s);
2072 if (mode != VOIDmode)
2073 real_convert (&r, mode, &r);
2078 /* Initialize R from string S and desired MODE. */
2081 real_from_string3 (REAL_VALUE_TYPE *r, const char *s, enum machine_mode mode)
2083 if (DECIMAL_FLOAT_MODE_P (mode))
2084 decimal_real_from_string (r, s);
2086 real_from_string (r, s);
2088 if (mode != VOIDmode)
2089 real_convert (r, mode, r);
2092 /* Initialize R from the integer pair HIGH+LOW. */
2095 real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
2096 unsigned HOST_WIDE_INT low, HOST_WIDE_INT high,
2099 if (low == 0 && high == 0)
2103 memset (r, 0, sizeof (*r));
2105 r->sign = high < 0 && !unsigned_p;
2106 SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT);
2117 if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT)
2119 r->sig[SIGSZ-1] = high;
2120 r->sig[SIGSZ-2] = low;
2124 gcc_assert (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT);
2125 r->sig[SIGSZ-1] = high >> (HOST_BITS_PER_LONG - 1) >> 1;
2126 r->sig[SIGSZ-2] = high;
2127 r->sig[SIGSZ-3] = low >> (HOST_BITS_PER_LONG - 1) >> 1;
2128 r->sig[SIGSZ-4] = low;
2134 if (mode != VOIDmode)
2135 real_convert (r, mode, r);
2138 /* Returns 10**2**N. */
2140 static const REAL_VALUE_TYPE *
2143 static REAL_VALUE_TYPE tens[EXP_BITS];
2145 gcc_assert (n >= 0);
2146 gcc_assert (n < EXP_BITS);
2148 if (tens[n].cl == rvc_zero)
2150 if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
2152 HOST_WIDE_INT t = 10;
2155 for (i = 0; i < n; ++i)
2158 real_from_integer (&tens[n], VOIDmode, t, 0, 1);
2162 const REAL_VALUE_TYPE *t = ten_to_ptwo (n - 1);
2163 do_multiply (&tens[n], t, t);
2170 /* Returns 10**(-2**N). */
2172 static const REAL_VALUE_TYPE *
2173 ten_to_mptwo (int n)
2175 static REAL_VALUE_TYPE tens[EXP_BITS];
2177 gcc_assert (n >= 0);
2178 gcc_assert (n < EXP_BITS);
2180 if (tens[n].cl == rvc_zero)
2181 do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
2188 static const REAL_VALUE_TYPE *
2191 static REAL_VALUE_TYPE num[10];
2193 gcc_assert (n >= 0);
2194 gcc_assert (n <= 9);
2196 if (n > 0 && num[n].cl == rvc_zero)
2197 real_from_integer (&num[n], VOIDmode, n, 0, 1);
2202 /* Multiply R by 10**EXP. */
2205 times_pten (REAL_VALUE_TYPE *r, int exp)
2207 REAL_VALUE_TYPE pten, *rr;
2208 bool negative = (exp < 0);
2214 pten = *real_digit (1);
2220 for (i = 0; exp > 0; ++i, exp >>= 1)
2222 do_multiply (rr, rr, ten_to_ptwo (i));
2225 do_divide (r, r, &pten);
2228 /* Returns the special REAL_VALUE_TYPE enumerated by E. */
2230 const REAL_VALUE_TYPE *
2231 get_real_const (enum real_value_const e)
2233 static REAL_VALUE_TYPE value[rv_max];
2235 gcc_assert (e < rv_max);
2237 /* Initialize mathematical constants for constant folding builtins.
2238 These constants need to be given to at least 160 bits precision. */
2239 if (value[e].cl == rvc_zero)
2245 mpfr_init2 (m, SIGNIFICAND_BITS);
2246 mpfr_set_ui (m, 1, GMP_RNDN);
2247 mpfr_exp (m, m, GMP_RNDN);
2248 real_from_mpfr (&value[e], m, NULL_TREE, GMP_RNDN);
2253 real_arithmetic (&value[e], RDIV_EXPR, &dconst1, real_digit (3));
2258 mpfr_init2 (m, SIGNIFICAND_BITS);
2259 mpfr_sqrt_ui (m, 2, GMP_RNDN);
2260 real_from_mpfr (&value[e], m, NULL_TREE, GMP_RNDN);
2271 /* Fills R with +Inf. */
2274 real_inf (REAL_VALUE_TYPE *r)
2279 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2280 we force a QNaN, else we force an SNaN. The string, if not empty,
2281 is parsed as a number and placed in the significand. Return true
2282 if the string was successfully parsed. */
2285 real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
2286 enum machine_mode mode)
2288 const struct real_format *fmt;
2290 fmt = REAL_MODE_FORMAT (mode);
2296 get_canonical_qnan (r, 0);
2298 get_canonical_snan (r, 0);
2304 memset (r, 0, sizeof (*r));
2307 /* Parse akin to strtol into the significand of R. */
2309 while (ISSPACE (*str))
2313 else if (*str == '+')
2318 if (*str == 'x' || *str == 'X')
2327 while ((d = hex_value (*str)) < base)
2334 lshift_significand (r, r, 3);
2337 lshift_significand (r, r, 4);
2340 lshift_significand_1 (&u, r);
2341 lshift_significand (r, r, 3);
2342 add_significands (r, r, &u);
2350 add_significands (r, r, &u);
2355 /* Must have consumed the entire string for success. */
2359 /* Shift the significand into place such that the bits
2360 are in the most significant bits for the format. */
2361 lshift_significand (r, r, SIGNIFICAND_BITS - fmt->pnan);
2363 /* Our MSB is always unset for NaNs. */
2364 r->sig[SIGSZ-1] &= ~SIG_MSB;
2366 /* Force quiet or signalling NaN. */
2367 r->signalling = !quiet;
2373 /* Fills R with the largest finite value representable in mode MODE.
2374 If SIGN is nonzero, R is set to the most negative finite value. */
2377 real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
2379 const struct real_format *fmt;
2382 fmt = REAL_MODE_FORMAT (mode);
2384 memset (r, 0, sizeof (*r));
2387 decimal_real_maxval (r, sign, mode);
2392 SET_REAL_EXP (r, fmt->emax);
2394 np2 = SIGNIFICAND_BITS - fmt->p;
2395 memset (r->sig, -1, SIGSZ * sizeof (unsigned long));
2396 clear_significand_below (r, np2);
2398 if (fmt->pnan < fmt->p)
2399 /* This is an IBM extended double format made up of two IEEE
2400 doubles. The value of the long double is the sum of the
2401 values of the two parts. The most significant part is
2402 required to be the value of the long double rounded to the
2403 nearest double. Rounding means we need a slightly smaller
2404 value for LDBL_MAX. */
2405 clear_significand_bit (r, SIGNIFICAND_BITS - fmt->pnan);
2409 /* Fills R with 2**N. */
2412 real_2expN (REAL_VALUE_TYPE *r, int n, enum machine_mode fmode)
2414 memset (r, 0, sizeof (*r));
2419 else if (n < -MAX_EXP)
2424 SET_REAL_EXP (r, n);
2425 r->sig[SIGSZ-1] = SIG_MSB;
2427 if (DECIMAL_FLOAT_MODE_P (fmode))
2428 decimal_real_convert (r, fmode, r);
2433 round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
2437 bool round_up = false;
2443 decimal_round_for_format (fmt, r);
2446 /* FIXME. We can come here via fp_easy_constant
2447 (e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
2448 investigated whether this convert needs to be here, or
2449 something else is missing. */
2450 decimal_real_convert (r, DFmode, r);
2454 emin2m1 = fmt->emin - 1;
2457 np2 = SIGNIFICAND_BITS - p2;
2461 get_zero (r, r->sign);
2463 if (!fmt->has_signed_zero)
2468 get_inf (r, r->sign);
2473 clear_significand_below (r, np2);
2483 /* Check the range of the exponent. If we're out of range,
2484 either underflow or overflow. */
2485 if (REAL_EXP (r) > emax2)
2487 else if (REAL_EXP (r) <= emin2m1)
2491 if (!fmt->has_denorm)
2493 /* Don't underflow completely until we've had a chance to round. */
2494 if (REAL_EXP (r) < emin2m1)
2499 diff = emin2m1 - REAL_EXP (r) + 1;
2503 /* De-normalize the significand. */
2504 r->sig[0] |= sticky_rshift_significand (r, r, diff);
2505 SET_REAL_EXP (r, REAL_EXP (r) + diff);
2509 if (!fmt->round_towards_zero)
2511 /* There are P2 true significand bits, followed by one guard bit,
2512 followed by one sticky bit, followed by stuff. Fold nonzero
2513 stuff into the sticky bit. */
2514 unsigned long sticky;
2518 for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
2519 sticky |= r->sig[i];
2521 & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
2523 guard = test_significand_bit (r, np2 - 1);
2524 lsb = test_significand_bit (r, np2);
2526 /* Round to even. */
2527 round_up = guard && (sticky || lsb);
2534 set_significand_bit (&u, np2);
2536 if (add_significands (r, r, &u))
2538 /* Overflow. Means the significand had been all ones, and
2539 is now all zeros. Need to increase the exponent, and
2540 possibly re-normalize it. */
2541 SET_REAL_EXP (r, REAL_EXP (r) + 1);
2542 if (REAL_EXP (r) > emax2)
2544 r->sig[SIGSZ-1] = SIG_MSB;
2548 /* Catch underflow that we deferred until after rounding. */
2549 if (REAL_EXP (r) <= emin2m1)
2552 /* Clear out trailing garbage. */
2553 clear_significand_below (r, np2);
2556 /* Extend or truncate to a new mode. */
2559 real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
2560 const REAL_VALUE_TYPE *a)
2562 const struct real_format *fmt;
2564 fmt = REAL_MODE_FORMAT (mode);
2569 if (a->decimal || fmt->b == 10)
2570 decimal_real_convert (r, mode, a);
2572 round_for_format (fmt, r);
2574 /* round_for_format de-normalizes denormals. Undo just that part. */
2575 if (r->cl == rvc_normal)
2579 /* Legacy. Likewise, except return the struct directly. */
2582 real_value_truncate (enum machine_mode mode, REAL_VALUE_TYPE a)
2585 real_convert (&r, mode, &a);
2589 /* Return true if truncating to MODE is exact. */
2592 exact_real_truncate (enum machine_mode mode, const REAL_VALUE_TYPE *a)
2594 const struct real_format *fmt;
2598 fmt = REAL_MODE_FORMAT (mode);
2601 /* Don't allow conversion to denormals. */
2602 emin2m1 = fmt->emin - 1;
2603 if (REAL_EXP (a) <= emin2m1)
2606 /* After conversion to the new mode, the value must be identical. */
2607 real_convert (&t, mode, a);
2608 return real_identical (&t, a);
2611 /* Write R to the given target format. Place the words of the result
2612 in target word order in BUF. There are always 32 bits in each
2613 long, no matter the size of the host long.
2615 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2618 real_to_target_fmt (long *buf, const REAL_VALUE_TYPE *r_orig,
2619 const struct real_format *fmt)
2625 round_for_format (fmt, &r);
2629 (*fmt->encode) (fmt, buf, &r);
2634 /* Similar, but look up the format from MODE. */
2637 real_to_target (long *buf, const REAL_VALUE_TYPE *r, enum machine_mode mode)
2639 const struct real_format *fmt;
2641 fmt = REAL_MODE_FORMAT (mode);
2644 return real_to_target_fmt (buf, r, fmt);
2647 /* Read R from the given target format. Read the words of the result
2648 in target word order in BUF. There are always 32 bits in each
2649 long, no matter the size of the host long. */
2652 real_from_target_fmt (REAL_VALUE_TYPE *r, const long *buf,
2653 const struct real_format *fmt)
2655 (*fmt->decode) (fmt, r, buf);
2658 /* Similar, but look up the format from MODE. */
2661 real_from_target (REAL_VALUE_TYPE *r, const long *buf, enum machine_mode mode)
2663 const struct real_format *fmt;
2665 fmt = REAL_MODE_FORMAT (mode);
2668 (*fmt->decode) (fmt, r, buf);
2671 /* Return the number of bits of the largest binary value that the
2672 significand of MODE will hold. */
2673 /* ??? Legacy. Should get access to real_format directly. */
2676 significand_size (enum machine_mode mode)
2678 const struct real_format *fmt;
2680 fmt = REAL_MODE_FORMAT (mode);
2686 /* Return the size in bits of the largest binary value that can be
2687 held by the decimal coefficient for this mode. This is one more
2688 than the number of bits required to hold the largest coefficient
2690 double log2_10 = 3.3219281;
2691 return fmt->p * log2_10;
2696 /* Return a hash value for the given real value. */
2697 /* ??? The "unsigned int" return value is intended to be hashval_t,
2698 but I didn't want to pull hashtab.h into real.h. */
2701 real_hash (const REAL_VALUE_TYPE *r)
2706 h = r->cl | (r->sign << 2);
2714 h |= REAL_EXP (r) << 3;
2719 h ^= (unsigned int)-1;
2728 if (sizeof(unsigned long) > sizeof(unsigned int))
2729 for (i = 0; i < SIGSZ; ++i)
2731 unsigned long s = r->sig[i];
2732 h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2));
2735 for (i = 0; i < SIGSZ; ++i)
2741 /* IEEE single-precision format. */
2743 static void encode_ieee_single (const struct real_format *fmt,
2744 long *, const REAL_VALUE_TYPE *);
2745 static void decode_ieee_single (const struct real_format *,
2746 REAL_VALUE_TYPE *, const long *);
2749 encode_ieee_single (const struct real_format *fmt, long *buf,
2750 const REAL_VALUE_TYPE *r)
2752 unsigned long image, sig, exp;
2753 unsigned long sign = r->sign;
2754 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2757 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
2768 image |= 0x7fffffff;
2775 sig = (fmt->canonical_nan_lsbs_set ? (1 << 22) - 1 : 0);
2776 if (r->signalling == fmt->qnan_msb_set)
2787 image |= 0x7fffffff;
2791 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2792 whereas the intermediate representation is 0.F x 2**exp.
2793 Which means we're off by one. */
2797 exp = REAL_EXP (r) + 127 - 1;
2810 decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
2813 unsigned long image = buf[0] & 0xffffffff;
2814 bool sign = (image >> 31) & 1;
2815 int exp = (image >> 23) & 0xff;
2817 memset (r, 0, sizeof (*r));
2818 image <<= HOST_BITS_PER_LONG - 24;
2823 if (image && fmt->has_denorm)
2827 SET_REAL_EXP (r, -126);
2828 r->sig[SIGSZ-1] = image << 1;
2831 else if (fmt->has_signed_zero)
2834 else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
2840 r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
2841 ^ fmt->qnan_msb_set);
2842 r->sig[SIGSZ-1] = image;
2854 SET_REAL_EXP (r, exp - 127 + 1);
2855 r->sig[SIGSZ-1] = image | SIG_MSB;
2859 const struct real_format ieee_single_format =
2880 const struct real_format mips_single_format =
2901 const struct real_format motorola_single_format =
2922 /* SPU Single Precision (Extended-Range Mode) format is the same as IEEE
2923 single precision with the following differences:
2924 - Infinities are not supported. Instead MAX_FLOAT or MIN_FLOAT
2926 - NaNs are not supported.
2927 - The range of non-zero numbers in binary is
2928 (001)[1.]000...000 to (255)[1.]111...111.
2929 - Denormals can be represented, but are treated as +0.0 when
2930 used as an operand and are never generated as a result.
2931 - -0.0 can be represented, but a zero result is always +0.0.
2932 - the only supported rounding mode is trunction (towards zero). */
2933 const struct real_format spu_single_format =
2954 /* IEEE double-precision format. */
2956 static void encode_ieee_double (const struct real_format *fmt,
2957 long *, const REAL_VALUE_TYPE *);
2958 static void decode_ieee_double (const struct real_format *,
2959 REAL_VALUE_TYPE *, const long *);
2962 encode_ieee_double (const struct real_format *fmt, long *buf,
2963 const REAL_VALUE_TYPE *r)
2965 unsigned long image_lo, image_hi, sig_lo, sig_hi, exp;
2966 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2968 image_hi = r->sign << 31;
2971 if (HOST_BITS_PER_LONG == 64)
2973 sig_hi = r->sig[SIGSZ-1];
2974 sig_lo = (sig_hi >> (64 - 53)) & 0xffffffff;
2975 sig_hi = (sig_hi >> (64 - 53 + 1) >> 31) & 0xfffff;
2979 sig_hi = r->sig[SIGSZ-1];
2980 sig_lo = r->sig[SIGSZ-2];
2981 sig_lo = (sig_hi << 21) | (sig_lo >> 11);
2982 sig_hi = (sig_hi >> 11) & 0xfffff;
2992 image_hi |= 2047 << 20;
2995 image_hi |= 0x7fffffff;
2996 image_lo = 0xffffffff;
3005 if (fmt->canonical_nan_lsbs_set)
3007 sig_hi = (1 << 19) - 1;
3008 sig_lo = 0xffffffff;
3016 if (r->signalling == fmt->qnan_msb_set)
3017 sig_hi &= ~(1 << 19);
3020 if (sig_hi == 0 && sig_lo == 0)
3023 image_hi |= 2047 << 20;
3029 image_hi |= 0x7fffffff;
3030 image_lo = 0xffffffff;
3035 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3036 whereas the intermediate representation is 0.F x 2**exp.
3037 Which means we're off by one. */
3041 exp = REAL_EXP (r) + 1023 - 1;
3042 image_hi |= exp << 20;
3051 if (FLOAT_WORDS_BIG_ENDIAN)
3052 buf[0] = image_hi, buf[1] = image_lo;
3054 buf[0] = image_lo, buf[1] = image_hi;
3058 decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3061 unsigned long image_hi, image_lo;
3065 if (FLOAT_WORDS_BIG_ENDIAN)
3066 image_hi = buf[0], image_lo = buf[1];
3068 image_lo = buf[0], image_hi = buf[1];
3069 image_lo &= 0xffffffff;
3070 image_hi &= 0xffffffff;
3072 sign = (image_hi >> 31) & 1;
3073 exp = (image_hi >> 20) & 0x7ff;
3075 memset (r, 0, sizeof (*r));
3077 image_hi <<= 32 - 21;
3078 image_hi |= image_lo >> 21;
3079 image_hi &= 0x7fffffff;
3080 image_lo <<= 32 - 21;
3084 if ((image_hi || image_lo) && fmt->has_denorm)
3088 SET_REAL_EXP (r, -1022);
3089 if (HOST_BITS_PER_LONG == 32)
3091 image_hi = (image_hi << 1) | (image_lo >> 31);
3093 r->sig[SIGSZ-1] = image_hi;
3094 r->sig[SIGSZ-2] = image_lo;
3098 image_hi = (image_hi << 31 << 2) | (image_lo << 1);
3099 r->sig[SIGSZ-1] = image_hi;
3103 else if (fmt->has_signed_zero)
3106 else if (exp == 2047 && (fmt->has_nans || fmt->has_inf))
3108 if (image_hi || image_lo)
3112 r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set;
3113 if (HOST_BITS_PER_LONG == 32)
3115 r->sig[SIGSZ-1] = image_hi;
3116 r->sig[SIGSZ-2] = image_lo;
3119 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo;
3131 SET_REAL_EXP (r, exp - 1023 + 1);
3132 if (HOST_BITS_PER_LONG == 32)
3134 r->sig[SIGSZ-1] = image_hi | SIG_MSB;
3135 r->sig[SIGSZ-2] = image_lo;
3138 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo | SIG_MSB;
3142 const struct real_format ieee_double_format =
3163 const struct real_format mips_double_format =
3184 const struct real_format motorola_double_format =
3205 /* IEEE extended real format. This comes in three flavors: Intel's as
3206 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
3207 12- and 16-byte images may be big- or little endian; Motorola's is
3208 always big endian. */
3210 /* Helper subroutine which converts from the internal format to the
3211 12-byte little-endian Intel format. Functions below adjust this
3212 for the other possible formats. */
3214 encode_ieee_extended (const struct real_format *fmt, long *buf,
3215 const REAL_VALUE_TYPE *r)
3217 unsigned long image_hi, sig_hi, sig_lo;
3218 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
3220 image_hi = r->sign << 15;
3221 sig_hi = sig_lo = 0;
3233 /* Intel requires the explicit integer bit to be set, otherwise
3234 it considers the value a "pseudo-infinity". Motorola docs
3235 say it doesn't care. */
3236 sig_hi = 0x80000000;
3241 sig_lo = sig_hi = 0xffffffff;
3251 if (fmt->canonical_nan_lsbs_set)
3253 sig_hi = (1 << 30) - 1;
3254 sig_lo = 0xffffffff;
3257 else if (HOST_BITS_PER_LONG == 32)
3259 sig_hi = r->sig[SIGSZ-1];
3260 sig_lo = r->sig[SIGSZ-2];
3264 sig_lo = r->sig[SIGSZ-1];
3265 sig_hi = sig_lo >> 31 >> 1;
3266 sig_lo &= 0xffffffff;
3268 if (r->signalling == fmt->qnan_msb_set)
3269 sig_hi &= ~(1 << 30);
3272 if ((sig_hi & 0x7fffffff) == 0 && sig_lo == 0)
3275 /* Intel requires the explicit integer bit to be set, otherwise
3276 it considers the value a "pseudo-nan". Motorola docs say it
3278 sig_hi |= 0x80000000;
3283 sig_lo = sig_hi = 0xffffffff;
3289 int exp = REAL_EXP (r);
3291 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3292 whereas the intermediate representation is 0.F x 2**exp.
3293 Which means we're off by one.
3295 Except for Motorola, which consider exp=0 and explicit
3296 integer bit set to continue to be normalized. In theory
3297 this discrepancy has been taken care of by the difference
3298 in fmt->emin in round_for_format. */
3305 gcc_assert (exp >= 0);
3309 if (HOST_BITS_PER_LONG == 32)
3311 sig_hi = r->sig[SIGSZ-1];
3312 sig_lo = r->sig[SIGSZ-2];
3316 sig_lo = r->sig[SIGSZ-1];
3317 sig_hi = sig_lo >> 31 >> 1;
3318 sig_lo &= 0xffffffff;
3327 buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
3330 /* Convert from the internal format to the 12-byte Motorola format
3331 for an IEEE extended real. */
3333 encode_ieee_extended_motorola (const struct real_format *fmt, long *buf,
3334 const REAL_VALUE_TYPE *r)
3337 encode_ieee_extended (fmt, intermed, r);
3339 /* Motorola chips are assumed always to be big-endian. Also, the
3340 padding in a Motorola extended real goes between the exponent and
3341 the mantissa. At this point the mantissa is entirely within
3342 elements 0 and 1 of intermed, and the exponent entirely within
3343 element 2, so all we have to do is swap the order around, and
3344 shift element 2 left 16 bits. */
3345 buf[0] = intermed[2] << 16;
3346 buf[1] = intermed[1];
3347 buf[2] = intermed[0];
3350 /* Convert from the internal format to the 12-byte Intel format for
3351 an IEEE extended real. */
3353 encode_ieee_extended_intel_96 (const struct real_format *fmt, long *buf,
3354 const REAL_VALUE_TYPE *r)
3356 if (FLOAT_WORDS_BIG_ENDIAN)
3358 /* All the padding in an Intel-format extended real goes at the high
3359 end, which in this case is after the mantissa, not the exponent.
3360 Therefore we must shift everything down 16 bits. */
3362 encode_ieee_extended (fmt, intermed, r);
3363 buf[0] = ((intermed[2] << 16) | ((unsigned long)(intermed[1] & 0xFFFF0000) >> 16));
3364 buf[1] = ((intermed[1] << 16) | ((unsigned long)(intermed[0] & 0xFFFF0000) >> 16));
3365 buf[2] = (intermed[0] << 16);
3368 /* encode_ieee_extended produces what we want directly. */
3369 encode_ieee_extended (fmt, buf, r);
3372 /* Convert from the internal format to the 16-byte Intel format for
3373 an IEEE extended real. */
3375 encode_ieee_extended_intel_128 (const struct real_format *fmt, long *buf,
3376 const REAL_VALUE_TYPE *r)
3378 /* All the padding in an Intel-format extended real goes at the high end. */
3379 encode_ieee_extended_intel_96 (fmt, buf, r);
3383 /* As above, we have a helper function which converts from 12-byte
3384 little-endian Intel format to internal format. Functions below
3385 adjust for the other possible formats. */
3387 decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3390 unsigned long image_hi, sig_hi, sig_lo;
3394 sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
3395 sig_lo &= 0xffffffff;
3396 sig_hi &= 0xffffffff;
3397 image_hi &= 0xffffffff;
3399 sign = (image_hi >> 15) & 1;
3400 exp = image_hi & 0x7fff;
3402 memset (r, 0, sizeof (*r));
3406 if ((sig_hi || sig_lo) && fmt->has_denorm)
3411 /* When the IEEE format contains a hidden bit, we know that
3412 it's zero at this point, and so shift up the significand
3413 and decrease the exponent to match. In this case, Motorola
3414 defines the explicit integer bit to be valid, so we don't
3415 know whether the msb is set or not. */
3416 SET_REAL_EXP (r, fmt->emin);
3417 if (HOST_BITS_PER_LONG == 32)
3419 r->sig[SIGSZ-1] = sig_hi;
3420 r->sig[SIGSZ-2] = sig_lo;
3423 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3427 else if (fmt->has_signed_zero)
3430 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3432 /* See above re "pseudo-infinities" and "pseudo-nans".
3433 Short summary is that the MSB will likely always be
3434 set, and that we don't care about it. */
3435 sig_hi &= 0x7fffffff;
3437 if (sig_hi || sig_lo)
3441 r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set;
3442 if (HOST_BITS_PER_LONG == 32)
3444 r->sig[SIGSZ-1] = sig_hi;
3445 r->sig[SIGSZ-2] = sig_lo;
3448 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3460 SET_REAL_EXP (r, exp - 16383 + 1);
3461 if (HOST_BITS_PER_LONG == 32)
3463 r->sig[SIGSZ-1] = sig_hi;
3464 r->sig[SIGSZ-2] = sig_lo;
3467 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3471 /* Convert from the internal format to the 12-byte Motorola format
3472 for an IEEE extended real. */
3474 decode_ieee_extended_motorola (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3479 /* Motorola chips are assumed always to be big-endian. Also, the
3480 padding in a Motorola extended real goes between the exponent and
3481 the mantissa; remove it. */
3482 intermed[0] = buf[2];
3483 intermed[1] = buf[1];
3484 intermed[2] = (unsigned long)buf[0] >> 16;
3486 decode_ieee_extended (fmt, r, intermed);
3489 /* Convert from the internal format to the 12-byte Intel format for
3490 an IEEE extended real. */
3492 decode_ieee_extended_intel_96 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3495 if (FLOAT_WORDS_BIG_ENDIAN)
3497 /* All the padding in an Intel-format extended real goes at the high
3498 end, which in this case is after the mantissa, not the exponent.
3499 Therefore we must shift everything up 16 bits. */
3502 intermed[0] = (((unsigned long)buf[2] >> 16) | (buf[1] << 16));
3503 intermed[1] = (((unsigned long)buf[1] >> 16) | (buf[0] << 16));
3504 intermed[2] = ((unsigned long)buf[0] >> 16);
3506 decode_ieee_extended (fmt, r, intermed);
3509 /* decode_ieee_extended produces what we want directly. */
3510 decode_ieee_extended (fmt, r, buf);
3513 /* Convert from the internal format to the 16-byte Intel format for
3514 an IEEE extended real. */
3516 decode_ieee_extended_intel_128 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3519 /* All the padding in an Intel-format extended real goes at the high end. */
3520 decode_ieee_extended_intel_96 (fmt, r, buf);
3523 const struct real_format ieee_extended_motorola_format =
3525 encode_ieee_extended_motorola,
3526 decode_ieee_extended_motorola,
3544 const struct real_format ieee_extended_intel_96_format =
3546 encode_ieee_extended_intel_96,
3547 decode_ieee_extended_intel_96,
3565 const struct real_format ieee_extended_intel_128_format =
3567 encode_ieee_extended_intel_128,
3568 decode_ieee_extended_intel_128,
3586 /* The following caters to i386 systems that set the rounding precision
3587 to 53 bits instead of 64, e.g. FreeBSD. */
3588 const struct real_format ieee_extended_intel_96_round_53_format =
3590 encode_ieee_extended_intel_96,
3591 decode_ieee_extended_intel_96,
3609 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3610 numbers whose sum is equal to the extended precision value. The number
3611 with greater magnitude is first. This format has the same magnitude
3612 range as an IEEE double precision value, but effectively 106 bits of
3613 significand precision. Infinity and NaN are represented by their IEEE
3614 double precision value stored in the first number, the second number is
3615 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3617 static void encode_ibm_extended (const struct real_format *fmt,
3618 long *, const REAL_VALUE_TYPE *);
3619 static void decode_ibm_extended (const struct real_format *,
3620 REAL_VALUE_TYPE *, const long *);
3623 encode_ibm_extended (const struct real_format *fmt, long *buf,
3624 const REAL_VALUE_TYPE *r)
3626 REAL_VALUE_TYPE u, normr, v;
3627 const struct real_format *base_fmt;
3629 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3631 /* Renormalize R before doing any arithmetic on it. */
3633 if (normr.cl == rvc_normal)
3636 /* u = IEEE double precision portion of significand. */
3638 round_for_format (base_fmt, &u);
3639 encode_ieee_double (base_fmt, &buf[0], &u);
3641 if (u.cl == rvc_normal)
3643 do_add (&v, &normr, &u, 1);
3644 /* Call round_for_format since we might need to denormalize. */
3645 round_for_format (base_fmt, &v);
3646 encode_ieee_double (base_fmt, &buf[2], &v);
3650 /* Inf, NaN, 0 are all representable as doubles, so the
3651 least-significant part can be 0.0. */
3658 decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_TYPE *r,
3661 REAL_VALUE_TYPE u, v;
3662 const struct real_format *base_fmt;
3664 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3665 decode_ieee_double (base_fmt, &u, &buf[0]);
3667 if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan)
3669 decode_ieee_double (base_fmt, &v, &buf[2]);
3670 do_add (r, &u, &v, 0);
3676 const struct real_format ibm_extended_format =
3678 encode_ibm_extended,
3679 decode_ibm_extended,
3697 const struct real_format mips_extended_format =
3699 encode_ibm_extended,
3700 decode_ibm_extended,
3719 /* IEEE quad precision format. */
3721 static void encode_ieee_quad (const struct real_format *fmt,
3722 long *, const REAL_VALUE_TYPE *);
3723 static void decode_ieee_quad (const struct real_format *,
3724 REAL_VALUE_TYPE *, const long *);
3727 encode_ieee_quad (const struct real_format *fmt, long *buf,
3728 const REAL_VALUE_TYPE *r)
3730 unsigned long image3, image2, image1, image0, exp;
3731 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
3734 image3 = r->sign << 31;
3739 rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
3748 image3 |= 32767 << 16;
3751 image3 |= 0x7fffffff;
3752 image2 = 0xffffffff;
3753 image1 = 0xffffffff;
3754 image0 = 0xffffffff;
3761 image3 |= 32767 << 16;
3765 if (fmt->canonical_nan_lsbs_set)
3768 image2 = image1 = image0 = 0xffffffff;
3771 else if (HOST_BITS_PER_LONG == 32)
3776 image3 |= u.sig[3] & 0xffff;
3781 image1 = image0 >> 31 >> 1;
3783 image3 |= (image2 >> 31 >> 1) & 0xffff;
3784 image0 &= 0xffffffff;
3785 image2 &= 0xffffffff;
3787 if (r->signalling == fmt->qnan_msb_set)
3791 if (((image3 & 0xffff) | image2 | image1 | image0) == 0)
3796 image3 |= 0x7fffffff;
3797 image2 = 0xffffffff;
3798 image1 = 0xffffffff;
3799 image0 = 0xffffffff;
3804 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3805 whereas the intermediate representation is 0.F x 2**exp.
3806 Which means we're off by one. */
3810 exp = REAL_EXP (r) + 16383 - 1;
3811 image3 |= exp << 16;
3813 if (HOST_BITS_PER_LONG == 32)
3818 image3 |= u.sig[3] & 0xffff;
3823 image1 = image0 >> 31 >> 1;
3825 image3 |= (image2 >> 31 >> 1) & 0xffff;
3826 image0 &= 0xffffffff;
3827 image2 &= 0xffffffff;
3835 if (FLOAT_WORDS_BIG_ENDIAN)
3852 decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3855 unsigned long image3, image2, image1, image0;
3859 if (FLOAT_WORDS_BIG_ENDIAN)
3873 image0 &= 0xffffffff;
3874 image1 &= 0xffffffff;
3875 image2 &= 0xffffffff;
3877 sign = (image3 >> 31) & 1;
3878 exp = (image3 >> 16) & 0x7fff;
3881 memset (r, 0, sizeof (*r));
3885 if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
3890 SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
3891 if (HOST_BITS_PER_LONG == 32)
3900 r->sig[0] = (image1 << 31 << 1) | image0;
3901 r->sig[1] = (image3 << 31 << 1) | image2;
3906 else if (fmt->has_signed_zero)
3909 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3911 if (image3 | image2 | image1 | image0)
3915 r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set;
3917 if (HOST_BITS_PER_LONG == 32)
3926 r->sig[0] = (image1 << 31 << 1) | image0;
3927 r->sig[1] = (image3 << 31 << 1) | image2;
3929 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3941 SET_REAL_EXP (r, exp - 16383 + 1);
3943 if (HOST_BITS_PER_LONG == 32)
3952 r->sig[0] = (image1 << 31 << 1) | image0;
3953 r->sig[1] = (image3 << 31 << 1) | image2;
3955 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3956 r->sig[SIGSZ-1] |= SIG_MSB;
3960 const struct real_format ieee_quad_format =
3981 const struct real_format mips_quad_format =
4002 /* Descriptions of VAX floating point formats can be found beginning at
4004 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
4006 The thing to remember is that they're almost IEEE, except for word
4007 order, exponent bias, and the lack of infinities, nans, and denormals.
4009 We don't implement the H_floating format here, simply because neither
4010 the VAX or Alpha ports use it. */
4012 static void encode_vax_f (const struct real_format *fmt,
4013 long *, const REAL_VALUE_TYPE *);
4014 static void decode_vax_f (const struct real_format *,
4015 REAL_VALUE_TYPE *, const long *);
4016 static void encode_vax_d (const struct real_format *fmt,
4017 long *, const REAL_VALUE_TYPE *);
4018 static void decode_vax_d (const struct real_format *,
4019 REAL_VALUE_TYPE *, const long *);
4020 static void encode_vax_g (const struct real_format *fmt,
4021 long *, const REAL_VALUE_TYPE *);
4022 static void decode_vax_g (const struct real_format *,
4023 REAL_VALUE_TYPE *, const long *);
4026 encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4027 const REAL_VALUE_TYPE *r)
4029 unsigned long sign, exp, sig, image;
4031 sign = r->sign << 15;
4041 image = 0xffff7fff | sign;
4045 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
4046 exp = REAL_EXP (r) + 128;
4048 image = (sig << 16) & 0xffff0000;
4062 decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED,
4063 REAL_VALUE_TYPE *r, const long *buf)
4065 unsigned long image = buf[0] & 0xffffffff;
4066 int exp = (image >> 7) & 0xff;
4068 memset (r, 0, sizeof (*r));
4073 r->sign = (image >> 15) & 1;
4074 SET_REAL_EXP (r, exp - 128);
4076 image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff);
4077 r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
4082 encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4083 const REAL_VALUE_TYPE *r)
4085 unsigned long image0, image1, sign = r->sign << 15;
4090 image0 = image1 = 0;
4095 image0 = 0xffff7fff | sign;
4096 image1 = 0xffffffff;
4100 /* Extract the significand into straight hi:lo. */
4101 if (HOST_BITS_PER_LONG == 64)
4103 image0 = r->sig[SIGSZ-1];
4104 image1 = (image0 >> (64 - 56)) & 0xffffffff;
4105 image0 = (image0 >> (64 - 56 + 1) >> 31) & 0x7fffff;
4109 image0 = r->sig[SIGSZ-1];
4110 image1 = r->sig[SIGSZ-2];
4111 image1 = (image0 << 24) | (image1 >> 8);
4112 image0 = (image0 >> 8) & 0xffffff;
4115 /* Rearrange the half-words of the significand to match the
4117 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff007f;
4118 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
4120 /* Add the sign and exponent. */
4122 image0 |= (REAL_EXP (r) + 128) << 7;
4129 if (FLOAT_WORDS_BIG_ENDIAN)
4130 buf[0] = image1, buf[1] = image0;
4132 buf[0] = image0, buf[1] = image1;
4136 decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED,
4137 REAL_VALUE_TYPE *r, const long *buf)
4139 unsigned long image0, image1;
4142 if (FLOAT_WORDS_BIG_ENDIAN)
4143 image1 = buf[0], image0 = buf[1];
4145 image0 = buf[0], image1 = buf[1];
4146 image0 &= 0xffffffff;
4147 image1 &= 0xffffffff;
4149 exp = (image0 >> 7) & 0xff;
4151 memset (r, 0, sizeof (*r));
4156 r->sign = (image0 >> 15) & 1;
4157 SET_REAL_EXP (r, exp - 128);
4159 /* Rearrange the half-words of the external format into
4160 proper ascending order. */
4161 image0 = ((image0 & 0x7f) << 16) | ((image0 >> 16) & 0xffff);
4162 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
4164 if (HOST_BITS_PER_LONG == 64)
4166 image0 = (image0 << 31 << 1) | image1;
4169 r->sig[SIGSZ-1] = image0;
4173 r->sig[SIGSZ-1] = image0;
4174 r->sig[SIGSZ-2] = image1;
4175 lshift_significand (r, r, 2*HOST_BITS_PER_LONG - 56);
4176 r->sig[SIGSZ-1] |= SIG_MSB;
4182 encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4183 const REAL_VALUE_TYPE *r)
4185 unsigned long image0, image1, sign = r->sign << 15;
4190 image0 = image1 = 0;
4195 image0 = 0xffff7fff | sign;
4196 image1 = 0xffffffff;
4200 /* Extract the significand into straight hi:lo. */
4201 if (HOST_BITS_PER_LONG == 64)
4203 image0 = r->sig[SIGSZ-1];
4204 image1 = (image0 >> (64 - 53)) & 0xffffffff;
4205 image0 = (image0 >> (64 - 53 + 1) >> 31) & 0xfffff;
4209 image0 = r->sig[SIGSZ-1];
4210 image1 = r->sig[SIGSZ-2];
4211 image1 = (image0 << 21) | (image1 >> 11);
4212 image0 = (image0 >> 11) & 0xfffff;
4215 /* Rearrange the half-words of the significand to match the
4217 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff000f;
4218 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
4220 /* Add the sign and exponent. */
4222 image0 |= (REAL_EXP (r) + 1024) << 4;
4229 if (FLOAT_WORDS_BIG_ENDIAN)
4230 buf[0] = image1, buf[1] = image0;
4232 buf[0] = image0, buf[1] = image1;
4236 decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED,
4237 REAL_VALUE_TYPE *r, const long *buf)
4239 unsigned long image0, image1;
4242 if (FLOAT_WORDS_BIG_ENDIAN)
4243 image1 = buf[0], image0 = buf[1];
4245 image0 = buf[0], image1 = buf[1];
4246 image0 &= 0xffffffff;
4247 image1 &= 0xffffffff;
4249 exp = (image0 >> 4) & 0x7ff;
4251 memset (r, 0, sizeof (*r));
4256 r->sign = (image0 >> 15) & 1;
4257 SET_REAL_EXP (r, exp - 1024);
4259 /* Rearrange the half-words of the external format into
4260 proper ascending order. */
4261 image0 = ((image0 & 0xf) << 16) | ((image0 >> 16) & 0xffff);
4262 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
4264 if (HOST_BITS_PER_LONG == 64)
4266 image0 = (image0 << 31 << 1) | image1;
4269 r->sig[SIGSZ-1] = image0;
4273 r->sig[SIGSZ-1] = image0;
4274 r->sig[SIGSZ-2] = image1;
4275 lshift_significand (r, r, 64 - 53);
4276 r->sig[SIGSZ-1] |= SIG_MSB;
4281 const struct real_format vax_f_format =
4302 const struct real_format vax_d_format =
4323 const struct real_format vax_g_format =
4344 /* Encode real R into a single precision DFP value in BUF. */
4346 encode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4347 long *buf ATTRIBUTE_UNUSED,
4348 const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
4350 encode_decimal32 (fmt, buf, r);
4353 /* Decode a single precision DFP value in BUF into a real R. */
4355 decode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4356 REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
4357 const long *buf ATTRIBUTE_UNUSED)
4359 decode_decimal32 (fmt, r, buf);
4362 /* Encode real R into a double precision DFP value in BUF. */
4364 encode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4365 long *buf ATTRIBUTE_UNUSED,
4366 const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
4368 encode_decimal64 (fmt, buf, r);
4371 /* Decode a double precision DFP value in BUF into a real R. */
4373 decode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4374 REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
4375 const long *buf ATTRIBUTE_UNUSED)
4377 decode_decimal64 (fmt, r, buf);
4380 /* Encode real R into a quad precision DFP value in BUF. */
4382 encode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
4383 long *buf ATTRIBUTE_UNUSED,
4384 const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
4386 encode_decimal128 (fmt, buf, r);
4389 /* Decode a quad precision DFP value in BUF into a real R. */
4391 decode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
4392 REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
4393 const long *buf ATTRIBUTE_UNUSED)
4395 decode_decimal128 (fmt, r, buf);
4398 /* Single precision decimal floating point (IEEE 754). */
4399 const struct real_format decimal_single_format =
4401 encode_decimal_single,
4402 decode_decimal_single,
4420 /* Double precision decimal floating point (IEEE 754). */
4421 const struct real_format decimal_double_format =
4423 encode_decimal_double,
4424 decode_decimal_double,
4442 /* Quad precision decimal floating point (IEEE 754). */
4443 const struct real_format decimal_quad_format =
4445 encode_decimal_quad,
4446 decode_decimal_quad,
4464 /* A synthetic "format" for internal arithmetic. It's the size of the
4465 internal significand minus the two bits needed for proper rounding.
4466 The encode and decode routines exist only to satisfy our paranoia
4469 static void encode_internal (const struct real_format *fmt,
4470 long *, const REAL_VALUE_TYPE *);
4471 static void decode_internal (const struct real_format *,
4472 REAL_VALUE_TYPE *, const long *);
4475 encode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4476 const REAL_VALUE_TYPE *r)
4478 memcpy (buf, r, sizeof (*r));
4482 decode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED,
4483 REAL_VALUE_TYPE *r, const long *buf)
4485 memcpy (r, buf, sizeof (*r));
4488 const struct real_format real_internal_format =
4493 SIGNIFICAND_BITS - 2,
4494 SIGNIFICAND_BITS - 2,
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. */
4516 real_sqrt (REAL_VALUE_TYPE *r, enum machine_mode mode,
4517 const REAL_VALUE_TYPE *x)
4519 static REAL_VALUE_TYPE halfthree;
4520 static bool init = false;
4521 REAL_VALUE_TYPE h, t, i;
4524 /* sqrt(-0.0) is -0.0. */
4525 if (real_isnegzero (x))
4531 /* Negative arguments return NaN. */
4534 get_canonical_qnan (r, 0);
4538 /* Infinity and NaN return themselves. */
4539 if (!real_isfinite (x))
4547 do_add (&halfthree, &dconst1, &dconsthalf, 0);
4551 /* Initial guess for reciprocal sqrt, i. */
4552 exp = real_exponent (x);
4553 real_ldexp (&i, &dconst1, -exp/2);
4555 /* Newton's iteration for reciprocal sqrt, i. */
4556 for (iter = 0; iter < 16; iter++)
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);
4565 /* Check for early convergence. */
4566 if (iter >= 6 && real_identical (&i, &t))
4569 /* ??? Unroll loop to avoid copying. */
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);
4581 /* ??? We need a Tuckerman test to get the last bit. */
4583 real_convert (r, mode, &h);
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. */
4594 real_powi (REAL_VALUE_TYPE *r, enum machine_mode mode,
4595 const REAL_VALUE_TYPE *x, HOST_WIDE_INT n)
4597 unsigned HOST_WIDE_INT bit;
4599 bool inexact = false;
4611 /* Don't worry about overflow, from now on n is unsigned. */
4619 bit = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
4620 for (i = 0; i < HOST_BITS_PER_WIDE_INT; i++)
4624 inexact |= do_multiply (&t, &t, &t);
4626 inexact |= do_multiply (&t, &t, x);
4634 inexact |= do_divide (&t, &dconst1, &t);
4636 real_convert (r, mode, &t);
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. */
4644 real_trunc (REAL_VALUE_TYPE *r, enum machine_mode mode,
4645 const REAL_VALUE_TYPE *x)
4647 do_fix_trunc (r, x);
4648 if (mode != VOIDmode)
4649 real_convert (r, mode, r);
4652 /* Round X to the largest integer not greater in value, i.e. round
4653 down, placing the result in R in mode MODE. */
4656 real_floor (REAL_VALUE_TYPE *r, enum machine_mode mode,
4657 const REAL_VALUE_TYPE *x)
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);
4670 /* Round X to the smallest integer not less then argument, i.e. round
4671 up, placing the result in R in mode MODE. */
4674 real_ceil (REAL_VALUE_TYPE *r, enum machine_mode mode,
4675 const REAL_VALUE_TYPE *x)
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);
4688 /* Round X to the nearest integer, but round halfway cases away from
4692 real_round (REAL_VALUE_TYPE *r, enum machine_mode mode,
4693 const REAL_VALUE_TYPE *x)
4695 do_add (r, x, &dconsthalf, x->sign);
4696 do_fix_trunc (r, r);
4697 if (mode != VOIDmode)
4698 real_convert (r, mode, r);
4701 /* Set the sign of R to the sign of X. */
4704 real_copysign (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *x)
4709 /* Convert from REAL_VALUE_TYPE to MPFR. The caller is responsible
4710 for initializing and clearing the MPFR parameter. */
4713 mpfr_from_real (mpfr_ptr m, const REAL_VALUE_TYPE *r, mp_rnd_t rndmode)
4715 /* We use a string as an intermediate type. */
4719 /* Take care of Infinity and NaN. */
4720 if (r->cl == rvc_inf)
4722 mpfr_set_inf (m, r->sign == 1 ? -1 : 1);
4726 if (r->cl == rvc_nan)
4732 real_to_hexadecimal (buf, r, sizeof (buf), 0, 1);
4733 /* mpfr_set_str() parses hexadecimal floats from strings in the same
4734 format that GCC will output them. Nothing extra is needed. */
4735 ret = mpfr_set_str (m, buf, 16, rndmode);
4736 gcc_assert (ret == 0);
4739 /* Convert from MPFR to REAL_VALUE_TYPE, for a given type TYPE and rounding
4740 mode RNDMODE. TYPE is only relevant if M is a NaN. */
4743 real_from_mpfr (REAL_VALUE_TYPE *r, mpfr_srcptr m, tree type, mp_rnd_t rndmode)
4745 /* We use a string as an intermediate type. */
4746 char buf[128], *rstr;
4749 /* Take care of Infinity and NaN. */
4753 if (mpfr_sgn (m) < 0)
4754 *r = REAL_VALUE_NEGATE (*r);
4760 real_nan (r, "", 1, TYPE_MODE (type));
4764 rstr = mpfr_get_str (NULL, &exp, 16, 0, m, rndmode);
4766 /* The additional 12 chars add space for the sprintf below. This
4767 leaves 6 digits for the exponent which is supposedly enough. */
4768 gcc_assert (rstr != NULL && strlen (rstr) < sizeof (buf) - 12);
4770 /* REAL_VALUE_ATOF expects the exponent for mantissa * 2**exp,
4771 mpfr_get_str returns the exponent for mantissa * 16**exp, adjust
4776 sprintf (buf, "-0x.%sp%d", &rstr[1], (int) exp);
4778 sprintf (buf, "0x.%sp%d", rstr, (int) exp);
4780 mpfr_free_str (rstr);
4782 real_from_string (r, buf);
4785 /* Check whether the real constant value given is an integer. */
4788 real_isinteger (const REAL_VALUE_TYPE *c, enum machine_mode mode)
4790 REAL_VALUE_TYPE cint;
4792 real_trunc (&cint, mode, c);
4793 return real_identical (c, &cint);
4796 /* Write into BUF the maximum representable finite floating-point
4797 number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
4798 float string. LEN is the size of BUF, and the buffer must be large
4799 enough to contain the resulting string. */
4802 get_max_float (const struct real_format *fmt, char *buf, size_t len)
4807 strcpy (buf, "0x0.");
4809 for (i = 0, p = buf + 4; i + 3 < n; i += 4)
4812 *p++ = "08ce"[n - i];
4813 sprintf (p, "p%d", fmt->emax);
4814 if (fmt->pnan < fmt->p)
4816 /* This is an IBM extended double format made up of two IEEE
4817 doubles. The value of the long double is the sum of the
4818 values of the two parts. The most significant part is
4819 required to be the value of the long double rounded to the
4820 nearest double. Rounding means we need a slightly smaller
4821 value for LDBL_MAX. */
4822 buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
4825 gcc_assert (strlen (buf) < len);