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>
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 2, 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 COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
26 #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.
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. */
75 /* Used to classify two numbers simultaneously. */
76 #define CLASS2(A, B) ((A) << 2 | (B))
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"
82 static void get_zero (REAL_VALUE_TYPE *, int);
83 static void get_canonical_qnan (REAL_VALUE_TYPE *, int);
84 static void get_canonical_snan (REAL_VALUE_TYPE *, int);
85 static void get_inf (REAL_VALUE_TYPE *, int);
86 static bool sticky_rshift_significand (REAL_VALUE_TYPE *,
87 const REAL_VALUE_TYPE *, unsigned int);
88 static void rshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
90 static void lshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
92 static void lshift_significand_1 (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
93 static bool add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *,
94 const REAL_VALUE_TYPE *);
95 static bool sub_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
96 const REAL_VALUE_TYPE *, int);
97 static void neg_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
98 static int cmp_significands (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
99 static int cmp_significand_0 (const REAL_VALUE_TYPE *);
100 static void set_significand_bit (REAL_VALUE_TYPE *, unsigned int);
101 static void clear_significand_bit (REAL_VALUE_TYPE *, unsigned int);
102 static bool test_significand_bit (REAL_VALUE_TYPE *, unsigned int);
103 static void clear_significand_below (REAL_VALUE_TYPE *, unsigned int);
104 static bool div_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
105 const REAL_VALUE_TYPE *);
106 static void normalize (REAL_VALUE_TYPE *);
108 static bool do_add (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
109 const REAL_VALUE_TYPE *, int);
110 static bool do_multiply (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
111 const REAL_VALUE_TYPE *);
112 static bool do_divide (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
113 const REAL_VALUE_TYPE *);
114 static int do_compare (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
115 static void do_fix_trunc (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
117 static unsigned long rtd_divmod (REAL_VALUE_TYPE *, REAL_VALUE_TYPE *);
119 static const REAL_VALUE_TYPE * ten_to_ptwo (int);
120 static const REAL_VALUE_TYPE * ten_to_mptwo (int);
121 static const REAL_VALUE_TYPE * real_digit (int);
122 static void times_pten (REAL_VALUE_TYPE *, int);
124 static void round_for_format (const struct real_format *, REAL_VALUE_TYPE *);
126 /* Initialize R with a positive zero. */
129 get_zero (REAL_VALUE_TYPE *r, int sign)
131 memset (r, 0, sizeof (*r));
135 /* Initialize R with the canonical quiet NaN. */
138 get_canonical_qnan (REAL_VALUE_TYPE *r, int sign)
140 memset (r, 0, sizeof (*r));
147 get_canonical_snan (REAL_VALUE_TYPE *r, int sign)
149 memset (r, 0, sizeof (*r));
157 get_inf (REAL_VALUE_TYPE *r, int sign)
159 memset (r, 0, sizeof (*r));
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. */
169 sticky_rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
172 unsigned long sticky = 0;
173 unsigned int i, ofs = 0;
175 if (n >= HOST_BITS_PER_LONG)
177 for (i = 0, ofs = n / HOST_BITS_PER_LONG; i < ofs; ++i)
179 n &= HOST_BITS_PER_LONG - 1;
184 sticky |= a->sig[ofs] & (((unsigned long)1 << n) - 1);
185 for (i = 0; i < SIGSZ; ++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)));
195 for (i = 0; ofs + i < SIGSZ; ++i)
196 r->sig[i] = a->sig[ofs + i];
197 for (; i < SIGSZ; ++i)
204 /* Right-shift the significand of A by N bits; put the result in the
208 rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
211 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
213 n &= HOST_BITS_PER_LONG - 1;
216 for (i = 0; i < SIGSZ; ++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)));
226 for (i = 0; ofs + i < SIGSZ; ++i)
227 r->sig[i] = a->sig[ofs + i];
228 for (; i < SIGSZ; ++i)
233 /* Left-shift the significand of A by N bits; put the result in the
237 lshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
240 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
242 n &= HOST_BITS_PER_LONG - 1;
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;
251 for (i = 0; i < SIGSZ; ++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)));
260 /* Likewise, but N is specialized to 1. */
263 lshift_significand_1 (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
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;
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. */
276 add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
277 const REAL_VALUE_TYPE *b)
282 for (i = 0; i < SIGSZ; ++i)
284 unsigned long ai = a->sig[i];
285 unsigned long ri = ai + b->sig[i];
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. */
306 sub_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
307 const REAL_VALUE_TYPE *b, int carry)
311 for (i = 0; i < SIGSZ; ++i)
313 unsigned long ai = a->sig[i];
314 unsigned long ri = ai - b->sig[i];
330 /* Negate the significand A, placing the result in R. */
333 neg_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
338 for (i = 0; i < SIGSZ; ++i)
340 unsigned long ri, ai = a->sig[i];
359 /* Compare significands. Return tri-state vs zero. */
362 cmp_significands (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
366 for (i = SIGSZ - 1; i >= 0; --i)
368 unsigned long ai = a->sig[i];
369 unsigned long bi = b->sig[i];
380 /* Return true if A is nonzero. */
383 cmp_significand_0 (const REAL_VALUE_TYPE *a)
387 for (i = SIGSZ - 1; i >= 0; --i)
394 /* Set bit N of the significand of R. */
397 set_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
399 r->sig[n / HOST_BITS_PER_LONG]
400 |= (unsigned long)1 << (n % HOST_BITS_PER_LONG);
403 /* Clear bit N of the significand of R. */
406 clear_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
408 r->sig[n / HOST_BITS_PER_LONG]
409 &= ~((unsigned long)1 << (n % HOST_BITS_PER_LONG));
412 /* Test bit N of the significand of R. */
415 test_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
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;
424 /* Clear bits 0..N-1 of the significand of R. */
427 clear_significand_below (REAL_VALUE_TYPE *r, unsigned int n)
429 int i, w = n / HOST_BITS_PER_LONG;
431 for (i = 0; i < w; ++i)
434 r->sig[w] &= ~(((unsigned long)1 << (n % HOST_BITS_PER_LONG)) - 1);
437 /* Divide the significands of A and B, placing the result in R. Return
438 true if the division was inexact. */
441 div_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
442 const REAL_VALUE_TYPE *b)
445 int i, bit = SIGNIFICAND_BITS - 1;
446 unsigned long msb, inexact;
449 memset (r->sig, 0, sizeof (r->sig));
455 msb = u.sig[SIGSZ-1] & SIG_MSB;
456 lshift_significand_1 (&u, &u);
458 if (msb || cmp_significands (&u, b) >= 0)
460 sub_significands (&u, &u, b, 0);
461 set_significand_bit (r, bit);
466 for (i = 0, inexact = 0; i < SIGSZ; i++)
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.) */
478 normalize (REAL_VALUE_TYPE *r)
483 /* Find the first word that is nonzero. */
484 for (i = SIGSZ - 1; i >= 0; i--)
486 shift += HOST_BITS_PER_LONG;
490 /* Zero significand flushes to zero. */
498 /* Find the first bit that is nonzero. */
500 if (r->sig[i] & ((unsigned long)1 << (HOST_BITS_PER_LONG - 1 - j)))
506 exp = REAL_EXP (r) - shift;
508 get_inf (r, r->sign);
509 else if (exp < -MAX_EXP)
510 get_zero (r, r->sign);
513 SET_REAL_EXP (r, exp);
514 lshift_significand (r, r, shift);
519 /* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the
520 result may be inexact due to a loss of precision. */
523 do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
524 const REAL_VALUE_TYPE *b, int subtract_p)
528 bool inexact = false;
530 /* Determine if we need to add or subtract. */
532 subtract_p = (sign ^ b->sign) ^ subtract_p;
534 switch (CLASS2 (a->cl, b->cl))
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);
541 case CLASS2 (rvc_zero, rvc_normal):
542 case CLASS2 (rvc_zero, rvc_inf):
543 case CLASS2 (rvc_zero, rvc_nan):
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):
552 r->sign = sign ^ subtract_p;
555 case CLASS2 (rvc_normal, rvc_zero):
556 case CLASS2 (rvc_inf, rvc_zero):
557 case CLASS2 (rvc_nan, rvc_zero):
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):
567 case CLASS2 (rvc_inf, rvc_inf):
569 /* Inf - Inf = NaN. */
570 get_canonical_qnan (r, 0);
572 /* Inf + Inf = Inf. */
576 case CLASS2 (rvc_normal, rvc_normal):
583 /* Swap the arguments such that A has the larger exponent. */
584 dexp = REAL_EXP (a) - REAL_EXP (b);
587 const REAL_VALUE_TYPE *t;
594 /* If the exponents are not identical, we need to shift the
595 significand of B down. */
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)
607 inexact |= sticky_rshift_significand (&t, b, dexp);
613 if (sub_significands (r, a, b, inexact))
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
620 neg_significand (r, r);
625 if (add_significands (r, a, b))
627 /* We got carry out of the addition. This means we need to
628 shift the significand back down one bit and increase the
630 inexact |= sticky_rshift_significand (r, r, 1);
631 r->sig[SIGSZ-1] |= SIG_MSB;
642 SET_REAL_EXP (r, exp);
643 /* Zero out the remaining fields. */
647 /* Re-normalize the result. */
650 /* Special case: if the subtraction results in zero, the result
652 if (r->cl == rvc_zero)
655 r->sig[0] |= inexact;
660 /* Calculate R = A * B. Return true if the result may be inexact. */
663 do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
664 const REAL_VALUE_TYPE *b)
666 REAL_VALUE_TYPE u, t, *rr;
667 unsigned int i, j, k;
668 int sign = a->sign ^ b->sign;
669 bool inexact = false;
671 switch (CLASS2 (a->cl, b->cl))
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. */
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. */
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. */
697 case CLASS2 (rvc_zero, rvc_inf):
698 case CLASS2 (rvc_inf, rvc_zero):
700 get_canonical_qnan (r, sign);
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 */
710 case CLASS2 (rvc_normal, rvc_normal):
717 if (r == a || r == b)
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.
726 Consider the long-hand form of a four half-word multiplication:
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. */
741 for (i = 0; i < SIGSZ * 2; ++i)
743 unsigned long ai = a->sig[i / 2];
745 ai >>= HOST_BITS_PER_LONG / 2;
747 ai &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
752 for (j = 0; j < 2; ++j)
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)));
764 /* Would underflow to zero, which we shouldn't bother adding. */
769 memset (&u, 0, sizeof (u));
771 SET_REAL_EXP (&u, exp);
773 for (k = j; k < SIGSZ * 2; k += 2)
775 unsigned long bi = b->sig[k / 2];
777 bi >>= HOST_BITS_PER_LONG / 2;
779 bi &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
781 u.sig[k / 2] = ai * bi;
785 inexact |= do_add (rr, rr, &u, 0);
796 /* Calculate R = A / B. Return true if the result may be inexact. */
799 do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
800 const REAL_VALUE_TYPE *b)
802 int exp, sign = a->sign ^ b->sign;
803 REAL_VALUE_TYPE t, *rr;
806 switch (CLASS2 (a->cl, b->cl))
808 case CLASS2 (rvc_zero, rvc_zero):
810 case CLASS2 (rvc_inf, rvc_inf):
811 /* Inf / Inf = NaN. */
812 get_canonical_qnan (r, sign);
815 case CLASS2 (rvc_zero, rvc_normal):
816 case CLASS2 (rvc_zero, rvc_inf):
818 case CLASS2 (rvc_normal, rvc_inf):
823 case CLASS2 (rvc_normal, rvc_zero):
825 case CLASS2 (rvc_inf, rvc_zero):
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. */
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. */
847 case CLASS2 (rvc_inf, rvc_normal):
852 case CLASS2 (rvc_normal, rvc_normal):
859 if (r == a || r == b)
864 /* Make sure all fields in the result are initialized. */
869 exp = REAL_EXP (a) - REAL_EXP (b) + 1;
880 SET_REAL_EXP (rr, exp);
882 inexact = div_significands (rr, a, b);
884 /* Re-normalize the result. */
886 rr->sig[0] |= inexact;
894 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
895 one of the two operands is a NaN. */
898 do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
903 switch (CLASS2 (a->cl, b->cl))
905 case CLASS2 (rvc_zero, rvc_zero):
906 /* Sign of zero doesn't matter for compares. */
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);
914 case CLASS2 (rvc_inf, rvc_inf):
915 return -a->sign - -b->sign;
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);
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):
931 case CLASS2 (rvc_normal, rvc_normal):
938 if (a->sign != b->sign)
939 return -a->sign - -b->sign;
941 if (REAL_EXP (a) > REAL_EXP (b))
943 else if (REAL_EXP (a) < REAL_EXP (b))
946 ret = cmp_significands (a, b);
948 return (a->sign ? -ret : ret);
951 /* Return A truncated to an integral value toward zero. */
954 do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
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));
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. */
982 real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
983 const REAL_VALUE_TYPE *op1)
985 enum tree_code code = icode;
990 return do_add (r, op0, op1, 0);
993 return do_add (r, op0, op1, 1);
996 return do_multiply (r, op0, op1);
999 return do_divide (r, op0, op1);
1002 if (op1->cl == rvc_nan)
1004 else if (do_compare (op0, op1, -1) < 0)
1011 if (op1->cl == rvc_nan)
1013 else if (do_compare (op0, op1, 1) < 0)
1029 case FIX_TRUNC_EXPR:
1030 do_fix_trunc (r, op0);
1039 /* Legacy. Similar, but return the result directly. */
1042 real_arithmetic2 (int icode, const REAL_VALUE_TYPE *op0,
1043 const REAL_VALUE_TYPE *op1)
1046 real_arithmetic (&r, icode, op0, op1);
1051 real_compare (int icode, const REAL_VALUE_TYPE *op0,
1052 const REAL_VALUE_TYPE *op1)
1054 enum tree_code code = icode;
1059 return do_compare (op0, op1, 1) < 0;
1061 return do_compare (op0, op1, 1) <= 0;
1063 return do_compare (op0, op1, -1) > 0;
1065 return do_compare (op0, op1, -1) >= 0;
1067 return do_compare (op0, op1, -1) == 0;
1069 return do_compare (op0, op1, -1) != 0;
1070 case UNORDERED_EXPR:
1071 return op0->cl == rvc_nan || op1->cl == rvc_nan;
1073 return op0->cl != rvc_nan && op1->cl != rvc_nan;
1075 return do_compare (op0, op1, -1) < 0;
1077 return do_compare (op0, op1, -1) <= 0;
1079 return do_compare (op0, op1, 1) > 0;
1081 return do_compare (op0, op1, 1) >= 0;
1083 return do_compare (op0, op1, 0) == 0;
1085 return do_compare (op0, op1, 0) != 0;
1092 /* Return floor log2(R). */
1095 real_exponent (const REAL_VALUE_TYPE *r)
1103 return (unsigned int)-1 >> 1;
1105 return REAL_EXP (r);
1111 /* R = OP0 * 2**EXP. */
1114 real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
1125 exp += REAL_EXP (op0);
1127 get_inf (r, r->sign);
1128 else if (exp < -MAX_EXP)
1129 get_zero (r, r->sign);
1131 SET_REAL_EXP (r, exp);
1139 /* Determine whether a floating-point value X is infinite. */
1142 real_isinf (const REAL_VALUE_TYPE *r)
1144 return (r->cl == rvc_inf);
1147 /* Determine whether a floating-point value X is a NaN. */
1150 real_isnan (const REAL_VALUE_TYPE *r)
1152 return (r->cl == rvc_nan);
1155 /* Determine whether a floating-point value X is negative. */
1158 real_isneg (const REAL_VALUE_TYPE *r)
1163 /* Determine whether a floating-point value X is minus zero. */
1166 real_isnegzero (const REAL_VALUE_TYPE *r)
1168 return r->sign && r->cl == rvc_zero;
1171 /* Compare two floating-point objects for bitwise identity. */
1174 real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
1180 if (a->sign != b->sign)
1190 if (REAL_EXP (a) != REAL_EXP (b))
1195 if (a->signalling != b->signalling)
1197 /* The significand is ignored for canonical NaNs. */
1198 if (a->canonical || b->canonical)
1199 return a->canonical == b->canonical;
1206 for (i = 0; i < SIGSZ; ++i)
1207 if (a->sig[i] != b->sig[i])
1213 /* Try to change R into its exact multiplicative inverse in machine
1214 mode MODE. Return true if successful. */
1217 exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
1219 const REAL_VALUE_TYPE *one = real_digit (1);
1223 if (r->cl != rvc_normal)
1226 /* Check for a power of two: all significand bits zero except the MSB. */
1227 for (i = 0; i < SIGSZ-1; ++i)
1230 if (r->sig[SIGSZ-1] != SIG_MSB)
1233 /* Find the inverse and truncate to the required mode. */
1234 do_divide (&u, one, r);
1235 real_convert (&u, mode, &u);
1237 /* The rounding may have overflowed. */
1238 if (u.cl != rvc_normal)
1240 for (i = 0; i < SIGSZ-1; ++i)
1243 if (u.sig[SIGSZ-1] != SIG_MSB)
1250 /* Render R as an integer. */
1253 real_to_integer (const REAL_VALUE_TYPE *r)
1255 unsigned HOST_WIDE_INT i;
1266 i = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1272 if (REAL_EXP (r) <= 0)
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)
1281 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1282 i = r->sig[SIGSZ-1];
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];
1291 i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
1302 /* Likewise, but to an integer pair, HI+LOW. */
1305 real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
1306 const REAL_VALUE_TYPE *r)
1309 HOST_WIDE_INT low, high;
1322 high = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
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)
1343 rshift_significand (&t, r, 2*HOST_BITS_PER_WIDE_INT - exp);
1344 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1346 high = t.sig[SIGSZ-1];
1347 low = t.sig[SIGSZ-2];
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];
1356 low = t.sig[SIGSZ-3];
1357 low = low << (HOST_BITS_PER_LONG - 1) << 1;
1358 low |= t.sig[SIGSZ-4];
1366 low = -low, high = ~high;
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
1383 static unsigned long
1384 rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den)
1386 unsigned long q, msb;
1387 int expn = REAL_EXP (num), expd = REAL_EXP (den);
1396 msb = num->sig[SIGSZ-1] & SIG_MSB;
1398 lshift_significand_1 (num, num);
1400 if (msb || cmp_significands (num, den) >= 0)
1402 sub_significands (num, num, den, 0);
1406 while (--expn >= expd);
1408 SET_REAL_EXP (num, expd);
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
1419 #define M_LOG10_2 0.30102999566398119521
1422 real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
1423 size_t digits, int crop_trailing_zeros)
1425 const REAL_VALUE_TYPE *one, *ten;
1426 REAL_VALUE_TYPE r, pten, u, v;
1427 int dec_exp, cmp_one, digit;
1429 char *p, *first, *last;
1436 strcpy (str, (r.sign ? "-0.0" : "0.0"));
1441 strcpy (str, (r.sign ? "-Inf" : "+Inf"));
1444 /* ??? Print the significand as well, if not canonical? */
1445 strcpy (str, (r.sign ? "-NaN" : "+NaN"));
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;
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++)
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;
1469 one = real_digit (1);
1470 ten = ten_to_ptwo (0);
1478 cmp_one = do_compare (&r, one, 0);
1483 /* Number is greater than one. Convert significand to an integer
1484 and strip trailing decimal zeros. */
1487 SET_REAL_EXP (&u, SIGNIFICAND_BITS - 1);
1489 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1490 m = floor_log2 (max_digits);
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
1500 do_divide (&t, &u, ten_to_ptwo (m));
1501 do_fix_trunc (&v, &t);
1502 if (cmp_significands (&v, &t) == 0)
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));
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)
1520 m = floor_log2 ((int)(REAL_EXP (&r) * M_LOG10_2)) + 1;
1523 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1524 if (do_compare (&u, ptentwo, 0) >= 0)
1526 do_divide (&u, &u, ptentwo);
1527 do_multiply (&pten, &pten, ptentwo);
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. */
1543 /* Number is less than one. Pad significand with leading
1549 /* Stop if we'd shift bits off the bottom. */
1553 do_multiply (&u, &v, ten);
1555 /* Stop if we're now >= 1. */
1556 if (REAL_EXP (&u) > 0)
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;
1570 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1571 const REAL_VALUE_TYPE *ptenmtwo = ten_to_mptwo (m);
1573 if (do_compare (&v, ptenmtwo, 0) <= 0)
1575 do_multiply (&v, &v, ptentwo);
1576 do_multiply (&pten, &pten, ptentwo);
1582 /* Invert the positive power of 10 that we've collected so far. */
1583 do_divide (&pten, one, &pten);
1591 /* At this point, PTEN should contain the nearest power of 10 smaller
1592 than R, such that this division produces the first digit.
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. */
1599 digit = rtd_divmod (&r, &pten);
1601 /* Be prepared for error in that division via underflow ... */
1602 if (digit == 0 && cmp_significand_0 (&r))
1604 /* Multiply by 10 and try again. */
1605 do_multiply (&r, &r, ten);
1606 digit = rtd_divmod (&r, &pten);
1608 gcc_assert (digit != 0);
1611 /* ... or overflow. */
1621 gcc_assert (digit <= 10);
1625 /* Generate subsequent digits. */
1626 while (--digits > 0)
1628 do_multiply (&r, &r, ten);
1629 digit = rtd_divmod (&r, &pten);
1634 /* Generate one more digit with which to do rounding. */
1635 do_multiply (&r, &r, ten);
1636 digit = rtd_divmod (&r, &pten);
1638 /* Round the result. */
1641 /* Round to nearest. If R is nonzero there are additional
1642 nonzero digits to be extracted. */
1643 if (cmp_significand_0 (&r))
1645 /* Round to even. */
1646 else if ((p[-1] - '0') & 1)
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. */
1672 /* Insert the decimal point. */
1673 first[0] = first[1];
1676 /* If requested, drop trailing zeros. Never crop past "1.0". */
1677 if (crop_trailing_zeros)
1678 while (last > first + 3 && last[-1] == '0')
1681 /* Append the exponent. */
1682 sprintf (last, "e%+d", dec_exp);
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. */
1691 real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
1692 size_t digits, int crop_trailing_zeros)
1694 int i, j, exp = REAL_EXP (r);
1707 strcpy (str, (r->sign ? "-Inf" : "+Inf"));
1710 /* ??? Print the significand as well, if not canonical? */
1711 strcpy (str, (r->sign ? "-NaN" : "+NaN"));
1718 digits = SIGNIFICAND_BITS / 4;
1720 /* Bound the number of digits printed by the size of the output buffer. */
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;
1737 for (i = SIGSZ - 1; i >= 0; --i)
1738 for (j = HOST_BITS_PER_LONG - 4; j >= 0; j -= 4)
1740 *p++ = "0123456789abcdef"[(r->sig[i] >> j) & 15];
1746 if (crop_trailing_zeros)
1747 while (p > first + 1 && p[-1] == '0')
1750 sprintf (p, "p%+d", exp);
1753 /* Initialize R from a decimal or hexadecimal string. The string is
1754 assumed to have been syntax checked already. */
1757 real_from_string (REAL_VALUE_TYPE *r, const char *str)
1769 else if (*str == '+')
1772 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
1774 /* Hexadecimal floating point. */
1775 int pos = SIGNIFICAND_BITS - 4, d;
1783 d = hex_value (*str);
1788 r->sig[pos / HOST_BITS_PER_LONG]
1789 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1793 /* Ensure correct rounding by setting last bit if there is
1794 a subsequent nonzero digit. */
1802 if (pos == SIGNIFICAND_BITS - 4)
1809 d = hex_value (*str);
1814 r->sig[pos / HOST_BITS_PER_LONG]
1815 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1821 if (*str == 'p' || *str == 'P')
1823 bool exp_neg = false;
1831 else if (*str == '+')
1835 while (ISDIGIT (*str))
1841 /* Overflowed the exponent. */
1856 SET_REAL_EXP (r, exp);
1862 /* Decimal floating point. */
1863 const REAL_VALUE_TYPE *ten = ten_to_ptwo (0);
1868 while (ISDIGIT (*str))
1871 do_multiply (r, r, ten);
1873 do_add (r, r, real_digit (d), 0);
1878 if (r->cl == rvc_zero)
1883 while (ISDIGIT (*str))
1886 do_multiply (r, r, ten);
1888 do_add (r, r, real_digit (d), 0);
1893 if (*str == 'e' || *str == 'E')
1895 bool exp_neg = false;
1903 else if (*str == '+')
1907 while (ISDIGIT (*str))
1913 /* Overflowed the exponent. */
1927 times_pten (r, exp);
1942 /* Legacy. Similar, but return the result directly. */
1945 real_from_string2 (const char *s, enum machine_mode mode)
1949 real_from_string (&r, s);
1950 if (mode != VOIDmode)
1951 real_convert (&r, mode, &r);
1956 /* Initialize R from the integer pair HIGH+LOW. */
1959 real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
1960 unsigned HOST_WIDE_INT low, HOST_WIDE_INT high,
1963 if (low == 0 && high == 0)
1967 memset (r, 0, sizeof (*r));
1969 r->sign = high < 0 && !unsigned_p;
1970 SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT);
1981 if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT)
1983 r->sig[SIGSZ-1] = high;
1984 r->sig[SIGSZ-2] = low;
1988 gcc_assert (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT);
1989 r->sig[SIGSZ-1] = high >> (HOST_BITS_PER_LONG - 1) >> 1;
1990 r->sig[SIGSZ-2] = high;
1991 r->sig[SIGSZ-3] = low >> (HOST_BITS_PER_LONG - 1) >> 1;
1992 r->sig[SIGSZ-4] = low;
1998 if (mode != VOIDmode)
1999 real_convert (r, mode, r);
2002 /* Returns 10**2**N. */
2004 static const REAL_VALUE_TYPE *
2007 static REAL_VALUE_TYPE tens[EXP_BITS];
2009 gcc_assert (n >= 0);
2010 gcc_assert (n < EXP_BITS);
2012 if (tens[n].cl == rvc_zero)
2014 if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
2016 HOST_WIDE_INT t = 10;
2019 for (i = 0; i < n; ++i)
2022 real_from_integer (&tens[n], VOIDmode, t, 0, 1);
2026 const REAL_VALUE_TYPE *t = ten_to_ptwo (n - 1);
2027 do_multiply (&tens[n], t, t);
2034 /* Returns 10**(-2**N). */
2036 static const REAL_VALUE_TYPE *
2037 ten_to_mptwo (int n)
2039 static REAL_VALUE_TYPE tens[EXP_BITS];
2041 gcc_assert (n >= 0);
2042 gcc_assert (n < EXP_BITS);
2044 if (tens[n].cl == rvc_zero)
2045 do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
2052 static const REAL_VALUE_TYPE *
2055 static REAL_VALUE_TYPE num[10];
2057 gcc_assert (n >= 0);
2058 gcc_assert (n <= 9);
2060 if (n > 0 && num[n].cl == rvc_zero)
2061 real_from_integer (&num[n], VOIDmode, n, 0, 1);
2066 /* Multiply R by 10**EXP. */
2069 times_pten (REAL_VALUE_TYPE *r, int exp)
2071 REAL_VALUE_TYPE pten, *rr;
2072 bool negative = (exp < 0);
2078 pten = *real_digit (1);
2084 for (i = 0; exp > 0; ++i, exp >>= 1)
2086 do_multiply (rr, rr, ten_to_ptwo (i));
2089 do_divide (r, r, &pten);
2092 /* Fills R with +Inf. */
2095 real_inf (REAL_VALUE_TYPE *r)
2100 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2101 we force a QNaN, else we force an SNaN. The string, if not empty,
2102 is parsed as a number and placed in the significand. Return true
2103 if the string was successfully parsed. */
2106 real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
2107 enum machine_mode mode)
2109 const struct real_format *fmt;
2111 fmt = REAL_MODE_FORMAT (mode);
2117 get_canonical_qnan (r, 0);
2119 get_canonical_snan (r, 0);
2125 memset (r, 0, sizeof (*r));
2128 /* Parse akin to strtol into the significand of R. */
2130 while (ISSPACE (*str))
2134 else if (*str == '+')
2144 while ((d = hex_value (*str)) < base)
2151 lshift_significand (r, r, 3);
2154 lshift_significand (r, r, 4);
2157 lshift_significand_1 (&u, r);
2158 lshift_significand (r, r, 3);
2159 add_significands (r, r, &u);
2167 add_significands (r, r, &u);
2172 /* Must have consumed the entire string for success. */
2176 /* Shift the significand into place such that the bits
2177 are in the most significant bits for the format. */
2178 lshift_significand (r, r, SIGNIFICAND_BITS - fmt->pnan);
2180 /* Our MSB is always unset for NaNs. */
2181 r->sig[SIGSZ-1] &= ~SIG_MSB;
2183 /* Force quiet or signalling NaN. */
2184 r->signalling = !quiet;
2190 /* Fills R with the largest finite value representable in mode MODE.
2191 If SIGN is nonzero, R is set to the most negative finite value. */
2194 real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
2196 const struct real_format *fmt;
2199 fmt = REAL_MODE_FORMAT (mode);
2206 SET_REAL_EXP (r, fmt->emax * fmt->log2_b);
2208 np2 = SIGNIFICAND_BITS - fmt->p * fmt->log2_b;
2209 memset (r->sig, -1, SIGSZ * sizeof (unsigned long));
2210 clear_significand_below (r, np2);
2213 /* Fills R with 2**N. */
2216 real_2expN (REAL_VALUE_TYPE *r, int n)
2218 memset (r, 0, sizeof (*r));
2223 else if (n < -MAX_EXP)
2228 SET_REAL_EXP (r, n);
2229 r->sig[SIGSZ-1] = SIG_MSB;
2235 round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
2238 unsigned long sticky;
2242 p2 = fmt->p * fmt->log2_b;
2243 emin2m1 = (fmt->emin - 1) * fmt->log2_b;
2244 emax2 = fmt->emax * fmt->log2_b;
2246 np2 = SIGNIFICAND_BITS - p2;
2250 get_zero (r, r->sign);
2252 if (!fmt->has_signed_zero)
2257 get_inf (r, r->sign);
2262 clear_significand_below (r, np2);
2272 /* If we're not base2, normalize the exponent to a multiple of
2274 if (fmt->log2_b != 1)
2276 int shift = REAL_EXP (r) & (fmt->log2_b - 1);
2279 shift = fmt->log2_b - shift;
2280 r->sig[0] |= sticky_rshift_significand (r, r, shift);
2281 SET_REAL_EXP (r, REAL_EXP (r) + shift);
2285 /* Check the range of the exponent. If we're out of range,
2286 either underflow or overflow. */
2287 if (REAL_EXP (r) > emax2)
2289 else if (REAL_EXP (r) <= emin2m1)
2293 if (!fmt->has_denorm)
2295 /* Don't underflow completely until we've had a chance to round. */
2296 if (REAL_EXP (r) < emin2m1)
2301 diff = emin2m1 - REAL_EXP (r) + 1;
2305 /* De-normalize the significand. */
2306 r->sig[0] |= sticky_rshift_significand (r, r, diff);
2307 SET_REAL_EXP (r, REAL_EXP (r) + diff);
2311 /* There are P2 true significand bits, followed by one guard bit,
2312 followed by one sticky bit, followed by stuff. Fold nonzero
2313 stuff into the sticky bit. */
2316 for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
2317 sticky |= r->sig[i];
2319 r->sig[w] & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
2321 guard = test_significand_bit (r, np2 - 1);
2322 lsb = test_significand_bit (r, np2);
2324 /* Round to even. */
2325 if (guard && (sticky || lsb))
2329 set_significand_bit (&u, np2);
2331 if (add_significands (r, r, &u))
2333 /* Overflow. Means the significand had been all ones, and
2334 is now all zeros. Need to increase the exponent, and
2335 possibly re-normalize it. */
2336 SET_REAL_EXP (r, REAL_EXP (r) + 1);
2337 if (REAL_EXP (r) > emax2)
2339 r->sig[SIGSZ-1] = SIG_MSB;
2341 if (fmt->log2_b != 1)
2343 int shift = REAL_EXP (r) & (fmt->log2_b - 1);
2346 shift = fmt->log2_b - shift;
2347 rshift_significand (r, r, shift);
2348 SET_REAL_EXP (r, REAL_EXP (r) + shift);
2349 if (REAL_EXP (r) > emax2)
2356 /* Catch underflow that we deferred until after rounding. */
2357 if (REAL_EXP (r) <= emin2m1)
2360 /* Clear out trailing garbage. */
2361 clear_significand_below (r, np2);
2364 /* Extend or truncate to a new mode. */
2367 real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
2368 const REAL_VALUE_TYPE *a)
2370 const struct real_format *fmt;
2372 fmt = REAL_MODE_FORMAT (mode);
2376 round_for_format (fmt, r);
2378 /* round_for_format de-normalizes denormals. Undo just that part. */
2379 if (r->cl == rvc_normal)
2383 /* Legacy. Likewise, except return the struct directly. */
2386 real_value_truncate (enum machine_mode mode, REAL_VALUE_TYPE a)
2389 real_convert (&r, mode, &a);
2393 /* Return true if truncating to MODE is exact. */
2396 exact_real_truncate (enum machine_mode mode, const REAL_VALUE_TYPE *a)
2399 real_convert (&t, mode, a);
2400 return real_identical (&t, a);
2403 /* Write R to the given target format. Place the words of the result
2404 in target word order in BUF. There are always 32 bits in each
2405 long, no matter the size of the host long.
2407 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2410 real_to_target_fmt (long *buf, const REAL_VALUE_TYPE *r_orig,
2411 const struct real_format *fmt)
2417 round_for_format (fmt, &r);
2421 (*fmt->encode) (fmt, buf, &r);
2426 /* Similar, but look up the format from MODE. */
2429 real_to_target (long *buf, const REAL_VALUE_TYPE *r, enum machine_mode mode)
2431 const struct real_format *fmt;
2433 fmt = REAL_MODE_FORMAT (mode);
2436 return real_to_target_fmt (buf, r, fmt);
2439 /* Read R from the given target format. Read the words of the result
2440 in target word order in BUF. There are always 32 bits in each
2441 long, no matter the size of the host long. */
2444 real_from_target_fmt (REAL_VALUE_TYPE *r, const long *buf,
2445 const struct real_format *fmt)
2447 (*fmt->decode) (fmt, r, buf);
2450 /* Similar, but look up the format from MODE. */
2453 real_from_target (REAL_VALUE_TYPE *r, const long *buf, enum machine_mode mode)
2455 const struct real_format *fmt;
2457 fmt = REAL_MODE_FORMAT (mode);
2460 (*fmt->decode) (fmt, r, buf);
2463 /* Return the number of bits in the significand for MODE. */
2464 /* ??? Legacy. Should get access to real_format directly. */
2467 significand_size (enum machine_mode mode)
2469 const struct real_format *fmt;
2471 fmt = REAL_MODE_FORMAT (mode);
2475 return fmt->p * fmt->log2_b;
2478 /* Return a hash value for the given real value. */
2479 /* ??? The "unsigned int" return value is intended to be hashval_t,
2480 but I didn't want to pull hashtab.h into real.h. */
2483 real_hash (const REAL_VALUE_TYPE *r)
2488 h = r->cl | (r->sign << 2);
2496 h |= REAL_EXP (r) << 3;
2501 h ^= (unsigned int)-1;
2510 if (sizeof(unsigned long) > sizeof(unsigned int))
2511 for (i = 0; i < SIGSZ; ++i)
2513 unsigned long s = r->sig[i];
2514 h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2));
2517 for (i = 0; i < SIGSZ; ++i)
2523 /* IEEE single-precision format. */
2525 static void encode_ieee_single (const struct real_format *fmt,
2526 long *, const REAL_VALUE_TYPE *);
2527 static void decode_ieee_single (const struct real_format *,
2528 REAL_VALUE_TYPE *, const long *);
2531 encode_ieee_single (const struct real_format *fmt, long *buf,
2532 const REAL_VALUE_TYPE *r)
2534 unsigned long image, sig, exp;
2535 unsigned long sign = r->sign;
2536 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2539 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
2550 image |= 0x7fffffff;
2558 if (r->signalling == fmt->qnan_msb_set)
2562 /* We overload qnan_msb_set here: it's only clear for
2563 mips_ieee_single, which wants all mantissa bits but the
2564 quiet/signalling one set in canonical NaNs (at least
2566 if (r->canonical && !fmt->qnan_msb_set)
2567 sig |= (1 << 22) - 1;
2575 image |= 0x7fffffff;
2579 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2580 whereas the intermediate representation is 0.F x 2**exp.
2581 Which means we're off by one. */
2585 exp = REAL_EXP (r) + 127 - 1;
2598 decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
2601 unsigned long image = buf[0] & 0xffffffff;
2602 bool sign = (image >> 31) & 1;
2603 int exp = (image >> 23) & 0xff;
2605 memset (r, 0, sizeof (*r));
2606 image <<= HOST_BITS_PER_LONG - 24;
2611 if (image && fmt->has_denorm)
2615 SET_REAL_EXP (r, -126);
2616 r->sig[SIGSZ-1] = image << 1;
2619 else if (fmt->has_signed_zero)
2622 else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
2628 r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
2629 ^ fmt->qnan_msb_set);
2630 r->sig[SIGSZ-1] = image;
2642 SET_REAL_EXP (r, exp - 127 + 1);
2643 r->sig[SIGSZ-1] = image | SIG_MSB;
2647 const struct real_format ieee_single_format =
2666 const struct real_format mips_single_format =
2686 /* IEEE double-precision format. */
2688 static void encode_ieee_double (const struct real_format *fmt,
2689 long *, const REAL_VALUE_TYPE *);
2690 static void decode_ieee_double (const struct real_format *,
2691 REAL_VALUE_TYPE *, const long *);
2694 encode_ieee_double (const struct real_format *fmt, long *buf,
2695 const REAL_VALUE_TYPE *r)
2697 unsigned long image_lo, image_hi, sig_lo, sig_hi, exp;
2698 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2700 image_hi = r->sign << 31;
2703 if (HOST_BITS_PER_LONG == 64)
2705 sig_hi = r->sig[SIGSZ-1];
2706 sig_lo = (sig_hi >> (64 - 53)) & 0xffffffff;
2707 sig_hi = (sig_hi >> (64 - 53 + 1) >> 31) & 0xfffff;
2711 sig_hi = r->sig[SIGSZ-1];
2712 sig_lo = r->sig[SIGSZ-2];
2713 sig_lo = (sig_hi << 21) | (sig_lo >> 11);
2714 sig_hi = (sig_hi >> 11) & 0xfffff;
2724 image_hi |= 2047 << 20;
2727 image_hi |= 0x7fffffff;
2728 image_lo = 0xffffffff;
2736 sig_hi = sig_lo = 0;
2737 if (r->signalling == fmt->qnan_msb_set)
2738 sig_hi &= ~(1 << 19);
2741 /* We overload qnan_msb_set here: it's only clear for
2742 mips_ieee_single, which wants all mantissa bits but the
2743 quiet/signalling one set in canonical NaNs (at least
2745 if (r->canonical && !fmt->qnan_msb_set)
2747 sig_hi |= (1 << 19) - 1;
2748 sig_lo = 0xffffffff;
2750 else if (sig_hi == 0 && sig_lo == 0)
2753 image_hi |= 2047 << 20;
2759 image_hi |= 0x7fffffff;
2760 image_lo = 0xffffffff;
2765 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2766 whereas the intermediate representation is 0.F x 2**exp.
2767 Which means we're off by one. */
2771 exp = REAL_EXP (r) + 1023 - 1;
2772 image_hi |= exp << 20;
2781 if (FLOAT_WORDS_BIG_ENDIAN)
2782 buf[0] = image_hi, buf[1] = image_lo;
2784 buf[0] = image_lo, buf[1] = image_hi;
2788 decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
2791 unsigned long image_hi, image_lo;
2795 if (FLOAT_WORDS_BIG_ENDIAN)
2796 image_hi = buf[0], image_lo = buf[1];
2798 image_lo = buf[0], image_hi = buf[1];
2799 image_lo &= 0xffffffff;
2800 image_hi &= 0xffffffff;
2802 sign = (image_hi >> 31) & 1;
2803 exp = (image_hi >> 20) & 0x7ff;
2805 memset (r, 0, sizeof (*r));
2807 image_hi <<= 32 - 21;
2808 image_hi |= image_lo >> 21;
2809 image_hi &= 0x7fffffff;
2810 image_lo <<= 32 - 21;
2814 if ((image_hi || image_lo) && fmt->has_denorm)
2818 SET_REAL_EXP (r, -1022);
2819 if (HOST_BITS_PER_LONG == 32)
2821 image_hi = (image_hi << 1) | (image_lo >> 31);
2823 r->sig[SIGSZ-1] = image_hi;
2824 r->sig[SIGSZ-2] = image_lo;
2828 image_hi = (image_hi << 31 << 2) | (image_lo << 1);
2829 r->sig[SIGSZ-1] = image_hi;
2833 else if (fmt->has_signed_zero)
2836 else if (exp == 2047 && (fmt->has_nans || fmt->has_inf))
2838 if (image_hi || image_lo)
2842 r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set;
2843 if (HOST_BITS_PER_LONG == 32)
2845 r->sig[SIGSZ-1] = image_hi;
2846 r->sig[SIGSZ-2] = image_lo;
2849 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo;
2861 SET_REAL_EXP (r, exp - 1023 + 1);
2862 if (HOST_BITS_PER_LONG == 32)
2864 r->sig[SIGSZ-1] = image_hi | SIG_MSB;
2865 r->sig[SIGSZ-2] = image_lo;
2868 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo | SIG_MSB;
2872 const struct real_format ieee_double_format =
2891 const struct real_format mips_double_format =
2911 /* IEEE extended real format. This comes in three flavors: Intel's as
2912 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
2913 12- and 16-byte images may be big- or little endian; Motorola's is
2914 always big endian. */
2916 /* Helper subroutine which converts from the internal format to the
2917 12-byte little-endian Intel format. Functions below adjust this
2918 for the other possible formats. */
2920 encode_ieee_extended (const struct real_format *fmt, long *buf,
2921 const REAL_VALUE_TYPE *r)
2923 unsigned long image_hi, sig_hi, sig_lo;
2924 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2926 image_hi = r->sign << 15;
2927 sig_hi = sig_lo = 0;
2939 /* Intel requires the explicit integer bit to be set, otherwise
2940 it considers the value a "pseudo-infinity". Motorola docs
2941 say it doesn't care. */
2942 sig_hi = 0x80000000;
2947 sig_lo = sig_hi = 0xffffffff;
2955 if (HOST_BITS_PER_LONG == 32)
2957 sig_hi = r->sig[SIGSZ-1];
2958 sig_lo = r->sig[SIGSZ-2];
2962 sig_lo = r->sig[SIGSZ-1];
2963 sig_hi = sig_lo >> 31 >> 1;
2964 sig_lo &= 0xffffffff;
2966 if (r->signalling == fmt->qnan_msb_set)
2967 sig_hi &= ~(1 << 30);
2970 if ((sig_hi & 0x7fffffff) == 0 && sig_lo == 0)
2973 /* Intel requires the explicit integer bit to be set, otherwise
2974 it considers the value a "pseudo-nan". Motorola docs say it
2976 sig_hi |= 0x80000000;
2981 sig_lo = sig_hi = 0xffffffff;
2987 int exp = REAL_EXP (r);
2989 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2990 whereas the intermediate representation is 0.F x 2**exp.
2991 Which means we're off by one.
2993 Except for Motorola, which consider exp=0 and explicit
2994 integer bit set to continue to be normalized. In theory
2995 this discrepancy has been taken care of by the difference
2996 in fmt->emin in round_for_format. */
3003 gcc_assert (exp >= 0);
3007 if (HOST_BITS_PER_LONG == 32)
3009 sig_hi = r->sig[SIGSZ-1];
3010 sig_lo = r->sig[SIGSZ-2];
3014 sig_lo = r->sig[SIGSZ-1];
3015 sig_hi = sig_lo >> 31 >> 1;
3016 sig_lo &= 0xffffffff;
3025 buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
3028 /* Convert from the internal format to the 12-byte Motorola format
3029 for an IEEE extended real. */
3031 encode_ieee_extended_motorola (const struct real_format *fmt, long *buf,
3032 const REAL_VALUE_TYPE *r)
3035 encode_ieee_extended (fmt, intermed, r);
3037 /* Motorola chips are assumed always to be big-endian. Also, the
3038 padding in a Motorola extended real goes between the exponent and
3039 the mantissa. At this point the mantissa is entirely within
3040 elements 0 and 1 of intermed, and the exponent entirely within
3041 element 2, so all we have to do is swap the order around, and
3042 shift element 2 left 16 bits. */
3043 buf[0] = intermed[2] << 16;
3044 buf[1] = intermed[1];
3045 buf[2] = intermed[0];
3048 /* Convert from the internal format to the 12-byte Intel format for
3049 an IEEE extended real. */
3051 encode_ieee_extended_intel_96 (const struct real_format *fmt, long *buf,
3052 const REAL_VALUE_TYPE *r)
3054 if (FLOAT_WORDS_BIG_ENDIAN)
3056 /* All the padding in an Intel-format extended real goes at the high
3057 end, which in this case is after the mantissa, not the exponent.
3058 Therefore we must shift everything down 16 bits. */
3060 encode_ieee_extended (fmt, intermed, r);
3061 buf[0] = ((intermed[2] << 16) | ((unsigned long)(intermed[1] & 0xFFFF0000) >> 16));
3062 buf[1] = ((intermed[1] << 16) | ((unsigned long)(intermed[0] & 0xFFFF0000) >> 16));
3063 buf[2] = (intermed[0] << 16);
3066 /* encode_ieee_extended produces what we want directly. */
3067 encode_ieee_extended (fmt, buf, r);
3070 /* Convert from the internal format to the 16-byte Intel format for
3071 an IEEE extended real. */
3073 encode_ieee_extended_intel_128 (const struct real_format *fmt, long *buf,
3074 const REAL_VALUE_TYPE *r)
3076 /* All the padding in an Intel-format extended real goes at the high end. */
3077 encode_ieee_extended_intel_96 (fmt, buf, r);
3081 /* As above, we have a helper function which converts from 12-byte
3082 little-endian Intel format to internal format. Functions below
3083 adjust for the other possible formats. */
3085 decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3088 unsigned long image_hi, sig_hi, sig_lo;
3092 sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
3093 sig_lo &= 0xffffffff;
3094 sig_hi &= 0xffffffff;
3095 image_hi &= 0xffffffff;
3097 sign = (image_hi >> 15) & 1;
3098 exp = image_hi & 0x7fff;
3100 memset (r, 0, sizeof (*r));
3104 if ((sig_hi || sig_lo) && fmt->has_denorm)
3109 /* When the IEEE format contains a hidden bit, we know that
3110 it's zero at this point, and so shift up the significand
3111 and decrease the exponent to match. In this case, Motorola
3112 defines the explicit integer bit to be valid, so we don't
3113 know whether the msb is set or not. */
3114 SET_REAL_EXP (r, fmt->emin);
3115 if (HOST_BITS_PER_LONG == 32)
3117 r->sig[SIGSZ-1] = sig_hi;
3118 r->sig[SIGSZ-2] = sig_lo;
3121 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3125 else if (fmt->has_signed_zero)
3128 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3130 /* See above re "pseudo-infinities" and "pseudo-nans".
3131 Short summary is that the MSB will likely always be
3132 set, and that we don't care about it. */
3133 sig_hi &= 0x7fffffff;
3135 if (sig_hi || sig_lo)
3139 r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set;
3140 if (HOST_BITS_PER_LONG == 32)
3142 r->sig[SIGSZ-1] = sig_hi;
3143 r->sig[SIGSZ-2] = sig_lo;
3146 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3158 SET_REAL_EXP (r, exp - 16383 + 1);
3159 if (HOST_BITS_PER_LONG == 32)
3161 r->sig[SIGSZ-1] = sig_hi;
3162 r->sig[SIGSZ-2] = sig_lo;
3165 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3169 /* Convert from the internal format to the 12-byte Motorola format
3170 for an IEEE extended real. */
3172 decode_ieee_extended_motorola (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3177 /* Motorola chips are assumed always to be big-endian. Also, the
3178 padding in a Motorola extended real goes between the exponent and
3179 the mantissa; remove it. */
3180 intermed[0] = buf[2];
3181 intermed[1] = buf[1];
3182 intermed[2] = (unsigned long)buf[0] >> 16;
3184 decode_ieee_extended (fmt, r, intermed);
3187 /* Convert from the internal format to the 12-byte Intel format for
3188 an IEEE extended real. */
3190 decode_ieee_extended_intel_96 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3193 if (FLOAT_WORDS_BIG_ENDIAN)
3195 /* All the padding in an Intel-format extended real goes at the high
3196 end, which in this case is after the mantissa, not the exponent.
3197 Therefore we must shift everything up 16 bits. */
3200 intermed[0] = (((unsigned long)buf[2] >> 16) | (buf[1] << 16));
3201 intermed[1] = (((unsigned long)buf[1] >> 16) | (buf[0] << 16));
3202 intermed[2] = ((unsigned long)buf[0] >> 16);
3204 decode_ieee_extended (fmt, r, intermed);
3207 /* decode_ieee_extended produces what we want directly. */
3208 decode_ieee_extended (fmt, r, buf);
3211 /* Convert from the internal format to the 16-byte Intel format for
3212 an IEEE extended real. */
3214 decode_ieee_extended_intel_128 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3217 /* All the padding in an Intel-format extended real goes at the high end. */
3218 decode_ieee_extended_intel_96 (fmt, r, buf);
3221 const struct real_format ieee_extended_motorola_format =
3223 encode_ieee_extended_motorola,
3224 decode_ieee_extended_motorola,
3240 const struct real_format ieee_extended_intel_96_format =
3242 encode_ieee_extended_intel_96,
3243 decode_ieee_extended_intel_96,
3259 const struct real_format ieee_extended_intel_128_format =
3261 encode_ieee_extended_intel_128,
3262 decode_ieee_extended_intel_128,
3278 /* The following caters to i386 systems that set the rounding precision
3279 to 53 bits instead of 64, e.g. FreeBSD. */
3280 const struct real_format ieee_extended_intel_96_round_53_format =
3282 encode_ieee_extended_intel_96,
3283 decode_ieee_extended_intel_96,
3299 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3300 numbers whose sum is equal to the extended precision value. The number
3301 with greater magnitude is first. This format has the same magnitude
3302 range as an IEEE double precision value, but effectively 106 bits of
3303 significand precision. Infinity and NaN are represented by their IEEE
3304 double precision value stored in the first number, the second number is
3305 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3307 static void encode_ibm_extended (const struct real_format *fmt,
3308 long *, const REAL_VALUE_TYPE *);
3309 static void decode_ibm_extended (const struct real_format *,
3310 REAL_VALUE_TYPE *, const long *);
3313 encode_ibm_extended (const struct real_format *fmt, long *buf,
3314 const REAL_VALUE_TYPE *r)
3316 REAL_VALUE_TYPE u, normr, v;
3317 const struct real_format *base_fmt;
3319 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3321 /* Renormlize R before doing any arithmetic on it. */
3323 if (normr.cl == rvc_normal)
3326 /* u = IEEE double precision portion of significand. */
3328 round_for_format (base_fmt, &u);
3329 encode_ieee_double (base_fmt, &buf[0], &u);
3331 if (u.cl == rvc_normal)
3333 do_add (&v, &normr, &u, 1);
3334 /* Call round_for_format since we might need to denormalize. */
3335 round_for_format (base_fmt, &v);
3336 encode_ieee_double (base_fmt, &buf[2], &v);
3340 /* Inf, NaN, 0 are all representable as doubles, so the
3341 least-significant part can be 0.0. */
3348 decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_TYPE *r,
3351 REAL_VALUE_TYPE u, v;
3352 const struct real_format *base_fmt;
3354 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3355 decode_ieee_double (base_fmt, &u, &buf[0]);
3357 if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan)
3359 decode_ieee_double (base_fmt, &v, &buf[2]);
3360 do_add (r, &u, &v, 0);
3366 const struct real_format ibm_extended_format =
3368 encode_ibm_extended,
3369 decode_ibm_extended,
3385 const struct real_format mips_extended_format =
3387 encode_ibm_extended,
3388 decode_ibm_extended,
3405 /* IEEE quad precision format. */
3407 static void encode_ieee_quad (const struct real_format *fmt,
3408 long *, const REAL_VALUE_TYPE *);
3409 static void decode_ieee_quad (const struct real_format *,
3410 REAL_VALUE_TYPE *, const long *);
3413 encode_ieee_quad (const struct real_format *fmt, long *buf,
3414 const REAL_VALUE_TYPE *r)
3416 unsigned long image3, image2, image1, image0, exp;
3417 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
3420 image3 = r->sign << 31;
3425 rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
3434 image3 |= 32767 << 16;
3437 image3 |= 0x7fffffff;
3438 image2 = 0xffffffff;
3439 image1 = 0xffffffff;
3440 image0 = 0xffffffff;
3447 image3 |= 32767 << 16;
3451 /* Don't use bits from the significand. The
3452 initialization above is right. */
3454 else if (HOST_BITS_PER_LONG == 32)
3459 image3 |= u.sig[3] & 0xffff;
3464 image1 = image0 >> 31 >> 1;
3466 image3 |= (image2 >> 31 >> 1) & 0xffff;
3467 image0 &= 0xffffffff;
3468 image2 &= 0xffffffff;
3470 if (r->signalling == fmt->qnan_msb_set)
3474 /* We overload qnan_msb_set here: it's only clear for
3475 mips_ieee_single, which wants all mantissa bits but the
3476 quiet/signalling one set in canonical NaNs (at least
3478 if (r->canonical && !fmt->qnan_msb_set)
3481 image2 = image1 = image0 = 0xffffffff;
3483 else if (((image3 & 0xffff) | image2 | image1 | image0) == 0)
3488 image3 |= 0x7fffffff;
3489 image2 = 0xffffffff;
3490 image1 = 0xffffffff;
3491 image0 = 0xffffffff;
3496 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3497 whereas the intermediate representation is 0.F x 2**exp.
3498 Which means we're off by one. */
3502 exp = REAL_EXP (r) + 16383 - 1;
3503 image3 |= exp << 16;
3505 if (HOST_BITS_PER_LONG == 32)
3510 image3 |= u.sig[3] & 0xffff;
3515 image1 = image0 >> 31 >> 1;
3517 image3 |= (image2 >> 31 >> 1) & 0xffff;
3518 image0 &= 0xffffffff;
3519 image2 &= 0xffffffff;
3527 if (FLOAT_WORDS_BIG_ENDIAN)
3544 decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3547 unsigned long image3, image2, image1, image0;
3551 if (FLOAT_WORDS_BIG_ENDIAN)
3565 image0 &= 0xffffffff;
3566 image1 &= 0xffffffff;
3567 image2 &= 0xffffffff;
3569 sign = (image3 >> 31) & 1;
3570 exp = (image3 >> 16) & 0x7fff;
3573 memset (r, 0, sizeof (*r));
3577 if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
3582 SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
3583 if (HOST_BITS_PER_LONG == 32)
3592 r->sig[0] = (image1 << 31 << 1) | image0;
3593 r->sig[1] = (image3 << 31 << 1) | image2;
3598 else if (fmt->has_signed_zero)
3601 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3603 if (image3 | image2 | image1 | image0)
3607 r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set;
3609 if (HOST_BITS_PER_LONG == 32)
3618 r->sig[0] = (image1 << 31 << 1) | image0;
3619 r->sig[1] = (image3 << 31 << 1) | image2;
3621 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3633 SET_REAL_EXP (r, exp - 16383 + 1);
3635 if (HOST_BITS_PER_LONG == 32)
3644 r->sig[0] = (image1 << 31 << 1) | image0;
3645 r->sig[1] = (image3 << 31 << 1) | image2;
3647 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3648 r->sig[SIGSZ-1] |= SIG_MSB;
3652 const struct real_format ieee_quad_format =
3671 const struct real_format mips_quad_format =
3690 /* Descriptions of VAX floating point formats can be found beginning at
3692 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
3694 The thing to remember is that they're almost IEEE, except for word
3695 order, exponent bias, and the lack of infinities, nans, and denormals.
3697 We don't implement the H_floating format here, simply because neither
3698 the VAX or Alpha ports use it. */
3700 static void encode_vax_f (const struct real_format *fmt,
3701 long *, const REAL_VALUE_TYPE *);
3702 static void decode_vax_f (const struct real_format *,
3703 REAL_VALUE_TYPE *, const long *);
3704 static void encode_vax_d (const struct real_format *fmt,
3705 long *, const REAL_VALUE_TYPE *);
3706 static void decode_vax_d (const struct real_format *,
3707 REAL_VALUE_TYPE *, const long *);
3708 static void encode_vax_g (const struct real_format *fmt,
3709 long *, const REAL_VALUE_TYPE *);
3710 static void decode_vax_g (const struct real_format *,
3711 REAL_VALUE_TYPE *, const long *);
3714 encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
3715 const REAL_VALUE_TYPE *r)
3717 unsigned long sign, exp, sig, image;
3719 sign = r->sign << 15;
3729 image = 0xffff7fff | sign;
3733 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
3734 exp = REAL_EXP (r) + 128;
3736 image = (sig << 16) & 0xffff0000;
3750 decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED,
3751 REAL_VALUE_TYPE *r, const long *buf)
3753 unsigned long image = buf[0] & 0xffffffff;
3754 int exp = (image >> 7) & 0xff;
3756 memset (r, 0, sizeof (*r));
3761 r->sign = (image >> 15) & 1;
3762 SET_REAL_EXP (r, exp - 128);
3764 image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff);
3765 r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
3770 encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
3771 const REAL_VALUE_TYPE *r)
3773 unsigned long image0, image1, sign = r->sign << 15;
3778 image0 = image1 = 0;
3783 image0 = 0xffff7fff | sign;
3784 image1 = 0xffffffff;
3788 /* Extract the significand into straight hi:lo. */
3789 if (HOST_BITS_PER_LONG == 64)
3791 image0 = r->sig[SIGSZ-1];
3792 image1 = (image0 >> (64 - 56)) & 0xffffffff;
3793 image0 = (image0 >> (64 - 56 + 1) >> 31) & 0x7fffff;
3797 image0 = r->sig[SIGSZ-1];
3798 image1 = r->sig[SIGSZ-2];
3799 image1 = (image0 << 24) | (image1 >> 8);
3800 image0 = (image0 >> 8) & 0xffffff;
3803 /* Rearrange the half-words of the significand to match the
3805 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff007f;
3806 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
3808 /* Add the sign and exponent. */
3810 image0 |= (REAL_EXP (r) + 128) << 7;
3817 if (FLOAT_WORDS_BIG_ENDIAN)
3818 buf[0] = image1, buf[1] = image0;
3820 buf[0] = image0, buf[1] = image1;
3824 decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED,
3825 REAL_VALUE_TYPE *r, const long *buf)
3827 unsigned long image0, image1;
3830 if (FLOAT_WORDS_BIG_ENDIAN)
3831 image1 = buf[0], image0 = buf[1];
3833 image0 = buf[0], image1 = buf[1];
3834 image0 &= 0xffffffff;
3835 image1 &= 0xffffffff;
3837 exp = (image0 >> 7) & 0xff;
3839 memset (r, 0, sizeof (*r));
3844 r->sign = (image0 >> 15) & 1;
3845 SET_REAL_EXP (r, exp - 128);
3847 /* Rearrange the half-words of the external format into
3848 proper ascending order. */
3849 image0 = ((image0 & 0x7f) << 16) | ((image0 >> 16) & 0xffff);
3850 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
3852 if (HOST_BITS_PER_LONG == 64)
3854 image0 = (image0 << 31 << 1) | image1;
3857 r->sig[SIGSZ-1] = image0;
3861 r->sig[SIGSZ-1] = image0;
3862 r->sig[SIGSZ-2] = image1;
3863 lshift_significand (r, r, 2*HOST_BITS_PER_LONG - 56);
3864 r->sig[SIGSZ-1] |= SIG_MSB;
3870 encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
3871 const REAL_VALUE_TYPE *r)
3873 unsigned long image0, image1, sign = r->sign << 15;
3878 image0 = image1 = 0;
3883 image0 = 0xffff7fff | sign;
3884 image1 = 0xffffffff;
3888 /* Extract the significand into straight hi:lo. */
3889 if (HOST_BITS_PER_LONG == 64)
3891 image0 = r->sig[SIGSZ-1];
3892 image1 = (image0 >> (64 - 53)) & 0xffffffff;
3893 image0 = (image0 >> (64 - 53 + 1) >> 31) & 0xfffff;
3897 image0 = r->sig[SIGSZ-1];
3898 image1 = r->sig[SIGSZ-2];
3899 image1 = (image0 << 21) | (image1 >> 11);
3900 image0 = (image0 >> 11) & 0xfffff;
3903 /* Rearrange the half-words of the significand to match the
3905 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff000f;
3906 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
3908 /* Add the sign and exponent. */
3910 image0 |= (REAL_EXP (r) + 1024) << 4;
3917 if (FLOAT_WORDS_BIG_ENDIAN)
3918 buf[0] = image1, buf[1] = image0;
3920 buf[0] = image0, buf[1] = image1;
3924 decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED,
3925 REAL_VALUE_TYPE *r, const long *buf)
3927 unsigned long image0, image1;
3930 if (FLOAT_WORDS_BIG_ENDIAN)
3931 image1 = buf[0], image0 = buf[1];
3933 image0 = buf[0], image1 = buf[1];
3934 image0 &= 0xffffffff;
3935 image1 &= 0xffffffff;
3937 exp = (image0 >> 4) & 0x7ff;
3939 memset (r, 0, sizeof (*r));
3944 r->sign = (image0 >> 15) & 1;
3945 SET_REAL_EXP (r, exp - 1024);
3947 /* Rearrange the half-words of the external format into
3948 proper ascending order. */
3949 image0 = ((image0 & 0xf) << 16) | ((image0 >> 16) & 0xffff);
3950 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
3952 if (HOST_BITS_PER_LONG == 64)
3954 image0 = (image0 << 31 << 1) | image1;
3957 r->sig[SIGSZ-1] = image0;
3961 r->sig[SIGSZ-1] = image0;
3962 r->sig[SIGSZ-2] = image1;
3963 lshift_significand (r, r, 64 - 53);
3964 r->sig[SIGSZ-1] |= SIG_MSB;
3969 const struct real_format vax_f_format =
3988 const struct real_format vax_d_format =
4007 const struct real_format vax_g_format =
4026 /* A good reference for these can be found in chapter 9 of
4027 "ESA/390 Principles of Operation", IBM document number SA22-7201-01.
4028 An on-line version can be found here:
4030 http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/DZ9AR001/9.1?DT=19930923083613
4033 static void encode_i370_single (const struct real_format *fmt,
4034 long *, const REAL_VALUE_TYPE *);
4035 static void decode_i370_single (const struct real_format *,
4036 REAL_VALUE_TYPE *, const long *);
4037 static void encode_i370_double (const struct real_format *fmt,
4038 long *, const REAL_VALUE_TYPE *);
4039 static void decode_i370_double (const struct real_format *,
4040 REAL_VALUE_TYPE *, const long *);
4043 encode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4044 long *buf, const REAL_VALUE_TYPE *r)
4046 unsigned long sign, exp, sig, image;
4048 sign = r->sign << 31;
4058 image = 0x7fffffff | sign;
4062 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0xffffff;
4063 exp = ((REAL_EXP (r) / 4) + 64) << 24;
4064 image = sign | exp | sig;
4075 decode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4076 REAL_VALUE_TYPE *r, const long *buf)
4078 unsigned long sign, sig, image = buf[0];
4081 sign = (image >> 31) & 1;
4082 exp = (image >> 24) & 0x7f;
4083 sig = image & 0xffffff;
4085 memset (r, 0, sizeof (*r));
4091 SET_REAL_EXP (r, (exp - 64) * 4);
4092 r->sig[SIGSZ-1] = sig << (HOST_BITS_PER_LONG - 24);
4098 encode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4099 long *buf, const REAL_VALUE_TYPE *r)
4101 unsigned long sign, exp, image_hi, image_lo;
4103 sign = r->sign << 31;
4108 image_hi = image_lo = 0;
4113 image_hi = 0x7fffffff | sign;
4114 image_lo = 0xffffffff;
4118 if (HOST_BITS_PER_LONG == 64)
4120 image_hi = r->sig[SIGSZ-1];
4121 image_lo = (image_hi >> (64 - 56)) & 0xffffffff;
4122 image_hi = (image_hi >> (64 - 56 + 1) >> 31) & 0xffffff;
4126 image_hi = r->sig[SIGSZ-1];
4127 image_lo = r->sig[SIGSZ-2];
4128 image_lo = (image_lo >> 8) | (image_hi << 24);
4132 exp = ((REAL_EXP (r) / 4) + 64) << 24;
4133 image_hi |= sign | exp;
4140 if (FLOAT_WORDS_BIG_ENDIAN)
4141 buf[0] = image_hi, buf[1] = image_lo;
4143 buf[0] = image_lo, buf[1] = image_hi;
4147 decode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4148 REAL_VALUE_TYPE *r, const long *buf)
4150 unsigned long sign, image_hi, image_lo;
4153 if (FLOAT_WORDS_BIG_ENDIAN)
4154 image_hi = buf[0], image_lo = buf[1];
4156 image_lo = buf[0], image_hi = buf[1];
4158 sign = (image_hi >> 31) & 1;
4159 exp = (image_hi >> 24) & 0x7f;
4160 image_hi &= 0xffffff;
4161 image_lo &= 0xffffffff;
4163 memset (r, 0, sizeof (*r));
4165 if (exp || image_hi || image_lo)
4169 SET_REAL_EXP (r, (exp - 64) * 4 + (SIGNIFICAND_BITS - 56));
4171 if (HOST_BITS_PER_LONG == 32)
4173 r->sig[0] = image_lo;
4174 r->sig[1] = image_hi;
4177 r->sig[0] = image_lo | (image_hi << 31 << 1);
4183 const struct real_format i370_single_format =
4197 false, /* ??? The encoding does allow for "unnormals". */
4198 false, /* ??? The encoding does allow for "unnormals". */
4202 const struct real_format i370_double_format =
4216 false, /* ??? The encoding does allow for "unnormals". */
4217 false, /* ??? The encoding does allow for "unnormals". */
4221 /* The "twos-complement" c4x format is officially defined as
4225 This is rather misleading. One must remember that F is signed.
4226 A better description would be
4228 x = -1**s * ((s + 1 + .f) * 2**e
4230 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
4231 that's -1 * (1+1+(-.5)) == -1.5. I think.
4233 The constructions here are taken from Tables 5-1 and 5-2 of the
4234 TMS320C4x User's Guide wherein step-by-step instructions for
4235 conversion from IEEE are presented. That's close enough to our
4236 internal representation so as to make things easy.
4238 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
4240 static void encode_c4x_single (const struct real_format *fmt,
4241 long *, const REAL_VALUE_TYPE *);
4242 static void decode_c4x_single (const struct real_format *,
4243 REAL_VALUE_TYPE *, const long *);
4244 static void encode_c4x_extended (const struct real_format *fmt,
4245 long *, const REAL_VALUE_TYPE *);
4246 static void decode_c4x_extended (const struct real_format *,
4247 REAL_VALUE_TYPE *, const long *);
4250 encode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4251 long *buf, const REAL_VALUE_TYPE *r)
4253 unsigned long image, exp, sig;
4265 sig = 0x800000 - r->sign;
4269 exp = REAL_EXP (r) - 1;
4270 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
4285 image = ((exp & 0xff) << 24) | (sig & 0xffffff);
4290 decode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4291 REAL_VALUE_TYPE *r, const long *buf)
4293 unsigned long image = buf[0];
4297 exp = (((image >> 24) & 0xff) ^ 0x80) - 0x80;
4298 sf = ((image & 0xffffff) ^ 0x800000) - 0x800000;
4300 memset (r, 0, sizeof (*r));
4306 sig = sf & 0x7fffff;
4315 sig = (sig << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
4317 SET_REAL_EXP (r, exp + 1);
4318 r->sig[SIGSZ-1] = sig;
4323 encode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
4324 long *buf, const REAL_VALUE_TYPE *r)
4326 unsigned long exp, sig;
4338 sig = 0x80000000 - r->sign;
4342 exp = REAL_EXP (r) - 1;
4344 sig = r->sig[SIGSZ-1];
4345 if (HOST_BITS_PER_LONG == 64)
4346 sig = sig >> 1 >> 31;
4363 exp = (exp & 0xff) << 24;
4366 if (FLOAT_WORDS_BIG_ENDIAN)
4367 buf[0] = exp, buf[1] = sig;
4369 buf[0] = sig, buf[0] = exp;
4373 decode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
4374 REAL_VALUE_TYPE *r, const long *buf)
4379 if (FLOAT_WORDS_BIG_ENDIAN)
4380 exp = buf[0], sf = buf[1];
4382 sf = buf[0], exp = buf[1];
4384 exp = (((exp >> 24) & 0xff) & 0x80) - 0x80;
4385 sf = ((sf & 0xffffffff) ^ 0x80000000) - 0x80000000;
4387 memset (r, 0, sizeof (*r));
4393 sig = sf & 0x7fffffff;
4402 if (HOST_BITS_PER_LONG == 64)
4403 sig = sig << 1 << 31;
4406 SET_REAL_EXP (r, exp + 1);
4407 r->sig[SIGSZ-1] = sig;
4411 const struct real_format c4x_single_format =
4430 const struct real_format c4x_extended_format =
4432 encode_c4x_extended,
4433 decode_c4x_extended,
4450 /* A synthetic "format" for internal arithmetic. It's the size of the
4451 internal significand minus the two bits needed for proper rounding.
4452 The encode and decode routines exist only to satisfy our paranoia
4455 static void encode_internal (const struct real_format *fmt,
4456 long *, const REAL_VALUE_TYPE *);
4457 static void decode_internal (const struct real_format *,
4458 REAL_VALUE_TYPE *, const long *);
4461 encode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4462 const REAL_VALUE_TYPE *r)
4464 memcpy (buf, r, sizeof (*r));
4468 decode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED,
4469 REAL_VALUE_TYPE *r, const long *buf)
4471 memcpy (r, buf, sizeof (*r));
4474 const struct real_format real_internal_format =
4480 SIGNIFICAND_BITS - 2,
4481 SIGNIFICAND_BITS - 2,
4493 /* Calculate the square root of X in mode MODE, and store the result
4494 in R. Return TRUE if the operation does not raise an exception.
4495 For details see "High Precision Division and Square Root",
4496 Alan H. Karp and Peter Markstein, HP Lab Report 93-93-42, June
4497 1993. http://www.hpl.hp.com/techreports/93/HPL-93-42.pdf. */
4500 real_sqrt (REAL_VALUE_TYPE *r, enum machine_mode mode,
4501 const REAL_VALUE_TYPE *x)
4503 static REAL_VALUE_TYPE halfthree;
4504 static bool init = false;
4505 REAL_VALUE_TYPE h, t, i;
4508 /* sqrt(-0.0) is -0.0. */
4509 if (real_isnegzero (x))
4515 /* Negative arguments return NaN. */
4518 get_canonical_qnan (r, 0);
4522 /* Infinity and NaN return themselves. */
4523 if (real_isinf (x) || real_isnan (x))
4531 do_add (&halfthree, &dconst1, &dconsthalf, 0);
4535 /* Initial guess for reciprocal sqrt, i. */
4536 exp = real_exponent (x);
4537 real_ldexp (&i, &dconst1, -exp/2);
4539 /* Newton's iteration for reciprocal sqrt, i. */
4540 for (iter = 0; iter < 16; iter++)
4542 /* i(n+1) = i(n) * (1.5 - 0.5*i(n)*i(n)*x). */
4543 do_multiply (&t, x, &i);
4544 do_multiply (&h, &t, &i);
4545 do_multiply (&t, &h, &dconsthalf);
4546 do_add (&h, &halfthree, &t, 1);
4547 do_multiply (&t, &i, &h);
4549 /* Check for early convergence. */
4550 if (iter >= 6 && real_identical (&i, &t))
4553 /* ??? Unroll loop to avoid copying. */
4557 /* Final iteration: r = i*x + 0.5*i*x*(1.0 - i*(i*x)). */
4558 do_multiply (&t, x, &i);
4559 do_multiply (&h, &t, &i);
4560 do_add (&i, &dconst1, &h, 1);
4561 do_multiply (&h, &t, &i);
4562 do_multiply (&i, &dconsthalf, &h);
4563 do_add (&h, &t, &i, 0);
4565 /* ??? We need a Tuckerman test to get the last bit. */
4567 real_convert (r, mode, &h);
4571 /* Calculate X raised to the integer exponent N in mode MODE and store
4572 the result in R. Return true if the result may be inexact due to
4573 loss of precision. The algorithm is the classic "left-to-right binary
4574 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
4575 Algorithms", "The Art of Computer Programming", Volume 2. */
4578 real_powi (REAL_VALUE_TYPE *r, enum machine_mode mode,
4579 const REAL_VALUE_TYPE *x, HOST_WIDE_INT n)
4581 unsigned HOST_WIDE_INT bit;
4583 bool inexact = false;
4595 /* Don't worry about overflow, from now on n is unsigned. */
4603 bit = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
4604 for (i = 0; i < HOST_BITS_PER_WIDE_INT; i++)
4608 inexact |= do_multiply (&t, &t, &t);
4610 inexact |= do_multiply (&t, &t, x);
4618 inexact |= do_divide (&t, &dconst1, &t);
4620 real_convert (r, mode, &t);
4624 /* Round X to the nearest integer not larger in absolute value, i.e.
4625 towards zero, placing the result in R in mode MODE. */
4628 real_trunc (REAL_VALUE_TYPE *r, enum machine_mode mode,
4629 const REAL_VALUE_TYPE *x)
4631 do_fix_trunc (r, x);
4632 if (mode != VOIDmode)
4633 real_convert (r, mode, r);
4636 /* Round X to the largest integer not greater in value, i.e. round
4637 down, placing the result in R in mode MODE. */
4640 real_floor (REAL_VALUE_TYPE *r, enum machine_mode mode,
4641 const REAL_VALUE_TYPE *x)
4645 do_fix_trunc (&t, x);
4646 if (! real_identical (&t, x) && x->sign)
4647 do_add (&t, &t, &dconstm1, 0);
4648 if (mode != VOIDmode)
4649 real_convert (r, mode, &t);
4654 /* Round X to the smallest integer not less then argument, i.e. round
4655 up, placing the result in R in mode MODE. */
4658 real_ceil (REAL_VALUE_TYPE *r, enum machine_mode mode,
4659 const REAL_VALUE_TYPE *x)
4663 do_fix_trunc (&t, x);
4664 if (! real_identical (&t, x) && ! x->sign)
4665 do_add (&t, &t, &dconst1, 0);
4666 if (mode != VOIDmode)
4667 real_convert (r, mode, &t);
4672 /* Round X to the nearest integer, but round halfway cases away from
4676 real_round (REAL_VALUE_TYPE *r, enum machine_mode mode,
4677 const REAL_VALUE_TYPE *x)
4679 do_add (r, x, &dconsthalf, x->sign);
4680 do_fix_trunc (r, r);
4681 if (mode != VOIDmode)
4682 real_convert (r, mode, r);
4685 /* Set the sign of R to the sign of X. */
4688 real_copysign (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *x)