1 /* real.c - software floating point emulation.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
4 Contributed by Stephen L. Moshier (moshier@world.std.com).
5 Re-written by Richard Henderson <rth@redhat.com>
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, 59 Temple Place - Suite 330, 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);
644 /* Re-normalize the result. */
647 /* Special case: if the subtraction results in zero, the result
649 if (r->cl == rvc_zero)
652 r->sig[0] |= inexact;
657 /* Calculate R = A * B. Return true if the result may be inexact. */
660 do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
661 const REAL_VALUE_TYPE *b)
663 REAL_VALUE_TYPE u, t, *rr;
664 unsigned int i, j, k;
665 int sign = a->sign ^ b->sign;
666 bool inexact = false;
668 switch (CLASS2 (a->cl, b->cl))
670 case CLASS2 (rvc_zero, rvc_zero):
671 case CLASS2 (rvc_zero, rvc_normal):
672 case CLASS2 (rvc_normal, rvc_zero):
673 /* +-0 * ANY = 0 with appropriate sign. */
677 case CLASS2 (rvc_zero, rvc_nan):
678 case CLASS2 (rvc_normal, rvc_nan):
679 case CLASS2 (rvc_inf, rvc_nan):
680 case CLASS2 (rvc_nan, rvc_nan):
681 /* ANY * NaN = NaN. */
686 case CLASS2 (rvc_nan, rvc_zero):
687 case CLASS2 (rvc_nan, rvc_normal):
688 case CLASS2 (rvc_nan, rvc_inf):
689 /* NaN * ANY = NaN. */
694 case CLASS2 (rvc_zero, rvc_inf):
695 case CLASS2 (rvc_inf, rvc_zero):
697 get_canonical_qnan (r, sign);
700 case CLASS2 (rvc_inf, rvc_inf):
701 case CLASS2 (rvc_normal, rvc_inf):
702 case CLASS2 (rvc_inf, rvc_normal):
703 /* Inf * Inf = Inf, R * Inf = Inf */
707 case CLASS2 (rvc_normal, rvc_normal):
714 if (r == a || r == b)
720 /* Collect all the partial products. Since we don't have sure access
721 to a widening multiply, we split each long into two half-words.
723 Consider the long-hand form of a four half-word multiplication:
733 We construct partial products of the widened half-word products
734 that are known to not overlap, e.g. DF+DH. Each such partial
735 product is given its proper exponent, which allows us to sum them
736 and obtain the finished product. */
738 for (i = 0; i < SIGSZ * 2; ++i)
740 unsigned long ai = a->sig[i / 2];
742 ai >>= HOST_BITS_PER_LONG / 2;
744 ai &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
749 for (j = 0; j < 2; ++j)
751 int exp = (REAL_EXP (a) - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2)
752 + (REAL_EXP (b) - (1-j)*(HOST_BITS_PER_LONG/2)));
761 /* Would underflow to zero, which we shouldn't bother adding. */
766 memset (&u, 0, sizeof (u));
768 SET_REAL_EXP (&u, exp);
770 for (k = j; k < SIGSZ * 2; k += 2)
772 unsigned long bi = b->sig[k / 2];
774 bi >>= HOST_BITS_PER_LONG / 2;
776 bi &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
778 u.sig[k / 2] = ai * bi;
782 inexact |= do_add (rr, rr, &u, 0);
793 /* Calculate R = A / B. Return true if the result may be inexact. */
796 do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
797 const REAL_VALUE_TYPE *b)
799 int exp, sign = a->sign ^ b->sign;
800 REAL_VALUE_TYPE t, *rr;
803 switch (CLASS2 (a->cl, b->cl))
805 case CLASS2 (rvc_zero, rvc_zero):
807 case CLASS2 (rvc_inf, rvc_inf):
808 /* Inf / Inf = NaN. */
809 get_canonical_qnan (r, sign);
812 case CLASS2 (rvc_zero, rvc_normal):
813 case CLASS2 (rvc_zero, rvc_inf):
815 case CLASS2 (rvc_normal, rvc_inf):
820 case CLASS2 (rvc_normal, rvc_zero):
822 case CLASS2 (rvc_inf, rvc_zero):
827 case CLASS2 (rvc_zero, rvc_nan):
828 case CLASS2 (rvc_normal, rvc_nan):
829 case CLASS2 (rvc_inf, rvc_nan):
830 case CLASS2 (rvc_nan, rvc_nan):
831 /* ANY / NaN = NaN. */
836 case CLASS2 (rvc_nan, rvc_zero):
837 case CLASS2 (rvc_nan, rvc_normal):
838 case CLASS2 (rvc_nan, rvc_inf):
839 /* NaN / ANY = NaN. */
844 case CLASS2 (rvc_inf, rvc_normal):
849 case CLASS2 (rvc_normal, rvc_normal):
856 if (r == a || r == b)
861 /* Make sure all fields in the result are initialized. */
866 exp = REAL_EXP (a) - REAL_EXP (b) + 1;
877 SET_REAL_EXP (rr, exp);
879 inexact = div_significands (rr, a, b);
881 /* Re-normalize the result. */
883 rr->sig[0] |= inexact;
891 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
892 one of the two operands is a NaN. */
895 do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
900 switch (CLASS2 (a->cl, b->cl))
902 case CLASS2 (rvc_zero, rvc_zero):
903 /* Sign of zero doesn't matter for compares. */
906 case CLASS2 (rvc_inf, rvc_zero):
907 case CLASS2 (rvc_inf, rvc_normal):
908 case CLASS2 (rvc_normal, rvc_zero):
909 return (a->sign ? -1 : 1);
911 case CLASS2 (rvc_inf, rvc_inf):
912 return -a->sign - -b->sign;
914 case CLASS2 (rvc_zero, rvc_normal):
915 case CLASS2 (rvc_zero, rvc_inf):
916 case CLASS2 (rvc_normal, rvc_inf):
917 return (b->sign ? 1 : -1);
919 case CLASS2 (rvc_zero, rvc_nan):
920 case CLASS2 (rvc_normal, rvc_nan):
921 case CLASS2 (rvc_inf, rvc_nan):
922 case CLASS2 (rvc_nan, rvc_nan):
923 case CLASS2 (rvc_nan, rvc_zero):
924 case CLASS2 (rvc_nan, rvc_normal):
925 case CLASS2 (rvc_nan, rvc_inf):
928 case CLASS2 (rvc_normal, rvc_normal):
935 if (a->sign != b->sign)
936 return -a->sign - -b->sign;
938 if (REAL_EXP (a) > REAL_EXP (b))
940 else if (REAL_EXP (a) < REAL_EXP (b))
943 ret = cmp_significands (a, b);
945 return (a->sign ? -ret : ret);
948 /* Return A truncated to an integral value toward zero. */
951 do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
963 if (REAL_EXP (r) <= 0)
964 get_zero (r, r->sign);
965 else if (REAL_EXP (r) < SIGNIFICAND_BITS)
966 clear_significand_below (r, SIGNIFICAND_BITS - REAL_EXP (r));
974 /* Perform the binary or unary operation described by CODE.
975 For a unary operation, leave OP1 NULL. */
978 real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
979 const REAL_VALUE_TYPE *op1)
981 enum tree_code code = icode;
986 do_add (r, op0, op1, 0);
990 do_add (r, op0, op1, 1);
994 do_multiply (r, op0, op1);
998 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);
1038 /* Legacy. Similar, but return the result directly. */
1041 real_arithmetic2 (int icode, const REAL_VALUE_TYPE *op0,
1042 const REAL_VALUE_TYPE *op1)
1045 real_arithmetic (&r, icode, op0, op1);
1050 real_compare (int icode, const REAL_VALUE_TYPE *op0,
1051 const REAL_VALUE_TYPE *op1)
1053 enum tree_code code = icode;
1058 return do_compare (op0, op1, 1) < 0;
1060 return do_compare (op0, op1, 1) <= 0;
1062 return do_compare (op0, op1, -1) > 0;
1064 return do_compare (op0, op1, -1) >= 0;
1066 return do_compare (op0, op1, -1) == 0;
1068 return do_compare (op0, op1, -1) != 0;
1069 case UNORDERED_EXPR:
1070 return op0->cl == rvc_nan || op1->cl == rvc_nan;
1072 return op0->cl != rvc_nan && op1->cl != rvc_nan;
1074 return do_compare (op0, op1, -1) < 0;
1076 return do_compare (op0, op1, -1) <= 0;
1078 return do_compare (op0, op1, 1) > 0;
1080 return do_compare (op0, op1, 1) >= 0;
1082 return do_compare (op0, op1, 0) == 0;
1084 return do_compare (op0, op1, 0) != 0;
1091 /* Return floor log2(R). */
1094 real_exponent (const REAL_VALUE_TYPE *r)
1102 return (unsigned int)-1 >> 1;
1104 return REAL_EXP (r);
1110 /* R = OP0 * 2**EXP. */
1113 real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
1124 exp += REAL_EXP (op0);
1126 get_inf (r, r->sign);
1127 else if (exp < -MAX_EXP)
1128 get_zero (r, r->sign);
1130 SET_REAL_EXP (r, exp);
1138 /* Determine whether a floating-point value X is infinite. */
1141 real_isinf (const REAL_VALUE_TYPE *r)
1143 return (r->cl == rvc_inf);
1146 /* Determine whether a floating-point value X is a NaN. */
1149 real_isnan (const REAL_VALUE_TYPE *r)
1151 return (r->cl == rvc_nan);
1154 /* Determine whether a floating-point value X is negative. */
1157 real_isneg (const REAL_VALUE_TYPE *r)
1162 /* Determine whether a floating-point value X is minus zero. */
1165 real_isnegzero (const REAL_VALUE_TYPE *r)
1167 return r->sign && r->cl == rvc_zero;
1170 /* Compare two floating-point objects for bitwise identity. */
1173 real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
1179 if (a->sign != b->sign)
1189 if (REAL_EXP (a) != REAL_EXP (b))
1194 if (a->signalling != b->signalling)
1196 /* The significand is ignored for canonical NaNs. */
1197 if (a->canonical || b->canonical)
1198 return a->canonical == b->canonical;
1205 for (i = 0; i < SIGSZ; ++i)
1206 if (a->sig[i] != b->sig[i])
1212 /* Try to change R into its exact multiplicative inverse in machine
1213 mode MODE. Return true if successful. */
1216 exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
1218 const REAL_VALUE_TYPE *one = real_digit (1);
1222 if (r->cl != rvc_normal)
1225 /* Check for a power of two: all significand bits zero except the MSB. */
1226 for (i = 0; i < SIGSZ-1; ++i)
1229 if (r->sig[SIGSZ-1] != SIG_MSB)
1232 /* Find the inverse and truncate to the required mode. */
1233 do_divide (&u, one, r);
1234 real_convert (&u, mode, &u);
1236 /* The rounding may have overflowed. */
1237 if (u.cl != rvc_normal)
1239 for (i = 0; i < SIGSZ-1; ++i)
1242 if (u.sig[SIGSZ-1] != SIG_MSB)
1249 /* Render R as an integer. */
1252 real_to_integer (const REAL_VALUE_TYPE *r)
1254 unsigned HOST_WIDE_INT i;
1265 i = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1271 if (REAL_EXP (r) <= 0)
1273 /* Only force overflow for unsigned overflow. Signed overflow is
1274 undefined, so it doesn't matter what we return, and some callers
1275 expect to be able to use this routine for both signed and
1276 unsigned conversions. */
1277 if (REAL_EXP (r) > HOST_BITS_PER_WIDE_INT)
1280 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1281 i = r->sig[SIGSZ-1];
1284 gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
1285 i = r->sig[SIGSZ-1];
1286 i = i << (HOST_BITS_PER_LONG - 1) << 1;
1287 i |= r->sig[SIGSZ-2];
1290 i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
1301 /* Likewise, but to an integer pair, HI+LOW. */
1304 real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
1305 const REAL_VALUE_TYPE *r)
1308 HOST_WIDE_INT low, high;
1321 high = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1335 /* Only force overflow for unsigned overflow. Signed overflow is
1336 undefined, so it doesn't matter what we return, and some callers
1337 expect to be able to use this routine for both signed and
1338 unsigned conversions. */
1339 if (exp > 2*HOST_BITS_PER_WIDE_INT)
1342 rshift_significand (&t, r, 2*HOST_BITS_PER_WIDE_INT - exp);
1343 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1345 high = t.sig[SIGSZ-1];
1346 low = t.sig[SIGSZ-2];
1350 gcc_assert (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG);
1351 high = t.sig[SIGSZ-1];
1352 high = high << (HOST_BITS_PER_LONG - 1) << 1;
1353 high |= t.sig[SIGSZ-2];
1355 low = t.sig[SIGSZ-3];
1356 low = low << (HOST_BITS_PER_LONG - 1) << 1;
1357 low |= t.sig[SIGSZ-4];
1365 low = -low, high = ~high;
1377 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1378 of NUM / DEN. Return the quotient and place the remainder in NUM.
1379 It is expected that NUM / DEN are close enough that the quotient is
1382 static unsigned long
1383 rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den)
1385 unsigned long q, msb;
1386 int expn = REAL_EXP (num), expd = REAL_EXP (den);
1395 msb = num->sig[SIGSZ-1] & SIG_MSB;
1397 lshift_significand_1 (num, num);
1399 if (msb || cmp_significands (num, den) >= 0)
1401 sub_significands (num, num, den, 0);
1405 while (--expn >= expd);
1407 SET_REAL_EXP (num, expd);
1413 /* Render R as a decimal floating point constant. Emit DIGITS significant
1414 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1415 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1418 #define M_LOG10_2 0.30102999566398119521
1421 real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
1422 size_t digits, int crop_trailing_zeros)
1424 const REAL_VALUE_TYPE *one, *ten;
1425 REAL_VALUE_TYPE r, pten, u, v;
1426 int dec_exp, cmp_one, digit;
1428 char *p, *first, *last;
1435 strcpy (str, (r.sign ? "-0.0" : "0.0"));
1440 strcpy (str, (r.sign ? "-Inf" : "+Inf"));
1443 /* ??? Print the significand as well, if not canonical? */
1444 strcpy (str, (r.sign ? "-NaN" : "+NaN"));
1450 /* Bound the number of digits printed by the size of the representation. */
1451 max_digits = SIGNIFICAND_BITS * M_LOG10_2;
1452 if (digits == 0 || digits > max_digits)
1453 digits = max_digits;
1455 /* Estimate the decimal exponent, and compute the length of the string it
1456 will print as. Be conservative and add one to account for possible
1457 overflow or rounding error. */
1458 dec_exp = REAL_EXP (&r) * M_LOG10_2;
1459 for (max_digits = 1; dec_exp ; max_digits++)
1462 /* Bound the number of digits printed by the size of the output buffer. */
1463 max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
1464 gcc_assert (max_digits <= buf_size);
1465 if (digits > max_digits)
1466 digits = max_digits;
1468 one = real_digit (1);
1469 ten = ten_to_ptwo (0);
1477 cmp_one = do_compare (&r, one, 0);
1482 /* Number is greater than one. Convert significand to an integer
1483 and strip trailing decimal zeros. */
1486 SET_REAL_EXP (&u, SIGNIFICAND_BITS - 1);
1488 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1489 m = floor_log2 (max_digits);
1491 /* Iterate over the bits of the possible powers of 10 that might
1492 be present in U and eliminate them. That is, if we find that
1493 10**2**M divides U evenly, keep the division and increase
1499 do_divide (&t, &u, ten_to_ptwo (m));
1500 do_fix_trunc (&v, &t);
1501 if (cmp_significands (&v, &t) == 0)
1509 /* Revert the scaling to integer that we performed earlier. */
1510 SET_REAL_EXP (&u, REAL_EXP (&u) + REAL_EXP (&r)
1511 - (SIGNIFICAND_BITS - 1));
1514 /* Find power of 10. Do this by dividing out 10**2**M when
1515 this is larger than the current remainder. Fill PTEN with
1516 the power of 10 that we compute. */
1517 if (REAL_EXP (&r) > 0)
1519 m = floor_log2 ((int)(REAL_EXP (&r) * M_LOG10_2)) + 1;
1522 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1523 if (do_compare (&u, ptentwo, 0) >= 0)
1525 do_divide (&u, &u, ptentwo);
1526 do_multiply (&pten, &pten, ptentwo);
1533 /* We managed to divide off enough tens in the above reduction
1534 loop that we've now got a negative exponent. Fall into the
1535 less-than-one code to compute the proper value for PTEN. */
1542 /* Number is less than one. Pad significand with leading
1548 /* Stop if we'd shift bits off the bottom. */
1552 do_multiply (&u, &v, ten);
1554 /* Stop if we're now >= 1. */
1555 if (REAL_EXP (&u) > 0)
1563 /* Find power of 10. Do this by multiplying in P=10**2**M when
1564 the current remainder is smaller than 1/P. Fill PTEN with the
1565 power of 10 that we compute. */
1566 m = floor_log2 ((int)(-REAL_EXP (&r) * M_LOG10_2)) + 1;
1569 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1570 const REAL_VALUE_TYPE *ptenmtwo = ten_to_mptwo (m);
1572 if (do_compare (&v, ptenmtwo, 0) <= 0)
1574 do_multiply (&v, &v, ptentwo);
1575 do_multiply (&pten, &pten, ptentwo);
1581 /* Invert the positive power of 10 that we've collected so far. */
1582 do_divide (&pten, one, &pten);
1590 /* At this point, PTEN should contain the nearest power of 10 smaller
1591 than R, such that this division produces the first digit.
1593 Using a divide-step primitive that returns the complete integral
1594 remainder avoids the rounding error that would be produced if
1595 we were to use do_divide here and then simply multiply by 10 for
1596 each subsequent digit. */
1598 digit = rtd_divmod (&r, &pten);
1600 /* Be prepared for error in that division via underflow ... */
1601 if (digit == 0 && cmp_significand_0 (&r))
1603 /* Multiply by 10 and try again. */
1604 do_multiply (&r, &r, ten);
1605 digit = rtd_divmod (&r, &pten);
1607 gcc_assert (digit != 0);
1610 /* ... or overflow. */
1620 gcc_assert (digit <= 10);
1624 /* Generate subsequent digits. */
1625 while (--digits > 0)
1627 do_multiply (&r, &r, ten);
1628 digit = rtd_divmod (&r, &pten);
1633 /* Generate one more digit with which to do rounding. */
1634 do_multiply (&r, &r, ten);
1635 digit = rtd_divmod (&r, &pten);
1637 /* Round the result. */
1640 /* Round to nearest. If R is nonzero there are additional
1641 nonzero digits to be extracted. */
1642 if (cmp_significand_0 (&r))
1644 /* Round to even. */
1645 else if ((p[-1] - '0') & 1)
1662 /* Carry out of the first digit. This means we had all 9's and
1663 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1671 /* Insert the decimal point. */
1672 first[0] = first[1];
1675 /* If requested, drop trailing zeros. Never crop past "1.0". */
1676 if (crop_trailing_zeros)
1677 while (last > first + 3 && last[-1] == '0')
1680 /* Append the exponent. */
1681 sprintf (last, "e%+d", dec_exp);
1684 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1685 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1686 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1687 strip trailing zeros. */
1690 real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
1691 size_t digits, int crop_trailing_zeros)
1693 int i, j, exp = REAL_EXP (r);
1706 strcpy (str, (r->sign ? "-Inf" : "+Inf"));
1709 /* ??? Print the significand as well, if not canonical? */
1710 strcpy (str, (r->sign ? "-NaN" : "+NaN"));
1717 digits = SIGNIFICAND_BITS / 4;
1719 /* Bound the number of digits printed by the size of the output buffer. */
1721 sprintf (exp_buf, "p%+d", exp);
1722 max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1;
1723 gcc_assert (max_digits <= buf_size);
1724 if (digits > max_digits)
1725 digits = max_digits;
1736 for (i = SIGSZ - 1; i >= 0; --i)
1737 for (j = HOST_BITS_PER_LONG - 4; j >= 0; j -= 4)
1739 *p++ = "0123456789abcdef"[(r->sig[i] >> j) & 15];
1745 if (crop_trailing_zeros)
1746 while (p > first + 1 && p[-1] == '0')
1749 sprintf (p, "p%+d", exp);
1752 /* Initialize R from a decimal or hexadecimal string. The string is
1753 assumed to have been syntax checked already. */
1756 real_from_string (REAL_VALUE_TYPE *r, const char *str)
1768 else if (*str == '+')
1771 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
1773 /* Hexadecimal floating point. */
1774 int pos = SIGNIFICAND_BITS - 4, d;
1782 d = hex_value (*str);
1787 r->sig[pos / HOST_BITS_PER_LONG]
1788 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1797 if (pos == SIGNIFICAND_BITS - 4)
1804 d = hex_value (*str);
1809 r->sig[pos / HOST_BITS_PER_LONG]
1810 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1816 if (*str == 'p' || *str == 'P')
1818 bool exp_neg = false;
1826 else if (*str == '+')
1830 while (ISDIGIT (*str))
1836 /* Overflowed the exponent. */
1851 SET_REAL_EXP (r, exp);
1857 /* Decimal floating point. */
1858 const REAL_VALUE_TYPE *ten = ten_to_ptwo (0);
1863 while (ISDIGIT (*str))
1866 do_multiply (r, r, ten);
1868 do_add (r, r, real_digit (d), 0);
1873 if (r->cl == rvc_zero)
1878 while (ISDIGIT (*str))
1881 do_multiply (r, r, ten);
1883 do_add (r, r, real_digit (d), 0);
1888 if (*str == 'e' || *str == 'E')
1890 bool exp_neg = false;
1898 else if (*str == '+')
1902 while (ISDIGIT (*str))
1908 /* Overflowed the exponent. */
1922 times_pten (r, exp);
1937 /* Legacy. Similar, but return the result directly. */
1940 real_from_string2 (const char *s, enum machine_mode mode)
1944 real_from_string (&r, s);
1945 if (mode != VOIDmode)
1946 real_convert (&r, mode, &r);
1951 /* Initialize R from the integer pair HIGH+LOW. */
1954 real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
1955 unsigned HOST_WIDE_INT low, HOST_WIDE_INT high,
1958 if (low == 0 && high == 0)
1963 r->sign = high < 0 && !unsigned_p;
1964 SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT);
1975 if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT)
1977 r->sig[SIGSZ-1] = high;
1978 r->sig[SIGSZ-2] = low;
1979 memset (r->sig, 0, sizeof(long)*(SIGSZ-2));
1983 gcc_assert (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT);
1984 r->sig[SIGSZ-1] = high >> (HOST_BITS_PER_LONG - 1) >> 1;
1985 r->sig[SIGSZ-2] = high;
1986 r->sig[SIGSZ-3] = low >> (HOST_BITS_PER_LONG - 1) >> 1;
1987 r->sig[SIGSZ-4] = low;
1989 memset (r->sig, 0, sizeof(long)*(SIGSZ-4));
1995 if (mode != VOIDmode)
1996 real_convert (r, mode, r);
1999 /* Returns 10**2**N. */
2001 static const REAL_VALUE_TYPE *
2004 static REAL_VALUE_TYPE tens[EXP_BITS];
2006 gcc_assert (n >= 0);
2007 gcc_assert (n < EXP_BITS);
2009 if (tens[n].cl == rvc_zero)
2011 if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
2013 HOST_WIDE_INT t = 10;
2016 for (i = 0; i < n; ++i)
2019 real_from_integer (&tens[n], VOIDmode, t, 0, 1);
2023 const REAL_VALUE_TYPE *t = ten_to_ptwo (n - 1);
2024 do_multiply (&tens[n], t, t);
2031 /* Returns 10**(-2**N). */
2033 static const REAL_VALUE_TYPE *
2034 ten_to_mptwo (int n)
2036 static REAL_VALUE_TYPE tens[EXP_BITS];
2038 gcc_assert (n >= 0);
2039 gcc_assert (n < EXP_BITS);
2041 if (tens[n].cl == rvc_zero)
2042 do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
2049 static const REAL_VALUE_TYPE *
2052 static REAL_VALUE_TYPE num[10];
2054 gcc_assert (n >= 0);
2055 gcc_assert (n <= 9);
2057 if (n > 0 && num[n].cl == rvc_zero)
2058 real_from_integer (&num[n], VOIDmode, n, 0, 1);
2063 /* Multiply R by 10**EXP. */
2066 times_pten (REAL_VALUE_TYPE *r, int exp)
2068 REAL_VALUE_TYPE pten, *rr;
2069 bool negative = (exp < 0);
2075 pten = *real_digit (1);
2081 for (i = 0; exp > 0; ++i, exp >>= 1)
2083 do_multiply (rr, rr, ten_to_ptwo (i));
2086 do_divide (r, r, &pten);
2089 /* Fills R with +Inf. */
2092 real_inf (REAL_VALUE_TYPE *r)
2097 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2098 we force a QNaN, else we force an SNaN. The string, if not empty,
2099 is parsed as a number and placed in the significand. Return true
2100 if the string was successfully parsed. */
2103 real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
2104 enum machine_mode mode)
2106 const struct real_format *fmt;
2108 fmt = REAL_MODE_FORMAT (mode);
2114 get_canonical_qnan (r, 0);
2116 get_canonical_snan (r, 0);
2123 memset (r, 0, sizeof (*r));
2126 /* Parse akin to strtol into the significand of R. */
2128 while (ISSPACE (*str))
2132 else if (*str == '+')
2142 while ((d = hex_value (*str)) < base)
2149 lshift_significand (r, r, 3);
2152 lshift_significand (r, r, 4);
2155 lshift_significand_1 (&u, r);
2156 lshift_significand (r, r, 3);
2157 add_significands (r, r, &u);
2165 add_significands (r, r, &u);
2170 /* Must have consumed the entire string for success. */
2174 /* Shift the significand into place such that the bits
2175 are in the most significant bits for the format. */
2176 lshift_significand (r, r, SIGNIFICAND_BITS - fmt->pnan);
2178 /* Our MSB is always unset for NaNs. */
2179 r->sig[SIGSZ-1] &= ~SIG_MSB;
2181 /* Force quiet or signalling NaN. */
2182 r->signalling = !quiet;
2188 /* Fills R with the largest finite value representable in mode MODE.
2189 If SIGN is nonzero, R is set to the most negative finite value. */
2192 real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
2194 const struct real_format *fmt;
2197 fmt = REAL_MODE_FORMAT (mode);
2204 SET_REAL_EXP (r, fmt->emax * fmt->log2_b);
2206 np2 = SIGNIFICAND_BITS - fmt->p * fmt->log2_b;
2207 memset (r->sig, -1, SIGSZ * sizeof (unsigned long));
2208 clear_significand_below (r, np2);
2211 /* Fills R with 2**N. */
2214 real_2expN (REAL_VALUE_TYPE *r, int n)
2216 memset (r, 0, sizeof (*r));
2221 else if (n < -MAX_EXP)
2226 SET_REAL_EXP (r, n);
2227 r->sig[SIGSZ-1] = SIG_MSB;
2233 round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
2236 unsigned long sticky;
2240 p2 = fmt->p * fmt->log2_b;
2241 emin2m1 = (fmt->emin - 1) * fmt->log2_b;
2242 emax2 = fmt->emax * fmt->log2_b;
2244 np2 = SIGNIFICAND_BITS - p2;
2248 get_zero (r, r->sign);
2250 if (!fmt->has_signed_zero)
2255 get_inf (r, r->sign);
2260 clear_significand_below (r, np2);
2270 /* If we're not base2, normalize the exponent to a multiple of
2272 if (fmt->log2_b != 1)
2274 int shift = REAL_EXP (r) & (fmt->log2_b - 1);
2277 shift = fmt->log2_b - shift;
2278 r->sig[0] |= sticky_rshift_significand (r, r, shift);
2279 SET_REAL_EXP (r, REAL_EXP (r) + shift);
2283 /* Check the range of the exponent. If we're out of range,
2284 either underflow or overflow. */
2285 if (REAL_EXP (r) > emax2)
2287 else if (REAL_EXP (r) <= emin2m1)
2291 if (!fmt->has_denorm)
2293 /* Don't underflow completely until we've had a chance to round. */
2294 if (REAL_EXP (r) < emin2m1)
2299 diff = emin2m1 - REAL_EXP (r) + 1;
2303 /* De-normalize the significand. */
2304 r->sig[0] |= sticky_rshift_significand (r, r, diff);
2305 SET_REAL_EXP (r, REAL_EXP (r) + diff);
2309 /* There are P2 true significand bits, followed by one guard bit,
2310 followed by one sticky bit, followed by stuff. Fold nonzero
2311 stuff into the sticky bit. */
2314 for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
2315 sticky |= r->sig[i];
2317 r->sig[w] & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
2319 guard = test_significand_bit (r, np2 - 1);
2320 lsb = test_significand_bit (r, np2);
2322 /* Round to even. */
2323 if (guard && (sticky || lsb))
2327 set_significand_bit (&u, np2);
2329 if (add_significands (r, r, &u))
2331 /* Overflow. Means the significand had been all ones, and
2332 is now all zeros. Need to increase the exponent, and
2333 possibly re-normalize it. */
2334 SET_REAL_EXP (r, REAL_EXP (r) + 1);
2335 if (REAL_EXP (r) > emax2)
2337 r->sig[SIGSZ-1] = SIG_MSB;
2339 if (fmt->log2_b != 1)
2341 int shift = REAL_EXP (r) & (fmt->log2_b - 1);
2344 shift = fmt->log2_b - shift;
2345 rshift_significand (r, r, shift);
2346 SET_REAL_EXP (r, REAL_EXP (r) + shift);
2347 if (REAL_EXP (r) > emax2)
2354 /* Catch underflow that we deferred until after rounding. */
2355 if (REAL_EXP (r) <= emin2m1)
2358 /* Clear out trailing garbage. */
2359 clear_significand_below (r, np2);
2362 /* Extend or truncate to a new mode. */
2365 real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
2366 const REAL_VALUE_TYPE *a)
2368 const struct real_format *fmt;
2370 fmt = REAL_MODE_FORMAT (mode);
2374 round_for_format (fmt, r);
2376 /* round_for_format de-normalizes denormals. Undo just that part. */
2377 if (r->cl == rvc_normal)
2381 /* Legacy. Likewise, except return the struct directly. */
2384 real_value_truncate (enum machine_mode mode, REAL_VALUE_TYPE a)
2387 real_convert (&r, mode, &a);
2391 /* Return true if truncating to MODE is exact. */
2394 exact_real_truncate (enum machine_mode mode, const REAL_VALUE_TYPE *a)
2397 real_convert (&t, mode, a);
2398 return real_identical (&t, a);
2401 /* Write R to the given target format. Place the words of the result
2402 in target word order in BUF. There are always 32 bits in each
2403 long, no matter the size of the host long.
2405 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2408 real_to_target_fmt (long *buf, const REAL_VALUE_TYPE *r_orig,
2409 const struct real_format *fmt)
2415 round_for_format (fmt, &r);
2419 (*fmt->encode) (fmt, buf, &r);
2424 /* Similar, but look up the format from MODE. */
2427 real_to_target (long *buf, const REAL_VALUE_TYPE *r, enum machine_mode mode)
2429 const struct real_format *fmt;
2431 fmt = REAL_MODE_FORMAT (mode);
2434 return real_to_target_fmt (buf, r, fmt);
2437 /* Read R from the given target format. Read the words of the result
2438 in target word order in BUF. There are always 32 bits in each
2439 long, no matter the size of the host long. */
2442 real_from_target_fmt (REAL_VALUE_TYPE *r, const long *buf,
2443 const struct real_format *fmt)
2445 (*fmt->decode) (fmt, r, buf);
2448 /* Similar, but look up the format from MODE. */
2451 real_from_target (REAL_VALUE_TYPE *r, const long *buf, enum machine_mode mode)
2453 const struct real_format *fmt;
2455 fmt = REAL_MODE_FORMAT (mode);
2458 (*fmt->decode) (fmt, r, buf);
2461 /* Return the number of bits in the significand for MODE. */
2462 /* ??? Legacy. Should get access to real_format directly. */
2465 significand_size (enum machine_mode mode)
2467 const struct real_format *fmt;
2469 fmt = REAL_MODE_FORMAT (mode);
2473 return fmt->p * fmt->log2_b;
2476 /* Return a hash value for the given real value. */
2477 /* ??? The "unsigned int" return value is intended to be hashval_t,
2478 but I didn't want to pull hashtab.h into real.h. */
2481 real_hash (const REAL_VALUE_TYPE *r)
2486 h = r->cl | (r->sign << 2);
2494 h |= REAL_EXP (r) << 3;
2499 h ^= (unsigned int)-1;
2508 if (sizeof(unsigned long) > sizeof(unsigned int))
2509 for (i = 0; i < SIGSZ; ++i)
2511 unsigned long s = r->sig[i];
2512 h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2));
2515 for (i = 0; i < SIGSZ; ++i)
2521 /* IEEE single-precision format. */
2523 static void encode_ieee_single (const struct real_format *fmt,
2524 long *, const REAL_VALUE_TYPE *);
2525 static void decode_ieee_single (const struct real_format *,
2526 REAL_VALUE_TYPE *, const long *);
2529 encode_ieee_single (const struct real_format *fmt, long *buf,
2530 const REAL_VALUE_TYPE *r)
2532 unsigned long image, sig, exp;
2533 unsigned long sign = r->sign;
2534 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2537 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
2548 image |= 0x7fffffff;
2556 if (r->signalling == fmt->qnan_msb_set)
2560 /* We overload qnan_msb_set here: it's only clear for
2561 mips_ieee_single, which wants all mantissa bits but the
2562 quiet/signalling one set in canonical NaNs (at least
2564 if (r->canonical && !fmt->qnan_msb_set)
2565 sig |= (1 << 22) - 1;
2573 image |= 0x7fffffff;
2577 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2578 whereas the intermediate representation is 0.F x 2**exp.
2579 Which means we're off by one. */
2583 exp = REAL_EXP (r) + 127 - 1;
2596 decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
2599 unsigned long image = buf[0] & 0xffffffff;
2600 bool sign = (image >> 31) & 1;
2601 int exp = (image >> 23) & 0xff;
2603 memset (r, 0, sizeof (*r));
2604 image <<= HOST_BITS_PER_LONG - 24;
2609 if (image && fmt->has_denorm)
2613 SET_REAL_EXP (r, -126);
2614 r->sig[SIGSZ-1] = image << 1;
2617 else if (fmt->has_signed_zero)
2620 else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
2626 r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
2627 ^ fmt->qnan_msb_set);
2628 r->sig[SIGSZ-1] = image;
2640 SET_REAL_EXP (r, exp - 127 + 1);
2641 r->sig[SIGSZ-1] = image | SIG_MSB;
2645 const struct real_format ieee_single_format =
2663 const struct real_format mips_single_format =
2682 /* IEEE double-precision format. */
2684 static void encode_ieee_double (const struct real_format *fmt,
2685 long *, const REAL_VALUE_TYPE *);
2686 static void decode_ieee_double (const struct real_format *,
2687 REAL_VALUE_TYPE *, const long *);
2690 encode_ieee_double (const struct real_format *fmt, long *buf,
2691 const REAL_VALUE_TYPE *r)
2693 unsigned long image_lo, image_hi, sig_lo, sig_hi, exp;
2694 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2696 image_hi = r->sign << 31;
2699 if (HOST_BITS_PER_LONG == 64)
2701 sig_hi = r->sig[SIGSZ-1];
2702 sig_lo = (sig_hi >> (64 - 53)) & 0xffffffff;
2703 sig_hi = (sig_hi >> (64 - 53 + 1) >> 31) & 0xfffff;
2707 sig_hi = r->sig[SIGSZ-1];
2708 sig_lo = r->sig[SIGSZ-2];
2709 sig_lo = (sig_hi << 21) | (sig_lo >> 11);
2710 sig_hi = (sig_hi >> 11) & 0xfffff;
2720 image_hi |= 2047 << 20;
2723 image_hi |= 0x7fffffff;
2724 image_lo = 0xffffffff;
2732 sig_hi = sig_lo = 0;
2733 if (r->signalling == fmt->qnan_msb_set)
2734 sig_hi &= ~(1 << 19);
2737 /* We overload qnan_msb_set here: it's only clear for
2738 mips_ieee_single, which wants all mantissa bits but the
2739 quiet/signalling one set in canonical NaNs (at least
2741 if (r->canonical && !fmt->qnan_msb_set)
2743 sig_hi |= (1 << 19) - 1;
2744 sig_lo = 0xffffffff;
2746 else if (sig_hi == 0 && sig_lo == 0)
2749 image_hi |= 2047 << 20;
2755 image_hi |= 0x7fffffff;
2756 image_lo = 0xffffffff;
2761 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2762 whereas the intermediate representation is 0.F x 2**exp.
2763 Which means we're off by one. */
2767 exp = REAL_EXP (r) + 1023 - 1;
2768 image_hi |= exp << 20;
2777 if (FLOAT_WORDS_BIG_ENDIAN)
2778 buf[0] = image_hi, buf[1] = image_lo;
2780 buf[0] = image_lo, buf[1] = image_hi;
2784 decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
2787 unsigned long image_hi, image_lo;
2791 if (FLOAT_WORDS_BIG_ENDIAN)
2792 image_hi = buf[0], image_lo = buf[1];
2794 image_lo = buf[0], image_hi = buf[1];
2795 image_lo &= 0xffffffff;
2796 image_hi &= 0xffffffff;
2798 sign = (image_hi >> 31) & 1;
2799 exp = (image_hi >> 20) & 0x7ff;
2801 memset (r, 0, sizeof (*r));
2803 image_hi <<= 32 - 21;
2804 image_hi |= image_lo >> 21;
2805 image_hi &= 0x7fffffff;
2806 image_lo <<= 32 - 21;
2810 if ((image_hi || image_lo) && fmt->has_denorm)
2814 SET_REAL_EXP (r, -1022);
2815 if (HOST_BITS_PER_LONG == 32)
2817 image_hi = (image_hi << 1) | (image_lo >> 31);
2819 r->sig[SIGSZ-1] = image_hi;
2820 r->sig[SIGSZ-2] = image_lo;
2824 image_hi = (image_hi << 31 << 2) | (image_lo << 1);
2825 r->sig[SIGSZ-1] = image_hi;
2829 else if (fmt->has_signed_zero)
2832 else if (exp == 2047 && (fmt->has_nans || fmt->has_inf))
2834 if (image_hi || image_lo)
2838 r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set;
2839 if (HOST_BITS_PER_LONG == 32)
2841 r->sig[SIGSZ-1] = image_hi;
2842 r->sig[SIGSZ-2] = image_lo;
2845 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo;
2857 SET_REAL_EXP (r, exp - 1023 + 1);
2858 if (HOST_BITS_PER_LONG == 32)
2860 r->sig[SIGSZ-1] = image_hi | SIG_MSB;
2861 r->sig[SIGSZ-2] = image_lo;
2864 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo | SIG_MSB;
2868 const struct real_format ieee_double_format =
2886 const struct real_format mips_double_format =
2905 /* IEEE extended real format. This comes in three flavors: Intel's as
2906 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
2907 12- and 16-byte images may be big- or little endian; Motorola's is
2908 always big endian. */
2910 /* Helper subroutine which converts from the internal format to the
2911 12-byte little-endian Intel format. Functions below adjust this
2912 for the other possible formats. */
2914 encode_ieee_extended (const struct real_format *fmt, long *buf,
2915 const REAL_VALUE_TYPE *r)
2917 unsigned long image_hi, sig_hi, sig_lo;
2918 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2920 image_hi = r->sign << 15;
2921 sig_hi = sig_lo = 0;
2933 /* Intel requires the explicit integer bit to be set, otherwise
2934 it considers the value a "pseudo-infinity". Motorola docs
2935 say it doesn't care. */
2936 sig_hi = 0x80000000;
2941 sig_lo = sig_hi = 0xffffffff;
2949 if (HOST_BITS_PER_LONG == 32)
2951 sig_hi = r->sig[SIGSZ-1];
2952 sig_lo = r->sig[SIGSZ-2];
2956 sig_lo = r->sig[SIGSZ-1];
2957 sig_hi = sig_lo >> 31 >> 1;
2958 sig_lo &= 0xffffffff;
2960 if (r->signalling == fmt->qnan_msb_set)
2961 sig_hi &= ~(1 << 30);
2964 if ((sig_hi & 0x7fffffff) == 0 && sig_lo == 0)
2967 /* Intel requires the explicit integer bit to be set, otherwise
2968 it considers the value a "pseudo-nan". Motorola docs say it
2970 sig_hi |= 0x80000000;
2975 sig_lo = sig_hi = 0xffffffff;
2981 int exp = REAL_EXP (r);
2983 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2984 whereas the intermediate representation is 0.F x 2**exp.
2985 Which means we're off by one.
2987 Except for Motorola, which consider exp=0 and explicit
2988 integer bit set to continue to be normalized. In theory
2989 this discrepancy has been taken care of by the difference
2990 in fmt->emin in round_for_format. */
2997 gcc_assert (exp >= 0);
3001 if (HOST_BITS_PER_LONG == 32)
3003 sig_hi = r->sig[SIGSZ-1];
3004 sig_lo = r->sig[SIGSZ-2];
3008 sig_lo = r->sig[SIGSZ-1];
3009 sig_hi = sig_lo >> 31 >> 1;
3010 sig_lo &= 0xffffffff;
3019 buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
3022 /* Convert from the internal format to the 12-byte Motorola format
3023 for an IEEE extended real. */
3025 encode_ieee_extended_motorola (const struct real_format *fmt, long *buf,
3026 const REAL_VALUE_TYPE *r)
3029 encode_ieee_extended (fmt, intermed, r);
3031 /* Motorola chips are assumed always to be big-endian. Also, the
3032 padding in a Motorola extended real goes between the exponent and
3033 the mantissa. At this point the mantissa is entirely within
3034 elements 0 and 1 of intermed, and the exponent entirely within
3035 element 2, so all we have to do is swap the order around, and
3036 shift element 2 left 16 bits. */
3037 buf[0] = intermed[2] << 16;
3038 buf[1] = intermed[1];
3039 buf[2] = intermed[0];
3042 /* Convert from the internal format to the 12-byte Intel format for
3043 an IEEE extended real. */
3045 encode_ieee_extended_intel_96 (const struct real_format *fmt, long *buf,
3046 const REAL_VALUE_TYPE *r)
3048 if (FLOAT_WORDS_BIG_ENDIAN)
3050 /* All the padding in an Intel-format extended real goes at the high
3051 end, which in this case is after the mantissa, not the exponent.
3052 Therefore we must shift everything down 16 bits. */
3054 encode_ieee_extended (fmt, intermed, r);
3055 buf[0] = ((intermed[2] << 16) | ((unsigned long)(intermed[1] & 0xFFFF0000) >> 16));
3056 buf[1] = ((intermed[1] << 16) | ((unsigned long)(intermed[0] & 0xFFFF0000) >> 16));
3057 buf[2] = (intermed[0] << 16);
3060 /* encode_ieee_extended produces what we want directly. */
3061 encode_ieee_extended (fmt, buf, r);
3064 /* Convert from the internal format to the 16-byte Intel format for
3065 an IEEE extended real. */
3067 encode_ieee_extended_intel_128 (const struct real_format *fmt, long *buf,
3068 const REAL_VALUE_TYPE *r)
3070 /* All the padding in an Intel-format extended real goes at the high end. */
3071 encode_ieee_extended_intel_96 (fmt, buf, r);
3075 /* As above, we have a helper function which converts from 12-byte
3076 little-endian Intel format to internal format. Functions below
3077 adjust for the other possible formats. */
3079 decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3082 unsigned long image_hi, sig_hi, sig_lo;
3086 sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
3087 sig_lo &= 0xffffffff;
3088 sig_hi &= 0xffffffff;
3089 image_hi &= 0xffffffff;
3091 sign = (image_hi >> 15) & 1;
3092 exp = image_hi & 0x7fff;
3094 memset (r, 0, sizeof (*r));
3098 if ((sig_hi || sig_lo) && fmt->has_denorm)
3103 /* When the IEEE format contains a hidden bit, we know that
3104 it's zero at this point, and so shift up the significand
3105 and decrease the exponent to match. In this case, Motorola
3106 defines the explicit integer bit to be valid, so we don't
3107 know whether the msb is set or not. */
3108 SET_REAL_EXP (r, fmt->emin);
3109 if (HOST_BITS_PER_LONG == 32)
3111 r->sig[SIGSZ-1] = sig_hi;
3112 r->sig[SIGSZ-2] = sig_lo;
3115 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3119 else if (fmt->has_signed_zero)
3122 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3124 /* See above re "pseudo-infinities" and "pseudo-nans".
3125 Short summary is that the MSB will likely always be
3126 set, and that we don't care about it. */
3127 sig_hi &= 0x7fffffff;
3129 if (sig_hi || sig_lo)
3133 r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set;
3134 if (HOST_BITS_PER_LONG == 32)
3136 r->sig[SIGSZ-1] = sig_hi;
3137 r->sig[SIGSZ-2] = sig_lo;
3140 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3152 SET_REAL_EXP (r, exp - 16383 + 1);
3153 if (HOST_BITS_PER_LONG == 32)
3155 r->sig[SIGSZ-1] = sig_hi;
3156 r->sig[SIGSZ-2] = sig_lo;
3159 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3163 /* Convert from the internal format to the 12-byte Motorola format
3164 for an IEEE extended real. */
3166 decode_ieee_extended_motorola (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3171 /* Motorola chips are assumed always to be big-endian. Also, the
3172 padding in a Motorola extended real goes between the exponent and
3173 the mantissa; remove it. */
3174 intermed[0] = buf[2];
3175 intermed[1] = buf[1];
3176 intermed[2] = (unsigned long)buf[0] >> 16;
3178 decode_ieee_extended (fmt, r, intermed);
3181 /* Convert from the internal format to the 12-byte Intel format for
3182 an IEEE extended real. */
3184 decode_ieee_extended_intel_96 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3187 if (FLOAT_WORDS_BIG_ENDIAN)
3189 /* All the padding in an Intel-format extended real goes at the high
3190 end, which in this case is after the mantissa, not the exponent.
3191 Therefore we must shift everything up 16 bits. */
3194 intermed[0] = (((unsigned long)buf[2] >> 16) | (buf[1] << 16));
3195 intermed[1] = (((unsigned long)buf[1] >> 16) | (buf[0] << 16));
3196 intermed[2] = ((unsigned long)buf[0] >> 16);
3198 decode_ieee_extended (fmt, r, intermed);
3201 /* decode_ieee_extended produces what we want directly. */
3202 decode_ieee_extended (fmt, r, buf);
3205 /* Convert from the internal format to the 16-byte Intel format for
3206 an IEEE extended real. */
3208 decode_ieee_extended_intel_128 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3211 /* All the padding in an Intel-format extended real goes at the high end. */
3212 decode_ieee_extended_intel_96 (fmt, r, buf);
3215 const struct real_format ieee_extended_motorola_format =
3217 encode_ieee_extended_motorola,
3218 decode_ieee_extended_motorola,
3233 const struct real_format ieee_extended_intel_96_format =
3235 encode_ieee_extended_intel_96,
3236 decode_ieee_extended_intel_96,
3251 const struct real_format ieee_extended_intel_128_format =
3253 encode_ieee_extended_intel_128,
3254 decode_ieee_extended_intel_128,
3269 /* The following caters to i386 systems that set the rounding precision
3270 to 53 bits instead of 64, e.g. FreeBSD. */
3271 const struct real_format ieee_extended_intel_96_round_53_format =
3273 encode_ieee_extended_intel_96,
3274 decode_ieee_extended_intel_96,
3289 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3290 numbers whose sum is equal to the extended precision value. The number
3291 with greater magnitude is first. This format has the same magnitude
3292 range as an IEEE double precision value, but effectively 106 bits of
3293 significand precision. Infinity and NaN are represented by their IEEE
3294 double precision value stored in the first number, the second number is
3295 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3297 static void encode_ibm_extended (const struct real_format *fmt,
3298 long *, const REAL_VALUE_TYPE *);
3299 static void decode_ibm_extended (const struct real_format *,
3300 REAL_VALUE_TYPE *, const long *);
3303 encode_ibm_extended (const struct real_format *fmt, long *buf,
3304 const REAL_VALUE_TYPE *r)
3306 REAL_VALUE_TYPE u, normr, v;
3307 const struct real_format *base_fmt;
3309 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3311 /* Renormlize R before doing any arithmetic on it. */
3313 if (normr.cl == rvc_normal)
3316 /* u = IEEE double precision portion of significand. */
3318 round_for_format (base_fmt, &u);
3319 encode_ieee_double (base_fmt, &buf[0], &u);
3321 if (u.cl == rvc_normal)
3323 do_add (&v, &normr, &u, 1);
3324 /* Call round_for_format since we might need to denormalize. */
3325 round_for_format (base_fmt, &v);
3326 encode_ieee_double (base_fmt, &buf[2], &v);
3330 /* Inf, NaN, 0 are all representable as doubles, so the
3331 least-significant part can be 0.0. */
3338 decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_TYPE *r,
3341 REAL_VALUE_TYPE u, v;
3342 const struct real_format *base_fmt;
3344 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3345 decode_ieee_double (base_fmt, &u, &buf[0]);
3347 if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan)
3349 decode_ieee_double (base_fmt, &v, &buf[2]);
3350 do_add (r, &u, &v, 0);
3356 const struct real_format ibm_extended_format =
3358 encode_ibm_extended,
3359 decode_ibm_extended,
3374 const struct real_format mips_extended_format =
3376 encode_ibm_extended,
3377 decode_ibm_extended,
3393 /* IEEE quad precision format. */
3395 static void encode_ieee_quad (const struct real_format *fmt,
3396 long *, const REAL_VALUE_TYPE *);
3397 static void decode_ieee_quad (const struct real_format *,
3398 REAL_VALUE_TYPE *, const long *);
3401 encode_ieee_quad (const struct real_format *fmt, long *buf,
3402 const REAL_VALUE_TYPE *r)
3404 unsigned long image3, image2, image1, image0, exp;
3405 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
3408 image3 = r->sign << 31;
3413 rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
3422 image3 |= 32767 << 16;
3425 image3 |= 0x7fffffff;
3426 image2 = 0xffffffff;
3427 image1 = 0xffffffff;
3428 image0 = 0xffffffff;
3435 image3 |= 32767 << 16;
3439 /* Don't use bits from the significand. The
3440 initialization above is right. */
3442 else if (HOST_BITS_PER_LONG == 32)
3447 image3 |= u.sig[3] & 0xffff;
3452 image1 = image0 >> 31 >> 1;
3454 image3 |= (image2 >> 31 >> 1) & 0xffff;
3455 image0 &= 0xffffffff;
3456 image2 &= 0xffffffff;
3458 if (r->signalling == fmt->qnan_msb_set)
3462 /* We overload qnan_msb_set here: it's only clear for
3463 mips_ieee_single, which wants all mantissa bits but the
3464 quiet/signalling one set in canonical NaNs (at least
3466 if (r->canonical && !fmt->qnan_msb_set)
3469 image2 = image1 = image0 = 0xffffffff;
3471 else if (((image3 & 0xffff) | image2 | image1 | image0) == 0)
3476 image3 |= 0x7fffffff;
3477 image2 = 0xffffffff;
3478 image1 = 0xffffffff;
3479 image0 = 0xffffffff;
3484 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3485 whereas the intermediate representation is 0.F x 2**exp.
3486 Which means we're off by one. */
3490 exp = REAL_EXP (r) + 16383 - 1;
3491 image3 |= exp << 16;
3493 if (HOST_BITS_PER_LONG == 32)
3498 image3 |= u.sig[3] & 0xffff;
3503 image1 = image0 >> 31 >> 1;
3505 image3 |= (image2 >> 31 >> 1) & 0xffff;
3506 image0 &= 0xffffffff;
3507 image2 &= 0xffffffff;
3515 if (FLOAT_WORDS_BIG_ENDIAN)
3532 decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3535 unsigned long image3, image2, image1, image0;
3539 if (FLOAT_WORDS_BIG_ENDIAN)
3553 image0 &= 0xffffffff;
3554 image1 &= 0xffffffff;
3555 image2 &= 0xffffffff;
3557 sign = (image3 >> 31) & 1;
3558 exp = (image3 >> 16) & 0x7fff;
3561 memset (r, 0, sizeof (*r));
3565 if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
3570 SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
3571 if (HOST_BITS_PER_LONG == 32)
3580 r->sig[0] = (image1 << 31 << 1) | image0;
3581 r->sig[1] = (image3 << 31 << 1) | image2;
3586 else if (fmt->has_signed_zero)
3589 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3591 if (image3 | image2 | image1 | image0)
3595 r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set;
3597 if (HOST_BITS_PER_LONG == 32)
3606 r->sig[0] = (image1 << 31 << 1) | image0;
3607 r->sig[1] = (image3 << 31 << 1) | image2;
3609 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3621 SET_REAL_EXP (r, exp - 16383 + 1);
3623 if (HOST_BITS_PER_LONG == 32)
3632 r->sig[0] = (image1 << 31 << 1) | image0;
3633 r->sig[1] = (image3 << 31 << 1) | image2;
3635 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3636 r->sig[SIGSZ-1] |= SIG_MSB;
3640 const struct real_format ieee_quad_format =
3658 const struct real_format mips_quad_format =
3676 /* Descriptions of VAX floating point formats can be found beginning at
3678 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
3680 The thing to remember is that they're almost IEEE, except for word
3681 order, exponent bias, and the lack of infinities, nans, and denormals.
3683 We don't implement the H_floating format here, simply because neither
3684 the VAX or Alpha ports use it. */
3686 static void encode_vax_f (const struct real_format *fmt,
3687 long *, const REAL_VALUE_TYPE *);
3688 static void decode_vax_f (const struct real_format *,
3689 REAL_VALUE_TYPE *, const long *);
3690 static void encode_vax_d (const struct real_format *fmt,
3691 long *, const REAL_VALUE_TYPE *);
3692 static void decode_vax_d (const struct real_format *,
3693 REAL_VALUE_TYPE *, const long *);
3694 static void encode_vax_g (const struct real_format *fmt,
3695 long *, const REAL_VALUE_TYPE *);
3696 static void decode_vax_g (const struct real_format *,
3697 REAL_VALUE_TYPE *, const long *);
3700 encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
3701 const REAL_VALUE_TYPE *r)
3703 unsigned long sign, exp, sig, image;
3705 sign = r->sign << 15;
3715 image = 0xffff7fff | sign;
3719 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
3720 exp = REAL_EXP (r) + 128;
3722 image = (sig << 16) & 0xffff0000;
3736 decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED,
3737 REAL_VALUE_TYPE *r, const long *buf)
3739 unsigned long image = buf[0] & 0xffffffff;
3740 int exp = (image >> 7) & 0xff;
3742 memset (r, 0, sizeof (*r));
3747 r->sign = (image >> 15) & 1;
3748 SET_REAL_EXP (r, exp - 128);
3750 image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff);
3751 r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
3756 encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
3757 const REAL_VALUE_TYPE *r)
3759 unsigned long image0, image1, sign = r->sign << 15;
3764 image0 = image1 = 0;
3769 image0 = 0xffff7fff | sign;
3770 image1 = 0xffffffff;
3774 /* Extract the significand into straight hi:lo. */
3775 if (HOST_BITS_PER_LONG == 64)
3777 image0 = r->sig[SIGSZ-1];
3778 image1 = (image0 >> (64 - 56)) & 0xffffffff;
3779 image0 = (image0 >> (64 - 56 + 1) >> 31) & 0x7fffff;
3783 image0 = r->sig[SIGSZ-1];
3784 image1 = r->sig[SIGSZ-2];
3785 image1 = (image0 << 24) | (image1 >> 8);
3786 image0 = (image0 >> 8) & 0xffffff;
3789 /* Rearrange the half-words of the significand to match the
3791 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff007f;
3792 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
3794 /* Add the sign and exponent. */
3796 image0 |= (REAL_EXP (r) + 128) << 7;
3803 if (FLOAT_WORDS_BIG_ENDIAN)
3804 buf[0] = image1, buf[1] = image0;
3806 buf[0] = image0, buf[1] = image1;
3810 decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED,
3811 REAL_VALUE_TYPE *r, const long *buf)
3813 unsigned long image0, image1;
3816 if (FLOAT_WORDS_BIG_ENDIAN)
3817 image1 = buf[0], image0 = buf[1];
3819 image0 = buf[0], image1 = buf[1];
3820 image0 &= 0xffffffff;
3821 image1 &= 0xffffffff;
3823 exp = (image0 >> 7) & 0xff;
3825 memset (r, 0, sizeof (*r));
3830 r->sign = (image0 >> 15) & 1;
3831 SET_REAL_EXP (r, exp - 128);
3833 /* Rearrange the half-words of the external format into
3834 proper ascending order. */
3835 image0 = ((image0 & 0x7f) << 16) | ((image0 >> 16) & 0xffff);
3836 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
3838 if (HOST_BITS_PER_LONG == 64)
3840 image0 = (image0 << 31 << 1) | image1;
3843 r->sig[SIGSZ-1] = image0;
3847 r->sig[SIGSZ-1] = image0;
3848 r->sig[SIGSZ-2] = image1;
3849 lshift_significand (r, r, 2*HOST_BITS_PER_LONG - 56);
3850 r->sig[SIGSZ-1] |= SIG_MSB;
3856 encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
3857 const REAL_VALUE_TYPE *r)
3859 unsigned long image0, image1, sign = r->sign << 15;
3864 image0 = image1 = 0;
3869 image0 = 0xffff7fff | sign;
3870 image1 = 0xffffffff;
3874 /* Extract the significand into straight hi:lo. */
3875 if (HOST_BITS_PER_LONG == 64)
3877 image0 = r->sig[SIGSZ-1];
3878 image1 = (image0 >> (64 - 53)) & 0xffffffff;
3879 image0 = (image0 >> (64 - 53 + 1) >> 31) & 0xfffff;
3883 image0 = r->sig[SIGSZ-1];
3884 image1 = r->sig[SIGSZ-2];
3885 image1 = (image0 << 21) | (image1 >> 11);
3886 image0 = (image0 >> 11) & 0xfffff;
3889 /* Rearrange the half-words of the significand to match the
3891 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff000f;
3892 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
3894 /* Add the sign and exponent. */
3896 image0 |= (REAL_EXP (r) + 1024) << 4;
3903 if (FLOAT_WORDS_BIG_ENDIAN)
3904 buf[0] = image1, buf[1] = image0;
3906 buf[0] = image0, buf[1] = image1;
3910 decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED,
3911 REAL_VALUE_TYPE *r, const long *buf)
3913 unsigned long image0, image1;
3916 if (FLOAT_WORDS_BIG_ENDIAN)
3917 image1 = buf[0], image0 = buf[1];
3919 image0 = buf[0], image1 = buf[1];
3920 image0 &= 0xffffffff;
3921 image1 &= 0xffffffff;
3923 exp = (image0 >> 4) & 0x7ff;
3925 memset (r, 0, sizeof (*r));
3930 r->sign = (image0 >> 15) & 1;
3931 SET_REAL_EXP (r, exp - 1024);
3933 /* Rearrange the half-words of the external format into
3934 proper ascending order. */
3935 image0 = ((image0 & 0xf) << 16) | ((image0 >> 16) & 0xffff);
3936 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
3938 if (HOST_BITS_PER_LONG == 64)
3940 image0 = (image0 << 31 << 1) | image1;
3943 r->sig[SIGSZ-1] = image0;
3947 r->sig[SIGSZ-1] = image0;
3948 r->sig[SIGSZ-2] = image1;
3949 lshift_significand (r, r, 64 - 53);
3950 r->sig[SIGSZ-1] |= SIG_MSB;
3955 const struct real_format vax_f_format =
3973 const struct real_format vax_d_format =
3991 const struct real_format vax_g_format =
4009 /* A good reference for these can be found in chapter 9 of
4010 "ESA/390 Principles of Operation", IBM document number SA22-7201-01.
4011 An on-line version can be found here:
4013 http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/DZ9AR001/9.1?DT=19930923083613
4016 static void encode_i370_single (const struct real_format *fmt,
4017 long *, const REAL_VALUE_TYPE *);
4018 static void decode_i370_single (const struct real_format *,
4019 REAL_VALUE_TYPE *, const long *);
4020 static void encode_i370_double (const struct real_format *fmt,
4021 long *, const REAL_VALUE_TYPE *);
4022 static void decode_i370_double (const struct real_format *,
4023 REAL_VALUE_TYPE *, const long *);
4026 encode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4027 long *buf, const REAL_VALUE_TYPE *r)
4029 unsigned long sign, exp, sig, image;
4031 sign = r->sign << 31;
4041 image = 0x7fffffff | sign;
4045 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0xffffff;
4046 exp = ((REAL_EXP (r) / 4) + 64) << 24;
4047 image = sign | exp | sig;
4058 decode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4059 REAL_VALUE_TYPE *r, const long *buf)
4061 unsigned long sign, sig, image = buf[0];
4064 sign = (image >> 31) & 1;
4065 exp = (image >> 24) & 0x7f;
4066 sig = image & 0xffffff;
4068 memset (r, 0, sizeof (*r));
4074 SET_REAL_EXP (r, (exp - 64) * 4);
4075 r->sig[SIGSZ-1] = sig << (HOST_BITS_PER_LONG - 24);
4081 encode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4082 long *buf, const REAL_VALUE_TYPE *r)
4084 unsigned long sign, exp, image_hi, image_lo;
4086 sign = r->sign << 31;
4091 image_hi = image_lo = 0;
4096 image_hi = 0x7fffffff | sign;
4097 image_lo = 0xffffffff;
4101 if (HOST_BITS_PER_LONG == 64)
4103 image_hi = r->sig[SIGSZ-1];
4104 image_lo = (image_hi >> (64 - 56)) & 0xffffffff;
4105 image_hi = (image_hi >> (64 - 56 + 1) >> 31) & 0xffffff;
4109 image_hi = r->sig[SIGSZ-1];
4110 image_lo = r->sig[SIGSZ-2];
4111 image_lo = (image_lo >> 8) | (image_hi << 24);
4115 exp = ((REAL_EXP (r) / 4) + 64) << 24;
4116 image_hi |= sign | exp;
4123 if (FLOAT_WORDS_BIG_ENDIAN)
4124 buf[0] = image_hi, buf[1] = image_lo;
4126 buf[0] = image_lo, buf[1] = image_hi;
4130 decode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4131 REAL_VALUE_TYPE *r, const long *buf)
4133 unsigned long sign, image_hi, image_lo;
4136 if (FLOAT_WORDS_BIG_ENDIAN)
4137 image_hi = buf[0], image_lo = buf[1];
4139 image_lo = buf[0], image_hi = buf[1];
4141 sign = (image_hi >> 31) & 1;
4142 exp = (image_hi >> 24) & 0x7f;
4143 image_hi &= 0xffffff;
4144 image_lo &= 0xffffffff;
4146 memset (r, 0, sizeof (*r));
4148 if (exp || image_hi || image_lo)
4152 SET_REAL_EXP (r, (exp - 64) * 4 + (SIGNIFICAND_BITS - 56));
4154 if (HOST_BITS_PER_LONG == 32)
4156 r->sig[0] = image_lo;
4157 r->sig[1] = image_hi;
4160 r->sig[0] = image_lo | (image_hi << 31 << 1);
4166 const struct real_format i370_single_format =
4179 false, /* ??? The encoding does allow for "unnormals". */
4180 false, /* ??? The encoding does allow for "unnormals". */
4184 const struct real_format i370_double_format =
4197 false, /* ??? The encoding does allow for "unnormals". */
4198 false, /* ??? The encoding does allow for "unnormals". */
4202 /* The "twos-complement" c4x format is officially defined as
4206 This is rather misleading. One must remember that F is signed.
4207 A better description would be
4209 x = -1**s * ((s + 1 + .f) * 2**e
4211 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
4212 that's -1 * (1+1+(-.5)) == -1.5. I think.
4214 The constructions here are taken from Tables 5-1 and 5-2 of the
4215 TMS320C4x User's Guide wherein step-by-step instructions for
4216 conversion from IEEE are presented. That's close enough to our
4217 internal representation so as to make things easy.
4219 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
4221 static void encode_c4x_single (const struct real_format *fmt,
4222 long *, const REAL_VALUE_TYPE *);
4223 static void decode_c4x_single (const struct real_format *,
4224 REAL_VALUE_TYPE *, const long *);
4225 static void encode_c4x_extended (const struct real_format *fmt,
4226 long *, const REAL_VALUE_TYPE *);
4227 static void decode_c4x_extended (const struct real_format *,
4228 REAL_VALUE_TYPE *, const long *);
4231 encode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4232 long *buf, const REAL_VALUE_TYPE *r)
4234 unsigned long image, exp, sig;
4246 sig = 0x800000 - r->sign;
4250 exp = REAL_EXP (r) - 1;
4251 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
4266 image = ((exp & 0xff) << 24) | (sig & 0xffffff);
4271 decode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4272 REAL_VALUE_TYPE *r, const long *buf)
4274 unsigned long image = buf[0];
4278 exp = (((image >> 24) & 0xff) ^ 0x80) - 0x80;
4279 sf = ((image & 0xffffff) ^ 0x800000) - 0x800000;
4281 memset (r, 0, sizeof (*r));
4287 sig = sf & 0x7fffff;
4296 sig = (sig << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
4298 SET_REAL_EXP (r, exp + 1);
4299 r->sig[SIGSZ-1] = sig;
4304 encode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
4305 long *buf, const REAL_VALUE_TYPE *r)
4307 unsigned long exp, sig;
4319 sig = 0x80000000 - r->sign;
4323 exp = REAL_EXP (r) - 1;
4325 sig = r->sig[SIGSZ-1];
4326 if (HOST_BITS_PER_LONG == 64)
4327 sig = sig >> 1 >> 31;
4344 exp = (exp & 0xff) << 24;
4347 if (FLOAT_WORDS_BIG_ENDIAN)
4348 buf[0] = exp, buf[1] = sig;
4350 buf[0] = sig, buf[0] = exp;
4354 decode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
4355 REAL_VALUE_TYPE *r, const long *buf)
4360 if (FLOAT_WORDS_BIG_ENDIAN)
4361 exp = buf[0], sf = buf[1];
4363 sf = buf[0], exp = buf[1];
4365 exp = (((exp >> 24) & 0xff) & 0x80) - 0x80;
4366 sf = ((sf & 0xffffffff) ^ 0x80000000) - 0x80000000;
4368 memset (r, 0, sizeof (*r));
4374 sig = sf & 0x7fffffff;
4383 if (HOST_BITS_PER_LONG == 64)
4384 sig = sig << 1 << 31;
4387 SET_REAL_EXP (r, exp + 1);
4388 r->sig[SIGSZ-1] = sig;
4392 const struct real_format c4x_single_format =
4410 const struct real_format c4x_extended_format =
4412 encode_c4x_extended,
4413 decode_c4x_extended,
4429 /* A synthetic "format" for internal arithmetic. It's the size of the
4430 internal significand minus the two bits needed for proper rounding.
4431 The encode and decode routines exist only to satisfy our paranoia
4434 static void encode_internal (const struct real_format *fmt,
4435 long *, const REAL_VALUE_TYPE *);
4436 static void decode_internal (const struct real_format *,
4437 REAL_VALUE_TYPE *, const long *);
4440 encode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4441 const REAL_VALUE_TYPE *r)
4443 memcpy (buf, r, sizeof (*r));
4447 decode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED,
4448 REAL_VALUE_TYPE *r, const long *buf)
4450 memcpy (r, buf, sizeof (*r));
4453 const struct real_format real_internal_format =
4459 SIGNIFICAND_BITS - 2,
4460 SIGNIFICAND_BITS - 2,
4471 /* Calculate the square root of X in mode MODE, and store the result
4472 in R. Return TRUE if the operation does not raise an exception.
4473 For details see "High Precision Division and Square Root",
4474 Alan H. Karp and Peter Markstein, HP Lab Report 93-93-42, June
4475 1993. http://www.hpl.hp.com/techreports/93/HPL-93-42.pdf. */
4478 real_sqrt (REAL_VALUE_TYPE *r, enum machine_mode mode,
4479 const REAL_VALUE_TYPE *x)
4481 static REAL_VALUE_TYPE halfthree;
4482 static bool init = false;
4483 REAL_VALUE_TYPE h, t, i;
4486 /* sqrt(-0.0) is -0.0. */
4487 if (real_isnegzero (x))
4493 /* Negative arguments return NaN. */
4496 get_canonical_qnan (r, 0);
4500 /* Infinity and NaN return themselves. */
4501 if (real_isinf (x) || real_isnan (x))
4509 do_add (&halfthree, &dconst1, &dconsthalf, 0);
4513 /* Initial guess for reciprocal sqrt, i. */
4514 exp = real_exponent (x);
4515 real_ldexp (&i, &dconst1, -exp/2);
4517 /* Newton's iteration for reciprocal sqrt, i. */
4518 for (iter = 0; iter < 16; iter++)
4520 /* i(n+1) = i(n) * (1.5 - 0.5*i(n)*i(n)*x). */
4521 do_multiply (&t, x, &i);
4522 do_multiply (&h, &t, &i);
4523 do_multiply (&t, &h, &dconsthalf);
4524 do_add (&h, &halfthree, &t, 1);
4525 do_multiply (&t, &i, &h);
4527 /* Check for early convergence. */
4528 if (iter >= 6 && real_identical (&i, &t))
4531 /* ??? Unroll loop to avoid copying. */
4535 /* Final iteration: r = i*x + 0.5*i*x*(1.0 - i*(i*x)). */
4536 do_multiply (&t, x, &i);
4537 do_multiply (&h, &t, &i);
4538 do_add (&i, &dconst1, &h, 1);
4539 do_multiply (&h, &t, &i);
4540 do_multiply (&i, &dconsthalf, &h);
4541 do_add (&h, &t, &i, 0);
4543 /* ??? We need a Tuckerman test to get the last bit. */
4545 real_convert (r, mode, &h);
4549 /* Calculate X raised to the integer exponent N in mode MODE and store
4550 the result in R. Return true if the result may be inexact due to
4551 loss of precision. The algorithm is the classic "left-to-right binary
4552 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
4553 Algorithms", "The Art of Computer Programming", Volume 2. */
4556 real_powi (REAL_VALUE_TYPE *r, enum machine_mode mode,
4557 const REAL_VALUE_TYPE *x, HOST_WIDE_INT n)
4559 unsigned HOST_WIDE_INT bit;
4561 bool inexact = false;
4573 /* Don't worry about overflow, from now on n is unsigned. */
4581 bit = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
4582 for (i = 0; i < HOST_BITS_PER_WIDE_INT; i++)
4586 inexact |= do_multiply (&t, &t, &t);
4588 inexact |= do_multiply (&t, &t, x);
4596 inexact |= do_divide (&t, &dconst1, &t);
4598 real_convert (r, mode, &t);
4602 /* Round X to the nearest integer not larger in absolute value, i.e.
4603 towards zero, placing the result in R in mode MODE. */
4606 real_trunc (REAL_VALUE_TYPE *r, enum machine_mode mode,
4607 const REAL_VALUE_TYPE *x)
4609 do_fix_trunc (r, x);
4610 if (mode != VOIDmode)
4611 real_convert (r, mode, r);
4614 /* Round X to the largest integer not greater in value, i.e. round
4615 down, placing the result in R in mode MODE. */
4618 real_floor (REAL_VALUE_TYPE *r, enum machine_mode mode,
4619 const REAL_VALUE_TYPE *x)
4623 do_fix_trunc (&t, x);
4624 if (! real_identical (&t, x) && x->sign)
4625 do_add (&t, &t, &dconstm1, 0);
4626 if (mode != VOIDmode)
4627 real_convert (r, mode, &t);
4630 /* Round X to the smallest integer not less then argument, i.e. round
4631 up, placing the result in R in mode MODE. */
4634 real_ceil (REAL_VALUE_TYPE *r, enum machine_mode mode,
4635 const REAL_VALUE_TYPE *x)
4639 do_fix_trunc (&t, x);
4640 if (! real_identical (&t, x) && ! x->sign)
4641 do_add (&t, &t, &dconst1, 0);
4642 if (mode != VOIDmode)
4643 real_convert (r, mode, &t);
4646 /* Round X to the nearest integer, but round halfway cases away from
4650 real_round (REAL_VALUE_TYPE *r, enum machine_mode mode,
4651 const REAL_VALUE_TYPE *x)
4653 do_add (r, x, &dconsthalf, x->sign);
4654 do_fix_trunc (r, r);
4655 if (mode != VOIDmode)
4656 real_convert (r, mode, r);
4659 /* Set the sign of R to the sign of X. */
4662 real_copysign (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *x)