1 /* real.cc - software floating point emulation.
2 Copyright (C) 1993-2023 Free Software Foundation, Inc.
3 Contributed by Stephen L. Moshier (moshier@world.std.com).
4 Re-written by Richard Henderson <rth@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
31 /* The floating point model used internally is not exactly IEEE 754
32 compliant, and close to the description in the ISO C99 standard,
33 section 5.2.4.2.2 Characteristics of floating types.
37 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
41 b = base or radix, here always 2
43 p = precision (the number of base-b digits in the significand)
44 f_k = the digits of the significand.
46 We differ from typical IEEE 754 encodings in that the entire
47 significand is fractional. Normalized significands are in the
50 A requirement of the model is that P be larger than the largest
51 supported target floating-point type by at least 2 bits. This gives
52 us proper rounding when we truncate to the target type. In addition,
53 E must be large enough to hold the smallest supported denormal number
56 Both of these requirements are easily satisfied. The largest target
57 significand is 113 bits; we store at least 160. The smallest
58 denormal number fits in 17 exponent bits; we store 26. */
61 /* Used to classify two numbers simultaneously. */
62 #define CLASS2(A, B) ((A) << 2 | (B))
64 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
65 #error "Some constant folding done by hand to avoid shift count warnings"
68 static void get_zero (REAL_VALUE_TYPE
*, int);
69 static void get_canonical_qnan (REAL_VALUE_TYPE
*, int);
70 static void get_canonical_snan (REAL_VALUE_TYPE
*, int);
71 static void get_inf (REAL_VALUE_TYPE
*, int);
72 static bool sticky_rshift_significand (REAL_VALUE_TYPE
*,
73 const REAL_VALUE_TYPE
*, unsigned int);
74 static void rshift_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
76 static void lshift_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
78 static void lshift_significand_1 (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
79 static bool add_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*,
80 const REAL_VALUE_TYPE
*);
81 static bool sub_significands (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
82 const REAL_VALUE_TYPE
*, int);
83 static void neg_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
84 static int cmp_significands (const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
85 static int cmp_significand_0 (const REAL_VALUE_TYPE
*);
86 static void set_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
87 static void clear_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
88 static bool test_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
89 static void clear_significand_below (REAL_VALUE_TYPE
*, unsigned int);
90 static bool div_significands (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
91 const REAL_VALUE_TYPE
*);
92 static void normalize (REAL_VALUE_TYPE
*);
94 static bool do_add (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
95 const REAL_VALUE_TYPE
*, int);
96 static bool do_multiply (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
97 const REAL_VALUE_TYPE
*);
98 static bool do_divide (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
99 const REAL_VALUE_TYPE
*);
100 static int do_compare (const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*, int);
101 static void do_fix_trunc (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
103 static unsigned long rtd_divmod (REAL_VALUE_TYPE
*, REAL_VALUE_TYPE
*);
104 static void decimal_from_integer (REAL_VALUE_TYPE
*);
105 static void decimal_integer_string (char *, const REAL_VALUE_TYPE
*,
108 static const REAL_VALUE_TYPE
* ten_to_ptwo (int);
109 static const REAL_VALUE_TYPE
* ten_to_mptwo (int);
110 static const REAL_VALUE_TYPE
* real_digit (int);
111 static void times_pten (REAL_VALUE_TYPE
*, int);
113 static void round_for_format (const struct real_format
*, REAL_VALUE_TYPE
*);
115 /* Determine whether a floating-point value X is a denormal. R is
116 expected to be in denormal form, so this function is only
117 meaningful after a call to round_for_format. */
120 real_isdenormal (const REAL_VALUE_TYPE
*r
)
122 return r
->cl
== rvc_normal
&& (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
125 /* Initialize R with a positive zero. */
128 get_zero (REAL_VALUE_TYPE
*r
, int sign
)
130 memset (r
, 0, sizeof (*r
));
134 /* Initialize R with the canonical quiet NaN. */
137 get_canonical_qnan (REAL_VALUE_TYPE
*r
, int sign
)
139 memset (r
, 0, sizeof (*r
));
146 get_canonical_snan (REAL_VALUE_TYPE
*r
, int sign
)
148 memset (r
, 0, sizeof (*r
));
156 get_inf (REAL_VALUE_TYPE
*r
, int sign
)
158 memset (r
, 0, sizeof (*r
));
164 /* Right-shift the significand of A by N bits; put the result in the
165 significand of R. If any one bits are shifted out, return true. */
168 sticky_rshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
171 unsigned long sticky
= 0;
172 unsigned int i
, ofs
= 0;
174 if (n
>= HOST_BITS_PER_LONG
)
176 for (i
= 0, ofs
= n
/ HOST_BITS_PER_LONG
; i
< ofs
; ++i
)
178 n
&= HOST_BITS_PER_LONG
- 1;
183 sticky
|= a
->sig
[ofs
] & (((unsigned long)1 << n
) - 1);
184 for (i
= 0; i
< SIGSZ
; ++i
)
187 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
188 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
189 << (HOST_BITS_PER_LONG
- n
)));
194 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
195 r
->sig
[i
] = a
->sig
[ofs
+ i
];
196 for (; i
< SIGSZ
; ++i
)
203 /* Right-shift the significand of A by N bits; put the result in the
207 rshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
210 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
212 n
&= HOST_BITS_PER_LONG
- 1;
215 for (i
= 0; i
< SIGSZ
; ++i
)
218 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
219 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
220 << (HOST_BITS_PER_LONG
- n
)));
225 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
226 r
->sig
[i
] = a
->sig
[ofs
+ i
];
227 for (; i
< SIGSZ
; ++i
)
232 /* Left-shift the significand of A by N bits; put the result in the
236 lshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
239 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
241 n
&= HOST_BITS_PER_LONG
- 1;
244 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
245 r
->sig
[SIGSZ
-1-i
] = a
->sig
[SIGSZ
-1-i
-ofs
];
246 for (; i
< SIGSZ
; ++i
)
247 r
->sig
[SIGSZ
-1-i
] = 0;
250 for (i
= 0; i
< SIGSZ
; ++i
)
253 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
]) << n
)
254 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
-1])
255 >> (HOST_BITS_PER_LONG
- n
)));
259 /* Likewise, but N is specialized to 1. */
262 lshift_significand_1 (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
266 for (i
= SIGSZ
- 1; i
> 0; --i
)
267 r
->sig
[i
] = (a
->sig
[i
] << 1) | (a
->sig
[i
-1] >> (HOST_BITS_PER_LONG
- 1));
268 r
->sig
[0] = a
->sig
[0] << 1;
271 /* Add the significands of A and B, placing the result in R. Return
272 true if there was carry out of the most significant word. */
275 add_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
276 const REAL_VALUE_TYPE
*b
)
281 for (i
= 0; i
< SIGSZ
; ++i
)
283 unsigned long ai
= a
->sig
[i
];
284 unsigned long ri
= ai
+ b
->sig
[i
];
300 /* Subtract the significands of A and B, placing the result in R. CARRY is
301 true if there's a borrow incoming to the least significant word.
302 Return true if there was borrow out of the most significant word. */
305 sub_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
306 const REAL_VALUE_TYPE
*b
, int carry
)
310 for (i
= 0; i
< SIGSZ
; ++i
)
312 unsigned long ai
= a
->sig
[i
];
313 unsigned long ri
= ai
- b
->sig
[i
];
329 /* Negate the significand A, placing the result in R. */
332 neg_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
337 for (i
= 0; i
< SIGSZ
; ++i
)
339 unsigned long ri
, ai
= a
->sig
[i
];
358 /* Compare significands. Return tri-state vs zero. */
361 cmp_significands (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
365 for (i
= SIGSZ
- 1; i
>= 0; --i
)
367 unsigned long ai
= a
->sig
[i
];
368 unsigned long bi
= b
->sig
[i
];
379 /* Return true if A is nonzero. */
382 cmp_significand_0 (const REAL_VALUE_TYPE
*a
)
386 for (i
= SIGSZ
- 1; i
>= 0; --i
)
393 /* Set bit N of the significand of R. */
396 set_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
398 r
->sig
[n
/ HOST_BITS_PER_LONG
]
399 |= (unsigned long)1 << (n
% HOST_BITS_PER_LONG
);
402 /* Clear bit N of the significand of R. */
405 clear_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
407 r
->sig
[n
/ HOST_BITS_PER_LONG
]
408 &= ~((unsigned long)1 << (n
% HOST_BITS_PER_LONG
));
411 /* Test bit N of the significand of R. */
414 test_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
416 /* ??? Compiler bug here if we return this expression directly.
417 The conversion to bool strips the "&1" and we wind up testing
418 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
419 int t
= (r
->sig
[n
/ HOST_BITS_PER_LONG
] >> (n
% HOST_BITS_PER_LONG
)) & 1;
423 /* Clear bits 0..N-1 of the significand of R. */
426 clear_significand_below (REAL_VALUE_TYPE
*r
, unsigned int n
)
428 int i
, w
= n
/ HOST_BITS_PER_LONG
;
430 for (i
= 0; i
< w
; ++i
)
433 /* We are actually passing N == SIGNIFICAND_BITS which would result
434 in an out-of-bound access below. */
435 if (n
% HOST_BITS_PER_LONG
!= 0)
436 r
->sig
[w
] &= ~(((unsigned long)1 << (n
% HOST_BITS_PER_LONG
)) - 1);
439 /* Divide the significands of A and B, placing the result in R. Return
440 true if the division was inexact. */
443 div_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
444 const REAL_VALUE_TYPE
*b
)
447 int i
, bit
= SIGNIFICAND_BITS
- 1;
448 unsigned long msb
, inexact
;
451 memset (r
->sig
, 0, sizeof (r
->sig
));
457 msb
= u
.sig
[SIGSZ
-1] & SIG_MSB
;
458 lshift_significand_1 (&u
, &u
);
460 if (msb
|| cmp_significands (&u
, b
) >= 0)
462 sub_significands (&u
, &u
, b
, 0);
463 set_significand_bit (r
, bit
);
468 for (i
= 0, inexact
= 0; i
< SIGSZ
; i
++)
474 /* Adjust the exponent and significand of R such that the most
475 significant bit is set. We underflow to zero and overflow to
476 infinity here, without denormals. (The intermediate representation
477 exponent is large enough to handle target denormals normalized.) */
480 normalize (REAL_VALUE_TYPE
*r
)
488 /* Find the first word that is nonzero. */
489 for (i
= SIGSZ
- 1; i
>= 0; i
--)
491 shift
+= HOST_BITS_PER_LONG
;
495 /* Zero significand flushes to zero. */
503 /* Find the first bit that is nonzero. */
505 if (r
->sig
[i
] & ((unsigned long)1 << (HOST_BITS_PER_LONG
- 1 - j
)))
511 exp
= REAL_EXP (r
) - shift
;
513 get_inf (r
, r
->sign
);
514 else if (exp
< -MAX_EXP
)
515 get_zero (r
, r
->sign
);
518 SET_REAL_EXP (r
, exp
);
519 lshift_significand (r
, r
, shift
);
524 /* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the
525 result may be inexact due to a loss of precision. */
528 do_add (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
529 const REAL_VALUE_TYPE
*b
, int subtract_p
)
533 bool inexact
= false;
535 /* Determine if we need to add or subtract. */
537 subtract_p
= (sign
^ b
->sign
) ^ subtract_p
;
539 switch (CLASS2 (a
->cl
, b
->cl
))
541 case CLASS2 (rvc_zero
, rvc_zero
):
542 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
543 get_zero (r
, sign
& !subtract_p
);
546 case CLASS2 (rvc_zero
, rvc_normal
):
547 case CLASS2 (rvc_zero
, rvc_inf
):
548 case CLASS2 (rvc_zero
, rvc_nan
):
550 case CLASS2 (rvc_normal
, rvc_nan
):
551 case CLASS2 (rvc_inf
, rvc_nan
):
552 case CLASS2 (rvc_nan
, rvc_nan
):
553 /* ANY + NaN = NaN. */
554 case CLASS2 (rvc_normal
, rvc_inf
):
557 /* Make resulting NaN value to be qNaN. The caller has the
558 responsibility to avoid the operation if flag_signaling_nans
561 r
->sign
= sign
^ subtract_p
;
564 case CLASS2 (rvc_normal
, rvc_zero
):
565 case CLASS2 (rvc_inf
, rvc_zero
):
566 case CLASS2 (rvc_nan
, rvc_zero
):
568 case CLASS2 (rvc_nan
, rvc_normal
):
569 case CLASS2 (rvc_nan
, rvc_inf
):
570 /* NaN + ANY = NaN. */
571 case CLASS2 (rvc_inf
, rvc_normal
):
574 /* Make resulting NaN value to be qNaN. The caller has the
575 responsibility to avoid the operation if flag_signaling_nans
580 case CLASS2 (rvc_inf
, rvc_inf
):
582 /* Inf - Inf = NaN. */
583 get_canonical_qnan (r
, 0);
585 /* Inf + Inf = Inf. */
589 case CLASS2 (rvc_normal
, rvc_normal
):
596 /* Swap the arguments such that A has the larger exponent. */
597 dexp
= REAL_EXP (a
) - REAL_EXP (b
);
600 const REAL_VALUE_TYPE
*t
;
607 /* If the exponents are not identical, we need to shift the
608 significand of B down. */
611 /* If the exponents are too far apart, the significands
612 do not overlap, which makes the subtraction a noop. */
613 if (dexp
>= SIGNIFICAND_BITS
)
620 inexact
|= sticky_rshift_significand (&t
, b
, dexp
);
626 if (sub_significands (r
, a
, b
, inexact
))
628 /* We got a borrow out of the subtraction. That means that
629 A and B had the same exponent, and B had the larger
630 significand. We need to swap the sign and negate the
633 neg_significand (r
, r
);
638 if (add_significands (r
, a
, b
))
640 /* We got carry out of the addition. This means we need to
641 shift the significand back down one bit and increase the
643 inexact
|= sticky_rshift_significand (r
, r
, 1);
644 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
655 SET_REAL_EXP (r
, exp
);
656 /* Zero out the remaining fields. */
661 /* Re-normalize the result. */
664 /* Special case: if the subtraction results in zero, the result
666 if (r
->cl
== rvc_zero
)
669 r
->sig
[0] |= inexact
;
674 /* Calculate R = A * B. Return true if the result may be inexact. */
677 do_multiply (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
678 const REAL_VALUE_TYPE
*b
)
680 REAL_VALUE_TYPE u
, t
, *rr
;
681 unsigned int i
, j
, k
;
682 int sign
= a
->sign
^ b
->sign
;
683 bool inexact
= false;
685 switch (CLASS2 (a
->cl
, b
->cl
))
687 case CLASS2 (rvc_zero
, rvc_zero
):
688 case CLASS2 (rvc_zero
, rvc_normal
):
689 case CLASS2 (rvc_normal
, rvc_zero
):
690 /* +-0 * ANY = 0 with appropriate sign. */
694 case CLASS2 (rvc_zero
, rvc_nan
):
695 case CLASS2 (rvc_normal
, rvc_nan
):
696 case CLASS2 (rvc_inf
, rvc_nan
):
697 case CLASS2 (rvc_nan
, rvc_nan
):
698 /* ANY * NaN = NaN. */
700 /* Make resulting NaN value to be qNaN. The caller has the
701 responsibility to avoid the operation if flag_signaling_nans
707 case CLASS2 (rvc_nan
, rvc_zero
):
708 case CLASS2 (rvc_nan
, rvc_normal
):
709 case CLASS2 (rvc_nan
, rvc_inf
):
710 /* NaN * ANY = NaN. */
712 /* Make resulting NaN value to be qNaN. The caller has the
713 responsibility to avoid the operation if flag_signaling_nans
719 case CLASS2 (rvc_zero
, rvc_inf
):
720 case CLASS2 (rvc_inf
, rvc_zero
):
722 get_canonical_qnan (r
, sign
);
725 case CLASS2 (rvc_inf
, rvc_inf
):
726 case CLASS2 (rvc_normal
, rvc_inf
):
727 case CLASS2 (rvc_inf
, rvc_normal
):
728 /* Inf * Inf = Inf, R * Inf = Inf */
732 case CLASS2 (rvc_normal
, rvc_normal
):
739 if (r
== a
|| r
== b
)
745 /* Collect all the partial products. Since we don't have sure access
746 to a widening multiply, we split each long into two half-words.
748 Consider the long-hand form of a four half-word multiplication:
758 We construct partial products of the widened half-word products
759 that are known to not overlap, e.g. DF+DH. Each such partial
760 product is given its proper exponent, which allows us to sum them
761 and obtain the finished product. */
763 for (i
= 0; i
< SIGSZ
* 2; ++i
)
765 unsigned long ai
= a
->sig
[i
/ 2];
767 ai
>>= HOST_BITS_PER_LONG
/ 2;
769 ai
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
774 for (j
= 0; j
< 2; ++j
)
776 int exp
= (REAL_EXP (a
) - (2*SIGSZ
-1-i
)*(HOST_BITS_PER_LONG
/2)
777 + (REAL_EXP (b
) - (1-j
)*(HOST_BITS_PER_LONG
/2)));
786 /* Would underflow to zero, which we shouldn't bother adding. */
791 memset (&u
, 0, sizeof (u
));
793 SET_REAL_EXP (&u
, exp
);
795 for (k
= j
; k
< SIGSZ
* 2; k
+= 2)
797 unsigned long bi
= b
->sig
[k
/ 2];
799 bi
>>= HOST_BITS_PER_LONG
/ 2;
801 bi
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
803 u
.sig
[k
/ 2] = ai
* bi
;
807 inexact
|= do_add (rr
, rr
, &u
, 0);
818 /* Calculate R = A / B. Return true if the result may be inexact. */
821 do_divide (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
822 const REAL_VALUE_TYPE
*b
)
824 int exp
, sign
= a
->sign
^ b
->sign
;
825 REAL_VALUE_TYPE t
, *rr
;
828 switch (CLASS2 (a
->cl
, b
->cl
))
830 case CLASS2 (rvc_zero
, rvc_zero
):
832 case CLASS2 (rvc_inf
, rvc_inf
):
833 /* Inf / Inf = NaN. */
834 get_canonical_qnan (r
, sign
);
837 case CLASS2 (rvc_zero
, rvc_normal
):
838 case CLASS2 (rvc_zero
, rvc_inf
):
840 case CLASS2 (rvc_normal
, rvc_inf
):
845 case CLASS2 (rvc_normal
, rvc_zero
):
847 case CLASS2 (rvc_inf
, rvc_zero
):
852 case CLASS2 (rvc_zero
, rvc_nan
):
853 case CLASS2 (rvc_normal
, rvc_nan
):
854 case CLASS2 (rvc_inf
, rvc_nan
):
855 case CLASS2 (rvc_nan
, rvc_nan
):
856 /* ANY / NaN = NaN. */
858 /* Make resulting NaN value to be qNaN. The caller has the
859 responsibility to avoid the operation if flag_signaling_nans
865 case CLASS2 (rvc_nan
, rvc_zero
):
866 case CLASS2 (rvc_nan
, rvc_normal
):
867 case CLASS2 (rvc_nan
, rvc_inf
):
868 /* NaN / ANY = NaN. */
870 /* Make resulting NaN value to be qNaN. The caller has the
871 responsibility to avoid the operation if flag_signaling_nans
877 case CLASS2 (rvc_inf
, rvc_normal
):
882 case CLASS2 (rvc_normal
, rvc_normal
):
889 if (r
== a
|| r
== b
)
894 /* Make sure all fields in the result are initialized. */
899 exp
= REAL_EXP (a
) - REAL_EXP (b
) + 1;
910 SET_REAL_EXP (rr
, exp
);
912 inexact
= div_significands (rr
, a
, b
);
914 /* Re-normalize the result. */
916 rr
->sig
[0] |= inexact
;
924 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
925 one of the two operands is a NaN. */
928 do_compare (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
,
933 switch (CLASS2 (a
->cl
, b
->cl
))
935 case CLASS2 (rvc_zero
, rvc_zero
):
936 /* Sign of zero doesn't matter for compares. */
939 case CLASS2 (rvc_normal
, rvc_zero
):
940 /* Decimal float zero is special and uses rvc_normal, not rvc_zero. */
942 return decimal_do_compare (a
, b
, nan_result
);
944 case CLASS2 (rvc_inf
, rvc_zero
):
945 case CLASS2 (rvc_inf
, rvc_normal
):
946 return (a
->sign
? -1 : 1);
948 case CLASS2 (rvc_inf
, rvc_inf
):
949 return -a
->sign
- -b
->sign
;
951 case CLASS2 (rvc_zero
, rvc_normal
):
952 /* Decimal float zero is special and uses rvc_normal, not rvc_zero. */
954 return decimal_do_compare (a
, b
, nan_result
);
956 case CLASS2 (rvc_zero
, rvc_inf
):
957 case CLASS2 (rvc_normal
, rvc_inf
):
958 return (b
->sign
? 1 : -1);
960 case CLASS2 (rvc_zero
, rvc_nan
):
961 case CLASS2 (rvc_normal
, rvc_nan
):
962 case CLASS2 (rvc_inf
, rvc_nan
):
963 case CLASS2 (rvc_nan
, rvc_nan
):
964 case CLASS2 (rvc_nan
, rvc_zero
):
965 case CLASS2 (rvc_nan
, rvc_normal
):
966 case CLASS2 (rvc_nan
, rvc_inf
):
969 case CLASS2 (rvc_normal
, rvc_normal
):
976 if (a
->decimal
|| b
->decimal
)
977 return decimal_do_compare (a
, b
, nan_result
);
979 if (a
->sign
!= b
->sign
)
980 return -a
->sign
- -b
->sign
;
982 if (REAL_EXP (a
) > REAL_EXP (b
))
984 else if (REAL_EXP (a
) < REAL_EXP (b
))
987 ret
= cmp_significands (a
, b
);
989 return (a
->sign
? -ret
: ret
);
992 /* Return A truncated to an integral value toward zero. */
995 do_fix_trunc (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
1004 /* Make resulting NaN value to be qNaN. The caller has the
1005 responsibility to avoid the operation if flag_signaling_nans
1013 decimal_do_fix_trunc (r
, a
);
1016 if (REAL_EXP (r
) <= 0)
1017 get_zero (r
, r
->sign
);
1018 else if (REAL_EXP (r
) < SIGNIFICAND_BITS
)
1019 clear_significand_below (r
, SIGNIFICAND_BITS
- REAL_EXP (r
));
1027 /* Perform the binary or unary operation described by CODE.
1028 For a unary operation, leave OP1 NULL. This function returns
1029 true if the result may be inexact due to loss of precision. */
1032 real_arithmetic (REAL_VALUE_TYPE
*r
, int icode
, const REAL_VALUE_TYPE
*op0
,
1033 const REAL_VALUE_TYPE
*op1
)
1035 enum tree_code code
= (enum tree_code
) icode
;
1037 if (op0
->decimal
|| (op1
&& op1
->decimal
))
1038 return decimal_real_arithmetic (r
, code
, op0
, op1
);
1043 /* Clear any padding areas in *r if it isn't equal to one of the
1044 operands so that we can later do bitwise comparisons later on. */
1045 if (r
!= op0
&& r
!= op1
)
1046 memset (r
, '\0', sizeof (*r
));
1047 return do_add (r
, op0
, op1
, 0);
1050 if (r
!= op0
&& r
!= op1
)
1051 memset (r
, '\0', sizeof (*r
));
1052 return do_add (r
, op0
, op1
, 1);
1055 if (r
!= op0
&& r
!= op1
)
1056 memset (r
, '\0', sizeof (*r
));
1057 return do_multiply (r
, op0
, op1
);
1060 if (r
!= op0
&& r
!= op1
)
1061 memset (r
, '\0', sizeof (*r
));
1062 return do_divide (r
, op0
, op1
);
1065 if (op1
->cl
== rvc_nan
)
1068 /* Make resulting NaN value to be qNaN. The caller has the
1069 responsibility to avoid the operation if flag_signaling_nans
1073 else if (do_compare (op0
, op1
, -1) < 0)
1080 if (op1
->cl
== rvc_nan
)
1083 /* Make resulting NaN value to be qNaN. The caller has the
1084 responsibility to avoid the operation if flag_signaling_nans
1088 else if (do_compare (op0
, op1
, 1) < 0)
1104 case FIX_TRUNC_EXPR
:
1105 do_fix_trunc (r
, op0
);
1115 real_value_negate (const REAL_VALUE_TYPE
*op0
)
1118 real_arithmetic (&r
, NEGATE_EXPR
, op0
, NULL
);
1123 real_value_abs (const REAL_VALUE_TYPE
*op0
)
1126 real_arithmetic (&r
, ABS_EXPR
, op0
, NULL
);
1130 /* Return whether OP0 == OP1. */
1133 real_equal (const REAL_VALUE_TYPE
*op0
, const REAL_VALUE_TYPE
*op1
)
1135 return do_compare (op0
, op1
, -1) == 0;
1138 /* Return whether OP0 < OP1. */
1141 real_less (const REAL_VALUE_TYPE
*op0
, const REAL_VALUE_TYPE
*op1
)
1143 return do_compare (op0
, op1
, 1) < 0;
1147 real_compare (int icode
, const REAL_VALUE_TYPE
*op0
,
1148 const REAL_VALUE_TYPE
*op1
)
1150 enum tree_code code
= (enum tree_code
) icode
;
1155 return real_less (op0
, op1
);
1157 return do_compare (op0
, op1
, 1) <= 0;
1159 return do_compare (op0
, op1
, -1) > 0;
1161 return do_compare (op0
, op1
, -1) >= 0;
1163 return real_equal (op0
, op1
);
1165 return do_compare (op0
, op1
, -1) != 0;
1166 case UNORDERED_EXPR
:
1167 return op0
->cl
== rvc_nan
|| op1
->cl
== rvc_nan
;
1169 return op0
->cl
!= rvc_nan
&& op1
->cl
!= rvc_nan
;
1171 return do_compare (op0
, op1
, -1) < 0;
1173 return do_compare (op0
, op1
, -1) <= 0;
1175 return do_compare (op0
, op1
, 1) > 0;
1177 return do_compare (op0
, op1
, 1) >= 0;
1179 return do_compare (op0
, op1
, 0) == 0;
1181 return do_compare (op0
, op1
, 0) != 0;
1188 /* Return floor log2(R). */
1191 real_exponent (const REAL_VALUE_TYPE
*r
)
1199 return (unsigned int)-1 >> 1;
1201 return REAL_EXP (r
);
1207 /* R = OP0 * 2**EXP. */
1210 real_ldexp (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*op0
, int exp
)
1218 /* Make resulting NaN value to be qNaN. The caller has the
1219 responsibility to avoid the operation if flag_signaling_nans
1225 exp
+= REAL_EXP (op0
);
1227 get_inf (r
, r
->sign
);
1228 else if (exp
< -MAX_EXP
)
1229 get_zero (r
, r
->sign
);
1231 SET_REAL_EXP (r
, exp
);
1239 /* Determine whether a floating-point value X is infinite. */
1242 real_isinf (const REAL_VALUE_TYPE
*r
)
1244 return (r
->cl
== rvc_inf
);
1247 /* Determine whether a floating-point value X is infinite with SIGN. */
1250 real_isinf (const REAL_VALUE_TYPE
*r
, bool sign
)
1252 return real_isinf (r
) && r
->sign
== sign
;
1255 /* Determine whether a floating-point value X is a NaN. */
1258 real_isnan (const REAL_VALUE_TYPE
*r
)
1260 return (r
->cl
== rvc_nan
);
1263 /* Determine whether a floating-point value X is a signaling NaN. */
1264 bool real_issignaling_nan (const REAL_VALUE_TYPE
*r
)
1266 return real_isnan (r
) && r
->signalling
;
1269 /* Determine whether a floating-point value X is finite. */
1272 real_isfinite (const REAL_VALUE_TYPE
*r
)
1274 return (r
->cl
!= rvc_nan
) && (r
->cl
!= rvc_inf
);
1277 /* Determine whether a floating-point value X is negative. */
1280 real_isneg (const REAL_VALUE_TYPE
*r
)
1285 /* Determine whether a floating-point value X is plus or minus zero. */
1288 real_iszero (const REAL_VALUE_TYPE
*r
)
1290 return r
->cl
== rvc_zero
;
1293 /* Determine whether a floating-point value X is zero with SIGN. */
1296 real_iszero (const REAL_VALUE_TYPE
*r
, bool sign
)
1298 return real_iszero (r
) && r
->sign
== sign
;
1301 /* Determine whether a floating-point value X is minus zero. */
1304 real_isnegzero (const REAL_VALUE_TYPE
*r
)
1306 return r
->sign
&& r
->cl
== rvc_zero
;
1309 /* Compare two floating-point objects for bitwise identity. */
1312 real_identical (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
1318 if (a
->sign
!= b
->sign
)
1328 if (a
->decimal
!= b
->decimal
)
1330 if (REAL_EXP (a
) != REAL_EXP (b
))
1335 if (a
->signalling
!= b
->signalling
)
1337 /* The significand is ignored for canonical NaNs. */
1338 if (a
->canonical
|| b
->canonical
)
1339 return a
->canonical
== b
->canonical
;
1346 for (i
= 0; i
< SIGSZ
; ++i
)
1347 if (a
->sig
[i
] != b
->sig
[i
])
1353 /* Try to change R into its exact multiplicative inverse in format FMT.
1354 Return true if successful. */
1357 exact_real_inverse (format_helper fmt
, REAL_VALUE_TYPE
*r
)
1359 const REAL_VALUE_TYPE
*one
= real_digit (1);
1363 if (r
->cl
!= rvc_normal
)
1366 /* Check for a power of two: all significand bits zero except the MSB. */
1367 for (i
= 0; i
< SIGSZ
-1; ++i
)
1370 if (r
->sig
[SIGSZ
-1] != SIG_MSB
)
1373 /* Find the inverse and truncate to the required format. */
1374 do_divide (&u
, one
, r
);
1375 real_convert (&u
, fmt
, &u
);
1377 /* The rounding may have overflowed. */
1378 if (u
.cl
!= rvc_normal
)
1380 for (i
= 0; i
< SIGSZ
-1; ++i
)
1383 if (u
.sig
[SIGSZ
-1] != SIG_MSB
)
1390 /* Return true if arithmetic on values in IMODE that were promoted
1391 from values in TMODE is equivalent to direct arithmetic on values
1395 real_can_shorten_arithmetic (machine_mode imode
, machine_mode tmode
)
1397 const struct real_format
*tfmt
, *ifmt
;
1398 tfmt
= REAL_MODE_FORMAT (tmode
);
1399 ifmt
= REAL_MODE_FORMAT (imode
);
1400 /* These conditions are conservative rather than trying to catch the
1401 exact boundary conditions; the main case to allow is IEEE float
1403 return (ifmt
->b
== tfmt
->b
1404 && ifmt
->p
> 2 * tfmt
->p
1405 && ifmt
->emin
< 2 * tfmt
->emin
- tfmt
->p
- 2
1406 && ifmt
->emin
< tfmt
->emin
- tfmt
->emax
- tfmt
->p
- 2
1407 && ifmt
->emax
> 2 * tfmt
->emax
+ 2
1408 && ifmt
->emax
> tfmt
->emax
- tfmt
->emin
+ tfmt
->p
+ 2
1409 && ifmt
->round_towards_zero
== tfmt
->round_towards_zero
1410 && (ifmt
->has_sign_dependent_rounding
1411 == tfmt
->has_sign_dependent_rounding
)
1412 && ifmt
->has_nans
>= tfmt
->has_nans
1413 && ifmt
->has_inf
>= tfmt
->has_inf
1414 && ifmt
->has_signed_zero
>= tfmt
->has_signed_zero
1415 && !MODE_COMPOSITE_P (tmode
)
1416 && !MODE_COMPOSITE_P (imode
));
1419 /* Render R as an integer. */
1422 real_to_integer (const REAL_VALUE_TYPE
*r
)
1424 unsigned HOST_WIDE_INT i
;
1435 i
= HOST_WIDE_INT_1U
<< (HOST_BITS_PER_WIDE_INT
- 1);
1442 return decimal_real_to_integer (r
);
1444 if (REAL_EXP (r
) <= 0)
1446 /* Only force overflow for unsigned overflow. Signed overflow is
1447 undefined, so it doesn't matter what we return, and some callers
1448 expect to be able to use this routine for both signed and
1449 unsigned conversions. */
1450 if (REAL_EXP (r
) > HOST_BITS_PER_WIDE_INT
)
1453 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1454 i
= r
->sig
[SIGSZ
-1];
1457 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2 * HOST_BITS_PER_LONG
);
1458 i
= r
->sig
[SIGSZ
-1];
1459 i
= i
<< (HOST_BITS_PER_LONG
- 1) << 1;
1460 i
|= r
->sig
[SIGSZ
-2];
1463 i
>>= HOST_BITS_PER_WIDE_INT
- REAL_EXP (r
);
1474 /* Likewise, but producing a wide-int of PRECISION. If the value cannot
1475 be represented in precision, *FAIL is set to TRUE. */
1478 real_to_integer (const REAL_VALUE_TYPE
*r
, bool *fail
, int precision
)
1480 HOST_WIDE_INT val
[2 * WIDE_INT_MAX_ELTS
];
1489 return wi::zero (precision
);
1497 return wi::set_bit_in_zero (precision
- 1, precision
);
1499 return ~wi::set_bit_in_zero (precision
- 1, precision
);
1503 return decimal_real_to_integer (r
, fail
, precision
);
1508 /* Only force overflow for unsigned overflow. Signed overflow is
1509 undefined, so it doesn't matter what we return, and some callers
1510 expect to be able to use this routine for both signed and
1511 unsigned conversions. */
1512 if (exp
> precision
)
1515 /* Put the significand into a wide_int that has precision W, which
1516 is the smallest HWI-multiple that has at least PRECISION bits.
1517 This ensures that the top bit of the significand is in the
1518 top bit of the wide_int. */
1519 words
= (precision
+ HOST_BITS_PER_WIDE_INT
- 1) / HOST_BITS_PER_WIDE_INT
;
1520 w
= words
* HOST_BITS_PER_WIDE_INT
;
1522 #if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1523 for (int i
= 0; i
< words
; i
++)
1525 int j
= SIGSZ
- words
+ i
;
1526 val
[i
] = (j
< 0) ? 0 : r
->sig
[j
];
1529 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2 * HOST_BITS_PER_LONG
);
1530 for (int i
= 0; i
< words
; i
++)
1532 int j
= SIGSZ
- (words
* 2) + (i
* 2);
1539 val
[i
] |= (unsigned HOST_WIDE_INT
) r
->sig
[j
] << HOST_BITS_PER_LONG
;
1542 /* Shift the value into place and truncate to the desired precision. */
1543 result
= wide_int::from_array (val
, words
, w
);
1544 result
= wi::lrshift (result
, w
- exp
);
1545 result
= wide_int::from (result
, precision
, UNSIGNED
);
1557 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1558 of NUM / DEN. Return the quotient and place the remainder in NUM.
1559 It is expected that NUM / DEN are close enough that the quotient is
1562 static unsigned long
1563 rtd_divmod (REAL_VALUE_TYPE
*num
, REAL_VALUE_TYPE
*den
)
1565 unsigned long q
, msb
;
1566 int expn
= REAL_EXP (num
), expd
= REAL_EXP (den
);
1575 msb
= num
->sig
[SIGSZ
-1] & SIG_MSB
;
1577 lshift_significand_1 (num
, num
);
1579 if (msb
|| cmp_significands (num
, den
) >= 0)
1581 sub_significands (num
, num
, den
, 0);
1585 while (--expn
>= expd
);
1587 SET_REAL_EXP (num
, expd
);
1593 /* Render R as a decimal floating point constant. Emit DIGITS significant
1594 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1595 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1596 zeros. If MODE is VOIDmode, round to nearest value. Otherwise, round
1597 to a string that, when parsed back in mode MODE, yields the same value. */
1599 #define M_LOG10_2 0.30102999566398119521
1602 real_to_decimal_for_mode (char *str
, const REAL_VALUE_TYPE
*r_orig
,
1603 size_t buf_size
, size_t digits
,
1604 int crop_trailing_zeros
, machine_mode mode
)
1606 const struct real_format
*fmt
= NULL
;
1607 const REAL_VALUE_TYPE
*one
, *ten
;
1608 REAL_VALUE_TYPE r
, pten
, u
, v
;
1609 int dec_exp
, cmp_one
, digit
;
1611 char *p
, *first
, *last
;
1615 if (mode
!= VOIDmode
)
1617 fmt
= REAL_MODE_FORMAT (mode
);
1625 strcpy (str
, (r
.sign
? "-0.0" : "0.0"));
1630 strcpy (str
, (r
.sign
? "-Inf" : "+Inf"));
1633 /* ??? Print the significand as well, if not canonical? */
1634 sprintf (str
, "%c%cNaN", (r_orig
->sign
? '-' : '+'),
1635 (r_orig
->signalling
? 'S' : 'Q'));
1643 decimal_real_to_decimal (str
, &r
, buf_size
, digits
, crop_trailing_zeros
);
1647 /* Bound the number of digits printed by the size of the representation. */
1648 max_digits
= SIGNIFICAND_BITS
* M_LOG10_2
;
1649 if (digits
== 0 || digits
> max_digits
)
1650 digits
= max_digits
;
1652 /* Estimate the decimal exponent, and compute the length of the string it
1653 will print as. Be conservative and add one to account for possible
1654 overflow or rounding error. */
1655 dec_exp
= REAL_EXP (&r
) * M_LOG10_2
;
1656 for (max_digits
= 1; dec_exp
; max_digits
++)
1659 /* Bound the number of digits printed by the size of the output buffer. */
1660 max_digits
= buf_size
- 1 - 1 - 2 - max_digits
- 1;
1661 gcc_assert (max_digits
<= buf_size
);
1662 if (digits
> max_digits
)
1663 digits
= max_digits
;
1665 one
= real_digit (1);
1666 ten
= ten_to_ptwo (0);
1674 cmp_one
= do_compare (&r
, one
, 0);
1679 /* Number is greater than one. Convert significand to an integer
1680 and strip trailing decimal zeros. */
1683 SET_REAL_EXP (&u
, SIGNIFICAND_BITS
- 1);
1685 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1686 m
= floor_log2 (max_digits
);
1688 /* Iterate over the bits of the possible powers of 10 that might
1689 be present in U and eliminate them. That is, if we find that
1690 10**2**M divides U evenly, keep the division and increase
1696 do_divide (&t
, &u
, ten_to_ptwo (m
));
1697 do_fix_trunc (&v
, &t
);
1698 if (cmp_significands (&v
, &t
) == 0)
1706 /* Revert the scaling to integer that we performed earlier. */
1707 SET_REAL_EXP (&u
, REAL_EXP (&u
) + REAL_EXP (&r
)
1708 - (SIGNIFICAND_BITS
- 1));
1711 /* Find power of 10. Do this by dividing out 10**2**M when
1712 this is larger than the current remainder. Fill PTEN with
1713 the power of 10 that we compute. */
1714 if (REAL_EXP (&r
) > 0)
1716 m
= floor_log2 ((int)(REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1719 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1720 if (do_compare (&u
, ptentwo
, 0) >= 0)
1722 do_divide (&u
, &u
, ptentwo
);
1723 do_multiply (&pten
, &pten
, ptentwo
);
1730 /* We managed to divide off enough tens in the above reduction
1731 loop that we've now got a negative exponent. Fall into the
1732 less-than-one code to compute the proper value for PTEN. */
1739 /* Number is less than one. Pad significand with leading
1745 /* Stop if we'd shift bits off the bottom. */
1749 do_multiply (&u
, &v
, ten
);
1751 /* Stop if we're now >= 1 or zero. */
1752 if (REAL_EXP (&u
) > 0 || u
.cl
== rvc_zero
)
1760 /* Find power of 10. Do this by multiplying in P=10**2**M when
1761 the current remainder is smaller than 1/P. Fill PTEN with the
1762 power of 10 that we compute. */
1763 m
= floor_log2 ((int)(-REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1766 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1767 const REAL_VALUE_TYPE
*ptenmtwo
= ten_to_mptwo (m
);
1769 if (do_compare (&v
, ptenmtwo
, 0) <= 0)
1771 do_multiply (&v
, &v
, ptentwo
);
1772 do_multiply (&pten
, &pten
, ptentwo
);
1778 /* Invert the positive power of 10 that we've collected so far. */
1779 do_divide (&pten
, one
, &pten
);
1787 /* At this point, PTEN should contain the nearest power of 10 smaller
1788 than R, such that this division produces the first digit.
1790 Using a divide-step primitive that returns the complete integral
1791 remainder avoids the rounding error that would be produced if
1792 we were to use do_divide here and then simply multiply by 10 for
1793 each subsequent digit. */
1795 digit
= rtd_divmod (&r
, &pten
);
1797 /* Be prepared for error in that division via underflow ... */
1798 if (digit
== 0 && cmp_significand_0 (&r
))
1800 /* Multiply by 10 and try again. */
1801 do_multiply (&r
, &r
, ten
);
1802 digit
= rtd_divmod (&r
, &pten
);
1804 gcc_assert (digit
!= 0);
1807 /* ... or overflow. */
1817 gcc_assert (digit
<= 10);
1821 /* Generate subsequent digits. */
1822 while (--digits
> 0)
1824 do_multiply (&r
, &r
, ten
);
1825 digit
= rtd_divmod (&r
, &pten
);
1830 /* Generate one more digit with which to do rounding. */
1831 do_multiply (&r
, &r
, ten
);
1832 digit
= rtd_divmod (&r
, &pten
);
1834 /* Round the result. */
1835 if (fmt
&& fmt
->round_towards_zero
)
1837 /* If the format uses round towards zero when parsing the string
1838 back in, we need to always round away from zero here. */
1839 if (cmp_significand_0 (&r
))
1841 round_up
= digit
> 0;
1847 /* Round to nearest. If R is nonzero there are additional
1848 nonzero digits to be extracted. */
1849 if (cmp_significand_0 (&r
))
1851 /* Round to even. */
1852 else if ((p
[-1] - '0') & 1)
1856 round_up
= digit
> 5;
1873 /* Carry out of the first digit. This means we had all 9's and
1874 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1882 /* Insert the decimal point. */
1883 first
[0] = first
[1];
1886 /* If requested, drop trailing zeros. Never crop past "1.0". */
1887 if (crop_trailing_zeros
)
1888 while (last
> first
+ 3 && last
[-1] == '0')
1891 /* Append the exponent. */
1892 sprintf (last
, "e%+d", dec_exp
);
1894 /* Verify that we can read the original value back in. */
1895 if (flag_checking
&& mode
!= VOIDmode
)
1897 real_from_string (&r
, str
);
1898 real_convert (&r
, mode
, &r
);
1899 gcc_assert (real_identical (&r
, r_orig
));
1903 /* Likewise, except always uses round-to-nearest. */
1906 real_to_decimal (char *str
, const REAL_VALUE_TYPE
*r_orig
, size_t buf_size
,
1907 size_t digits
, int crop_trailing_zeros
)
1909 real_to_decimal_for_mode (str
, r_orig
, buf_size
,
1910 digits
, crop_trailing_zeros
, VOIDmode
);
1914 debug (const REAL_VALUE_TYPE
&r
)
1917 real_to_hexadecimal (s
, &r
, sizeof (s
), 0, 1);
1918 fprintf (stderr
, "%s\n", s
);
1921 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1922 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1923 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1924 strip trailing zeros. */
1927 real_to_hexadecimal (char *str
, const REAL_VALUE_TYPE
*r
, size_t buf_size
,
1928 size_t digits
, int crop_trailing_zeros
)
1930 int i
, j
, exp
= REAL_EXP (r
);
1943 strcpy (str
, (r
->sign
? "-Inf" : "+Inf"));
1946 /* ??? Print the significand as well, if not canonical? */
1947 sprintf (str
, "%c%cNaN", (r
->sign
? '-' : '+'),
1948 (r
->signalling
? 'S' : 'Q'));
1956 /* Hexadecimal format for decimal floats is not interesting. */
1957 strcpy (str
, "N/A");
1962 digits
= SIGNIFICAND_BITS
/ 4;
1964 /* Bound the number of digits printed by the size of the output buffer. */
1966 sprintf (exp_buf
, "p%+d", exp
);
1967 max_digits
= buf_size
- strlen (exp_buf
) - r
->sign
- 4 - 1;
1968 gcc_assert (max_digits
<= buf_size
);
1969 if (digits
> max_digits
)
1970 digits
= max_digits
;
1981 for (i
= SIGSZ
- 1; i
>= 0; --i
)
1982 for (j
= HOST_BITS_PER_LONG
- 4; j
>= 0; j
-= 4)
1984 *p
++ = "0123456789abcdef"[(r
->sig
[i
] >> j
) & 15];
1990 if (crop_trailing_zeros
)
1991 while (p
> first
+ 1 && p
[-1] == '0')
1994 sprintf (p
, "p%+d", exp
);
1997 /* Initialize R from a decimal or hexadecimal string. The string is
1998 assumed to have been syntax checked already. Return -1 if the
1999 value underflows, +1 if overflows, and 0 otherwise. */
2002 real_from_string (REAL_VALUE_TYPE
*r
, const char *str
)
2014 else if (*str
== '+')
2017 if (startswith (str
, "QNaN"))
2019 get_canonical_qnan (r
, sign
);
2022 else if (startswith (str
, "SNaN"))
2024 get_canonical_snan (r
, sign
);
2027 else if (startswith (str
, "Inf"))
2033 if (str
[0] == '0' && (str
[1] == 'x' || str
[1] == 'X'))
2035 /* Hexadecimal floating point. */
2036 int pos
= SIGNIFICAND_BITS
- 4, d
;
2044 d
= hex_value (*str
);
2049 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
2050 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
2054 /* Ensure correct rounding by setting last bit if there is
2055 a subsequent nonzero digit. */
2063 if (pos
== SIGNIFICAND_BITS
- 4)
2070 d
= hex_value (*str
);
2075 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
2076 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
2080 /* Ensure correct rounding by setting last bit if there is
2081 a subsequent nonzero digit. */
2087 /* If the mantissa is zero, ignore the exponent. */
2088 if (!cmp_significand_0 (r
))
2091 if (*str
== 'p' || *str
== 'P')
2093 bool exp_neg
= false;
2101 else if (*str
== '+')
2105 while (ISDIGIT (*str
))
2111 /* Overflowed the exponent. */
2126 SET_REAL_EXP (r
, exp
);
2132 /* Decimal floating point. */
2133 const char *cstr
= str
;
2136 while (*cstr
== '0')
2141 while (*cstr
== '0')
2145 /* If the mantissa is zero, ignore the exponent. */
2146 if (!ISDIGIT (*cstr
))
2149 /* Nonzero value, possibly overflowing or underflowing. */
2150 auto_mpfr
m (SIGNIFICAND_BITS
);
2151 inexact
= mpfr_strtofr (m
, str
, NULL
, 10, MPFR_RNDZ
);
2152 /* The result should never be a NaN, and because the rounding is
2153 toward zero should never be an infinity. */
2154 gcc_assert (!mpfr_nan_p (m
) && !mpfr_inf_p (m
));
2155 if (mpfr_zero_p (m
) || mpfr_get_exp (m
) < -MAX_EXP
+ 4)
2157 else if (mpfr_get_exp (m
) > MAX_EXP
- 4)
2161 real_from_mpfr (r
, m
, NULL_TREE
, MPFR_RNDZ
);
2162 /* 1 to 3 bits may have been shifted off (with a sticky bit)
2163 because the hex digits used in real_from_mpfr did not
2164 start with a digit 8 to f, but the exponent bounds above
2165 should have avoided underflow or overflow. */
2166 gcc_assert (r
->cl
== rvc_normal
);
2167 /* Set a sticky bit if mpfr_strtofr was inexact. */
2168 r
->sig
[0] |= inexact
;
2188 /* Legacy. Similar, but return the result directly. */
2191 real_from_string2 (const char *s
, format_helper fmt
)
2195 real_from_string (&r
, s
);
2197 real_convert (&r
, fmt
, &r
);
2202 /* Initialize R from string S and desired format FMT. */
2205 real_from_string3 (REAL_VALUE_TYPE
*r
, const char *s
, format_helper fmt
)
2207 if (fmt
.decimal_p ())
2208 decimal_real_from_string (r
, s
);
2210 real_from_string (r
, s
);
2213 real_convert (r
, fmt
, r
);
2216 /* Initialize R from the wide_int VAL_IN. Round it to format FMT if
2220 real_from_integer (REAL_VALUE_TYPE
*r
, format_helper fmt
,
2221 const wide_int_ref
&val_in
, signop sgn
)
2227 unsigned int len
= val_in
.get_precision ();
2229 int maxbitlen
= MAX_BITSIZE_MODE_ANY_INT
+ HOST_BITS_PER_WIDE_INT
;
2230 const unsigned int realmax
= (SIGNIFICAND_BITS
/ HOST_BITS_PER_WIDE_INT
2231 * HOST_BITS_PER_WIDE_INT
);
2233 memset (r
, 0, sizeof (*r
));
2235 r
->sign
= wi::neg_p (val_in
, sgn
);
2237 /* We have to ensure we can negate the largest negative number. */
2238 wide_int val
= wide_int::from (val_in
, maxbitlen
, sgn
);
2243 /* Ensure a multiple of HOST_BITS_PER_WIDE_INT, ceiling, as elt
2244 won't work with precisions that are not a multiple of
2245 HOST_BITS_PER_WIDE_INT. */
2246 len
+= HOST_BITS_PER_WIDE_INT
- 1;
2248 /* Ensure we can represent the largest negative number. */
2251 len
= len
/HOST_BITS_PER_WIDE_INT
* HOST_BITS_PER_WIDE_INT
;
2253 /* Cap the size to the size allowed by real.h. */
2256 HOST_WIDE_INT cnt_l_z
;
2257 cnt_l_z
= wi::clz (val
);
2259 if (maxbitlen
- cnt_l_z
> realmax
)
2261 e
= maxbitlen
- cnt_l_z
- realmax
;
2263 /* This value is too large, we must shift it right to
2264 preserve all the bits we can, and then bump the
2265 exponent up by that amount. */
2266 val
= wi::lrshift (val
, e
);
2271 /* Clear out top bits so elt will work with precisions that aren't
2272 a multiple of HOST_BITS_PER_WIDE_INT. */
2273 val
= wide_int::from (val
, len
, sgn
);
2274 len
= len
/ HOST_BITS_PER_WIDE_INT
;
2276 SET_REAL_EXP (r
, len
* HOST_BITS_PER_WIDE_INT
+ e
);
2279 if (HOST_BITS_PER_LONG
== HOST_BITS_PER_WIDE_INT
)
2280 for (i
= len
- 1; i
>= 0; i
--)
2282 r
->sig
[j
--] = val
.elt (i
);
2288 gcc_assert (HOST_BITS_PER_LONG
*2 == HOST_BITS_PER_WIDE_INT
);
2289 for (i
= len
- 1; i
>= 0; i
--)
2291 HOST_WIDE_INT e
= val
.elt (i
);
2292 r
->sig
[j
--] = e
>> (HOST_BITS_PER_LONG
- 1) >> 1;
2304 if (fmt
.decimal_p ())
2305 decimal_from_integer (r
);
2307 real_convert (r
, fmt
, r
);
2310 /* Render R, an integral value, as a floating point constant with no
2311 specified exponent. */
2314 decimal_integer_string (char *str
, const REAL_VALUE_TYPE
*r_orig
,
2317 int dec_exp
, digit
, digits
;
2318 REAL_VALUE_TYPE r
, pten
;
2324 if (r
.cl
== rvc_zero
)
2333 dec_exp
= REAL_EXP (&r
) * M_LOG10_2
;
2334 digits
= dec_exp
+ 1;
2335 gcc_assert ((digits
+ 2) < (int)buf_size
);
2337 pten
= *real_digit (1);
2338 times_pten (&pten
, dec_exp
);
2344 digit
= rtd_divmod (&r
, &pten
);
2345 gcc_assert (digit
>= 0 && digit
<= 9);
2347 while (--digits
> 0)
2350 digit
= rtd_divmod (&r
, &pten
);
2357 /* Convert a real with an integral value to decimal float. */
2360 decimal_from_integer (REAL_VALUE_TYPE
*r
)
2364 decimal_integer_string (str
, r
, sizeof (str
) - 1);
2365 decimal_real_from_string (r
, str
);
2368 /* Returns 10**2**N. */
2370 static const REAL_VALUE_TYPE
*
2373 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2375 gcc_assert (n
>= 0);
2376 gcc_assert (n
< EXP_BITS
);
2378 if (tens
[n
].cl
== rvc_zero
)
2380 if (n
< (HOST_BITS_PER_WIDE_INT
== 64 ? 5 : 4))
2382 HOST_WIDE_INT t
= 10;
2385 for (i
= 0; i
< n
; ++i
)
2388 real_from_integer (&tens
[n
], VOIDmode
, t
, UNSIGNED
);
2392 const REAL_VALUE_TYPE
*t
= ten_to_ptwo (n
- 1);
2393 do_multiply (&tens
[n
], t
, t
);
2400 /* Returns 10**(-2**N). */
2402 static const REAL_VALUE_TYPE
*
2403 ten_to_mptwo (int n
)
2405 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2407 gcc_assert (n
>= 0);
2408 gcc_assert (n
< EXP_BITS
);
2410 if (tens
[n
].cl
== rvc_zero
)
2411 do_divide (&tens
[n
], real_digit (1), ten_to_ptwo (n
));
2418 static const REAL_VALUE_TYPE
*
2421 static REAL_VALUE_TYPE num
[10];
2423 gcc_assert (n
>= 0);
2424 gcc_assert (n
<= 9);
2426 if (n
> 0 && num
[n
].cl
== rvc_zero
)
2427 real_from_integer (&num
[n
], VOIDmode
, n
, UNSIGNED
);
2432 /* Multiply R by 10**EXP. */
2435 times_pten (REAL_VALUE_TYPE
*r
, int exp
)
2437 REAL_VALUE_TYPE pten
, *rr
;
2438 bool negative
= (exp
< 0);
2444 pten
= *real_digit (1);
2450 for (i
= 0; exp
> 0; ++i
, exp
>>= 1)
2452 do_multiply (rr
, rr
, ten_to_ptwo (i
));
2455 do_divide (r
, r
, &pten
);
2458 /* Returns the special REAL_VALUE_TYPE corresponding to 'e'. */
2460 const REAL_VALUE_TYPE
*
2463 static REAL_VALUE_TYPE value
;
2465 /* Initialize mathematical constants for constant folding builtins.
2466 These constants need to be given to at least 160 bits precision. */
2467 if (value
.cl
== rvc_zero
)
2469 auto_mpfr
m (SIGNIFICAND_BITS
);
2470 mpfr_set_ui (m
, 1, MPFR_RNDN
);
2471 mpfr_exp (m
, m
, MPFR_RNDN
);
2472 real_from_mpfr (&value
, m
, NULL_TREE
, MPFR_RNDN
);
2478 /* Returns the special REAL_VALUE_TYPE corresponding to 'pi'. */
2480 const REAL_VALUE_TYPE
*
2481 dconst_pi_ptr (void)
2483 static REAL_VALUE_TYPE value
;
2485 /* Initialize mathematical constants for constant folding builtins.
2486 These constants need to be given to at least 160 bits precision. */
2487 if (value
.cl
== rvc_zero
)
2489 auto_mpfr
m (SIGNIFICAND_BITS
);
2490 mpfr_set_si (m
, -1, MPFR_RNDN
);
2491 mpfr_acos (m
, m
, MPFR_RNDN
);
2492 real_from_mpfr (&value
, m
, NULL_TREE
, MPFR_RNDN
);
2498 /* Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n. */
2500 #define CACHED_FRACTION(NAME, N) \
2501 const REAL_VALUE_TYPE * \
2504 static REAL_VALUE_TYPE value; \
2506 /* Initialize mathematical constants for constant folding builtins. \
2507 These constants need to be given to at least 160 bits \
2509 if (value.cl == rvc_zero) \
2510 real_arithmetic (&value, RDIV_EXPR, &dconst1, real_digit (N)); \
2514 CACHED_FRACTION (dconst_third_ptr
, 3)
2515 CACHED_FRACTION (dconst_quarter_ptr
, 4)
2516 CACHED_FRACTION (dconst_sixth_ptr
, 6)
2517 CACHED_FRACTION (dconst_ninth_ptr
, 9)
2519 /* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2). */
2521 const REAL_VALUE_TYPE
*
2522 dconst_sqrt2_ptr (void)
2524 static REAL_VALUE_TYPE value
;
2526 /* Initialize mathematical constants for constant folding builtins.
2527 These constants need to be given to at least 160 bits precision. */
2528 if (value
.cl
== rvc_zero
)
2530 auto_mpfr
m (SIGNIFICAND_BITS
);
2531 mpfr_sqrt_ui (m
, 2, MPFR_RNDN
);
2532 real_from_mpfr (&value
, m
, NULL_TREE
, MPFR_RNDN
);
2537 /* Fills R with Inf with SIGN. */
2540 real_inf (REAL_VALUE_TYPE
*r
, bool sign
)
2545 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2546 we force a QNaN, else we force an SNaN. The string, if not empty,
2547 is parsed as a number and placed in the significand. Return true
2548 if the string was successfully parsed. */
2551 real_nan (REAL_VALUE_TYPE
*r
, const char *str
, int quiet
,
2557 get_canonical_qnan (r
, 0);
2559 get_canonical_snan (r
, 0);
2565 memset (r
, 0, sizeof (*r
));
2568 /* Parse akin to strtol into the significand of R. */
2570 while (ISSPACE (*str
))
2574 else if (*str
== '+')
2579 if (*str
== 'x' || *str
== 'X')
2588 while ((d
= hex_value (*str
)) < base
)
2595 lshift_significand (r
, r
, 3);
2598 lshift_significand (r
, r
, 4);
2601 lshift_significand_1 (&u
, r
);
2602 lshift_significand (r
, r
, 3);
2603 add_significands (r
, r
, &u
);
2611 add_significands (r
, r
, &u
);
2616 /* Must have consumed the entire string for success. */
2620 /* Shift the significand into place such that the bits
2621 are in the most significant bits for the format. */
2622 lshift_significand (r
, r
, SIGNIFICAND_BITS
- fmt
->pnan
);
2624 /* Our MSB is always unset for NaNs. */
2625 r
->sig
[SIGSZ
-1] &= ~SIG_MSB
;
2627 /* Force quiet or signaling NaN. */
2628 r
->signalling
= !quiet
;
2634 /* Fills R with the largest finite value representable in mode MODE.
2635 If SIGN is nonzero, R is set to the most negative finite value. */
2638 real_maxval (REAL_VALUE_TYPE
*r
, int sign
, machine_mode mode
)
2640 const struct real_format
*fmt
;
2643 fmt
= REAL_MODE_FORMAT (mode
);
2645 memset (r
, 0, sizeof (*r
));
2648 decimal_real_maxval (r
, sign
, mode
);
2653 SET_REAL_EXP (r
, fmt
->emax
);
2655 np2
= SIGNIFICAND_BITS
- fmt
->p
;
2656 memset (r
->sig
, -1, SIGSZ
* sizeof (unsigned long));
2657 clear_significand_below (r
, np2
);
2659 if (fmt
->pnan
< fmt
->p
)
2660 /* This is an IBM extended double format made up of two IEEE
2661 doubles. The value of the long double is the sum of the
2662 values of the two parts. The most significant part is
2663 required to be the value of the long double rounded to the
2664 nearest double. Rounding means we need a slightly smaller
2665 value for LDBL_MAX. */
2666 clear_significand_bit (r
, SIGNIFICAND_BITS
- fmt
->pnan
- 1);
2670 /* Fills R with 2**N. */
2673 real_2expN (REAL_VALUE_TYPE
*r
, int n
, format_helper fmt
)
2675 memset (r
, 0, sizeof (*r
));
2680 else if (n
< -MAX_EXP
)
2685 SET_REAL_EXP (r
, n
);
2686 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2688 if (fmt
.decimal_p ())
2689 decimal_real_convert (r
, fmt
, r
);
2694 round_for_format (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
)
2698 bool round_up
= false;
2704 decimal_round_for_format (fmt
, r
);
2707 /* FIXME. We can come here via fp_easy_constant
2708 (e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
2709 investigated whether this convert needs to be here, or
2710 something else is missing. */
2711 decimal_real_convert (r
, REAL_MODE_FORMAT (DFmode
), r
);
2715 emin2m1
= fmt
->emin
- 1;
2718 np2
= SIGNIFICAND_BITS
- p2
;
2722 get_zero (r
, r
->sign
);
2725 if (!fmt
->has_signed_zero
)
2730 get_inf (r
, r
->sign
);
2735 clear_significand_below (r
, np2
);
2745 /* Check the range of the exponent. If we're out of range,
2746 either underflow or overflow. */
2747 if (REAL_EXP (r
) > emax2
)
2749 else if (REAL_EXP (r
) <= emin2m1
)
2753 if (!fmt
->has_denorm
)
2755 /* Don't underflow completely until we've had a chance to round. */
2756 if (REAL_EXP (r
) < emin2m1
)
2761 diff
= emin2m1
- REAL_EXP (r
) + 1;
2765 /* De-normalize the significand. */
2766 r
->sig
[0] |= sticky_rshift_significand (r
, r
, diff
);
2767 SET_REAL_EXP (r
, REAL_EXP (r
) + diff
);
2771 if (!fmt
->round_towards_zero
)
2773 /* There are P2 true significand bits, followed by one guard bit,
2774 followed by one sticky bit, followed by stuff. Fold nonzero
2775 stuff into the sticky bit. */
2776 unsigned long sticky
;
2780 for (i
= 0, w
= (np2
- 1) / HOST_BITS_PER_LONG
; i
< w
; ++i
)
2781 sticky
|= r
->sig
[i
];
2783 & (((unsigned long)1 << ((np2
- 1) % HOST_BITS_PER_LONG
)) - 1);
2785 guard
= test_significand_bit (r
, np2
- 1);
2786 lsb
= test_significand_bit (r
, np2
);
2788 /* Round to even. */
2789 round_up
= guard
&& (sticky
|| lsb
);
2796 set_significand_bit (&u
, np2
);
2798 if (add_significands (r
, r
, &u
))
2800 /* Overflow. Means the significand had been all ones, and
2801 is now all zeros. Need to increase the exponent, and
2802 possibly re-normalize it. */
2803 SET_REAL_EXP (r
, REAL_EXP (r
) + 1);
2804 if (REAL_EXP (r
) > emax2
)
2806 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2810 /* Catch underflow that we deferred until after rounding. */
2811 if (REAL_EXP (r
) <= emin2m1
)
2814 /* Clear out trailing garbage. */
2815 clear_significand_below (r
, np2
);
2818 /* Extend or truncate to a new format. */
2821 real_convert (REAL_VALUE_TYPE
*r
, format_helper fmt
,
2822 const REAL_VALUE_TYPE
*a
)
2826 if (a
->decimal
|| fmt
->b
== 10)
2827 decimal_real_convert (r
, fmt
, a
);
2829 round_for_format (fmt
, r
);
2831 /* Make resulting NaN value to be qNaN. The caller has the
2832 responsibility to avoid the operation if flag_signaling_nans
2834 if (r
->cl
== rvc_nan
)
2837 /* round_for_format de-normalizes denormals. Undo just that part. */
2838 if (r
->cl
== rvc_normal
)
2842 /* Legacy. Likewise, except return the struct directly. */
2845 real_value_truncate (format_helper fmt
, REAL_VALUE_TYPE a
)
2848 real_convert (&r
, fmt
, &a
);
2852 /* Return true if truncating to FMT is exact. */
2855 exact_real_truncate (format_helper fmt
, const REAL_VALUE_TYPE
*a
)
2860 /* Don't allow conversion to denormals. */
2861 emin2m1
= fmt
->emin
- 1;
2862 if (REAL_EXP (a
) <= emin2m1
)
2865 /* After conversion to the new format, the value must be identical. */
2866 real_convert (&t
, fmt
, a
);
2867 return real_identical (&t
, a
);
2870 /* Write R to the given target format. Place the words of the result
2871 in target word order in BUF. There are always 32 bits in each
2872 long, no matter the size of the host long.
2874 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2877 real_to_target (long *buf
, const REAL_VALUE_TYPE
*r_orig
,
2884 round_for_format (fmt
, &r
);
2888 (*fmt
->encode
) (fmt
, buf
, &r
);
2893 /* Read R from the given target format. Read the words of the result
2894 in target word order in BUF. There are always 32 bits in each
2895 long, no matter the size of the host long. */
2898 real_from_target (REAL_VALUE_TYPE
*r
, const long *buf
, format_helper fmt
)
2900 (*fmt
->decode
) (fmt
, r
, buf
);
2903 /* Return the number of bits of the largest binary value that the
2904 significand of FMT will hold. */
2905 /* ??? Legacy. Should get access to real_format directly. */
2908 significand_size (format_helper fmt
)
2915 /* Return the size in bits of the largest binary value that can be
2916 held by the decimal coefficient for this format. This is one more
2917 than the number of bits required to hold the largest coefficient
2919 double log2_10
= 3.3219281;
2920 return fmt
->p
* log2_10
;
2925 /* Return a hash value for the given real value. */
2926 /* ??? The "unsigned int" return value is intended to be hashval_t,
2927 but I didn't want to pull hashtab.h into real.h. */
2930 real_hash (const REAL_VALUE_TYPE
*r
)
2935 h
= r
->cl
| (r
->sign
<< 2);
2943 h
|= (unsigned int)REAL_EXP (r
) << 3;
2948 h
^= (unsigned int)-1;
2957 if (sizeof (unsigned long) > sizeof (unsigned int))
2958 for (i
= 0; i
< SIGSZ
; ++i
)
2960 unsigned long s
= r
->sig
[i
];
2961 h
^= s
^ (s
>> (HOST_BITS_PER_LONG
/ 2));
2964 for (i
= 0; i
< SIGSZ
; ++i
)
2970 /* IEEE single-precision format. */
2972 static void encode_ieee_single (const struct real_format
*fmt
,
2973 long *, const REAL_VALUE_TYPE
*);
2974 static void decode_ieee_single (const struct real_format
*,
2975 REAL_VALUE_TYPE
*, const long *);
2978 encode_ieee_single (const struct real_format
*fmt
, long *buf
,
2979 const REAL_VALUE_TYPE
*r
)
2981 unsigned long image
, sig
, exp
;
2982 unsigned long sign
= r
->sign
;
2985 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
2996 image
|= 0x7fffffff;
3003 sig
= (fmt
->canonical_nan_lsbs_set
? (1 << 22) - 1 : 0);
3004 if (r
->signalling
== fmt
->qnan_msb_set
)
3015 image
|= 0x7fffffff;
3019 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3020 whereas the intermediate representation is 0.F x 2**exp.
3021 Which means we're off by one. */
3022 if (real_isdenormal (r
))
3025 exp
= REAL_EXP (r
) + 127 - 1;
3038 decode_ieee_single (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3041 unsigned long image
= buf
[0] & 0xffffffff;
3042 bool sign
= (image
>> 31) & 1;
3043 int exp
= (image
>> 23) & 0xff;
3045 memset (r
, 0, sizeof (*r
));
3046 image
<<= HOST_BITS_PER_LONG
- 24;
3051 if (image
&& fmt
->has_denorm
)
3055 SET_REAL_EXP (r
, -126);
3056 r
->sig
[SIGSZ
-1] = image
<< 1;
3059 else if (fmt
->has_signed_zero
)
3062 else if (exp
== 255 && (fmt
->has_nans
|| fmt
->has_inf
))
3068 r
->signalling
= (((image
>> (HOST_BITS_PER_LONG
- 2)) & 1)
3069 ^ fmt
->qnan_msb_set
);
3070 r
->sig
[SIGSZ
-1] = image
;
3082 SET_REAL_EXP (r
, exp
- 127 + 1);
3083 r
->sig
[SIGSZ
-1] = image
| SIG_MSB
;
3087 const struct real_format ieee_single_format
=
3110 const struct real_format mips_single_format
=
3133 const struct real_format motorola_single_format
=
3156 /* SPU Single Precision (Extended-Range Mode) format is the same as IEEE
3157 single precision with the following differences:
3158 - Infinities are not supported. Instead MAX_FLOAT or MIN_FLOAT
3160 - NaNs are not supported.
3161 - The range of non-zero numbers in binary is
3162 (001)[1.]000...000 to (255)[1.]111...111.
3163 - Denormals can be represented, but are treated as +0.0 when
3164 used as an operand and are never generated as a result.
3165 - -0.0 can be represented, but a zero result is always +0.0.
3166 - the only supported rounding mode is trunction (towards zero). */
3167 const struct real_format spu_single_format
=
3190 /* IEEE double-precision format. */
3192 static void encode_ieee_double (const struct real_format
*fmt
,
3193 long *, const REAL_VALUE_TYPE
*);
3194 static void decode_ieee_double (const struct real_format
*,
3195 REAL_VALUE_TYPE
*, const long *);
3198 encode_ieee_double (const struct real_format
*fmt
, long *buf
,
3199 const REAL_VALUE_TYPE
*r
)
3201 unsigned long image_lo
, image_hi
, sig_lo
, sig_hi
, exp
;
3202 unsigned long sign
= r
->sign
;
3204 image_hi
= sign
<< 31;
3207 if (HOST_BITS_PER_LONG
== 64)
3209 sig_hi
= r
->sig
[SIGSZ
-1];
3210 sig_lo
= (sig_hi
>> (64 - 53)) & 0xffffffff;
3211 sig_hi
= (sig_hi
>> (64 - 53 + 1) >> 31) & 0xfffff;
3215 sig_hi
= r
->sig
[SIGSZ
-1];
3216 sig_lo
= r
->sig
[SIGSZ
-2];
3217 sig_lo
= (sig_hi
<< 21) | (sig_lo
>> 11);
3218 sig_hi
= (sig_hi
>> 11) & 0xfffff;
3228 image_hi
|= 2047 << 20;
3231 image_hi
|= 0x7fffffff;
3232 image_lo
= 0xffffffff;
3241 if (fmt
->canonical_nan_lsbs_set
)
3243 sig_hi
= (1 << 19) - 1;
3244 sig_lo
= 0xffffffff;
3252 if (r
->signalling
== fmt
->qnan_msb_set
)
3253 sig_hi
&= ~(1 << 19);
3256 if (sig_hi
== 0 && sig_lo
== 0)
3259 image_hi
|= 2047 << 20;
3265 image_hi
|= 0x7fffffff;
3266 image_lo
= 0xffffffff;
3271 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3272 whereas the intermediate representation is 0.F x 2**exp.
3273 Which means we're off by one. */
3274 if (real_isdenormal (r
))
3277 exp
= REAL_EXP (r
) + 1023 - 1;
3278 image_hi
|= exp
<< 20;
3287 if (FLOAT_WORDS_BIG_ENDIAN
)
3288 buf
[0] = image_hi
, buf
[1] = image_lo
;
3290 buf
[0] = image_lo
, buf
[1] = image_hi
;
3294 decode_ieee_double (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3297 unsigned long image_hi
, image_lo
;
3301 if (FLOAT_WORDS_BIG_ENDIAN
)
3302 image_hi
= buf
[0], image_lo
= buf
[1];
3304 image_lo
= buf
[0], image_hi
= buf
[1];
3305 image_lo
&= 0xffffffff;
3306 image_hi
&= 0xffffffff;
3308 sign
= (image_hi
>> 31) & 1;
3309 exp
= (image_hi
>> 20) & 0x7ff;
3311 memset (r
, 0, sizeof (*r
));
3313 image_hi
<<= 32 - 21;
3314 image_hi
|= image_lo
>> 21;
3315 image_hi
&= 0x7fffffff;
3316 image_lo
<<= 32 - 21;
3320 if ((image_hi
|| image_lo
) && fmt
->has_denorm
)
3324 SET_REAL_EXP (r
, -1022);
3325 if (HOST_BITS_PER_LONG
== 32)
3327 image_hi
= (image_hi
<< 1) | (image_lo
>> 31);
3329 r
->sig
[SIGSZ
-1] = image_hi
;
3330 r
->sig
[SIGSZ
-2] = image_lo
;
3334 image_hi
= (image_hi
<< 31 << 2) | (image_lo
<< 1);
3335 r
->sig
[SIGSZ
-1] = image_hi
;
3339 else if (fmt
->has_signed_zero
)
3342 else if (exp
== 2047 && (fmt
->has_nans
|| fmt
->has_inf
))
3344 if (image_hi
|| image_lo
)
3348 r
->signalling
= ((image_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
3349 if (HOST_BITS_PER_LONG
== 32)
3351 r
->sig
[SIGSZ
-1] = image_hi
;
3352 r
->sig
[SIGSZ
-2] = image_lo
;
3355 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
;
3367 SET_REAL_EXP (r
, exp
- 1023 + 1);
3368 if (HOST_BITS_PER_LONG
== 32)
3370 r
->sig
[SIGSZ
-1] = image_hi
| SIG_MSB
;
3371 r
->sig
[SIGSZ
-2] = image_lo
;
3374 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
| SIG_MSB
;
3378 const struct real_format ieee_double_format
=
3401 const struct real_format mips_double_format
=
3424 const struct real_format motorola_double_format
=
3447 /* IEEE extended real format. This comes in three flavors: Intel's as
3448 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
3449 12- and 16-byte images may be big- or little endian; Motorola's is
3450 always big endian. */
3452 /* Helper subroutine which converts from the internal format to the
3453 12-byte little-endian Intel format. Functions below adjust this
3454 for the other possible formats. */
3456 encode_ieee_extended (const struct real_format
*fmt
, long *buf
,
3457 const REAL_VALUE_TYPE
*r
)
3459 unsigned long image_hi
, sig_hi
, sig_lo
;
3461 image_hi
= r
->sign
<< 15;
3462 sig_hi
= sig_lo
= 0;
3474 /* Intel requires the explicit integer bit to be set, otherwise
3475 it considers the value a "pseudo-infinity". Motorola docs
3476 say it doesn't care. */
3477 sig_hi
= 0x80000000;
3482 sig_lo
= sig_hi
= 0xffffffff;
3492 if (fmt
->canonical_nan_lsbs_set
)
3494 sig_hi
= (1 << 30) - 1;
3495 sig_lo
= 0xffffffff;
3498 else if (HOST_BITS_PER_LONG
== 32)
3500 sig_hi
= r
->sig
[SIGSZ
-1];
3501 sig_lo
= r
->sig
[SIGSZ
-2];
3505 sig_lo
= r
->sig
[SIGSZ
-1];
3506 sig_hi
= sig_lo
>> 31 >> 1;
3507 sig_lo
&= 0xffffffff;
3509 if (r
->signalling
== fmt
->qnan_msb_set
)
3510 sig_hi
&= ~(1 << 30);
3513 if ((sig_hi
& 0x7fffffff) == 0 && sig_lo
== 0)
3516 /* Intel requires the explicit integer bit to be set, otherwise
3517 it considers the value a "pseudo-nan". Motorola docs say it
3519 sig_hi
|= 0x80000000;
3524 sig_lo
= sig_hi
= 0xffffffff;
3530 int exp
= REAL_EXP (r
);
3532 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3533 whereas the intermediate representation is 0.F x 2**exp.
3534 Which means we're off by one.
3536 Except for Motorola, which consider exp=0 and explicit
3537 integer bit set to continue to be normalized. In theory
3538 this discrepancy has been taken care of by the difference
3539 in fmt->emin in round_for_format. */
3541 if (real_isdenormal (r
))
3546 gcc_assert (exp
>= 0);
3550 if (HOST_BITS_PER_LONG
== 32)
3552 sig_hi
= r
->sig
[SIGSZ
-1];
3553 sig_lo
= r
->sig
[SIGSZ
-2];
3557 sig_lo
= r
->sig
[SIGSZ
-1];
3558 sig_hi
= sig_lo
>> 31 >> 1;
3559 sig_lo
&= 0xffffffff;
3568 buf
[0] = sig_lo
, buf
[1] = sig_hi
, buf
[2] = image_hi
;
3571 /* Convert from the internal format to the 12-byte Motorola format
3572 for an IEEE extended real. */
3574 encode_ieee_extended_motorola (const struct real_format
*fmt
, long *buf
,
3575 const REAL_VALUE_TYPE
*r
)
3578 encode_ieee_extended (fmt
, intermed
, r
);
3580 if (r
->cl
== rvc_inf
)
3581 /* For infinity clear the explicit integer bit again, so that the
3582 format matches the canonical infinity generated by the FPU. */
3585 /* Motorola chips are assumed always to be big-endian. Also, the
3586 padding in a Motorola extended real goes between the exponent and
3587 the mantissa. At this point the mantissa is entirely within
3588 elements 0 and 1 of intermed, and the exponent entirely within
3589 element 2, so all we have to do is swap the order around, and
3590 shift element 2 left 16 bits. */
3591 buf
[0] = intermed
[2] << 16;
3592 buf
[1] = intermed
[1];
3593 buf
[2] = intermed
[0];
3596 /* Convert from the internal format to the 12-byte Intel format for
3597 an IEEE extended real. */
3599 encode_ieee_extended_intel_96 (const struct real_format
*fmt
, long *buf
,
3600 const REAL_VALUE_TYPE
*r
)
3602 if (FLOAT_WORDS_BIG_ENDIAN
)
3604 /* All the padding in an Intel-format extended real goes at the high
3605 end, which in this case is after the mantissa, not the exponent.
3606 Therefore we must shift everything down 16 bits. */
3608 encode_ieee_extended (fmt
, intermed
, r
);
3609 buf
[0] = ((intermed
[2] << 16) | ((unsigned long)(intermed
[1] & 0xFFFF0000) >> 16));
3610 buf
[1] = ((intermed
[1] << 16) | ((unsigned long)(intermed
[0] & 0xFFFF0000) >> 16));
3611 buf
[2] = (intermed
[0] << 16);
3614 /* encode_ieee_extended produces what we want directly. */
3615 encode_ieee_extended (fmt
, buf
, r
);
3618 /* Convert from the internal format to the 16-byte Intel format for
3619 an IEEE extended real. */
3621 encode_ieee_extended_intel_128 (const struct real_format
*fmt
, long *buf
,
3622 const REAL_VALUE_TYPE
*r
)
3624 /* All the padding in an Intel-format extended real goes at the high end. */
3625 encode_ieee_extended_intel_96 (fmt
, buf
, r
);
3629 /* As above, we have a helper function which converts from 12-byte
3630 little-endian Intel format to internal format. Functions below
3631 adjust for the other possible formats. */
3633 decode_ieee_extended (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3636 unsigned long image_hi
, sig_hi
, sig_lo
;
3640 sig_lo
= buf
[0], sig_hi
= buf
[1], image_hi
= buf
[2];
3641 sig_lo
&= 0xffffffff;
3642 sig_hi
&= 0xffffffff;
3643 image_hi
&= 0xffffffff;
3645 sign
= (image_hi
>> 15) & 1;
3646 exp
= image_hi
& 0x7fff;
3648 memset (r
, 0, sizeof (*r
));
3652 if ((sig_hi
|| sig_lo
) && fmt
->has_denorm
)
3657 /* When the IEEE format contains a hidden bit, we know that
3658 it's zero at this point, and so shift up the significand
3659 and decrease the exponent to match. In this case, Motorola
3660 defines the explicit integer bit to be valid, so we don't
3661 know whether the msb is set or not. */
3662 SET_REAL_EXP (r
, fmt
->emin
);
3663 if (HOST_BITS_PER_LONG
== 32)
3665 r
->sig
[SIGSZ
-1] = sig_hi
;
3666 r
->sig
[SIGSZ
-2] = sig_lo
;
3669 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3673 else if (fmt
->has_signed_zero
)
3676 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3678 /* See above re "pseudo-infinities" and "pseudo-nans".
3679 Short summary is that the MSB will likely always be
3680 set, and that we don't care about it. */
3681 sig_hi
&= 0x7fffffff;
3683 if (sig_hi
|| sig_lo
)
3687 r
->signalling
= ((sig_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
3688 if (HOST_BITS_PER_LONG
== 32)
3690 r
->sig
[SIGSZ
-1] = sig_hi
;
3691 r
->sig
[SIGSZ
-2] = sig_lo
;
3694 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3706 SET_REAL_EXP (r
, exp
- 16383 + 1);
3707 if (HOST_BITS_PER_LONG
== 32)
3709 r
->sig
[SIGSZ
-1] = sig_hi
;
3710 r
->sig
[SIGSZ
-2] = sig_lo
;
3713 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3717 /* Convert from the internal format to the 12-byte Motorola format
3718 for an IEEE extended real. */
3720 decode_ieee_extended_motorola (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3725 /* Motorola chips are assumed always to be big-endian. Also, the
3726 padding in a Motorola extended real goes between the exponent and
3727 the mantissa; remove it. */
3728 intermed
[0] = buf
[2];
3729 intermed
[1] = buf
[1];
3730 intermed
[2] = (unsigned long)buf
[0] >> 16;
3732 decode_ieee_extended (fmt
, r
, intermed
);
3735 /* Convert from the internal format to the 12-byte Intel format for
3736 an IEEE extended real. */
3738 decode_ieee_extended_intel_96 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3741 if (FLOAT_WORDS_BIG_ENDIAN
)
3743 /* All the padding in an Intel-format extended real goes at the high
3744 end, which in this case is after the mantissa, not the exponent.
3745 Therefore we must shift everything up 16 bits. */
3748 intermed
[0] = (((unsigned long)buf
[2] >> 16) | (buf
[1] << 16));
3749 intermed
[1] = (((unsigned long)buf
[1] >> 16) | (buf
[0] << 16));
3750 intermed
[2] = ((unsigned long)buf
[0] >> 16);
3752 decode_ieee_extended (fmt
, r
, intermed
);
3755 /* decode_ieee_extended produces what we want directly. */
3756 decode_ieee_extended (fmt
, r
, buf
);
3759 /* Convert from the internal format to the 16-byte Intel format for
3760 an IEEE extended real. */
3762 decode_ieee_extended_intel_128 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3765 /* All the padding in an Intel-format extended real goes at the high end. */
3766 decode_ieee_extended_intel_96 (fmt
, r
, buf
);
3769 const struct real_format ieee_extended_motorola_format
=
3771 encode_ieee_extended_motorola
,
3772 decode_ieee_extended_motorola
,
3789 "ieee_extended_motorola"
3792 const struct real_format ieee_extended_intel_96_format
=
3794 encode_ieee_extended_intel_96
,
3795 decode_ieee_extended_intel_96
,
3812 "ieee_extended_intel_96"
3815 const struct real_format ieee_extended_intel_128_format
=
3817 encode_ieee_extended_intel_128
,
3818 decode_ieee_extended_intel_128
,
3835 "ieee_extended_intel_128"
3838 /* The following caters to i386 systems that set the rounding precision
3839 to 53 bits instead of 64, e.g. FreeBSD. */
3840 const struct real_format ieee_extended_intel_96_round_53_format
=
3842 encode_ieee_extended_intel_96
,
3843 decode_ieee_extended_intel_96
,
3860 "ieee_extended_intel_96_round_53"
3863 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3864 numbers whose sum is equal to the extended precision value. The number
3865 with greater magnitude is first. This format has the same magnitude
3866 range as an IEEE double precision value, but effectively 106 bits of
3867 significand precision. Infinity and NaN are represented by their IEEE
3868 double precision value stored in the first number, the second number is
3869 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3871 static void encode_ibm_extended (const struct real_format
*fmt
,
3872 long *, const REAL_VALUE_TYPE
*);
3873 static void decode_ibm_extended (const struct real_format
*,
3874 REAL_VALUE_TYPE
*, const long *);
3877 encode_ibm_extended (const struct real_format
*fmt
, long *buf
,
3878 const REAL_VALUE_TYPE
*r
)
3880 REAL_VALUE_TYPE u
, normr
, v
;
3881 const struct real_format
*base_fmt
;
3883 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3885 /* Renormalize R before doing any arithmetic on it. */
3887 if (normr
.cl
== rvc_normal
)
3890 /* u = IEEE double precision portion of significand. */
3892 round_for_format (base_fmt
, &u
);
3893 encode_ieee_double (base_fmt
, &buf
[0], &u
);
3895 if (u
.cl
== rvc_normal
)
3897 do_add (&v
, &normr
, &u
, 1);
3898 /* Call round_for_format since we might need to denormalize. */
3899 round_for_format (base_fmt
, &v
);
3900 encode_ieee_double (base_fmt
, &buf
[2], &v
);
3904 /* Inf, NaN, 0 are all representable as doubles, so the
3905 least-significant part can be 0.0. */
3912 decode_ibm_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
, REAL_VALUE_TYPE
*r
,
3915 REAL_VALUE_TYPE u
, v
;
3916 const struct real_format
*base_fmt
;
3918 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3919 decode_ieee_double (base_fmt
, &u
, &buf
[0]);
3921 if (u
.cl
!= rvc_zero
&& u
.cl
!= rvc_inf
&& u
.cl
!= rvc_nan
)
3923 decode_ieee_double (base_fmt
, &v
, &buf
[2]);
3924 do_add (r
, &u
, &v
, 0);
3930 const struct real_format ibm_extended_format
=
3932 encode_ibm_extended
,
3933 decode_ibm_extended
,
3953 const struct real_format mips_extended_format
=
3955 encode_ibm_extended
,
3956 decode_ibm_extended
,
3977 /* IEEE quad precision format. */
3979 static void encode_ieee_quad (const struct real_format
*fmt
,
3980 long *, const REAL_VALUE_TYPE
*);
3981 static void decode_ieee_quad (const struct real_format
*,
3982 REAL_VALUE_TYPE
*, const long *);
3985 encode_ieee_quad (const struct real_format
*fmt
, long *buf
,
3986 const REAL_VALUE_TYPE
*r
)
3988 unsigned long image3
, image2
, image1
, image0
, exp
;
3989 unsigned long sign
= r
->sign
;
3992 image3
= sign
<< 31;
3997 rshift_significand (&u
, r
, SIGNIFICAND_BITS
- 113);
4006 image3
|= 32767 << 16;
4009 image3
|= 0x7fffffff;
4010 image2
= 0xffffffff;
4011 image1
= 0xffffffff;
4012 image0
= 0xffffffff;
4019 image3
|= 32767 << 16;
4023 if (fmt
->canonical_nan_lsbs_set
)
4026 image2
= image1
= image0
= 0xffffffff;
4029 else if (HOST_BITS_PER_LONG
== 32)
4034 image3
|= u
.sig
[3] & 0xffff;
4039 image1
= image0
>> 31 >> 1;
4041 image3
|= (image2
>> 31 >> 1) & 0xffff;
4042 image0
&= 0xffffffff;
4043 image2
&= 0xffffffff;
4045 if (r
->signalling
== fmt
->qnan_msb_set
)
4049 if (((image3
& 0xffff) | image2
| image1
| image0
) == 0)
4054 image3
|= 0x7fffffff;
4055 image2
= 0xffffffff;
4056 image1
= 0xffffffff;
4057 image0
= 0xffffffff;
4062 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
4063 whereas the intermediate representation is 0.F x 2**exp.
4064 Which means we're off by one. */
4065 if (real_isdenormal (r
))
4068 exp
= REAL_EXP (r
) + 16383 - 1;
4069 image3
|= exp
<< 16;
4071 if (HOST_BITS_PER_LONG
== 32)
4076 image3
|= u
.sig
[3] & 0xffff;
4081 image1
= image0
>> 31 >> 1;
4083 image3
|= (image2
>> 31 >> 1) & 0xffff;
4084 image0
&= 0xffffffff;
4085 image2
&= 0xffffffff;
4093 if (FLOAT_WORDS_BIG_ENDIAN
)
4110 decode_ieee_quad (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
4113 unsigned long image3
, image2
, image1
, image0
;
4117 if (FLOAT_WORDS_BIG_ENDIAN
)
4131 image0
&= 0xffffffff;
4132 image1
&= 0xffffffff;
4133 image2
&= 0xffffffff;
4135 sign
= (image3
>> 31) & 1;
4136 exp
= (image3
>> 16) & 0x7fff;
4139 memset (r
, 0, sizeof (*r
));
4143 if ((image3
| image2
| image1
| image0
) && fmt
->has_denorm
)
4148 SET_REAL_EXP (r
, -16382 + (SIGNIFICAND_BITS
- 112));
4149 if (HOST_BITS_PER_LONG
== 32)
4158 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
4159 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
4164 else if (fmt
->has_signed_zero
)
4167 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
4169 if (image3
| image2
| image1
| image0
)
4173 r
->signalling
= ((image3
>> 15) & 1) ^ fmt
->qnan_msb_set
;
4175 if (HOST_BITS_PER_LONG
== 32)
4184 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
4185 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
4187 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
4199 SET_REAL_EXP (r
, exp
- 16383 + 1);
4201 if (HOST_BITS_PER_LONG
== 32)
4210 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
4211 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
4213 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
4214 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4218 const struct real_format ieee_quad_format
=
4241 const struct real_format mips_quad_format
=
4264 /* Descriptions of VAX floating point formats can be found beginning at
4266 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
4268 The thing to remember is that they're almost IEEE, except for word
4269 order, exponent bias, and the lack of infinities, nans, and denormals.
4271 We don't implement the H_floating format here, simply because neither
4272 the VAX or Alpha ports use it. */
4274 static void encode_vax_f (const struct real_format
*fmt
,
4275 long *, const REAL_VALUE_TYPE
*);
4276 static void decode_vax_f (const struct real_format
*,
4277 REAL_VALUE_TYPE
*, const long *);
4278 static void encode_vax_d (const struct real_format
*fmt
,
4279 long *, const REAL_VALUE_TYPE
*);
4280 static void decode_vax_d (const struct real_format
*,
4281 REAL_VALUE_TYPE
*, const long *);
4282 static void encode_vax_g (const struct real_format
*fmt
,
4283 long *, const REAL_VALUE_TYPE
*);
4284 static void decode_vax_g (const struct real_format
*,
4285 REAL_VALUE_TYPE
*, const long *);
4288 encode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4289 const REAL_VALUE_TYPE
*r
)
4291 unsigned long sign
, exp
, sig
, image
;
4293 sign
= r
->sign
<< 15;
4303 image
= 0xffff7fff | sign
;
4307 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
4308 exp
= REAL_EXP (r
) + 128;
4310 image
= (sig
<< 16) & 0xffff0000;
4324 decode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4325 REAL_VALUE_TYPE
*r
, const long *buf
)
4327 unsigned long image
= buf
[0] & 0xffffffff;
4328 int exp
= (image
>> 7) & 0xff;
4330 memset (r
, 0, sizeof (*r
));
4335 r
->sign
= (image
>> 15) & 1;
4336 SET_REAL_EXP (r
, exp
- 128);
4338 image
= ((image
& 0x7f) << 16) | ((image
>> 16) & 0xffff);
4339 r
->sig
[SIGSZ
-1] = (image
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
4344 encode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4345 const REAL_VALUE_TYPE
*r
)
4347 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
4352 image0
= image1
= 0;
4357 image0
= 0xffff7fff | sign
;
4358 image1
= 0xffffffff;
4362 /* Extract the significand into straight hi:lo. */
4363 if (HOST_BITS_PER_LONG
== 64)
4365 image0
= r
->sig
[SIGSZ
-1];
4366 image1
= (image0
>> (64 - 56)) & 0xffffffff;
4367 image0
= (image0
>> (64 - 56 + 1) >> 31) & 0x7fffff;
4371 image0
= r
->sig
[SIGSZ
-1];
4372 image1
= r
->sig
[SIGSZ
-2];
4373 image1
= (image0
<< 24) | (image1
>> 8);
4374 image0
= (image0
>> 8) & 0xffffff;
4377 /* Rearrange the half-words of the significand to match the
4379 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff007f;
4380 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
4382 /* Add the sign and exponent. */
4384 image0
|= (REAL_EXP (r
) + 128) << 7;
4391 if (FLOAT_WORDS_BIG_ENDIAN
)
4392 buf
[0] = image1
, buf
[1] = image0
;
4394 buf
[0] = image0
, buf
[1] = image1
;
4398 decode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4399 REAL_VALUE_TYPE
*r
, const long *buf
)
4401 unsigned long image0
, image1
;
4404 if (FLOAT_WORDS_BIG_ENDIAN
)
4405 image1
= buf
[0], image0
= buf
[1];
4407 image0
= buf
[0], image1
= buf
[1];
4408 image0
&= 0xffffffff;
4409 image1
&= 0xffffffff;
4411 exp
= (image0
>> 7) & 0xff;
4413 memset (r
, 0, sizeof (*r
));
4418 r
->sign
= (image0
>> 15) & 1;
4419 SET_REAL_EXP (r
, exp
- 128);
4421 /* Rearrange the half-words of the external format into
4422 proper ascending order. */
4423 image0
= ((image0
& 0x7f) << 16) | ((image0
>> 16) & 0xffff);
4424 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
4426 if (HOST_BITS_PER_LONG
== 64)
4428 image0
= (image0
<< 31 << 1) | image1
;
4431 r
->sig
[SIGSZ
-1] = image0
;
4435 r
->sig
[SIGSZ
-1] = image0
;
4436 r
->sig
[SIGSZ
-2] = image1
;
4437 lshift_significand (r
, r
, 2*HOST_BITS_PER_LONG
- 56);
4438 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4444 encode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4445 const REAL_VALUE_TYPE
*r
)
4447 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
4452 image0
= image1
= 0;
4457 image0
= 0xffff7fff | sign
;
4458 image1
= 0xffffffff;
4462 /* Extract the significand into straight hi:lo. */
4463 if (HOST_BITS_PER_LONG
== 64)
4465 image0
= r
->sig
[SIGSZ
-1];
4466 image1
= (image0
>> (64 - 53)) & 0xffffffff;
4467 image0
= (image0
>> (64 - 53 + 1) >> 31) & 0xfffff;
4471 image0
= r
->sig
[SIGSZ
-1];
4472 image1
= r
->sig
[SIGSZ
-2];
4473 image1
= (image0
<< 21) | (image1
>> 11);
4474 image0
= (image0
>> 11) & 0xfffff;
4477 /* Rearrange the half-words of the significand to match the
4479 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff000f;
4480 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
4482 /* Add the sign and exponent. */
4484 image0
|= (REAL_EXP (r
) + 1024) << 4;
4491 if (FLOAT_WORDS_BIG_ENDIAN
)
4492 buf
[0] = image1
, buf
[1] = image0
;
4494 buf
[0] = image0
, buf
[1] = image1
;
4498 decode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4499 REAL_VALUE_TYPE
*r
, const long *buf
)
4501 unsigned long image0
, image1
;
4504 if (FLOAT_WORDS_BIG_ENDIAN
)
4505 image1
= buf
[0], image0
= buf
[1];
4507 image0
= buf
[0], image1
= buf
[1];
4508 image0
&= 0xffffffff;
4509 image1
&= 0xffffffff;
4511 exp
= (image0
>> 4) & 0x7ff;
4513 memset (r
, 0, sizeof (*r
));
4518 r
->sign
= (image0
>> 15) & 1;
4519 SET_REAL_EXP (r
, exp
- 1024);
4521 /* Rearrange the half-words of the external format into
4522 proper ascending order. */
4523 image0
= ((image0
& 0xf) << 16) | ((image0
>> 16) & 0xffff);
4524 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
4526 if (HOST_BITS_PER_LONG
== 64)
4528 image0
= (image0
<< 31 << 1) | image1
;
4531 r
->sig
[SIGSZ
-1] = image0
;
4535 r
->sig
[SIGSZ
-1] = image0
;
4536 r
->sig
[SIGSZ
-2] = image1
;
4537 lshift_significand (r
, r
, 64 - 53);
4538 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4543 const struct real_format vax_f_format
=
4566 const struct real_format vax_d_format
=
4589 const struct real_format vax_g_format
=
4612 /* Encode real R into a single precision DFP value in BUF. */
4614 encode_decimal_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4615 long *buf ATTRIBUTE_UNUSED
,
4616 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4618 encode_decimal32 (fmt
, buf
, r
);
4621 /* Decode a single precision DFP value in BUF into a real R. */
4623 decode_decimal_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4624 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4625 const long *buf ATTRIBUTE_UNUSED
)
4627 decode_decimal32 (fmt
, r
, buf
);
4630 /* Encode real R into a double precision DFP value in BUF. */
4632 encode_decimal_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4633 long *buf ATTRIBUTE_UNUSED
,
4634 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4636 encode_decimal64 (fmt
, buf
, r
);
4639 /* Decode a double precision DFP value in BUF into a real R. */
4641 decode_decimal_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4642 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4643 const long *buf ATTRIBUTE_UNUSED
)
4645 decode_decimal64 (fmt
, r
, buf
);
4648 /* Encode real R into a quad precision DFP value in BUF. */
4650 encode_decimal_quad (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4651 long *buf ATTRIBUTE_UNUSED
,
4652 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4654 encode_decimal128 (fmt
, buf
, r
);
4657 /* Decode a quad precision DFP value in BUF into a real R. */
4659 decode_decimal_quad (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4660 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4661 const long *buf ATTRIBUTE_UNUSED
)
4663 decode_decimal128 (fmt
, r
, buf
);
4666 /* Single precision decimal floating point (IEEE 754). */
4667 const struct real_format decimal_single_format
=
4669 encode_decimal_single
,
4670 decode_decimal_single
,
4690 /* Double precision decimal floating point (IEEE 754). */
4691 const struct real_format decimal_double_format
=
4693 encode_decimal_double
,
4694 decode_decimal_double
,
4714 /* Quad precision decimal floating point (IEEE 754). */
4715 const struct real_format decimal_quad_format
=
4717 encode_decimal_quad
,
4718 decode_decimal_quad
,
4738 /* Encode half-precision floats. This routine is used both for the IEEE
4739 ARM alternative encodings. */
4741 encode_ieee_half (const struct real_format
*fmt
, long *buf
,
4742 const REAL_VALUE_TYPE
*r
)
4744 unsigned long image
, sig
, exp
;
4745 unsigned long sign
= r
->sign
;
4748 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 11)) & 0x3ff;
4766 sig
= (fmt
->canonical_nan_lsbs_set
? (1 << 9) - 1 : 0);
4767 if (r
->signalling
== fmt
->qnan_msb_set
)
4782 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
4783 whereas the intermediate representation is 0.F x 2**exp.
4784 Which means we're off by one. */
4785 if (real_isdenormal (r
))
4788 exp
= REAL_EXP (r
) + 15 - 1;
4800 /* Decode half-precision floats. This routine is used both for the IEEE
4801 ARM alternative encodings. */
4803 decode_ieee_half (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
4806 unsigned long image
= buf
[0] & 0xffff;
4807 bool sign
= (image
>> 15) & 1;
4808 int exp
= (image
>> 10) & 0x1f;
4810 memset (r
, 0, sizeof (*r
));
4811 image
<<= HOST_BITS_PER_LONG
- 11;
4816 if (image
&& fmt
->has_denorm
)
4820 SET_REAL_EXP (r
, -14);
4821 r
->sig
[SIGSZ
-1] = image
<< 1;
4824 else if (fmt
->has_signed_zero
)
4827 else if (exp
== 31 && (fmt
->has_nans
|| fmt
->has_inf
))
4833 r
->signalling
= (((image
>> (HOST_BITS_PER_LONG
- 2)) & 1)
4834 ^ fmt
->qnan_msb_set
);
4835 r
->sig
[SIGSZ
-1] = image
;
4847 SET_REAL_EXP (r
, exp
- 15 + 1);
4848 r
->sig
[SIGSZ
-1] = image
| SIG_MSB
;
4852 /* Encode arm_bfloat types. */
4854 encode_arm_bfloat_half (const struct real_format
*fmt
, long *buf
,
4855 const REAL_VALUE_TYPE
*r
)
4857 unsigned long image
, sig
, exp
;
4858 unsigned long sign
= r
->sign
;
4861 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 8)) & 0x7f;
4879 sig
= (fmt
->canonical_nan_lsbs_set
? (1 << 6) - 1 : 0);
4880 if (r
->signalling
== fmt
->qnan_msb_set
)
4895 if (real_isdenormal (r
))
4898 exp
= REAL_EXP (r
) + 127 - 1;
4910 /* Decode arm_bfloat types. */
4912 decode_arm_bfloat_half (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
4915 unsigned long image
= buf
[0] & 0xffff;
4916 bool sign
= (image
>> 15) & 1;
4917 int exp
= (image
>> 7) & 0xff;
4919 memset (r
, 0, sizeof (*r
));
4920 image
<<= HOST_BITS_PER_LONG
- 8;
4925 if (image
&& fmt
->has_denorm
)
4929 SET_REAL_EXP (r
, -126);
4930 r
->sig
[SIGSZ
-1] = image
<< 1;
4933 else if (fmt
->has_signed_zero
)
4936 else if (exp
== 255 && (fmt
->has_nans
|| fmt
->has_inf
))
4942 r
->signalling
= (((image
>> (HOST_BITS_PER_LONG
- 2)) & 1)
4943 ^ fmt
->qnan_msb_set
);
4944 r
->sig
[SIGSZ
-1] = image
;
4956 SET_REAL_EXP (r
, exp
- 127 + 1);
4957 r
->sig
[SIGSZ
-1] = image
| SIG_MSB
;
4961 /* Half-precision format, as specified in IEEE 754R. */
4962 const struct real_format ieee_half_format
=
4985 /* ARM's alternative half-precision format, similar to IEEE but with
4986 no reserved exponent value for NaNs and infinities; rather, it just
4987 extends the range of exponents by one. */
4988 const struct real_format arm_half_format
=
5011 /* ARM Bfloat half-precision format. This format resembles a truncated
5012 (16-bit) version of the 32-bit IEEE 754 single-precision floating-point
5014 const struct real_format arm_bfloat_half_format
=
5016 encode_arm_bfloat_half
,
5017 decode_arm_bfloat_half
,
5038 /* A synthetic "format" for internal arithmetic. It's the size of the
5039 internal significand minus the two bits needed for proper rounding.
5040 The encode and decode routines exist only to satisfy our paranoia
5043 static void encode_internal (const struct real_format
*fmt
,
5044 long *, const REAL_VALUE_TYPE
*);
5045 static void decode_internal (const struct real_format
*,
5046 REAL_VALUE_TYPE
*, const long *);
5049 encode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
5050 const REAL_VALUE_TYPE
*r
)
5052 memcpy (buf
, r
, sizeof (*r
));
5056 decode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
5057 REAL_VALUE_TYPE
*r
, const long *buf
)
5059 memcpy (r
, buf
, sizeof (*r
));
5062 const struct real_format real_internal_format
=
5067 SIGNIFICAND_BITS
- 2,
5068 SIGNIFICAND_BITS
- 2,
5085 /* Calculate X raised to the integer exponent N in format FMT and store
5086 the result in R. Return true if the result may be inexact due to
5087 loss of precision. The algorithm is the classic "left-to-right binary
5088 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
5089 Algorithms", "The Art of Computer Programming", Volume 2. */
5092 real_powi (REAL_VALUE_TYPE
*r
, format_helper fmt
,
5093 const REAL_VALUE_TYPE
*x
, HOST_WIDE_INT n
)
5095 unsigned HOST_WIDE_INT bit
;
5097 bool inexact
= false;
5109 /* Don't worry about overflow, from now on n is unsigned. */
5117 bit
= HOST_WIDE_INT_1U
<< (HOST_BITS_PER_WIDE_INT
- 1);
5118 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
; i
++)
5122 inexact
|= do_multiply (&t
, &t
, &t
);
5124 inexact
|= do_multiply (&t
, &t
, x
);
5132 inexact
|= do_divide (&t
, &dconst1
, &t
);
5134 real_convert (r
, fmt
, &t
);
5138 /* Round X to the nearest integer not larger in absolute value, i.e.
5139 towards zero, placing the result in R in format FMT. */
5142 real_trunc (REAL_VALUE_TYPE
*r
, format_helper fmt
,
5143 const REAL_VALUE_TYPE
*x
)
5145 do_fix_trunc (r
, x
);
5147 real_convert (r
, fmt
, r
);
5150 /* Round X to the largest integer not greater in value, i.e. round
5151 down, placing the result in R in format FMT. */
5154 real_floor (REAL_VALUE_TYPE
*r
, format_helper fmt
,
5155 const REAL_VALUE_TYPE
*x
)
5159 do_fix_trunc (&t
, x
);
5160 if (! real_identical (&t
, x
) && x
->sign
)
5161 do_add (&t
, &t
, &dconstm1
, 0);
5163 real_convert (r
, fmt
, &t
);
5168 /* Round X to the smallest integer not less then argument, i.e. round
5169 up, placing the result in R in format FMT. */
5172 real_ceil (REAL_VALUE_TYPE
*r
, format_helper fmt
,
5173 const REAL_VALUE_TYPE
*x
)
5177 do_fix_trunc (&t
, x
);
5178 if (! real_identical (&t
, x
) && ! x
->sign
)
5179 do_add (&t
, &t
, &dconst1
, 0);
5181 real_convert (r
, fmt
, &t
);
5186 /* Round X to the nearest integer, but round halfway cases away from
5190 real_round (REAL_VALUE_TYPE
*r
, format_helper fmt
,
5191 const REAL_VALUE_TYPE
*x
)
5193 do_add (r
, x
, &dconsthalf
, x
->sign
);
5194 do_fix_trunc (r
, r
);
5196 real_convert (r
, fmt
, r
);
5199 /* Return true (including 0) if integer part of R is even, else return
5200 false. The function is not valid for rvc_inf and rvc_nan classes. */
5203 is_even (REAL_VALUE_TYPE
*r
)
5205 gcc_assert (r
->cl
!= rvc_inf
);
5206 gcc_assert (r
->cl
!= rvc_nan
);
5208 if (r
->cl
== rvc_zero
)
5211 /* For (-1,1), number is even. */
5212 if (REAL_EXP (r
) <= 0)
5215 /* Check lowest bit, if not set, return true. */
5216 else if (REAL_EXP (r
) <= SIGNIFICAND_BITS
)
5218 unsigned int n
= SIGNIFICAND_BITS
- REAL_EXP (r
);
5219 int w
= n
/ HOST_BITS_PER_LONG
;
5221 unsigned long num
= ((unsigned long)1 << (n
% HOST_BITS_PER_LONG
));
5223 if ((r
->sig
[w
] & num
) == 0)
5232 /* Return true if R is halfway between two integers, else return
5236 is_halfway_below (const REAL_VALUE_TYPE
*r
)
5238 if (r
->cl
!= rvc_normal
)
5241 /* For numbers (-0.5,0) and (0,0.5). */
5242 if (REAL_EXP (r
) < 0)
5245 else if (REAL_EXP (r
) < SIGNIFICAND_BITS
)
5247 unsigned int n
= SIGNIFICAND_BITS
- REAL_EXP (r
) - 1;
5248 int w
= n
/ HOST_BITS_PER_LONG
;
5250 for (int i
= 0; i
< w
; ++i
)
5254 unsigned long num
= 1UL << (n
% HOST_BITS_PER_LONG
);
5256 if ((r
->sig
[w
] & num
) != 0 && (r
->sig
[w
] & (num
- 1)) == 0)
5262 /* Round X to nearest integer, rounding halfway cases towards even. */
5265 real_roundeven (REAL_VALUE_TYPE
*r
, format_helper fmt
,
5266 const REAL_VALUE_TYPE
*x
)
5268 if (is_halfway_below (x
))
5270 /* Special case as -0.5 rounds to -0.0 and
5271 similarly +0.5 rounds to +0.0. */
5272 if (REAL_EXP (x
) == 0)
5275 clear_significand_below (r
, SIGNIFICAND_BITS
);
5279 do_add (r
, x
, &dconsthalf
, x
->sign
);
5281 do_add (r
, r
, &dconstm1
, x
->sign
);
5284 real_convert (r
, fmt
, r
);
5287 real_round (r
, fmt
, x
);
5290 /* Set the sign of R to the sign of X. */
5293 real_copysign (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*x
)
5298 /* Check whether the real constant value given is an integer.
5299 Returns false for signaling NaN. */
5302 real_isinteger (const REAL_VALUE_TYPE
*c
, format_helper fmt
)
5304 REAL_VALUE_TYPE cint
;
5306 real_trunc (&cint
, fmt
, c
);
5307 return real_identical (c
, &cint
);
5310 /* Check whether C is an integer that fits in a HOST_WIDE_INT,
5311 storing it in *INT_OUT if so. */
5314 real_isinteger (const REAL_VALUE_TYPE
*c
, HOST_WIDE_INT
*int_out
)
5316 REAL_VALUE_TYPE cint
;
5318 HOST_WIDE_INT n
= real_to_integer (c
);
5319 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
5320 if (real_identical (c
, &cint
))
5328 /* Calculate nextafter (X, Y) or nexttoward (X, Y). Return true if
5329 underflow or overflow needs to be raised. */
5332 real_nextafter (REAL_VALUE_TYPE
*r
, format_helper fmt
,
5333 const REAL_VALUE_TYPE
*x
, const REAL_VALUE_TYPE
*y
)
5335 int cmp
= do_compare (x
, y
, 2);
5336 /* If either operand is NaN, return qNaN. */
5339 get_canonical_qnan (r
, 0);
5342 /* If x == y, return y cast to target type. */
5345 real_convert (r
, fmt
, y
);
5349 if (x
->cl
== rvc_zero
)
5351 get_zero (r
, y
->sign
);
5353 SET_REAL_EXP (r
, fmt
->emin
- fmt
->p
+ 1);
5354 r
->sig
[SIGSZ
- 1] = SIG_MSB
;
5358 int np2
= SIGNIFICAND_BITS
- fmt
->p
;
5359 /* For denormals adjust np2 correspondingly. */
5360 if (x
->cl
== rvc_normal
&& REAL_EXP (x
) < fmt
->emin
)
5361 np2
+= fmt
->emin
- REAL_EXP (x
);
5364 get_zero (r
, x
->sign
);
5366 set_significand_bit (&u
, np2
);
5368 SET_REAL_EXP (r
, REAL_EXP (x
));
5370 if (x
->cl
== rvc_inf
)
5372 bool borrow
= sub_significands (r
, r
, &u
, 0);
5373 gcc_assert (borrow
);
5374 SET_REAL_EXP (r
, fmt
->emax
);
5376 else if (cmp
== (x
->sign
? 1 : -1))
5378 if (add_significands (r
, x
, &u
))
5380 /* Overflow. Means the significand had been all ones, and
5381 is now all zeros. Need to increase the exponent, and
5382 possibly re-normalize it. */
5383 SET_REAL_EXP (r
, REAL_EXP (r
) + 1);
5384 if (REAL_EXP (r
) > fmt
->emax
)
5386 get_inf (r
, x
->sign
);
5389 r
->sig
[SIGSZ
- 1] = SIG_MSB
;
5394 if (REAL_EXP (x
) > fmt
->emin
&& x
->sig
[SIGSZ
- 1] == SIG_MSB
)
5397 for (i
= SIGSZ
- 2; i
>= 0; i
--)
5402 /* When mantissa is 1.0, we need to subtract only
5403 half of u: nextafter (1.0, 0.0) is 1.0 - __DBL_EPSILON__ / 2
5404 rather than 1.0 - __DBL_EPSILON__. */
5405 clear_significand_bit (&u
, np2
);
5407 set_significand_bit (&u
, np2
);
5410 sub_significands (r
, x
, &u
, 0);
5413 /* Clear out trailing garbage. */
5414 clear_significand_below (r
, np2
);
5416 if (REAL_EXP (r
) <= fmt
->emin
- fmt
->p
)
5418 get_zero (r
, x
->sign
);
5421 return r
->cl
== rvc_zero
|| REAL_EXP (r
) < fmt
->emin
;
5424 /* Write into BUF the maximum representable finite floating-point
5425 number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
5426 float string. LEN is the size of BUF, and the buffer must be large
5427 enough to contain the resulting string. If NORM_MAX, instead write
5428 the maximum representable finite normalized floating-point number,
5429 defined to be such that all choices of digits for that exponent are
5430 representable in the format (this only makes a difference for IBM
5434 get_max_float (const struct real_format
*fmt
, char *buf
, size_t len
,
5439 bool is_ibm_extended
= fmt
->pnan
< fmt
->p
;
5441 strcpy (buf
, "0x0.");
5443 for (i
= 0, p
= buf
+ 4; i
+ 3 < n
; i
+= 4)
5446 *p
++ = "08ce"[n
- i
];
5448 (is_ibm_extended
&& norm_max
) ? fmt
->emax
- 1 : fmt
->emax
);
5449 if (is_ibm_extended
&& !norm_max
)
5451 /* This is an IBM extended double format made up of two IEEE
5452 doubles. The value of the long double is the sum of the
5453 values of the two parts. The most significant part is
5454 required to be the value of the long double rounded to the
5455 nearest double. Rounding means we need a slightly smaller
5456 value for LDBL_MAX. */
5457 buf
[4 + fmt
->pnan
/ 4] = "7bde"[fmt
->pnan
% 4];
5460 gcc_assert (strlen (buf
) < len
);
5463 /* True if all values of integral type can be represented
5464 by this floating-point type exactly. */
5466 bool format_helper::can_represent_integral_type_p (tree type
) const
5468 gcc_assert (! decimal_p () && INTEGRAL_TYPE_P (type
));
5470 /* INT?_MIN is power-of-two so it takes
5471 only one mantissa bit. */
5472 bool signed_p
= TYPE_SIGN (type
) == SIGNED
;
5473 return TYPE_PRECISION (type
) - signed_p
<= significand_size (*this);
5476 /* True if mode M has a NaN representation and
5477 the treatment of NaN operands is important. */
5480 HONOR_NANS (machine_mode m
)
5482 return MODE_HAS_NANS (m
) && !flag_finite_math_only
;
5486 HONOR_NANS (const_tree t
)
5488 return HONOR_NANS (element_mode (t
));
5492 HONOR_NANS (const_rtx x
)
5494 return HONOR_NANS (GET_MODE (x
));
5497 /* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs). */
5500 HONOR_SNANS (machine_mode m
)
5502 return flag_signaling_nans
&& HONOR_NANS (m
);
5506 HONOR_SNANS (const_tree t
)
5508 return HONOR_SNANS (element_mode (t
));
5512 HONOR_SNANS (const_rtx x
)
5514 return HONOR_SNANS (GET_MODE (x
));
5517 /* As for HONOR_NANS, but true if the mode can represent infinity and
5518 the treatment of infinite values is important. */
5521 HONOR_INFINITIES (machine_mode m
)
5523 return MODE_HAS_INFINITIES (m
) && !flag_finite_math_only
;
5527 HONOR_INFINITIES (const_tree t
)
5529 return HONOR_INFINITIES (element_mode (t
));
5533 HONOR_INFINITIES (const_rtx x
)
5535 return HONOR_INFINITIES (GET_MODE (x
));
5538 /* Like HONOR_NANS, but true if the given mode distinguishes between
5539 positive and negative zero, and the sign of zero is important. */
5542 HONOR_SIGNED_ZEROS (machine_mode m
)
5544 return MODE_HAS_SIGNED_ZEROS (m
) && flag_signed_zeros
;
5548 HONOR_SIGNED_ZEROS (const_tree t
)
5550 return HONOR_SIGNED_ZEROS (element_mode (t
));
5554 HONOR_SIGNED_ZEROS (const_rtx x
)
5556 return HONOR_SIGNED_ZEROS (GET_MODE (x
));
5559 /* Like HONOR_NANS, but true if given mode supports sign-dependent rounding,
5560 and the rounding mode is important. */
5563 HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode m
)
5565 return MODE_HAS_SIGN_DEPENDENT_ROUNDING (m
) && flag_rounding_math
;
5569 HONOR_SIGN_DEPENDENT_ROUNDING (const_tree t
)
5571 return HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (t
));
5575 HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx x
)
5577 return HONOR_SIGN_DEPENDENT_ROUNDING (GET_MODE (x
));
5580 /* Fills r with the largest value such that 1 + r*r won't overflow.
5581 This is used in both sin (atan (x)) and cos (atan(x)) optimizations. */
5584 build_sinatan_real (REAL_VALUE_TYPE
* r
, tree type
)
5586 REAL_VALUE_TYPE maxval
;
5587 mpfr_t mpfr_const1
, mpfr_c
, mpfr_maxval
;
5588 machine_mode mode
= TYPE_MODE (type
);
5589 const struct real_format
* fmt
= REAL_MODE_FORMAT (mode
);
5591 real_maxval (&maxval
, 0, mode
);
5593 mpfr_inits (mpfr_const1
, mpfr_c
, mpfr_maxval
, NULL
);
5595 mpfr_from_real (mpfr_const1
, &dconst1
, MPFR_RNDN
);
5596 mpfr_from_real (mpfr_maxval
, &maxval
, MPFR_RNDN
);
5598 mpfr_sub (mpfr_c
, mpfr_maxval
, mpfr_const1
, MPFR_RNDN
);
5599 mpfr_sqrt (mpfr_c
, mpfr_c
, MPFR_RNDZ
);
5601 real_from_mpfr (r
, mpfr_c
, fmt
, MPFR_RNDZ
);
5603 mpfr_clears (mpfr_const1
, mpfr_c
, mpfr_maxval
, NULL
);