1 /* real.c - software floating point emulation.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2002, 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
4 Contributed by Stephen L. Moshier (moshier@world.std.com).
5 Re-written by Richard Henderson <rth@redhat.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
33 /* The floating point model used internally is not exactly IEEE 754
34 compliant, and close to the description in the ISO C99 standard,
35 section 5.2.4.2.2 Characteristics of floating types.
39 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
43 b = base or radix, here always 2
45 p = precision (the number of base-b digits in the significand)
46 f_k = the digits of the significand.
48 We differ from typical IEEE 754 encodings in that the entire
49 significand is fractional. Normalized significands are in the
52 A requirement of the model is that P be larger than the largest
53 supported target floating-point type by at least 2 bits. This gives
54 us proper rounding when we truncate to the target type. In addition,
55 E must be large enough to hold the smallest supported denormal number
58 Both of these requirements are easily satisfied. The largest target
59 significand is 113 bits; we store at least 160. The smallest
60 denormal number fits in 17 exponent bits; we store 27.
62 Note that the decimal string conversion routines are sensitive to
63 rounding errors. Since the raw arithmetic routines do not themselves
64 have guard digits or rounding, the computation of 10**exp can
65 accumulate more than a few digits of error. The previous incarnation
66 of real.c successfully used a 144-bit fraction; given the current
67 layout of REAL_VALUE_TYPE we're forced to expand to at least 160 bits. */
70 /* Used to classify two numbers simultaneously. */
71 #define CLASS2(A, B) ((A) << 2 | (B))
73 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
74 #error "Some constant folding done by hand to avoid shift count warnings"
77 static void get_zero (REAL_VALUE_TYPE
*, int);
78 static void get_canonical_qnan (REAL_VALUE_TYPE
*, int);
79 static void get_canonical_snan (REAL_VALUE_TYPE
*, int);
80 static void get_inf (REAL_VALUE_TYPE
*, int);
81 static bool sticky_rshift_significand (REAL_VALUE_TYPE
*,
82 const REAL_VALUE_TYPE
*, unsigned int);
83 static void rshift_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
85 static void lshift_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
87 static void lshift_significand_1 (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
88 static bool add_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*,
89 const REAL_VALUE_TYPE
*);
90 static bool sub_significands (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
91 const REAL_VALUE_TYPE
*, int);
92 static void neg_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
93 static int cmp_significands (const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
94 static int cmp_significand_0 (const REAL_VALUE_TYPE
*);
95 static void set_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
96 static void clear_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
97 static bool test_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
98 static void clear_significand_below (REAL_VALUE_TYPE
*, unsigned int);
99 static bool div_significands (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
100 const REAL_VALUE_TYPE
*);
101 static void normalize (REAL_VALUE_TYPE
*);
103 static bool do_add (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
104 const REAL_VALUE_TYPE
*, int);
105 static bool do_multiply (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
106 const REAL_VALUE_TYPE
*);
107 static bool do_divide (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
108 const REAL_VALUE_TYPE
*);
109 static int do_compare (const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*, int);
110 static void do_fix_trunc (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
112 static unsigned long rtd_divmod (REAL_VALUE_TYPE
*, REAL_VALUE_TYPE
*);
114 static const REAL_VALUE_TYPE
* ten_to_ptwo (int);
115 static const REAL_VALUE_TYPE
* ten_to_mptwo (int);
116 static const REAL_VALUE_TYPE
* real_digit (int);
117 static void times_pten (REAL_VALUE_TYPE
*, int);
119 static void round_for_format (const struct real_format
*, REAL_VALUE_TYPE
*);
121 /* Initialize R with a positive zero. */
124 get_zero (REAL_VALUE_TYPE
*r
, int sign
)
126 memset (r
, 0, sizeof (*r
));
130 /* Initialize R with the canonical quiet NaN. */
133 get_canonical_qnan (REAL_VALUE_TYPE
*r
, int sign
)
135 memset (r
, 0, sizeof (*r
));
142 get_canonical_snan (REAL_VALUE_TYPE
*r
, int sign
)
144 memset (r
, 0, sizeof (*r
));
152 get_inf (REAL_VALUE_TYPE
*r
, int sign
)
154 memset (r
, 0, sizeof (*r
));
160 /* Right-shift the significand of A by N bits; put the result in the
161 significand of R. If any one bits are shifted out, return true. */
164 sticky_rshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
167 unsigned long sticky
= 0;
168 unsigned int i
, ofs
= 0;
170 if (n
>= HOST_BITS_PER_LONG
)
172 for (i
= 0, ofs
= n
/ HOST_BITS_PER_LONG
; i
< ofs
; ++i
)
174 n
&= HOST_BITS_PER_LONG
- 1;
179 sticky
|= a
->sig
[ofs
] & (((unsigned long)1 << n
) - 1);
180 for (i
= 0; i
< SIGSZ
; ++i
)
183 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
184 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
185 << (HOST_BITS_PER_LONG
- n
)));
190 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
191 r
->sig
[i
] = a
->sig
[ofs
+ i
];
192 for (; i
< SIGSZ
; ++i
)
199 /* Right-shift the significand of A by N bits; put the result in the
203 rshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
206 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
208 n
&= HOST_BITS_PER_LONG
- 1;
211 for (i
= 0; i
< SIGSZ
; ++i
)
214 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
215 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
216 << (HOST_BITS_PER_LONG
- n
)));
221 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
222 r
->sig
[i
] = a
->sig
[ofs
+ i
];
223 for (; i
< SIGSZ
; ++i
)
228 /* Left-shift the significand of A by N bits; put the result in the
232 lshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
235 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
237 n
&= HOST_BITS_PER_LONG
- 1;
240 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
241 r
->sig
[SIGSZ
-1-i
] = a
->sig
[SIGSZ
-1-i
-ofs
];
242 for (; i
< SIGSZ
; ++i
)
243 r
->sig
[SIGSZ
-1-i
] = 0;
246 for (i
= 0; i
< SIGSZ
; ++i
)
249 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
]) << n
)
250 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
-1])
251 >> (HOST_BITS_PER_LONG
- n
)));
255 /* Likewise, but N is specialized to 1. */
258 lshift_significand_1 (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
262 for (i
= SIGSZ
- 1; i
> 0; --i
)
263 r
->sig
[i
] = (a
->sig
[i
] << 1) | (a
->sig
[i
-1] >> (HOST_BITS_PER_LONG
- 1));
264 r
->sig
[0] = a
->sig
[0] << 1;
267 /* Add the significands of A and B, placing the result in R. Return
268 true if there was carry out of the most significant word. */
271 add_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
272 const REAL_VALUE_TYPE
*b
)
277 for (i
= 0; i
< SIGSZ
; ++i
)
279 unsigned long ai
= a
->sig
[i
];
280 unsigned long ri
= ai
+ b
->sig
[i
];
296 /* Subtract the significands of A and B, placing the result in R. CARRY is
297 true if there's a borrow incoming to the least significant word.
298 Return true if there was borrow out of the most significant word. */
301 sub_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
302 const REAL_VALUE_TYPE
*b
, int carry
)
306 for (i
= 0; i
< SIGSZ
; ++i
)
308 unsigned long ai
= a
->sig
[i
];
309 unsigned long ri
= ai
- b
->sig
[i
];
325 /* Negate the significand A, placing the result in R. */
328 neg_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
333 for (i
= 0; i
< SIGSZ
; ++i
)
335 unsigned long ri
, ai
= a
->sig
[i
];
354 /* Compare significands. Return tri-state vs zero. */
357 cmp_significands (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
361 for (i
= SIGSZ
- 1; i
>= 0; --i
)
363 unsigned long ai
= a
->sig
[i
];
364 unsigned long bi
= b
->sig
[i
];
375 /* Return true if A is nonzero. */
378 cmp_significand_0 (const REAL_VALUE_TYPE
*a
)
382 for (i
= SIGSZ
- 1; i
>= 0; --i
)
389 /* Set bit N of the significand of R. */
392 set_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
394 r
->sig
[n
/ HOST_BITS_PER_LONG
]
395 |= (unsigned long)1 << (n
% HOST_BITS_PER_LONG
);
398 /* Clear bit N of the significand of R. */
401 clear_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
403 r
->sig
[n
/ HOST_BITS_PER_LONG
]
404 &= ~((unsigned long)1 << (n
% HOST_BITS_PER_LONG
));
407 /* Test bit N of the significand of R. */
410 test_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
412 /* ??? Compiler bug here if we return this expression directly.
413 The conversion to bool strips the "&1" and we wind up testing
414 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
415 int t
= (r
->sig
[n
/ HOST_BITS_PER_LONG
] >> (n
% HOST_BITS_PER_LONG
)) & 1;
419 /* Clear bits 0..N-1 of the significand of R. */
422 clear_significand_below (REAL_VALUE_TYPE
*r
, unsigned int n
)
424 int i
, w
= n
/ HOST_BITS_PER_LONG
;
426 for (i
= 0; i
< w
; ++i
)
429 r
->sig
[w
] &= ~(((unsigned long)1 << (n
% HOST_BITS_PER_LONG
)) - 1);
432 /* Divide the significands of A and B, placing the result in R. Return
433 true if the division was inexact. */
436 div_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
437 const REAL_VALUE_TYPE
*b
)
440 int i
, bit
= SIGNIFICAND_BITS
- 1;
441 unsigned long msb
, inexact
;
444 memset (r
->sig
, 0, sizeof (r
->sig
));
450 msb
= u
.sig
[SIGSZ
-1] & SIG_MSB
;
451 lshift_significand_1 (&u
, &u
);
453 if (msb
|| cmp_significands (&u
, b
) >= 0)
455 sub_significands (&u
, &u
, b
, 0);
456 set_significand_bit (r
, bit
);
461 for (i
= 0, inexact
= 0; i
< SIGSZ
; i
++)
467 /* Adjust the exponent and significand of R such that the most
468 significant bit is set. We underflow to zero and overflow to
469 infinity here, without denormals. (The intermediate representation
470 exponent is large enough to handle target denormals normalized.) */
473 normalize (REAL_VALUE_TYPE
*r
)
481 /* Find the first word that is nonzero. */
482 for (i
= SIGSZ
- 1; i
>= 0; i
--)
484 shift
+= HOST_BITS_PER_LONG
;
488 /* Zero significand flushes to zero. */
496 /* Find the first bit that is nonzero. */
498 if (r
->sig
[i
] & ((unsigned long)1 << (HOST_BITS_PER_LONG
- 1 - j
)))
504 exp
= REAL_EXP (r
) - shift
;
506 get_inf (r
, r
->sign
);
507 else if (exp
< -MAX_EXP
)
508 get_zero (r
, r
->sign
);
511 SET_REAL_EXP (r
, exp
);
512 lshift_significand (r
, r
, shift
);
517 /* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the
518 result may be inexact due to a loss of precision. */
521 do_add (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
522 const REAL_VALUE_TYPE
*b
, int subtract_p
)
526 bool inexact
= false;
528 /* Determine if we need to add or subtract. */
530 subtract_p
= (sign
^ b
->sign
) ^ subtract_p
;
532 switch (CLASS2 (a
->cl
, b
->cl
))
534 case CLASS2 (rvc_zero
, rvc_zero
):
535 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
536 get_zero (r
, sign
& !subtract_p
);
539 case CLASS2 (rvc_zero
, rvc_normal
):
540 case CLASS2 (rvc_zero
, rvc_inf
):
541 case CLASS2 (rvc_zero
, rvc_nan
):
543 case CLASS2 (rvc_normal
, rvc_nan
):
544 case CLASS2 (rvc_inf
, rvc_nan
):
545 case CLASS2 (rvc_nan
, rvc_nan
):
546 /* ANY + NaN = NaN. */
547 case CLASS2 (rvc_normal
, rvc_inf
):
550 r
->sign
= sign
^ subtract_p
;
553 case CLASS2 (rvc_normal
, rvc_zero
):
554 case CLASS2 (rvc_inf
, rvc_zero
):
555 case CLASS2 (rvc_nan
, rvc_zero
):
557 case CLASS2 (rvc_nan
, rvc_normal
):
558 case CLASS2 (rvc_nan
, rvc_inf
):
559 /* NaN + ANY = NaN. */
560 case CLASS2 (rvc_inf
, rvc_normal
):
565 case CLASS2 (rvc_inf
, rvc_inf
):
567 /* Inf - Inf = NaN. */
568 get_canonical_qnan (r
, 0);
570 /* Inf + Inf = Inf. */
574 case CLASS2 (rvc_normal
, rvc_normal
):
581 /* Swap the arguments such that A has the larger exponent. */
582 dexp
= REAL_EXP (a
) - REAL_EXP (b
);
585 const REAL_VALUE_TYPE
*t
;
592 /* If the exponents are not identical, we need to shift the
593 significand of B down. */
596 /* If the exponents are too far apart, the significands
597 do not overlap, which makes the subtraction a noop. */
598 if (dexp
>= SIGNIFICAND_BITS
)
605 inexact
|= sticky_rshift_significand (&t
, b
, dexp
);
611 if (sub_significands (r
, a
, b
, inexact
))
613 /* We got a borrow out of the subtraction. That means that
614 A and B had the same exponent, and B had the larger
615 significand. We need to swap the sign and negate the
618 neg_significand (r
, r
);
623 if (add_significands (r
, a
, b
))
625 /* We got carry out of the addition. This means we need to
626 shift the significand back down one bit and increase the
628 inexact
|= sticky_rshift_significand (r
, r
, 1);
629 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
640 SET_REAL_EXP (r
, exp
);
641 /* Zero out the remaining fields. */
646 /* Re-normalize the result. */
649 /* Special case: if the subtraction results in zero, the result
651 if (r
->cl
== rvc_zero
)
654 r
->sig
[0] |= inexact
;
659 /* Calculate R = A * B. Return true if the result may be inexact. */
662 do_multiply (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
663 const REAL_VALUE_TYPE
*b
)
665 REAL_VALUE_TYPE u
, t
, *rr
;
666 unsigned int i
, j
, k
;
667 int sign
= a
->sign
^ b
->sign
;
668 bool inexact
= false;
670 switch (CLASS2 (a
->cl
, b
->cl
))
672 case CLASS2 (rvc_zero
, rvc_zero
):
673 case CLASS2 (rvc_zero
, rvc_normal
):
674 case CLASS2 (rvc_normal
, rvc_zero
):
675 /* +-0 * ANY = 0 with appropriate sign. */
679 case CLASS2 (rvc_zero
, rvc_nan
):
680 case CLASS2 (rvc_normal
, rvc_nan
):
681 case CLASS2 (rvc_inf
, rvc_nan
):
682 case CLASS2 (rvc_nan
, rvc_nan
):
683 /* ANY * NaN = NaN. */
688 case CLASS2 (rvc_nan
, rvc_zero
):
689 case CLASS2 (rvc_nan
, rvc_normal
):
690 case CLASS2 (rvc_nan
, rvc_inf
):
691 /* NaN * ANY = NaN. */
696 case CLASS2 (rvc_zero
, rvc_inf
):
697 case CLASS2 (rvc_inf
, rvc_zero
):
699 get_canonical_qnan (r
, sign
);
702 case CLASS2 (rvc_inf
, rvc_inf
):
703 case CLASS2 (rvc_normal
, rvc_inf
):
704 case CLASS2 (rvc_inf
, rvc_normal
):
705 /* Inf * Inf = Inf, R * Inf = Inf */
709 case CLASS2 (rvc_normal
, rvc_normal
):
716 if (r
== a
|| r
== b
)
722 /* Collect all the partial products. Since we don't have sure access
723 to a widening multiply, we split each long into two half-words.
725 Consider the long-hand form of a four half-word multiplication:
735 We construct partial products of the widened half-word products
736 that are known to not overlap, e.g. DF+DH. Each such partial
737 product is given its proper exponent, which allows us to sum them
738 and obtain the finished product. */
740 for (i
= 0; i
< SIGSZ
* 2; ++i
)
742 unsigned long ai
= a
->sig
[i
/ 2];
744 ai
>>= HOST_BITS_PER_LONG
/ 2;
746 ai
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
751 for (j
= 0; j
< 2; ++j
)
753 int exp
= (REAL_EXP (a
) - (2*SIGSZ
-1-i
)*(HOST_BITS_PER_LONG
/2)
754 + (REAL_EXP (b
) - (1-j
)*(HOST_BITS_PER_LONG
/2)));
763 /* Would underflow to zero, which we shouldn't bother adding. */
768 memset (&u
, 0, sizeof (u
));
770 SET_REAL_EXP (&u
, exp
);
772 for (k
= j
; k
< SIGSZ
* 2; k
+= 2)
774 unsigned long bi
= b
->sig
[k
/ 2];
776 bi
>>= HOST_BITS_PER_LONG
/ 2;
778 bi
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
780 u
.sig
[k
/ 2] = ai
* bi
;
784 inexact
|= do_add (rr
, rr
, &u
, 0);
795 /* Calculate R = A / B. Return true if the result may be inexact. */
798 do_divide (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
799 const REAL_VALUE_TYPE
*b
)
801 int exp
, sign
= a
->sign
^ b
->sign
;
802 REAL_VALUE_TYPE t
, *rr
;
805 switch (CLASS2 (a
->cl
, b
->cl
))
807 case CLASS2 (rvc_zero
, rvc_zero
):
809 case CLASS2 (rvc_inf
, rvc_inf
):
810 /* Inf / Inf = NaN. */
811 get_canonical_qnan (r
, sign
);
814 case CLASS2 (rvc_zero
, rvc_normal
):
815 case CLASS2 (rvc_zero
, rvc_inf
):
817 case CLASS2 (rvc_normal
, rvc_inf
):
822 case CLASS2 (rvc_normal
, rvc_zero
):
824 case CLASS2 (rvc_inf
, rvc_zero
):
829 case CLASS2 (rvc_zero
, rvc_nan
):
830 case CLASS2 (rvc_normal
, rvc_nan
):
831 case CLASS2 (rvc_inf
, rvc_nan
):
832 case CLASS2 (rvc_nan
, rvc_nan
):
833 /* ANY / NaN = NaN. */
838 case CLASS2 (rvc_nan
, rvc_zero
):
839 case CLASS2 (rvc_nan
, rvc_normal
):
840 case CLASS2 (rvc_nan
, rvc_inf
):
841 /* NaN / ANY = NaN. */
846 case CLASS2 (rvc_inf
, rvc_normal
):
851 case CLASS2 (rvc_normal
, rvc_normal
):
858 if (r
== a
|| r
== b
)
863 /* Make sure all fields in the result are initialized. */
868 exp
= REAL_EXP (a
) - REAL_EXP (b
) + 1;
879 SET_REAL_EXP (rr
, exp
);
881 inexact
= div_significands (rr
, a
, b
);
883 /* Re-normalize the result. */
885 rr
->sig
[0] |= inexact
;
893 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
894 one of the two operands is a NaN. */
897 do_compare (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
,
902 switch (CLASS2 (a
->cl
, b
->cl
))
904 case CLASS2 (rvc_zero
, rvc_zero
):
905 /* Sign of zero doesn't matter for compares. */
908 case CLASS2 (rvc_inf
, rvc_zero
):
909 case CLASS2 (rvc_inf
, rvc_normal
):
910 case CLASS2 (rvc_normal
, rvc_zero
):
911 return (a
->sign
? -1 : 1);
913 case CLASS2 (rvc_inf
, rvc_inf
):
914 return -a
->sign
- -b
->sign
;
916 case CLASS2 (rvc_zero
, rvc_normal
):
917 case CLASS2 (rvc_zero
, rvc_inf
):
918 case CLASS2 (rvc_normal
, rvc_inf
):
919 return (b
->sign
? 1 : -1);
921 case CLASS2 (rvc_zero
, rvc_nan
):
922 case CLASS2 (rvc_normal
, rvc_nan
):
923 case CLASS2 (rvc_inf
, rvc_nan
):
924 case CLASS2 (rvc_nan
, rvc_nan
):
925 case CLASS2 (rvc_nan
, rvc_zero
):
926 case CLASS2 (rvc_nan
, rvc_normal
):
927 case CLASS2 (rvc_nan
, rvc_inf
):
930 case CLASS2 (rvc_normal
, rvc_normal
):
937 if (a
->sign
!= b
->sign
)
938 return -a
->sign
- -b
->sign
;
940 if (a
->decimal
|| b
->decimal
)
941 return decimal_do_compare (a
, b
, nan_result
);
943 if (REAL_EXP (a
) > REAL_EXP (b
))
945 else if (REAL_EXP (a
) < REAL_EXP (b
))
948 ret
= cmp_significands (a
, b
);
950 return (a
->sign
? -ret
: ret
);
953 /* Return A truncated to an integral value toward zero. */
956 do_fix_trunc (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
970 decimal_do_fix_trunc (r
, a
);
973 if (REAL_EXP (r
) <= 0)
974 get_zero (r
, r
->sign
);
975 else if (REAL_EXP (r
) < SIGNIFICAND_BITS
)
976 clear_significand_below (r
, SIGNIFICAND_BITS
- REAL_EXP (r
));
984 /* Perform the binary or unary operation described by CODE.
985 For a unary operation, leave OP1 NULL. This function returns
986 true if the result may be inexact due to loss of precision. */
989 real_arithmetic (REAL_VALUE_TYPE
*r
, int icode
, const REAL_VALUE_TYPE
*op0
,
990 const REAL_VALUE_TYPE
*op1
)
992 enum tree_code code
= icode
;
994 if (op0
->decimal
|| (op1
&& op1
->decimal
))
995 return decimal_real_arithmetic (r
, icode
, op0
, op1
);
1000 return do_add (r
, op0
, op1
, 0);
1003 return do_add (r
, op0
, op1
, 1);
1006 return do_multiply (r
, op0
, op1
);
1009 return do_divide (r
, op0
, op1
);
1012 if (op1
->cl
== rvc_nan
)
1014 else if (do_compare (op0
, op1
, -1) < 0)
1021 if (op1
->cl
== rvc_nan
)
1023 else if (do_compare (op0
, op1
, 1) < 0)
1039 case FIX_TRUNC_EXPR
:
1040 do_fix_trunc (r
, op0
);
1049 /* Legacy. Similar, but return the result directly. */
1052 real_arithmetic2 (int icode
, const REAL_VALUE_TYPE
*op0
,
1053 const REAL_VALUE_TYPE
*op1
)
1056 real_arithmetic (&r
, icode
, op0
, op1
);
1061 real_compare (int icode
, const REAL_VALUE_TYPE
*op0
,
1062 const REAL_VALUE_TYPE
*op1
)
1064 enum tree_code code
= icode
;
1069 return do_compare (op0
, op1
, 1) < 0;
1071 return do_compare (op0
, op1
, 1) <= 0;
1073 return do_compare (op0
, op1
, -1) > 0;
1075 return do_compare (op0
, op1
, -1) >= 0;
1077 return do_compare (op0
, op1
, -1) == 0;
1079 return do_compare (op0
, op1
, -1) != 0;
1080 case UNORDERED_EXPR
:
1081 return op0
->cl
== rvc_nan
|| op1
->cl
== rvc_nan
;
1083 return op0
->cl
!= rvc_nan
&& op1
->cl
!= rvc_nan
;
1085 return do_compare (op0
, op1
, -1) < 0;
1087 return do_compare (op0
, op1
, -1) <= 0;
1089 return do_compare (op0
, op1
, 1) > 0;
1091 return do_compare (op0
, op1
, 1) >= 0;
1093 return do_compare (op0
, op1
, 0) == 0;
1095 return do_compare (op0
, op1
, 0) != 0;
1102 /* Return floor log2(R). */
1105 real_exponent (const REAL_VALUE_TYPE
*r
)
1113 return (unsigned int)-1 >> 1;
1115 return REAL_EXP (r
);
1121 /* R = OP0 * 2**EXP. */
1124 real_ldexp (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*op0
, int exp
)
1135 exp
+= REAL_EXP (op0
);
1137 get_inf (r
, r
->sign
);
1138 else if (exp
< -MAX_EXP
)
1139 get_zero (r
, r
->sign
);
1141 SET_REAL_EXP (r
, exp
);
1149 /* Determine whether a floating-point value X is infinite. */
1152 real_isinf (const REAL_VALUE_TYPE
*r
)
1154 return (r
->cl
== rvc_inf
);
1157 /* Determine whether a floating-point value X is a NaN. */
1160 real_isnan (const REAL_VALUE_TYPE
*r
)
1162 return (r
->cl
== rvc_nan
);
1165 /* Determine whether a floating-point value X is finite. */
1168 real_isfinite (const REAL_VALUE_TYPE
*r
)
1170 return (r
->cl
!= rvc_nan
) && (r
->cl
!= rvc_inf
);
1173 /* Determine whether a floating-point value X is negative. */
1176 real_isneg (const REAL_VALUE_TYPE
*r
)
1181 /* Determine whether a floating-point value X is minus zero. */
1184 real_isnegzero (const REAL_VALUE_TYPE
*r
)
1186 return r
->sign
&& r
->cl
== rvc_zero
;
1189 /* Compare two floating-point objects for bitwise identity. */
1192 real_identical (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
1198 if (a
->sign
!= b
->sign
)
1208 if (a
->decimal
!= b
->decimal
)
1210 if (REAL_EXP (a
) != REAL_EXP (b
))
1215 if (a
->signalling
!= b
->signalling
)
1217 /* The significand is ignored for canonical NaNs. */
1218 if (a
->canonical
|| b
->canonical
)
1219 return a
->canonical
== b
->canonical
;
1226 for (i
= 0; i
< SIGSZ
; ++i
)
1227 if (a
->sig
[i
] != b
->sig
[i
])
1233 /* Try to change R into its exact multiplicative inverse in machine
1234 mode MODE. Return true if successful. */
1237 exact_real_inverse (enum machine_mode mode
, REAL_VALUE_TYPE
*r
)
1239 const REAL_VALUE_TYPE
*one
= real_digit (1);
1243 if (r
->cl
!= rvc_normal
)
1246 /* Check for a power of two: all significand bits zero except the MSB. */
1247 for (i
= 0; i
< SIGSZ
-1; ++i
)
1250 if (r
->sig
[SIGSZ
-1] != SIG_MSB
)
1253 /* Find the inverse and truncate to the required mode. */
1254 do_divide (&u
, one
, r
);
1255 real_convert (&u
, mode
, &u
);
1257 /* The rounding may have overflowed. */
1258 if (u
.cl
!= rvc_normal
)
1260 for (i
= 0; i
< SIGSZ
-1; ++i
)
1263 if (u
.sig
[SIGSZ
-1] != SIG_MSB
)
1270 /* Render R as an integer. */
1273 real_to_integer (const REAL_VALUE_TYPE
*r
)
1275 unsigned HOST_WIDE_INT i
;
1286 i
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1293 return decimal_real_to_integer (r
);
1295 if (REAL_EXP (r
) <= 0)
1297 /* Only force overflow for unsigned overflow. Signed overflow is
1298 undefined, so it doesn't matter what we return, and some callers
1299 expect to be able to use this routine for both signed and
1300 unsigned conversions. */
1301 if (REAL_EXP (r
) > HOST_BITS_PER_WIDE_INT
)
1304 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1305 i
= r
->sig
[SIGSZ
-1];
1308 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2 * HOST_BITS_PER_LONG
);
1309 i
= r
->sig
[SIGSZ
-1];
1310 i
= i
<< (HOST_BITS_PER_LONG
- 1) << 1;
1311 i
|= r
->sig
[SIGSZ
-2];
1314 i
>>= HOST_BITS_PER_WIDE_INT
- REAL_EXP (r
);
1325 /* Likewise, but to an integer pair, HI+LOW. */
1328 real_to_integer2 (HOST_WIDE_INT
*plow
, HOST_WIDE_INT
*phigh
,
1329 const REAL_VALUE_TYPE
*r
)
1332 HOST_WIDE_INT low
, high
;
1345 high
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1358 decimal_real_to_integer2 (plow
, phigh
, r
);
1365 /* Only force overflow for unsigned overflow. Signed overflow is
1366 undefined, so it doesn't matter what we return, and some callers
1367 expect to be able to use this routine for both signed and
1368 unsigned conversions. */
1369 if (exp
> 2*HOST_BITS_PER_WIDE_INT
)
1372 rshift_significand (&t
, r
, 2*HOST_BITS_PER_WIDE_INT
- exp
);
1373 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1375 high
= t
.sig
[SIGSZ
-1];
1376 low
= t
.sig
[SIGSZ
-2];
1380 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2*HOST_BITS_PER_LONG
);
1381 high
= t
.sig
[SIGSZ
-1];
1382 high
= high
<< (HOST_BITS_PER_LONG
- 1) << 1;
1383 high
|= t
.sig
[SIGSZ
-2];
1385 low
= t
.sig
[SIGSZ
-3];
1386 low
= low
<< (HOST_BITS_PER_LONG
- 1) << 1;
1387 low
|= t
.sig
[SIGSZ
-4];
1395 low
= -low
, high
= ~high
;
1407 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1408 of NUM / DEN. Return the quotient and place the remainder in NUM.
1409 It is expected that NUM / DEN are close enough that the quotient is
1412 static unsigned long
1413 rtd_divmod (REAL_VALUE_TYPE
*num
, REAL_VALUE_TYPE
*den
)
1415 unsigned long q
, msb
;
1416 int expn
= REAL_EXP (num
), expd
= REAL_EXP (den
);
1425 msb
= num
->sig
[SIGSZ
-1] & SIG_MSB
;
1427 lshift_significand_1 (num
, num
);
1429 if (msb
|| cmp_significands (num
, den
) >= 0)
1431 sub_significands (num
, num
, den
, 0);
1435 while (--expn
>= expd
);
1437 SET_REAL_EXP (num
, expd
);
1443 /* Render R as a decimal floating point constant. Emit DIGITS significant
1444 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1445 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1448 #define M_LOG10_2 0.30102999566398119521
1451 real_to_decimal (char *str
, const REAL_VALUE_TYPE
*r_orig
, size_t buf_size
,
1452 size_t digits
, int crop_trailing_zeros
)
1454 const REAL_VALUE_TYPE
*one
, *ten
;
1455 REAL_VALUE_TYPE r
, pten
, u
, v
;
1456 int dec_exp
, cmp_one
, digit
;
1458 char *p
, *first
, *last
;
1465 strcpy (str
, (r
.sign
? "-0.0" : "0.0"));
1470 strcpy (str
, (r
.sign
? "-Inf" : "+Inf"));
1473 /* ??? Print the significand as well, if not canonical? */
1474 sprintf (str
, "%c%cNaN", (r_orig
->sign
? '-' : '+'),
1475 (r_orig
->signalling
? 'S' : 'Q'));
1483 decimal_real_to_decimal (str
, &r
, buf_size
, digits
, crop_trailing_zeros
);
1487 /* Bound the number of digits printed by the size of the representation. */
1488 max_digits
= SIGNIFICAND_BITS
* M_LOG10_2
;
1489 if (digits
== 0 || digits
> max_digits
)
1490 digits
= max_digits
;
1492 /* Estimate the decimal exponent, and compute the length of the string it
1493 will print as. Be conservative and add one to account for possible
1494 overflow or rounding error. */
1495 dec_exp
= REAL_EXP (&r
) * M_LOG10_2
;
1496 for (max_digits
= 1; dec_exp
; max_digits
++)
1499 /* Bound the number of digits printed by the size of the output buffer. */
1500 max_digits
= buf_size
- 1 - 1 - 2 - max_digits
- 1;
1501 gcc_assert (max_digits
<= buf_size
);
1502 if (digits
> max_digits
)
1503 digits
= max_digits
;
1505 one
= real_digit (1);
1506 ten
= ten_to_ptwo (0);
1514 cmp_one
= do_compare (&r
, one
, 0);
1519 /* Number is greater than one. Convert significand to an integer
1520 and strip trailing decimal zeros. */
1523 SET_REAL_EXP (&u
, SIGNIFICAND_BITS
- 1);
1525 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1526 m
= floor_log2 (max_digits
);
1528 /* Iterate over the bits of the possible powers of 10 that might
1529 be present in U and eliminate them. That is, if we find that
1530 10**2**M divides U evenly, keep the division and increase
1536 do_divide (&t
, &u
, ten_to_ptwo (m
));
1537 do_fix_trunc (&v
, &t
);
1538 if (cmp_significands (&v
, &t
) == 0)
1546 /* Revert the scaling to integer that we performed earlier. */
1547 SET_REAL_EXP (&u
, REAL_EXP (&u
) + REAL_EXP (&r
)
1548 - (SIGNIFICAND_BITS
- 1));
1551 /* Find power of 10. Do this by dividing out 10**2**M when
1552 this is larger than the current remainder. Fill PTEN with
1553 the power of 10 that we compute. */
1554 if (REAL_EXP (&r
) > 0)
1556 m
= floor_log2 ((int)(REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1559 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1560 if (do_compare (&u
, ptentwo
, 0) >= 0)
1562 do_divide (&u
, &u
, ptentwo
);
1563 do_multiply (&pten
, &pten
, ptentwo
);
1570 /* We managed to divide off enough tens in the above reduction
1571 loop that we've now got a negative exponent. Fall into the
1572 less-than-one code to compute the proper value for PTEN. */
1579 /* Number is less than one. Pad significand with leading
1585 /* Stop if we'd shift bits off the bottom. */
1589 do_multiply (&u
, &v
, ten
);
1591 /* Stop if we're now >= 1. */
1592 if (REAL_EXP (&u
) > 0)
1600 /* Find power of 10. Do this by multiplying in P=10**2**M when
1601 the current remainder is smaller than 1/P. Fill PTEN with the
1602 power of 10 that we compute. */
1603 m
= floor_log2 ((int)(-REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1606 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1607 const REAL_VALUE_TYPE
*ptenmtwo
= ten_to_mptwo (m
);
1609 if (do_compare (&v
, ptenmtwo
, 0) <= 0)
1611 do_multiply (&v
, &v
, ptentwo
);
1612 do_multiply (&pten
, &pten
, ptentwo
);
1618 /* Invert the positive power of 10 that we've collected so far. */
1619 do_divide (&pten
, one
, &pten
);
1627 /* At this point, PTEN should contain the nearest power of 10 smaller
1628 than R, such that this division produces the first digit.
1630 Using a divide-step primitive that returns the complete integral
1631 remainder avoids the rounding error that would be produced if
1632 we were to use do_divide here and then simply multiply by 10 for
1633 each subsequent digit. */
1635 digit
= rtd_divmod (&r
, &pten
);
1637 /* Be prepared for error in that division via underflow ... */
1638 if (digit
== 0 && cmp_significand_0 (&r
))
1640 /* Multiply by 10 and try again. */
1641 do_multiply (&r
, &r
, ten
);
1642 digit
= rtd_divmod (&r
, &pten
);
1644 gcc_assert (digit
!= 0);
1647 /* ... or overflow. */
1657 gcc_assert (digit
<= 10);
1661 /* Generate subsequent digits. */
1662 while (--digits
> 0)
1664 do_multiply (&r
, &r
, ten
);
1665 digit
= rtd_divmod (&r
, &pten
);
1670 /* Generate one more digit with which to do rounding. */
1671 do_multiply (&r
, &r
, ten
);
1672 digit
= rtd_divmod (&r
, &pten
);
1674 /* Round the result. */
1677 /* Round to nearest. If R is nonzero there are additional
1678 nonzero digits to be extracted. */
1679 if (cmp_significand_0 (&r
))
1681 /* Round to even. */
1682 else if ((p
[-1] - '0') & 1)
1699 /* Carry out of the first digit. This means we had all 9's and
1700 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1708 /* Insert the decimal point. */
1709 first
[0] = first
[1];
1712 /* If requested, drop trailing zeros. Never crop past "1.0". */
1713 if (crop_trailing_zeros
)
1714 while (last
> first
+ 3 && last
[-1] == '0')
1717 /* Append the exponent. */
1718 sprintf (last
, "e%+d", dec_exp
);
1721 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1722 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1723 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1724 strip trailing zeros. */
1727 real_to_hexadecimal (char *str
, const REAL_VALUE_TYPE
*r
, size_t buf_size
,
1728 size_t digits
, int crop_trailing_zeros
)
1730 int i
, j
, exp
= REAL_EXP (r
);
1743 strcpy (str
, (r
->sign
? "-Inf" : "+Inf"));
1746 /* ??? Print the significand as well, if not canonical? */
1747 sprintf (str
, "%c%cNaN", (r
->sign
? '-' : '+'),
1748 (r
->signalling
? 'S' : 'Q'));
1756 /* Hexadecimal format for decimal floats is not interesting. */
1757 strcpy (str
, "N/A");
1762 digits
= SIGNIFICAND_BITS
/ 4;
1764 /* Bound the number of digits printed by the size of the output buffer. */
1766 sprintf (exp_buf
, "p%+d", exp
);
1767 max_digits
= buf_size
- strlen (exp_buf
) - r
->sign
- 4 - 1;
1768 gcc_assert (max_digits
<= buf_size
);
1769 if (digits
> max_digits
)
1770 digits
= max_digits
;
1781 for (i
= SIGSZ
- 1; i
>= 0; --i
)
1782 for (j
= HOST_BITS_PER_LONG
- 4; j
>= 0; j
-= 4)
1784 *p
++ = "0123456789abcdef"[(r
->sig
[i
] >> j
) & 15];
1790 if (crop_trailing_zeros
)
1791 while (p
> first
+ 1 && p
[-1] == '0')
1794 sprintf (p
, "p%+d", exp
);
1797 /* Initialize R from a decimal or hexadecimal string. The string is
1798 assumed to have been syntax checked already. Return -1 if the
1799 value underflows, +1 if overflows, and 0 otherwise. */
1802 real_from_string (REAL_VALUE_TYPE
*r
, const char *str
)
1814 else if (*str
== '+')
1817 if (!strncmp (str
, "QNaN", 4))
1819 get_canonical_qnan (r
, sign
);
1822 else if (!strncmp (str
, "SNaN", 4))
1824 get_canonical_snan (r
, sign
);
1827 else if (!strncmp (str
, "Inf", 3))
1833 if (str
[0] == '0' && (str
[1] == 'x' || str
[1] == 'X'))
1835 /* Hexadecimal floating point. */
1836 int pos
= SIGNIFICAND_BITS
- 4, d
;
1844 d
= hex_value (*str
);
1849 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1850 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1854 /* Ensure correct rounding by setting last bit if there is
1855 a subsequent nonzero digit. */
1863 if (pos
== SIGNIFICAND_BITS
- 4)
1870 d
= hex_value (*str
);
1875 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1876 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1880 /* Ensure correct rounding by setting last bit if there is
1881 a subsequent nonzero digit. */
1887 /* If the mantissa is zero, ignore the exponent. */
1888 if (!cmp_significand_0 (r
))
1891 if (*str
== 'p' || *str
== 'P')
1893 bool exp_neg
= false;
1901 else if (*str
== '+')
1905 while (ISDIGIT (*str
))
1911 /* Overflowed the exponent. */
1926 SET_REAL_EXP (r
, exp
);
1932 /* Decimal floating point. */
1933 const REAL_VALUE_TYPE
*ten
= ten_to_ptwo (0);
1938 while (ISDIGIT (*str
))
1941 do_multiply (r
, r
, ten
);
1943 do_add (r
, r
, real_digit (d
), 0);
1948 if (r
->cl
== rvc_zero
)
1953 while (ISDIGIT (*str
))
1956 do_multiply (r
, r
, ten
);
1958 do_add (r
, r
, real_digit (d
), 0);
1963 /* If the mantissa is zero, ignore the exponent. */
1964 if (r
->cl
== rvc_zero
)
1967 if (*str
== 'e' || *str
== 'E')
1969 bool exp_neg
= false;
1977 else if (*str
== '+')
1981 while (ISDIGIT (*str
))
1987 /* Overflowed the exponent. */
2001 times_pten (r
, exp
);
2020 /* Legacy. Similar, but return the result directly. */
2023 real_from_string2 (const char *s
, enum machine_mode mode
)
2027 real_from_string (&r
, s
);
2028 if (mode
!= VOIDmode
)
2029 real_convert (&r
, mode
, &r
);
2034 /* Initialize R from string S and desired MODE. */
2037 real_from_string3 (REAL_VALUE_TYPE
*r
, const char *s
, enum machine_mode mode
)
2039 if (DECIMAL_FLOAT_MODE_P (mode
))
2040 decimal_real_from_string (r
, s
);
2042 real_from_string (r
, s
);
2044 if (mode
!= VOIDmode
)
2045 real_convert (r
, mode
, r
);
2048 /* Initialize R from the integer pair HIGH+LOW. */
2051 real_from_integer (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
2052 unsigned HOST_WIDE_INT low
, HOST_WIDE_INT high
,
2055 if (low
== 0 && high
== 0)
2059 memset (r
, 0, sizeof (*r
));
2061 r
->sign
= high
< 0 && !unsigned_p
;
2062 SET_REAL_EXP (r
, 2 * HOST_BITS_PER_WIDE_INT
);
2073 if (HOST_BITS_PER_LONG
== HOST_BITS_PER_WIDE_INT
)
2075 r
->sig
[SIGSZ
-1] = high
;
2076 r
->sig
[SIGSZ
-2] = low
;
2080 gcc_assert (HOST_BITS_PER_LONG
*2 == HOST_BITS_PER_WIDE_INT
);
2081 r
->sig
[SIGSZ
-1] = high
>> (HOST_BITS_PER_LONG
- 1) >> 1;
2082 r
->sig
[SIGSZ
-2] = high
;
2083 r
->sig
[SIGSZ
-3] = low
>> (HOST_BITS_PER_LONG
- 1) >> 1;
2084 r
->sig
[SIGSZ
-4] = low
;
2090 if (mode
!= VOIDmode
)
2091 real_convert (r
, mode
, r
);
2094 /* Returns 10**2**N. */
2096 static const REAL_VALUE_TYPE
*
2099 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2101 gcc_assert (n
>= 0);
2102 gcc_assert (n
< EXP_BITS
);
2104 if (tens
[n
].cl
== rvc_zero
)
2106 if (n
< (HOST_BITS_PER_WIDE_INT
== 64 ? 5 : 4))
2108 HOST_WIDE_INT t
= 10;
2111 for (i
= 0; i
< n
; ++i
)
2114 real_from_integer (&tens
[n
], VOIDmode
, t
, 0, 1);
2118 const REAL_VALUE_TYPE
*t
= ten_to_ptwo (n
- 1);
2119 do_multiply (&tens
[n
], t
, t
);
2126 /* Returns 10**(-2**N). */
2128 static const REAL_VALUE_TYPE
*
2129 ten_to_mptwo (int n
)
2131 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2133 gcc_assert (n
>= 0);
2134 gcc_assert (n
< EXP_BITS
);
2136 if (tens
[n
].cl
== rvc_zero
)
2137 do_divide (&tens
[n
], real_digit (1), ten_to_ptwo (n
));
2144 static const REAL_VALUE_TYPE
*
2147 static REAL_VALUE_TYPE num
[10];
2149 gcc_assert (n
>= 0);
2150 gcc_assert (n
<= 9);
2152 if (n
> 0 && num
[n
].cl
== rvc_zero
)
2153 real_from_integer (&num
[n
], VOIDmode
, n
, 0, 1);
2158 /* Multiply R by 10**EXP. */
2161 times_pten (REAL_VALUE_TYPE
*r
, int exp
)
2163 REAL_VALUE_TYPE pten
, *rr
;
2164 bool negative
= (exp
< 0);
2170 pten
= *real_digit (1);
2176 for (i
= 0; exp
> 0; ++i
, exp
>>= 1)
2178 do_multiply (rr
, rr
, ten_to_ptwo (i
));
2181 do_divide (r
, r
, &pten
);
2184 /* Returns the special REAL_VALUE_TYPE enumerated by E. */
2186 const REAL_VALUE_TYPE
*
2187 get_real_const (enum real_value_const e
)
2189 static REAL_VALUE_TYPE value
[rv_max
];
2191 gcc_assert (e
< rv_max
);
2193 /* Initialize mathematical constants for constant folding builtins.
2194 These constants need to be given to at least 160 bits precision. */
2195 if (value
[e
].cl
== rvc_zero
)
2201 mpfr_init2 (m
, SIGNIFICAND_BITS
);
2202 mpfr_set_ui (m
, 1, GMP_RNDN
);
2203 mpfr_exp (m
, m
, GMP_RNDN
);
2204 real_from_mpfr (&value
[e
], m
, NULL_TREE
, GMP_RNDN
);
2209 real_arithmetic (&value
[e
], RDIV_EXPR
, &dconst1
, real_digit (3));
2214 mpfr_init2 (m
, SIGNIFICAND_BITS
);
2215 mpfr_sqrt_ui (m
, 2, GMP_RNDN
);
2216 real_from_mpfr (&value
[e
], m
, NULL_TREE
, GMP_RNDN
);
2227 /* Fills R with +Inf. */
2230 real_inf (REAL_VALUE_TYPE
*r
)
2235 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2236 we force a QNaN, else we force an SNaN. The string, if not empty,
2237 is parsed as a number and placed in the significand. Return true
2238 if the string was successfully parsed. */
2241 real_nan (REAL_VALUE_TYPE
*r
, const char *str
, int quiet
,
2242 enum machine_mode mode
)
2244 const struct real_format
*fmt
;
2246 fmt
= REAL_MODE_FORMAT (mode
);
2252 get_canonical_qnan (r
, 0);
2254 get_canonical_snan (r
, 0);
2260 memset (r
, 0, sizeof (*r
));
2263 /* Parse akin to strtol into the significand of R. */
2265 while (ISSPACE (*str
))
2269 else if (*str
== '+')
2274 if (*str
== 'x' || *str
== 'X')
2283 while ((d
= hex_value (*str
)) < base
)
2290 lshift_significand (r
, r
, 3);
2293 lshift_significand (r
, r
, 4);
2296 lshift_significand_1 (&u
, r
);
2297 lshift_significand (r
, r
, 3);
2298 add_significands (r
, r
, &u
);
2306 add_significands (r
, r
, &u
);
2311 /* Must have consumed the entire string for success. */
2315 /* Shift the significand into place such that the bits
2316 are in the most significant bits for the format. */
2317 lshift_significand (r
, r
, SIGNIFICAND_BITS
- fmt
->pnan
);
2319 /* Our MSB is always unset for NaNs. */
2320 r
->sig
[SIGSZ
-1] &= ~SIG_MSB
;
2322 /* Force quiet or signalling NaN. */
2323 r
->signalling
= !quiet
;
2329 /* Fills R with the largest finite value representable in mode MODE.
2330 If SIGN is nonzero, R is set to the most negative finite value. */
2333 real_maxval (REAL_VALUE_TYPE
*r
, int sign
, enum machine_mode mode
)
2335 const struct real_format
*fmt
;
2338 fmt
= REAL_MODE_FORMAT (mode
);
2340 memset (r
, 0, sizeof (*r
));
2343 decimal_real_maxval (r
, sign
, mode
);
2348 SET_REAL_EXP (r
, fmt
->emax
);
2350 np2
= SIGNIFICAND_BITS
- fmt
->p
;
2351 memset (r
->sig
, -1, SIGSZ
* sizeof (unsigned long));
2352 clear_significand_below (r
, np2
);
2354 if (fmt
->pnan
< fmt
->p
)
2355 /* This is an IBM extended double format made up of two IEEE
2356 doubles. The value of the long double is the sum of the
2357 values of the two parts. The most significant part is
2358 required to be the value of the long double rounded to the
2359 nearest double. Rounding means we need a slightly smaller
2360 value for LDBL_MAX. */
2361 clear_significand_bit (r
, SIGNIFICAND_BITS
- fmt
->pnan
);
2365 /* Fills R with 2**N. */
2368 real_2expN (REAL_VALUE_TYPE
*r
, int n
, enum machine_mode fmode
)
2370 memset (r
, 0, sizeof (*r
));
2375 else if (n
< -MAX_EXP
)
2380 SET_REAL_EXP (r
, n
);
2381 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2383 if (DECIMAL_FLOAT_MODE_P (fmode
))
2384 decimal_real_convert (r
, fmode
, r
);
2389 round_for_format (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
)
2392 unsigned long sticky
;
2400 decimal_round_for_format (fmt
, r
);
2403 /* FIXME. We can come here via fp_easy_constant
2404 (e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
2405 investigated whether this convert needs to be here, or
2406 something else is missing. */
2407 decimal_real_convert (r
, DFmode
, r
);
2411 emin2m1
= fmt
->emin
- 1;
2414 np2
= SIGNIFICAND_BITS
- p2
;
2418 get_zero (r
, r
->sign
);
2420 if (!fmt
->has_signed_zero
)
2425 get_inf (r
, r
->sign
);
2430 clear_significand_below (r
, np2
);
2440 /* Check the range of the exponent. If we're out of range,
2441 either underflow or overflow. */
2442 if (REAL_EXP (r
) > emax2
)
2444 else if (REAL_EXP (r
) <= emin2m1
)
2448 if (!fmt
->has_denorm
)
2450 /* Don't underflow completely until we've had a chance to round. */
2451 if (REAL_EXP (r
) < emin2m1
)
2456 diff
= emin2m1
- REAL_EXP (r
) + 1;
2460 /* De-normalize the significand. */
2461 r
->sig
[0] |= sticky_rshift_significand (r
, r
, diff
);
2462 SET_REAL_EXP (r
, REAL_EXP (r
) + diff
);
2466 /* There are P2 true significand bits, followed by one guard bit,
2467 followed by one sticky bit, followed by stuff. Fold nonzero
2468 stuff into the sticky bit. */
2471 for (i
= 0, w
= (np2
- 1) / HOST_BITS_PER_LONG
; i
< w
; ++i
)
2472 sticky
|= r
->sig
[i
];
2474 r
->sig
[w
] & (((unsigned long)1 << ((np2
- 1) % HOST_BITS_PER_LONG
)) - 1);
2476 guard
= test_significand_bit (r
, np2
- 1);
2477 lsb
= test_significand_bit (r
, np2
);
2479 /* Round to even. */
2480 if (guard
&& (sticky
|| lsb
))
2484 set_significand_bit (&u
, np2
);
2486 if (add_significands (r
, r
, &u
))
2488 /* Overflow. Means the significand had been all ones, and
2489 is now all zeros. Need to increase the exponent, and
2490 possibly re-normalize it. */
2491 SET_REAL_EXP (r
, REAL_EXP (r
) + 1);
2492 if (REAL_EXP (r
) > emax2
)
2494 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2498 /* Catch underflow that we deferred until after rounding. */
2499 if (REAL_EXP (r
) <= emin2m1
)
2502 /* Clear out trailing garbage. */
2503 clear_significand_below (r
, np2
);
2506 /* Extend or truncate to a new mode. */
2509 real_convert (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
2510 const REAL_VALUE_TYPE
*a
)
2512 const struct real_format
*fmt
;
2514 fmt
= REAL_MODE_FORMAT (mode
);
2519 if (a
->decimal
|| fmt
->b
== 10)
2520 decimal_real_convert (r
, mode
, a
);
2522 round_for_format (fmt
, r
);
2524 /* round_for_format de-normalizes denormals. Undo just that part. */
2525 if (r
->cl
== rvc_normal
)
2529 /* Legacy. Likewise, except return the struct directly. */
2532 real_value_truncate (enum machine_mode mode
, REAL_VALUE_TYPE a
)
2535 real_convert (&r
, mode
, &a
);
2539 /* Return true if truncating to MODE is exact. */
2542 exact_real_truncate (enum machine_mode mode
, const REAL_VALUE_TYPE
*a
)
2544 const struct real_format
*fmt
;
2548 fmt
= REAL_MODE_FORMAT (mode
);
2551 /* Don't allow conversion to denormals. */
2552 emin2m1
= fmt
->emin
- 1;
2553 if (REAL_EXP (a
) <= emin2m1
)
2556 /* After conversion to the new mode, the value must be identical. */
2557 real_convert (&t
, mode
, a
);
2558 return real_identical (&t
, a
);
2561 /* Write R to the given target format. Place the words of the result
2562 in target word order in BUF. There are always 32 bits in each
2563 long, no matter the size of the host long.
2565 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2568 real_to_target_fmt (long *buf
, const REAL_VALUE_TYPE
*r_orig
,
2569 const struct real_format
*fmt
)
2575 round_for_format (fmt
, &r
);
2579 (*fmt
->encode
) (fmt
, buf
, &r
);
2584 /* Similar, but look up the format from MODE. */
2587 real_to_target (long *buf
, const REAL_VALUE_TYPE
*r
, enum machine_mode mode
)
2589 const struct real_format
*fmt
;
2591 fmt
= REAL_MODE_FORMAT (mode
);
2594 return real_to_target_fmt (buf
, r
, fmt
);
2597 /* Read R from the given target format. Read the words of the result
2598 in target word order in BUF. There are always 32 bits in each
2599 long, no matter the size of the host long. */
2602 real_from_target_fmt (REAL_VALUE_TYPE
*r
, const long *buf
,
2603 const struct real_format
*fmt
)
2605 (*fmt
->decode
) (fmt
, r
, buf
);
2608 /* Similar, but look up the format from MODE. */
2611 real_from_target (REAL_VALUE_TYPE
*r
, const long *buf
, enum machine_mode mode
)
2613 const struct real_format
*fmt
;
2615 fmt
= REAL_MODE_FORMAT (mode
);
2618 (*fmt
->decode
) (fmt
, r
, buf
);
2621 /* Return the number of bits of the largest binary value that the
2622 significand of MODE will hold. */
2623 /* ??? Legacy. Should get access to real_format directly. */
2626 significand_size (enum machine_mode mode
)
2628 const struct real_format
*fmt
;
2630 fmt
= REAL_MODE_FORMAT (mode
);
2636 /* Return the size in bits of the largest binary value that can be
2637 held by the decimal coefficient for this mode. This is one more
2638 than the number of bits required to hold the largest coefficient
2640 double log2_10
= 3.3219281;
2641 return fmt
->p
* log2_10
;
2646 /* Return a hash value for the given real value. */
2647 /* ??? The "unsigned int" return value is intended to be hashval_t,
2648 but I didn't want to pull hashtab.h into real.h. */
2651 real_hash (const REAL_VALUE_TYPE
*r
)
2656 h
= r
->cl
| (r
->sign
<< 2);
2664 h
|= REAL_EXP (r
) << 3;
2669 h
^= (unsigned int)-1;
2678 if (sizeof(unsigned long) > sizeof(unsigned int))
2679 for (i
= 0; i
< SIGSZ
; ++i
)
2681 unsigned long s
= r
->sig
[i
];
2682 h
^= s
^ (s
>> (HOST_BITS_PER_LONG
/ 2));
2685 for (i
= 0; i
< SIGSZ
; ++i
)
2691 /* IEEE single-precision format. */
2693 static void encode_ieee_single (const struct real_format
*fmt
,
2694 long *, const REAL_VALUE_TYPE
*);
2695 static void decode_ieee_single (const struct real_format
*,
2696 REAL_VALUE_TYPE
*, const long *);
2699 encode_ieee_single (const struct real_format
*fmt
, long *buf
,
2700 const REAL_VALUE_TYPE
*r
)
2702 unsigned long image
, sig
, exp
;
2703 unsigned long sign
= r
->sign
;
2704 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2707 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
2718 image
|= 0x7fffffff;
2725 sig
= (fmt
->canonical_nan_lsbs_set
? (1 << 22) - 1 : 0);
2726 if (r
->signalling
== fmt
->qnan_msb_set
)
2737 image
|= 0x7fffffff;
2741 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2742 whereas the intermediate representation is 0.F x 2**exp.
2743 Which means we're off by one. */
2747 exp
= REAL_EXP (r
) + 127 - 1;
2760 decode_ieee_single (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
2763 unsigned long image
= buf
[0] & 0xffffffff;
2764 bool sign
= (image
>> 31) & 1;
2765 int exp
= (image
>> 23) & 0xff;
2767 memset (r
, 0, sizeof (*r
));
2768 image
<<= HOST_BITS_PER_LONG
- 24;
2773 if (image
&& fmt
->has_denorm
)
2777 SET_REAL_EXP (r
, -126);
2778 r
->sig
[SIGSZ
-1] = image
<< 1;
2781 else if (fmt
->has_signed_zero
)
2784 else if (exp
== 255 && (fmt
->has_nans
|| fmt
->has_inf
))
2790 r
->signalling
= (((image
>> (HOST_BITS_PER_LONG
- 2)) & 1)
2791 ^ fmt
->qnan_msb_set
);
2792 r
->sig
[SIGSZ
-1] = image
;
2804 SET_REAL_EXP (r
, exp
- 127 + 1);
2805 r
->sig
[SIGSZ
-1] = image
| SIG_MSB
;
2809 const struct real_format ieee_single_format
=
2828 const struct real_format mips_single_format
=
2847 const struct real_format motorola_single_format
=
2866 /* SPU Single Precision (Extended-Range Mode) format is the same as IEEE
2867 single precision with the following differences:
2868 - Infinities are not supported. Instead MAX_FLOAT or MIN_FLOAT
2870 - NaNs are not supported.
2871 - The range of non-zero numbers in binary is
2872 (001)[1.]000...000 to (255)[1.]111...111.
2873 - Denormals can be represented, but are treated as +0.0 when
2874 used as an operand and are never generated as a result.
2875 - -0.0 can be represented, but a zero result is always +0.0.
2876 - the only supported rounding mode is trunction (towards zero). */
2877 const struct real_format spu_single_format
=
2896 /* IEEE double-precision format. */
2898 static void encode_ieee_double (const struct real_format
*fmt
,
2899 long *, const REAL_VALUE_TYPE
*);
2900 static void decode_ieee_double (const struct real_format
*,
2901 REAL_VALUE_TYPE
*, const long *);
2904 encode_ieee_double (const struct real_format
*fmt
, long *buf
,
2905 const REAL_VALUE_TYPE
*r
)
2907 unsigned long image_lo
, image_hi
, sig_lo
, sig_hi
, exp
;
2908 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2910 image_hi
= r
->sign
<< 31;
2913 if (HOST_BITS_PER_LONG
== 64)
2915 sig_hi
= r
->sig
[SIGSZ
-1];
2916 sig_lo
= (sig_hi
>> (64 - 53)) & 0xffffffff;
2917 sig_hi
= (sig_hi
>> (64 - 53 + 1) >> 31) & 0xfffff;
2921 sig_hi
= r
->sig
[SIGSZ
-1];
2922 sig_lo
= r
->sig
[SIGSZ
-2];
2923 sig_lo
= (sig_hi
<< 21) | (sig_lo
>> 11);
2924 sig_hi
= (sig_hi
>> 11) & 0xfffff;
2934 image_hi
|= 2047 << 20;
2937 image_hi
|= 0x7fffffff;
2938 image_lo
= 0xffffffff;
2947 if (fmt
->canonical_nan_lsbs_set
)
2949 sig_hi
= (1 << 19) - 1;
2950 sig_lo
= 0xffffffff;
2958 if (r
->signalling
== fmt
->qnan_msb_set
)
2959 sig_hi
&= ~(1 << 19);
2962 if (sig_hi
== 0 && sig_lo
== 0)
2965 image_hi
|= 2047 << 20;
2971 image_hi
|= 0x7fffffff;
2972 image_lo
= 0xffffffff;
2977 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2978 whereas the intermediate representation is 0.F x 2**exp.
2979 Which means we're off by one. */
2983 exp
= REAL_EXP (r
) + 1023 - 1;
2984 image_hi
|= exp
<< 20;
2993 if (FLOAT_WORDS_BIG_ENDIAN
)
2994 buf
[0] = image_hi
, buf
[1] = image_lo
;
2996 buf
[0] = image_lo
, buf
[1] = image_hi
;
3000 decode_ieee_double (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3003 unsigned long image_hi
, image_lo
;
3007 if (FLOAT_WORDS_BIG_ENDIAN
)
3008 image_hi
= buf
[0], image_lo
= buf
[1];
3010 image_lo
= buf
[0], image_hi
= buf
[1];
3011 image_lo
&= 0xffffffff;
3012 image_hi
&= 0xffffffff;
3014 sign
= (image_hi
>> 31) & 1;
3015 exp
= (image_hi
>> 20) & 0x7ff;
3017 memset (r
, 0, sizeof (*r
));
3019 image_hi
<<= 32 - 21;
3020 image_hi
|= image_lo
>> 21;
3021 image_hi
&= 0x7fffffff;
3022 image_lo
<<= 32 - 21;
3026 if ((image_hi
|| image_lo
) && fmt
->has_denorm
)
3030 SET_REAL_EXP (r
, -1022);
3031 if (HOST_BITS_PER_LONG
== 32)
3033 image_hi
= (image_hi
<< 1) | (image_lo
>> 31);
3035 r
->sig
[SIGSZ
-1] = image_hi
;
3036 r
->sig
[SIGSZ
-2] = image_lo
;
3040 image_hi
= (image_hi
<< 31 << 2) | (image_lo
<< 1);
3041 r
->sig
[SIGSZ
-1] = image_hi
;
3045 else if (fmt
->has_signed_zero
)
3048 else if (exp
== 2047 && (fmt
->has_nans
|| fmt
->has_inf
))
3050 if (image_hi
|| image_lo
)
3054 r
->signalling
= ((image_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
3055 if (HOST_BITS_PER_LONG
== 32)
3057 r
->sig
[SIGSZ
-1] = image_hi
;
3058 r
->sig
[SIGSZ
-2] = image_lo
;
3061 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
;
3073 SET_REAL_EXP (r
, exp
- 1023 + 1);
3074 if (HOST_BITS_PER_LONG
== 32)
3076 r
->sig
[SIGSZ
-1] = image_hi
| SIG_MSB
;
3077 r
->sig
[SIGSZ
-2] = image_lo
;
3080 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
| SIG_MSB
;
3084 const struct real_format ieee_double_format
=
3103 const struct real_format mips_double_format
=
3122 const struct real_format motorola_double_format
=
3141 /* IEEE extended real format. This comes in three flavors: Intel's as
3142 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
3143 12- and 16-byte images may be big- or little endian; Motorola's is
3144 always big endian. */
3146 /* Helper subroutine which converts from the internal format to the
3147 12-byte little-endian Intel format. Functions below adjust this
3148 for the other possible formats. */
3150 encode_ieee_extended (const struct real_format
*fmt
, long *buf
,
3151 const REAL_VALUE_TYPE
*r
)
3153 unsigned long image_hi
, sig_hi
, sig_lo
;
3154 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3156 image_hi
= r
->sign
<< 15;
3157 sig_hi
= sig_lo
= 0;
3169 /* Intel requires the explicit integer bit to be set, otherwise
3170 it considers the value a "pseudo-infinity". Motorola docs
3171 say it doesn't care. */
3172 sig_hi
= 0x80000000;
3177 sig_lo
= sig_hi
= 0xffffffff;
3187 if (fmt
->canonical_nan_lsbs_set
)
3189 sig_hi
= (1 << 30) - 1;
3190 sig_lo
= 0xffffffff;
3193 else if (HOST_BITS_PER_LONG
== 32)
3195 sig_hi
= r
->sig
[SIGSZ
-1];
3196 sig_lo
= r
->sig
[SIGSZ
-2];
3200 sig_lo
= r
->sig
[SIGSZ
-1];
3201 sig_hi
= sig_lo
>> 31 >> 1;
3202 sig_lo
&= 0xffffffff;
3204 if (r
->signalling
== fmt
->qnan_msb_set
)
3205 sig_hi
&= ~(1 << 30);
3208 if ((sig_hi
& 0x7fffffff) == 0 && sig_lo
== 0)
3211 /* Intel requires the explicit integer bit to be set, otherwise
3212 it considers the value a "pseudo-nan". Motorola docs say it
3214 sig_hi
|= 0x80000000;
3219 sig_lo
= sig_hi
= 0xffffffff;
3225 int exp
= REAL_EXP (r
);
3227 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3228 whereas the intermediate representation is 0.F x 2**exp.
3229 Which means we're off by one.
3231 Except for Motorola, which consider exp=0 and explicit
3232 integer bit set to continue to be normalized. In theory
3233 this discrepancy has been taken care of by the difference
3234 in fmt->emin in round_for_format. */
3241 gcc_assert (exp
>= 0);
3245 if (HOST_BITS_PER_LONG
== 32)
3247 sig_hi
= r
->sig
[SIGSZ
-1];
3248 sig_lo
= r
->sig
[SIGSZ
-2];
3252 sig_lo
= r
->sig
[SIGSZ
-1];
3253 sig_hi
= sig_lo
>> 31 >> 1;
3254 sig_lo
&= 0xffffffff;
3263 buf
[0] = sig_lo
, buf
[1] = sig_hi
, buf
[2] = image_hi
;
3266 /* Convert from the internal format to the 12-byte Motorola format
3267 for an IEEE extended real. */
3269 encode_ieee_extended_motorola (const struct real_format
*fmt
, long *buf
,
3270 const REAL_VALUE_TYPE
*r
)
3273 encode_ieee_extended (fmt
, intermed
, r
);
3275 /* Motorola chips are assumed always to be big-endian. Also, the
3276 padding in a Motorola extended real goes between the exponent and
3277 the mantissa. At this point the mantissa is entirely within
3278 elements 0 and 1 of intermed, and the exponent entirely within
3279 element 2, so all we have to do is swap the order around, and
3280 shift element 2 left 16 bits. */
3281 buf
[0] = intermed
[2] << 16;
3282 buf
[1] = intermed
[1];
3283 buf
[2] = intermed
[0];
3286 /* Convert from the internal format to the 12-byte Intel format for
3287 an IEEE extended real. */
3289 encode_ieee_extended_intel_96 (const struct real_format
*fmt
, long *buf
,
3290 const REAL_VALUE_TYPE
*r
)
3292 if (FLOAT_WORDS_BIG_ENDIAN
)
3294 /* All the padding in an Intel-format extended real goes at the high
3295 end, which in this case is after the mantissa, not the exponent.
3296 Therefore we must shift everything down 16 bits. */
3298 encode_ieee_extended (fmt
, intermed
, r
);
3299 buf
[0] = ((intermed
[2] << 16) | ((unsigned long)(intermed
[1] & 0xFFFF0000) >> 16));
3300 buf
[1] = ((intermed
[1] << 16) | ((unsigned long)(intermed
[0] & 0xFFFF0000) >> 16));
3301 buf
[2] = (intermed
[0] << 16);
3304 /* encode_ieee_extended produces what we want directly. */
3305 encode_ieee_extended (fmt
, buf
, r
);
3308 /* Convert from the internal format to the 16-byte Intel format for
3309 an IEEE extended real. */
3311 encode_ieee_extended_intel_128 (const struct real_format
*fmt
, long *buf
,
3312 const REAL_VALUE_TYPE
*r
)
3314 /* All the padding in an Intel-format extended real goes at the high end. */
3315 encode_ieee_extended_intel_96 (fmt
, buf
, r
);
3319 /* As above, we have a helper function which converts from 12-byte
3320 little-endian Intel format to internal format. Functions below
3321 adjust for the other possible formats. */
3323 decode_ieee_extended (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3326 unsigned long image_hi
, sig_hi
, sig_lo
;
3330 sig_lo
= buf
[0], sig_hi
= buf
[1], image_hi
= buf
[2];
3331 sig_lo
&= 0xffffffff;
3332 sig_hi
&= 0xffffffff;
3333 image_hi
&= 0xffffffff;
3335 sign
= (image_hi
>> 15) & 1;
3336 exp
= image_hi
& 0x7fff;
3338 memset (r
, 0, sizeof (*r
));
3342 if ((sig_hi
|| sig_lo
) && fmt
->has_denorm
)
3347 /* When the IEEE format contains a hidden bit, we know that
3348 it's zero at this point, and so shift up the significand
3349 and decrease the exponent to match. In this case, Motorola
3350 defines the explicit integer bit to be valid, so we don't
3351 know whether the msb is set or not. */
3352 SET_REAL_EXP (r
, fmt
->emin
);
3353 if (HOST_BITS_PER_LONG
== 32)
3355 r
->sig
[SIGSZ
-1] = sig_hi
;
3356 r
->sig
[SIGSZ
-2] = sig_lo
;
3359 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3363 else if (fmt
->has_signed_zero
)
3366 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3368 /* See above re "pseudo-infinities" and "pseudo-nans".
3369 Short summary is that the MSB will likely always be
3370 set, and that we don't care about it. */
3371 sig_hi
&= 0x7fffffff;
3373 if (sig_hi
|| sig_lo
)
3377 r
->signalling
= ((sig_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
3378 if (HOST_BITS_PER_LONG
== 32)
3380 r
->sig
[SIGSZ
-1] = sig_hi
;
3381 r
->sig
[SIGSZ
-2] = sig_lo
;
3384 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3396 SET_REAL_EXP (r
, exp
- 16383 + 1);
3397 if (HOST_BITS_PER_LONG
== 32)
3399 r
->sig
[SIGSZ
-1] = sig_hi
;
3400 r
->sig
[SIGSZ
-2] = sig_lo
;
3403 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3407 /* Convert from the internal format to the 12-byte Motorola format
3408 for an IEEE extended real. */
3410 decode_ieee_extended_motorola (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3415 /* Motorola chips are assumed always to be big-endian. Also, the
3416 padding in a Motorola extended real goes between the exponent and
3417 the mantissa; remove it. */
3418 intermed
[0] = buf
[2];
3419 intermed
[1] = buf
[1];
3420 intermed
[2] = (unsigned long)buf
[0] >> 16;
3422 decode_ieee_extended (fmt
, r
, intermed
);
3425 /* Convert from the internal format to the 12-byte Intel format for
3426 an IEEE extended real. */
3428 decode_ieee_extended_intel_96 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3431 if (FLOAT_WORDS_BIG_ENDIAN
)
3433 /* All the padding in an Intel-format extended real goes at the high
3434 end, which in this case is after the mantissa, not the exponent.
3435 Therefore we must shift everything up 16 bits. */
3438 intermed
[0] = (((unsigned long)buf
[2] >> 16) | (buf
[1] << 16));
3439 intermed
[1] = (((unsigned long)buf
[1] >> 16) | (buf
[0] << 16));
3440 intermed
[2] = ((unsigned long)buf
[0] >> 16);
3442 decode_ieee_extended (fmt
, r
, intermed
);
3445 /* decode_ieee_extended produces what we want directly. */
3446 decode_ieee_extended (fmt
, r
, buf
);
3449 /* Convert from the internal format to the 16-byte Intel format for
3450 an IEEE extended real. */
3452 decode_ieee_extended_intel_128 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3455 /* All the padding in an Intel-format extended real goes at the high end. */
3456 decode_ieee_extended_intel_96 (fmt
, r
, buf
);
3459 const struct real_format ieee_extended_motorola_format
=
3461 encode_ieee_extended_motorola
,
3462 decode_ieee_extended_motorola
,
3478 const struct real_format ieee_extended_intel_96_format
=
3480 encode_ieee_extended_intel_96
,
3481 decode_ieee_extended_intel_96
,
3497 const struct real_format ieee_extended_intel_128_format
=
3499 encode_ieee_extended_intel_128
,
3500 decode_ieee_extended_intel_128
,
3516 /* The following caters to i386 systems that set the rounding precision
3517 to 53 bits instead of 64, e.g. FreeBSD. */
3518 const struct real_format ieee_extended_intel_96_round_53_format
=
3520 encode_ieee_extended_intel_96
,
3521 decode_ieee_extended_intel_96
,
3537 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3538 numbers whose sum is equal to the extended precision value. The number
3539 with greater magnitude is first. This format has the same magnitude
3540 range as an IEEE double precision value, but effectively 106 bits of
3541 significand precision. Infinity and NaN are represented by their IEEE
3542 double precision value stored in the first number, the second number is
3543 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3545 static void encode_ibm_extended (const struct real_format
*fmt
,
3546 long *, const REAL_VALUE_TYPE
*);
3547 static void decode_ibm_extended (const struct real_format
*,
3548 REAL_VALUE_TYPE
*, const long *);
3551 encode_ibm_extended (const struct real_format
*fmt
, long *buf
,
3552 const REAL_VALUE_TYPE
*r
)
3554 REAL_VALUE_TYPE u
, normr
, v
;
3555 const struct real_format
*base_fmt
;
3557 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3559 /* Renormalize R before doing any arithmetic on it. */
3561 if (normr
.cl
== rvc_normal
)
3564 /* u = IEEE double precision portion of significand. */
3566 round_for_format (base_fmt
, &u
);
3567 encode_ieee_double (base_fmt
, &buf
[0], &u
);
3569 if (u
.cl
== rvc_normal
)
3571 do_add (&v
, &normr
, &u
, 1);
3572 /* Call round_for_format since we might need to denormalize. */
3573 round_for_format (base_fmt
, &v
);
3574 encode_ieee_double (base_fmt
, &buf
[2], &v
);
3578 /* Inf, NaN, 0 are all representable as doubles, so the
3579 least-significant part can be 0.0. */
3586 decode_ibm_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
, REAL_VALUE_TYPE
*r
,
3589 REAL_VALUE_TYPE u
, v
;
3590 const struct real_format
*base_fmt
;
3592 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3593 decode_ieee_double (base_fmt
, &u
, &buf
[0]);
3595 if (u
.cl
!= rvc_zero
&& u
.cl
!= rvc_inf
&& u
.cl
!= rvc_nan
)
3597 decode_ieee_double (base_fmt
, &v
, &buf
[2]);
3598 do_add (r
, &u
, &v
, 0);
3604 const struct real_format ibm_extended_format
=
3606 encode_ibm_extended
,
3607 decode_ibm_extended
,
3623 const struct real_format mips_extended_format
=
3625 encode_ibm_extended
,
3626 decode_ibm_extended
,
3643 /* IEEE quad precision format. */
3645 static void encode_ieee_quad (const struct real_format
*fmt
,
3646 long *, const REAL_VALUE_TYPE
*);
3647 static void decode_ieee_quad (const struct real_format
*,
3648 REAL_VALUE_TYPE
*, const long *);
3651 encode_ieee_quad (const struct real_format
*fmt
, long *buf
,
3652 const REAL_VALUE_TYPE
*r
)
3654 unsigned long image3
, image2
, image1
, image0
, exp
;
3655 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3658 image3
= r
->sign
<< 31;
3663 rshift_significand (&u
, r
, SIGNIFICAND_BITS
- 113);
3672 image3
|= 32767 << 16;
3675 image3
|= 0x7fffffff;
3676 image2
= 0xffffffff;
3677 image1
= 0xffffffff;
3678 image0
= 0xffffffff;
3685 image3
|= 32767 << 16;
3689 if (fmt
->canonical_nan_lsbs_set
)
3692 image2
= image1
= image0
= 0xffffffff;
3695 else if (HOST_BITS_PER_LONG
== 32)
3700 image3
|= u
.sig
[3] & 0xffff;
3705 image1
= image0
>> 31 >> 1;
3707 image3
|= (image2
>> 31 >> 1) & 0xffff;
3708 image0
&= 0xffffffff;
3709 image2
&= 0xffffffff;
3711 if (r
->signalling
== fmt
->qnan_msb_set
)
3715 if (((image3
& 0xffff) | image2
| image1
| image0
) == 0)
3720 image3
|= 0x7fffffff;
3721 image2
= 0xffffffff;
3722 image1
= 0xffffffff;
3723 image0
= 0xffffffff;
3728 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3729 whereas the intermediate representation is 0.F x 2**exp.
3730 Which means we're off by one. */
3734 exp
= REAL_EXP (r
) + 16383 - 1;
3735 image3
|= exp
<< 16;
3737 if (HOST_BITS_PER_LONG
== 32)
3742 image3
|= u
.sig
[3] & 0xffff;
3747 image1
= image0
>> 31 >> 1;
3749 image3
|= (image2
>> 31 >> 1) & 0xffff;
3750 image0
&= 0xffffffff;
3751 image2
&= 0xffffffff;
3759 if (FLOAT_WORDS_BIG_ENDIAN
)
3776 decode_ieee_quad (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3779 unsigned long image3
, image2
, image1
, image0
;
3783 if (FLOAT_WORDS_BIG_ENDIAN
)
3797 image0
&= 0xffffffff;
3798 image1
&= 0xffffffff;
3799 image2
&= 0xffffffff;
3801 sign
= (image3
>> 31) & 1;
3802 exp
= (image3
>> 16) & 0x7fff;
3805 memset (r
, 0, sizeof (*r
));
3809 if ((image3
| image2
| image1
| image0
) && fmt
->has_denorm
)
3814 SET_REAL_EXP (r
, -16382 + (SIGNIFICAND_BITS
- 112));
3815 if (HOST_BITS_PER_LONG
== 32)
3824 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3825 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3830 else if (fmt
->has_signed_zero
)
3833 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3835 if (image3
| image2
| image1
| image0
)
3839 r
->signalling
= ((image3
>> 15) & 1) ^ fmt
->qnan_msb_set
;
3841 if (HOST_BITS_PER_LONG
== 32)
3850 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3851 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3853 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3865 SET_REAL_EXP (r
, exp
- 16383 + 1);
3867 if (HOST_BITS_PER_LONG
== 32)
3876 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3877 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3879 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3880 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3884 const struct real_format ieee_quad_format
=
3903 const struct real_format mips_quad_format
=
3922 /* Descriptions of VAX floating point formats can be found beginning at
3924 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
3926 The thing to remember is that they're almost IEEE, except for word
3927 order, exponent bias, and the lack of infinities, nans, and denormals.
3929 We don't implement the H_floating format here, simply because neither
3930 the VAX or Alpha ports use it. */
3932 static void encode_vax_f (const struct real_format
*fmt
,
3933 long *, const REAL_VALUE_TYPE
*);
3934 static void decode_vax_f (const struct real_format
*,
3935 REAL_VALUE_TYPE
*, const long *);
3936 static void encode_vax_d (const struct real_format
*fmt
,
3937 long *, const REAL_VALUE_TYPE
*);
3938 static void decode_vax_d (const struct real_format
*,
3939 REAL_VALUE_TYPE
*, const long *);
3940 static void encode_vax_g (const struct real_format
*fmt
,
3941 long *, const REAL_VALUE_TYPE
*);
3942 static void decode_vax_g (const struct real_format
*,
3943 REAL_VALUE_TYPE
*, const long *);
3946 encode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3947 const REAL_VALUE_TYPE
*r
)
3949 unsigned long sign
, exp
, sig
, image
;
3951 sign
= r
->sign
<< 15;
3961 image
= 0xffff7fff | sign
;
3965 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
3966 exp
= REAL_EXP (r
) + 128;
3968 image
= (sig
<< 16) & 0xffff0000;
3982 decode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3983 REAL_VALUE_TYPE
*r
, const long *buf
)
3985 unsigned long image
= buf
[0] & 0xffffffff;
3986 int exp
= (image
>> 7) & 0xff;
3988 memset (r
, 0, sizeof (*r
));
3993 r
->sign
= (image
>> 15) & 1;
3994 SET_REAL_EXP (r
, exp
- 128);
3996 image
= ((image
& 0x7f) << 16) | ((image
>> 16) & 0xffff);
3997 r
->sig
[SIGSZ
-1] = (image
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
4002 encode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4003 const REAL_VALUE_TYPE
*r
)
4005 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
4010 image0
= image1
= 0;
4015 image0
= 0xffff7fff | sign
;
4016 image1
= 0xffffffff;
4020 /* Extract the significand into straight hi:lo. */
4021 if (HOST_BITS_PER_LONG
== 64)
4023 image0
= r
->sig
[SIGSZ
-1];
4024 image1
= (image0
>> (64 - 56)) & 0xffffffff;
4025 image0
= (image0
>> (64 - 56 + 1) >> 31) & 0x7fffff;
4029 image0
= r
->sig
[SIGSZ
-1];
4030 image1
= r
->sig
[SIGSZ
-2];
4031 image1
= (image0
<< 24) | (image1
>> 8);
4032 image0
= (image0
>> 8) & 0xffffff;
4035 /* Rearrange the half-words of the significand to match the
4037 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff007f;
4038 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
4040 /* Add the sign and exponent. */
4042 image0
|= (REAL_EXP (r
) + 128) << 7;
4049 if (FLOAT_WORDS_BIG_ENDIAN
)
4050 buf
[0] = image1
, buf
[1] = image0
;
4052 buf
[0] = image0
, buf
[1] = image1
;
4056 decode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4057 REAL_VALUE_TYPE
*r
, const long *buf
)
4059 unsigned long image0
, image1
;
4062 if (FLOAT_WORDS_BIG_ENDIAN
)
4063 image1
= buf
[0], image0
= buf
[1];
4065 image0
= buf
[0], image1
= buf
[1];
4066 image0
&= 0xffffffff;
4067 image1
&= 0xffffffff;
4069 exp
= (image0
>> 7) & 0xff;
4071 memset (r
, 0, sizeof (*r
));
4076 r
->sign
= (image0
>> 15) & 1;
4077 SET_REAL_EXP (r
, exp
- 128);
4079 /* Rearrange the half-words of the external format into
4080 proper ascending order. */
4081 image0
= ((image0
& 0x7f) << 16) | ((image0
>> 16) & 0xffff);
4082 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
4084 if (HOST_BITS_PER_LONG
== 64)
4086 image0
= (image0
<< 31 << 1) | image1
;
4089 r
->sig
[SIGSZ
-1] = image0
;
4093 r
->sig
[SIGSZ
-1] = image0
;
4094 r
->sig
[SIGSZ
-2] = image1
;
4095 lshift_significand (r
, r
, 2*HOST_BITS_PER_LONG
- 56);
4096 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4102 encode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4103 const REAL_VALUE_TYPE
*r
)
4105 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
4110 image0
= image1
= 0;
4115 image0
= 0xffff7fff | sign
;
4116 image1
= 0xffffffff;
4120 /* Extract the significand into straight hi:lo. */
4121 if (HOST_BITS_PER_LONG
== 64)
4123 image0
= r
->sig
[SIGSZ
-1];
4124 image1
= (image0
>> (64 - 53)) & 0xffffffff;
4125 image0
= (image0
>> (64 - 53 + 1) >> 31) & 0xfffff;
4129 image0
= r
->sig
[SIGSZ
-1];
4130 image1
= r
->sig
[SIGSZ
-2];
4131 image1
= (image0
<< 21) | (image1
>> 11);
4132 image0
= (image0
>> 11) & 0xfffff;
4135 /* Rearrange the half-words of the significand to match the
4137 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff000f;
4138 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
4140 /* Add the sign and exponent. */
4142 image0
|= (REAL_EXP (r
) + 1024) << 4;
4149 if (FLOAT_WORDS_BIG_ENDIAN
)
4150 buf
[0] = image1
, buf
[1] = image0
;
4152 buf
[0] = image0
, buf
[1] = image1
;
4156 decode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4157 REAL_VALUE_TYPE
*r
, const long *buf
)
4159 unsigned long image0
, image1
;
4162 if (FLOAT_WORDS_BIG_ENDIAN
)
4163 image1
= buf
[0], image0
= buf
[1];
4165 image0
= buf
[0], image1
= buf
[1];
4166 image0
&= 0xffffffff;
4167 image1
&= 0xffffffff;
4169 exp
= (image0
>> 4) & 0x7ff;
4171 memset (r
, 0, sizeof (*r
));
4176 r
->sign
= (image0
>> 15) & 1;
4177 SET_REAL_EXP (r
, exp
- 1024);
4179 /* Rearrange the half-words of the external format into
4180 proper ascending order. */
4181 image0
= ((image0
& 0xf) << 16) | ((image0
>> 16) & 0xffff);
4182 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
4184 if (HOST_BITS_PER_LONG
== 64)
4186 image0
= (image0
<< 31 << 1) | image1
;
4189 r
->sig
[SIGSZ
-1] = image0
;
4193 r
->sig
[SIGSZ
-1] = image0
;
4194 r
->sig
[SIGSZ
-2] = image1
;
4195 lshift_significand (r
, r
, 64 - 53);
4196 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4201 const struct real_format vax_f_format
=
4220 const struct real_format vax_d_format
=
4239 const struct real_format vax_g_format
=
4258 /* Encode real R into a single precision DFP value in BUF. */
4260 encode_decimal_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4261 long *buf ATTRIBUTE_UNUSED
,
4262 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4264 encode_decimal32 (fmt
, buf
, r
);
4267 /* Decode a single precision DFP value in BUF into a real R. */
4269 decode_decimal_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4270 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4271 const long *buf ATTRIBUTE_UNUSED
)
4273 decode_decimal32 (fmt
, r
, buf
);
4276 /* Encode real R into a double precision DFP value in BUF. */
4278 encode_decimal_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4279 long *buf ATTRIBUTE_UNUSED
,
4280 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4282 encode_decimal64 (fmt
, buf
, r
);
4285 /* Decode a double precision DFP value in BUF into a real R. */
4287 decode_decimal_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4288 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4289 const long *buf ATTRIBUTE_UNUSED
)
4291 decode_decimal64 (fmt
, r
, buf
);
4294 /* Encode real R into a quad precision DFP value in BUF. */
4296 encode_decimal_quad (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4297 long *buf ATTRIBUTE_UNUSED
,
4298 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4300 encode_decimal128 (fmt
, buf
, r
);
4303 /* Decode a quad precision DFP value in BUF into a real R. */
4305 decode_decimal_quad (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4306 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4307 const long *buf ATTRIBUTE_UNUSED
)
4309 decode_decimal128 (fmt
, r
, buf
);
4312 /* Single precision decimal floating point (IEEE 754). */
4313 const struct real_format decimal_single_format
=
4315 encode_decimal_single
,
4316 decode_decimal_single
,
4332 /* Double precision decimal floating point (IEEE 754). */
4333 const struct real_format decimal_double_format
=
4335 encode_decimal_double
,
4336 decode_decimal_double
,
4352 /* Quad precision decimal floating point (IEEE 754). */
4353 const struct real_format decimal_quad_format
=
4355 encode_decimal_quad
,
4356 decode_decimal_quad
,
4372 /* A synthetic "format" for internal arithmetic. It's the size of the
4373 internal significand minus the two bits needed for proper rounding.
4374 The encode and decode routines exist only to satisfy our paranoia
4377 static void encode_internal (const struct real_format
*fmt
,
4378 long *, const REAL_VALUE_TYPE
*);
4379 static void decode_internal (const struct real_format
*,
4380 REAL_VALUE_TYPE
*, const long *);
4383 encode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4384 const REAL_VALUE_TYPE
*r
)
4386 memcpy (buf
, r
, sizeof (*r
));
4390 decode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4391 REAL_VALUE_TYPE
*r
, const long *buf
)
4393 memcpy (r
, buf
, sizeof (*r
));
4396 const struct real_format real_internal_format
=
4401 SIGNIFICAND_BITS
- 2,
4402 SIGNIFICAND_BITS
- 2,
4415 /* Calculate the square root of X in mode MODE, and store the result
4416 in R. Return TRUE if the operation does not raise an exception.
4417 For details see "High Precision Division and Square Root",
4418 Alan H. Karp and Peter Markstein, HP Lab Report 93-93-42, June
4419 1993. http://www.hpl.hp.com/techreports/93/HPL-93-42.pdf. */
4422 real_sqrt (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4423 const REAL_VALUE_TYPE
*x
)
4425 static REAL_VALUE_TYPE halfthree
;
4426 static bool init
= false;
4427 REAL_VALUE_TYPE h
, t
, i
;
4430 /* sqrt(-0.0) is -0.0. */
4431 if (real_isnegzero (x
))
4437 /* Negative arguments return NaN. */
4440 get_canonical_qnan (r
, 0);
4444 /* Infinity and NaN return themselves. */
4445 if (!real_isfinite (x
))
4453 do_add (&halfthree
, &dconst1
, &dconsthalf
, 0);
4457 /* Initial guess for reciprocal sqrt, i. */
4458 exp
= real_exponent (x
);
4459 real_ldexp (&i
, &dconst1
, -exp
/2);
4461 /* Newton's iteration for reciprocal sqrt, i. */
4462 for (iter
= 0; iter
< 16; iter
++)
4464 /* i(n+1) = i(n) * (1.5 - 0.5*i(n)*i(n)*x). */
4465 do_multiply (&t
, x
, &i
);
4466 do_multiply (&h
, &t
, &i
);
4467 do_multiply (&t
, &h
, &dconsthalf
);
4468 do_add (&h
, &halfthree
, &t
, 1);
4469 do_multiply (&t
, &i
, &h
);
4471 /* Check for early convergence. */
4472 if (iter
>= 6 && real_identical (&i
, &t
))
4475 /* ??? Unroll loop to avoid copying. */
4479 /* Final iteration: r = i*x + 0.5*i*x*(1.0 - i*(i*x)). */
4480 do_multiply (&t
, x
, &i
);
4481 do_multiply (&h
, &t
, &i
);
4482 do_add (&i
, &dconst1
, &h
, 1);
4483 do_multiply (&h
, &t
, &i
);
4484 do_multiply (&i
, &dconsthalf
, &h
);
4485 do_add (&h
, &t
, &i
, 0);
4487 /* ??? We need a Tuckerman test to get the last bit. */
4489 real_convert (r
, mode
, &h
);
4493 /* Calculate X raised to the integer exponent N in mode MODE and store
4494 the result in R. Return true if the result may be inexact due to
4495 loss of precision. The algorithm is the classic "left-to-right binary
4496 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
4497 Algorithms", "The Art of Computer Programming", Volume 2. */
4500 real_powi (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4501 const REAL_VALUE_TYPE
*x
, HOST_WIDE_INT n
)
4503 unsigned HOST_WIDE_INT bit
;
4505 bool inexact
= false;
4517 /* Don't worry about overflow, from now on n is unsigned. */
4525 bit
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
4526 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
; i
++)
4530 inexact
|= do_multiply (&t
, &t
, &t
);
4532 inexact
|= do_multiply (&t
, &t
, x
);
4540 inexact
|= do_divide (&t
, &dconst1
, &t
);
4542 real_convert (r
, mode
, &t
);
4546 /* Round X to the nearest integer not larger in absolute value, i.e.
4547 towards zero, placing the result in R in mode MODE. */
4550 real_trunc (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4551 const REAL_VALUE_TYPE
*x
)
4553 do_fix_trunc (r
, x
);
4554 if (mode
!= VOIDmode
)
4555 real_convert (r
, mode
, r
);
4558 /* Round X to the largest integer not greater in value, i.e. round
4559 down, placing the result in R in mode MODE. */
4562 real_floor (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4563 const REAL_VALUE_TYPE
*x
)
4567 do_fix_trunc (&t
, x
);
4568 if (! real_identical (&t
, x
) && x
->sign
)
4569 do_add (&t
, &t
, &dconstm1
, 0);
4570 if (mode
!= VOIDmode
)
4571 real_convert (r
, mode
, &t
);
4576 /* Round X to the smallest integer not less then argument, i.e. round
4577 up, placing the result in R in mode MODE. */
4580 real_ceil (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4581 const REAL_VALUE_TYPE
*x
)
4585 do_fix_trunc (&t
, x
);
4586 if (! real_identical (&t
, x
) && ! x
->sign
)
4587 do_add (&t
, &t
, &dconst1
, 0);
4588 if (mode
!= VOIDmode
)
4589 real_convert (r
, mode
, &t
);
4594 /* Round X to the nearest integer, but round halfway cases away from
4598 real_round (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4599 const REAL_VALUE_TYPE
*x
)
4601 do_add (r
, x
, &dconsthalf
, x
->sign
);
4602 do_fix_trunc (r
, r
);
4603 if (mode
!= VOIDmode
)
4604 real_convert (r
, mode
, r
);
4607 /* Set the sign of R to the sign of X. */
4610 real_copysign (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*x
)
4615 /* Convert from REAL_VALUE_TYPE to MPFR. The caller is responsible
4616 for initializing and clearing the MPFR parameter. */
4619 mpfr_from_real (mpfr_ptr m
, const REAL_VALUE_TYPE
*r
, mp_rnd_t rndmode
)
4621 /* We use a string as an intermediate type. */
4625 /* Take care of Infinity and NaN. */
4626 if (r
->cl
== rvc_inf
)
4628 mpfr_set_inf (m
, r
->sign
== 1 ? -1 : 1);
4632 if (r
->cl
== rvc_nan
)
4638 real_to_hexadecimal (buf
, r
, sizeof (buf
), 0, 1);
4639 /* mpfr_set_str() parses hexadecimal floats from strings in the same
4640 format that GCC will output them. Nothing extra is needed. */
4641 ret
= mpfr_set_str (m
, buf
, 16, rndmode
);
4642 gcc_assert (ret
== 0);
4645 /* Convert from MPFR to REAL_VALUE_TYPE, for a given type TYPE and rounding
4646 mode RNDMODE. TYPE is only relevant if M is a NaN. */
4649 real_from_mpfr (REAL_VALUE_TYPE
*r
, mpfr_srcptr m
, tree type
, mp_rnd_t rndmode
)
4651 /* We use a string as an intermediate type. */
4652 char buf
[128], *rstr
;
4655 /* Take care of Infinity and NaN. */
4659 if (mpfr_sgn (m
) < 0)
4660 *r
= REAL_VALUE_NEGATE (*r
);
4666 real_nan (r
, "", 1, TYPE_MODE (type
));
4670 rstr
= mpfr_get_str (NULL
, &exp
, 16, 0, m
, rndmode
);
4672 /* The additional 12 chars add space for the sprintf below. This
4673 leaves 6 digits for the exponent which is supposedly enough. */
4674 gcc_assert (rstr
!= NULL
&& strlen (rstr
) < sizeof (buf
) - 12);
4676 /* REAL_VALUE_ATOF expects the exponent for mantissa * 2**exp,
4677 mpfr_get_str returns the exponent for mantissa * 16**exp, adjust
4682 sprintf (buf
, "-0x.%sp%d", &rstr
[1], (int) exp
);
4684 sprintf (buf
, "0x.%sp%d", rstr
, (int) exp
);
4686 mpfr_free_str (rstr
);
4688 real_from_string (r
, buf
);
4691 /* Check whether the real constant value given is an integer. */
4694 real_isinteger (const REAL_VALUE_TYPE
*c
, enum machine_mode mode
)
4696 REAL_VALUE_TYPE cint
;
4698 real_trunc (&cint
, mode
, c
);
4699 return real_identical (c
, &cint
);
4702 /* Write into BUF the maximum representable finite floating-point
4703 number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
4704 float string. LEN is the size of BUF, and the buffer must be large
4705 enough to contain the resulting string. */
4708 get_max_float (const struct real_format
*fmt
, char *buf
, size_t len
)
4713 strcpy (buf
, "0x0.");
4715 for (i
= 0, p
= buf
+ 4; i
+ 3 < n
; i
+= 4)
4718 *p
++ = "08ce"[n
- i
];
4719 sprintf (p
, "p%d", fmt
->emax
);
4720 if (fmt
->pnan
< fmt
->p
)
4722 /* This is an IBM extended double format made up of two IEEE
4723 doubles. The value of the long double is the sum of the
4724 values of the two parts. The most significant part is
4725 required to be the value of the long double rounded to the
4726 nearest double. Rounding means we need a slightly smaller
4727 value for LDBL_MAX. */
4728 buf
[4 + fmt
->pnan
/ 4] = "7bde"[fmt
->pnan
% 4];
4731 gcc_assert (strlen (buf
) < len
);