1 /* real.c - software floating point emulation.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2002 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
31 /* The floating point model used internally is not exactly IEEE 754
32 compliant, and close to the description in the ISO C standard,
33 section 5.2.4.2.2 Characteristics of floating types.
37 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
41 b = base or radix, here always 2
43 p = precision (the number of base-b digits in the significand)
44 f_k = the digits of the significand.
46 We differ from typical IEEE 754 encodings in that the entire
47 significand is fractional. Normalized significands are in the
50 A requirement of the model is that P be larger than than the
51 largest supported target floating-point type by at least 2 bits.
52 This gives us proper rounding when we truncate to the target type.
53 In addition, E must be large enough to hold the smallest supported
54 denormal number in a normalized form.
56 Both of these requirements are easily satisfied. The largest target
57 significand is 113 bits; we store at least 160. The smallest
58 denormal number fits in 17 exponent bits; we store 29.
60 Note that the decimal string conversion routines are sensitive to
61 rounding error. Since the raw arithmetic routines do not themselves
62 have guard digits or rounding, the computation of 10**exp can
63 accumulate more than a few digits of error. The previous incarnation
64 of real.c successfully used a 144 bit fraction; given the current
65 layout of REAL_VALUE_TYPE we're forced to expand to at least 160 bits.
67 Target floating point models that use base 16 instead of base 2
68 (i.e. IBM 370), are handled during round_for_format, in which we
69 canonicalize the exponent to be a multiple of 4 (log2(16)), and
70 adjust the significand to match. */
73 /* Used to classify two numbers simultaneously. */
74 #define CLASS2(A, B) ((A) << 2 | (B))
76 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
77 #error "Some constant folding done by hand to avoid shift count warnings"
80 static void get_zero PARAMS ((REAL_VALUE_TYPE *, int));
81 static void get_canonical_qnan PARAMS ((REAL_VALUE_TYPE *, int));
82 static void get_canonical_snan PARAMS ((REAL_VALUE_TYPE *, int));
83 static void get_inf PARAMS ((REAL_VALUE_TYPE *, int));
84 static bool sticky_rshift_significand PARAMS ((REAL_VALUE_TYPE *,
85 const REAL_VALUE_TYPE *,
87 static void rshift_significand PARAMS ((REAL_VALUE_TYPE *,
88 const REAL_VALUE_TYPE *,
90 static void lshift_significand PARAMS ((REAL_VALUE_TYPE *,
91 const REAL_VALUE_TYPE *,
93 static void lshift_significand_1 PARAMS ((REAL_VALUE_TYPE *,
94 const REAL_VALUE_TYPE *));
95 static bool add_significands PARAMS ((REAL_VALUE_TYPE *r,
96 const REAL_VALUE_TYPE *,
97 const REAL_VALUE_TYPE *));
98 static bool sub_significands PARAMS ((REAL_VALUE_TYPE *,
99 const REAL_VALUE_TYPE *,
100 const REAL_VALUE_TYPE *, int));
101 static void neg_significand PARAMS ((REAL_VALUE_TYPE *,
102 const REAL_VALUE_TYPE *));
103 static int cmp_significands PARAMS ((const REAL_VALUE_TYPE *,
104 const REAL_VALUE_TYPE *));
105 static int cmp_significand_0 PARAMS ((const REAL_VALUE_TYPE *));
106 static void set_significand_bit PARAMS ((REAL_VALUE_TYPE *, unsigned int));
107 static void clear_significand_bit PARAMS ((REAL_VALUE_TYPE *, unsigned int));
108 static bool test_significand_bit PARAMS ((REAL_VALUE_TYPE *, unsigned int));
109 static void clear_significand_below PARAMS ((REAL_VALUE_TYPE *,
111 static bool div_significands PARAMS ((REAL_VALUE_TYPE *,
112 const REAL_VALUE_TYPE *,
113 const REAL_VALUE_TYPE *));
114 static void normalize PARAMS ((REAL_VALUE_TYPE *));
116 static void do_add PARAMS ((REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
117 const REAL_VALUE_TYPE *, int));
118 static void do_multiply PARAMS ((REAL_VALUE_TYPE *,
119 const REAL_VALUE_TYPE *,
120 const REAL_VALUE_TYPE *));
121 static void do_divide PARAMS ((REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
122 const REAL_VALUE_TYPE *));
123 static int do_compare PARAMS ((const REAL_VALUE_TYPE *,
124 const REAL_VALUE_TYPE *, int));
125 static void do_fix_trunc PARAMS ((REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *));
127 static unsigned long rtd_divmod PARAMS ((REAL_VALUE_TYPE *,
130 static const REAL_VALUE_TYPE * ten_to_ptwo PARAMS ((int));
131 static const REAL_VALUE_TYPE * ten_to_mptwo PARAMS ((int));
132 static const REAL_VALUE_TYPE * real_digit PARAMS ((int));
133 static void times_pten PARAMS ((REAL_VALUE_TYPE *, int));
135 static void round_for_format PARAMS ((const struct real_format *,
138 /* Initialize R with a positive zero. */
145 memset (r, 0, sizeof (*r));
149 /* Initialize R with the canonical quiet NaN. */
152 get_canonical_qnan (r, sign)
156 memset (r, 0, sizeof (*r));
159 r->sig[SIGSZ-1] = SIG_MSB >> 1;
163 get_canonical_snan (r, sign)
167 memset (r, 0, sizeof (*r));
170 r->sig[SIGSZ-1] = SIG_MSB >> 2;
178 memset (r, 0, sizeof (*r));
184 /* Right-shift the significand of A by N bits; put the result in the
185 significand of R. If any one bits are shifted out, return true. */
188 sticky_rshift_significand (r, a, n)
190 const REAL_VALUE_TYPE *a;
193 unsigned long sticky = 0;
194 unsigned int i, ofs = 0;
196 if (n >= HOST_BITS_PER_LONG)
198 for (i = 0, ofs = n / HOST_BITS_PER_LONG; i < ofs; ++i)
200 n &= HOST_BITS_PER_LONG - 1;
205 sticky |= a->sig[ofs] & (((unsigned long)1 << n) - 1);
206 for (i = 0; i < SIGSZ; ++i)
209 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
210 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
211 << (HOST_BITS_PER_LONG - n)));
216 for (i = 0; ofs + i < SIGSZ; ++i)
217 r->sig[i] = a->sig[ofs + i];
218 for (; i < SIGSZ; ++i)
225 /* Right-shift the significand of A by N bits; put the result in the
229 rshift_significand (r, a, n)
231 const REAL_VALUE_TYPE *a;
234 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
236 n &= HOST_BITS_PER_LONG - 1;
239 for (i = 0; i < SIGSZ; ++i)
242 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
243 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
244 << (HOST_BITS_PER_LONG - n)));
249 for (i = 0; ofs + i < SIGSZ; ++i)
250 r->sig[i] = a->sig[ofs + i];
251 for (; i < SIGSZ; ++i)
256 /* Left-shift the significand of A by N bits; put the result in the
260 lshift_significand (r, a, n)
262 const REAL_VALUE_TYPE *a;
265 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
267 n &= HOST_BITS_PER_LONG - 1;
270 for (i = 0; ofs + i < SIGSZ; ++i)
271 r->sig[SIGSZ-1-i] = a->sig[SIGSZ-1-i-ofs];
272 for (; i < SIGSZ; ++i)
273 r->sig[SIGSZ-1-i] = 0;
276 for (i = 0; i < SIGSZ; ++i)
279 = (((ofs + i >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs]) << n)
280 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs-1])
281 >> (HOST_BITS_PER_LONG - n)));
285 /* Likewise, but N is specialized to 1. */
288 lshift_significand_1 (r, a)
290 const REAL_VALUE_TYPE *a;
294 for (i = SIGSZ - 1; i > 0; --i)
295 r->sig[i] = (a->sig[i] << 1) | (a->sig[i-1] >> (HOST_BITS_PER_LONG - 1));
296 r->sig[0] = a->sig[0] << 1;
299 /* Add the significands of A and B, placing the result in R. Return
300 true if there was carry out of the most significant word. */
303 add_significands (r, a, b)
305 const REAL_VALUE_TYPE *a, *b;
310 for (i = 0; i < SIGSZ; ++i)
312 unsigned long ai = a->sig[i];
313 unsigned long ri = ai + b->sig[i];
329 /* Subtract the significands of A and B, placing the result in R. CARRY is
330 true if there's a borrow incoming to the least significant word.
331 Return true if there was borrow out of the most significant word. */
334 sub_significands (r, a, b, carry)
336 const REAL_VALUE_TYPE *a, *b;
341 for (i = 0; i < SIGSZ; ++i)
343 unsigned long ai = a->sig[i];
344 unsigned long ri = ai - b->sig[i];
360 /* Negate the significand A, placing the result in R. */
363 neg_significand (r, a)
365 const REAL_VALUE_TYPE *a;
370 for (i = 0; i < SIGSZ; ++i)
372 unsigned long ri, ai = a->sig[i];
391 /* Compare significands. Return tri-state vs zero. */
394 cmp_significands (a, b)
395 const REAL_VALUE_TYPE *a, *b;
399 for (i = SIGSZ - 1; i >= 0; --i)
401 unsigned long ai = a->sig[i];
402 unsigned long bi = b->sig[i];
413 /* Return true if A is non-zero. */
416 cmp_significand_0 (a)
417 const REAL_VALUE_TYPE *a;
421 for (i = SIGSZ - 1; i >= 0; --i)
428 /* Set bit N of the significand of R. */
431 set_significand_bit (r, n)
435 r->sig[n / HOST_BITS_PER_LONG]
436 |= (unsigned long)1 << (n % HOST_BITS_PER_LONG);
439 /* Clear bit N of the significand of R. */
442 clear_significand_bit (r, n)
446 r->sig[n / HOST_BITS_PER_LONG]
447 &= ~((unsigned long)1 << (n % HOST_BITS_PER_LONG));
450 /* Test bit N of the significand of R. */
453 test_significand_bit (r, n)
457 /* ??? Compiler bug here if we return this expression directly.
458 The conversion to bool strips the "&1" and we wind up testing
459 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
460 int t = (r->sig[n / HOST_BITS_PER_LONG] >> (n % HOST_BITS_PER_LONG)) & 1;
464 /* Clear bits 0..N-1 of the significand of R. */
467 clear_significand_below (r, n)
471 int i, w = n / HOST_BITS_PER_LONG;
473 for (i = 0; i < w; ++i)
476 r->sig[w] &= ~(((unsigned long)1 << (n % HOST_BITS_PER_LONG)) - 1);
479 /* Divide the significands of A and B, placing the result in R. Return
480 true if the division was inexact. */
483 div_significands (r, a, b)
485 const REAL_VALUE_TYPE *a, *b;
488 int i, bit = SIGNIFICAND_BITS - 1;
489 unsigned long msb, inexact;
492 memset (r->sig, 0, sizeof (r->sig));
498 msb = u.sig[SIGSZ-1] & SIG_MSB;
499 lshift_significand_1 (&u, &u);
501 if (msb || cmp_significands (&u, b) >= 0)
503 sub_significands (&u, &u, b, 0);
504 set_significand_bit (r, bit);
509 for (i = 0, inexact = 0; i < SIGSZ; i++)
515 /* Adjust the exponent and significand of R such that the most
516 significant bit is set. We underflow to zero and overflow to
517 infinity here, without denormals. (The intermediate representation
518 exponent is large enough to handle target denormals normalized.) */
527 /* Find the first word that is nonzero. */
528 for (i = SIGSZ - 1; i >= 0; i--)
530 shift += HOST_BITS_PER_LONG;
534 /* Zero significand flushes to zero. */
542 /* Find the first bit that is nonzero. */
544 if (r->sig[i] & ((unsigned long)1 << (HOST_BITS_PER_LONG - 1 - j)))
550 exp = r->exp - shift;
552 get_inf (r, r->sign);
553 else if (exp < -MAX_EXP)
554 get_zero (r, r->sign);
558 lshift_significand (r, r, shift);
563 /* Return R = A + (SUBTRACT_P ? -B : B). */
566 do_add (r, a, b, subtract_p)
568 const REAL_VALUE_TYPE *a, *b;
573 bool inexact = false;
575 /* Determine if we need to add or subtract. */
577 subtract_p = (sign ^ b->sign) ^ subtract_p;
579 switch (CLASS2 (a->class, b->class))
581 case CLASS2 (rvc_zero, rvc_zero):
582 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
583 get_zero (r, sign & !subtract_p);
586 case CLASS2 (rvc_zero, rvc_normal):
587 case CLASS2 (rvc_zero, rvc_inf):
588 case CLASS2 (rvc_zero, rvc_nan):
590 case CLASS2 (rvc_normal, rvc_nan):
591 case CLASS2 (rvc_inf, rvc_nan):
592 case CLASS2 (rvc_nan, rvc_nan):
593 /* ANY + NaN = NaN. */
594 case CLASS2 (rvc_normal, rvc_inf):
597 r->sign = sign ^ subtract_p;
600 case CLASS2 (rvc_normal, rvc_zero):
601 case CLASS2 (rvc_inf, rvc_zero):
602 case CLASS2 (rvc_nan, rvc_zero):
604 case CLASS2 (rvc_nan, rvc_normal):
605 case CLASS2 (rvc_nan, rvc_inf):
606 /* NaN + ANY = NaN. */
607 case CLASS2 (rvc_inf, rvc_normal):
612 case CLASS2 (rvc_inf, rvc_inf):
614 /* Inf - Inf = NaN. */
615 get_canonical_qnan (r, 0);
617 /* Inf + Inf = Inf. */
621 case CLASS2 (rvc_normal, rvc_normal):
628 /* Swap the arguments such that A has the larger exponent. */
629 dexp = a->exp - b->exp;
632 const REAL_VALUE_TYPE *t;
639 /* If the exponents are not identical, we need to shift the
640 significand of B down. */
643 /* If the exponents are too far apart, the significands
644 do not overlap, which makes the subtraction a noop. */
645 if (dexp >= SIGNIFICAND_BITS)
652 inexact |= sticky_rshift_significand (&t, b, dexp);
658 if (sub_significands (r, a, b, inexact))
660 /* We got a borrow out of the subtraction. That means that
661 A and B had the same exponent, and B had the larger
662 significand. We need to swap the sign and negate the
665 neg_significand (r, r);
670 if (add_significands (r, a, b))
672 /* We got carry out of the addition. This means we need to
673 shift the significand back down one bit and increase the
675 inexact |= sticky_rshift_significand (r, r, 1);
676 r->sig[SIGSZ-1] |= SIG_MSB;
685 r->class = rvc_normal;
689 /* Re-normalize the result. */
692 /* Special case: if the subtraction results in zero, the result
694 if (r->class == rvc_zero)
697 r->sig[0] |= inexact;
700 /* Return R = A * B. */
703 do_multiply (r, a, b)
705 const REAL_VALUE_TYPE *a, *b;
707 REAL_VALUE_TYPE u, t, *rr;
708 unsigned int i, j, k;
709 int sign = a->sign ^ b->sign;
711 switch (CLASS2 (a->class, b->class))
713 case CLASS2 (rvc_zero, rvc_zero):
714 case CLASS2 (rvc_zero, rvc_normal):
715 case CLASS2 (rvc_normal, rvc_zero):
716 /* +-0 * ANY = 0 with appropriate sign. */
720 case CLASS2 (rvc_zero, rvc_nan):
721 case CLASS2 (rvc_normal, rvc_nan):
722 case CLASS2 (rvc_inf, rvc_nan):
723 case CLASS2 (rvc_nan, rvc_nan):
724 /* ANY * NaN = NaN. */
729 case CLASS2 (rvc_nan, rvc_zero):
730 case CLASS2 (rvc_nan, rvc_normal):
731 case CLASS2 (rvc_nan, rvc_inf):
732 /* NaN * ANY = NaN. */
737 case CLASS2 (rvc_zero, rvc_inf):
738 case CLASS2 (rvc_inf, rvc_zero):
740 get_canonical_qnan (r, sign);
743 case CLASS2 (rvc_inf, rvc_inf):
744 case CLASS2 (rvc_normal, rvc_inf):
745 case CLASS2 (rvc_inf, rvc_normal):
746 /* Inf * Inf = Inf, R * Inf = Inf */
751 case CLASS2 (rvc_normal, rvc_normal):
758 if (r == a || r == b)
764 /* Collect all the partial products. Since we don't have sure access
765 to a widening multiply, we split each long into two half-words.
767 Consider the long-hand form of a four half-word multiplication:
777 We construct partial products of the widened half-word products
778 that are known to not overlap, e.g. DF+DH. Each such partial
779 product is given its proper exponent, which allows us to sum them
780 and obtain the finished product. */
782 for (i = 0; i < SIGSZ * 2; ++i)
784 unsigned long ai = a->sig[i / 2];
786 ai >>= HOST_BITS_PER_LONG / 2;
788 ai &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
793 for (j = 0; j < 2; ++j)
795 int exp = (a->exp - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2)
796 + (b->exp - (1-j)*(HOST_BITS_PER_LONG/2)));
801 /* Would underflow to zero, which we shouldn't bother adding. */
804 u.class = rvc_normal;
808 for (k = j; k < SIGSZ * 2; k += 2)
810 unsigned long bi = b->sig[k / 2];
812 bi >>= HOST_BITS_PER_LONG / 2;
814 bi &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
816 u.sig[k / 2] = ai * bi;
820 do_add (rr, rr, &u, 0);
829 /* Return R = A / B. */
834 const REAL_VALUE_TYPE *a, *b;
836 int exp, sign = a->sign ^ b->sign;
837 REAL_VALUE_TYPE t, *rr;
840 switch (CLASS2 (a->class, b->class))
842 case CLASS2 (rvc_zero, rvc_zero):
844 case CLASS2 (rvc_inf, rvc_inf):
845 /* Inf / Inf = NaN. */
846 get_canonical_qnan (r, sign);
849 case CLASS2 (rvc_zero, rvc_normal):
850 case CLASS2 (rvc_zero, rvc_inf):
852 case CLASS2 (rvc_normal, rvc_inf):
858 case CLASS2 (rvc_normal, rvc_zero):
860 case CLASS2 (rvc_inf, rvc_zero):
865 case CLASS2 (rvc_zero, rvc_nan):
866 case CLASS2 (rvc_normal, rvc_nan):
867 case CLASS2 (rvc_inf, rvc_nan):
868 case CLASS2 (rvc_nan, rvc_nan):
869 /* ANY / NaN = NaN. */
874 case CLASS2 (rvc_nan, rvc_zero):
875 case CLASS2 (rvc_nan, rvc_normal):
876 case CLASS2 (rvc_nan, rvc_inf):
877 /* NaN / ANY = NaN. */
882 case CLASS2 (rvc_inf, rvc_normal):
888 case CLASS2 (rvc_normal, rvc_normal):
895 if (r == a || r == b)
900 rr->class = rvc_normal;
903 exp = a->exp - b->exp + 1;
910 inexact = div_significands (rr, a, b);
912 /* Re-normalize the result. */
914 rr->sig[0] |= inexact;
920 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
921 one of the two operands is a NaN. */
924 do_compare (a, b, nan_result)
925 const REAL_VALUE_TYPE *a, *b;
930 switch (CLASS2 (a->class, b->class))
932 case CLASS2 (rvc_zero, rvc_zero):
933 /* Sign of zero doesn't matter for compares. */
936 case CLASS2 (rvc_inf, rvc_zero):
937 case CLASS2 (rvc_inf, rvc_normal):
938 case CLASS2 (rvc_normal, rvc_zero):
939 return (a->sign ? -1 : 1);
941 case CLASS2 (rvc_inf, rvc_inf):
942 return -a->sign - -b->sign;
944 case CLASS2 (rvc_zero, rvc_normal):
945 case CLASS2 (rvc_zero, rvc_inf):
946 case CLASS2 (rvc_normal, rvc_inf):
947 return (b->sign ? 1 : -1);
949 case CLASS2 (rvc_zero, rvc_nan):
950 case CLASS2 (rvc_normal, rvc_nan):
951 case CLASS2 (rvc_inf, rvc_nan):
952 case CLASS2 (rvc_nan, rvc_nan):
953 case CLASS2 (rvc_nan, rvc_zero):
954 case CLASS2 (rvc_nan, rvc_normal):
955 case CLASS2 (rvc_nan, rvc_inf):
958 case CLASS2 (rvc_normal, rvc_normal):
965 if (a->sign != b->sign)
966 return -a->sign - -b->sign;
970 else if (a->exp < b->exp)
973 ret = cmp_significands (a, b);
975 return (a->sign ? -ret : ret);
978 /* Return A truncated to an integral value toward zero. */
983 const REAL_VALUE_TYPE *a;
996 get_zero (r, r->sign);
997 else if (r->exp < SIGNIFICAND_BITS)
998 clear_significand_below (r, SIGNIFICAND_BITS - r->exp);
1006 /* Perform the binary or unary operation described by CODE.
1007 For a unary operation, leave OP1 NULL. */
1010 real_arithmetic (r, icode, op0, op1)
1013 const REAL_VALUE_TYPE *op0, *op1;
1015 enum tree_code code = icode;
1020 do_add (r, op0, op1, 0);
1024 do_add (r, op0, op1, 1);
1028 do_multiply (r, op0, op1);
1032 do_divide (r, op0, op1);
1036 if (op1->class == rvc_nan)
1038 else if (do_compare (op0, op1, -1) < 0)
1045 if (op1->class == rvc_nan)
1047 else if (do_compare (op0, op1, 1) < 0)
1063 case FIX_TRUNC_EXPR:
1064 do_fix_trunc (r, op0);
1072 /* Legacy. Similar, but return the result directly. */
1075 real_arithmetic2 (icode, op0, op1)
1077 const REAL_VALUE_TYPE *op0, *op1;
1080 real_arithmetic (&r, icode, op0, op1);
1085 real_compare (icode, op0, op1)
1087 const REAL_VALUE_TYPE *op0, *op1;
1089 enum tree_code code = icode;
1094 return do_compare (op0, op1, 1) < 0;
1096 return do_compare (op0, op1, 1) <= 0;
1098 return do_compare (op0, op1, -1) > 0;
1100 return do_compare (op0, op1, -1) >= 0;
1102 return do_compare (op0, op1, -1) == 0;
1104 return do_compare (op0, op1, -1) != 0;
1105 case UNORDERED_EXPR:
1106 return op0->class == rvc_nan || op1->class == rvc_nan;
1108 return op0->class != rvc_nan && op1->class != rvc_nan;
1110 return do_compare (op0, op1, -1) < 0;
1112 return do_compare (op0, op1, -1) <= 0;
1114 return do_compare (op0, op1, 1) > 0;
1116 return do_compare (op0, op1, 1) >= 0;
1118 return do_compare (op0, op1, 0) == 0;
1125 /* Return floor log2(R). */
1129 const REAL_VALUE_TYPE *r;
1137 return (unsigned int)-1 >> 1;
1145 /* R = OP0 * 2**EXP. */
1148 real_ldexp (r, op0, exp)
1150 const REAL_VALUE_TYPE *op0;
1164 get_inf (r, r->sign);
1165 else if (exp < -MAX_EXP)
1166 get_zero (r, r->sign);
1176 /* Determine whether a floating-point value X is infinite. */
1180 const REAL_VALUE_TYPE *r;
1182 return (r->class == rvc_inf);
1185 /* Determine whether a floating-point value X is a NaN. */
1189 const REAL_VALUE_TYPE *r;
1191 return (r->class == rvc_nan);
1194 /* Determine whether a floating-point value X is negative. */
1198 const REAL_VALUE_TYPE *r;
1203 /* Determine whether a floating-point value X is minus zero. */
1207 const REAL_VALUE_TYPE *r;
1209 return r->sign && r->class == rvc_zero;
1212 /* Compare two floating-point objects for bitwise identity. */
1215 real_identical (a, b)
1216 const REAL_VALUE_TYPE *a, *b;
1220 if (a->class != b->class)
1222 if (a->sign != b->sign)
1232 if (a->exp != b->exp)
1236 for (i = 0; i < SIGSZ; ++i)
1237 if (a->sig[i] != b->sig[i])
1248 /* Try to change R into its exact multiplicative inverse in machine
1249 mode MODE. Return true if successful. */
1252 exact_real_inverse (mode, r)
1253 enum machine_mode mode;
1256 const REAL_VALUE_TYPE *one = real_digit (1);
1260 if (r->class != rvc_normal)
1263 /* Check for a power of two: all significand bits zero except the MSB. */
1264 for (i = 0; i < SIGSZ-1; ++i)
1267 if (r->sig[SIGSZ-1] != SIG_MSB)
1270 /* Find the inverse and truncate to the required mode. */
1271 do_divide (&u, one, r);
1272 real_convert (&u, mode, &u);
1274 /* The rounding may have overflowed. */
1275 if (u.class != rvc_normal)
1277 for (i = 0; i < SIGSZ-1; ++i)
1280 if (u.sig[SIGSZ-1] != SIG_MSB)
1287 /* Render R as an integer. */
1291 const REAL_VALUE_TYPE *r;
1293 unsigned HOST_WIDE_INT i;
1304 i = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1312 if (r->exp > HOST_BITS_PER_WIDE_INT)
1315 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1316 i = r->sig[SIGSZ-1];
1317 else if (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG)
1319 i = r->sig[SIGSZ-1];
1320 i = i << (HOST_BITS_PER_LONG - 1) << 1;
1321 i |= r->sig[SIGSZ-2];
1326 i >>= HOST_BITS_PER_WIDE_INT - r->exp;
1337 /* Likewise, but to an integer pair, HI+LOW. */
1340 real_to_integer2 (plow, phigh, r)
1341 HOST_WIDE_INT *plow, *phigh;
1342 const REAL_VALUE_TYPE *r;
1345 HOST_WIDE_INT low, high;
1358 high = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1372 if (exp >= 2*HOST_BITS_PER_WIDE_INT)
1375 rshift_significand (&t, r, 2*HOST_BITS_PER_WIDE_INT - exp);
1376 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1378 high = t.sig[SIGSZ-1];
1379 low = t.sig[SIGSZ-2];
1381 else if (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG)
1383 high = t.sig[SIGSZ-1];
1384 high = high << (HOST_BITS_PER_LONG - 1) << 1;
1385 high |= t.sig[SIGSZ-2];
1387 low = t.sig[SIGSZ-3];
1388 low = low << (HOST_BITS_PER_LONG - 1) << 1;
1389 low |= t.sig[SIGSZ-4];
1399 low = -low, high = ~high;
1411 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1412 of NUM / DEN. Return the quotient and place the remainder in NUM.
1413 It is expected that NUM / DEN are close enough that the quotient is
1416 static unsigned long
1417 rtd_divmod (num, den)
1418 REAL_VALUE_TYPE *num, *den;
1420 unsigned long q, msb;
1421 int expn = num->exp, expd = den->exp;
1430 msb = num->sig[SIGSZ-1] & SIG_MSB;
1432 lshift_significand_1 (num, num);
1434 if (msb || cmp_significands (num, den) >= 0)
1436 sub_significands (num, num, den, 0);
1440 while (--expn >= expd);
1448 /* Render R as a decimal floating point constant. Emit DIGITS significant
1449 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1450 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1453 #define M_LOG10_2 0.30102999566398119521
1456 real_to_decimal (str, r_orig, buf_size, digits, crop_trailing_zeros)
1458 const REAL_VALUE_TYPE *r_orig;
1459 size_t buf_size, digits;
1460 int crop_trailing_zeros;
1462 const REAL_VALUE_TYPE *one, *ten;
1463 REAL_VALUE_TYPE r, pten, u, v;
1464 int dec_exp, cmp_one, digit;
1466 char *p, *first, *last;
1473 strcpy (str, (r.sign ? "-0.0" : "0.0"));
1478 strcpy (str, (r.sign ? "-Inf" : "+Inf"));
1481 /* ??? Print the significand as well, if not canonical? */
1482 strcpy (str, (r.sign ? "-NaN" : "+NaN"));
1488 /* Estimate the decimal exponent, and compute the length of the string it
1489 will print as. Be conservative and add one to account for possible
1490 overflow or rounding error. */
1491 dec_exp = r.exp * M_LOG10_2;
1492 for (max_digits = 1; dec_exp ; max_digits++)
1495 /* Bound the number of digits printed by the size of the output buffer. */
1496 max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
1497 if (max_digits > buf_size)
1499 if (digits > max_digits)
1500 digits = max_digits;
1502 /* Bound the number of digits printed by the size of the representation. */
1503 max_digits = SIGNIFICAND_BITS * M_LOG10_2;
1504 if (digits == 0 || digits > max_digits)
1505 digits = max_digits;
1507 one = real_digit (1);
1508 ten = ten_to_ptwo (0);
1516 cmp_one = do_compare (&r, one, 0);
1521 /* Number is greater than one. Convert significand to an integer
1522 and strip trailing decimal zeros. */
1525 u.exp = SIGNIFICAND_BITS - 1;
1527 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1528 m = floor_log2 (max_digits);
1530 /* Iterate over the bits of the possible powers of 10 that might
1531 be present in U and eliminate them. That is, if we find that
1532 10**2**M divides U evenly, keep the division and increase
1538 do_divide (&t, &u, ten_to_ptwo (m));
1539 do_fix_trunc (&v, &t);
1540 if (cmp_significands (&v, &t) == 0)
1548 /* Revert the scaling to integer that we performed earlier. */
1549 u.exp += r.exp - (SIGNIFICAND_BITS - 1);
1552 /* Find power of 10. Do this by dividing out 10**2**M when
1553 this is larger than the current remainder. Fill PTEN with
1554 the power of 10 that we compute. */
1555 m = floor_log2 ((int)(r.exp * M_LOG10_2)) + 1;
1558 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1559 if (do_compare (&u, ptentwo, 0) >= 0)
1561 do_divide (&u, &u, ptentwo);
1562 do_multiply (&pten, &pten, ptentwo);
1568 else if (cmp_one < 0)
1572 /* Number is less than one. Pad significand with leading
1578 /* Stop if we'd shift bits off the bottom. */
1582 do_multiply (&u, &v, ten);
1584 /* Stop if we're now >= 1. */
1593 /* Find power of 10. Do this by multiplying in P=10**2**M when
1594 the current remainder is smaller than 1/P. Fill PTEN with the
1595 power of 10 that we compute. */
1596 m = floor_log2 ((int)(-r.exp * M_LOG10_2)) + 1;
1599 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1600 const REAL_VALUE_TYPE *ptenmtwo = ten_to_mptwo (m);
1602 if (do_compare (&v, ptenmtwo, 0) <= 0)
1604 do_multiply (&v, &v, ptentwo);
1605 do_multiply (&pten, &pten, ptentwo);
1611 /* Invert the positive power of 10 that we've collected so far. */
1612 do_divide (&pten, one, &pten);
1620 /* At this point, PTEN should contain the nearest power of 10 smaller
1621 than R, such that this division produces the first digit.
1623 Using a divide-step primitive that returns the complete integral
1624 remainder avoids the rounding error that would be produced if
1625 we were to use do_divide here and then simply multiply by 10 for
1626 each subsequent digit. */
1628 digit = rtd_divmod (&r, &pten);
1630 /* Be prepared for error in that division via underflow ... */
1631 if (digit == 0 && cmp_significand_0 (&r))
1633 /* Multiply by 10 and try again. */
1634 do_multiply (&r, &r, ten);
1635 digit = rtd_divmod (&r, &pten);
1641 /* ... or overflow. */
1649 else if (digit > 10)
1654 /* Generate subsequent digits. */
1655 while (--digits > 0)
1657 do_multiply (&r, &r, ten);
1658 digit = rtd_divmod (&r, &pten);
1663 /* Generate one more digit with which to do rounding. */
1664 do_multiply (&r, &r, ten);
1665 digit = rtd_divmod (&r, &pten);
1667 /* Round the result. */
1670 /* Round to nearest. If R is non-zero there are additional
1671 non-zero digits to be extracted. */
1672 if (cmp_significand_0 (&r))
1674 /* Round to even. */
1675 else if ((p[-1] - '0') & 1)
1692 /* Carry out of the first digit. This means we had all 9's and
1693 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1701 /* Insert the decimal point. */
1702 first[0] = first[1];
1705 /* If requested, drop trailing zeros. Never crop past "1.0". */
1706 if (crop_trailing_zeros)
1707 while (last > first + 3 && last[-1] == '0')
1710 /* Append the exponent. */
1711 sprintf (last, "e%+d", dec_exp);
1714 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1715 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1716 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1717 strip trailing zeros. */
1720 real_to_hexadecimal (str, r, buf_size, digits, crop_trailing_zeros)
1722 const REAL_VALUE_TYPE *r;
1723 size_t buf_size, digits;
1724 int crop_trailing_zeros;
1726 int i, j, exp = r->exp;
1739 strcpy (str, (r->sign ? "-Inf" : "+Inf"));
1742 /* ??? Print the significand as well, if not canonical? */
1743 strcpy (str, (r->sign ? "-NaN" : "+NaN"));
1750 digits = SIGNIFICAND_BITS / 4;
1752 /* Bound the number of digits printed by the size of the output buffer. */
1754 sprintf (exp_buf, "p%+d", exp);
1755 max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1;
1756 if (max_digits > buf_size)
1758 if (digits > max_digits)
1759 digits = max_digits;
1770 for (i = SIGSZ - 1; i >= 0; --i)
1771 for (j = HOST_BITS_PER_LONG - 4; j >= 0; j -= 4)
1773 *p++ = "0123456789abcdef"[(r->sig[i] >> j) & 15];
1779 if (crop_trailing_zeros)
1780 while (p > first + 1 && p[-1] == '0')
1783 sprintf (p, "p%+d", exp);
1786 /* Initialize R from a decimal or hexadecimal string. The string is
1787 assumed to have been syntax checked already. */
1790 real_from_string (r, str)
1804 else if (*str == '+')
1807 if (str[0] == '0' && str[1] == 'x')
1809 /* Hexadecimal floating point. */
1810 int pos = SIGNIFICAND_BITS - 4, d;
1818 d = hex_value (*str);
1823 r->sig[pos / HOST_BITS_PER_LONG]
1824 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1833 if (pos == SIGNIFICAND_BITS - 4)
1840 d = hex_value (*str);
1845 r->sig[pos / HOST_BITS_PER_LONG]
1846 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1852 if (*str == 'p' || *str == 'P')
1854 bool exp_neg = false;
1862 else if (*str == '+')
1866 while (ISDIGIT (*str))
1872 /* Overflowed the exponent. */
1886 r->class = rvc_normal;
1893 /* Decimal floating point. */
1894 const REAL_VALUE_TYPE *ten = ten_to_ptwo (0);
1899 while (ISDIGIT (*str))
1902 do_multiply (r, r, ten);
1904 do_add (r, r, real_digit (d), 0);
1909 if (r->class == rvc_zero)
1914 while (ISDIGIT (*str))
1917 do_multiply (r, r, ten);
1919 do_add (r, r, real_digit (d), 0);
1924 if (*str == 'e' || *str == 'E')
1926 bool exp_neg = false;
1934 else if (*str == '+')
1938 while (ISDIGIT (*str))
1944 /* Overflowed the exponent. */
1958 times_pten (r, exp);
1973 /* Legacy. Similar, but return the result directly. */
1976 real_from_string2 (s, mode)
1978 enum machine_mode mode;
1982 real_from_string (&r, s);
1983 if (mode != VOIDmode)
1984 real_convert (&r, mode, &r);
1989 /* Initialize R from the integer pair HIGH+LOW. */
1992 real_from_integer (r, mode, low, high, unsigned_p)
1994 enum machine_mode mode;
1995 unsigned HOST_WIDE_INT low;
1999 if (low == 0 && high == 0)
2003 r->class = rvc_normal;
2004 r->sign = high < 0 && !unsigned_p;
2005 r->exp = 2 * HOST_BITS_PER_WIDE_INT;
2016 if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT)
2018 r->sig[SIGSZ-1] = high;
2019 r->sig[SIGSZ-2] = low;
2020 memset (r->sig, 0, sizeof(long)*(SIGSZ-2));
2022 else if (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT)
2024 r->sig[SIGSZ-1] = high >> (HOST_BITS_PER_LONG - 1) >> 1;
2025 r->sig[SIGSZ-2] = high;
2026 r->sig[SIGSZ-3] = low >> (HOST_BITS_PER_LONG - 1) >> 1;
2027 r->sig[SIGSZ-4] = low;
2029 memset (r->sig, 0, sizeof(long)*(SIGSZ-4));
2037 if (mode != VOIDmode)
2038 real_convert (r, mode, r);
2041 /* Returns 10**2**N. */
2043 static const REAL_VALUE_TYPE *
2047 static REAL_VALUE_TYPE tens[EXP_BITS];
2049 if (n < 0 || n >= EXP_BITS)
2052 if (tens[n].class == rvc_zero)
2054 if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
2056 HOST_WIDE_INT t = 10;
2059 for (i = 0; i < n; ++i)
2062 real_from_integer (&tens[n], VOIDmode, t, 0, 1);
2066 const REAL_VALUE_TYPE *t = ten_to_ptwo (n - 1);
2067 do_multiply (&tens[n], t, t);
2074 /* Returns 10**(-2**N). */
2076 static const REAL_VALUE_TYPE *
2080 static REAL_VALUE_TYPE tens[EXP_BITS];
2082 if (n < 0 || n >= EXP_BITS)
2085 if (tens[n].class == rvc_zero)
2086 do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
2093 static const REAL_VALUE_TYPE *
2097 static REAL_VALUE_TYPE num[10];
2102 if (n > 0 && num[n].class == rvc_zero)
2103 real_from_integer (&num[n], VOIDmode, n, 0, 1);
2108 /* Multiply R by 10**EXP. */
2115 REAL_VALUE_TYPE pten, *rr;
2116 bool negative = (exp < 0);
2122 pten = *real_digit (1);
2128 for (i = 0; exp > 0; ++i, exp >>= 1)
2130 do_multiply (rr, rr, ten_to_ptwo (i));
2133 do_divide (r, r, &pten);
2136 /* Fills R with +Inf. */
2145 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2146 we force a QNaN, else we force an SNaN. The string, if not empty,
2147 is parsed as a number and placed in the significand. Return true
2148 if the string was successfully parsed. */
2151 real_nan (r, str, quiet, mode)
2155 enum machine_mode mode;
2157 const struct real_format *fmt;
2159 fmt = real_format_for_mode[mode - QFmode];
2166 get_canonical_qnan (r, 0);
2168 get_canonical_snan (r, 0);
2175 memset (r, 0, sizeof (*r));
2178 /* Parse akin to strtol into the significand of R. */
2180 while (ISSPACE (*str))
2184 else if (*str == '+')
2194 while ((d = hex_value (*str)) < base)
2201 lshift_significand (r, r, 3);
2204 lshift_significand (r, r, 4);
2207 lshift_significand_1 (&u, r);
2208 lshift_significand (r, r, 3);
2209 add_significands (r, r, &u);
2217 add_significands (r, r, &u);
2222 /* Must have consumed the entire string for success. */
2226 /* Shift the significand into place such that the bits
2227 are in the most significant bits for the format. */
2228 lshift_significand (r, r, SIGNIFICAND_BITS - fmt->p);
2230 /* Our MSB is always unset for NaNs. */
2231 r->sig[SIGSZ-1] &= ~SIG_MSB;
2233 /* Force quiet or signalling NaN. */
2235 r->sig[SIGSZ-1] |= SIG_MSB >> 1;
2237 r->sig[SIGSZ-1] &= ~(SIG_MSB >> 1);
2239 /* Force at least one bit of the significand set. */
2240 for (d = 0; d < SIGSZ; ++d)
2244 r->sig[SIGSZ-1] |= SIG_MSB >> 2;
2246 /* Our intermediate format forces QNaNs to have MSB-1 set.
2247 If the target format has QNaNs with the top bit unset,
2248 mirror the output routines and invert the top two bits. */
2249 if (!fmt->qnan_msb_set)
2250 r->sig[SIGSZ-1] ^= (SIG_MSB >> 1) | (SIG_MSB >> 2);
2256 /* Fills R with 2**N. */
2263 memset (r, 0, sizeof (*r));
2268 else if (n < -MAX_EXP)
2272 r->class = rvc_normal;
2274 r->sig[SIGSZ-1] = SIG_MSB;
2280 round_for_format (fmt, r)
2281 const struct real_format *fmt;
2285 unsigned long sticky;
2289 p2 = fmt->p * fmt->log2_b;
2290 emin2m1 = (fmt->emin - 1) * fmt->log2_b;
2291 emax2 = fmt->emax * fmt->log2_b;
2293 np2 = SIGNIFICAND_BITS - p2;
2297 get_zero (r, r->sign);
2299 if (!fmt->has_signed_zero)
2304 get_inf (r, r->sign);
2309 clear_significand_below (r, np2);
2311 /* If we've cleared the entire significand, we need one bit
2312 set for this to continue to be a NaN. */
2313 for (i = 0; i < SIGSZ; ++i)
2317 r->sig[SIGSZ-1] = SIG_MSB >> 2;
2327 /* If we're not base2, normalize the exponent to a multiple of
2329 if (fmt->log2_b != 1)
2331 int shift = r->exp & (fmt->log2_b - 1);
2334 shift = fmt->log2_b - shift;
2335 r->sig[0] |= sticky_rshift_significand (r, r, shift);
2340 /* Check the range of the exponent. If we're out of range,
2341 either underflow or overflow. */
2344 else if (r->exp <= emin2m1)
2348 if (!fmt->has_denorm)
2350 /* Don't underflow completely until we've had a chance to round. */
2351 if (r->exp < emin2m1)
2356 diff = emin2m1 - r->exp + 1;
2360 /* De-normalize the significand. */
2361 r->sig[0] |= sticky_rshift_significand (r, r, diff);
2366 /* There are P2 true significand bits, followed by one guard bit,
2367 followed by one sticky bit, followed by stuff. Fold nonzero
2368 stuff into the sticky bit. */
2371 for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
2372 sticky |= r->sig[i];
2374 r->sig[w] & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
2376 guard = test_significand_bit (r, np2 - 1);
2377 lsb = test_significand_bit (r, np2);
2379 /* Round to even. */
2380 if (guard && (sticky || lsb))
2384 set_significand_bit (&u, np2);
2386 if (add_significands (r, r, &u))
2388 /* Overflow. Means the significand had been all ones, and
2389 is now all zeros. Need to increase the exponent, and
2390 possibly re-normalize it. */
2391 if (++r->exp > emax2)
2393 r->sig[SIGSZ-1] = SIG_MSB;
2395 if (fmt->log2_b != 1)
2397 int shift = r->exp & (fmt->log2_b - 1);
2400 shift = fmt->log2_b - shift;
2401 rshift_significand (r, r, shift);
2410 /* Catch underflow that we deferred until after rounding. */
2411 if (r->exp <= emin2m1)
2414 /* Clear out trailing garbage. */
2415 clear_significand_below (r, np2);
2418 /* Extend or truncate to a new mode. */
2421 real_convert (r, mode, a)
2423 enum machine_mode mode;
2424 const REAL_VALUE_TYPE *a;
2426 const struct real_format *fmt;
2428 fmt = real_format_for_mode[mode - QFmode];
2433 round_for_format (fmt, r);
2435 /* round_for_format de-normalizes denormals. Undo just that part. */
2436 if (r->class == rvc_normal)
2440 /* Legacy. Likewise, except return the struct directly. */
2443 real_value_truncate (mode, a)
2444 enum machine_mode mode;
2448 real_convert (&r, mode, &a);
2452 /* Return true if truncating to MODE is exact. */
2455 exact_real_truncate (mode, a)
2456 enum machine_mode mode;
2457 const REAL_VALUE_TYPE *a;
2460 real_convert (&t, mode, a);
2461 return real_identical (&t, a);
2464 /* Write R to the given target format. Place the words of the result
2465 in target word order in BUF. There are always 32 bits in each
2466 long, no matter the size of the host long.
2468 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2471 real_to_target_fmt (buf, r_orig, fmt)
2473 const REAL_VALUE_TYPE *r_orig;
2474 const struct real_format *fmt;
2480 round_for_format (fmt, &r);
2484 (*fmt->encode) (fmt, buf, &r);
2489 /* Similar, but look up the format from MODE. */
2492 real_to_target (buf, r, mode)
2494 const REAL_VALUE_TYPE *r;
2495 enum machine_mode mode;
2497 const struct real_format *fmt;
2499 fmt = real_format_for_mode[mode - QFmode];
2503 return real_to_target_fmt (buf, r, fmt);
2506 /* Read R from the given target format. Read the words of the result
2507 in target word order in BUF. There are always 32 bits in each
2508 long, no matter the size of the host long. */
2511 real_from_target_fmt (r, buf, fmt)
2514 const struct real_format *fmt;
2516 (*fmt->decode) (fmt, r, buf);
2519 /* Similar, but look up the format from MODE. */
2522 real_from_target (r, buf, mode)
2525 enum machine_mode mode;
2527 const struct real_format *fmt;
2529 fmt = real_format_for_mode[mode - QFmode];
2533 (*fmt->decode) (fmt, r, buf);
2536 /* Return the number of bits in the significand for MODE. */
2537 /* ??? Legacy. Should get access to real_format directly. */
2540 significand_size (mode)
2541 enum machine_mode mode;
2543 const struct real_format *fmt;
2545 fmt = real_format_for_mode[mode - QFmode];
2549 return fmt->p * fmt->log2_b;
2552 /* Return a hash value for the given real value. */
2553 /* ??? The "unsigned int" return value is intended to be hashval_t,
2554 but I didn't want to pull hashtab.h into real.h. */
2558 const REAL_VALUE_TYPE *r;
2563 h = r->class | (r->sign << 2);
2575 if (sizeof(unsigned long) > sizeof(unsigned int))
2576 for (i = 0; i < SIGSZ; ++i)
2578 unsigned long s = r->sig[i];
2579 h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2));
2582 for (i = 0; i < SIGSZ; ++i)
2593 /* IEEE single-precision format. */
2595 static void encode_ieee_single PARAMS ((const struct real_format *fmt,
2596 long *, const REAL_VALUE_TYPE *));
2597 static void decode_ieee_single PARAMS ((const struct real_format *,
2598 REAL_VALUE_TYPE *, const long *));
2601 encode_ieee_single (fmt, buf, r)
2602 const struct real_format *fmt;
2604 const REAL_VALUE_TYPE *r;
2606 unsigned long image, sig, exp;
2607 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2609 image = r->sign << 31;
2610 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
2621 image |= 0x7fffffff;
2629 if (!fmt->qnan_msb_set)
2630 image ^= 1 << 23 | 1 << 22;
2633 image |= 0x7fffffff;
2637 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2638 whereas the intermediate representation is 0.F x 2**exp.
2639 Which means we're off by one. */
2643 exp = r->exp + 127 - 1;
2656 decode_ieee_single (fmt, r, buf)
2657 const struct real_format *fmt;
2661 unsigned long image = buf[0] & 0xffffffff;
2662 bool sign = (image >> 31) & 1;
2663 int exp = (image >> 23) & 0xff;
2665 memset (r, 0, sizeof (*r));
2666 image <<= HOST_BITS_PER_LONG - 24;
2671 if (image && fmt->has_denorm)
2673 r->class = rvc_normal;
2676 r->sig[SIGSZ-1] = image << 1;
2679 else if (fmt->has_signed_zero)
2682 else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
2688 if (!fmt->qnan_msb_set)
2689 image ^= (SIG_MSB >> 1 | SIG_MSB >> 2);
2690 r->sig[SIGSZ-1] = image;
2700 r->class = rvc_normal;
2702 r->exp = exp - 127 + 1;
2703 r->sig[SIGSZ-1] = image | SIG_MSB;
2707 const struct real_format ieee_single_format =
2724 /* IEEE double-precision format. */
2726 static void encode_ieee_double PARAMS ((const struct real_format *fmt,
2727 long *, const REAL_VALUE_TYPE *));
2728 static void decode_ieee_double PARAMS ((const struct real_format *,
2729 REAL_VALUE_TYPE *, const long *));
2732 encode_ieee_double (fmt, buf, r)
2733 const struct real_format *fmt;
2735 const REAL_VALUE_TYPE *r;
2737 unsigned long image_lo, image_hi, sig_lo, sig_hi, exp;
2738 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2740 image_hi = r->sign << 31;
2743 if (HOST_BITS_PER_LONG == 64)
2745 sig_hi = r->sig[SIGSZ-1];
2746 sig_lo = (sig_hi >> (64 - 53)) & 0xffffffff;
2747 sig_hi = (sig_hi >> (64 - 53 + 1) >> 31) & 0xfffff;
2751 sig_hi = r->sig[SIGSZ-1];
2752 sig_lo = r->sig[SIGSZ-2];
2753 sig_lo = (sig_hi << 21) | (sig_lo >> 11);
2754 sig_hi = (sig_hi >> 11) & 0xfffff;
2764 image_hi |= 2047 << 20;
2767 image_hi |= 0x7fffffff;
2768 image_lo = 0xffffffff;
2775 image_hi |= 2047 << 20;
2777 if (!fmt->qnan_msb_set)
2778 image_hi ^= 1 << 19 | 1 << 18;
2783 image_hi |= 0x7fffffff;
2784 image_lo = 0xffffffff;
2789 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2790 whereas the intermediate representation is 0.F x 2**exp.
2791 Which means we're off by one. */
2795 exp = r->exp + 1023 - 1;
2796 image_hi |= exp << 20;
2805 if (FLOAT_WORDS_BIG_ENDIAN)
2806 buf[0] = image_hi, buf[1] = image_lo;
2808 buf[0] = image_lo, buf[1] = image_hi;
2812 decode_ieee_double (fmt, r, buf)
2813 const struct real_format *fmt;
2817 unsigned long image_hi, image_lo;
2821 if (FLOAT_WORDS_BIG_ENDIAN)
2822 image_hi = buf[0], image_lo = buf[1];
2824 image_lo = buf[0], image_hi = buf[1];
2825 image_lo &= 0xffffffff;
2826 image_hi &= 0xffffffff;
2828 sign = (image_hi >> 31) & 1;
2829 exp = (image_hi >> 20) & 0x7ff;
2831 memset (r, 0, sizeof (*r));
2833 image_hi <<= 32 - 21;
2834 image_hi |= image_lo >> 21;
2835 image_hi &= 0x7fffffff;
2836 image_lo <<= 32 - 21;
2840 if ((image_hi || image_lo) && fmt->has_denorm)
2842 r->class = rvc_normal;
2845 if (HOST_BITS_PER_LONG == 32)
2847 image_hi = (image_hi << 1) | (image_lo >> 31);
2849 r->sig[SIGSZ-1] = image_hi;
2850 r->sig[SIGSZ-2] = image_lo;
2854 image_hi = (image_hi << 31 << 2) | (image_lo << 1);
2855 r->sig[SIGSZ-1] = image_hi;
2859 else if (fmt->has_signed_zero)
2862 else if (exp == 2047 && (fmt->has_nans || fmt->has_inf))
2864 if (image_hi || image_lo)
2868 if (HOST_BITS_PER_LONG == 32)
2870 r->sig[SIGSZ-1] = image_hi;
2871 r->sig[SIGSZ-2] = image_lo;
2874 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo;
2876 if (!fmt->qnan_msb_set)
2877 r->sig[SIGSZ-1] ^= (SIG_MSB >> 1 | SIG_MSB >> 2);
2887 r->class = rvc_normal;
2889 r->exp = exp - 1023 + 1;
2890 if (HOST_BITS_PER_LONG == 32)
2892 r->sig[SIGSZ-1] = image_hi | SIG_MSB;
2893 r->sig[SIGSZ-2] = image_lo;
2896 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo | SIG_MSB;
2900 const struct real_format ieee_double_format =
2917 /* IEEE extended double precision format. This comes in three
2918 flavours: Intel's as a 12 byte image, Intel's as a 16 byte image,
2921 static void encode_ieee_extended PARAMS ((const struct real_format *fmt,
2922 long *, const REAL_VALUE_TYPE *));
2923 static void decode_ieee_extended PARAMS ((const struct real_format *,
2924 REAL_VALUE_TYPE *, const long *));
2926 static void encode_ieee_extended_128 PARAMS ((const struct real_format *fmt,
2928 const REAL_VALUE_TYPE *));
2929 static void decode_ieee_extended_128 PARAMS ((const struct real_format *,
2934 encode_ieee_extended (fmt, buf, r)
2935 const struct real_format *fmt;
2937 const REAL_VALUE_TYPE *r;
2939 unsigned long image_hi, sig_hi, sig_lo;
2940 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2942 image_hi = r->sign << 15;
2943 sig_hi = sig_lo = 0;
2955 /* Intel requires the explicit integer bit to be set, otherwise
2956 it considers the value a "pseudo-infinity". Motorola docs
2957 say it doesn't care. */
2958 sig_hi = 0x80000000;
2963 sig_lo = sig_hi = 0xffffffff;
2971 if (HOST_BITS_PER_LONG == 32)
2973 sig_hi = r->sig[SIGSZ-1];
2974 sig_lo = r->sig[SIGSZ-2];
2978 sig_lo = r->sig[SIGSZ-1];
2979 sig_hi = sig_lo >> 31 >> 1;
2980 sig_lo &= 0xffffffff;
2982 if (!fmt->qnan_msb_set)
2983 sig_hi ^= 1 << 30 | 1 << 29;
2985 /* Intel requires the explicit integer bit to be set, otherwise
2986 it considers the value a "pseudo-nan". Motorola docs say it
2988 sig_hi |= 0x80000000;
2993 sig_lo = sig_hi = 0xffffffff;
3001 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3002 whereas the intermediate representation is 0.F x 2**exp.
3003 Which means we're off by one.
3005 Except for Motorola, which consider exp=0 and explicit
3006 integer bit set to continue to be normalized. In theory
3007 this descrepency has been taken care of by the difference
3008 in fmt->emin in round_for_format. */
3020 if (HOST_BITS_PER_LONG == 32)
3022 sig_hi = r->sig[SIGSZ-1];
3023 sig_lo = r->sig[SIGSZ-2];
3027 sig_lo = r->sig[SIGSZ-1];
3028 sig_hi = sig_lo >> 31 >> 1;
3029 sig_lo &= 0xffffffff;
3038 if (FLOAT_WORDS_BIG_ENDIAN)
3039 buf[0] = image_hi << 16, buf[1] = sig_hi, buf[2] = sig_lo;
3041 buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
3045 encode_ieee_extended_128 (fmt, buf, r)
3046 const struct real_format *fmt;
3048 const REAL_VALUE_TYPE *r;
3050 buf[3 * !FLOAT_WORDS_BIG_ENDIAN] = 0;
3051 encode_ieee_extended (fmt, buf+!!FLOAT_WORDS_BIG_ENDIAN, r);
3055 decode_ieee_extended (fmt, r, buf)
3056 const struct real_format *fmt;
3060 unsigned long image_hi, sig_hi, sig_lo;
3064 if (FLOAT_WORDS_BIG_ENDIAN)
3065 image_hi = buf[0] >> 16, sig_hi = buf[1], sig_lo = buf[2];
3067 sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
3068 sig_lo &= 0xffffffff;
3069 sig_hi &= 0xffffffff;
3070 image_hi &= 0xffffffff;
3072 sign = (image_hi >> 15) & 1;
3073 exp = image_hi & 0x7fff;
3075 memset (r, 0, sizeof (*r));
3079 if ((sig_hi || sig_lo) && fmt->has_denorm)
3081 r->class = rvc_normal;
3084 /* When the IEEE format contains a hidden bit, we know that
3085 it's zero at this point, and so shift up the significand
3086 and decrease the exponent to match. In this case, Motorola
3087 defines the explicit integer bit to be valid, so we don't
3088 know whether the msb is set or not. */
3090 if (HOST_BITS_PER_LONG == 32)
3092 r->sig[SIGSZ-1] = sig_hi;
3093 r->sig[SIGSZ-2] = sig_lo;
3096 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3100 else if (fmt->has_signed_zero)
3103 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3105 /* See above re "pseudo-infinities" and "pseudo-nans".
3106 Short summary is that the MSB will likely always be
3107 set, and that we don't care about it. */
3108 sig_hi &= 0x7fffffff;
3110 if (sig_hi || sig_lo)
3114 if (HOST_BITS_PER_LONG == 32)
3116 r->sig[SIGSZ-1] = sig_hi;
3117 r->sig[SIGSZ-2] = sig_lo;
3120 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3122 if (!fmt->qnan_msb_set)
3123 r->sig[SIGSZ-1] ^= (SIG_MSB >> 1 | SIG_MSB >> 2);
3133 r->class = rvc_normal;
3135 r->exp = exp - 16383 + 1;
3136 if (HOST_BITS_PER_LONG == 32)
3138 r->sig[SIGSZ-1] = sig_hi;
3139 r->sig[SIGSZ-2] = sig_lo;
3142 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3147 decode_ieee_extended_128 (fmt, r, buf)
3148 const struct real_format *fmt;
3152 decode_ieee_extended (fmt, r, buf+!!FLOAT_WORDS_BIG_ENDIAN);
3155 const struct real_format ieee_extended_motorola_format =
3157 encode_ieee_extended,
3158 decode_ieee_extended,
3171 const struct real_format ieee_extended_intel_96_format =
3173 encode_ieee_extended,
3174 decode_ieee_extended,
3187 const struct real_format ieee_extended_intel_128_format =
3189 encode_ieee_extended_128,
3190 decode_ieee_extended_128,
3204 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3205 numbers whose sum is equal to the extended precision value. The number
3206 with greater magnitude is first. This format has the same magnitude
3207 range as an IEEE double precision value, but effectively 106 bits of
3208 significand precision. Infinity and NaN are represented by their IEEE
3209 double precision value stored in the first number, the second number is
3210 ignored. Zeroes, Infinities, and NaNs are set in both doubles
3211 due to precedent. */
3213 static void encode_ibm_extended PARAMS ((const struct real_format *fmt,
3214 long *, const REAL_VALUE_TYPE *));
3215 static void decode_ibm_extended PARAMS ((const struct real_format *,
3216 REAL_VALUE_TYPE *, const long *));
3219 encode_ibm_extended (fmt, buf, r)
3220 const struct real_format *fmt ATTRIBUTE_UNUSED;
3222 const REAL_VALUE_TYPE *r;
3224 REAL_VALUE_TYPE u, v;
3229 /* Both doubles have sign bit set. */
3230 buf[0] = FLOAT_WORDS_BIG_ENDIAN ? r->sign << 31 : 0;
3231 buf[1] = FLOAT_WORDS_BIG_ENDIAN ? 0 : r->sign << 31;
3238 /* Both doubles set to Inf / NaN. */
3239 encode_ieee_double (&ieee_double_format, &buf[0], r);
3245 /* u = IEEE double precision portion of significand. */
3247 clear_significand_below (&u, SIGNIFICAND_BITS - 53);
3249 /* v = remainder containing additional 53 bits of significand. */
3250 do_add (&v, r, &u, 1);
3252 encode_ieee_double (&ieee_double_format, &buf[0], &u);
3253 encode_ieee_double (&ieee_double_format, &buf[2], &v);
3262 decode_ibm_extended (fmt, r, buf)
3263 const struct real_format *fmt ATTRIBUTE_UNUSED;
3267 REAL_VALUE_TYPE u, v;
3269 decode_ieee_double (&ieee_double_format, &u, &buf[0]);
3271 if (u.class != rvc_zero && u.class != rvc_inf && u.class != rvc_nan)
3273 decode_ieee_double (&ieee_double_format, &v, &buf[2]);
3274 do_add (r, &u, &v, 0);
3280 const struct real_format ibm_extended_format =
3282 encode_ibm_extended,
3283 decode_ibm_extended,
3297 /* IEEE quad precision format. */
3299 static void encode_ieee_quad PARAMS ((const struct real_format *fmt,
3300 long *, const REAL_VALUE_TYPE *));
3301 static void decode_ieee_quad PARAMS ((const struct real_format *,
3302 REAL_VALUE_TYPE *, const long *));
3305 encode_ieee_quad (fmt, buf, r)
3306 const struct real_format *fmt;
3308 const REAL_VALUE_TYPE *r;
3310 unsigned long image3, image2, image1, image0, exp;
3311 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
3314 image3 = r->sign << 31;
3319 rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
3328 image3 |= 32767 << 16;
3331 image3 |= 0x7fffffff;
3332 image2 = 0xffffffff;
3333 image1 = 0xffffffff;
3334 image0 = 0xffffffff;
3341 image3 |= 32767 << 16;
3343 if (HOST_BITS_PER_LONG == 32)
3348 image3 |= u.sig[3] & 0xffff;
3353 image1 = image0 >> 31 >> 1;
3355 image3 |= (image2 >> 31 >> 1) & 0xffff;
3356 image0 &= 0xffffffff;
3357 image2 &= 0xffffffff;
3360 if (!fmt->qnan_msb_set)
3361 image3 ^= 1 << 15 | 1 << 14;
3365 image3 |= 0x7fffffff;
3366 image2 = 0xffffffff;
3367 image1 = 0xffffffff;
3368 image0 = 0xffffffff;
3373 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3374 whereas the intermediate representation is 0.F x 2**exp.
3375 Which means we're off by one. */
3379 exp = r->exp + 16383 - 1;
3380 image3 |= exp << 16;
3382 if (HOST_BITS_PER_LONG == 32)
3387 image3 |= u.sig[3] & 0xffff;
3392 image1 = image0 >> 31 >> 1;
3394 image3 |= (image2 >> 31 >> 1) & 0xffff;
3395 image0 &= 0xffffffff;
3396 image2 &= 0xffffffff;
3404 if (FLOAT_WORDS_BIG_ENDIAN)
3421 decode_ieee_quad (fmt, r, buf)
3422 const struct real_format *fmt;
3426 unsigned long image3, image2, image1, image0;
3430 if (FLOAT_WORDS_BIG_ENDIAN)
3444 image0 &= 0xffffffff;
3445 image1 &= 0xffffffff;
3446 image2 &= 0xffffffff;
3448 sign = (image3 >> 31) & 1;
3449 exp = (image3 >> 16) & 0x7fff;
3452 memset (r, 0, sizeof (*r));
3456 if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
3458 r->class = rvc_normal;
3461 r->exp = -16382 + (SIGNIFICAND_BITS - 112);
3462 if (HOST_BITS_PER_LONG == 32)
3471 r->sig[0] = (image1 << 31 << 1) | image0;
3472 r->sig[1] = (image3 << 31 << 1) | image2;
3477 else if (fmt->has_signed_zero)
3480 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3482 if (image3 | image2 | image1 | image0)
3487 if (HOST_BITS_PER_LONG == 32)
3496 r->sig[0] = (image1 << 31 << 1) | image0;
3497 r->sig[1] = (image3 << 31 << 1) | image2;
3499 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3501 if (!fmt->qnan_msb_set)
3502 r->sig[SIGSZ-1] ^= (SIG_MSB >> 1 | SIG_MSB >> 2);
3512 r->class = rvc_normal;
3514 r->exp = exp - 16383 + 1;
3516 if (HOST_BITS_PER_LONG == 32)
3525 r->sig[0] = (image1 << 31 << 1) | image0;
3526 r->sig[1] = (image3 << 31 << 1) | image2;
3528 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3529 r->sig[SIGSZ-1] |= SIG_MSB;
3533 const struct real_format ieee_quad_format =
3549 /* Descriptions of VAX floating point formats can be found beginning at
3551 http://www.openvms.compaq.com:8000/73final/4515/4515pro_013.html#f_floating_point_format
3553 The thing to remember is that they're almost IEEE, except for word
3554 order, exponent bias, and the lack of infinities, nans, and denormals.
3556 We don't implement the H_floating format here, simply because neither
3557 the VAX or Alpha ports use it. */
3559 static void encode_vax_f PARAMS ((const struct real_format *fmt,
3560 long *, const REAL_VALUE_TYPE *));
3561 static void decode_vax_f PARAMS ((const struct real_format *,
3562 REAL_VALUE_TYPE *, const long *));
3563 static void encode_vax_d PARAMS ((const struct real_format *fmt,
3564 long *, const REAL_VALUE_TYPE *));
3565 static void decode_vax_d PARAMS ((const struct real_format *,
3566 REAL_VALUE_TYPE *, const long *));
3567 static void encode_vax_g PARAMS ((const struct real_format *fmt,
3568 long *, const REAL_VALUE_TYPE *));
3569 static void decode_vax_g PARAMS ((const struct real_format *,
3570 REAL_VALUE_TYPE *, const long *));
3573 encode_vax_f (fmt, buf, r)
3574 const struct real_format *fmt ATTRIBUTE_UNUSED;
3576 const REAL_VALUE_TYPE *r;
3578 unsigned long sign, exp, sig, image;
3580 sign = r->sign << 15;
3590 image = 0xffff7fff | sign;
3594 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
3597 image = (sig << 16) & 0xffff0000;
3611 decode_vax_f (fmt, r, buf)
3612 const struct real_format *fmt ATTRIBUTE_UNUSED;
3616 unsigned long image = buf[0] & 0xffffffff;
3617 int exp = (image >> 7) & 0xff;
3619 memset (r, 0, sizeof (*r));
3623 r->class = rvc_normal;
3624 r->sign = (image >> 15) & 1;
3627 image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff);
3628 r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
3633 encode_vax_d (fmt, buf, r)
3634 const struct real_format *fmt ATTRIBUTE_UNUSED;
3636 const REAL_VALUE_TYPE *r;
3638 unsigned long image0, image1, sign = r->sign << 15;
3643 image0 = image1 = 0;
3648 image0 = 0xffff7fff | sign;
3649 image1 = 0xffffffff;
3653 /* Extract the significand into straight hi:lo. */
3654 if (HOST_BITS_PER_LONG == 64)
3656 image0 = r->sig[SIGSZ-1];
3657 image1 = (image0 >> (64 - 56)) & 0xffffffff;
3658 image0 = (image0 >> (64 - 56 + 1) >> 31) & 0x7fffff;
3662 image0 = r->sig[SIGSZ-1];
3663 image1 = r->sig[SIGSZ-2];
3664 image1 = (image0 << 24) | (image1 >> 8);
3665 image0 = (image0 >> 8) & 0xffffff;
3668 /* Rearrange the half-words of the significand to match the
3670 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff007f;
3671 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
3673 /* Add the sign and exponent. */
3675 image0 |= (r->exp + 128) << 7;
3682 if (FLOAT_WORDS_BIG_ENDIAN)
3683 buf[0] = image1, buf[1] = image0;
3685 buf[0] = image0, buf[1] = image1;
3689 decode_vax_d (fmt, r, buf)
3690 const struct real_format *fmt ATTRIBUTE_UNUSED;
3694 unsigned long image0, image1;
3697 if (FLOAT_WORDS_BIG_ENDIAN)
3698 image1 = buf[0], image0 = buf[1];
3700 image0 = buf[0], image1 = buf[1];
3701 image0 &= 0xffffffff;
3702 image1 &= 0xffffffff;
3704 exp = (image0 >> 7) & 0x7f;
3706 memset (r, 0, sizeof (*r));
3710 r->class = rvc_normal;
3711 r->sign = (image0 >> 15) & 1;
3714 /* Rearrange the half-words of the external format into
3715 proper ascending order. */
3716 image0 = ((image0 & 0x7f) << 16) | ((image0 >> 16) & 0xffff);
3717 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
3719 if (HOST_BITS_PER_LONG == 64)
3721 image0 = (image0 << 31 << 1) | image1;
3724 r->sig[SIGSZ-1] = image0;
3728 r->sig[SIGSZ-1] = image0;
3729 r->sig[SIGSZ-2] = image1;
3730 lshift_significand (r, r, 2*HOST_BITS_PER_LONG - 56);
3731 r->sig[SIGSZ-1] |= SIG_MSB;
3737 encode_vax_g (fmt, buf, r)
3738 const struct real_format *fmt ATTRIBUTE_UNUSED;
3740 const REAL_VALUE_TYPE *r;
3742 unsigned long image0, image1, sign = r->sign << 15;
3747 image0 = image1 = 0;
3752 image0 = 0xffff7fff | sign;
3753 image1 = 0xffffffff;
3757 /* Extract the significand into straight hi:lo. */
3758 if (HOST_BITS_PER_LONG == 64)
3760 image0 = r->sig[SIGSZ-1];
3761 image1 = (image0 >> (64 - 53)) & 0xffffffff;
3762 image0 = (image0 >> (64 - 53 + 1) >> 31) & 0xfffff;
3766 image0 = r->sig[SIGSZ-1];
3767 image1 = r->sig[SIGSZ-2];
3768 image1 = (image0 << 21) | (image1 >> 11);
3769 image0 = (image0 >> 11) & 0xfffff;
3772 /* Rearrange the half-words of the significand to match the
3774 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff000f;
3775 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
3777 /* Add the sign and exponent. */
3779 image0 |= (r->exp + 1024) << 4;
3786 if (FLOAT_WORDS_BIG_ENDIAN)
3787 buf[0] = image1, buf[1] = image0;
3789 buf[0] = image0, buf[1] = image1;
3793 decode_vax_g (fmt, r, buf)
3794 const struct real_format *fmt ATTRIBUTE_UNUSED;
3798 unsigned long image0, image1;
3801 if (FLOAT_WORDS_BIG_ENDIAN)
3802 image1 = buf[0], image0 = buf[1];
3804 image0 = buf[0], image1 = buf[1];
3805 image0 &= 0xffffffff;
3806 image1 &= 0xffffffff;
3808 exp = (image0 >> 4) & 0x7ff;
3810 memset (r, 0, sizeof (*r));
3814 r->class = rvc_normal;
3815 r->sign = (image0 >> 15) & 1;
3816 r->exp = exp - 1024;
3818 /* Rearrange the half-words of the external format into
3819 proper ascending order. */
3820 image0 = ((image0 & 0xf) << 16) | ((image0 >> 16) & 0xffff);
3821 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
3823 if (HOST_BITS_PER_LONG == 64)
3825 image0 = (image0 << 31 << 1) | image1;
3828 r->sig[SIGSZ-1] = image0;
3832 r->sig[SIGSZ-1] = image0;
3833 r->sig[SIGSZ-2] = image1;
3834 lshift_significand (r, r, 64 - 53);
3835 r->sig[SIGSZ-1] |= SIG_MSB;
3840 const struct real_format vax_f_format =
3856 const struct real_format vax_d_format =
3872 const struct real_format vax_g_format =
3888 /* A good reference for these can be found in chapter 9 of
3889 "ESA/390 Principles of Operation", IBM document number SA22-7201-01.
3890 An on-line version can be found here:
3892 http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/DZ9AR001/9.1?DT=19930923083613
3895 static void encode_i370_single PARAMS ((const struct real_format *fmt,
3896 long *, const REAL_VALUE_TYPE *));
3897 static void decode_i370_single PARAMS ((const struct real_format *,
3898 REAL_VALUE_TYPE *, const long *));
3899 static void encode_i370_double PARAMS ((const struct real_format *fmt,
3900 long *, const REAL_VALUE_TYPE *));
3901 static void decode_i370_double PARAMS ((const struct real_format *,
3902 REAL_VALUE_TYPE *, const long *));
3905 encode_i370_single (fmt, buf, r)
3906 const struct real_format *fmt ATTRIBUTE_UNUSED;
3908 const REAL_VALUE_TYPE *r;
3910 unsigned long sign, exp, sig, image;
3912 sign = r->sign << 31;
3922 image = 0x7fffffff | sign;
3926 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0xffffff;
3927 exp = ((r->exp / 4) + 64) << 24;
3928 image = sign | exp | sig;
3939 decode_i370_single (fmt, r, buf)
3940 const struct real_format *fmt ATTRIBUTE_UNUSED;
3944 unsigned long sign, sig, image = buf[0];
3947 sign = (image >> 31) & 1;
3948 exp = (image >> 24) & 0x7f;
3949 sig = image & 0xffffff;
3951 memset (r, 0, sizeof (*r));
3955 r->class = rvc_normal;
3957 r->exp = (exp - 64) * 4;
3958 r->sig[SIGSZ-1] = sig << (HOST_BITS_PER_LONG - 24);
3964 encode_i370_double (fmt, buf, r)
3965 const struct real_format *fmt ATTRIBUTE_UNUSED;
3967 const REAL_VALUE_TYPE *r;
3969 unsigned long sign, exp, image_hi, image_lo;
3971 sign = r->sign << 31;
3976 image_hi = image_lo = 0;
3981 image_hi = 0x7fffffff | sign;
3982 image_lo = 0xffffffff;
3986 if (HOST_BITS_PER_LONG == 64)
3988 image_hi = r->sig[SIGSZ-1];
3989 image_lo = (image_hi >> (64 - 56)) & 0xffffffff;
3990 image_hi = (image_hi >> (64 - 56 + 1) >> 31) & 0xffffff;
3994 image_hi = r->sig[SIGSZ-1];
3995 image_lo = r->sig[SIGSZ-2];
3996 image_lo = (image_lo >> 8) | (image_hi << 24);
4000 exp = ((r->exp / 4) + 64) << 24;
4001 image_hi |= sign | exp;
4008 if (FLOAT_WORDS_BIG_ENDIAN)
4009 buf[0] = image_hi, buf[1] = image_lo;
4011 buf[0] = image_lo, buf[1] = image_hi;
4015 decode_i370_double (fmt, r, buf)
4016 const struct real_format *fmt ATTRIBUTE_UNUSED;
4020 unsigned long sign, image_hi, image_lo;
4023 if (FLOAT_WORDS_BIG_ENDIAN)
4024 image_hi = buf[0], image_lo = buf[1];
4026 image_lo = buf[0], image_hi = buf[1];
4028 sign = (image_hi >> 31) & 1;
4029 exp = (image_hi >> 24) & 0x7f;
4030 image_hi &= 0xffffff;
4031 image_lo &= 0xffffffff;
4033 memset (r, 0, sizeof (*r));
4035 if (exp || image_hi || image_lo)
4037 r->class = rvc_normal;
4039 r->exp = (exp - 64) * 4 + (SIGNIFICAND_BITS - 56);
4041 if (HOST_BITS_PER_LONG == 32)
4043 r->sig[0] = image_lo;
4044 r->sig[1] = image_hi;
4047 r->sig[0] = image_lo | (image_hi << 31 << 1);
4053 const struct real_format i370_single_format =
4064 false, /* ??? The encoding does allow for "unnormals". */
4065 false, /* ??? The encoding does allow for "unnormals". */
4069 const struct real_format i370_double_format =
4080 false, /* ??? The encoding does allow for "unnormals". */
4081 false, /* ??? The encoding does allow for "unnormals". */
4085 /* The "twos-complement" c4x format is officially defined as
4089 This is rather misleading. One must remember that F is signed.
4090 A better description would be
4092 x = -1**s * ((s + 1 + .f) * 2**e
4094 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
4095 that's -1 * (1+1+(-.5)) == -1.5. I think.
4097 The constructions here are taken from Tables 5-1 and 5-2 of the
4098 TMS320C4x User's Guide wherein step-by-step instructions for
4099 conversion from IEEE are presented. That's close enough to our
4100 internal representation so as to make things easy.
4102 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
4104 static void encode_c4x_single PARAMS ((const struct real_format *fmt,
4105 long *, const REAL_VALUE_TYPE *));
4106 static void decode_c4x_single PARAMS ((const struct real_format *,
4107 REAL_VALUE_TYPE *, const long *));
4108 static void encode_c4x_extended PARAMS ((const struct real_format *fmt,
4109 long *, const REAL_VALUE_TYPE *));
4110 static void decode_c4x_extended PARAMS ((const struct real_format *,
4111 REAL_VALUE_TYPE *, const long *));
4114 encode_c4x_single (fmt, buf, r)
4115 const struct real_format *fmt ATTRIBUTE_UNUSED;
4117 const REAL_VALUE_TYPE *r;
4119 unsigned long image, exp, sig;
4131 sig = 0x800000 - r->sign;
4136 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
4151 image = ((exp & 0xff) << 24) | (sig & 0xffffff);
4156 decode_c4x_single (fmt, r, buf)
4157 const struct real_format *fmt ATTRIBUTE_UNUSED;
4161 unsigned long image = buf[0];
4165 exp = (((image >> 24) & 0xff) ^ 0x80) - 0x80;
4166 sf = ((image & 0xffffff) ^ 0x800000) - 0x800000;
4168 memset (r, 0, sizeof (*r));
4172 r->class = rvc_normal;
4174 sig = sf & 0x7fffff;
4183 sig = (sig << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
4186 r->sig[SIGSZ-1] = sig;
4191 encode_c4x_extended (fmt, buf, r)
4192 const struct real_format *fmt ATTRIBUTE_UNUSED;
4194 const REAL_VALUE_TYPE *r;
4196 unsigned long exp, sig;
4208 sig = 0x80000000 - r->sign;
4214 sig = r->sig[SIGSZ-1];
4215 if (HOST_BITS_PER_LONG == 64)
4216 sig = sig >> 1 >> 31;
4233 exp = (exp & 0xff) << 24;
4236 if (FLOAT_WORDS_BIG_ENDIAN)
4237 buf[0] = exp, buf[1] = sig;
4239 buf[0] = sig, buf[0] = exp;
4243 decode_c4x_extended (fmt, r, buf)
4244 const struct real_format *fmt ATTRIBUTE_UNUSED;
4251 if (FLOAT_WORDS_BIG_ENDIAN)
4252 exp = buf[0], sf = buf[1];
4254 sf = buf[0], exp = buf[1];
4256 exp = (((exp >> 24) & 0xff) & 0x80) - 0x80;
4257 sf = ((sf & 0xffffffff) ^ 0x80000000) - 0x80000000;
4259 memset (r, 0, sizeof (*r));
4263 r->class = rvc_normal;
4265 sig = sf & 0x7fffffff;
4274 if (HOST_BITS_PER_LONG == 64)
4275 sig = sig << 1 << 31;
4279 r->sig[SIGSZ-1] = sig;
4283 const struct real_format c4x_single_format =
4299 const struct real_format c4x_extended_format =
4301 encode_c4x_extended,
4302 decode_c4x_extended,
4316 /* A synthetic "format" for internal arithmetic. It's the size of the
4317 internal significand minus the two bits needed for proper rounding.
4318 The encode and decode routines exist only to satisfy our paranoia
4321 static void encode_internal PARAMS ((const struct real_format *fmt,
4322 long *, const REAL_VALUE_TYPE *));
4323 static void decode_internal PARAMS ((const struct real_format *,
4324 REAL_VALUE_TYPE *, const long *));
4327 encode_internal (fmt, buf, r)
4328 const struct real_format *fmt ATTRIBUTE_UNUSED;
4330 const REAL_VALUE_TYPE *r;
4332 memcpy (buf, r, sizeof (*r));
4336 decode_internal (fmt, r, buf)
4337 const struct real_format *fmt ATTRIBUTE_UNUSED;
4341 memcpy (r, buf, sizeof (*r));
4344 const struct real_format real_internal_format =
4350 SIGNIFICAND_BITS - 2,
4360 /* Set up default mode to format mapping for IEEE. Everyone else has
4361 to set these values in OVERRIDE_OPTIONS. */
4363 const struct real_format *real_format_for_mode[TFmode - QFmode + 1] =
4368 &ieee_single_format, /* SFmode */
4369 &ieee_double_format, /* DFmode */
4371 /* We explicitly don't handle XFmode. There are two formats,
4372 pretty much equally common. Choose one in OVERRIDE_OPTIONS. */
4374 &ieee_quad_format /* TFmode */