1 /* real.c - software floating point emulation.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
4 Contributed by Stephen L. Moshier (moshier@world.std.com).
5 Re-written by Richard Henderson <rth@redhat.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 2, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
26 #include "coretypes.h"
34 /* The floating point model used internally is not exactly IEEE 754
35 compliant, and close to the description in the ISO C99 standard,
36 section 5.2.4.2.2 Characteristics of floating types.
40 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
44 b = base or radix, here always 2
46 p = precision (the number of base-b digits in the significand)
47 f_k = the digits of the significand.
49 We differ from typical IEEE 754 encodings in that the entire
50 significand is fractional. Normalized significands are in the
53 A requirement of the model is that P be larger than the largest
54 supported target floating-point type by at least 2 bits. This gives
55 us proper rounding when we truncate to the target type. In addition,
56 E must be large enough to hold the smallest supported denormal number
59 Both of these requirements are easily satisfied. The largest target
60 significand is 113 bits; we store at least 160. The smallest
61 denormal number fits in 17 exponent bits; we store 27.
63 Note that the decimal string conversion routines are sensitive to
64 rounding errors. Since the raw arithmetic routines do not themselves
65 have guard digits or rounding, the computation of 10**exp can
66 accumulate more than a few digits of error. The previous incarnation
67 of real.c successfully used a 144-bit fraction; given the current
68 layout of REAL_VALUE_TYPE we're forced to expand to at least 160 bits. */
71 /* Used to classify two numbers simultaneously. */
72 #define CLASS2(A, B) ((A) << 2 | (B))
74 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
75 #error "Some constant folding done by hand to avoid shift count warnings"
78 static void get_zero (REAL_VALUE_TYPE
*, int);
79 static void get_canonical_qnan (REAL_VALUE_TYPE
*, int);
80 static void get_canonical_snan (REAL_VALUE_TYPE
*, int);
81 static void get_inf (REAL_VALUE_TYPE
*, int);
82 static bool sticky_rshift_significand (REAL_VALUE_TYPE
*,
83 const REAL_VALUE_TYPE
*, unsigned int);
84 static void rshift_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
86 static void lshift_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
88 static void lshift_significand_1 (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
89 static bool add_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*,
90 const REAL_VALUE_TYPE
*);
91 static bool sub_significands (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
92 const REAL_VALUE_TYPE
*, int);
93 static void neg_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
94 static int cmp_significands (const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
95 static int cmp_significand_0 (const REAL_VALUE_TYPE
*);
96 static void set_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
97 static void clear_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
98 static bool test_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
99 static void clear_significand_below (REAL_VALUE_TYPE
*, unsigned int);
100 static bool div_significands (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
101 const REAL_VALUE_TYPE
*);
102 static void normalize (REAL_VALUE_TYPE
*);
104 static bool do_add (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
105 const REAL_VALUE_TYPE
*, int);
106 static bool do_multiply (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
107 const REAL_VALUE_TYPE
*);
108 static bool do_divide (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
109 const REAL_VALUE_TYPE
*);
110 static int do_compare (const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*, int);
111 static void do_fix_trunc (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
113 static unsigned long rtd_divmod (REAL_VALUE_TYPE
*, REAL_VALUE_TYPE
*);
115 static const REAL_VALUE_TYPE
* ten_to_ptwo (int);
116 static const REAL_VALUE_TYPE
* ten_to_mptwo (int);
117 static const REAL_VALUE_TYPE
* real_digit (int);
118 static void times_pten (REAL_VALUE_TYPE
*, int);
120 static void round_for_format (const struct real_format
*, REAL_VALUE_TYPE
*);
122 /* Initialize R with a positive zero. */
125 get_zero (REAL_VALUE_TYPE
*r
, int sign
)
127 memset (r
, 0, sizeof (*r
));
131 /* Initialize R with the canonical quiet NaN. */
134 get_canonical_qnan (REAL_VALUE_TYPE
*r
, int sign
)
136 memset (r
, 0, sizeof (*r
));
143 get_canonical_snan (REAL_VALUE_TYPE
*r
, int sign
)
145 memset (r
, 0, sizeof (*r
));
153 get_inf (REAL_VALUE_TYPE
*r
, int sign
)
155 memset (r
, 0, sizeof (*r
));
161 /* Right-shift the significand of A by N bits; put the result in the
162 significand of R. If any one bits are shifted out, return true. */
165 sticky_rshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
168 unsigned long sticky
= 0;
169 unsigned int i
, ofs
= 0;
171 if (n
>= HOST_BITS_PER_LONG
)
173 for (i
= 0, ofs
= n
/ HOST_BITS_PER_LONG
; i
< ofs
; ++i
)
175 n
&= HOST_BITS_PER_LONG
- 1;
180 sticky
|= a
->sig
[ofs
] & (((unsigned long)1 << n
) - 1);
181 for (i
= 0; i
< SIGSZ
; ++i
)
184 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
185 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
186 << (HOST_BITS_PER_LONG
- n
)));
191 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
192 r
->sig
[i
] = a
->sig
[ofs
+ i
];
193 for (; i
< SIGSZ
; ++i
)
200 /* Right-shift the significand of A by N bits; put the result in the
204 rshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
207 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
209 n
&= HOST_BITS_PER_LONG
- 1;
212 for (i
= 0; i
< SIGSZ
; ++i
)
215 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
216 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
217 << (HOST_BITS_PER_LONG
- n
)));
222 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
223 r
->sig
[i
] = a
->sig
[ofs
+ i
];
224 for (; i
< SIGSZ
; ++i
)
229 /* Left-shift the significand of A by N bits; put the result in the
233 lshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
236 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
238 n
&= HOST_BITS_PER_LONG
- 1;
241 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
242 r
->sig
[SIGSZ
-1-i
] = a
->sig
[SIGSZ
-1-i
-ofs
];
243 for (; i
< SIGSZ
; ++i
)
244 r
->sig
[SIGSZ
-1-i
] = 0;
247 for (i
= 0; i
< SIGSZ
; ++i
)
250 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
]) << n
)
251 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
-1])
252 >> (HOST_BITS_PER_LONG
- n
)));
256 /* Likewise, but N is specialized to 1. */
259 lshift_significand_1 (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
263 for (i
= SIGSZ
- 1; i
> 0; --i
)
264 r
->sig
[i
] = (a
->sig
[i
] << 1) | (a
->sig
[i
-1] >> (HOST_BITS_PER_LONG
- 1));
265 r
->sig
[0] = a
->sig
[0] << 1;
268 /* Add the significands of A and B, placing the result in R. Return
269 true if there was carry out of the most significant word. */
272 add_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
273 const REAL_VALUE_TYPE
*b
)
278 for (i
= 0; i
< SIGSZ
; ++i
)
280 unsigned long ai
= a
->sig
[i
];
281 unsigned long ri
= ai
+ b
->sig
[i
];
297 /* Subtract the significands of A and B, placing the result in R. CARRY is
298 true if there's a borrow incoming to the least significant word.
299 Return true if there was borrow out of the most significant word. */
302 sub_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
303 const REAL_VALUE_TYPE
*b
, int carry
)
307 for (i
= 0; i
< SIGSZ
; ++i
)
309 unsigned long ai
= a
->sig
[i
];
310 unsigned long ri
= ai
- b
->sig
[i
];
326 /* Negate the significand A, placing the result in R. */
329 neg_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
334 for (i
= 0; i
< SIGSZ
; ++i
)
336 unsigned long ri
, ai
= a
->sig
[i
];
355 /* Compare significands. Return tri-state vs zero. */
358 cmp_significands (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
362 for (i
= SIGSZ
- 1; i
>= 0; --i
)
364 unsigned long ai
= a
->sig
[i
];
365 unsigned long bi
= b
->sig
[i
];
376 /* Return true if A is nonzero. */
379 cmp_significand_0 (const REAL_VALUE_TYPE
*a
)
383 for (i
= SIGSZ
- 1; i
>= 0; --i
)
390 /* Set bit N of the significand of R. */
393 set_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
395 r
->sig
[n
/ HOST_BITS_PER_LONG
]
396 |= (unsigned long)1 << (n
% HOST_BITS_PER_LONG
);
399 /* Clear bit N of the significand of R. */
402 clear_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
404 r
->sig
[n
/ HOST_BITS_PER_LONG
]
405 &= ~((unsigned long)1 << (n
% HOST_BITS_PER_LONG
));
408 /* Test bit N of the significand of R. */
411 test_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
413 /* ??? Compiler bug here if we return this expression directly.
414 The conversion to bool strips the "&1" and we wind up testing
415 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
416 int t
= (r
->sig
[n
/ HOST_BITS_PER_LONG
] >> (n
% HOST_BITS_PER_LONG
)) & 1;
420 /* Clear bits 0..N-1 of the significand of R. */
423 clear_significand_below (REAL_VALUE_TYPE
*r
, unsigned int n
)
425 int i
, w
= n
/ HOST_BITS_PER_LONG
;
427 for (i
= 0; i
< w
; ++i
)
430 r
->sig
[w
] &= ~(((unsigned long)1 << (n
% HOST_BITS_PER_LONG
)) - 1);
433 /* Divide the significands of A and B, placing the result in R. Return
434 true if the division was inexact. */
437 div_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
438 const REAL_VALUE_TYPE
*b
)
441 int i
, bit
= SIGNIFICAND_BITS
- 1;
442 unsigned long msb
, inexact
;
445 memset (r
->sig
, 0, sizeof (r
->sig
));
451 msb
= u
.sig
[SIGSZ
-1] & SIG_MSB
;
452 lshift_significand_1 (&u
, &u
);
454 if (msb
|| cmp_significands (&u
, b
) >= 0)
456 sub_significands (&u
, &u
, b
, 0);
457 set_significand_bit (r
, bit
);
462 for (i
= 0, inexact
= 0; i
< SIGSZ
; i
++)
468 /* Adjust the exponent and significand of R such that the most
469 significant bit is set. We underflow to zero and overflow to
470 infinity here, without denormals. (The intermediate representation
471 exponent is large enough to handle target denormals normalized.) */
474 normalize (REAL_VALUE_TYPE
*r
)
482 /* Find the first word that is nonzero. */
483 for (i
= SIGSZ
- 1; i
>= 0; i
--)
485 shift
+= HOST_BITS_PER_LONG
;
489 /* Zero significand flushes to zero. */
497 /* Find the first bit that is nonzero. */
499 if (r
->sig
[i
] & ((unsigned long)1 << (HOST_BITS_PER_LONG
- 1 - j
)))
505 exp
= REAL_EXP (r
) - shift
;
507 get_inf (r
, r
->sign
);
508 else if (exp
< -MAX_EXP
)
509 get_zero (r
, r
->sign
);
512 SET_REAL_EXP (r
, exp
);
513 lshift_significand (r
, r
, shift
);
518 /* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the
519 result may be inexact due to a loss of precision. */
522 do_add (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
523 const REAL_VALUE_TYPE
*b
, int subtract_p
)
527 bool inexact
= false;
529 /* Determine if we need to add or subtract. */
531 subtract_p
= (sign
^ b
->sign
) ^ subtract_p
;
533 switch (CLASS2 (a
->cl
, b
->cl
))
535 case CLASS2 (rvc_zero
, rvc_zero
):
536 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
537 get_zero (r
, sign
& !subtract_p
);
540 case CLASS2 (rvc_zero
, rvc_normal
):
541 case CLASS2 (rvc_zero
, rvc_inf
):
542 case CLASS2 (rvc_zero
, rvc_nan
):
544 case CLASS2 (rvc_normal
, rvc_nan
):
545 case CLASS2 (rvc_inf
, rvc_nan
):
546 case CLASS2 (rvc_nan
, rvc_nan
):
547 /* ANY + NaN = NaN. */
548 case CLASS2 (rvc_normal
, rvc_inf
):
551 r
->sign
= sign
^ subtract_p
;
554 case CLASS2 (rvc_normal
, rvc_zero
):
555 case CLASS2 (rvc_inf
, rvc_zero
):
556 case CLASS2 (rvc_nan
, rvc_zero
):
558 case CLASS2 (rvc_nan
, rvc_normal
):
559 case CLASS2 (rvc_nan
, rvc_inf
):
560 /* NaN + ANY = NaN. */
561 case CLASS2 (rvc_inf
, rvc_normal
):
566 case CLASS2 (rvc_inf
, rvc_inf
):
568 /* Inf - Inf = NaN. */
569 get_canonical_qnan (r
, 0);
571 /* Inf + Inf = Inf. */
575 case CLASS2 (rvc_normal
, rvc_normal
):
582 /* Swap the arguments such that A has the larger exponent. */
583 dexp
= REAL_EXP (a
) - REAL_EXP (b
);
586 const REAL_VALUE_TYPE
*t
;
593 /* If the exponents are not identical, we need to shift the
594 significand of B down. */
597 /* If the exponents are too far apart, the significands
598 do not overlap, which makes the subtraction a noop. */
599 if (dexp
>= SIGNIFICAND_BITS
)
606 inexact
|= sticky_rshift_significand (&t
, b
, dexp
);
612 if (sub_significands (r
, a
, b
, inexact
))
614 /* We got a borrow out of the subtraction. That means that
615 A and B had the same exponent, and B had the larger
616 significand. We need to swap the sign and negate the
619 neg_significand (r
, r
);
624 if (add_significands (r
, a
, b
))
626 /* We got carry out of the addition. This means we need to
627 shift the significand back down one bit and increase the
629 inexact
|= sticky_rshift_significand (r
, r
, 1);
630 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
641 SET_REAL_EXP (r
, exp
);
642 /* Zero out the remaining fields. */
647 /* Re-normalize the result. */
650 /* Special case: if the subtraction results in zero, the result
652 if (r
->cl
== rvc_zero
)
655 r
->sig
[0] |= inexact
;
660 /* Calculate R = A * B. Return true if the result may be inexact. */
663 do_multiply (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
664 const REAL_VALUE_TYPE
*b
)
666 REAL_VALUE_TYPE u
, t
, *rr
;
667 unsigned int i
, j
, k
;
668 int sign
= a
->sign
^ b
->sign
;
669 bool inexact
= false;
671 switch (CLASS2 (a
->cl
, b
->cl
))
673 case CLASS2 (rvc_zero
, rvc_zero
):
674 case CLASS2 (rvc_zero
, rvc_normal
):
675 case CLASS2 (rvc_normal
, rvc_zero
):
676 /* +-0 * ANY = 0 with appropriate sign. */
680 case CLASS2 (rvc_zero
, rvc_nan
):
681 case CLASS2 (rvc_normal
, rvc_nan
):
682 case CLASS2 (rvc_inf
, rvc_nan
):
683 case CLASS2 (rvc_nan
, rvc_nan
):
684 /* ANY * NaN = NaN. */
689 case CLASS2 (rvc_nan
, rvc_zero
):
690 case CLASS2 (rvc_nan
, rvc_normal
):
691 case CLASS2 (rvc_nan
, rvc_inf
):
692 /* NaN * ANY = NaN. */
697 case CLASS2 (rvc_zero
, rvc_inf
):
698 case CLASS2 (rvc_inf
, rvc_zero
):
700 get_canonical_qnan (r
, sign
);
703 case CLASS2 (rvc_inf
, rvc_inf
):
704 case CLASS2 (rvc_normal
, rvc_inf
):
705 case CLASS2 (rvc_inf
, rvc_normal
):
706 /* Inf * Inf = Inf, R * Inf = Inf */
710 case CLASS2 (rvc_normal
, rvc_normal
):
717 if (r
== a
|| r
== b
)
723 /* Collect all the partial products. Since we don't have sure access
724 to a widening multiply, we split each long into two half-words.
726 Consider the long-hand form of a four half-word multiplication:
736 We construct partial products of the widened half-word products
737 that are known to not overlap, e.g. DF+DH. Each such partial
738 product is given its proper exponent, which allows us to sum them
739 and obtain the finished product. */
741 for (i
= 0; i
< SIGSZ
* 2; ++i
)
743 unsigned long ai
= a
->sig
[i
/ 2];
745 ai
>>= HOST_BITS_PER_LONG
/ 2;
747 ai
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
752 for (j
= 0; j
< 2; ++j
)
754 int exp
= (REAL_EXP (a
) - (2*SIGSZ
-1-i
)*(HOST_BITS_PER_LONG
/2)
755 + (REAL_EXP (b
) - (1-j
)*(HOST_BITS_PER_LONG
/2)));
764 /* Would underflow to zero, which we shouldn't bother adding. */
769 memset (&u
, 0, sizeof (u
));
771 SET_REAL_EXP (&u
, exp
);
773 for (k
= j
; k
< SIGSZ
* 2; k
+= 2)
775 unsigned long bi
= b
->sig
[k
/ 2];
777 bi
>>= HOST_BITS_PER_LONG
/ 2;
779 bi
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
781 u
.sig
[k
/ 2] = ai
* bi
;
785 inexact
|= do_add (rr
, rr
, &u
, 0);
796 /* Calculate R = A / B. Return true if the result may be inexact. */
799 do_divide (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
800 const REAL_VALUE_TYPE
*b
)
802 int exp
, sign
= a
->sign
^ b
->sign
;
803 REAL_VALUE_TYPE t
, *rr
;
806 switch (CLASS2 (a
->cl
, b
->cl
))
808 case CLASS2 (rvc_zero
, rvc_zero
):
810 case CLASS2 (rvc_inf
, rvc_inf
):
811 /* Inf / Inf = NaN. */
812 get_canonical_qnan (r
, sign
);
815 case CLASS2 (rvc_zero
, rvc_normal
):
816 case CLASS2 (rvc_zero
, rvc_inf
):
818 case CLASS2 (rvc_normal
, rvc_inf
):
823 case CLASS2 (rvc_normal
, rvc_zero
):
825 case CLASS2 (rvc_inf
, rvc_zero
):
830 case CLASS2 (rvc_zero
, rvc_nan
):
831 case CLASS2 (rvc_normal
, rvc_nan
):
832 case CLASS2 (rvc_inf
, rvc_nan
):
833 case CLASS2 (rvc_nan
, rvc_nan
):
834 /* ANY / NaN = NaN. */
839 case CLASS2 (rvc_nan
, rvc_zero
):
840 case CLASS2 (rvc_nan
, rvc_normal
):
841 case CLASS2 (rvc_nan
, rvc_inf
):
842 /* NaN / ANY = NaN. */
847 case CLASS2 (rvc_inf
, rvc_normal
):
852 case CLASS2 (rvc_normal
, rvc_normal
):
859 if (r
== a
|| r
== b
)
864 /* Make sure all fields in the result are initialized. */
869 exp
= REAL_EXP (a
) - REAL_EXP (b
) + 1;
880 SET_REAL_EXP (rr
, exp
);
882 inexact
= div_significands (rr
, a
, b
);
884 /* Re-normalize the result. */
886 rr
->sig
[0] |= inexact
;
894 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
895 one of the two operands is a NaN. */
898 do_compare (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
,
903 switch (CLASS2 (a
->cl
, b
->cl
))
905 case CLASS2 (rvc_zero
, rvc_zero
):
906 /* Sign of zero doesn't matter for compares. */
909 case CLASS2 (rvc_inf
, rvc_zero
):
910 case CLASS2 (rvc_inf
, rvc_normal
):
911 case CLASS2 (rvc_normal
, rvc_zero
):
912 return (a
->sign
? -1 : 1);
914 case CLASS2 (rvc_inf
, rvc_inf
):
915 return -a
->sign
- -b
->sign
;
917 case CLASS2 (rvc_zero
, rvc_normal
):
918 case CLASS2 (rvc_zero
, rvc_inf
):
919 case CLASS2 (rvc_normal
, rvc_inf
):
920 return (b
->sign
? 1 : -1);
922 case CLASS2 (rvc_zero
, rvc_nan
):
923 case CLASS2 (rvc_normal
, rvc_nan
):
924 case CLASS2 (rvc_inf
, rvc_nan
):
925 case CLASS2 (rvc_nan
, rvc_nan
):
926 case CLASS2 (rvc_nan
, rvc_zero
):
927 case CLASS2 (rvc_nan
, rvc_normal
):
928 case CLASS2 (rvc_nan
, rvc_inf
):
931 case CLASS2 (rvc_normal
, rvc_normal
):
938 if (a
->sign
!= b
->sign
)
939 return -a
->sign
- -b
->sign
;
941 if (a
->decimal
|| b
->decimal
)
942 return decimal_do_compare (a
, b
, nan_result
);
944 if (REAL_EXP (a
) > REAL_EXP (b
))
946 else if (REAL_EXP (a
) < REAL_EXP (b
))
949 ret
= cmp_significands (a
, b
);
951 return (a
->sign
? -ret
: ret
);
954 /* Return A truncated to an integral value toward zero. */
957 do_fix_trunc (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
971 decimal_do_fix_trunc (r
, a
);
974 if (REAL_EXP (r
) <= 0)
975 get_zero (r
, r
->sign
);
976 else if (REAL_EXP (r
) < SIGNIFICAND_BITS
)
977 clear_significand_below (r
, SIGNIFICAND_BITS
- REAL_EXP (r
));
985 /* Perform the binary or unary operation described by CODE.
986 For a unary operation, leave OP1 NULL. This function returns
987 true if the result may be inexact due to loss of precision. */
990 real_arithmetic (REAL_VALUE_TYPE
*r
, int icode
, const REAL_VALUE_TYPE
*op0
,
991 const REAL_VALUE_TYPE
*op1
)
993 enum tree_code code
= icode
;
995 if (op0
->decimal
|| (op1
&& op1
->decimal
))
996 return decimal_real_arithmetic (r
, icode
, op0
, op1
);
1001 return do_add (r
, op0
, op1
, 0);
1004 return do_add (r
, op0
, op1
, 1);
1007 return do_multiply (r
, op0
, op1
);
1010 return do_divide (r
, op0
, op1
);
1013 if (op1
->cl
== rvc_nan
)
1015 else if (do_compare (op0
, op1
, -1) < 0)
1022 if (op1
->cl
== rvc_nan
)
1024 else if (do_compare (op0
, op1
, 1) < 0)
1040 case FIX_TRUNC_EXPR
:
1041 do_fix_trunc (r
, op0
);
1050 /* Legacy. Similar, but return the result directly. */
1053 real_arithmetic2 (int icode
, const REAL_VALUE_TYPE
*op0
,
1054 const REAL_VALUE_TYPE
*op1
)
1057 real_arithmetic (&r
, icode
, op0
, op1
);
1062 real_compare (int icode
, const REAL_VALUE_TYPE
*op0
,
1063 const REAL_VALUE_TYPE
*op1
)
1065 enum tree_code code
= icode
;
1070 return do_compare (op0
, op1
, 1) < 0;
1072 return do_compare (op0
, op1
, 1) <= 0;
1074 return do_compare (op0
, op1
, -1) > 0;
1076 return do_compare (op0
, op1
, -1) >= 0;
1078 return do_compare (op0
, op1
, -1) == 0;
1080 return do_compare (op0
, op1
, -1) != 0;
1081 case UNORDERED_EXPR
:
1082 return op0
->cl
== rvc_nan
|| op1
->cl
== rvc_nan
;
1084 return op0
->cl
!= rvc_nan
&& op1
->cl
!= rvc_nan
;
1086 return do_compare (op0
, op1
, -1) < 0;
1088 return do_compare (op0
, op1
, -1) <= 0;
1090 return do_compare (op0
, op1
, 1) > 0;
1092 return do_compare (op0
, op1
, 1) >= 0;
1094 return do_compare (op0
, op1
, 0) == 0;
1096 return do_compare (op0
, op1
, 0) != 0;
1103 /* Return floor log2(R). */
1106 real_exponent (const REAL_VALUE_TYPE
*r
)
1114 return (unsigned int)-1 >> 1;
1116 return REAL_EXP (r
);
1122 /* R = OP0 * 2**EXP. */
1125 real_ldexp (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*op0
, int exp
)
1136 exp
+= REAL_EXP (op0
);
1138 get_inf (r
, r
->sign
);
1139 else if (exp
< -MAX_EXP
)
1140 get_zero (r
, r
->sign
);
1142 SET_REAL_EXP (r
, exp
);
1150 /* Determine whether a floating-point value X is infinite. */
1153 real_isinf (const REAL_VALUE_TYPE
*r
)
1155 return (r
->cl
== rvc_inf
);
1158 /* Determine whether a floating-point value X is a NaN. */
1161 real_isnan (const REAL_VALUE_TYPE
*r
)
1163 return (r
->cl
== rvc_nan
);
1166 /* Determine whether a floating-point value X is finite. */
1169 real_isfinite (const REAL_VALUE_TYPE
*r
)
1171 return (r
->cl
!= rvc_nan
) && (r
->cl
!= rvc_inf
);
1174 /* Determine whether a floating-point value X is negative. */
1177 real_isneg (const REAL_VALUE_TYPE
*r
)
1182 /* Determine whether a floating-point value X is minus zero. */
1185 real_isnegzero (const REAL_VALUE_TYPE
*r
)
1187 return r
->sign
&& r
->cl
== rvc_zero
;
1190 /* Compare two floating-point objects for bitwise identity. */
1193 real_identical (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
1199 if (a
->sign
!= b
->sign
)
1209 if (a
->decimal
!= b
->decimal
)
1211 if (REAL_EXP (a
) != REAL_EXP (b
))
1216 if (a
->signalling
!= b
->signalling
)
1218 /* The significand is ignored for canonical NaNs. */
1219 if (a
->canonical
|| b
->canonical
)
1220 return a
->canonical
== b
->canonical
;
1227 for (i
= 0; i
< SIGSZ
; ++i
)
1228 if (a
->sig
[i
] != b
->sig
[i
])
1234 /* Try to change R into its exact multiplicative inverse in machine
1235 mode MODE. Return true if successful. */
1238 exact_real_inverse (enum machine_mode mode
, REAL_VALUE_TYPE
*r
)
1240 const REAL_VALUE_TYPE
*one
= real_digit (1);
1244 if (r
->cl
!= rvc_normal
)
1247 /* Check for a power of two: all significand bits zero except the MSB. */
1248 for (i
= 0; i
< SIGSZ
-1; ++i
)
1251 if (r
->sig
[SIGSZ
-1] != SIG_MSB
)
1254 /* Find the inverse and truncate to the required mode. */
1255 do_divide (&u
, one
, r
);
1256 real_convert (&u
, mode
, &u
);
1258 /* The rounding may have overflowed. */
1259 if (u
.cl
!= rvc_normal
)
1261 for (i
= 0; i
< SIGSZ
-1; ++i
)
1264 if (u
.sig
[SIGSZ
-1] != SIG_MSB
)
1271 /* Render R as an integer. */
1274 real_to_integer (const REAL_VALUE_TYPE
*r
)
1276 unsigned HOST_WIDE_INT i
;
1287 i
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1294 return decimal_real_to_integer (r
);
1296 if (REAL_EXP (r
) <= 0)
1298 /* Only force overflow for unsigned overflow. Signed overflow is
1299 undefined, so it doesn't matter what we return, and some callers
1300 expect to be able to use this routine for both signed and
1301 unsigned conversions. */
1302 if (REAL_EXP (r
) > HOST_BITS_PER_WIDE_INT
)
1305 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1306 i
= r
->sig
[SIGSZ
-1];
1309 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2 * HOST_BITS_PER_LONG
);
1310 i
= r
->sig
[SIGSZ
-1];
1311 i
= i
<< (HOST_BITS_PER_LONG
- 1) << 1;
1312 i
|= r
->sig
[SIGSZ
-2];
1315 i
>>= HOST_BITS_PER_WIDE_INT
- REAL_EXP (r
);
1326 /* Likewise, but to an integer pair, HI+LOW. */
1329 real_to_integer2 (HOST_WIDE_INT
*plow
, HOST_WIDE_INT
*phigh
,
1330 const REAL_VALUE_TYPE
*r
)
1333 HOST_WIDE_INT low
, high
;
1346 high
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1359 decimal_real_to_integer2 (plow
, phigh
, r
);
1366 /* Only force overflow for unsigned overflow. Signed overflow is
1367 undefined, so it doesn't matter what we return, and some callers
1368 expect to be able to use this routine for both signed and
1369 unsigned conversions. */
1370 if (exp
> 2*HOST_BITS_PER_WIDE_INT
)
1373 rshift_significand (&t
, r
, 2*HOST_BITS_PER_WIDE_INT
- exp
);
1374 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1376 high
= t
.sig
[SIGSZ
-1];
1377 low
= t
.sig
[SIGSZ
-2];
1381 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2*HOST_BITS_PER_LONG
);
1382 high
= t
.sig
[SIGSZ
-1];
1383 high
= high
<< (HOST_BITS_PER_LONG
- 1) << 1;
1384 high
|= t
.sig
[SIGSZ
-2];
1386 low
= t
.sig
[SIGSZ
-3];
1387 low
= low
<< (HOST_BITS_PER_LONG
- 1) << 1;
1388 low
|= t
.sig
[SIGSZ
-4];
1396 low
= -low
, high
= ~high
;
1408 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1409 of NUM / DEN. Return the quotient and place the remainder in NUM.
1410 It is expected that NUM / DEN are close enough that the quotient is
1413 static unsigned long
1414 rtd_divmod (REAL_VALUE_TYPE
*num
, REAL_VALUE_TYPE
*den
)
1416 unsigned long q
, msb
;
1417 int expn
= REAL_EXP (num
), expd
= REAL_EXP (den
);
1426 msb
= num
->sig
[SIGSZ
-1] & SIG_MSB
;
1428 lshift_significand_1 (num
, num
);
1430 if (msb
|| cmp_significands (num
, den
) >= 0)
1432 sub_significands (num
, num
, den
, 0);
1436 while (--expn
>= expd
);
1438 SET_REAL_EXP (num
, expd
);
1444 /* Render R as a decimal floating point constant. Emit DIGITS significant
1445 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1446 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1449 #define M_LOG10_2 0.30102999566398119521
1452 real_to_decimal (char *str
, const REAL_VALUE_TYPE
*r_orig
, size_t buf_size
,
1453 size_t digits
, int crop_trailing_zeros
)
1455 const REAL_VALUE_TYPE
*one
, *ten
;
1456 REAL_VALUE_TYPE r
, pten
, u
, v
;
1457 int dec_exp
, cmp_one
, digit
;
1459 char *p
, *first
, *last
;
1466 strcpy (str
, (r
.sign
? "-0.0" : "0.0"));
1471 strcpy (str
, (r
.sign
? "-Inf" : "+Inf"));
1474 /* ??? Print the significand as well, if not canonical? */
1475 strcpy (str
, (r
.sign
? "-NaN" : "+NaN"));
1483 decimal_real_to_decimal (str
, &r
, buf_size
, digits
, crop_trailing_zeros
);
1487 /* Bound the number of digits printed by the size of the representation. */
1488 max_digits
= SIGNIFICAND_BITS
* M_LOG10_2
;
1489 if (digits
== 0 || digits
> max_digits
)
1490 digits
= max_digits
;
1492 /* Estimate the decimal exponent, and compute the length of the string it
1493 will print as. Be conservative and add one to account for possible
1494 overflow or rounding error. */
1495 dec_exp
= REAL_EXP (&r
) * M_LOG10_2
;
1496 for (max_digits
= 1; dec_exp
; max_digits
++)
1499 /* Bound the number of digits printed by the size of the output buffer. */
1500 max_digits
= buf_size
- 1 - 1 - 2 - max_digits
- 1;
1501 gcc_assert (max_digits
<= buf_size
);
1502 if (digits
> max_digits
)
1503 digits
= max_digits
;
1505 one
= real_digit (1);
1506 ten
= ten_to_ptwo (0);
1514 cmp_one
= do_compare (&r
, one
, 0);
1519 /* Number is greater than one. Convert significand to an integer
1520 and strip trailing decimal zeros. */
1523 SET_REAL_EXP (&u
, SIGNIFICAND_BITS
- 1);
1525 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1526 m
= floor_log2 (max_digits
);
1528 /* Iterate over the bits of the possible powers of 10 that might
1529 be present in U and eliminate them. That is, if we find that
1530 10**2**M divides U evenly, keep the division and increase
1536 do_divide (&t
, &u
, ten_to_ptwo (m
));
1537 do_fix_trunc (&v
, &t
);
1538 if (cmp_significands (&v
, &t
) == 0)
1546 /* Revert the scaling to integer that we performed earlier. */
1547 SET_REAL_EXP (&u
, REAL_EXP (&u
) + REAL_EXP (&r
)
1548 - (SIGNIFICAND_BITS
- 1));
1551 /* Find power of 10. Do this by dividing out 10**2**M when
1552 this is larger than the current remainder. Fill PTEN with
1553 the power of 10 that we compute. */
1554 if (REAL_EXP (&r
) > 0)
1556 m
= floor_log2 ((int)(REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1559 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1560 if (do_compare (&u
, ptentwo
, 0) >= 0)
1562 do_divide (&u
, &u
, ptentwo
);
1563 do_multiply (&pten
, &pten
, ptentwo
);
1570 /* We managed to divide off enough tens in the above reduction
1571 loop that we've now got a negative exponent. Fall into the
1572 less-than-one code to compute the proper value for PTEN. */
1579 /* Number is less than one. Pad significand with leading
1585 /* Stop if we'd shift bits off the bottom. */
1589 do_multiply (&u
, &v
, ten
);
1591 /* Stop if we're now >= 1. */
1592 if (REAL_EXP (&u
) > 0)
1600 /* Find power of 10. Do this by multiplying in P=10**2**M when
1601 the current remainder is smaller than 1/P. Fill PTEN with the
1602 power of 10 that we compute. */
1603 m
= floor_log2 ((int)(-REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1606 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1607 const REAL_VALUE_TYPE
*ptenmtwo
= ten_to_mptwo (m
);
1609 if (do_compare (&v
, ptenmtwo
, 0) <= 0)
1611 do_multiply (&v
, &v
, ptentwo
);
1612 do_multiply (&pten
, &pten
, ptentwo
);
1618 /* Invert the positive power of 10 that we've collected so far. */
1619 do_divide (&pten
, one
, &pten
);
1627 /* At this point, PTEN should contain the nearest power of 10 smaller
1628 than R, such that this division produces the first digit.
1630 Using a divide-step primitive that returns the complete integral
1631 remainder avoids the rounding error that would be produced if
1632 we were to use do_divide here and then simply multiply by 10 for
1633 each subsequent digit. */
1635 digit
= rtd_divmod (&r
, &pten
);
1637 /* Be prepared for error in that division via underflow ... */
1638 if (digit
== 0 && cmp_significand_0 (&r
))
1640 /* Multiply by 10 and try again. */
1641 do_multiply (&r
, &r
, ten
);
1642 digit
= rtd_divmod (&r
, &pten
);
1644 gcc_assert (digit
!= 0);
1647 /* ... or overflow. */
1657 gcc_assert (digit
<= 10);
1661 /* Generate subsequent digits. */
1662 while (--digits
> 0)
1664 do_multiply (&r
, &r
, ten
);
1665 digit
= rtd_divmod (&r
, &pten
);
1670 /* Generate one more digit with which to do rounding. */
1671 do_multiply (&r
, &r
, ten
);
1672 digit
= rtd_divmod (&r
, &pten
);
1674 /* Round the result. */
1677 /* Round to nearest. If R is nonzero there are additional
1678 nonzero digits to be extracted. */
1679 if (cmp_significand_0 (&r
))
1681 /* Round to even. */
1682 else if ((p
[-1] - '0') & 1)
1699 /* Carry out of the first digit. This means we had all 9's and
1700 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1708 /* Insert the decimal point. */
1709 first
[0] = first
[1];
1712 /* If requested, drop trailing zeros. Never crop past "1.0". */
1713 if (crop_trailing_zeros
)
1714 while (last
> first
+ 3 && last
[-1] == '0')
1717 /* Append the exponent. */
1718 sprintf (last
, "e%+d", dec_exp
);
1721 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1722 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1723 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1724 strip trailing zeros. */
1727 real_to_hexadecimal (char *str
, const REAL_VALUE_TYPE
*r
, size_t buf_size
,
1728 size_t digits
, int crop_trailing_zeros
)
1730 int i
, j
, exp
= REAL_EXP (r
);
1743 strcpy (str
, (r
->sign
? "-Inf" : "+Inf"));
1746 /* ??? Print the significand as well, if not canonical? */
1747 strcpy (str
, (r
->sign
? "-NaN" : "+NaN"));
1755 /* Hexadecimal format for decimal floats is not interesting. */
1756 strcpy (str
, "N/A");
1761 digits
= SIGNIFICAND_BITS
/ 4;
1763 /* Bound the number of digits printed by the size of the output buffer. */
1765 sprintf (exp_buf
, "p%+d", exp
);
1766 max_digits
= buf_size
- strlen (exp_buf
) - r
->sign
- 4 - 1;
1767 gcc_assert (max_digits
<= buf_size
);
1768 if (digits
> max_digits
)
1769 digits
= max_digits
;
1780 for (i
= SIGSZ
- 1; i
>= 0; --i
)
1781 for (j
= HOST_BITS_PER_LONG
- 4; j
>= 0; j
-= 4)
1783 *p
++ = "0123456789abcdef"[(r
->sig
[i
] >> j
) & 15];
1789 if (crop_trailing_zeros
)
1790 while (p
> first
+ 1 && p
[-1] == '0')
1793 sprintf (p
, "p%+d", exp
);
1796 /* Initialize R from a decimal or hexadecimal string. The string is
1797 assumed to have been syntax checked already. Return -1 if the
1798 value underflows, +1 if overflows, and 0 otherwise. */
1801 real_from_string (REAL_VALUE_TYPE
*r
, const char *str
)
1813 else if (*str
== '+')
1816 if (str
[0] == '0' && (str
[1] == 'x' || str
[1] == 'X'))
1818 /* Hexadecimal floating point. */
1819 int pos
= SIGNIFICAND_BITS
- 4, d
;
1827 d
= hex_value (*str
);
1832 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1833 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1837 /* Ensure correct rounding by setting last bit if there is
1838 a subsequent nonzero digit. */
1846 if (pos
== SIGNIFICAND_BITS
- 4)
1853 d
= hex_value (*str
);
1858 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1859 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1863 /* Ensure correct rounding by setting last bit if there is
1864 a subsequent nonzero digit. */
1870 /* If the mantissa is zero, ignore the exponent. */
1871 if (!cmp_significand_0 (r
))
1874 if (*str
== 'p' || *str
== 'P')
1876 bool exp_neg
= false;
1884 else if (*str
== '+')
1888 while (ISDIGIT (*str
))
1894 /* Overflowed the exponent. */
1909 SET_REAL_EXP (r
, exp
);
1915 /* Decimal floating point. */
1916 const REAL_VALUE_TYPE
*ten
= ten_to_ptwo (0);
1921 while (ISDIGIT (*str
))
1924 do_multiply (r
, r
, ten
);
1926 do_add (r
, r
, real_digit (d
), 0);
1931 if (r
->cl
== rvc_zero
)
1936 while (ISDIGIT (*str
))
1939 do_multiply (r
, r
, ten
);
1941 do_add (r
, r
, real_digit (d
), 0);
1946 /* If the mantissa is zero, ignore the exponent. */
1947 if (r
->cl
== rvc_zero
)
1950 if (*str
== 'e' || *str
== 'E')
1952 bool exp_neg
= false;
1960 else if (*str
== '+')
1964 while (ISDIGIT (*str
))
1970 /* Overflowed the exponent. */
1984 times_pten (r
, exp
);
2003 /* Legacy. Similar, but return the result directly. */
2006 real_from_string2 (const char *s
, enum machine_mode mode
)
2010 real_from_string (&r
, s
);
2011 if (mode
!= VOIDmode
)
2012 real_convert (&r
, mode
, &r
);
2017 /* Initialize R from string S and desired MODE. */
2020 real_from_string3 (REAL_VALUE_TYPE
*r
, const char *s
, enum machine_mode mode
)
2022 if (DECIMAL_FLOAT_MODE_P (mode
))
2023 decimal_real_from_string (r
, s
);
2025 real_from_string (r
, s
);
2027 if (mode
!= VOIDmode
)
2028 real_convert (r
, mode
, r
);
2031 /* Initialize R from the integer pair HIGH+LOW. */
2034 real_from_integer (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
2035 unsigned HOST_WIDE_INT low
, HOST_WIDE_INT high
,
2038 if (low
== 0 && high
== 0)
2042 memset (r
, 0, sizeof (*r
));
2044 r
->sign
= high
< 0 && !unsigned_p
;
2045 SET_REAL_EXP (r
, 2 * HOST_BITS_PER_WIDE_INT
);
2056 if (HOST_BITS_PER_LONG
== HOST_BITS_PER_WIDE_INT
)
2058 r
->sig
[SIGSZ
-1] = high
;
2059 r
->sig
[SIGSZ
-2] = low
;
2063 gcc_assert (HOST_BITS_PER_LONG
*2 == HOST_BITS_PER_WIDE_INT
);
2064 r
->sig
[SIGSZ
-1] = high
>> (HOST_BITS_PER_LONG
- 1) >> 1;
2065 r
->sig
[SIGSZ
-2] = high
;
2066 r
->sig
[SIGSZ
-3] = low
>> (HOST_BITS_PER_LONG
- 1) >> 1;
2067 r
->sig
[SIGSZ
-4] = low
;
2073 if (mode
!= VOIDmode
)
2074 real_convert (r
, mode
, r
);
2077 /* Returns 10**2**N. */
2079 static const REAL_VALUE_TYPE
*
2082 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2084 gcc_assert (n
>= 0);
2085 gcc_assert (n
< EXP_BITS
);
2087 if (tens
[n
].cl
== rvc_zero
)
2089 if (n
< (HOST_BITS_PER_WIDE_INT
== 64 ? 5 : 4))
2091 HOST_WIDE_INT t
= 10;
2094 for (i
= 0; i
< n
; ++i
)
2097 real_from_integer (&tens
[n
], VOIDmode
, t
, 0, 1);
2101 const REAL_VALUE_TYPE
*t
= ten_to_ptwo (n
- 1);
2102 do_multiply (&tens
[n
], t
, t
);
2109 /* Returns 10**(-2**N). */
2111 static const REAL_VALUE_TYPE
*
2112 ten_to_mptwo (int n
)
2114 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2116 gcc_assert (n
>= 0);
2117 gcc_assert (n
< EXP_BITS
);
2119 if (tens
[n
].cl
== rvc_zero
)
2120 do_divide (&tens
[n
], real_digit (1), ten_to_ptwo (n
));
2127 static const REAL_VALUE_TYPE
*
2130 static REAL_VALUE_TYPE num
[10];
2132 gcc_assert (n
>= 0);
2133 gcc_assert (n
<= 9);
2135 if (n
> 0 && num
[n
].cl
== rvc_zero
)
2136 real_from_integer (&num
[n
], VOIDmode
, n
, 0, 1);
2141 /* Multiply R by 10**EXP. */
2144 times_pten (REAL_VALUE_TYPE
*r
, int exp
)
2146 REAL_VALUE_TYPE pten
, *rr
;
2147 bool negative
= (exp
< 0);
2153 pten
= *real_digit (1);
2159 for (i
= 0; exp
> 0; ++i
, exp
>>= 1)
2161 do_multiply (rr
, rr
, ten_to_ptwo (i
));
2164 do_divide (r
, r
, &pten
);
2167 /* Fills R with +Inf. */
2170 real_inf (REAL_VALUE_TYPE
*r
)
2175 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2176 we force a QNaN, else we force an SNaN. The string, if not empty,
2177 is parsed as a number and placed in the significand. Return true
2178 if the string was successfully parsed. */
2181 real_nan (REAL_VALUE_TYPE
*r
, const char *str
, int quiet
,
2182 enum machine_mode mode
)
2184 const struct real_format
*fmt
;
2186 fmt
= REAL_MODE_FORMAT (mode
);
2192 get_canonical_qnan (r
, 0);
2194 get_canonical_snan (r
, 0);
2200 memset (r
, 0, sizeof (*r
));
2203 /* Parse akin to strtol into the significand of R. */
2205 while (ISSPACE (*str
))
2209 else if (*str
== '+')
2214 if (*str
== 'x' || *str
== 'X')
2223 while ((d
= hex_value (*str
)) < base
)
2230 lshift_significand (r
, r
, 3);
2233 lshift_significand (r
, r
, 4);
2236 lshift_significand_1 (&u
, r
);
2237 lshift_significand (r
, r
, 3);
2238 add_significands (r
, r
, &u
);
2246 add_significands (r
, r
, &u
);
2251 /* Must have consumed the entire string for success. */
2255 /* Shift the significand into place such that the bits
2256 are in the most significant bits for the format. */
2257 lshift_significand (r
, r
, SIGNIFICAND_BITS
- fmt
->pnan
);
2259 /* Our MSB is always unset for NaNs. */
2260 r
->sig
[SIGSZ
-1] &= ~SIG_MSB
;
2262 /* Force quiet or signalling NaN. */
2263 r
->signalling
= !quiet
;
2269 /* Fills R with the largest finite value representable in mode MODE.
2270 If SIGN is nonzero, R is set to the most negative finite value. */
2273 real_maxval (REAL_VALUE_TYPE
*r
, int sign
, enum machine_mode mode
)
2275 const struct real_format
*fmt
;
2278 fmt
= REAL_MODE_FORMAT (mode
);
2280 memset (r
, 0, sizeof (*r
));
2283 decimal_real_maxval (r
, sign
, mode
);
2288 SET_REAL_EXP (r
, fmt
->emax
);
2290 np2
= SIGNIFICAND_BITS
- fmt
->p
;
2291 memset (r
->sig
, -1, SIGSZ
* sizeof (unsigned long));
2292 clear_significand_below (r
, np2
);
2294 if (fmt
->pnan
< fmt
->p
)
2295 /* This is an IBM extended double format made up of two IEEE
2296 doubles. The value of the long double is the sum of the
2297 values of the two parts. The most significant part is
2298 required to be the value of the long double rounded to the
2299 nearest double. Rounding means we need a slightly smaller
2300 value for LDBL_MAX. */
2301 clear_significand_bit (r
, SIGNIFICAND_BITS
- fmt
->pnan
);
2305 /* Fills R with 2**N. */
2308 real_2expN (REAL_VALUE_TYPE
*r
, int n
)
2310 memset (r
, 0, sizeof (*r
));
2315 else if (n
< -MAX_EXP
)
2320 SET_REAL_EXP (r
, n
);
2321 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2327 round_for_format (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
)
2330 unsigned long sticky
;
2338 decimal_round_for_format (fmt
, r
);
2341 /* FIXME. We can come here via fp_easy_constant
2342 (e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
2343 investigated whether this convert needs to be here, or
2344 something else is missing. */
2345 decimal_real_convert (r
, DFmode
, r
);
2349 emin2m1
= fmt
->emin
- 1;
2352 np2
= SIGNIFICAND_BITS
- p2
;
2356 get_zero (r
, r
->sign
);
2358 if (!fmt
->has_signed_zero
)
2363 get_inf (r
, r
->sign
);
2368 clear_significand_below (r
, np2
);
2378 /* Check the range of the exponent. If we're out of range,
2379 either underflow or overflow. */
2380 if (REAL_EXP (r
) > emax2
)
2382 else if (REAL_EXP (r
) <= emin2m1
)
2386 if (!fmt
->has_denorm
)
2388 /* Don't underflow completely until we've had a chance to round. */
2389 if (REAL_EXP (r
) < emin2m1
)
2394 diff
= emin2m1
- REAL_EXP (r
) + 1;
2398 /* De-normalize the significand. */
2399 r
->sig
[0] |= sticky_rshift_significand (r
, r
, diff
);
2400 SET_REAL_EXP (r
, REAL_EXP (r
) + diff
);
2404 /* There are P2 true significand bits, followed by one guard bit,
2405 followed by one sticky bit, followed by stuff. Fold nonzero
2406 stuff into the sticky bit. */
2409 for (i
= 0, w
= (np2
- 1) / HOST_BITS_PER_LONG
; i
< w
; ++i
)
2410 sticky
|= r
->sig
[i
];
2412 r
->sig
[w
] & (((unsigned long)1 << ((np2
- 1) % HOST_BITS_PER_LONG
)) - 1);
2414 guard
= test_significand_bit (r
, np2
- 1);
2415 lsb
= test_significand_bit (r
, np2
);
2417 /* Round to even. */
2418 if (guard
&& (sticky
|| lsb
))
2422 set_significand_bit (&u
, np2
);
2424 if (add_significands (r
, r
, &u
))
2426 /* Overflow. Means the significand had been all ones, and
2427 is now all zeros. Need to increase the exponent, and
2428 possibly re-normalize it. */
2429 SET_REAL_EXP (r
, REAL_EXP (r
) + 1);
2430 if (REAL_EXP (r
) > emax2
)
2432 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2436 /* Catch underflow that we deferred until after rounding. */
2437 if (REAL_EXP (r
) <= emin2m1
)
2440 /* Clear out trailing garbage. */
2441 clear_significand_below (r
, np2
);
2444 /* Extend or truncate to a new mode. */
2447 real_convert (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
2448 const REAL_VALUE_TYPE
*a
)
2450 const struct real_format
*fmt
;
2452 fmt
= REAL_MODE_FORMAT (mode
);
2457 if (a
->decimal
|| fmt
->b
== 10)
2458 decimal_real_convert (r
, mode
, a
);
2460 round_for_format (fmt
, r
);
2462 /* round_for_format de-normalizes denormals. Undo just that part. */
2463 if (r
->cl
== rvc_normal
)
2467 /* Legacy. Likewise, except return the struct directly. */
2470 real_value_truncate (enum machine_mode mode
, REAL_VALUE_TYPE a
)
2473 real_convert (&r
, mode
, &a
);
2477 /* Return true if truncating to MODE is exact. */
2480 exact_real_truncate (enum machine_mode mode
, const REAL_VALUE_TYPE
*a
)
2482 const struct real_format
*fmt
;
2486 fmt
= REAL_MODE_FORMAT (mode
);
2489 /* Don't allow conversion to denormals. */
2490 emin2m1
= fmt
->emin
- 1;
2491 if (REAL_EXP (a
) <= emin2m1
)
2494 /* After conversion to the new mode, the value must be identical. */
2495 real_convert (&t
, mode
, a
);
2496 return real_identical (&t
, a
);
2499 /* Write R to the given target format. Place the words of the result
2500 in target word order in BUF. There are always 32 bits in each
2501 long, no matter the size of the host long.
2503 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2506 real_to_target_fmt (long *buf
, const REAL_VALUE_TYPE
*r_orig
,
2507 const struct real_format
*fmt
)
2513 round_for_format (fmt
, &r
);
2517 (*fmt
->encode
) (fmt
, buf
, &r
);
2522 /* Similar, but look up the format from MODE. */
2525 real_to_target (long *buf
, const REAL_VALUE_TYPE
*r
, enum machine_mode mode
)
2527 const struct real_format
*fmt
;
2529 fmt
= REAL_MODE_FORMAT (mode
);
2532 return real_to_target_fmt (buf
, r
, fmt
);
2535 /* Read R from the given target format. Read the words of the result
2536 in target word order in BUF. There are always 32 bits in each
2537 long, no matter the size of the host long. */
2540 real_from_target_fmt (REAL_VALUE_TYPE
*r
, const long *buf
,
2541 const struct real_format
*fmt
)
2543 (*fmt
->decode
) (fmt
, r
, buf
);
2546 /* Similar, but look up the format from MODE. */
2549 real_from_target (REAL_VALUE_TYPE
*r
, const long *buf
, enum machine_mode mode
)
2551 const struct real_format
*fmt
;
2553 fmt
= REAL_MODE_FORMAT (mode
);
2556 (*fmt
->decode
) (fmt
, r
, buf
);
2559 /* Return the number of bits of the largest binary value that the
2560 significand of MODE will hold. */
2561 /* ??? Legacy. Should get access to real_format directly. */
2564 significand_size (enum machine_mode mode
)
2566 const struct real_format
*fmt
;
2568 fmt
= REAL_MODE_FORMAT (mode
);
2574 /* Return the size in bits of the largest binary value that can be
2575 held by the decimal coefficient for this mode. This is one more
2576 than the number of bits required to hold the largest coefficient
2578 double log2_10
= 3.3219281;
2579 return fmt
->p
* log2_10
;
2584 /* Return a hash value for the given real value. */
2585 /* ??? The "unsigned int" return value is intended to be hashval_t,
2586 but I didn't want to pull hashtab.h into real.h. */
2589 real_hash (const REAL_VALUE_TYPE
*r
)
2594 h
= r
->cl
| (r
->sign
<< 2);
2602 h
|= REAL_EXP (r
) << 3;
2607 h
^= (unsigned int)-1;
2616 if (sizeof(unsigned long) > sizeof(unsigned int))
2617 for (i
= 0; i
< SIGSZ
; ++i
)
2619 unsigned long s
= r
->sig
[i
];
2620 h
^= s
^ (s
>> (HOST_BITS_PER_LONG
/ 2));
2623 for (i
= 0; i
< SIGSZ
; ++i
)
2629 /* IEEE single-precision format. */
2631 static void encode_ieee_single (const struct real_format
*fmt
,
2632 long *, const REAL_VALUE_TYPE
*);
2633 static void decode_ieee_single (const struct real_format
*,
2634 REAL_VALUE_TYPE
*, const long *);
2637 encode_ieee_single (const struct real_format
*fmt
, long *buf
,
2638 const REAL_VALUE_TYPE
*r
)
2640 unsigned long image
, sig
, exp
;
2641 unsigned long sign
= r
->sign
;
2642 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2645 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
2656 image
|= 0x7fffffff;
2663 sig
= (fmt
->canonical_nan_lsbs_set
? (1 << 22) - 1 : 0);
2664 if (r
->signalling
== fmt
->qnan_msb_set
)
2675 image
|= 0x7fffffff;
2679 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2680 whereas the intermediate representation is 0.F x 2**exp.
2681 Which means we're off by one. */
2685 exp
= REAL_EXP (r
) + 127 - 1;
2698 decode_ieee_single (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
2701 unsigned long image
= buf
[0] & 0xffffffff;
2702 bool sign
= (image
>> 31) & 1;
2703 int exp
= (image
>> 23) & 0xff;
2705 memset (r
, 0, sizeof (*r
));
2706 image
<<= HOST_BITS_PER_LONG
- 24;
2711 if (image
&& fmt
->has_denorm
)
2715 SET_REAL_EXP (r
, -126);
2716 r
->sig
[SIGSZ
-1] = image
<< 1;
2719 else if (fmt
->has_signed_zero
)
2722 else if (exp
== 255 && (fmt
->has_nans
|| fmt
->has_inf
))
2728 r
->signalling
= (((image
>> (HOST_BITS_PER_LONG
- 2)) & 1)
2729 ^ fmt
->qnan_msb_set
);
2730 r
->sig
[SIGSZ
-1] = image
;
2742 SET_REAL_EXP (r
, exp
- 127 + 1);
2743 r
->sig
[SIGSZ
-1] = image
| SIG_MSB
;
2747 const struct real_format ieee_single_format
=
2766 const struct real_format mips_single_format
=
2785 const struct real_format motorola_single_format
=
2804 /* IEEE double-precision format. */
2806 static void encode_ieee_double (const struct real_format
*fmt
,
2807 long *, const REAL_VALUE_TYPE
*);
2808 static void decode_ieee_double (const struct real_format
*,
2809 REAL_VALUE_TYPE
*, const long *);
2812 encode_ieee_double (const struct real_format
*fmt
, long *buf
,
2813 const REAL_VALUE_TYPE
*r
)
2815 unsigned long image_lo
, image_hi
, sig_lo
, sig_hi
, exp
;
2816 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2818 image_hi
= r
->sign
<< 31;
2821 if (HOST_BITS_PER_LONG
== 64)
2823 sig_hi
= r
->sig
[SIGSZ
-1];
2824 sig_lo
= (sig_hi
>> (64 - 53)) & 0xffffffff;
2825 sig_hi
= (sig_hi
>> (64 - 53 + 1) >> 31) & 0xfffff;
2829 sig_hi
= r
->sig
[SIGSZ
-1];
2830 sig_lo
= r
->sig
[SIGSZ
-2];
2831 sig_lo
= (sig_hi
<< 21) | (sig_lo
>> 11);
2832 sig_hi
= (sig_hi
>> 11) & 0xfffff;
2842 image_hi
|= 2047 << 20;
2845 image_hi
|= 0x7fffffff;
2846 image_lo
= 0xffffffff;
2855 if (fmt
->canonical_nan_lsbs_set
)
2857 sig_hi
= (1 << 19) - 1;
2858 sig_lo
= 0xffffffff;
2866 if (r
->signalling
== fmt
->qnan_msb_set
)
2867 sig_hi
&= ~(1 << 19);
2870 if (sig_hi
== 0 && sig_lo
== 0)
2873 image_hi
|= 2047 << 20;
2879 image_hi
|= 0x7fffffff;
2880 image_lo
= 0xffffffff;
2885 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2886 whereas the intermediate representation is 0.F x 2**exp.
2887 Which means we're off by one. */
2891 exp
= REAL_EXP (r
) + 1023 - 1;
2892 image_hi
|= exp
<< 20;
2901 if (FLOAT_WORDS_BIG_ENDIAN
)
2902 buf
[0] = image_hi
, buf
[1] = image_lo
;
2904 buf
[0] = image_lo
, buf
[1] = image_hi
;
2908 decode_ieee_double (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
2911 unsigned long image_hi
, image_lo
;
2915 if (FLOAT_WORDS_BIG_ENDIAN
)
2916 image_hi
= buf
[0], image_lo
= buf
[1];
2918 image_lo
= buf
[0], image_hi
= buf
[1];
2919 image_lo
&= 0xffffffff;
2920 image_hi
&= 0xffffffff;
2922 sign
= (image_hi
>> 31) & 1;
2923 exp
= (image_hi
>> 20) & 0x7ff;
2925 memset (r
, 0, sizeof (*r
));
2927 image_hi
<<= 32 - 21;
2928 image_hi
|= image_lo
>> 21;
2929 image_hi
&= 0x7fffffff;
2930 image_lo
<<= 32 - 21;
2934 if ((image_hi
|| image_lo
) && fmt
->has_denorm
)
2938 SET_REAL_EXP (r
, -1022);
2939 if (HOST_BITS_PER_LONG
== 32)
2941 image_hi
= (image_hi
<< 1) | (image_lo
>> 31);
2943 r
->sig
[SIGSZ
-1] = image_hi
;
2944 r
->sig
[SIGSZ
-2] = image_lo
;
2948 image_hi
= (image_hi
<< 31 << 2) | (image_lo
<< 1);
2949 r
->sig
[SIGSZ
-1] = image_hi
;
2953 else if (fmt
->has_signed_zero
)
2956 else if (exp
== 2047 && (fmt
->has_nans
|| fmt
->has_inf
))
2958 if (image_hi
|| image_lo
)
2962 r
->signalling
= ((image_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
2963 if (HOST_BITS_PER_LONG
== 32)
2965 r
->sig
[SIGSZ
-1] = image_hi
;
2966 r
->sig
[SIGSZ
-2] = image_lo
;
2969 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
;
2981 SET_REAL_EXP (r
, exp
- 1023 + 1);
2982 if (HOST_BITS_PER_LONG
== 32)
2984 r
->sig
[SIGSZ
-1] = image_hi
| SIG_MSB
;
2985 r
->sig
[SIGSZ
-2] = image_lo
;
2988 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
| SIG_MSB
;
2992 const struct real_format ieee_double_format
=
3011 const struct real_format mips_double_format
=
3030 const struct real_format motorola_double_format
=
3049 /* IEEE extended real format. This comes in three flavors: Intel's as
3050 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
3051 12- and 16-byte images may be big- or little endian; Motorola's is
3052 always big endian. */
3054 /* Helper subroutine which converts from the internal format to the
3055 12-byte little-endian Intel format. Functions below adjust this
3056 for the other possible formats. */
3058 encode_ieee_extended (const struct real_format
*fmt
, long *buf
,
3059 const REAL_VALUE_TYPE
*r
)
3061 unsigned long image_hi
, sig_hi
, sig_lo
;
3062 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3064 image_hi
= r
->sign
<< 15;
3065 sig_hi
= sig_lo
= 0;
3077 /* Intel requires the explicit integer bit to be set, otherwise
3078 it considers the value a "pseudo-infinity". Motorola docs
3079 say it doesn't care. */
3080 sig_hi
= 0x80000000;
3085 sig_lo
= sig_hi
= 0xffffffff;
3095 if (fmt
->canonical_nan_lsbs_set
)
3097 sig_hi
= (1 << 30) - 1;
3098 sig_lo
= 0xffffffff;
3101 else if (HOST_BITS_PER_LONG
== 32)
3103 sig_hi
= r
->sig
[SIGSZ
-1];
3104 sig_lo
= r
->sig
[SIGSZ
-2];
3108 sig_lo
= r
->sig
[SIGSZ
-1];
3109 sig_hi
= sig_lo
>> 31 >> 1;
3110 sig_lo
&= 0xffffffff;
3112 if (r
->signalling
== fmt
->qnan_msb_set
)
3113 sig_hi
&= ~(1 << 30);
3116 if ((sig_hi
& 0x7fffffff) == 0 && sig_lo
== 0)
3119 /* Intel requires the explicit integer bit to be set, otherwise
3120 it considers the value a "pseudo-nan". Motorola docs say it
3122 sig_hi
|= 0x80000000;
3127 sig_lo
= sig_hi
= 0xffffffff;
3133 int exp
= REAL_EXP (r
);
3135 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3136 whereas the intermediate representation is 0.F x 2**exp.
3137 Which means we're off by one.
3139 Except for Motorola, which consider exp=0 and explicit
3140 integer bit set to continue to be normalized. In theory
3141 this discrepancy has been taken care of by the difference
3142 in fmt->emin in round_for_format. */
3149 gcc_assert (exp
>= 0);
3153 if (HOST_BITS_PER_LONG
== 32)
3155 sig_hi
= r
->sig
[SIGSZ
-1];
3156 sig_lo
= r
->sig
[SIGSZ
-2];
3160 sig_lo
= r
->sig
[SIGSZ
-1];
3161 sig_hi
= sig_lo
>> 31 >> 1;
3162 sig_lo
&= 0xffffffff;
3171 buf
[0] = sig_lo
, buf
[1] = sig_hi
, buf
[2] = image_hi
;
3174 /* Convert from the internal format to the 12-byte Motorola format
3175 for an IEEE extended real. */
3177 encode_ieee_extended_motorola (const struct real_format
*fmt
, long *buf
,
3178 const REAL_VALUE_TYPE
*r
)
3181 encode_ieee_extended (fmt
, intermed
, r
);
3183 /* Motorola chips are assumed always to be big-endian. Also, the
3184 padding in a Motorola extended real goes between the exponent and
3185 the mantissa. At this point the mantissa is entirely within
3186 elements 0 and 1 of intermed, and the exponent entirely within
3187 element 2, so all we have to do is swap the order around, and
3188 shift element 2 left 16 bits. */
3189 buf
[0] = intermed
[2] << 16;
3190 buf
[1] = intermed
[1];
3191 buf
[2] = intermed
[0];
3194 /* Convert from the internal format to the 12-byte Intel format for
3195 an IEEE extended real. */
3197 encode_ieee_extended_intel_96 (const struct real_format
*fmt
, long *buf
,
3198 const REAL_VALUE_TYPE
*r
)
3200 if (FLOAT_WORDS_BIG_ENDIAN
)
3202 /* All the padding in an Intel-format extended real goes at the high
3203 end, which in this case is after the mantissa, not the exponent.
3204 Therefore we must shift everything down 16 bits. */
3206 encode_ieee_extended (fmt
, intermed
, r
);
3207 buf
[0] = ((intermed
[2] << 16) | ((unsigned long)(intermed
[1] & 0xFFFF0000) >> 16));
3208 buf
[1] = ((intermed
[1] << 16) | ((unsigned long)(intermed
[0] & 0xFFFF0000) >> 16));
3209 buf
[2] = (intermed
[0] << 16);
3212 /* encode_ieee_extended produces what we want directly. */
3213 encode_ieee_extended (fmt
, buf
, r
);
3216 /* Convert from the internal format to the 16-byte Intel format for
3217 an IEEE extended real. */
3219 encode_ieee_extended_intel_128 (const struct real_format
*fmt
, long *buf
,
3220 const REAL_VALUE_TYPE
*r
)
3222 /* All the padding in an Intel-format extended real goes at the high end. */
3223 encode_ieee_extended_intel_96 (fmt
, buf
, r
);
3227 /* As above, we have a helper function which converts from 12-byte
3228 little-endian Intel format to internal format. Functions below
3229 adjust for the other possible formats. */
3231 decode_ieee_extended (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3234 unsigned long image_hi
, sig_hi
, sig_lo
;
3238 sig_lo
= buf
[0], sig_hi
= buf
[1], image_hi
= buf
[2];
3239 sig_lo
&= 0xffffffff;
3240 sig_hi
&= 0xffffffff;
3241 image_hi
&= 0xffffffff;
3243 sign
= (image_hi
>> 15) & 1;
3244 exp
= image_hi
& 0x7fff;
3246 memset (r
, 0, sizeof (*r
));
3250 if ((sig_hi
|| sig_lo
) && fmt
->has_denorm
)
3255 /* When the IEEE format contains a hidden bit, we know that
3256 it's zero at this point, and so shift up the significand
3257 and decrease the exponent to match. In this case, Motorola
3258 defines the explicit integer bit to be valid, so we don't
3259 know whether the msb is set or not. */
3260 SET_REAL_EXP (r
, fmt
->emin
);
3261 if (HOST_BITS_PER_LONG
== 32)
3263 r
->sig
[SIGSZ
-1] = sig_hi
;
3264 r
->sig
[SIGSZ
-2] = sig_lo
;
3267 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3271 else if (fmt
->has_signed_zero
)
3274 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3276 /* See above re "pseudo-infinities" and "pseudo-nans".
3277 Short summary is that the MSB will likely always be
3278 set, and that we don't care about it. */
3279 sig_hi
&= 0x7fffffff;
3281 if (sig_hi
|| sig_lo
)
3285 r
->signalling
= ((sig_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
3286 if (HOST_BITS_PER_LONG
== 32)
3288 r
->sig
[SIGSZ
-1] = sig_hi
;
3289 r
->sig
[SIGSZ
-2] = sig_lo
;
3292 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3304 SET_REAL_EXP (r
, exp
- 16383 + 1);
3305 if (HOST_BITS_PER_LONG
== 32)
3307 r
->sig
[SIGSZ
-1] = sig_hi
;
3308 r
->sig
[SIGSZ
-2] = sig_lo
;
3311 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3315 /* Convert from the internal format to the 12-byte Motorola format
3316 for an IEEE extended real. */
3318 decode_ieee_extended_motorola (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3323 /* Motorola chips are assumed always to be big-endian. Also, the
3324 padding in a Motorola extended real goes between the exponent and
3325 the mantissa; remove it. */
3326 intermed
[0] = buf
[2];
3327 intermed
[1] = buf
[1];
3328 intermed
[2] = (unsigned long)buf
[0] >> 16;
3330 decode_ieee_extended (fmt
, r
, intermed
);
3333 /* Convert from the internal format to the 12-byte Intel format for
3334 an IEEE extended real. */
3336 decode_ieee_extended_intel_96 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3339 if (FLOAT_WORDS_BIG_ENDIAN
)
3341 /* All the padding in an Intel-format extended real goes at the high
3342 end, which in this case is after the mantissa, not the exponent.
3343 Therefore we must shift everything up 16 bits. */
3346 intermed
[0] = (((unsigned long)buf
[2] >> 16) | (buf
[1] << 16));
3347 intermed
[1] = (((unsigned long)buf
[1] >> 16) | (buf
[0] << 16));
3348 intermed
[2] = ((unsigned long)buf
[0] >> 16);
3350 decode_ieee_extended (fmt
, r
, intermed
);
3353 /* decode_ieee_extended produces what we want directly. */
3354 decode_ieee_extended (fmt
, r
, buf
);
3357 /* Convert from the internal format to the 16-byte Intel format for
3358 an IEEE extended real. */
3360 decode_ieee_extended_intel_128 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3363 /* All the padding in an Intel-format extended real goes at the high end. */
3364 decode_ieee_extended_intel_96 (fmt
, r
, buf
);
3367 const struct real_format ieee_extended_motorola_format
=
3369 encode_ieee_extended_motorola
,
3370 decode_ieee_extended_motorola
,
3386 const struct real_format ieee_extended_intel_96_format
=
3388 encode_ieee_extended_intel_96
,
3389 decode_ieee_extended_intel_96
,
3405 const struct real_format ieee_extended_intel_128_format
=
3407 encode_ieee_extended_intel_128
,
3408 decode_ieee_extended_intel_128
,
3424 /* The following caters to i386 systems that set the rounding precision
3425 to 53 bits instead of 64, e.g. FreeBSD. */
3426 const struct real_format ieee_extended_intel_96_round_53_format
=
3428 encode_ieee_extended_intel_96
,
3429 decode_ieee_extended_intel_96
,
3445 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3446 numbers whose sum is equal to the extended precision value. The number
3447 with greater magnitude is first. This format has the same magnitude
3448 range as an IEEE double precision value, but effectively 106 bits of
3449 significand precision. Infinity and NaN are represented by their IEEE
3450 double precision value stored in the first number, the second number is
3451 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3453 static void encode_ibm_extended (const struct real_format
*fmt
,
3454 long *, const REAL_VALUE_TYPE
*);
3455 static void decode_ibm_extended (const struct real_format
*,
3456 REAL_VALUE_TYPE
*, const long *);
3459 encode_ibm_extended (const struct real_format
*fmt
, long *buf
,
3460 const REAL_VALUE_TYPE
*r
)
3462 REAL_VALUE_TYPE u
, normr
, v
;
3463 const struct real_format
*base_fmt
;
3465 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3467 /* Renormlize R before doing any arithmetic on it. */
3469 if (normr
.cl
== rvc_normal
)
3472 /* u = IEEE double precision portion of significand. */
3474 round_for_format (base_fmt
, &u
);
3475 encode_ieee_double (base_fmt
, &buf
[0], &u
);
3477 if (u
.cl
== rvc_normal
)
3479 do_add (&v
, &normr
, &u
, 1);
3480 /* Call round_for_format since we might need to denormalize. */
3481 round_for_format (base_fmt
, &v
);
3482 encode_ieee_double (base_fmt
, &buf
[2], &v
);
3486 /* Inf, NaN, 0 are all representable as doubles, so the
3487 least-significant part can be 0.0. */
3494 decode_ibm_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
, REAL_VALUE_TYPE
*r
,
3497 REAL_VALUE_TYPE u
, v
;
3498 const struct real_format
*base_fmt
;
3500 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3501 decode_ieee_double (base_fmt
, &u
, &buf
[0]);
3503 if (u
.cl
!= rvc_zero
&& u
.cl
!= rvc_inf
&& u
.cl
!= rvc_nan
)
3505 decode_ieee_double (base_fmt
, &v
, &buf
[2]);
3506 do_add (r
, &u
, &v
, 0);
3512 const struct real_format ibm_extended_format
=
3514 encode_ibm_extended
,
3515 decode_ibm_extended
,
3531 const struct real_format mips_extended_format
=
3533 encode_ibm_extended
,
3534 decode_ibm_extended
,
3551 /* IEEE quad precision format. */
3553 static void encode_ieee_quad (const struct real_format
*fmt
,
3554 long *, const REAL_VALUE_TYPE
*);
3555 static void decode_ieee_quad (const struct real_format
*,
3556 REAL_VALUE_TYPE
*, const long *);
3559 encode_ieee_quad (const struct real_format
*fmt
, long *buf
,
3560 const REAL_VALUE_TYPE
*r
)
3562 unsigned long image3
, image2
, image1
, image0
, exp
;
3563 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3566 image3
= r
->sign
<< 31;
3571 rshift_significand (&u
, r
, SIGNIFICAND_BITS
- 113);
3580 image3
|= 32767 << 16;
3583 image3
|= 0x7fffffff;
3584 image2
= 0xffffffff;
3585 image1
= 0xffffffff;
3586 image0
= 0xffffffff;
3593 image3
|= 32767 << 16;
3597 if (fmt
->canonical_nan_lsbs_set
)
3600 image2
= image1
= image0
= 0xffffffff;
3603 else if (HOST_BITS_PER_LONG
== 32)
3608 image3
|= u
.sig
[3] & 0xffff;
3613 image1
= image0
>> 31 >> 1;
3615 image3
|= (image2
>> 31 >> 1) & 0xffff;
3616 image0
&= 0xffffffff;
3617 image2
&= 0xffffffff;
3619 if (r
->signalling
== fmt
->qnan_msb_set
)
3623 if (((image3
& 0xffff) | image2
| image1
| image0
) == 0)
3628 image3
|= 0x7fffffff;
3629 image2
= 0xffffffff;
3630 image1
= 0xffffffff;
3631 image0
= 0xffffffff;
3636 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3637 whereas the intermediate representation is 0.F x 2**exp.
3638 Which means we're off by one. */
3642 exp
= REAL_EXP (r
) + 16383 - 1;
3643 image3
|= exp
<< 16;
3645 if (HOST_BITS_PER_LONG
== 32)
3650 image3
|= u
.sig
[3] & 0xffff;
3655 image1
= image0
>> 31 >> 1;
3657 image3
|= (image2
>> 31 >> 1) & 0xffff;
3658 image0
&= 0xffffffff;
3659 image2
&= 0xffffffff;
3667 if (FLOAT_WORDS_BIG_ENDIAN
)
3684 decode_ieee_quad (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3687 unsigned long image3
, image2
, image1
, image0
;
3691 if (FLOAT_WORDS_BIG_ENDIAN
)
3705 image0
&= 0xffffffff;
3706 image1
&= 0xffffffff;
3707 image2
&= 0xffffffff;
3709 sign
= (image3
>> 31) & 1;
3710 exp
= (image3
>> 16) & 0x7fff;
3713 memset (r
, 0, sizeof (*r
));
3717 if ((image3
| image2
| image1
| image0
) && fmt
->has_denorm
)
3722 SET_REAL_EXP (r
, -16382 + (SIGNIFICAND_BITS
- 112));
3723 if (HOST_BITS_PER_LONG
== 32)
3732 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3733 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3738 else if (fmt
->has_signed_zero
)
3741 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3743 if (image3
| image2
| image1
| image0
)
3747 r
->signalling
= ((image3
>> 15) & 1) ^ fmt
->qnan_msb_set
;
3749 if (HOST_BITS_PER_LONG
== 32)
3758 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3759 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3761 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3773 SET_REAL_EXP (r
, exp
- 16383 + 1);
3775 if (HOST_BITS_PER_LONG
== 32)
3784 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3785 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3787 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3788 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3792 const struct real_format ieee_quad_format
=
3811 const struct real_format mips_quad_format
=
3830 /* Descriptions of VAX floating point formats can be found beginning at
3832 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
3834 The thing to remember is that they're almost IEEE, except for word
3835 order, exponent bias, and the lack of infinities, nans, and denormals.
3837 We don't implement the H_floating format here, simply because neither
3838 the VAX or Alpha ports use it. */
3840 static void encode_vax_f (const struct real_format
*fmt
,
3841 long *, const REAL_VALUE_TYPE
*);
3842 static void decode_vax_f (const struct real_format
*,
3843 REAL_VALUE_TYPE
*, const long *);
3844 static void encode_vax_d (const struct real_format
*fmt
,
3845 long *, const REAL_VALUE_TYPE
*);
3846 static void decode_vax_d (const struct real_format
*,
3847 REAL_VALUE_TYPE
*, const long *);
3848 static void encode_vax_g (const struct real_format
*fmt
,
3849 long *, const REAL_VALUE_TYPE
*);
3850 static void decode_vax_g (const struct real_format
*,
3851 REAL_VALUE_TYPE
*, const long *);
3854 encode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3855 const REAL_VALUE_TYPE
*r
)
3857 unsigned long sign
, exp
, sig
, image
;
3859 sign
= r
->sign
<< 15;
3869 image
= 0xffff7fff | sign
;
3873 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
3874 exp
= REAL_EXP (r
) + 128;
3876 image
= (sig
<< 16) & 0xffff0000;
3890 decode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3891 REAL_VALUE_TYPE
*r
, const long *buf
)
3893 unsigned long image
= buf
[0] & 0xffffffff;
3894 int exp
= (image
>> 7) & 0xff;
3896 memset (r
, 0, sizeof (*r
));
3901 r
->sign
= (image
>> 15) & 1;
3902 SET_REAL_EXP (r
, exp
- 128);
3904 image
= ((image
& 0x7f) << 16) | ((image
>> 16) & 0xffff);
3905 r
->sig
[SIGSZ
-1] = (image
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
3910 encode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3911 const REAL_VALUE_TYPE
*r
)
3913 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
3918 image0
= image1
= 0;
3923 image0
= 0xffff7fff | sign
;
3924 image1
= 0xffffffff;
3928 /* Extract the significand into straight hi:lo. */
3929 if (HOST_BITS_PER_LONG
== 64)
3931 image0
= r
->sig
[SIGSZ
-1];
3932 image1
= (image0
>> (64 - 56)) & 0xffffffff;
3933 image0
= (image0
>> (64 - 56 + 1) >> 31) & 0x7fffff;
3937 image0
= r
->sig
[SIGSZ
-1];
3938 image1
= r
->sig
[SIGSZ
-2];
3939 image1
= (image0
<< 24) | (image1
>> 8);
3940 image0
= (image0
>> 8) & 0xffffff;
3943 /* Rearrange the half-words of the significand to match the
3945 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff007f;
3946 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
3948 /* Add the sign and exponent. */
3950 image0
|= (REAL_EXP (r
) + 128) << 7;
3957 if (FLOAT_WORDS_BIG_ENDIAN
)
3958 buf
[0] = image1
, buf
[1] = image0
;
3960 buf
[0] = image0
, buf
[1] = image1
;
3964 decode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3965 REAL_VALUE_TYPE
*r
, const long *buf
)
3967 unsigned long image0
, image1
;
3970 if (FLOAT_WORDS_BIG_ENDIAN
)
3971 image1
= buf
[0], image0
= buf
[1];
3973 image0
= buf
[0], image1
= buf
[1];
3974 image0
&= 0xffffffff;
3975 image1
&= 0xffffffff;
3977 exp
= (image0
>> 7) & 0xff;
3979 memset (r
, 0, sizeof (*r
));
3984 r
->sign
= (image0
>> 15) & 1;
3985 SET_REAL_EXP (r
, exp
- 128);
3987 /* Rearrange the half-words of the external format into
3988 proper ascending order. */
3989 image0
= ((image0
& 0x7f) << 16) | ((image0
>> 16) & 0xffff);
3990 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
3992 if (HOST_BITS_PER_LONG
== 64)
3994 image0
= (image0
<< 31 << 1) | image1
;
3997 r
->sig
[SIGSZ
-1] = image0
;
4001 r
->sig
[SIGSZ
-1] = image0
;
4002 r
->sig
[SIGSZ
-2] = image1
;
4003 lshift_significand (r
, r
, 2*HOST_BITS_PER_LONG
- 56);
4004 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4010 encode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4011 const REAL_VALUE_TYPE
*r
)
4013 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
4018 image0
= image1
= 0;
4023 image0
= 0xffff7fff | sign
;
4024 image1
= 0xffffffff;
4028 /* Extract the significand into straight hi:lo. */
4029 if (HOST_BITS_PER_LONG
== 64)
4031 image0
= r
->sig
[SIGSZ
-1];
4032 image1
= (image0
>> (64 - 53)) & 0xffffffff;
4033 image0
= (image0
>> (64 - 53 + 1) >> 31) & 0xfffff;
4037 image0
= r
->sig
[SIGSZ
-1];
4038 image1
= r
->sig
[SIGSZ
-2];
4039 image1
= (image0
<< 21) | (image1
>> 11);
4040 image0
= (image0
>> 11) & 0xfffff;
4043 /* Rearrange the half-words of the significand to match the
4045 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff000f;
4046 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
4048 /* Add the sign and exponent. */
4050 image0
|= (REAL_EXP (r
) + 1024) << 4;
4057 if (FLOAT_WORDS_BIG_ENDIAN
)
4058 buf
[0] = image1
, buf
[1] = image0
;
4060 buf
[0] = image0
, buf
[1] = image1
;
4064 decode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4065 REAL_VALUE_TYPE
*r
, const long *buf
)
4067 unsigned long image0
, image1
;
4070 if (FLOAT_WORDS_BIG_ENDIAN
)
4071 image1
= buf
[0], image0
= buf
[1];
4073 image0
= buf
[0], image1
= buf
[1];
4074 image0
&= 0xffffffff;
4075 image1
&= 0xffffffff;
4077 exp
= (image0
>> 4) & 0x7ff;
4079 memset (r
, 0, sizeof (*r
));
4084 r
->sign
= (image0
>> 15) & 1;
4085 SET_REAL_EXP (r
, exp
- 1024);
4087 /* Rearrange the half-words of the external format into
4088 proper ascending order. */
4089 image0
= ((image0
& 0xf) << 16) | ((image0
>> 16) & 0xffff);
4090 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
4092 if (HOST_BITS_PER_LONG
== 64)
4094 image0
= (image0
<< 31 << 1) | image1
;
4097 r
->sig
[SIGSZ
-1] = image0
;
4101 r
->sig
[SIGSZ
-1] = image0
;
4102 r
->sig
[SIGSZ
-2] = image1
;
4103 lshift_significand (r
, r
, 64 - 53);
4104 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4109 const struct real_format vax_f_format
=
4128 const struct real_format vax_d_format
=
4147 const struct real_format vax_g_format
=
4166 /* Encode real R into a single precision DFP value in BUF. */
4168 encode_decimal_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4169 long *buf ATTRIBUTE_UNUSED
,
4170 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4172 encode_decimal32 (fmt
, buf
, r
);
4175 /* Decode a single precision DFP value in BUF into a real R. */
4177 decode_decimal_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4178 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4179 const long *buf ATTRIBUTE_UNUSED
)
4181 decode_decimal32 (fmt
, r
, buf
);
4184 /* Encode real R into a double precision DFP value in BUF. */
4186 encode_decimal_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4187 long *buf ATTRIBUTE_UNUSED
,
4188 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4190 encode_decimal64 (fmt
, buf
, r
);
4193 /* Decode a double precision DFP value in BUF into a real R. */
4195 decode_decimal_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4196 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4197 const long *buf ATTRIBUTE_UNUSED
)
4199 decode_decimal64 (fmt
, r
, buf
);
4202 /* Encode real R into a quad precision DFP value in BUF. */
4204 encode_decimal_quad (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4205 long *buf ATTRIBUTE_UNUSED
,
4206 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4208 encode_decimal128 (fmt
, buf
, r
);
4211 /* Decode a quad precision DFP value in BUF into a real R. */
4213 decode_decimal_quad (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4214 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4215 const long *buf ATTRIBUTE_UNUSED
)
4217 decode_decimal128 (fmt
, r
, buf
);
4220 /* Single precision decimal floating point (IEEE 754R). */
4221 const struct real_format decimal_single_format
=
4223 encode_decimal_single
,
4224 decode_decimal_single
,
4240 /* Double precision decimal floating point (IEEE 754R). */
4241 const struct real_format decimal_double_format
=
4243 encode_decimal_double
,
4244 decode_decimal_double
,
4260 /* Quad precision decimal floating point (IEEE 754R). */
4261 const struct real_format decimal_quad_format
=
4263 encode_decimal_quad
,
4264 decode_decimal_quad
,
4280 /* The "twos-complement" c4x format is officially defined as
4284 This is rather misleading. One must remember that F is signed.
4285 A better description would be
4287 x = -1**s * ((s + 1 + .f) * 2**e
4289 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
4290 that's -1 * (1+1+(-.5)) == -1.5. I think.
4292 The constructions here are taken from Tables 5-1 and 5-2 of the
4293 TMS320C4x User's Guide wherein step-by-step instructions for
4294 conversion from IEEE are presented. That's close enough to our
4295 internal representation so as to make things easy.
4297 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
4299 static void encode_c4x_single (const struct real_format
*fmt
,
4300 long *, const REAL_VALUE_TYPE
*);
4301 static void decode_c4x_single (const struct real_format
*,
4302 REAL_VALUE_TYPE
*, const long *);
4303 static void encode_c4x_extended (const struct real_format
*fmt
,
4304 long *, const REAL_VALUE_TYPE
*);
4305 static void decode_c4x_extended (const struct real_format
*,
4306 REAL_VALUE_TYPE
*, const long *);
4309 encode_c4x_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4310 long *buf
, const REAL_VALUE_TYPE
*r
)
4312 unsigned long image
, exp
, sig
;
4324 sig
= 0x800000 - r
->sign
;
4328 exp
= REAL_EXP (r
) - 1;
4329 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
4344 image
= ((exp
& 0xff) << 24) | (sig
& 0xffffff);
4349 decode_c4x_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4350 REAL_VALUE_TYPE
*r
, const long *buf
)
4352 unsigned long image
= buf
[0];
4356 exp
= (((image
>> 24) & 0xff) ^ 0x80) - 0x80;
4357 sf
= ((image
& 0xffffff) ^ 0x800000) - 0x800000;
4359 memset (r
, 0, sizeof (*r
));
4365 sig
= sf
& 0x7fffff;
4374 sig
= (sig
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
4376 SET_REAL_EXP (r
, exp
+ 1);
4377 r
->sig
[SIGSZ
-1] = sig
;
4382 encode_c4x_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4383 long *buf
, const REAL_VALUE_TYPE
*r
)
4385 unsigned long exp
, sig
;
4397 sig
= 0x80000000 - r
->sign
;
4401 exp
= REAL_EXP (r
) - 1;
4403 sig
= r
->sig
[SIGSZ
-1];
4404 if (HOST_BITS_PER_LONG
== 64)
4405 sig
= sig
>> 1 >> 31;
4422 exp
= (exp
& 0xff) << 24;
4425 if (FLOAT_WORDS_BIG_ENDIAN
)
4426 buf
[0] = exp
, buf
[1] = sig
;
4428 buf
[0] = sig
, buf
[0] = exp
;
4432 decode_c4x_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4433 REAL_VALUE_TYPE
*r
, const long *buf
)
4438 if (FLOAT_WORDS_BIG_ENDIAN
)
4439 exp
= buf
[0], sf
= buf
[1];
4441 sf
= buf
[0], exp
= buf
[1];
4443 exp
= (((exp
>> 24) & 0xff) & 0x80) - 0x80;
4444 sf
= ((sf
& 0xffffffff) ^ 0x80000000) - 0x80000000;
4446 memset (r
, 0, sizeof (*r
));
4452 sig
= sf
& 0x7fffffff;
4461 if (HOST_BITS_PER_LONG
== 64)
4462 sig
= sig
<< 1 << 31;
4465 SET_REAL_EXP (r
, exp
+ 1);
4466 r
->sig
[SIGSZ
-1] = sig
;
4470 const struct real_format c4x_single_format
=
4489 const struct real_format c4x_extended_format
=
4491 encode_c4x_extended
,
4492 decode_c4x_extended
,
4509 /* A synthetic "format" for internal arithmetic. It's the size of the
4510 internal significand minus the two bits needed for proper rounding.
4511 The encode and decode routines exist only to satisfy our paranoia
4514 static void encode_internal (const struct real_format
*fmt
,
4515 long *, const REAL_VALUE_TYPE
*);
4516 static void decode_internal (const struct real_format
*,
4517 REAL_VALUE_TYPE
*, const long *);
4520 encode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4521 const REAL_VALUE_TYPE
*r
)
4523 memcpy (buf
, r
, sizeof (*r
));
4527 decode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4528 REAL_VALUE_TYPE
*r
, const long *buf
)
4530 memcpy (r
, buf
, sizeof (*r
));
4533 const struct real_format real_internal_format
=
4538 SIGNIFICAND_BITS
- 2,
4539 SIGNIFICAND_BITS
- 2,
4552 /* Calculate the square root of X in mode MODE, and store the result
4553 in R. Return TRUE if the operation does not raise an exception.
4554 For details see "High Precision Division and Square Root",
4555 Alan H. Karp and Peter Markstein, HP Lab Report 93-93-42, June
4556 1993. http://www.hpl.hp.com/techreports/93/HPL-93-42.pdf. */
4559 real_sqrt (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4560 const REAL_VALUE_TYPE
*x
)
4562 static REAL_VALUE_TYPE halfthree
;
4563 static bool init
= false;
4564 REAL_VALUE_TYPE h
, t
, i
;
4567 /* sqrt(-0.0) is -0.0. */
4568 if (real_isnegzero (x
))
4574 /* Negative arguments return NaN. */
4577 get_canonical_qnan (r
, 0);
4581 /* Infinity and NaN return themselves. */
4582 if (!real_isfinite (x
))
4590 do_add (&halfthree
, &dconst1
, &dconsthalf
, 0);
4594 /* Initial guess for reciprocal sqrt, i. */
4595 exp
= real_exponent (x
);
4596 real_ldexp (&i
, &dconst1
, -exp
/2);
4598 /* Newton's iteration for reciprocal sqrt, i. */
4599 for (iter
= 0; iter
< 16; iter
++)
4601 /* i(n+1) = i(n) * (1.5 - 0.5*i(n)*i(n)*x). */
4602 do_multiply (&t
, x
, &i
);
4603 do_multiply (&h
, &t
, &i
);
4604 do_multiply (&t
, &h
, &dconsthalf
);
4605 do_add (&h
, &halfthree
, &t
, 1);
4606 do_multiply (&t
, &i
, &h
);
4608 /* Check for early convergence. */
4609 if (iter
>= 6 && real_identical (&i
, &t
))
4612 /* ??? Unroll loop to avoid copying. */
4616 /* Final iteration: r = i*x + 0.5*i*x*(1.0 - i*(i*x)). */
4617 do_multiply (&t
, x
, &i
);
4618 do_multiply (&h
, &t
, &i
);
4619 do_add (&i
, &dconst1
, &h
, 1);
4620 do_multiply (&h
, &t
, &i
);
4621 do_multiply (&i
, &dconsthalf
, &h
);
4622 do_add (&h
, &t
, &i
, 0);
4624 /* ??? We need a Tuckerman test to get the last bit. */
4626 real_convert (r
, mode
, &h
);
4630 /* Calculate X raised to the integer exponent N in mode MODE and store
4631 the result in R. Return true if the result may be inexact due to
4632 loss of precision. The algorithm is the classic "left-to-right binary
4633 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
4634 Algorithms", "The Art of Computer Programming", Volume 2. */
4637 real_powi (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4638 const REAL_VALUE_TYPE
*x
, HOST_WIDE_INT n
)
4640 unsigned HOST_WIDE_INT bit
;
4642 bool inexact
= false;
4654 /* Don't worry about overflow, from now on n is unsigned. */
4662 bit
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
4663 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
; i
++)
4667 inexact
|= do_multiply (&t
, &t
, &t
);
4669 inexact
|= do_multiply (&t
, &t
, x
);
4677 inexact
|= do_divide (&t
, &dconst1
, &t
);
4679 real_convert (r
, mode
, &t
);
4683 /* Round X to the nearest integer not larger in absolute value, i.e.
4684 towards zero, placing the result in R in mode MODE. */
4687 real_trunc (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4688 const REAL_VALUE_TYPE
*x
)
4690 do_fix_trunc (r
, x
);
4691 if (mode
!= VOIDmode
)
4692 real_convert (r
, mode
, r
);
4695 /* Round X to the largest integer not greater in value, i.e. round
4696 down, placing the result in R in mode MODE. */
4699 real_floor (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4700 const REAL_VALUE_TYPE
*x
)
4704 do_fix_trunc (&t
, x
);
4705 if (! real_identical (&t
, x
) && x
->sign
)
4706 do_add (&t
, &t
, &dconstm1
, 0);
4707 if (mode
!= VOIDmode
)
4708 real_convert (r
, mode
, &t
);
4713 /* Round X to the smallest integer not less then argument, i.e. round
4714 up, placing the result in R in mode MODE. */
4717 real_ceil (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4718 const REAL_VALUE_TYPE
*x
)
4722 do_fix_trunc (&t
, x
);
4723 if (! real_identical (&t
, x
) && ! x
->sign
)
4724 do_add (&t
, &t
, &dconst1
, 0);
4725 if (mode
!= VOIDmode
)
4726 real_convert (r
, mode
, &t
);
4731 /* Round X to the nearest integer, but round halfway cases away from
4735 real_round (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4736 const REAL_VALUE_TYPE
*x
)
4738 do_add (r
, x
, &dconsthalf
, x
->sign
);
4739 do_fix_trunc (r
, r
);
4740 if (mode
!= VOIDmode
)
4741 real_convert (r
, mode
, r
);
4744 /* Set the sign of R to the sign of X. */
4747 real_copysign (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*x
)
4752 /* Convert from REAL_VALUE_TYPE to MPFR. The caller is responsible
4753 for initializing and clearing the MPFR parameter. */
4756 mpfr_from_real (mpfr_ptr m
, const REAL_VALUE_TYPE
*r
, mp_rnd_t rndmode
)
4758 /* We use a string as an intermediate type. */
4762 /* Take care of Infinity and NaN. */
4763 if (r
->cl
== rvc_inf
)
4765 mpfr_set_inf (m
, r
->sign
== 1 ? -1 : 1);
4769 if (r
->cl
== rvc_nan
)
4775 real_to_hexadecimal (buf
, r
, sizeof (buf
), 0, 1);
4776 /* mpfr_set_str() parses hexadecimal floats from strings in the same
4777 format that GCC will output them. Nothing extra is needed. */
4778 ret
= mpfr_set_str (m
, buf
, 16, rndmode
);
4779 gcc_assert (ret
== 0);
4782 /* Convert from MPFR to REAL_VALUE_TYPE, for a given type TYPE and rounding
4783 mode RNDMODE. TYPE is only relevant if M is a NaN. */
4786 real_from_mpfr (REAL_VALUE_TYPE
*r
, mpfr_srcptr m
, tree type
, mp_rnd_t rndmode
)
4788 /* We use a string as an intermediate type. */
4789 char buf
[128], *rstr
;
4792 /* Take care of Infinity and NaN. */
4796 if (mpfr_sgn (m
) < 0)
4797 *r
= REAL_VALUE_NEGATE (*r
);
4803 real_nan (r
, "", 1, TYPE_MODE (type
));
4807 rstr
= mpfr_get_str (NULL
, &exp
, 16, 0, m
, rndmode
);
4809 /* The additional 12 chars add space for the sprintf below. This
4810 leaves 6 digits for the exponent which is supposedly enough. */
4811 gcc_assert (rstr
!= NULL
&& strlen (rstr
) < sizeof (buf
) - 12);
4813 /* REAL_VALUE_ATOF expects the exponent for mantissa * 2**exp,
4814 mpfr_get_str returns the exponent for mantissa * 16**exp, adjust
4819 sprintf (buf
, "-0x.%sp%d", &rstr
[1], (int) exp
);
4821 sprintf (buf
, "0x.%sp%d", rstr
, (int) exp
);
4823 mpfr_free_str (rstr
);
4825 real_from_string (r
, buf
);
4828 /* Check whether the real constant value given is an integer. */
4831 real_isinteger (const REAL_VALUE_TYPE
*c
, enum machine_mode mode
)
4833 REAL_VALUE_TYPE cint
;
4835 real_trunc (&cint
, mode
, c
);
4836 return real_identical (c
, &cint
);