1 /* real.c - software floating point emulation.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
3 2003, 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
4 Contributed by Stephen L. Moshier (moshier@world.std.com).
5 Re-written by Richard Henderson <rth@redhat.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
33 /* The floating point model used internally is not exactly IEEE 754
34 compliant, and close to the description in the ISO C99 standard,
35 section 5.2.4.2.2 Characteristics of floating types.
39 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
43 b = base or radix, here always 2
45 p = precision (the number of base-b digits in the significand)
46 f_k = the digits of the significand.
48 We differ from typical IEEE 754 encodings in that the entire
49 significand is fractional. Normalized significands are in the
52 A requirement of the model is that P be larger than the largest
53 supported target floating-point type by at least 2 bits. This gives
54 us proper rounding when we truncate to the target type. In addition,
55 E must be large enough to hold the smallest supported denormal number
58 Both of these requirements are easily satisfied. The largest target
59 significand is 113 bits; we store at least 160. The smallest
60 denormal number fits in 17 exponent bits; we store 27.
62 Note that the decimal string conversion routines are sensitive to
63 rounding errors. Since the raw arithmetic routines do not themselves
64 have guard digits or rounding, the computation of 10**exp can
65 accumulate more than a few digits of error. The previous incarnation
66 of real.c successfully used a 144-bit fraction; given the current
67 layout of REAL_VALUE_TYPE we're forced to expand to at least 160 bits. */
70 /* Used to classify two numbers simultaneously. */
71 #define CLASS2(A, B) ((A) << 2 | (B))
73 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
74 #error "Some constant folding done by hand to avoid shift count warnings"
77 static void get_zero (REAL_VALUE_TYPE
*, int);
78 static void get_canonical_qnan (REAL_VALUE_TYPE
*, int);
79 static void get_canonical_snan (REAL_VALUE_TYPE
*, int);
80 static void get_inf (REAL_VALUE_TYPE
*, int);
81 static bool sticky_rshift_significand (REAL_VALUE_TYPE
*,
82 const REAL_VALUE_TYPE
*, unsigned int);
83 static void rshift_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
85 static void lshift_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
87 static void lshift_significand_1 (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
88 static bool add_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*,
89 const REAL_VALUE_TYPE
*);
90 static bool sub_significands (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
91 const REAL_VALUE_TYPE
*, int);
92 static void neg_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
93 static int cmp_significands (const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
94 static int cmp_significand_0 (const REAL_VALUE_TYPE
*);
95 static void set_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
96 static void clear_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
97 static bool test_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
98 static void clear_significand_below (REAL_VALUE_TYPE
*, unsigned int);
99 static bool div_significands (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
100 const REAL_VALUE_TYPE
*);
101 static void normalize (REAL_VALUE_TYPE
*);
103 static bool do_add (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
104 const REAL_VALUE_TYPE
*, int);
105 static bool do_multiply (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
106 const REAL_VALUE_TYPE
*);
107 static bool do_divide (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
108 const REAL_VALUE_TYPE
*);
109 static int do_compare (const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*, int);
110 static void do_fix_trunc (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
112 static unsigned long rtd_divmod (REAL_VALUE_TYPE
*, REAL_VALUE_TYPE
*);
114 static const REAL_VALUE_TYPE
* ten_to_ptwo (int);
115 static const REAL_VALUE_TYPE
* ten_to_mptwo (int);
116 static const REAL_VALUE_TYPE
* real_digit (int);
117 static void times_pten (REAL_VALUE_TYPE
*, int);
119 static void round_for_format (const struct real_format
*, REAL_VALUE_TYPE
*);
121 /* Initialize R with a positive zero. */
124 get_zero (REAL_VALUE_TYPE
*r
, int sign
)
126 memset (r
, 0, sizeof (*r
));
130 /* Initialize R with the canonical quiet NaN. */
133 get_canonical_qnan (REAL_VALUE_TYPE
*r
, int sign
)
135 memset (r
, 0, sizeof (*r
));
142 get_canonical_snan (REAL_VALUE_TYPE
*r
, int sign
)
144 memset (r
, 0, sizeof (*r
));
152 get_inf (REAL_VALUE_TYPE
*r
, int sign
)
154 memset (r
, 0, sizeof (*r
));
160 /* Right-shift the significand of A by N bits; put the result in the
161 significand of R. If any one bits are shifted out, return true. */
164 sticky_rshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
167 unsigned long sticky
= 0;
168 unsigned int i
, ofs
= 0;
170 if (n
>= HOST_BITS_PER_LONG
)
172 for (i
= 0, ofs
= n
/ HOST_BITS_PER_LONG
; i
< ofs
; ++i
)
174 n
&= HOST_BITS_PER_LONG
- 1;
179 sticky
|= a
->sig
[ofs
] & (((unsigned long)1 << n
) - 1);
180 for (i
= 0; i
< SIGSZ
; ++i
)
183 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
184 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
185 << (HOST_BITS_PER_LONG
- n
)));
190 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
191 r
->sig
[i
] = a
->sig
[ofs
+ i
];
192 for (; i
< SIGSZ
; ++i
)
199 /* Right-shift the significand of A by N bits; put the result in the
203 rshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
206 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
208 n
&= HOST_BITS_PER_LONG
- 1;
211 for (i
= 0; i
< SIGSZ
; ++i
)
214 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
215 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
216 << (HOST_BITS_PER_LONG
- n
)));
221 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
222 r
->sig
[i
] = a
->sig
[ofs
+ i
];
223 for (; i
< SIGSZ
; ++i
)
228 /* Left-shift the significand of A by N bits; put the result in the
232 lshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
235 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
237 n
&= HOST_BITS_PER_LONG
- 1;
240 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
241 r
->sig
[SIGSZ
-1-i
] = a
->sig
[SIGSZ
-1-i
-ofs
];
242 for (; i
< SIGSZ
; ++i
)
243 r
->sig
[SIGSZ
-1-i
] = 0;
246 for (i
= 0; i
< SIGSZ
; ++i
)
249 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
]) << n
)
250 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
-1])
251 >> (HOST_BITS_PER_LONG
- n
)));
255 /* Likewise, but N is specialized to 1. */
258 lshift_significand_1 (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
262 for (i
= SIGSZ
- 1; i
> 0; --i
)
263 r
->sig
[i
] = (a
->sig
[i
] << 1) | (a
->sig
[i
-1] >> (HOST_BITS_PER_LONG
- 1));
264 r
->sig
[0] = a
->sig
[0] << 1;
267 /* Add the significands of A and B, placing the result in R. Return
268 true if there was carry out of the most significant word. */
271 add_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
272 const REAL_VALUE_TYPE
*b
)
277 for (i
= 0; i
< SIGSZ
; ++i
)
279 unsigned long ai
= a
->sig
[i
];
280 unsigned long ri
= ai
+ b
->sig
[i
];
296 /* Subtract the significands of A and B, placing the result in R. CARRY is
297 true if there's a borrow incoming to the least significant word.
298 Return true if there was borrow out of the most significant word. */
301 sub_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
302 const REAL_VALUE_TYPE
*b
, int carry
)
306 for (i
= 0; i
< SIGSZ
; ++i
)
308 unsigned long ai
= a
->sig
[i
];
309 unsigned long ri
= ai
- b
->sig
[i
];
325 /* Negate the significand A, placing the result in R. */
328 neg_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
333 for (i
= 0; i
< SIGSZ
; ++i
)
335 unsigned long ri
, ai
= a
->sig
[i
];
354 /* Compare significands. Return tri-state vs zero. */
357 cmp_significands (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
361 for (i
= SIGSZ
- 1; i
>= 0; --i
)
363 unsigned long ai
= a
->sig
[i
];
364 unsigned long bi
= b
->sig
[i
];
375 /* Return true if A is nonzero. */
378 cmp_significand_0 (const REAL_VALUE_TYPE
*a
)
382 for (i
= SIGSZ
- 1; i
>= 0; --i
)
389 /* Set bit N of the significand of R. */
392 set_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
394 r
->sig
[n
/ HOST_BITS_PER_LONG
]
395 |= (unsigned long)1 << (n
% HOST_BITS_PER_LONG
);
398 /* Clear bit N of the significand of R. */
401 clear_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
403 r
->sig
[n
/ HOST_BITS_PER_LONG
]
404 &= ~((unsigned long)1 << (n
% HOST_BITS_PER_LONG
));
407 /* Test bit N of the significand of R. */
410 test_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
412 /* ??? Compiler bug here if we return this expression directly.
413 The conversion to bool strips the "&1" and we wind up testing
414 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
415 int t
= (r
->sig
[n
/ HOST_BITS_PER_LONG
] >> (n
% HOST_BITS_PER_LONG
)) & 1;
419 /* Clear bits 0..N-1 of the significand of R. */
422 clear_significand_below (REAL_VALUE_TYPE
*r
, unsigned int n
)
424 int i
, w
= n
/ HOST_BITS_PER_LONG
;
426 for (i
= 0; i
< w
; ++i
)
429 r
->sig
[w
] &= ~(((unsigned long)1 << (n
% HOST_BITS_PER_LONG
)) - 1);
432 /* Divide the significands of A and B, placing the result in R. Return
433 true if the division was inexact. */
436 div_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
437 const REAL_VALUE_TYPE
*b
)
440 int i
, bit
= SIGNIFICAND_BITS
- 1;
441 unsigned long msb
, inexact
;
444 memset (r
->sig
, 0, sizeof (r
->sig
));
450 msb
= u
.sig
[SIGSZ
-1] & SIG_MSB
;
451 lshift_significand_1 (&u
, &u
);
453 if (msb
|| cmp_significands (&u
, b
) >= 0)
455 sub_significands (&u
, &u
, b
, 0);
456 set_significand_bit (r
, bit
);
461 for (i
= 0, inexact
= 0; i
< SIGSZ
; i
++)
467 /* Adjust the exponent and significand of R such that the most
468 significant bit is set. We underflow to zero and overflow to
469 infinity here, without denormals. (The intermediate representation
470 exponent is large enough to handle target denormals normalized.) */
473 normalize (REAL_VALUE_TYPE
*r
)
481 /* Find the first word that is nonzero. */
482 for (i
= SIGSZ
- 1; i
>= 0; i
--)
484 shift
+= HOST_BITS_PER_LONG
;
488 /* Zero significand flushes to zero. */
496 /* Find the first bit that is nonzero. */
498 if (r
->sig
[i
] & ((unsigned long)1 << (HOST_BITS_PER_LONG
- 1 - j
)))
504 exp
= REAL_EXP (r
) - shift
;
506 get_inf (r
, r
->sign
);
507 else if (exp
< -MAX_EXP
)
508 get_zero (r
, r
->sign
);
511 SET_REAL_EXP (r
, exp
);
512 lshift_significand (r
, r
, shift
);
517 /* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the
518 result may be inexact due to a loss of precision. */
521 do_add (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
522 const REAL_VALUE_TYPE
*b
, int subtract_p
)
526 bool inexact
= false;
528 /* Determine if we need to add or subtract. */
530 subtract_p
= (sign
^ b
->sign
) ^ subtract_p
;
532 switch (CLASS2 (a
->cl
, b
->cl
))
534 case CLASS2 (rvc_zero
, rvc_zero
):
535 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
536 get_zero (r
, sign
& !subtract_p
);
539 case CLASS2 (rvc_zero
, rvc_normal
):
540 case CLASS2 (rvc_zero
, rvc_inf
):
541 case CLASS2 (rvc_zero
, rvc_nan
):
543 case CLASS2 (rvc_normal
, rvc_nan
):
544 case CLASS2 (rvc_inf
, rvc_nan
):
545 case CLASS2 (rvc_nan
, rvc_nan
):
546 /* ANY + NaN = NaN. */
547 case CLASS2 (rvc_normal
, rvc_inf
):
550 r
->sign
= sign
^ subtract_p
;
553 case CLASS2 (rvc_normal
, rvc_zero
):
554 case CLASS2 (rvc_inf
, rvc_zero
):
555 case CLASS2 (rvc_nan
, rvc_zero
):
557 case CLASS2 (rvc_nan
, rvc_normal
):
558 case CLASS2 (rvc_nan
, rvc_inf
):
559 /* NaN + ANY = NaN. */
560 case CLASS2 (rvc_inf
, rvc_normal
):
565 case CLASS2 (rvc_inf
, rvc_inf
):
567 /* Inf - Inf = NaN. */
568 get_canonical_qnan (r
, 0);
570 /* Inf + Inf = Inf. */
574 case CLASS2 (rvc_normal
, rvc_normal
):
581 /* Swap the arguments such that A has the larger exponent. */
582 dexp
= REAL_EXP (a
) - REAL_EXP (b
);
585 const REAL_VALUE_TYPE
*t
;
592 /* If the exponents are not identical, we need to shift the
593 significand of B down. */
596 /* If the exponents are too far apart, the significands
597 do not overlap, which makes the subtraction a noop. */
598 if (dexp
>= SIGNIFICAND_BITS
)
605 inexact
|= sticky_rshift_significand (&t
, b
, dexp
);
611 if (sub_significands (r
, a
, b
, inexact
))
613 /* We got a borrow out of the subtraction. That means that
614 A and B had the same exponent, and B had the larger
615 significand. We need to swap the sign and negate the
618 neg_significand (r
, r
);
623 if (add_significands (r
, a
, b
))
625 /* We got carry out of the addition. This means we need to
626 shift the significand back down one bit and increase the
628 inexact
|= sticky_rshift_significand (r
, r
, 1);
629 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
640 SET_REAL_EXP (r
, exp
);
641 /* Zero out the remaining fields. */
646 /* Re-normalize the result. */
649 /* Special case: if the subtraction results in zero, the result
651 if (r
->cl
== rvc_zero
)
654 r
->sig
[0] |= inexact
;
659 /* Calculate R = A * B. Return true if the result may be inexact. */
662 do_multiply (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
663 const REAL_VALUE_TYPE
*b
)
665 REAL_VALUE_TYPE u
, t
, *rr
;
666 unsigned int i
, j
, k
;
667 int sign
= a
->sign
^ b
->sign
;
668 bool inexact
= false;
670 switch (CLASS2 (a
->cl
, b
->cl
))
672 case CLASS2 (rvc_zero
, rvc_zero
):
673 case CLASS2 (rvc_zero
, rvc_normal
):
674 case CLASS2 (rvc_normal
, rvc_zero
):
675 /* +-0 * ANY = 0 with appropriate sign. */
679 case CLASS2 (rvc_zero
, rvc_nan
):
680 case CLASS2 (rvc_normal
, rvc_nan
):
681 case CLASS2 (rvc_inf
, rvc_nan
):
682 case CLASS2 (rvc_nan
, rvc_nan
):
683 /* ANY * NaN = NaN. */
688 case CLASS2 (rvc_nan
, rvc_zero
):
689 case CLASS2 (rvc_nan
, rvc_normal
):
690 case CLASS2 (rvc_nan
, rvc_inf
):
691 /* NaN * ANY = NaN. */
696 case CLASS2 (rvc_zero
, rvc_inf
):
697 case CLASS2 (rvc_inf
, rvc_zero
):
699 get_canonical_qnan (r
, sign
);
702 case CLASS2 (rvc_inf
, rvc_inf
):
703 case CLASS2 (rvc_normal
, rvc_inf
):
704 case CLASS2 (rvc_inf
, rvc_normal
):
705 /* Inf * Inf = Inf, R * Inf = Inf */
709 case CLASS2 (rvc_normal
, rvc_normal
):
716 if (r
== a
|| r
== b
)
722 /* Collect all the partial products. Since we don't have sure access
723 to a widening multiply, we split each long into two half-words.
725 Consider the long-hand form of a four half-word multiplication:
735 We construct partial products of the widened half-word products
736 that are known to not overlap, e.g. DF+DH. Each such partial
737 product is given its proper exponent, which allows us to sum them
738 and obtain the finished product. */
740 for (i
= 0; i
< SIGSZ
* 2; ++i
)
742 unsigned long ai
= a
->sig
[i
/ 2];
744 ai
>>= HOST_BITS_PER_LONG
/ 2;
746 ai
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
751 for (j
= 0; j
< 2; ++j
)
753 int exp
= (REAL_EXP (a
) - (2*SIGSZ
-1-i
)*(HOST_BITS_PER_LONG
/2)
754 + (REAL_EXP (b
) - (1-j
)*(HOST_BITS_PER_LONG
/2)));
763 /* Would underflow to zero, which we shouldn't bother adding. */
768 memset (&u
, 0, sizeof (u
));
770 SET_REAL_EXP (&u
, exp
);
772 for (k
= j
; k
< SIGSZ
* 2; k
+= 2)
774 unsigned long bi
= b
->sig
[k
/ 2];
776 bi
>>= HOST_BITS_PER_LONG
/ 2;
778 bi
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
780 u
.sig
[k
/ 2] = ai
* bi
;
784 inexact
|= do_add (rr
, rr
, &u
, 0);
795 /* Calculate R = A / B. Return true if the result may be inexact. */
798 do_divide (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
799 const REAL_VALUE_TYPE
*b
)
801 int exp
, sign
= a
->sign
^ b
->sign
;
802 REAL_VALUE_TYPE t
, *rr
;
805 switch (CLASS2 (a
->cl
, b
->cl
))
807 case CLASS2 (rvc_zero
, rvc_zero
):
809 case CLASS2 (rvc_inf
, rvc_inf
):
810 /* Inf / Inf = NaN. */
811 get_canonical_qnan (r
, sign
);
814 case CLASS2 (rvc_zero
, rvc_normal
):
815 case CLASS2 (rvc_zero
, rvc_inf
):
817 case CLASS2 (rvc_normal
, rvc_inf
):
822 case CLASS2 (rvc_normal
, rvc_zero
):
824 case CLASS2 (rvc_inf
, rvc_zero
):
829 case CLASS2 (rvc_zero
, rvc_nan
):
830 case CLASS2 (rvc_normal
, rvc_nan
):
831 case CLASS2 (rvc_inf
, rvc_nan
):
832 case CLASS2 (rvc_nan
, rvc_nan
):
833 /* ANY / NaN = NaN. */
838 case CLASS2 (rvc_nan
, rvc_zero
):
839 case CLASS2 (rvc_nan
, rvc_normal
):
840 case CLASS2 (rvc_nan
, rvc_inf
):
841 /* NaN / ANY = NaN. */
846 case CLASS2 (rvc_inf
, rvc_normal
):
851 case CLASS2 (rvc_normal
, rvc_normal
):
858 if (r
== a
|| r
== b
)
863 /* Make sure all fields in the result are initialized. */
868 exp
= REAL_EXP (a
) - REAL_EXP (b
) + 1;
879 SET_REAL_EXP (rr
, exp
);
881 inexact
= div_significands (rr
, a
, b
);
883 /* Re-normalize the result. */
885 rr
->sig
[0] |= inexact
;
893 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
894 one of the two operands is a NaN. */
897 do_compare (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
,
902 switch (CLASS2 (a
->cl
, b
->cl
))
904 case CLASS2 (rvc_zero
, rvc_zero
):
905 /* Sign of zero doesn't matter for compares. */
908 case CLASS2 (rvc_inf
, rvc_zero
):
909 case CLASS2 (rvc_inf
, rvc_normal
):
910 case CLASS2 (rvc_normal
, rvc_zero
):
911 return (a
->sign
? -1 : 1);
913 case CLASS2 (rvc_inf
, rvc_inf
):
914 return -a
->sign
- -b
->sign
;
916 case CLASS2 (rvc_zero
, rvc_normal
):
917 case CLASS2 (rvc_zero
, rvc_inf
):
918 case CLASS2 (rvc_normal
, rvc_inf
):
919 return (b
->sign
? 1 : -1);
921 case CLASS2 (rvc_zero
, rvc_nan
):
922 case CLASS2 (rvc_normal
, rvc_nan
):
923 case CLASS2 (rvc_inf
, rvc_nan
):
924 case CLASS2 (rvc_nan
, rvc_nan
):
925 case CLASS2 (rvc_nan
, rvc_zero
):
926 case CLASS2 (rvc_nan
, rvc_normal
):
927 case CLASS2 (rvc_nan
, rvc_inf
):
930 case CLASS2 (rvc_normal
, rvc_normal
):
937 if (a
->sign
!= b
->sign
)
938 return -a
->sign
- -b
->sign
;
940 if (a
->decimal
|| b
->decimal
)
941 return decimal_do_compare (a
, b
, nan_result
);
943 if (REAL_EXP (a
) > REAL_EXP (b
))
945 else if (REAL_EXP (a
) < REAL_EXP (b
))
948 ret
= cmp_significands (a
, b
);
950 return (a
->sign
? -ret
: ret
);
953 /* Return A truncated to an integral value toward zero. */
956 do_fix_trunc (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
970 decimal_do_fix_trunc (r
, a
);
973 if (REAL_EXP (r
) <= 0)
974 get_zero (r
, r
->sign
);
975 else if (REAL_EXP (r
) < SIGNIFICAND_BITS
)
976 clear_significand_below (r
, SIGNIFICAND_BITS
- REAL_EXP (r
));
984 /* Perform the binary or unary operation described by CODE.
985 For a unary operation, leave OP1 NULL. This function returns
986 true if the result may be inexact due to loss of precision. */
989 real_arithmetic (REAL_VALUE_TYPE
*r
, int icode
, const REAL_VALUE_TYPE
*op0
,
990 const REAL_VALUE_TYPE
*op1
)
992 enum tree_code code
= icode
;
994 if (op0
->decimal
|| (op1
&& op1
->decimal
))
995 return decimal_real_arithmetic (r
, icode
, op0
, op1
);
1000 return do_add (r
, op0
, op1
, 0);
1003 return do_add (r
, op0
, op1
, 1);
1006 return do_multiply (r
, op0
, op1
);
1009 return do_divide (r
, op0
, op1
);
1012 if (op1
->cl
== rvc_nan
)
1014 else if (do_compare (op0
, op1
, -1) < 0)
1021 if (op1
->cl
== rvc_nan
)
1023 else if (do_compare (op0
, op1
, 1) < 0)
1039 case FIX_TRUNC_EXPR
:
1040 do_fix_trunc (r
, op0
);
1049 /* Legacy. Similar, but return the result directly. */
1052 real_arithmetic2 (int icode
, const REAL_VALUE_TYPE
*op0
,
1053 const REAL_VALUE_TYPE
*op1
)
1056 real_arithmetic (&r
, icode
, op0
, op1
);
1061 real_compare (int icode
, const REAL_VALUE_TYPE
*op0
,
1062 const REAL_VALUE_TYPE
*op1
)
1064 enum tree_code code
= icode
;
1069 return do_compare (op0
, op1
, 1) < 0;
1071 return do_compare (op0
, op1
, 1) <= 0;
1073 return do_compare (op0
, op1
, -1) > 0;
1075 return do_compare (op0
, op1
, -1) >= 0;
1077 return do_compare (op0
, op1
, -1) == 0;
1079 return do_compare (op0
, op1
, -1) != 0;
1080 case UNORDERED_EXPR
:
1081 return op0
->cl
== rvc_nan
|| op1
->cl
== rvc_nan
;
1083 return op0
->cl
!= rvc_nan
&& op1
->cl
!= rvc_nan
;
1085 return do_compare (op0
, op1
, -1) < 0;
1087 return do_compare (op0
, op1
, -1) <= 0;
1089 return do_compare (op0
, op1
, 1) > 0;
1091 return do_compare (op0
, op1
, 1) >= 0;
1093 return do_compare (op0
, op1
, 0) == 0;
1095 return do_compare (op0
, op1
, 0) != 0;
1102 /* Return floor log2(R). */
1105 real_exponent (const REAL_VALUE_TYPE
*r
)
1113 return (unsigned int)-1 >> 1;
1115 return REAL_EXP (r
);
1121 /* R = OP0 * 2**EXP. */
1124 real_ldexp (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*op0
, int exp
)
1135 exp
+= REAL_EXP (op0
);
1137 get_inf (r
, r
->sign
);
1138 else if (exp
< -MAX_EXP
)
1139 get_zero (r
, r
->sign
);
1141 SET_REAL_EXP (r
, exp
);
1149 /* Determine whether a floating-point value X is infinite. */
1152 real_isinf (const REAL_VALUE_TYPE
*r
)
1154 return (r
->cl
== rvc_inf
);
1157 /* Determine whether a floating-point value X is a NaN. */
1160 real_isnan (const REAL_VALUE_TYPE
*r
)
1162 return (r
->cl
== rvc_nan
);
1165 /* Determine whether a floating-point value X is finite. */
1168 real_isfinite (const REAL_VALUE_TYPE
*r
)
1170 return (r
->cl
!= rvc_nan
) && (r
->cl
!= rvc_inf
);
1173 /* Determine whether a floating-point value X is negative. */
1176 real_isneg (const REAL_VALUE_TYPE
*r
)
1181 /* Determine whether a floating-point value X is minus zero. */
1184 real_isnegzero (const REAL_VALUE_TYPE
*r
)
1186 return r
->sign
&& r
->cl
== rvc_zero
;
1189 /* Compare two floating-point objects for bitwise identity. */
1192 real_identical (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
1198 if (a
->sign
!= b
->sign
)
1208 if (a
->decimal
!= b
->decimal
)
1210 if (REAL_EXP (a
) != REAL_EXP (b
))
1215 if (a
->signalling
!= b
->signalling
)
1217 /* The significand is ignored for canonical NaNs. */
1218 if (a
->canonical
|| b
->canonical
)
1219 return a
->canonical
== b
->canonical
;
1226 for (i
= 0; i
< SIGSZ
; ++i
)
1227 if (a
->sig
[i
] != b
->sig
[i
])
1233 /* Try to change R into its exact multiplicative inverse in machine
1234 mode MODE. Return true if successful. */
1237 exact_real_inverse (enum machine_mode mode
, REAL_VALUE_TYPE
*r
)
1239 const REAL_VALUE_TYPE
*one
= real_digit (1);
1243 if (r
->cl
!= rvc_normal
)
1246 /* Check for a power of two: all significand bits zero except the MSB. */
1247 for (i
= 0; i
< SIGSZ
-1; ++i
)
1250 if (r
->sig
[SIGSZ
-1] != SIG_MSB
)
1253 /* Find the inverse and truncate to the required mode. */
1254 do_divide (&u
, one
, r
);
1255 real_convert (&u
, mode
, &u
);
1257 /* The rounding may have overflowed. */
1258 if (u
.cl
!= rvc_normal
)
1260 for (i
= 0; i
< SIGSZ
-1; ++i
)
1263 if (u
.sig
[SIGSZ
-1] != SIG_MSB
)
1270 /* Return true if arithmetic on values in IMODE that were promoted
1271 from values in TMODE is equivalent to direct arithmetic on values
1275 real_can_shorten_arithmetic (enum machine_mode imode
, enum machine_mode tmode
)
1277 const struct real_format
*tfmt
, *ifmt
;
1278 tfmt
= REAL_MODE_FORMAT (tmode
);
1279 ifmt
= REAL_MODE_FORMAT (imode
);
1280 /* These conditions are conservative rather than trying to catch the
1281 exact boundary conditions; the main case to allow is IEEE float
1283 return (ifmt
->b
== tfmt
->b
1284 && ifmt
->p
> 2 * tfmt
->p
1285 && ifmt
->emin
< 2 * tfmt
->emin
- tfmt
->p
- 2
1286 && ifmt
->emin
< tfmt
->emin
- tfmt
->emax
- tfmt
->p
- 2
1287 && ifmt
->emax
> 2 * tfmt
->emax
+ 2
1288 && ifmt
->emax
> tfmt
->emax
- tfmt
->emin
+ tfmt
->p
+ 2
1289 && ifmt
->round_towards_zero
== tfmt
->round_towards_zero
1290 && (ifmt
->has_sign_dependent_rounding
1291 == tfmt
->has_sign_dependent_rounding
)
1292 && ifmt
->has_nans
>= tfmt
->has_nans
1293 && ifmt
->has_inf
>= tfmt
->has_inf
1294 && ifmt
->has_signed_zero
>= tfmt
->has_signed_zero
1295 && !MODE_COMPOSITE_P (tmode
)
1296 && !MODE_COMPOSITE_P (imode
));
1299 /* Render R as an integer. */
1302 real_to_integer (const REAL_VALUE_TYPE
*r
)
1304 unsigned HOST_WIDE_INT i
;
1315 i
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1322 return decimal_real_to_integer (r
);
1324 if (REAL_EXP (r
) <= 0)
1326 /* Only force overflow for unsigned overflow. Signed overflow is
1327 undefined, so it doesn't matter what we return, and some callers
1328 expect to be able to use this routine for both signed and
1329 unsigned conversions. */
1330 if (REAL_EXP (r
) > HOST_BITS_PER_WIDE_INT
)
1333 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1334 i
= r
->sig
[SIGSZ
-1];
1337 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2 * HOST_BITS_PER_LONG
);
1338 i
= r
->sig
[SIGSZ
-1];
1339 i
= i
<< (HOST_BITS_PER_LONG
- 1) << 1;
1340 i
|= r
->sig
[SIGSZ
-2];
1343 i
>>= HOST_BITS_PER_WIDE_INT
- REAL_EXP (r
);
1354 /* Likewise, but to an integer pair, HI+LOW. */
1357 real_to_integer2 (HOST_WIDE_INT
*plow
, HOST_WIDE_INT
*phigh
,
1358 const REAL_VALUE_TYPE
*r
)
1361 HOST_WIDE_INT low
, high
;
1374 high
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1387 decimal_real_to_integer2 (plow
, phigh
, r
);
1394 /* Only force overflow for unsigned overflow. Signed overflow is
1395 undefined, so it doesn't matter what we return, and some callers
1396 expect to be able to use this routine for both signed and
1397 unsigned conversions. */
1398 if (exp
> 2*HOST_BITS_PER_WIDE_INT
)
1401 rshift_significand (&t
, r
, 2*HOST_BITS_PER_WIDE_INT
- exp
);
1402 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1404 high
= t
.sig
[SIGSZ
-1];
1405 low
= t
.sig
[SIGSZ
-2];
1409 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2*HOST_BITS_PER_LONG
);
1410 high
= t
.sig
[SIGSZ
-1];
1411 high
= high
<< (HOST_BITS_PER_LONG
- 1) << 1;
1412 high
|= t
.sig
[SIGSZ
-2];
1414 low
= t
.sig
[SIGSZ
-3];
1415 low
= low
<< (HOST_BITS_PER_LONG
- 1) << 1;
1416 low
|= t
.sig
[SIGSZ
-4];
1424 low
= -low
, high
= ~high
;
1436 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1437 of NUM / DEN. Return the quotient and place the remainder in NUM.
1438 It is expected that NUM / DEN are close enough that the quotient is
1441 static unsigned long
1442 rtd_divmod (REAL_VALUE_TYPE
*num
, REAL_VALUE_TYPE
*den
)
1444 unsigned long q
, msb
;
1445 int expn
= REAL_EXP (num
), expd
= REAL_EXP (den
);
1454 msb
= num
->sig
[SIGSZ
-1] & SIG_MSB
;
1456 lshift_significand_1 (num
, num
);
1458 if (msb
|| cmp_significands (num
, den
) >= 0)
1460 sub_significands (num
, num
, den
, 0);
1464 while (--expn
>= expd
);
1466 SET_REAL_EXP (num
, expd
);
1472 /* Render R as a decimal floating point constant. Emit DIGITS significant
1473 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1474 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1475 zeros. If MODE is VOIDmode, round to nearest value. Otherwise, round
1476 to a string that, when parsed back in mode MODE, yields the same value. */
1478 #define M_LOG10_2 0.30102999566398119521
1481 real_to_decimal_for_mode (char *str
, const REAL_VALUE_TYPE
*r_orig
,
1482 size_t buf_size
, size_t digits
,
1483 int crop_trailing_zeros
, enum machine_mode mode
)
1485 const struct real_format
*fmt
= NULL
;
1486 const REAL_VALUE_TYPE
*one
, *ten
;
1487 REAL_VALUE_TYPE r
, pten
, u
, v
;
1488 int dec_exp
, cmp_one
, digit
;
1490 char *p
, *first
, *last
;
1494 if (mode
!= VOIDmode
)
1496 fmt
= REAL_MODE_FORMAT (mode
);
1504 strcpy (str
, (r
.sign
? "-0.0" : "0.0"));
1509 strcpy (str
, (r
.sign
? "-Inf" : "+Inf"));
1512 /* ??? Print the significand as well, if not canonical? */
1513 sprintf (str
, "%c%cNaN", (r_orig
->sign
? '-' : '+'),
1514 (r_orig
->signalling
? 'S' : 'Q'));
1522 decimal_real_to_decimal (str
, &r
, buf_size
, digits
, crop_trailing_zeros
);
1526 /* Bound the number of digits printed by the size of the representation. */
1527 max_digits
= SIGNIFICAND_BITS
* M_LOG10_2
;
1528 if (digits
== 0 || digits
> max_digits
)
1529 digits
= max_digits
;
1531 /* Estimate the decimal exponent, and compute the length of the string it
1532 will print as. Be conservative and add one to account for possible
1533 overflow or rounding error. */
1534 dec_exp
= REAL_EXP (&r
) * M_LOG10_2
;
1535 for (max_digits
= 1; dec_exp
; max_digits
++)
1538 /* Bound the number of digits printed by the size of the output buffer. */
1539 max_digits
= buf_size
- 1 - 1 - 2 - max_digits
- 1;
1540 gcc_assert (max_digits
<= buf_size
);
1541 if (digits
> max_digits
)
1542 digits
= max_digits
;
1544 one
= real_digit (1);
1545 ten
= ten_to_ptwo (0);
1553 cmp_one
= do_compare (&r
, one
, 0);
1558 /* Number is greater than one. Convert significand to an integer
1559 and strip trailing decimal zeros. */
1562 SET_REAL_EXP (&u
, SIGNIFICAND_BITS
- 1);
1564 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1565 m
= floor_log2 (max_digits
);
1567 /* Iterate over the bits of the possible powers of 10 that might
1568 be present in U and eliminate them. That is, if we find that
1569 10**2**M divides U evenly, keep the division and increase
1575 do_divide (&t
, &u
, ten_to_ptwo (m
));
1576 do_fix_trunc (&v
, &t
);
1577 if (cmp_significands (&v
, &t
) == 0)
1585 /* Revert the scaling to integer that we performed earlier. */
1586 SET_REAL_EXP (&u
, REAL_EXP (&u
) + REAL_EXP (&r
)
1587 - (SIGNIFICAND_BITS
- 1));
1590 /* Find power of 10. Do this by dividing out 10**2**M when
1591 this is larger than the current remainder. Fill PTEN with
1592 the power of 10 that we compute. */
1593 if (REAL_EXP (&r
) > 0)
1595 m
= floor_log2 ((int)(REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1598 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1599 if (do_compare (&u
, ptentwo
, 0) >= 0)
1601 do_divide (&u
, &u
, ptentwo
);
1602 do_multiply (&pten
, &pten
, ptentwo
);
1609 /* We managed to divide off enough tens in the above reduction
1610 loop that we've now got a negative exponent. Fall into the
1611 less-than-one code to compute the proper value for PTEN. */
1618 /* Number is less than one. Pad significand with leading
1624 /* Stop if we'd shift bits off the bottom. */
1628 do_multiply (&u
, &v
, ten
);
1630 /* Stop if we're now >= 1. */
1631 if (REAL_EXP (&u
) > 0)
1639 /* Find power of 10. Do this by multiplying in P=10**2**M when
1640 the current remainder is smaller than 1/P. Fill PTEN with the
1641 power of 10 that we compute. */
1642 m
= floor_log2 ((int)(-REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1645 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1646 const REAL_VALUE_TYPE
*ptenmtwo
= ten_to_mptwo (m
);
1648 if (do_compare (&v
, ptenmtwo
, 0) <= 0)
1650 do_multiply (&v
, &v
, ptentwo
);
1651 do_multiply (&pten
, &pten
, ptentwo
);
1657 /* Invert the positive power of 10 that we've collected so far. */
1658 do_divide (&pten
, one
, &pten
);
1666 /* At this point, PTEN should contain the nearest power of 10 smaller
1667 than R, such that this division produces the first digit.
1669 Using a divide-step primitive that returns the complete integral
1670 remainder avoids the rounding error that would be produced if
1671 we were to use do_divide here and then simply multiply by 10 for
1672 each subsequent digit. */
1674 digit
= rtd_divmod (&r
, &pten
);
1676 /* Be prepared for error in that division via underflow ... */
1677 if (digit
== 0 && cmp_significand_0 (&r
))
1679 /* Multiply by 10 and try again. */
1680 do_multiply (&r
, &r
, ten
);
1681 digit
= rtd_divmod (&r
, &pten
);
1683 gcc_assert (digit
!= 0);
1686 /* ... or overflow. */
1696 gcc_assert (digit
<= 10);
1700 /* Generate subsequent digits. */
1701 while (--digits
> 0)
1703 do_multiply (&r
, &r
, ten
);
1704 digit
= rtd_divmod (&r
, &pten
);
1709 /* Generate one more digit with which to do rounding. */
1710 do_multiply (&r
, &r
, ten
);
1711 digit
= rtd_divmod (&r
, &pten
);
1713 /* Round the result. */
1714 if (fmt
&& fmt
->round_towards_zero
)
1716 /* If the format uses round towards zero when parsing the string
1717 back in, we need to always round away from zero here. */
1718 if (cmp_significand_0 (&r
))
1720 round_up
= digit
> 0;
1726 /* Round to nearest. If R is nonzero there are additional
1727 nonzero digits to be extracted. */
1728 if (cmp_significand_0 (&r
))
1730 /* Round to even. */
1731 else if ((p
[-1] - '0') & 1)
1735 round_up
= digit
> 5;
1752 /* Carry out of the first digit. This means we had all 9's and
1753 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1761 /* Insert the decimal point. */
1762 first
[0] = first
[1];
1765 /* If requested, drop trailing zeros. Never crop past "1.0". */
1766 if (crop_trailing_zeros
)
1767 while (last
> first
+ 3 && last
[-1] == '0')
1770 /* Append the exponent. */
1771 sprintf (last
, "e%+d", dec_exp
);
1773 #ifdef ENABLE_CHECKING
1774 /* Verify that we can read the original value back in. */
1775 if (mode
!= VOIDmode
)
1777 real_from_string (&r
, str
);
1778 real_convert (&r
, mode
, &r
);
1779 gcc_assert (real_identical (&r
, r_orig
));
1784 /* Likewise, except always uses round-to-nearest. */
1787 real_to_decimal (char *str
, const REAL_VALUE_TYPE
*r_orig
, size_t buf_size
,
1788 size_t digits
, int crop_trailing_zeros
)
1790 real_to_decimal_for_mode (str
, r_orig
, buf_size
,
1791 digits
, crop_trailing_zeros
, VOIDmode
);
1794 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1795 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1796 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1797 strip trailing zeros. */
1800 real_to_hexadecimal (char *str
, const REAL_VALUE_TYPE
*r
, size_t buf_size
,
1801 size_t digits
, int crop_trailing_zeros
)
1803 int i
, j
, exp
= REAL_EXP (r
);
1816 strcpy (str
, (r
->sign
? "-Inf" : "+Inf"));
1819 /* ??? Print the significand as well, if not canonical? */
1820 sprintf (str
, "%c%cNaN", (r
->sign
? '-' : '+'),
1821 (r
->signalling
? 'S' : 'Q'));
1829 /* Hexadecimal format for decimal floats is not interesting. */
1830 strcpy (str
, "N/A");
1835 digits
= SIGNIFICAND_BITS
/ 4;
1837 /* Bound the number of digits printed by the size of the output buffer. */
1839 sprintf (exp_buf
, "p%+d", exp
);
1840 max_digits
= buf_size
- strlen (exp_buf
) - r
->sign
- 4 - 1;
1841 gcc_assert (max_digits
<= buf_size
);
1842 if (digits
> max_digits
)
1843 digits
= max_digits
;
1854 for (i
= SIGSZ
- 1; i
>= 0; --i
)
1855 for (j
= HOST_BITS_PER_LONG
- 4; j
>= 0; j
-= 4)
1857 *p
++ = "0123456789abcdef"[(r
->sig
[i
] >> j
) & 15];
1863 if (crop_trailing_zeros
)
1864 while (p
> first
+ 1 && p
[-1] == '0')
1867 sprintf (p
, "p%+d", exp
);
1870 /* Initialize R from a decimal or hexadecimal string. The string is
1871 assumed to have been syntax checked already. Return -1 if the
1872 value underflows, +1 if overflows, and 0 otherwise. */
1875 real_from_string (REAL_VALUE_TYPE
*r
, const char *str
)
1887 else if (*str
== '+')
1890 if (!strncmp (str
, "QNaN", 4))
1892 get_canonical_qnan (r
, sign
);
1895 else if (!strncmp (str
, "SNaN", 4))
1897 get_canonical_snan (r
, sign
);
1900 else if (!strncmp (str
, "Inf", 3))
1906 if (str
[0] == '0' && (str
[1] == 'x' || str
[1] == 'X'))
1908 /* Hexadecimal floating point. */
1909 int pos
= SIGNIFICAND_BITS
- 4, d
;
1917 d
= hex_value (*str
);
1922 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1923 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1927 /* Ensure correct rounding by setting last bit if there is
1928 a subsequent nonzero digit. */
1936 if (pos
== SIGNIFICAND_BITS
- 4)
1943 d
= hex_value (*str
);
1948 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1949 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1953 /* Ensure correct rounding by setting last bit if there is
1954 a subsequent nonzero digit. */
1960 /* If the mantissa is zero, ignore the exponent. */
1961 if (!cmp_significand_0 (r
))
1964 if (*str
== 'p' || *str
== 'P')
1966 bool exp_neg
= false;
1974 else if (*str
== '+')
1978 while (ISDIGIT (*str
))
1984 /* Overflowed the exponent. */
1999 SET_REAL_EXP (r
, exp
);
2005 /* Decimal floating point. */
2006 const REAL_VALUE_TYPE
*ten
= ten_to_ptwo (0);
2011 while (ISDIGIT (*str
))
2014 do_multiply (r
, r
, ten
);
2016 do_add (r
, r
, real_digit (d
), 0);
2021 if (r
->cl
== rvc_zero
)
2026 while (ISDIGIT (*str
))
2029 do_multiply (r
, r
, ten
);
2031 do_add (r
, r
, real_digit (d
), 0);
2036 /* If the mantissa is zero, ignore the exponent. */
2037 if (r
->cl
== rvc_zero
)
2040 if (*str
== 'e' || *str
== 'E')
2042 bool exp_neg
= false;
2050 else if (*str
== '+')
2054 while (ISDIGIT (*str
))
2060 /* Overflowed the exponent. */
2074 times_pten (r
, exp
);
2093 /* Legacy. Similar, but return the result directly. */
2096 real_from_string2 (const char *s
, enum machine_mode mode
)
2100 real_from_string (&r
, s
);
2101 if (mode
!= VOIDmode
)
2102 real_convert (&r
, mode
, &r
);
2107 /* Initialize R from string S and desired MODE. */
2110 real_from_string3 (REAL_VALUE_TYPE
*r
, const char *s
, enum machine_mode mode
)
2112 if (DECIMAL_FLOAT_MODE_P (mode
))
2113 decimal_real_from_string (r
, s
);
2115 real_from_string (r
, s
);
2117 if (mode
!= VOIDmode
)
2118 real_convert (r
, mode
, r
);
2121 /* Initialize R from the integer pair HIGH+LOW. */
2124 real_from_integer (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
2125 unsigned HOST_WIDE_INT low
, HOST_WIDE_INT high
,
2128 if (low
== 0 && high
== 0)
2132 memset (r
, 0, sizeof (*r
));
2134 r
->sign
= high
< 0 && !unsigned_p
;
2135 SET_REAL_EXP (r
, 2 * HOST_BITS_PER_WIDE_INT
);
2146 if (HOST_BITS_PER_LONG
== HOST_BITS_PER_WIDE_INT
)
2148 r
->sig
[SIGSZ
-1] = high
;
2149 r
->sig
[SIGSZ
-2] = low
;
2153 gcc_assert (HOST_BITS_PER_LONG
*2 == HOST_BITS_PER_WIDE_INT
);
2154 r
->sig
[SIGSZ
-1] = high
>> (HOST_BITS_PER_LONG
- 1) >> 1;
2155 r
->sig
[SIGSZ
-2] = high
;
2156 r
->sig
[SIGSZ
-3] = low
>> (HOST_BITS_PER_LONG
- 1) >> 1;
2157 r
->sig
[SIGSZ
-4] = low
;
2163 if (mode
!= VOIDmode
)
2164 real_convert (r
, mode
, r
);
2167 /* Returns 10**2**N. */
2169 static const REAL_VALUE_TYPE
*
2172 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2174 gcc_assert (n
>= 0);
2175 gcc_assert (n
< EXP_BITS
);
2177 if (tens
[n
].cl
== rvc_zero
)
2179 if (n
< (HOST_BITS_PER_WIDE_INT
== 64 ? 5 : 4))
2181 HOST_WIDE_INT t
= 10;
2184 for (i
= 0; i
< n
; ++i
)
2187 real_from_integer (&tens
[n
], VOIDmode
, t
, 0, 1);
2191 const REAL_VALUE_TYPE
*t
= ten_to_ptwo (n
- 1);
2192 do_multiply (&tens
[n
], t
, t
);
2199 /* Returns 10**(-2**N). */
2201 static const REAL_VALUE_TYPE
*
2202 ten_to_mptwo (int n
)
2204 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2206 gcc_assert (n
>= 0);
2207 gcc_assert (n
< EXP_BITS
);
2209 if (tens
[n
].cl
== rvc_zero
)
2210 do_divide (&tens
[n
], real_digit (1), ten_to_ptwo (n
));
2217 static const REAL_VALUE_TYPE
*
2220 static REAL_VALUE_TYPE num
[10];
2222 gcc_assert (n
>= 0);
2223 gcc_assert (n
<= 9);
2225 if (n
> 0 && num
[n
].cl
== rvc_zero
)
2226 real_from_integer (&num
[n
], VOIDmode
, n
, 0, 1);
2231 /* Multiply R by 10**EXP. */
2234 times_pten (REAL_VALUE_TYPE
*r
, int exp
)
2236 REAL_VALUE_TYPE pten
, *rr
;
2237 bool negative
= (exp
< 0);
2243 pten
= *real_digit (1);
2249 for (i
= 0; exp
> 0; ++i
, exp
>>= 1)
2251 do_multiply (rr
, rr
, ten_to_ptwo (i
));
2254 do_divide (r
, r
, &pten
);
2257 /* Returns the special REAL_VALUE_TYPE corresponding to 'e'. */
2259 const REAL_VALUE_TYPE
*
2262 static REAL_VALUE_TYPE value
;
2264 /* Initialize mathematical constants for constant folding builtins.
2265 These constants need to be given to at least 160 bits precision. */
2266 if (value
.cl
== rvc_zero
)
2269 mpfr_init2 (m
, SIGNIFICAND_BITS
);
2270 mpfr_set_ui (m
, 1, GMP_RNDN
);
2271 mpfr_exp (m
, m
, GMP_RNDN
);
2272 real_from_mpfr (&value
, m
, NULL_TREE
, GMP_RNDN
);
2279 /* Returns the special REAL_VALUE_TYPE corresponding to 1/3. */
2281 const REAL_VALUE_TYPE
*
2282 dconst_third_ptr (void)
2284 static REAL_VALUE_TYPE value
;
2286 /* Initialize mathematical constants for constant folding builtins.
2287 These constants need to be given to at least 160 bits precision. */
2288 if (value
.cl
== rvc_zero
)
2290 real_arithmetic (&value
, RDIV_EXPR
, &dconst1
, real_digit (3));
2295 /* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2). */
2297 const REAL_VALUE_TYPE
*
2298 dconst_sqrt2_ptr (void)
2300 static REAL_VALUE_TYPE value
;
2302 /* Initialize mathematical constants for constant folding builtins.
2303 These constants need to be given to at least 160 bits precision. */
2304 if (value
.cl
== rvc_zero
)
2307 mpfr_init2 (m
, SIGNIFICAND_BITS
);
2308 mpfr_sqrt_ui (m
, 2, GMP_RNDN
);
2309 real_from_mpfr (&value
, m
, NULL_TREE
, GMP_RNDN
);
2315 /* Fills R with +Inf. */
2318 real_inf (REAL_VALUE_TYPE
*r
)
2323 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2324 we force a QNaN, else we force an SNaN. The string, if not empty,
2325 is parsed as a number and placed in the significand. Return true
2326 if the string was successfully parsed. */
2329 real_nan (REAL_VALUE_TYPE
*r
, const char *str
, int quiet
,
2330 enum machine_mode mode
)
2332 const struct real_format
*fmt
;
2334 fmt
= REAL_MODE_FORMAT (mode
);
2340 get_canonical_qnan (r
, 0);
2342 get_canonical_snan (r
, 0);
2348 memset (r
, 0, sizeof (*r
));
2351 /* Parse akin to strtol into the significand of R. */
2353 while (ISSPACE (*str
))
2357 else if (*str
== '+')
2362 if (*str
== 'x' || *str
== 'X')
2371 while ((d
= hex_value (*str
)) < base
)
2378 lshift_significand (r
, r
, 3);
2381 lshift_significand (r
, r
, 4);
2384 lshift_significand_1 (&u
, r
);
2385 lshift_significand (r
, r
, 3);
2386 add_significands (r
, r
, &u
);
2394 add_significands (r
, r
, &u
);
2399 /* Must have consumed the entire string for success. */
2403 /* Shift the significand into place such that the bits
2404 are in the most significant bits for the format. */
2405 lshift_significand (r
, r
, SIGNIFICAND_BITS
- fmt
->pnan
);
2407 /* Our MSB is always unset for NaNs. */
2408 r
->sig
[SIGSZ
-1] &= ~SIG_MSB
;
2410 /* Force quiet or signalling NaN. */
2411 r
->signalling
= !quiet
;
2417 /* Fills R with the largest finite value representable in mode MODE.
2418 If SIGN is nonzero, R is set to the most negative finite value. */
2421 real_maxval (REAL_VALUE_TYPE
*r
, int sign
, enum machine_mode mode
)
2423 const struct real_format
*fmt
;
2426 fmt
= REAL_MODE_FORMAT (mode
);
2428 memset (r
, 0, sizeof (*r
));
2431 decimal_real_maxval (r
, sign
, mode
);
2436 SET_REAL_EXP (r
, fmt
->emax
);
2438 np2
= SIGNIFICAND_BITS
- fmt
->p
;
2439 memset (r
->sig
, -1, SIGSZ
* sizeof (unsigned long));
2440 clear_significand_below (r
, np2
);
2442 if (fmt
->pnan
< fmt
->p
)
2443 /* This is an IBM extended double format made up of two IEEE
2444 doubles. The value of the long double is the sum of the
2445 values of the two parts. The most significant part is
2446 required to be the value of the long double rounded to the
2447 nearest double. Rounding means we need a slightly smaller
2448 value for LDBL_MAX. */
2449 clear_significand_bit (r
, SIGNIFICAND_BITS
- fmt
->pnan
- 1);
2453 /* Fills R with 2**N. */
2456 real_2expN (REAL_VALUE_TYPE
*r
, int n
, enum machine_mode fmode
)
2458 memset (r
, 0, sizeof (*r
));
2463 else if (n
< -MAX_EXP
)
2468 SET_REAL_EXP (r
, n
);
2469 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2471 if (DECIMAL_FLOAT_MODE_P (fmode
))
2472 decimal_real_convert (r
, fmode
, r
);
2477 round_for_format (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
)
2481 bool round_up
= false;
2487 decimal_round_for_format (fmt
, r
);
2490 /* FIXME. We can come here via fp_easy_constant
2491 (e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
2492 investigated whether this convert needs to be here, or
2493 something else is missing. */
2494 decimal_real_convert (r
, DFmode
, r
);
2498 emin2m1
= fmt
->emin
- 1;
2501 np2
= SIGNIFICAND_BITS
- p2
;
2505 get_zero (r
, r
->sign
);
2507 if (!fmt
->has_signed_zero
)
2512 get_inf (r
, r
->sign
);
2517 clear_significand_below (r
, np2
);
2527 /* Check the range of the exponent. If we're out of range,
2528 either underflow or overflow. */
2529 if (REAL_EXP (r
) > emax2
)
2531 else if (REAL_EXP (r
) <= emin2m1
)
2535 if (!fmt
->has_denorm
)
2537 /* Don't underflow completely until we've had a chance to round. */
2538 if (REAL_EXP (r
) < emin2m1
)
2543 diff
= emin2m1
- REAL_EXP (r
) + 1;
2547 /* De-normalize the significand. */
2548 r
->sig
[0] |= sticky_rshift_significand (r
, r
, diff
);
2549 SET_REAL_EXP (r
, REAL_EXP (r
) + diff
);
2553 if (!fmt
->round_towards_zero
)
2555 /* There are P2 true significand bits, followed by one guard bit,
2556 followed by one sticky bit, followed by stuff. Fold nonzero
2557 stuff into the sticky bit. */
2558 unsigned long sticky
;
2562 for (i
= 0, w
= (np2
- 1) / HOST_BITS_PER_LONG
; i
< w
; ++i
)
2563 sticky
|= r
->sig
[i
];
2565 & (((unsigned long)1 << ((np2
- 1) % HOST_BITS_PER_LONG
)) - 1);
2567 guard
= test_significand_bit (r
, np2
- 1);
2568 lsb
= test_significand_bit (r
, np2
);
2570 /* Round to even. */
2571 round_up
= guard
&& (sticky
|| lsb
);
2578 set_significand_bit (&u
, np2
);
2580 if (add_significands (r
, r
, &u
))
2582 /* Overflow. Means the significand had been all ones, and
2583 is now all zeros. Need to increase the exponent, and
2584 possibly re-normalize it. */
2585 SET_REAL_EXP (r
, REAL_EXP (r
) + 1);
2586 if (REAL_EXP (r
) > emax2
)
2588 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2592 /* Catch underflow that we deferred until after rounding. */
2593 if (REAL_EXP (r
) <= emin2m1
)
2596 /* Clear out trailing garbage. */
2597 clear_significand_below (r
, np2
);
2600 /* Extend or truncate to a new mode. */
2603 real_convert (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
2604 const REAL_VALUE_TYPE
*a
)
2606 const struct real_format
*fmt
;
2608 fmt
= REAL_MODE_FORMAT (mode
);
2613 if (a
->decimal
|| fmt
->b
== 10)
2614 decimal_real_convert (r
, mode
, a
);
2616 round_for_format (fmt
, r
);
2618 /* round_for_format de-normalizes denormals. Undo just that part. */
2619 if (r
->cl
== rvc_normal
)
2623 /* Legacy. Likewise, except return the struct directly. */
2626 real_value_truncate (enum machine_mode mode
, REAL_VALUE_TYPE a
)
2629 real_convert (&r
, mode
, &a
);
2633 /* Return true if truncating to MODE is exact. */
2636 exact_real_truncate (enum machine_mode mode
, const REAL_VALUE_TYPE
*a
)
2638 const struct real_format
*fmt
;
2642 fmt
= REAL_MODE_FORMAT (mode
);
2645 /* Don't allow conversion to denormals. */
2646 emin2m1
= fmt
->emin
- 1;
2647 if (REAL_EXP (a
) <= emin2m1
)
2650 /* After conversion to the new mode, the value must be identical. */
2651 real_convert (&t
, mode
, a
);
2652 return real_identical (&t
, a
);
2655 /* Write R to the given target format. Place the words of the result
2656 in target word order in BUF. There are always 32 bits in each
2657 long, no matter the size of the host long.
2659 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2662 real_to_target_fmt (long *buf
, const REAL_VALUE_TYPE
*r_orig
,
2663 const struct real_format
*fmt
)
2669 round_for_format (fmt
, &r
);
2673 (*fmt
->encode
) (fmt
, buf
, &r
);
2678 /* Similar, but look up the format from MODE. */
2681 real_to_target (long *buf
, const REAL_VALUE_TYPE
*r
, enum machine_mode mode
)
2683 const struct real_format
*fmt
;
2685 fmt
= REAL_MODE_FORMAT (mode
);
2688 return real_to_target_fmt (buf
, r
, fmt
);
2691 /* Read R from the given target format. Read the words of the result
2692 in target word order in BUF. There are always 32 bits in each
2693 long, no matter the size of the host long. */
2696 real_from_target_fmt (REAL_VALUE_TYPE
*r
, const long *buf
,
2697 const struct real_format
*fmt
)
2699 (*fmt
->decode
) (fmt
, r
, buf
);
2702 /* Similar, but look up the format from MODE. */
2705 real_from_target (REAL_VALUE_TYPE
*r
, const long *buf
, enum machine_mode mode
)
2707 const struct real_format
*fmt
;
2709 fmt
= REAL_MODE_FORMAT (mode
);
2712 (*fmt
->decode
) (fmt
, r
, buf
);
2715 /* Return the number of bits of the largest binary value that the
2716 significand of MODE will hold. */
2717 /* ??? Legacy. Should get access to real_format directly. */
2720 significand_size (enum machine_mode mode
)
2722 const struct real_format
*fmt
;
2724 fmt
= REAL_MODE_FORMAT (mode
);
2730 /* Return the size in bits of the largest binary value that can be
2731 held by the decimal coefficient for this mode. This is one more
2732 than the number of bits required to hold the largest coefficient
2734 double log2_10
= 3.3219281;
2735 return fmt
->p
* log2_10
;
2740 /* Return a hash value for the given real value. */
2741 /* ??? The "unsigned int" return value is intended to be hashval_t,
2742 but I didn't want to pull hashtab.h into real.h. */
2745 real_hash (const REAL_VALUE_TYPE
*r
)
2750 h
= r
->cl
| (r
->sign
<< 2);
2758 h
|= REAL_EXP (r
) << 3;
2763 h
^= (unsigned int)-1;
2772 if (sizeof(unsigned long) > sizeof(unsigned int))
2773 for (i
= 0; i
< SIGSZ
; ++i
)
2775 unsigned long s
= r
->sig
[i
];
2776 h
^= s
^ (s
>> (HOST_BITS_PER_LONG
/ 2));
2779 for (i
= 0; i
< SIGSZ
; ++i
)
2785 /* IEEE single-precision format. */
2787 static void encode_ieee_single (const struct real_format
*fmt
,
2788 long *, const REAL_VALUE_TYPE
*);
2789 static void decode_ieee_single (const struct real_format
*,
2790 REAL_VALUE_TYPE
*, const long *);
2793 encode_ieee_single (const struct real_format
*fmt
, long *buf
,
2794 const REAL_VALUE_TYPE
*r
)
2796 unsigned long image
, sig
, exp
;
2797 unsigned long sign
= r
->sign
;
2798 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2801 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
2812 image
|= 0x7fffffff;
2819 sig
= (fmt
->canonical_nan_lsbs_set
? (1 << 22) - 1 : 0);
2820 if (r
->signalling
== fmt
->qnan_msb_set
)
2831 image
|= 0x7fffffff;
2835 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2836 whereas the intermediate representation is 0.F x 2**exp.
2837 Which means we're off by one. */
2841 exp
= REAL_EXP (r
) + 127 - 1;
2854 decode_ieee_single (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
2857 unsigned long image
= buf
[0] & 0xffffffff;
2858 bool sign
= (image
>> 31) & 1;
2859 int exp
= (image
>> 23) & 0xff;
2861 memset (r
, 0, sizeof (*r
));
2862 image
<<= HOST_BITS_PER_LONG
- 24;
2867 if (image
&& fmt
->has_denorm
)
2871 SET_REAL_EXP (r
, -126);
2872 r
->sig
[SIGSZ
-1] = image
<< 1;
2875 else if (fmt
->has_signed_zero
)
2878 else if (exp
== 255 && (fmt
->has_nans
|| fmt
->has_inf
))
2884 r
->signalling
= (((image
>> (HOST_BITS_PER_LONG
- 2)) & 1)
2885 ^ fmt
->qnan_msb_set
);
2886 r
->sig
[SIGSZ
-1] = image
;
2898 SET_REAL_EXP (r
, exp
- 127 + 1);
2899 r
->sig
[SIGSZ
-1] = image
| SIG_MSB
;
2903 const struct real_format ieee_single_format
=
2924 const struct real_format mips_single_format
=
2945 const struct real_format motorola_single_format
=
2966 /* SPU Single Precision (Extended-Range Mode) format is the same as IEEE
2967 single precision with the following differences:
2968 - Infinities are not supported. Instead MAX_FLOAT or MIN_FLOAT
2970 - NaNs are not supported.
2971 - The range of non-zero numbers in binary is
2972 (001)[1.]000...000 to (255)[1.]111...111.
2973 - Denormals can be represented, but are treated as +0.0 when
2974 used as an operand and are never generated as a result.
2975 - -0.0 can be represented, but a zero result is always +0.0.
2976 - the only supported rounding mode is trunction (towards zero). */
2977 const struct real_format spu_single_format
=
2998 /* IEEE double-precision format. */
3000 static void encode_ieee_double (const struct real_format
*fmt
,
3001 long *, const REAL_VALUE_TYPE
*);
3002 static void decode_ieee_double (const struct real_format
*,
3003 REAL_VALUE_TYPE
*, const long *);
3006 encode_ieee_double (const struct real_format
*fmt
, long *buf
,
3007 const REAL_VALUE_TYPE
*r
)
3009 unsigned long image_lo
, image_hi
, sig_lo
, sig_hi
, exp
;
3010 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3012 image_hi
= r
->sign
<< 31;
3015 if (HOST_BITS_PER_LONG
== 64)
3017 sig_hi
= r
->sig
[SIGSZ
-1];
3018 sig_lo
= (sig_hi
>> (64 - 53)) & 0xffffffff;
3019 sig_hi
= (sig_hi
>> (64 - 53 + 1) >> 31) & 0xfffff;
3023 sig_hi
= r
->sig
[SIGSZ
-1];
3024 sig_lo
= r
->sig
[SIGSZ
-2];
3025 sig_lo
= (sig_hi
<< 21) | (sig_lo
>> 11);
3026 sig_hi
= (sig_hi
>> 11) & 0xfffff;
3036 image_hi
|= 2047 << 20;
3039 image_hi
|= 0x7fffffff;
3040 image_lo
= 0xffffffff;
3049 if (fmt
->canonical_nan_lsbs_set
)
3051 sig_hi
= (1 << 19) - 1;
3052 sig_lo
= 0xffffffff;
3060 if (r
->signalling
== fmt
->qnan_msb_set
)
3061 sig_hi
&= ~(1 << 19);
3064 if (sig_hi
== 0 && sig_lo
== 0)
3067 image_hi
|= 2047 << 20;
3073 image_hi
|= 0x7fffffff;
3074 image_lo
= 0xffffffff;
3079 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3080 whereas the intermediate representation is 0.F x 2**exp.
3081 Which means we're off by one. */
3085 exp
= REAL_EXP (r
) + 1023 - 1;
3086 image_hi
|= exp
<< 20;
3095 if (FLOAT_WORDS_BIG_ENDIAN
)
3096 buf
[0] = image_hi
, buf
[1] = image_lo
;
3098 buf
[0] = image_lo
, buf
[1] = image_hi
;
3102 decode_ieee_double (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3105 unsigned long image_hi
, image_lo
;
3109 if (FLOAT_WORDS_BIG_ENDIAN
)
3110 image_hi
= buf
[0], image_lo
= buf
[1];
3112 image_lo
= buf
[0], image_hi
= buf
[1];
3113 image_lo
&= 0xffffffff;
3114 image_hi
&= 0xffffffff;
3116 sign
= (image_hi
>> 31) & 1;
3117 exp
= (image_hi
>> 20) & 0x7ff;
3119 memset (r
, 0, sizeof (*r
));
3121 image_hi
<<= 32 - 21;
3122 image_hi
|= image_lo
>> 21;
3123 image_hi
&= 0x7fffffff;
3124 image_lo
<<= 32 - 21;
3128 if ((image_hi
|| image_lo
) && fmt
->has_denorm
)
3132 SET_REAL_EXP (r
, -1022);
3133 if (HOST_BITS_PER_LONG
== 32)
3135 image_hi
= (image_hi
<< 1) | (image_lo
>> 31);
3137 r
->sig
[SIGSZ
-1] = image_hi
;
3138 r
->sig
[SIGSZ
-2] = image_lo
;
3142 image_hi
= (image_hi
<< 31 << 2) | (image_lo
<< 1);
3143 r
->sig
[SIGSZ
-1] = image_hi
;
3147 else if (fmt
->has_signed_zero
)
3150 else if (exp
== 2047 && (fmt
->has_nans
|| fmt
->has_inf
))
3152 if (image_hi
|| image_lo
)
3156 r
->signalling
= ((image_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
3157 if (HOST_BITS_PER_LONG
== 32)
3159 r
->sig
[SIGSZ
-1] = image_hi
;
3160 r
->sig
[SIGSZ
-2] = image_lo
;
3163 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
;
3175 SET_REAL_EXP (r
, exp
- 1023 + 1);
3176 if (HOST_BITS_PER_LONG
== 32)
3178 r
->sig
[SIGSZ
-1] = image_hi
| SIG_MSB
;
3179 r
->sig
[SIGSZ
-2] = image_lo
;
3182 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
| SIG_MSB
;
3186 const struct real_format ieee_double_format
=
3207 const struct real_format mips_double_format
=
3228 const struct real_format motorola_double_format
=
3249 /* IEEE extended real format. This comes in three flavors: Intel's as
3250 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
3251 12- and 16-byte images may be big- or little endian; Motorola's is
3252 always big endian. */
3254 /* Helper subroutine which converts from the internal format to the
3255 12-byte little-endian Intel format. Functions below adjust this
3256 for the other possible formats. */
3258 encode_ieee_extended (const struct real_format
*fmt
, long *buf
,
3259 const REAL_VALUE_TYPE
*r
)
3261 unsigned long image_hi
, sig_hi
, sig_lo
;
3262 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3264 image_hi
= r
->sign
<< 15;
3265 sig_hi
= sig_lo
= 0;
3277 /* Intel requires the explicit integer bit to be set, otherwise
3278 it considers the value a "pseudo-infinity". Motorola docs
3279 say it doesn't care. */
3280 sig_hi
= 0x80000000;
3285 sig_lo
= sig_hi
= 0xffffffff;
3295 if (fmt
->canonical_nan_lsbs_set
)
3297 sig_hi
= (1 << 30) - 1;
3298 sig_lo
= 0xffffffff;
3301 else if (HOST_BITS_PER_LONG
== 32)
3303 sig_hi
= r
->sig
[SIGSZ
-1];
3304 sig_lo
= r
->sig
[SIGSZ
-2];
3308 sig_lo
= r
->sig
[SIGSZ
-1];
3309 sig_hi
= sig_lo
>> 31 >> 1;
3310 sig_lo
&= 0xffffffff;
3312 if (r
->signalling
== fmt
->qnan_msb_set
)
3313 sig_hi
&= ~(1 << 30);
3316 if ((sig_hi
& 0x7fffffff) == 0 && sig_lo
== 0)
3319 /* Intel requires the explicit integer bit to be set, otherwise
3320 it considers the value a "pseudo-nan". Motorola docs say it
3322 sig_hi
|= 0x80000000;
3327 sig_lo
= sig_hi
= 0xffffffff;
3333 int exp
= REAL_EXP (r
);
3335 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3336 whereas the intermediate representation is 0.F x 2**exp.
3337 Which means we're off by one.
3339 Except for Motorola, which consider exp=0 and explicit
3340 integer bit set to continue to be normalized. In theory
3341 this discrepancy has been taken care of by the difference
3342 in fmt->emin in round_for_format. */
3349 gcc_assert (exp
>= 0);
3353 if (HOST_BITS_PER_LONG
== 32)
3355 sig_hi
= r
->sig
[SIGSZ
-1];
3356 sig_lo
= r
->sig
[SIGSZ
-2];
3360 sig_lo
= r
->sig
[SIGSZ
-1];
3361 sig_hi
= sig_lo
>> 31 >> 1;
3362 sig_lo
&= 0xffffffff;
3371 buf
[0] = sig_lo
, buf
[1] = sig_hi
, buf
[2] = image_hi
;
3374 /* Convert from the internal format to the 12-byte Motorola format
3375 for an IEEE extended real. */
3377 encode_ieee_extended_motorola (const struct real_format
*fmt
, long *buf
,
3378 const REAL_VALUE_TYPE
*r
)
3381 encode_ieee_extended (fmt
, intermed
, r
);
3383 /* Motorola chips are assumed always to be big-endian. Also, the
3384 padding in a Motorola extended real goes between the exponent and
3385 the mantissa. At this point the mantissa is entirely within
3386 elements 0 and 1 of intermed, and the exponent entirely within
3387 element 2, so all we have to do is swap the order around, and
3388 shift element 2 left 16 bits. */
3389 buf
[0] = intermed
[2] << 16;
3390 buf
[1] = intermed
[1];
3391 buf
[2] = intermed
[0];
3394 /* Convert from the internal format to the 12-byte Intel format for
3395 an IEEE extended real. */
3397 encode_ieee_extended_intel_96 (const struct real_format
*fmt
, long *buf
,
3398 const REAL_VALUE_TYPE
*r
)
3400 if (FLOAT_WORDS_BIG_ENDIAN
)
3402 /* All the padding in an Intel-format extended real goes at the high
3403 end, which in this case is after the mantissa, not the exponent.
3404 Therefore we must shift everything down 16 bits. */
3406 encode_ieee_extended (fmt
, intermed
, r
);
3407 buf
[0] = ((intermed
[2] << 16) | ((unsigned long)(intermed
[1] & 0xFFFF0000) >> 16));
3408 buf
[1] = ((intermed
[1] << 16) | ((unsigned long)(intermed
[0] & 0xFFFF0000) >> 16));
3409 buf
[2] = (intermed
[0] << 16);
3412 /* encode_ieee_extended produces what we want directly. */
3413 encode_ieee_extended (fmt
, buf
, r
);
3416 /* Convert from the internal format to the 16-byte Intel format for
3417 an IEEE extended real. */
3419 encode_ieee_extended_intel_128 (const struct real_format
*fmt
, long *buf
,
3420 const REAL_VALUE_TYPE
*r
)
3422 /* All the padding in an Intel-format extended real goes at the high end. */
3423 encode_ieee_extended_intel_96 (fmt
, buf
, r
);
3427 /* As above, we have a helper function which converts from 12-byte
3428 little-endian Intel format to internal format. Functions below
3429 adjust for the other possible formats. */
3431 decode_ieee_extended (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3434 unsigned long image_hi
, sig_hi
, sig_lo
;
3438 sig_lo
= buf
[0], sig_hi
= buf
[1], image_hi
= buf
[2];
3439 sig_lo
&= 0xffffffff;
3440 sig_hi
&= 0xffffffff;
3441 image_hi
&= 0xffffffff;
3443 sign
= (image_hi
>> 15) & 1;
3444 exp
= image_hi
& 0x7fff;
3446 memset (r
, 0, sizeof (*r
));
3450 if ((sig_hi
|| sig_lo
) && fmt
->has_denorm
)
3455 /* When the IEEE format contains a hidden bit, we know that
3456 it's zero at this point, and so shift up the significand
3457 and decrease the exponent to match. In this case, Motorola
3458 defines the explicit integer bit to be valid, so we don't
3459 know whether the msb is set or not. */
3460 SET_REAL_EXP (r
, fmt
->emin
);
3461 if (HOST_BITS_PER_LONG
== 32)
3463 r
->sig
[SIGSZ
-1] = sig_hi
;
3464 r
->sig
[SIGSZ
-2] = sig_lo
;
3467 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3471 else if (fmt
->has_signed_zero
)
3474 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3476 /* See above re "pseudo-infinities" and "pseudo-nans".
3477 Short summary is that the MSB will likely always be
3478 set, and that we don't care about it. */
3479 sig_hi
&= 0x7fffffff;
3481 if (sig_hi
|| sig_lo
)
3485 r
->signalling
= ((sig_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
3486 if (HOST_BITS_PER_LONG
== 32)
3488 r
->sig
[SIGSZ
-1] = sig_hi
;
3489 r
->sig
[SIGSZ
-2] = sig_lo
;
3492 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3504 SET_REAL_EXP (r
, exp
- 16383 + 1);
3505 if (HOST_BITS_PER_LONG
== 32)
3507 r
->sig
[SIGSZ
-1] = sig_hi
;
3508 r
->sig
[SIGSZ
-2] = sig_lo
;
3511 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3515 /* Convert from the internal format to the 12-byte Motorola format
3516 for an IEEE extended real. */
3518 decode_ieee_extended_motorola (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3523 /* Motorola chips are assumed always to be big-endian. Also, the
3524 padding in a Motorola extended real goes between the exponent and
3525 the mantissa; remove it. */
3526 intermed
[0] = buf
[2];
3527 intermed
[1] = buf
[1];
3528 intermed
[2] = (unsigned long)buf
[0] >> 16;
3530 decode_ieee_extended (fmt
, r
, intermed
);
3533 /* Convert from the internal format to the 12-byte Intel format for
3534 an IEEE extended real. */
3536 decode_ieee_extended_intel_96 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3539 if (FLOAT_WORDS_BIG_ENDIAN
)
3541 /* All the padding in an Intel-format extended real goes at the high
3542 end, which in this case is after the mantissa, not the exponent.
3543 Therefore we must shift everything up 16 bits. */
3546 intermed
[0] = (((unsigned long)buf
[2] >> 16) | (buf
[1] << 16));
3547 intermed
[1] = (((unsigned long)buf
[1] >> 16) | (buf
[0] << 16));
3548 intermed
[2] = ((unsigned long)buf
[0] >> 16);
3550 decode_ieee_extended (fmt
, r
, intermed
);
3553 /* decode_ieee_extended produces what we want directly. */
3554 decode_ieee_extended (fmt
, r
, buf
);
3557 /* Convert from the internal format to the 16-byte Intel format for
3558 an IEEE extended real. */
3560 decode_ieee_extended_intel_128 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3563 /* All the padding in an Intel-format extended real goes at the high end. */
3564 decode_ieee_extended_intel_96 (fmt
, r
, buf
);
3567 const struct real_format ieee_extended_motorola_format
=
3569 encode_ieee_extended_motorola
,
3570 decode_ieee_extended_motorola
,
3588 const struct real_format ieee_extended_intel_96_format
=
3590 encode_ieee_extended_intel_96
,
3591 decode_ieee_extended_intel_96
,
3609 const struct real_format ieee_extended_intel_128_format
=
3611 encode_ieee_extended_intel_128
,
3612 decode_ieee_extended_intel_128
,
3630 /* The following caters to i386 systems that set the rounding precision
3631 to 53 bits instead of 64, e.g. FreeBSD. */
3632 const struct real_format ieee_extended_intel_96_round_53_format
=
3634 encode_ieee_extended_intel_96
,
3635 decode_ieee_extended_intel_96
,
3653 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3654 numbers whose sum is equal to the extended precision value. The number
3655 with greater magnitude is first. This format has the same magnitude
3656 range as an IEEE double precision value, but effectively 106 bits of
3657 significand precision. Infinity and NaN are represented by their IEEE
3658 double precision value stored in the first number, the second number is
3659 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3661 static void encode_ibm_extended (const struct real_format
*fmt
,
3662 long *, const REAL_VALUE_TYPE
*);
3663 static void decode_ibm_extended (const struct real_format
*,
3664 REAL_VALUE_TYPE
*, const long *);
3667 encode_ibm_extended (const struct real_format
*fmt
, long *buf
,
3668 const REAL_VALUE_TYPE
*r
)
3670 REAL_VALUE_TYPE u
, normr
, v
;
3671 const struct real_format
*base_fmt
;
3673 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3675 /* Renormalize R before doing any arithmetic on it. */
3677 if (normr
.cl
== rvc_normal
)
3680 /* u = IEEE double precision portion of significand. */
3682 round_for_format (base_fmt
, &u
);
3683 encode_ieee_double (base_fmt
, &buf
[0], &u
);
3685 if (u
.cl
== rvc_normal
)
3687 do_add (&v
, &normr
, &u
, 1);
3688 /* Call round_for_format since we might need to denormalize. */
3689 round_for_format (base_fmt
, &v
);
3690 encode_ieee_double (base_fmt
, &buf
[2], &v
);
3694 /* Inf, NaN, 0 are all representable as doubles, so the
3695 least-significant part can be 0.0. */
3702 decode_ibm_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
, REAL_VALUE_TYPE
*r
,
3705 REAL_VALUE_TYPE u
, v
;
3706 const struct real_format
*base_fmt
;
3708 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3709 decode_ieee_double (base_fmt
, &u
, &buf
[0]);
3711 if (u
.cl
!= rvc_zero
&& u
.cl
!= rvc_inf
&& u
.cl
!= rvc_nan
)
3713 decode_ieee_double (base_fmt
, &v
, &buf
[2]);
3714 do_add (r
, &u
, &v
, 0);
3720 const struct real_format ibm_extended_format
=
3722 encode_ibm_extended
,
3723 decode_ibm_extended
,
3741 const struct real_format mips_extended_format
=
3743 encode_ibm_extended
,
3744 decode_ibm_extended
,
3763 /* IEEE quad precision format. */
3765 static void encode_ieee_quad (const struct real_format
*fmt
,
3766 long *, const REAL_VALUE_TYPE
*);
3767 static void decode_ieee_quad (const struct real_format
*,
3768 REAL_VALUE_TYPE
*, const long *);
3771 encode_ieee_quad (const struct real_format
*fmt
, long *buf
,
3772 const REAL_VALUE_TYPE
*r
)
3774 unsigned long image3
, image2
, image1
, image0
, exp
;
3775 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3778 image3
= r
->sign
<< 31;
3783 rshift_significand (&u
, r
, SIGNIFICAND_BITS
- 113);
3792 image3
|= 32767 << 16;
3795 image3
|= 0x7fffffff;
3796 image2
= 0xffffffff;
3797 image1
= 0xffffffff;
3798 image0
= 0xffffffff;
3805 image3
|= 32767 << 16;
3809 if (fmt
->canonical_nan_lsbs_set
)
3812 image2
= image1
= image0
= 0xffffffff;
3815 else if (HOST_BITS_PER_LONG
== 32)
3820 image3
|= u
.sig
[3] & 0xffff;
3825 image1
= image0
>> 31 >> 1;
3827 image3
|= (image2
>> 31 >> 1) & 0xffff;
3828 image0
&= 0xffffffff;
3829 image2
&= 0xffffffff;
3831 if (r
->signalling
== fmt
->qnan_msb_set
)
3835 if (((image3
& 0xffff) | image2
| image1
| image0
) == 0)
3840 image3
|= 0x7fffffff;
3841 image2
= 0xffffffff;
3842 image1
= 0xffffffff;
3843 image0
= 0xffffffff;
3848 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3849 whereas the intermediate representation is 0.F x 2**exp.
3850 Which means we're off by one. */
3854 exp
= REAL_EXP (r
) + 16383 - 1;
3855 image3
|= exp
<< 16;
3857 if (HOST_BITS_PER_LONG
== 32)
3862 image3
|= u
.sig
[3] & 0xffff;
3867 image1
= image0
>> 31 >> 1;
3869 image3
|= (image2
>> 31 >> 1) & 0xffff;
3870 image0
&= 0xffffffff;
3871 image2
&= 0xffffffff;
3879 if (FLOAT_WORDS_BIG_ENDIAN
)
3896 decode_ieee_quad (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3899 unsigned long image3
, image2
, image1
, image0
;
3903 if (FLOAT_WORDS_BIG_ENDIAN
)
3917 image0
&= 0xffffffff;
3918 image1
&= 0xffffffff;
3919 image2
&= 0xffffffff;
3921 sign
= (image3
>> 31) & 1;
3922 exp
= (image3
>> 16) & 0x7fff;
3925 memset (r
, 0, sizeof (*r
));
3929 if ((image3
| image2
| image1
| image0
) && fmt
->has_denorm
)
3934 SET_REAL_EXP (r
, -16382 + (SIGNIFICAND_BITS
- 112));
3935 if (HOST_BITS_PER_LONG
== 32)
3944 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3945 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3950 else if (fmt
->has_signed_zero
)
3953 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3955 if (image3
| image2
| image1
| image0
)
3959 r
->signalling
= ((image3
>> 15) & 1) ^ fmt
->qnan_msb_set
;
3961 if (HOST_BITS_PER_LONG
== 32)
3970 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3971 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3973 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3985 SET_REAL_EXP (r
, exp
- 16383 + 1);
3987 if (HOST_BITS_PER_LONG
== 32)
3996 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3997 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3999 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
4000 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4004 const struct real_format ieee_quad_format
=
4025 const struct real_format mips_quad_format
=
4046 /* Descriptions of VAX floating point formats can be found beginning at
4048 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
4050 The thing to remember is that they're almost IEEE, except for word
4051 order, exponent bias, and the lack of infinities, nans, and denormals.
4053 We don't implement the H_floating format here, simply because neither
4054 the VAX or Alpha ports use it. */
4056 static void encode_vax_f (const struct real_format
*fmt
,
4057 long *, const REAL_VALUE_TYPE
*);
4058 static void decode_vax_f (const struct real_format
*,
4059 REAL_VALUE_TYPE
*, const long *);
4060 static void encode_vax_d (const struct real_format
*fmt
,
4061 long *, const REAL_VALUE_TYPE
*);
4062 static void decode_vax_d (const struct real_format
*,
4063 REAL_VALUE_TYPE
*, const long *);
4064 static void encode_vax_g (const struct real_format
*fmt
,
4065 long *, const REAL_VALUE_TYPE
*);
4066 static void decode_vax_g (const struct real_format
*,
4067 REAL_VALUE_TYPE
*, const long *);
4070 encode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4071 const REAL_VALUE_TYPE
*r
)
4073 unsigned long sign
, exp
, sig
, image
;
4075 sign
= r
->sign
<< 15;
4085 image
= 0xffff7fff | sign
;
4089 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
4090 exp
= REAL_EXP (r
) + 128;
4092 image
= (sig
<< 16) & 0xffff0000;
4106 decode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4107 REAL_VALUE_TYPE
*r
, const long *buf
)
4109 unsigned long image
= buf
[0] & 0xffffffff;
4110 int exp
= (image
>> 7) & 0xff;
4112 memset (r
, 0, sizeof (*r
));
4117 r
->sign
= (image
>> 15) & 1;
4118 SET_REAL_EXP (r
, exp
- 128);
4120 image
= ((image
& 0x7f) << 16) | ((image
>> 16) & 0xffff);
4121 r
->sig
[SIGSZ
-1] = (image
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
4126 encode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4127 const REAL_VALUE_TYPE
*r
)
4129 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
4134 image0
= image1
= 0;
4139 image0
= 0xffff7fff | sign
;
4140 image1
= 0xffffffff;
4144 /* Extract the significand into straight hi:lo. */
4145 if (HOST_BITS_PER_LONG
== 64)
4147 image0
= r
->sig
[SIGSZ
-1];
4148 image1
= (image0
>> (64 - 56)) & 0xffffffff;
4149 image0
= (image0
>> (64 - 56 + 1) >> 31) & 0x7fffff;
4153 image0
= r
->sig
[SIGSZ
-1];
4154 image1
= r
->sig
[SIGSZ
-2];
4155 image1
= (image0
<< 24) | (image1
>> 8);
4156 image0
= (image0
>> 8) & 0xffffff;
4159 /* Rearrange the half-words of the significand to match the
4161 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff007f;
4162 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
4164 /* Add the sign and exponent. */
4166 image0
|= (REAL_EXP (r
) + 128) << 7;
4173 if (FLOAT_WORDS_BIG_ENDIAN
)
4174 buf
[0] = image1
, buf
[1] = image0
;
4176 buf
[0] = image0
, buf
[1] = image1
;
4180 decode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4181 REAL_VALUE_TYPE
*r
, const long *buf
)
4183 unsigned long image0
, image1
;
4186 if (FLOAT_WORDS_BIG_ENDIAN
)
4187 image1
= buf
[0], image0
= buf
[1];
4189 image0
= buf
[0], image1
= buf
[1];
4190 image0
&= 0xffffffff;
4191 image1
&= 0xffffffff;
4193 exp
= (image0
>> 7) & 0xff;
4195 memset (r
, 0, sizeof (*r
));
4200 r
->sign
= (image0
>> 15) & 1;
4201 SET_REAL_EXP (r
, exp
- 128);
4203 /* Rearrange the half-words of the external format into
4204 proper ascending order. */
4205 image0
= ((image0
& 0x7f) << 16) | ((image0
>> 16) & 0xffff);
4206 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
4208 if (HOST_BITS_PER_LONG
== 64)
4210 image0
= (image0
<< 31 << 1) | image1
;
4213 r
->sig
[SIGSZ
-1] = image0
;
4217 r
->sig
[SIGSZ
-1] = image0
;
4218 r
->sig
[SIGSZ
-2] = image1
;
4219 lshift_significand (r
, r
, 2*HOST_BITS_PER_LONG
- 56);
4220 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4226 encode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4227 const REAL_VALUE_TYPE
*r
)
4229 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
4234 image0
= image1
= 0;
4239 image0
= 0xffff7fff | sign
;
4240 image1
= 0xffffffff;
4244 /* Extract the significand into straight hi:lo. */
4245 if (HOST_BITS_PER_LONG
== 64)
4247 image0
= r
->sig
[SIGSZ
-1];
4248 image1
= (image0
>> (64 - 53)) & 0xffffffff;
4249 image0
= (image0
>> (64 - 53 + 1) >> 31) & 0xfffff;
4253 image0
= r
->sig
[SIGSZ
-1];
4254 image1
= r
->sig
[SIGSZ
-2];
4255 image1
= (image0
<< 21) | (image1
>> 11);
4256 image0
= (image0
>> 11) & 0xfffff;
4259 /* Rearrange the half-words of the significand to match the
4261 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff000f;
4262 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
4264 /* Add the sign and exponent. */
4266 image0
|= (REAL_EXP (r
) + 1024) << 4;
4273 if (FLOAT_WORDS_BIG_ENDIAN
)
4274 buf
[0] = image1
, buf
[1] = image0
;
4276 buf
[0] = image0
, buf
[1] = image1
;
4280 decode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4281 REAL_VALUE_TYPE
*r
, const long *buf
)
4283 unsigned long image0
, image1
;
4286 if (FLOAT_WORDS_BIG_ENDIAN
)
4287 image1
= buf
[0], image0
= buf
[1];
4289 image0
= buf
[0], image1
= buf
[1];
4290 image0
&= 0xffffffff;
4291 image1
&= 0xffffffff;
4293 exp
= (image0
>> 4) & 0x7ff;
4295 memset (r
, 0, sizeof (*r
));
4300 r
->sign
= (image0
>> 15) & 1;
4301 SET_REAL_EXP (r
, exp
- 1024);
4303 /* Rearrange the half-words of the external format into
4304 proper ascending order. */
4305 image0
= ((image0
& 0xf) << 16) | ((image0
>> 16) & 0xffff);
4306 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
4308 if (HOST_BITS_PER_LONG
== 64)
4310 image0
= (image0
<< 31 << 1) | image1
;
4313 r
->sig
[SIGSZ
-1] = image0
;
4317 r
->sig
[SIGSZ
-1] = image0
;
4318 r
->sig
[SIGSZ
-2] = image1
;
4319 lshift_significand (r
, r
, 64 - 53);
4320 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4325 const struct real_format vax_f_format
=
4346 const struct real_format vax_d_format
=
4367 const struct real_format vax_g_format
=
4388 /* Encode real R into a single precision DFP value in BUF. */
4390 encode_decimal_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4391 long *buf ATTRIBUTE_UNUSED
,
4392 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4394 encode_decimal32 (fmt
, buf
, r
);
4397 /* Decode a single precision DFP value in BUF into a real R. */
4399 decode_decimal_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4400 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4401 const long *buf ATTRIBUTE_UNUSED
)
4403 decode_decimal32 (fmt
, r
, buf
);
4406 /* Encode real R into a double precision DFP value in BUF. */
4408 encode_decimal_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4409 long *buf ATTRIBUTE_UNUSED
,
4410 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4412 encode_decimal64 (fmt
, buf
, r
);
4415 /* Decode a double precision DFP value in BUF into a real R. */
4417 decode_decimal_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4418 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4419 const long *buf ATTRIBUTE_UNUSED
)
4421 decode_decimal64 (fmt
, r
, buf
);
4424 /* Encode real R into a quad precision DFP value in BUF. */
4426 encode_decimal_quad (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4427 long *buf ATTRIBUTE_UNUSED
,
4428 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4430 encode_decimal128 (fmt
, buf
, r
);
4433 /* Decode a quad precision DFP value in BUF into a real R. */
4435 decode_decimal_quad (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4436 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4437 const long *buf ATTRIBUTE_UNUSED
)
4439 decode_decimal128 (fmt
, r
, buf
);
4442 /* Single precision decimal floating point (IEEE 754). */
4443 const struct real_format decimal_single_format
=
4445 encode_decimal_single
,
4446 decode_decimal_single
,
4464 /* Double precision decimal floating point (IEEE 754). */
4465 const struct real_format decimal_double_format
=
4467 encode_decimal_double
,
4468 decode_decimal_double
,
4486 /* Quad precision decimal floating point (IEEE 754). */
4487 const struct real_format decimal_quad_format
=
4489 encode_decimal_quad
,
4490 decode_decimal_quad
,
4508 /* A synthetic "format" for internal arithmetic. It's the size of the
4509 internal significand minus the two bits needed for proper rounding.
4510 The encode and decode routines exist only to satisfy our paranoia
4513 static void encode_internal (const struct real_format
*fmt
,
4514 long *, const REAL_VALUE_TYPE
*);
4515 static void decode_internal (const struct real_format
*,
4516 REAL_VALUE_TYPE
*, const long *);
4519 encode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4520 const REAL_VALUE_TYPE
*r
)
4522 memcpy (buf
, r
, sizeof (*r
));
4526 decode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4527 REAL_VALUE_TYPE
*r
, const long *buf
)
4529 memcpy (r
, buf
, sizeof (*r
));
4532 const struct real_format real_internal_format
=
4537 SIGNIFICAND_BITS
- 2,
4538 SIGNIFICAND_BITS
- 2,
4553 /* Calculate the square root of X in mode MODE, and store the result
4554 in R. Return TRUE if the operation does not raise an exception.
4555 For details see "High Precision Division and Square Root",
4556 Alan H. Karp and Peter Markstein, HP Lab Report 93-93-42, June
4557 1993. http://www.hpl.hp.com/techreports/93/HPL-93-42.pdf. */
4560 real_sqrt (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4561 const REAL_VALUE_TYPE
*x
)
4563 static REAL_VALUE_TYPE halfthree
;
4564 static bool init
= false;
4565 REAL_VALUE_TYPE h
, t
, i
;
4568 /* sqrt(-0.0) is -0.0. */
4569 if (real_isnegzero (x
))
4575 /* Negative arguments return NaN. */
4578 get_canonical_qnan (r
, 0);
4582 /* Infinity and NaN return themselves. */
4583 if (!real_isfinite (x
))
4591 do_add (&halfthree
, &dconst1
, &dconsthalf
, 0);
4595 /* Initial guess for reciprocal sqrt, i. */
4596 exp
= real_exponent (x
);
4597 real_ldexp (&i
, &dconst1
, -exp
/2);
4599 /* Newton's iteration for reciprocal sqrt, i. */
4600 for (iter
= 0; iter
< 16; iter
++)
4602 /* i(n+1) = i(n) * (1.5 - 0.5*i(n)*i(n)*x). */
4603 do_multiply (&t
, x
, &i
);
4604 do_multiply (&h
, &t
, &i
);
4605 do_multiply (&t
, &h
, &dconsthalf
);
4606 do_add (&h
, &halfthree
, &t
, 1);
4607 do_multiply (&t
, &i
, &h
);
4609 /* Check for early convergence. */
4610 if (iter
>= 6 && real_identical (&i
, &t
))
4613 /* ??? Unroll loop to avoid copying. */
4617 /* Final iteration: r = i*x + 0.5*i*x*(1.0 - i*(i*x)). */
4618 do_multiply (&t
, x
, &i
);
4619 do_multiply (&h
, &t
, &i
);
4620 do_add (&i
, &dconst1
, &h
, 1);
4621 do_multiply (&h
, &t
, &i
);
4622 do_multiply (&i
, &dconsthalf
, &h
);
4623 do_add (&h
, &t
, &i
, 0);
4625 /* ??? We need a Tuckerman test to get the last bit. */
4627 real_convert (r
, mode
, &h
);
4631 /* Calculate X raised to the integer exponent N in mode MODE and store
4632 the result in R. Return true if the result may be inexact due to
4633 loss of precision. The algorithm is the classic "left-to-right binary
4634 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
4635 Algorithms", "The Art of Computer Programming", Volume 2. */
4638 real_powi (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4639 const REAL_VALUE_TYPE
*x
, HOST_WIDE_INT n
)
4641 unsigned HOST_WIDE_INT bit
;
4643 bool inexact
= false;
4655 /* Don't worry about overflow, from now on n is unsigned. */
4663 bit
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
4664 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
; i
++)
4668 inexact
|= do_multiply (&t
, &t
, &t
);
4670 inexact
|= do_multiply (&t
, &t
, x
);
4678 inexact
|= do_divide (&t
, &dconst1
, &t
);
4680 real_convert (r
, mode
, &t
);
4684 /* Round X to the nearest integer not larger in absolute value, i.e.
4685 towards zero, placing the result in R in mode MODE. */
4688 real_trunc (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4689 const REAL_VALUE_TYPE
*x
)
4691 do_fix_trunc (r
, x
);
4692 if (mode
!= VOIDmode
)
4693 real_convert (r
, mode
, r
);
4696 /* Round X to the largest integer not greater in value, i.e. round
4697 down, placing the result in R in mode MODE. */
4700 real_floor (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4701 const REAL_VALUE_TYPE
*x
)
4705 do_fix_trunc (&t
, x
);
4706 if (! real_identical (&t
, x
) && x
->sign
)
4707 do_add (&t
, &t
, &dconstm1
, 0);
4708 if (mode
!= VOIDmode
)
4709 real_convert (r
, mode
, &t
);
4714 /* Round X to the smallest integer not less then argument, i.e. round
4715 up, placing the result in R in mode MODE. */
4718 real_ceil (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4719 const REAL_VALUE_TYPE
*x
)
4723 do_fix_trunc (&t
, x
);
4724 if (! real_identical (&t
, x
) && ! x
->sign
)
4725 do_add (&t
, &t
, &dconst1
, 0);
4726 if (mode
!= VOIDmode
)
4727 real_convert (r
, mode
, &t
);
4732 /* Round X to the nearest integer, but round halfway cases away from
4736 real_round (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4737 const REAL_VALUE_TYPE
*x
)
4739 do_add (r
, x
, &dconsthalf
, x
->sign
);
4740 do_fix_trunc (r
, r
);
4741 if (mode
!= VOIDmode
)
4742 real_convert (r
, mode
, r
);
4745 /* Set the sign of R to the sign of X. */
4748 real_copysign (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*x
)
4753 /* Convert from REAL_VALUE_TYPE to MPFR. The caller is responsible
4754 for initializing and clearing the MPFR parameter. */
4757 mpfr_from_real (mpfr_ptr m
, const REAL_VALUE_TYPE
*r
, mp_rnd_t rndmode
)
4759 /* We use a string as an intermediate type. */
4763 /* Take care of Infinity and NaN. */
4764 if (r
->cl
== rvc_inf
)
4766 mpfr_set_inf (m
, r
->sign
== 1 ? -1 : 1);
4770 if (r
->cl
== rvc_nan
)
4776 real_to_hexadecimal (buf
, r
, sizeof (buf
), 0, 1);
4777 /* mpfr_set_str() parses hexadecimal floats from strings in the same
4778 format that GCC will output them. Nothing extra is needed. */
4779 ret
= mpfr_set_str (m
, buf
, 16, rndmode
);
4780 gcc_assert (ret
== 0);
4783 /* Convert from MPFR to REAL_VALUE_TYPE, for a given type TYPE and rounding
4784 mode RNDMODE. TYPE is only relevant if M is a NaN. */
4787 real_from_mpfr (REAL_VALUE_TYPE
*r
, mpfr_srcptr m
, tree type
, mp_rnd_t rndmode
)
4789 /* We use a string as an intermediate type. */
4790 char buf
[128], *rstr
;
4793 /* Take care of Infinity and NaN. */
4797 if (mpfr_sgn (m
) < 0)
4798 *r
= REAL_VALUE_NEGATE (*r
);
4804 real_nan (r
, "", 1, TYPE_MODE (type
));
4808 rstr
= mpfr_get_str (NULL
, &exp
, 16, 0, m
, rndmode
);
4810 /* The additional 12 chars add space for the sprintf below. This
4811 leaves 6 digits for the exponent which is supposedly enough. */
4812 gcc_assert (rstr
!= NULL
&& strlen (rstr
) < sizeof (buf
) - 12);
4814 /* REAL_VALUE_ATOF expects the exponent for mantissa * 2**exp,
4815 mpfr_get_str returns the exponent for mantissa * 16**exp, adjust
4820 sprintf (buf
, "-0x.%sp%d", &rstr
[1], (int) exp
);
4822 sprintf (buf
, "0x.%sp%d", rstr
, (int) exp
);
4824 mpfr_free_str (rstr
);
4826 real_from_string (r
, buf
);
4829 /* Check whether the real constant value given is an integer. */
4832 real_isinteger (const REAL_VALUE_TYPE
*c
, enum machine_mode mode
)
4834 REAL_VALUE_TYPE cint
;
4836 real_trunc (&cint
, mode
, c
);
4837 return real_identical (c
, &cint
);
4840 /* Write into BUF the maximum representable finite floating-point
4841 number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
4842 float string. LEN is the size of BUF, and the buffer must be large
4843 enough to contain the resulting string. */
4846 get_max_float (const struct real_format
*fmt
, char *buf
, size_t len
)
4851 strcpy (buf
, "0x0.");
4853 for (i
= 0, p
= buf
+ 4; i
+ 3 < n
; i
+= 4)
4856 *p
++ = "08ce"[n
- i
];
4857 sprintf (p
, "p%d", fmt
->emax
);
4858 if (fmt
->pnan
< fmt
->p
)
4860 /* This is an IBM extended double format made up of two IEEE
4861 doubles. The value of the long double is the sum of the
4862 values of the two parts. The most significant part is
4863 required to be the value of the long double rounded to the
4864 nearest double. Rounding means we need a slightly smaller
4865 value for LDBL_MAX. */
4866 buf
[4 + fmt
->pnan
/ 4] = "7bde"[fmt
->pnan
% 4];
4869 gcc_assert (strlen (buf
) < len
);