1 /* real.c - software floating point emulation.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2002, 2003, 2004, 2005 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 negative. */
1169 real_isneg (const REAL_VALUE_TYPE
*r
)
1174 /* Determine whether a floating-point value X is minus zero. */
1177 real_isnegzero (const REAL_VALUE_TYPE
*r
)
1179 return r
->sign
&& r
->cl
== rvc_zero
;
1182 /* Compare two floating-point objects for bitwise identity. */
1185 real_identical (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
1191 if (a
->sign
!= b
->sign
)
1201 if (a
->decimal
!= b
->decimal
)
1203 if (REAL_EXP (a
) != REAL_EXP (b
))
1208 if (a
->signalling
!= b
->signalling
)
1210 /* The significand is ignored for canonical NaNs. */
1211 if (a
->canonical
|| b
->canonical
)
1212 return a
->canonical
== b
->canonical
;
1219 for (i
= 0; i
< SIGSZ
; ++i
)
1220 if (a
->sig
[i
] != b
->sig
[i
])
1226 /* Try to change R into its exact multiplicative inverse in machine
1227 mode MODE. Return true if successful. */
1230 exact_real_inverse (enum machine_mode mode
, REAL_VALUE_TYPE
*r
)
1232 const REAL_VALUE_TYPE
*one
= real_digit (1);
1236 if (r
->cl
!= rvc_normal
)
1239 /* Check for a power of two: all significand bits zero except the MSB. */
1240 for (i
= 0; i
< SIGSZ
-1; ++i
)
1243 if (r
->sig
[SIGSZ
-1] != SIG_MSB
)
1246 /* Find the inverse and truncate to the required mode. */
1247 do_divide (&u
, one
, r
);
1248 real_convert (&u
, mode
, &u
);
1250 /* The rounding may have overflowed. */
1251 if (u
.cl
!= rvc_normal
)
1253 for (i
= 0; i
< SIGSZ
-1; ++i
)
1256 if (u
.sig
[SIGSZ
-1] != SIG_MSB
)
1263 /* Render R as an integer. */
1266 real_to_integer (const REAL_VALUE_TYPE
*r
)
1268 unsigned HOST_WIDE_INT i
;
1279 i
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1286 return decimal_real_to_integer (r
);
1288 if (REAL_EXP (r
) <= 0)
1290 /* Only force overflow for unsigned overflow. Signed overflow is
1291 undefined, so it doesn't matter what we return, and some callers
1292 expect to be able to use this routine for both signed and
1293 unsigned conversions. */
1294 if (REAL_EXP (r
) > HOST_BITS_PER_WIDE_INT
)
1297 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1298 i
= r
->sig
[SIGSZ
-1];
1301 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2 * HOST_BITS_PER_LONG
);
1302 i
= r
->sig
[SIGSZ
-1];
1303 i
= i
<< (HOST_BITS_PER_LONG
- 1) << 1;
1304 i
|= r
->sig
[SIGSZ
-2];
1307 i
>>= HOST_BITS_PER_WIDE_INT
- REAL_EXP (r
);
1318 /* Likewise, but to an integer pair, HI+LOW. */
1321 real_to_integer2 (HOST_WIDE_INT
*plow
, HOST_WIDE_INT
*phigh
,
1322 const REAL_VALUE_TYPE
*r
)
1325 HOST_WIDE_INT low
, high
;
1338 high
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1351 decimal_real_to_integer2 (plow
, phigh
, r
);
1358 /* Only force overflow for unsigned overflow. Signed overflow is
1359 undefined, so it doesn't matter what we return, and some callers
1360 expect to be able to use this routine for both signed and
1361 unsigned conversions. */
1362 if (exp
> 2*HOST_BITS_PER_WIDE_INT
)
1365 rshift_significand (&t
, r
, 2*HOST_BITS_PER_WIDE_INT
- exp
);
1366 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1368 high
= t
.sig
[SIGSZ
-1];
1369 low
= t
.sig
[SIGSZ
-2];
1373 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2*HOST_BITS_PER_LONG
);
1374 high
= t
.sig
[SIGSZ
-1];
1375 high
= high
<< (HOST_BITS_PER_LONG
- 1) << 1;
1376 high
|= t
.sig
[SIGSZ
-2];
1378 low
= t
.sig
[SIGSZ
-3];
1379 low
= low
<< (HOST_BITS_PER_LONG
- 1) << 1;
1380 low
|= t
.sig
[SIGSZ
-4];
1388 low
= -low
, high
= ~high
;
1400 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1401 of NUM / DEN. Return the quotient and place the remainder in NUM.
1402 It is expected that NUM / DEN are close enough that the quotient is
1405 static unsigned long
1406 rtd_divmod (REAL_VALUE_TYPE
*num
, REAL_VALUE_TYPE
*den
)
1408 unsigned long q
, msb
;
1409 int expn
= REAL_EXP (num
), expd
= REAL_EXP (den
);
1418 msb
= num
->sig
[SIGSZ
-1] & SIG_MSB
;
1420 lshift_significand_1 (num
, num
);
1422 if (msb
|| cmp_significands (num
, den
) >= 0)
1424 sub_significands (num
, num
, den
, 0);
1428 while (--expn
>= expd
);
1430 SET_REAL_EXP (num
, expd
);
1436 /* Render R as a decimal floating point constant. Emit DIGITS significant
1437 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1438 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1441 #define M_LOG10_2 0.30102999566398119521
1444 real_to_decimal (char *str
, const REAL_VALUE_TYPE
*r_orig
, size_t buf_size
,
1445 size_t digits
, int crop_trailing_zeros
)
1447 const REAL_VALUE_TYPE
*one
, *ten
;
1448 REAL_VALUE_TYPE r
, pten
, u
, v
;
1449 int dec_exp
, cmp_one
, digit
;
1451 char *p
, *first
, *last
;
1458 strcpy (str
, (r
.sign
? "-0.0" : "0.0"));
1463 strcpy (str
, (r
.sign
? "-Inf" : "+Inf"));
1466 /* ??? Print the significand as well, if not canonical? */
1467 strcpy (str
, (r
.sign
? "-NaN" : "+NaN"));
1475 decimal_real_to_decimal (str
, &r
, buf_size
, digits
, crop_trailing_zeros
);
1479 /* Bound the number of digits printed by the size of the representation. */
1480 max_digits
= SIGNIFICAND_BITS
* M_LOG10_2
;
1481 if (digits
== 0 || digits
> max_digits
)
1482 digits
= max_digits
;
1484 /* Estimate the decimal exponent, and compute the length of the string it
1485 will print as. Be conservative and add one to account for possible
1486 overflow or rounding error. */
1487 dec_exp
= REAL_EXP (&r
) * M_LOG10_2
;
1488 for (max_digits
= 1; dec_exp
; max_digits
++)
1491 /* Bound the number of digits printed by the size of the output buffer. */
1492 max_digits
= buf_size
- 1 - 1 - 2 - max_digits
- 1;
1493 gcc_assert (max_digits
<= buf_size
);
1494 if (digits
> max_digits
)
1495 digits
= max_digits
;
1497 one
= real_digit (1);
1498 ten
= ten_to_ptwo (0);
1506 cmp_one
= do_compare (&r
, one
, 0);
1511 /* Number is greater than one. Convert significand to an integer
1512 and strip trailing decimal zeros. */
1515 SET_REAL_EXP (&u
, SIGNIFICAND_BITS
- 1);
1517 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1518 m
= floor_log2 (max_digits
);
1520 /* Iterate over the bits of the possible powers of 10 that might
1521 be present in U and eliminate them. That is, if we find that
1522 10**2**M divides U evenly, keep the division and increase
1528 do_divide (&t
, &u
, ten_to_ptwo (m
));
1529 do_fix_trunc (&v
, &t
);
1530 if (cmp_significands (&v
, &t
) == 0)
1538 /* Revert the scaling to integer that we performed earlier. */
1539 SET_REAL_EXP (&u
, REAL_EXP (&u
) + REAL_EXP (&r
)
1540 - (SIGNIFICAND_BITS
- 1));
1543 /* Find power of 10. Do this by dividing out 10**2**M when
1544 this is larger than the current remainder. Fill PTEN with
1545 the power of 10 that we compute. */
1546 if (REAL_EXP (&r
) > 0)
1548 m
= floor_log2 ((int)(REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1551 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1552 if (do_compare (&u
, ptentwo
, 0) >= 0)
1554 do_divide (&u
, &u
, ptentwo
);
1555 do_multiply (&pten
, &pten
, ptentwo
);
1562 /* We managed to divide off enough tens in the above reduction
1563 loop that we've now got a negative exponent. Fall into the
1564 less-than-one code to compute the proper value for PTEN. */
1571 /* Number is less than one. Pad significand with leading
1577 /* Stop if we'd shift bits off the bottom. */
1581 do_multiply (&u
, &v
, ten
);
1583 /* Stop if we're now >= 1. */
1584 if (REAL_EXP (&u
) > 0)
1592 /* Find power of 10. Do this by multiplying in P=10**2**M when
1593 the current remainder is smaller than 1/P. Fill PTEN with the
1594 power of 10 that we compute. */
1595 m
= floor_log2 ((int)(-REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1598 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1599 const REAL_VALUE_TYPE
*ptenmtwo
= ten_to_mptwo (m
);
1601 if (do_compare (&v
, ptenmtwo
, 0) <= 0)
1603 do_multiply (&v
, &v
, ptentwo
);
1604 do_multiply (&pten
, &pten
, ptentwo
);
1610 /* Invert the positive power of 10 that we've collected so far. */
1611 do_divide (&pten
, one
, &pten
);
1619 /* At this point, PTEN should contain the nearest power of 10 smaller
1620 than R, such that this division produces the first digit.
1622 Using a divide-step primitive that returns the complete integral
1623 remainder avoids the rounding error that would be produced if
1624 we were to use do_divide here and then simply multiply by 10 for
1625 each subsequent digit. */
1627 digit
= rtd_divmod (&r
, &pten
);
1629 /* Be prepared for error in that division via underflow ... */
1630 if (digit
== 0 && cmp_significand_0 (&r
))
1632 /* Multiply by 10 and try again. */
1633 do_multiply (&r
, &r
, ten
);
1634 digit
= rtd_divmod (&r
, &pten
);
1636 gcc_assert (digit
!= 0);
1639 /* ... or overflow. */
1649 gcc_assert (digit
<= 10);
1653 /* Generate subsequent digits. */
1654 while (--digits
> 0)
1656 do_multiply (&r
, &r
, ten
);
1657 digit
= rtd_divmod (&r
, &pten
);
1662 /* Generate one more digit with which to do rounding. */
1663 do_multiply (&r
, &r
, ten
);
1664 digit
= rtd_divmod (&r
, &pten
);
1666 /* Round the result. */
1669 /* Round to nearest. If R is nonzero there are additional
1670 nonzero digits to be extracted. */
1671 if (cmp_significand_0 (&r
))
1673 /* Round to even. */
1674 else if ((p
[-1] - '0') & 1)
1691 /* Carry out of the first digit. This means we had all 9's and
1692 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1700 /* Insert the decimal point. */
1701 first
[0] = first
[1];
1704 /* If requested, drop trailing zeros. Never crop past "1.0". */
1705 if (crop_trailing_zeros
)
1706 while (last
> first
+ 3 && last
[-1] == '0')
1709 /* Append the exponent. */
1710 sprintf (last
, "e%+d", dec_exp
);
1713 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1714 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1715 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1716 strip trailing zeros. */
1719 real_to_hexadecimal (char *str
, const REAL_VALUE_TYPE
*r
, size_t buf_size
,
1720 size_t digits
, int crop_trailing_zeros
)
1722 int i
, j
, exp
= REAL_EXP (r
);
1735 strcpy (str
, (r
->sign
? "-Inf" : "+Inf"));
1738 /* ??? Print the significand as well, if not canonical? */
1739 strcpy (str
, (r
->sign
? "-NaN" : "+NaN"));
1747 /* Hexadecimal format for decimal floats is not interesting. */
1748 strcpy (str
, "N/A");
1753 digits
= SIGNIFICAND_BITS
/ 4;
1755 /* Bound the number of digits printed by the size of the output buffer. */
1757 sprintf (exp_buf
, "p%+d", exp
);
1758 max_digits
= buf_size
- strlen (exp_buf
) - r
->sign
- 4 - 1;
1759 gcc_assert (max_digits
<= buf_size
);
1760 if (digits
> max_digits
)
1761 digits
= max_digits
;
1772 for (i
= SIGSZ
- 1; i
>= 0; --i
)
1773 for (j
= HOST_BITS_PER_LONG
- 4; j
>= 0; j
-= 4)
1775 *p
++ = "0123456789abcdef"[(r
->sig
[i
] >> j
) & 15];
1781 if (crop_trailing_zeros
)
1782 while (p
> first
+ 1 && p
[-1] == '0')
1785 sprintf (p
, "p%+d", exp
);
1788 /* Initialize R from a decimal or hexadecimal string. The string is
1789 assumed to have been syntax checked already. Return -1 if the
1790 value underflows, +1 if overflows, and 0 otherwise. */
1793 real_from_string (REAL_VALUE_TYPE
*r
, const char *str
)
1805 else if (*str
== '+')
1808 if (str
[0] == '0' && (str
[1] == 'x' || str
[1] == 'X'))
1810 /* Hexadecimal floating point. */
1811 int pos
= SIGNIFICAND_BITS
- 4, d
;
1819 d
= hex_value (*str
);
1824 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1825 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1829 /* Ensure correct rounding by setting last bit if there is
1830 a subsequent nonzero digit. */
1838 if (pos
== SIGNIFICAND_BITS
- 4)
1845 d
= hex_value (*str
);
1850 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1851 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1855 /* Ensure correct rounding by setting last bit if there is
1856 a subsequent nonzero digit. */
1862 /* If the mantissa is zero, ignore the exponent. */
1863 if (!cmp_significand_0 (r
))
1866 if (*str
== 'p' || *str
== 'P')
1868 bool exp_neg
= false;
1876 else if (*str
== '+')
1880 while (ISDIGIT (*str
))
1886 /* Overflowed the exponent. */
1901 SET_REAL_EXP (r
, exp
);
1907 /* Decimal floating point. */
1908 const REAL_VALUE_TYPE
*ten
= ten_to_ptwo (0);
1913 while (ISDIGIT (*str
))
1916 do_multiply (r
, r
, ten
);
1918 do_add (r
, r
, real_digit (d
), 0);
1923 if (r
->cl
== rvc_zero
)
1928 while (ISDIGIT (*str
))
1931 do_multiply (r
, r
, ten
);
1933 do_add (r
, r
, real_digit (d
), 0);
1938 /* If the mantissa is zero, ignore the exponent. */
1939 if (r
->cl
== rvc_zero
)
1942 if (*str
== 'e' || *str
== 'E')
1944 bool exp_neg
= false;
1952 else if (*str
== '+')
1956 while (ISDIGIT (*str
))
1962 /* Overflowed the exponent. */
1976 times_pten (r
, exp
);
1995 /* Legacy. Similar, but return the result directly. */
1998 real_from_string2 (const char *s
, enum machine_mode mode
)
2002 real_from_string (&r
, s
);
2003 if (mode
!= VOIDmode
)
2004 real_convert (&r
, mode
, &r
);
2009 /* Initialize R from string S and desired MODE. */
2012 real_from_string3 (REAL_VALUE_TYPE
*r
, const char *s
, enum machine_mode mode
)
2014 if (DECIMAL_FLOAT_MODE_P (mode
))
2015 decimal_real_from_string (r
, s
);
2017 real_from_string (r
, s
);
2019 if (mode
!= VOIDmode
)
2020 real_convert (r
, mode
, r
);
2023 /* Initialize R from the integer pair HIGH+LOW. */
2026 real_from_integer (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
2027 unsigned HOST_WIDE_INT low
, HOST_WIDE_INT high
,
2030 if (low
== 0 && high
== 0)
2034 memset (r
, 0, sizeof (*r
));
2036 r
->sign
= high
< 0 && !unsigned_p
;
2037 SET_REAL_EXP (r
, 2 * HOST_BITS_PER_WIDE_INT
);
2048 if (HOST_BITS_PER_LONG
== HOST_BITS_PER_WIDE_INT
)
2050 r
->sig
[SIGSZ
-1] = high
;
2051 r
->sig
[SIGSZ
-2] = low
;
2055 gcc_assert (HOST_BITS_PER_LONG
*2 == HOST_BITS_PER_WIDE_INT
);
2056 r
->sig
[SIGSZ
-1] = high
>> (HOST_BITS_PER_LONG
- 1) >> 1;
2057 r
->sig
[SIGSZ
-2] = high
;
2058 r
->sig
[SIGSZ
-3] = low
>> (HOST_BITS_PER_LONG
- 1) >> 1;
2059 r
->sig
[SIGSZ
-4] = low
;
2065 if (mode
!= VOIDmode
)
2066 real_convert (r
, mode
, r
);
2069 /* Returns 10**2**N. */
2071 static const REAL_VALUE_TYPE
*
2074 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2076 gcc_assert (n
>= 0);
2077 gcc_assert (n
< EXP_BITS
);
2079 if (tens
[n
].cl
== rvc_zero
)
2081 if (n
< (HOST_BITS_PER_WIDE_INT
== 64 ? 5 : 4))
2083 HOST_WIDE_INT t
= 10;
2086 for (i
= 0; i
< n
; ++i
)
2089 real_from_integer (&tens
[n
], VOIDmode
, t
, 0, 1);
2093 const REAL_VALUE_TYPE
*t
= ten_to_ptwo (n
- 1);
2094 do_multiply (&tens
[n
], t
, t
);
2101 /* Returns 10**(-2**N). */
2103 static const REAL_VALUE_TYPE
*
2104 ten_to_mptwo (int n
)
2106 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2108 gcc_assert (n
>= 0);
2109 gcc_assert (n
< EXP_BITS
);
2111 if (tens
[n
].cl
== rvc_zero
)
2112 do_divide (&tens
[n
], real_digit (1), ten_to_ptwo (n
));
2119 static const REAL_VALUE_TYPE
*
2122 static REAL_VALUE_TYPE num
[10];
2124 gcc_assert (n
>= 0);
2125 gcc_assert (n
<= 9);
2127 if (n
> 0 && num
[n
].cl
== rvc_zero
)
2128 real_from_integer (&num
[n
], VOIDmode
, n
, 0, 1);
2133 /* Multiply R by 10**EXP. */
2136 times_pten (REAL_VALUE_TYPE
*r
, int exp
)
2138 REAL_VALUE_TYPE pten
, *rr
;
2139 bool negative
= (exp
< 0);
2145 pten
= *real_digit (1);
2151 for (i
= 0; exp
> 0; ++i
, exp
>>= 1)
2153 do_multiply (rr
, rr
, ten_to_ptwo (i
));
2156 do_divide (r
, r
, &pten
);
2159 /* Fills R with +Inf. */
2162 real_inf (REAL_VALUE_TYPE
*r
)
2167 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2168 we force a QNaN, else we force an SNaN. The string, if not empty,
2169 is parsed as a number and placed in the significand. Return true
2170 if the string was successfully parsed. */
2173 real_nan (REAL_VALUE_TYPE
*r
, const char *str
, int quiet
,
2174 enum machine_mode mode
)
2176 const struct real_format
*fmt
;
2178 fmt
= REAL_MODE_FORMAT (mode
);
2184 get_canonical_qnan (r
, 0);
2186 get_canonical_snan (r
, 0);
2192 memset (r
, 0, sizeof (*r
));
2195 /* Parse akin to strtol into the significand of R. */
2197 while (ISSPACE (*str
))
2201 else if (*str
== '+')
2206 if (*str
== 'x' || *str
== 'X')
2215 while ((d
= hex_value (*str
)) < base
)
2222 lshift_significand (r
, r
, 3);
2225 lshift_significand (r
, r
, 4);
2228 lshift_significand_1 (&u
, r
);
2229 lshift_significand (r
, r
, 3);
2230 add_significands (r
, r
, &u
);
2238 add_significands (r
, r
, &u
);
2243 /* Must have consumed the entire string for success. */
2247 /* Shift the significand into place such that the bits
2248 are in the most significant bits for the format. */
2249 lshift_significand (r
, r
, SIGNIFICAND_BITS
- fmt
->pnan
);
2251 /* Our MSB is always unset for NaNs. */
2252 r
->sig
[SIGSZ
-1] &= ~SIG_MSB
;
2254 /* Force quiet or signalling NaN. */
2255 r
->signalling
= !quiet
;
2261 /* Fills R with the largest finite value representable in mode MODE.
2262 If SIGN is nonzero, R is set to the most negative finite value. */
2265 real_maxval (REAL_VALUE_TYPE
*r
, int sign
, enum machine_mode mode
)
2267 const struct real_format
*fmt
;
2270 fmt
= REAL_MODE_FORMAT (mode
);
2272 memset (r
, 0, sizeof (*r
));
2275 decimal_real_maxval (r
, sign
, mode
);
2280 SET_REAL_EXP (r
, fmt
->emax
);
2282 np2
= SIGNIFICAND_BITS
- fmt
->p
;
2283 memset (r
->sig
, -1, SIGSZ
* sizeof (unsigned long));
2284 clear_significand_below (r
, np2
);
2286 if (fmt
->pnan
< fmt
->p
)
2287 /* This is an IBM extended double format made up of two IEEE
2288 doubles. The value of the long double is the sum of the
2289 values of the two parts. The most significant part is
2290 required to be the value of the long double rounded to the
2291 nearest double. Rounding means we need a slightly smaller
2292 value for LDBL_MAX. */
2293 clear_significand_bit (r
, SIGNIFICAND_BITS
- fmt
->pnan
);
2297 /* Fills R with 2**N. */
2300 real_2expN (REAL_VALUE_TYPE
*r
, int n
)
2302 memset (r
, 0, sizeof (*r
));
2307 else if (n
< -MAX_EXP
)
2312 SET_REAL_EXP (r
, n
);
2313 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2319 round_for_format (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
)
2322 unsigned long sticky
;
2330 decimal_round_for_format (fmt
, r
);
2333 /* FIXME. We can come here via fp_easy_constant
2334 (e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
2335 investigated whether this convert needs to be here, or
2336 something else is missing. */
2337 decimal_real_convert (r
, DFmode
, r
);
2341 emin2m1
= fmt
->emin
- 1;
2344 np2
= SIGNIFICAND_BITS
- p2
;
2348 get_zero (r
, r
->sign
);
2350 if (!fmt
->has_signed_zero
)
2355 get_inf (r
, r
->sign
);
2360 clear_significand_below (r
, np2
);
2370 /* Check the range of the exponent. If we're out of range,
2371 either underflow or overflow. */
2372 if (REAL_EXP (r
) > emax2
)
2374 else if (REAL_EXP (r
) <= emin2m1
)
2378 if (!fmt
->has_denorm
)
2380 /* Don't underflow completely until we've had a chance to round. */
2381 if (REAL_EXP (r
) < emin2m1
)
2386 diff
= emin2m1
- REAL_EXP (r
) + 1;
2390 /* De-normalize the significand. */
2391 r
->sig
[0] |= sticky_rshift_significand (r
, r
, diff
);
2392 SET_REAL_EXP (r
, REAL_EXP (r
) + diff
);
2396 /* There are P2 true significand bits, followed by one guard bit,
2397 followed by one sticky bit, followed by stuff. Fold nonzero
2398 stuff into the sticky bit. */
2401 for (i
= 0, w
= (np2
- 1) / HOST_BITS_PER_LONG
; i
< w
; ++i
)
2402 sticky
|= r
->sig
[i
];
2404 r
->sig
[w
] & (((unsigned long)1 << ((np2
- 1) % HOST_BITS_PER_LONG
)) - 1);
2406 guard
= test_significand_bit (r
, np2
- 1);
2407 lsb
= test_significand_bit (r
, np2
);
2409 /* Round to even. */
2410 if (guard
&& (sticky
|| lsb
))
2414 set_significand_bit (&u
, np2
);
2416 if (add_significands (r
, r
, &u
))
2418 /* Overflow. Means the significand had been all ones, and
2419 is now all zeros. Need to increase the exponent, and
2420 possibly re-normalize it. */
2421 SET_REAL_EXP (r
, REAL_EXP (r
) + 1);
2422 if (REAL_EXP (r
) > emax2
)
2424 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2428 /* Catch underflow that we deferred until after rounding. */
2429 if (REAL_EXP (r
) <= emin2m1
)
2432 /* Clear out trailing garbage. */
2433 clear_significand_below (r
, np2
);
2436 /* Extend or truncate to a new mode. */
2439 real_convert (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
2440 const REAL_VALUE_TYPE
*a
)
2442 const struct real_format
*fmt
;
2444 fmt
= REAL_MODE_FORMAT (mode
);
2449 if (a
->decimal
|| fmt
->b
== 10)
2450 decimal_real_convert (r
, mode
, a
);
2452 round_for_format (fmt
, r
);
2454 /* round_for_format de-normalizes denormals. Undo just that part. */
2455 if (r
->cl
== rvc_normal
)
2459 /* Legacy. Likewise, except return the struct directly. */
2462 real_value_truncate (enum machine_mode mode
, REAL_VALUE_TYPE a
)
2465 real_convert (&r
, mode
, &a
);
2469 /* Return true if truncating to MODE is exact. */
2472 exact_real_truncate (enum machine_mode mode
, const REAL_VALUE_TYPE
*a
)
2474 const struct real_format
*fmt
;
2478 fmt
= REAL_MODE_FORMAT (mode
);
2481 /* Don't allow conversion to denormals. */
2482 emin2m1
= fmt
->emin
- 1;
2483 if (REAL_EXP (a
) <= emin2m1
)
2486 /* After conversion to the new mode, the value must be identical. */
2487 real_convert (&t
, mode
, a
);
2488 return real_identical (&t
, a
);
2491 /* Write R to the given target format. Place the words of the result
2492 in target word order in BUF. There are always 32 bits in each
2493 long, no matter the size of the host long.
2495 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2498 real_to_target_fmt (long *buf
, const REAL_VALUE_TYPE
*r_orig
,
2499 const struct real_format
*fmt
)
2505 round_for_format (fmt
, &r
);
2509 (*fmt
->encode
) (fmt
, buf
, &r
);
2514 /* Similar, but look up the format from MODE. */
2517 real_to_target (long *buf
, const REAL_VALUE_TYPE
*r
, enum machine_mode mode
)
2519 const struct real_format
*fmt
;
2521 fmt
= REAL_MODE_FORMAT (mode
);
2524 return real_to_target_fmt (buf
, r
, fmt
);
2527 /* Read R from the given target format. Read the words of the result
2528 in target word order in BUF. There are always 32 bits in each
2529 long, no matter the size of the host long. */
2532 real_from_target_fmt (REAL_VALUE_TYPE
*r
, const long *buf
,
2533 const struct real_format
*fmt
)
2535 (*fmt
->decode
) (fmt
, r
, buf
);
2538 /* Similar, but look up the format from MODE. */
2541 real_from_target (REAL_VALUE_TYPE
*r
, const long *buf
, enum machine_mode mode
)
2543 const struct real_format
*fmt
;
2545 fmt
= REAL_MODE_FORMAT (mode
);
2548 (*fmt
->decode
) (fmt
, r
, buf
);
2551 /* Return the number of bits of the largest binary value that the
2552 significand of MODE will hold. */
2553 /* ??? Legacy. Should get access to real_format directly. */
2556 significand_size (enum machine_mode mode
)
2558 const struct real_format
*fmt
;
2560 fmt
= REAL_MODE_FORMAT (mode
);
2566 /* Return the size in bits of the largest binary value that can be
2567 held by the decimal coefficient for this mode. This is one more
2568 than the number of bits required to hold the largest coefficient
2570 double log2_10
= 3.3219281;
2571 return fmt
->p
* log2_10
;
2576 /* Return a hash value for the given real value. */
2577 /* ??? The "unsigned int" return value is intended to be hashval_t,
2578 but I didn't want to pull hashtab.h into real.h. */
2581 real_hash (const REAL_VALUE_TYPE
*r
)
2586 h
= r
->cl
| (r
->sign
<< 2);
2594 h
|= REAL_EXP (r
) << 3;
2599 h
^= (unsigned int)-1;
2608 if (sizeof(unsigned long) > sizeof(unsigned int))
2609 for (i
= 0; i
< SIGSZ
; ++i
)
2611 unsigned long s
= r
->sig
[i
];
2612 h
^= s
^ (s
>> (HOST_BITS_PER_LONG
/ 2));
2615 for (i
= 0; i
< SIGSZ
; ++i
)
2621 /* IEEE single-precision format. */
2623 static void encode_ieee_single (const struct real_format
*fmt
,
2624 long *, const REAL_VALUE_TYPE
*);
2625 static void decode_ieee_single (const struct real_format
*,
2626 REAL_VALUE_TYPE
*, const long *);
2629 encode_ieee_single (const struct real_format
*fmt
, long *buf
,
2630 const REAL_VALUE_TYPE
*r
)
2632 unsigned long image
, sig
, exp
;
2633 unsigned long sign
= r
->sign
;
2634 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2637 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
2648 image
|= 0x7fffffff;
2655 sig
= (fmt
->canonical_nan_lsbs_set
? (1 << 22) - 1 : 0);
2656 if (r
->signalling
== fmt
->qnan_msb_set
)
2667 image
|= 0x7fffffff;
2671 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2672 whereas the intermediate representation is 0.F x 2**exp.
2673 Which means we're off by one. */
2677 exp
= REAL_EXP (r
) + 127 - 1;
2690 decode_ieee_single (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
2693 unsigned long image
= buf
[0] & 0xffffffff;
2694 bool sign
= (image
>> 31) & 1;
2695 int exp
= (image
>> 23) & 0xff;
2697 memset (r
, 0, sizeof (*r
));
2698 image
<<= HOST_BITS_PER_LONG
- 24;
2703 if (image
&& fmt
->has_denorm
)
2707 SET_REAL_EXP (r
, -126);
2708 r
->sig
[SIGSZ
-1] = image
<< 1;
2711 else if (fmt
->has_signed_zero
)
2714 else if (exp
== 255 && (fmt
->has_nans
|| fmt
->has_inf
))
2720 r
->signalling
= (((image
>> (HOST_BITS_PER_LONG
- 2)) & 1)
2721 ^ fmt
->qnan_msb_set
);
2722 r
->sig
[SIGSZ
-1] = image
;
2734 SET_REAL_EXP (r
, exp
- 127 + 1);
2735 r
->sig
[SIGSZ
-1] = image
| SIG_MSB
;
2739 const struct real_format ieee_single_format
=
2758 const struct real_format mips_single_format
=
2777 const struct real_format coldfire_single_format
=
2796 /* IEEE double-precision format. */
2798 static void encode_ieee_double (const struct real_format
*fmt
,
2799 long *, const REAL_VALUE_TYPE
*);
2800 static void decode_ieee_double (const struct real_format
*,
2801 REAL_VALUE_TYPE
*, const long *);
2804 encode_ieee_double (const struct real_format
*fmt
, long *buf
,
2805 const REAL_VALUE_TYPE
*r
)
2807 unsigned long image_lo
, image_hi
, sig_lo
, sig_hi
, exp
;
2808 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2810 image_hi
= r
->sign
<< 31;
2813 if (HOST_BITS_PER_LONG
== 64)
2815 sig_hi
= r
->sig
[SIGSZ
-1];
2816 sig_lo
= (sig_hi
>> (64 - 53)) & 0xffffffff;
2817 sig_hi
= (sig_hi
>> (64 - 53 + 1) >> 31) & 0xfffff;
2821 sig_hi
= r
->sig
[SIGSZ
-1];
2822 sig_lo
= r
->sig
[SIGSZ
-2];
2823 sig_lo
= (sig_hi
<< 21) | (sig_lo
>> 11);
2824 sig_hi
= (sig_hi
>> 11) & 0xfffff;
2834 image_hi
|= 2047 << 20;
2837 image_hi
|= 0x7fffffff;
2838 image_lo
= 0xffffffff;
2847 if (fmt
->canonical_nan_lsbs_set
)
2849 sig_hi
= (1 << 19) - 1;
2850 sig_lo
= 0xffffffff;
2858 if (r
->signalling
== fmt
->qnan_msb_set
)
2859 sig_hi
&= ~(1 << 19);
2862 if (sig_hi
== 0 && sig_lo
== 0)
2865 image_hi
|= 2047 << 20;
2871 image_hi
|= 0x7fffffff;
2872 image_lo
= 0xffffffff;
2877 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2878 whereas the intermediate representation is 0.F x 2**exp.
2879 Which means we're off by one. */
2883 exp
= REAL_EXP (r
) + 1023 - 1;
2884 image_hi
|= exp
<< 20;
2893 if (FLOAT_WORDS_BIG_ENDIAN
)
2894 buf
[0] = image_hi
, buf
[1] = image_lo
;
2896 buf
[0] = image_lo
, buf
[1] = image_hi
;
2900 decode_ieee_double (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
2903 unsigned long image_hi
, image_lo
;
2907 if (FLOAT_WORDS_BIG_ENDIAN
)
2908 image_hi
= buf
[0], image_lo
= buf
[1];
2910 image_lo
= buf
[0], image_hi
= buf
[1];
2911 image_lo
&= 0xffffffff;
2912 image_hi
&= 0xffffffff;
2914 sign
= (image_hi
>> 31) & 1;
2915 exp
= (image_hi
>> 20) & 0x7ff;
2917 memset (r
, 0, sizeof (*r
));
2919 image_hi
<<= 32 - 21;
2920 image_hi
|= image_lo
>> 21;
2921 image_hi
&= 0x7fffffff;
2922 image_lo
<<= 32 - 21;
2926 if ((image_hi
|| image_lo
) && fmt
->has_denorm
)
2930 SET_REAL_EXP (r
, -1022);
2931 if (HOST_BITS_PER_LONG
== 32)
2933 image_hi
= (image_hi
<< 1) | (image_lo
>> 31);
2935 r
->sig
[SIGSZ
-1] = image_hi
;
2936 r
->sig
[SIGSZ
-2] = image_lo
;
2940 image_hi
= (image_hi
<< 31 << 2) | (image_lo
<< 1);
2941 r
->sig
[SIGSZ
-1] = image_hi
;
2945 else if (fmt
->has_signed_zero
)
2948 else if (exp
== 2047 && (fmt
->has_nans
|| fmt
->has_inf
))
2950 if (image_hi
|| image_lo
)
2954 r
->signalling
= ((image_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
2955 if (HOST_BITS_PER_LONG
== 32)
2957 r
->sig
[SIGSZ
-1] = image_hi
;
2958 r
->sig
[SIGSZ
-2] = image_lo
;
2961 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
;
2973 SET_REAL_EXP (r
, exp
- 1023 + 1);
2974 if (HOST_BITS_PER_LONG
== 32)
2976 r
->sig
[SIGSZ
-1] = image_hi
| SIG_MSB
;
2977 r
->sig
[SIGSZ
-2] = image_lo
;
2980 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
| SIG_MSB
;
2984 const struct real_format ieee_double_format
=
3003 const struct real_format mips_double_format
=
3022 const struct real_format coldfire_double_format
=
3041 /* IEEE extended real format. This comes in three flavors: Intel's as
3042 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
3043 12- and 16-byte images may be big- or little endian; Motorola's is
3044 always big endian. */
3046 /* Helper subroutine which converts from the internal format to the
3047 12-byte little-endian Intel format. Functions below adjust this
3048 for the other possible formats. */
3050 encode_ieee_extended (const struct real_format
*fmt
, long *buf
,
3051 const REAL_VALUE_TYPE
*r
)
3053 unsigned long image_hi
, sig_hi
, sig_lo
;
3054 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3056 image_hi
= r
->sign
<< 15;
3057 sig_hi
= sig_lo
= 0;
3069 /* Intel requires the explicit integer bit to be set, otherwise
3070 it considers the value a "pseudo-infinity". Motorola docs
3071 say it doesn't care. */
3072 sig_hi
= 0x80000000;
3077 sig_lo
= sig_hi
= 0xffffffff;
3085 if (HOST_BITS_PER_LONG
== 32)
3087 sig_hi
= r
->sig
[SIGSZ
-1];
3088 sig_lo
= r
->sig
[SIGSZ
-2];
3092 sig_lo
= r
->sig
[SIGSZ
-1];
3093 sig_hi
= sig_lo
>> 31 >> 1;
3094 sig_lo
&= 0xffffffff;
3096 if (r
->signalling
== fmt
->qnan_msb_set
)
3097 sig_hi
&= ~(1 << 30);
3100 if ((sig_hi
& 0x7fffffff) == 0 && sig_lo
== 0)
3103 /* Intel requires the explicit integer bit to be set, otherwise
3104 it considers the value a "pseudo-nan". Motorola docs say it
3106 sig_hi
|= 0x80000000;
3111 sig_lo
= sig_hi
= 0xffffffff;
3117 int exp
= REAL_EXP (r
);
3119 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3120 whereas the intermediate representation is 0.F x 2**exp.
3121 Which means we're off by one.
3123 Except for Motorola, which consider exp=0 and explicit
3124 integer bit set to continue to be normalized. In theory
3125 this discrepancy has been taken care of by the difference
3126 in fmt->emin in round_for_format. */
3133 gcc_assert (exp
>= 0);
3137 if (HOST_BITS_PER_LONG
== 32)
3139 sig_hi
= r
->sig
[SIGSZ
-1];
3140 sig_lo
= r
->sig
[SIGSZ
-2];
3144 sig_lo
= r
->sig
[SIGSZ
-1];
3145 sig_hi
= sig_lo
>> 31 >> 1;
3146 sig_lo
&= 0xffffffff;
3155 buf
[0] = sig_lo
, buf
[1] = sig_hi
, buf
[2] = image_hi
;
3158 /* Convert from the internal format to the 12-byte Motorola format
3159 for an IEEE extended real. */
3161 encode_ieee_extended_motorola (const struct real_format
*fmt
, long *buf
,
3162 const REAL_VALUE_TYPE
*r
)
3165 encode_ieee_extended (fmt
, intermed
, r
);
3167 /* Motorola chips are assumed always to be big-endian. Also, the
3168 padding in a Motorola extended real goes between the exponent and
3169 the mantissa. At this point the mantissa is entirely within
3170 elements 0 and 1 of intermed, and the exponent entirely within
3171 element 2, so all we have to do is swap the order around, and
3172 shift element 2 left 16 bits. */
3173 buf
[0] = intermed
[2] << 16;
3174 buf
[1] = intermed
[1];
3175 buf
[2] = intermed
[0];
3178 /* Convert from the internal format to the 12-byte Intel format for
3179 an IEEE extended real. */
3181 encode_ieee_extended_intel_96 (const struct real_format
*fmt
, long *buf
,
3182 const REAL_VALUE_TYPE
*r
)
3184 if (FLOAT_WORDS_BIG_ENDIAN
)
3186 /* All the padding in an Intel-format extended real goes at the high
3187 end, which in this case is after the mantissa, not the exponent.
3188 Therefore we must shift everything down 16 bits. */
3190 encode_ieee_extended (fmt
, intermed
, r
);
3191 buf
[0] = ((intermed
[2] << 16) | ((unsigned long)(intermed
[1] & 0xFFFF0000) >> 16));
3192 buf
[1] = ((intermed
[1] << 16) | ((unsigned long)(intermed
[0] & 0xFFFF0000) >> 16));
3193 buf
[2] = (intermed
[0] << 16);
3196 /* encode_ieee_extended produces what we want directly. */
3197 encode_ieee_extended (fmt
, buf
, r
);
3200 /* Convert from the internal format to the 16-byte Intel format for
3201 an IEEE extended real. */
3203 encode_ieee_extended_intel_128 (const struct real_format
*fmt
, long *buf
,
3204 const REAL_VALUE_TYPE
*r
)
3206 /* All the padding in an Intel-format extended real goes at the high end. */
3207 encode_ieee_extended_intel_96 (fmt
, buf
, r
);
3211 /* As above, we have a helper function which converts from 12-byte
3212 little-endian Intel format to internal format. Functions below
3213 adjust for the other possible formats. */
3215 decode_ieee_extended (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3218 unsigned long image_hi
, sig_hi
, sig_lo
;
3222 sig_lo
= buf
[0], sig_hi
= buf
[1], image_hi
= buf
[2];
3223 sig_lo
&= 0xffffffff;
3224 sig_hi
&= 0xffffffff;
3225 image_hi
&= 0xffffffff;
3227 sign
= (image_hi
>> 15) & 1;
3228 exp
= image_hi
& 0x7fff;
3230 memset (r
, 0, sizeof (*r
));
3234 if ((sig_hi
|| sig_lo
) && fmt
->has_denorm
)
3239 /* When the IEEE format contains a hidden bit, we know that
3240 it's zero at this point, and so shift up the significand
3241 and decrease the exponent to match. In this case, Motorola
3242 defines the explicit integer bit to be valid, so we don't
3243 know whether the msb is set or not. */
3244 SET_REAL_EXP (r
, fmt
->emin
);
3245 if (HOST_BITS_PER_LONG
== 32)
3247 r
->sig
[SIGSZ
-1] = sig_hi
;
3248 r
->sig
[SIGSZ
-2] = sig_lo
;
3251 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3255 else if (fmt
->has_signed_zero
)
3258 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3260 /* See above re "pseudo-infinities" and "pseudo-nans".
3261 Short summary is that the MSB will likely always be
3262 set, and that we don't care about it. */
3263 sig_hi
&= 0x7fffffff;
3265 if (sig_hi
|| sig_lo
)
3269 r
->signalling
= ((sig_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
3270 if (HOST_BITS_PER_LONG
== 32)
3272 r
->sig
[SIGSZ
-1] = sig_hi
;
3273 r
->sig
[SIGSZ
-2] = sig_lo
;
3276 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3288 SET_REAL_EXP (r
, exp
- 16383 + 1);
3289 if (HOST_BITS_PER_LONG
== 32)
3291 r
->sig
[SIGSZ
-1] = sig_hi
;
3292 r
->sig
[SIGSZ
-2] = sig_lo
;
3295 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3299 /* Convert from the internal format to the 12-byte Motorola format
3300 for an IEEE extended real. */
3302 decode_ieee_extended_motorola (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3307 /* Motorola chips are assumed always to be big-endian. Also, the
3308 padding in a Motorola extended real goes between the exponent and
3309 the mantissa; remove it. */
3310 intermed
[0] = buf
[2];
3311 intermed
[1] = buf
[1];
3312 intermed
[2] = (unsigned long)buf
[0] >> 16;
3314 decode_ieee_extended (fmt
, r
, intermed
);
3317 /* Convert from the internal format to the 12-byte Intel format for
3318 an IEEE extended real. */
3320 decode_ieee_extended_intel_96 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3323 if (FLOAT_WORDS_BIG_ENDIAN
)
3325 /* All the padding in an Intel-format extended real goes at the high
3326 end, which in this case is after the mantissa, not the exponent.
3327 Therefore we must shift everything up 16 bits. */
3330 intermed
[0] = (((unsigned long)buf
[2] >> 16) | (buf
[1] << 16));
3331 intermed
[1] = (((unsigned long)buf
[1] >> 16) | (buf
[0] << 16));
3332 intermed
[2] = ((unsigned long)buf
[0] >> 16);
3334 decode_ieee_extended (fmt
, r
, intermed
);
3337 /* decode_ieee_extended produces what we want directly. */
3338 decode_ieee_extended (fmt
, r
, buf
);
3341 /* Convert from the internal format to the 16-byte Intel format for
3342 an IEEE extended real. */
3344 decode_ieee_extended_intel_128 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3347 /* All the padding in an Intel-format extended real goes at the high end. */
3348 decode_ieee_extended_intel_96 (fmt
, r
, buf
);
3351 const struct real_format ieee_extended_motorola_format
=
3353 encode_ieee_extended_motorola
,
3354 decode_ieee_extended_motorola
,
3370 const struct real_format ieee_extended_intel_96_format
=
3372 encode_ieee_extended_intel_96
,
3373 decode_ieee_extended_intel_96
,
3389 const struct real_format ieee_extended_intel_128_format
=
3391 encode_ieee_extended_intel_128
,
3392 decode_ieee_extended_intel_128
,
3408 /* The following caters to i386 systems that set the rounding precision
3409 to 53 bits instead of 64, e.g. FreeBSD. */
3410 const struct real_format ieee_extended_intel_96_round_53_format
=
3412 encode_ieee_extended_intel_96
,
3413 decode_ieee_extended_intel_96
,
3429 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3430 numbers whose sum is equal to the extended precision value. The number
3431 with greater magnitude is first. This format has the same magnitude
3432 range as an IEEE double precision value, but effectively 106 bits of
3433 significand precision. Infinity and NaN are represented by their IEEE
3434 double precision value stored in the first number, the second number is
3435 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3437 static void encode_ibm_extended (const struct real_format
*fmt
,
3438 long *, const REAL_VALUE_TYPE
*);
3439 static void decode_ibm_extended (const struct real_format
*,
3440 REAL_VALUE_TYPE
*, const long *);
3443 encode_ibm_extended (const struct real_format
*fmt
, long *buf
,
3444 const REAL_VALUE_TYPE
*r
)
3446 REAL_VALUE_TYPE u
, normr
, v
;
3447 const struct real_format
*base_fmt
;
3449 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3451 /* Renormlize R before doing any arithmetic on it. */
3453 if (normr
.cl
== rvc_normal
)
3456 /* u = IEEE double precision portion of significand. */
3458 round_for_format (base_fmt
, &u
);
3459 encode_ieee_double (base_fmt
, &buf
[0], &u
);
3461 if (u
.cl
== rvc_normal
)
3463 do_add (&v
, &normr
, &u
, 1);
3464 /* Call round_for_format since we might need to denormalize. */
3465 round_for_format (base_fmt
, &v
);
3466 encode_ieee_double (base_fmt
, &buf
[2], &v
);
3470 /* Inf, NaN, 0 are all representable as doubles, so the
3471 least-significant part can be 0.0. */
3478 decode_ibm_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
, REAL_VALUE_TYPE
*r
,
3481 REAL_VALUE_TYPE u
, v
;
3482 const struct real_format
*base_fmt
;
3484 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3485 decode_ieee_double (base_fmt
, &u
, &buf
[0]);
3487 if (u
.cl
!= rvc_zero
&& u
.cl
!= rvc_inf
&& u
.cl
!= rvc_nan
)
3489 decode_ieee_double (base_fmt
, &v
, &buf
[2]);
3490 do_add (r
, &u
, &v
, 0);
3496 const struct real_format ibm_extended_format
=
3498 encode_ibm_extended
,
3499 decode_ibm_extended
,
3515 const struct real_format mips_extended_format
=
3517 encode_ibm_extended
,
3518 decode_ibm_extended
,
3535 /* IEEE quad precision format. */
3537 static void encode_ieee_quad (const struct real_format
*fmt
,
3538 long *, const REAL_VALUE_TYPE
*);
3539 static void decode_ieee_quad (const struct real_format
*,
3540 REAL_VALUE_TYPE
*, const long *);
3543 encode_ieee_quad (const struct real_format
*fmt
, long *buf
,
3544 const REAL_VALUE_TYPE
*r
)
3546 unsigned long image3
, image2
, image1
, image0
, exp
;
3547 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3550 image3
= r
->sign
<< 31;
3555 rshift_significand (&u
, r
, SIGNIFICAND_BITS
- 113);
3564 image3
|= 32767 << 16;
3567 image3
|= 0x7fffffff;
3568 image2
= 0xffffffff;
3569 image1
= 0xffffffff;
3570 image0
= 0xffffffff;
3577 image3
|= 32767 << 16;
3581 if (fmt
->canonical_nan_lsbs_set
)
3584 image2
= image1
= image0
= 0xffffffff;
3587 else if (HOST_BITS_PER_LONG
== 32)
3592 image3
|= u
.sig
[3] & 0xffff;
3597 image1
= image0
>> 31 >> 1;
3599 image3
|= (image2
>> 31 >> 1) & 0xffff;
3600 image0
&= 0xffffffff;
3601 image2
&= 0xffffffff;
3603 if (r
->signalling
== fmt
->qnan_msb_set
)
3607 if (((image3
& 0xffff) | image2
| image1
| image0
) == 0)
3612 image3
|= 0x7fffffff;
3613 image2
= 0xffffffff;
3614 image1
= 0xffffffff;
3615 image0
= 0xffffffff;
3620 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3621 whereas the intermediate representation is 0.F x 2**exp.
3622 Which means we're off by one. */
3626 exp
= REAL_EXP (r
) + 16383 - 1;
3627 image3
|= exp
<< 16;
3629 if (HOST_BITS_PER_LONG
== 32)
3634 image3
|= u
.sig
[3] & 0xffff;
3639 image1
= image0
>> 31 >> 1;
3641 image3
|= (image2
>> 31 >> 1) & 0xffff;
3642 image0
&= 0xffffffff;
3643 image2
&= 0xffffffff;
3651 if (FLOAT_WORDS_BIG_ENDIAN
)
3668 decode_ieee_quad (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3671 unsigned long image3
, image2
, image1
, image0
;
3675 if (FLOAT_WORDS_BIG_ENDIAN
)
3689 image0
&= 0xffffffff;
3690 image1
&= 0xffffffff;
3691 image2
&= 0xffffffff;
3693 sign
= (image3
>> 31) & 1;
3694 exp
= (image3
>> 16) & 0x7fff;
3697 memset (r
, 0, sizeof (*r
));
3701 if ((image3
| image2
| image1
| image0
) && fmt
->has_denorm
)
3706 SET_REAL_EXP (r
, -16382 + (SIGNIFICAND_BITS
- 112));
3707 if (HOST_BITS_PER_LONG
== 32)
3716 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3717 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3722 else if (fmt
->has_signed_zero
)
3725 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3727 if (image3
| image2
| image1
| image0
)
3731 r
->signalling
= ((image3
>> 15) & 1) ^ fmt
->qnan_msb_set
;
3733 if (HOST_BITS_PER_LONG
== 32)
3742 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3743 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3745 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3757 SET_REAL_EXP (r
, exp
- 16383 + 1);
3759 if (HOST_BITS_PER_LONG
== 32)
3768 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3769 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3771 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3772 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3776 const struct real_format ieee_quad_format
=
3795 const struct real_format mips_quad_format
=
3814 /* Descriptions of VAX floating point formats can be found beginning at
3816 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
3818 The thing to remember is that they're almost IEEE, except for word
3819 order, exponent bias, and the lack of infinities, nans, and denormals.
3821 We don't implement the H_floating format here, simply because neither
3822 the VAX or Alpha ports use it. */
3824 static void encode_vax_f (const struct real_format
*fmt
,
3825 long *, const REAL_VALUE_TYPE
*);
3826 static void decode_vax_f (const struct real_format
*,
3827 REAL_VALUE_TYPE
*, const long *);
3828 static void encode_vax_d (const struct real_format
*fmt
,
3829 long *, const REAL_VALUE_TYPE
*);
3830 static void decode_vax_d (const struct real_format
*,
3831 REAL_VALUE_TYPE
*, const long *);
3832 static void encode_vax_g (const struct real_format
*fmt
,
3833 long *, const REAL_VALUE_TYPE
*);
3834 static void decode_vax_g (const struct real_format
*,
3835 REAL_VALUE_TYPE
*, const long *);
3838 encode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3839 const REAL_VALUE_TYPE
*r
)
3841 unsigned long sign
, exp
, sig
, image
;
3843 sign
= r
->sign
<< 15;
3853 image
= 0xffff7fff | sign
;
3857 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
3858 exp
= REAL_EXP (r
) + 128;
3860 image
= (sig
<< 16) & 0xffff0000;
3874 decode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3875 REAL_VALUE_TYPE
*r
, const long *buf
)
3877 unsigned long image
= buf
[0] & 0xffffffff;
3878 int exp
= (image
>> 7) & 0xff;
3880 memset (r
, 0, sizeof (*r
));
3885 r
->sign
= (image
>> 15) & 1;
3886 SET_REAL_EXP (r
, exp
- 128);
3888 image
= ((image
& 0x7f) << 16) | ((image
>> 16) & 0xffff);
3889 r
->sig
[SIGSZ
-1] = (image
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
3894 encode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3895 const REAL_VALUE_TYPE
*r
)
3897 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
3902 image0
= image1
= 0;
3907 image0
= 0xffff7fff | sign
;
3908 image1
= 0xffffffff;
3912 /* Extract the significand into straight hi:lo. */
3913 if (HOST_BITS_PER_LONG
== 64)
3915 image0
= r
->sig
[SIGSZ
-1];
3916 image1
= (image0
>> (64 - 56)) & 0xffffffff;
3917 image0
= (image0
>> (64 - 56 + 1) >> 31) & 0x7fffff;
3921 image0
= r
->sig
[SIGSZ
-1];
3922 image1
= r
->sig
[SIGSZ
-2];
3923 image1
= (image0
<< 24) | (image1
>> 8);
3924 image0
= (image0
>> 8) & 0xffffff;
3927 /* Rearrange the half-words of the significand to match the
3929 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff007f;
3930 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
3932 /* Add the sign and exponent. */
3934 image0
|= (REAL_EXP (r
) + 128) << 7;
3941 if (FLOAT_WORDS_BIG_ENDIAN
)
3942 buf
[0] = image1
, buf
[1] = image0
;
3944 buf
[0] = image0
, buf
[1] = image1
;
3948 decode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3949 REAL_VALUE_TYPE
*r
, const long *buf
)
3951 unsigned long image0
, image1
;
3954 if (FLOAT_WORDS_BIG_ENDIAN
)
3955 image1
= buf
[0], image0
= buf
[1];
3957 image0
= buf
[0], image1
= buf
[1];
3958 image0
&= 0xffffffff;
3959 image1
&= 0xffffffff;
3961 exp
= (image0
>> 7) & 0xff;
3963 memset (r
, 0, sizeof (*r
));
3968 r
->sign
= (image0
>> 15) & 1;
3969 SET_REAL_EXP (r
, exp
- 128);
3971 /* Rearrange the half-words of the external format into
3972 proper ascending order. */
3973 image0
= ((image0
& 0x7f) << 16) | ((image0
>> 16) & 0xffff);
3974 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
3976 if (HOST_BITS_PER_LONG
== 64)
3978 image0
= (image0
<< 31 << 1) | image1
;
3981 r
->sig
[SIGSZ
-1] = image0
;
3985 r
->sig
[SIGSZ
-1] = image0
;
3986 r
->sig
[SIGSZ
-2] = image1
;
3987 lshift_significand (r
, r
, 2*HOST_BITS_PER_LONG
- 56);
3988 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3994 encode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3995 const REAL_VALUE_TYPE
*r
)
3997 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
4002 image0
= image1
= 0;
4007 image0
= 0xffff7fff | sign
;
4008 image1
= 0xffffffff;
4012 /* Extract the significand into straight hi:lo. */
4013 if (HOST_BITS_PER_LONG
== 64)
4015 image0
= r
->sig
[SIGSZ
-1];
4016 image1
= (image0
>> (64 - 53)) & 0xffffffff;
4017 image0
= (image0
>> (64 - 53 + 1) >> 31) & 0xfffff;
4021 image0
= r
->sig
[SIGSZ
-1];
4022 image1
= r
->sig
[SIGSZ
-2];
4023 image1
= (image0
<< 21) | (image1
>> 11);
4024 image0
= (image0
>> 11) & 0xfffff;
4027 /* Rearrange the half-words of the significand to match the
4029 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff000f;
4030 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
4032 /* Add the sign and exponent. */
4034 image0
|= (REAL_EXP (r
) + 1024) << 4;
4041 if (FLOAT_WORDS_BIG_ENDIAN
)
4042 buf
[0] = image1
, buf
[1] = image0
;
4044 buf
[0] = image0
, buf
[1] = image1
;
4048 decode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4049 REAL_VALUE_TYPE
*r
, const long *buf
)
4051 unsigned long image0
, image1
;
4054 if (FLOAT_WORDS_BIG_ENDIAN
)
4055 image1
= buf
[0], image0
= buf
[1];
4057 image0
= buf
[0], image1
= buf
[1];
4058 image0
&= 0xffffffff;
4059 image1
&= 0xffffffff;
4061 exp
= (image0
>> 4) & 0x7ff;
4063 memset (r
, 0, sizeof (*r
));
4068 r
->sign
= (image0
>> 15) & 1;
4069 SET_REAL_EXP (r
, exp
- 1024);
4071 /* Rearrange the half-words of the external format into
4072 proper ascending order. */
4073 image0
= ((image0
& 0xf) << 16) | ((image0
>> 16) & 0xffff);
4074 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
4076 if (HOST_BITS_PER_LONG
== 64)
4078 image0
= (image0
<< 31 << 1) | image1
;
4081 r
->sig
[SIGSZ
-1] = image0
;
4085 r
->sig
[SIGSZ
-1] = image0
;
4086 r
->sig
[SIGSZ
-2] = image1
;
4087 lshift_significand (r
, r
, 64 - 53);
4088 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
4093 const struct real_format vax_f_format
=
4112 const struct real_format vax_d_format
=
4131 const struct real_format vax_g_format
=
4150 /* Encode real R into a single precision DFP value in BUF. */
4152 encode_decimal_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4153 long *buf ATTRIBUTE_UNUSED
,
4154 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4156 encode_decimal32 (fmt
, buf
, r
);
4159 /* Decode a single precision DFP value in BUF into a real R. */
4161 decode_decimal_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4162 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4163 const long *buf ATTRIBUTE_UNUSED
)
4165 decode_decimal32 (fmt
, r
, buf
);
4168 /* Encode real R into a double precision DFP value in BUF. */
4170 encode_decimal_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4171 long *buf ATTRIBUTE_UNUSED
,
4172 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4174 encode_decimal64 (fmt
, buf
, r
);
4177 /* Decode a double precision DFP value in BUF into a real R. */
4179 decode_decimal_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4180 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4181 const long *buf ATTRIBUTE_UNUSED
)
4183 decode_decimal64 (fmt
, r
, buf
);
4186 /* Encode real R into a quad precision DFP value in BUF. */
4188 encode_decimal_quad (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4189 long *buf ATTRIBUTE_UNUSED
,
4190 const REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
)
4192 encode_decimal128 (fmt
, buf
, r
);
4195 /* Decode a quad precision DFP value in BUF into a real R. */
4197 decode_decimal_quad (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4198 REAL_VALUE_TYPE
*r ATTRIBUTE_UNUSED
,
4199 const long *buf ATTRIBUTE_UNUSED
)
4201 decode_decimal128 (fmt
, r
, buf
);
4204 /* Single precision decimal floating point (IEEE 754R). */
4205 const struct real_format decimal_single_format
=
4207 encode_decimal_single
,
4208 decode_decimal_single
,
4224 /* Double precision decimal floating point (IEEE 754R). */
4225 const struct real_format decimal_double_format
=
4227 encode_decimal_double
,
4228 decode_decimal_double
,
4244 /* Quad precision decimal floating point (IEEE 754R). */
4245 const struct real_format decimal_quad_format
=
4247 encode_decimal_quad
,
4248 decode_decimal_quad
,
4264 /* The "twos-complement" c4x format is officially defined as
4268 This is rather misleading. One must remember that F is signed.
4269 A better description would be
4271 x = -1**s * ((s + 1 + .f) * 2**e
4273 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
4274 that's -1 * (1+1+(-.5)) == -1.5. I think.
4276 The constructions here are taken from Tables 5-1 and 5-2 of the
4277 TMS320C4x User's Guide wherein step-by-step instructions for
4278 conversion from IEEE are presented. That's close enough to our
4279 internal representation so as to make things easy.
4281 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
4283 static void encode_c4x_single (const struct real_format
*fmt
,
4284 long *, const REAL_VALUE_TYPE
*);
4285 static void decode_c4x_single (const struct real_format
*,
4286 REAL_VALUE_TYPE
*, const long *);
4287 static void encode_c4x_extended (const struct real_format
*fmt
,
4288 long *, const REAL_VALUE_TYPE
*);
4289 static void decode_c4x_extended (const struct real_format
*,
4290 REAL_VALUE_TYPE
*, const long *);
4293 encode_c4x_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4294 long *buf
, const REAL_VALUE_TYPE
*r
)
4296 unsigned long image
, exp
, sig
;
4308 sig
= 0x800000 - r
->sign
;
4312 exp
= REAL_EXP (r
) - 1;
4313 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
4328 image
= ((exp
& 0xff) << 24) | (sig
& 0xffffff);
4333 decode_c4x_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4334 REAL_VALUE_TYPE
*r
, const long *buf
)
4336 unsigned long image
= buf
[0];
4340 exp
= (((image
>> 24) & 0xff) ^ 0x80) - 0x80;
4341 sf
= ((image
& 0xffffff) ^ 0x800000) - 0x800000;
4343 memset (r
, 0, sizeof (*r
));
4349 sig
= sf
& 0x7fffff;
4358 sig
= (sig
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
4360 SET_REAL_EXP (r
, exp
+ 1);
4361 r
->sig
[SIGSZ
-1] = sig
;
4366 encode_c4x_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4367 long *buf
, const REAL_VALUE_TYPE
*r
)
4369 unsigned long exp
, sig
;
4381 sig
= 0x80000000 - r
->sign
;
4385 exp
= REAL_EXP (r
) - 1;
4387 sig
= r
->sig
[SIGSZ
-1];
4388 if (HOST_BITS_PER_LONG
== 64)
4389 sig
= sig
>> 1 >> 31;
4406 exp
= (exp
& 0xff) << 24;
4409 if (FLOAT_WORDS_BIG_ENDIAN
)
4410 buf
[0] = exp
, buf
[1] = sig
;
4412 buf
[0] = sig
, buf
[0] = exp
;
4416 decode_c4x_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4417 REAL_VALUE_TYPE
*r
, const long *buf
)
4422 if (FLOAT_WORDS_BIG_ENDIAN
)
4423 exp
= buf
[0], sf
= buf
[1];
4425 sf
= buf
[0], exp
= buf
[1];
4427 exp
= (((exp
>> 24) & 0xff) & 0x80) - 0x80;
4428 sf
= ((sf
& 0xffffffff) ^ 0x80000000) - 0x80000000;
4430 memset (r
, 0, sizeof (*r
));
4436 sig
= sf
& 0x7fffffff;
4445 if (HOST_BITS_PER_LONG
== 64)
4446 sig
= sig
<< 1 << 31;
4449 SET_REAL_EXP (r
, exp
+ 1);
4450 r
->sig
[SIGSZ
-1] = sig
;
4454 const struct real_format c4x_single_format
=
4473 const struct real_format c4x_extended_format
=
4475 encode_c4x_extended
,
4476 decode_c4x_extended
,
4493 /* A synthetic "format" for internal arithmetic. It's the size of the
4494 internal significand minus the two bits needed for proper rounding.
4495 The encode and decode routines exist only to satisfy our paranoia
4498 static void encode_internal (const struct real_format
*fmt
,
4499 long *, const REAL_VALUE_TYPE
*);
4500 static void decode_internal (const struct real_format
*,
4501 REAL_VALUE_TYPE
*, const long *);
4504 encode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4505 const REAL_VALUE_TYPE
*r
)
4507 memcpy (buf
, r
, sizeof (*r
));
4511 decode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4512 REAL_VALUE_TYPE
*r
, const long *buf
)
4514 memcpy (r
, buf
, sizeof (*r
));
4517 const struct real_format real_internal_format
=
4522 SIGNIFICAND_BITS
- 2,
4523 SIGNIFICAND_BITS
- 2,
4536 /* Calculate the square root of X in mode MODE, and store the result
4537 in R. Return TRUE if the operation does not raise an exception.
4538 For details see "High Precision Division and Square Root",
4539 Alan H. Karp and Peter Markstein, HP Lab Report 93-93-42, June
4540 1993. http://www.hpl.hp.com/techreports/93/HPL-93-42.pdf. */
4543 real_sqrt (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4544 const REAL_VALUE_TYPE
*x
)
4546 static REAL_VALUE_TYPE halfthree
;
4547 static bool init
= false;
4548 REAL_VALUE_TYPE h
, t
, i
;
4551 /* sqrt(-0.0) is -0.0. */
4552 if (real_isnegzero (x
))
4558 /* Negative arguments return NaN. */
4561 get_canonical_qnan (r
, 0);
4565 /* Infinity and NaN return themselves. */
4566 if (real_isinf (x
) || real_isnan (x
))
4574 do_add (&halfthree
, &dconst1
, &dconsthalf
, 0);
4578 /* Initial guess for reciprocal sqrt, i. */
4579 exp
= real_exponent (x
);
4580 real_ldexp (&i
, &dconst1
, -exp
/2);
4582 /* Newton's iteration for reciprocal sqrt, i. */
4583 for (iter
= 0; iter
< 16; iter
++)
4585 /* i(n+1) = i(n) * (1.5 - 0.5*i(n)*i(n)*x). */
4586 do_multiply (&t
, x
, &i
);
4587 do_multiply (&h
, &t
, &i
);
4588 do_multiply (&t
, &h
, &dconsthalf
);
4589 do_add (&h
, &halfthree
, &t
, 1);
4590 do_multiply (&t
, &i
, &h
);
4592 /* Check for early convergence. */
4593 if (iter
>= 6 && real_identical (&i
, &t
))
4596 /* ??? Unroll loop to avoid copying. */
4600 /* Final iteration: r = i*x + 0.5*i*x*(1.0 - i*(i*x)). */
4601 do_multiply (&t
, x
, &i
);
4602 do_multiply (&h
, &t
, &i
);
4603 do_add (&i
, &dconst1
, &h
, 1);
4604 do_multiply (&h
, &t
, &i
);
4605 do_multiply (&i
, &dconsthalf
, &h
);
4606 do_add (&h
, &t
, &i
, 0);
4608 /* ??? We need a Tuckerman test to get the last bit. */
4610 real_convert (r
, mode
, &h
);
4614 /* Calculate X raised to the integer exponent N in mode MODE and store
4615 the result in R. Return true if the result may be inexact due to
4616 loss of precision. The algorithm is the classic "left-to-right binary
4617 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
4618 Algorithms", "The Art of Computer Programming", Volume 2. */
4621 real_powi (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4622 const REAL_VALUE_TYPE
*x
, HOST_WIDE_INT n
)
4624 unsigned HOST_WIDE_INT bit
;
4626 bool inexact
= false;
4638 /* Don't worry about overflow, from now on n is unsigned. */
4646 bit
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
4647 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
; i
++)
4651 inexact
|= do_multiply (&t
, &t
, &t
);
4653 inexact
|= do_multiply (&t
, &t
, x
);
4661 inexact
|= do_divide (&t
, &dconst1
, &t
);
4663 real_convert (r
, mode
, &t
);
4667 /* Round X to the nearest integer not larger in absolute value, i.e.
4668 towards zero, placing the result in R in mode MODE. */
4671 real_trunc (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4672 const REAL_VALUE_TYPE
*x
)
4674 do_fix_trunc (r
, x
);
4675 if (mode
!= VOIDmode
)
4676 real_convert (r
, mode
, r
);
4679 /* Round X to the largest integer not greater in value, i.e. round
4680 down, placing the result in R in mode MODE. */
4683 real_floor (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4684 const REAL_VALUE_TYPE
*x
)
4688 do_fix_trunc (&t
, x
);
4689 if (! real_identical (&t
, x
) && x
->sign
)
4690 do_add (&t
, &t
, &dconstm1
, 0);
4691 if (mode
!= VOIDmode
)
4692 real_convert (r
, mode
, &t
);
4697 /* Round X to the smallest integer not less then argument, i.e. round
4698 up, placing the result in R in mode MODE. */
4701 real_ceil (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4702 const REAL_VALUE_TYPE
*x
)
4706 do_fix_trunc (&t
, x
);
4707 if (! real_identical (&t
, x
) && ! x
->sign
)
4708 do_add (&t
, &t
, &dconst1
, 0);
4709 if (mode
!= VOIDmode
)
4710 real_convert (r
, mode
, &t
);
4715 /* Round X to the nearest integer, but round halfway cases away from
4719 real_round (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4720 const REAL_VALUE_TYPE
*x
)
4722 do_add (r
, x
, &dconsthalf
, x
->sign
);
4723 do_fix_trunc (r
, r
);
4724 if (mode
!= VOIDmode
)
4725 real_convert (r
, mode
, r
);
4728 /* Set the sign of R to the sign of X. */
4731 real_copysign (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*x
)
4736 /* Convert from REAL_VALUE_TYPE to MPFR. The caller is responsible
4737 for initializing and clearing the MPFR parameter. */
4740 mpfr_from_real (mpfr_ptr m
, const REAL_VALUE_TYPE
*r
, mp_rnd_t rndmode
)
4742 /* We use a string as an intermediate type. */
4746 /* Take care of Infinity and NaN. */
4747 if (r
->cl
== rvc_inf
)
4749 mpfr_set_inf (m
, r
->sign
);
4753 if (r
->cl
== rvc_nan
)
4759 real_to_hexadecimal (buf
, r
, sizeof (buf
), 0, 1);
4760 /* mpfr_set_str() parses hexadecimal floats from strings in the same
4761 format that GCC will output them. Nothing extra is needed. */
4762 ret
= mpfr_set_str (m
, buf
, 16, rndmode
);
4763 gcc_assert (ret
== 0);
4766 /* Convert from MPFR to REAL_VALUE_TYPE, for a given type TYPE and rounding
4767 mode RNDMODE. TYPE is only relevant if M is a NaN. */
4770 real_from_mpfr (REAL_VALUE_TYPE
*r
, mpfr_srcptr m
, tree type
, mp_rnd_t rndmode
)
4772 /* We use a string as an intermediate type. */
4773 char buf
[128], *rstr
;
4776 /* Take care of Infinity and NaN. */
4780 if (mpfr_sgn (m
) < 0)
4781 *r
= REAL_VALUE_NEGATE (*r
);
4787 real_nan (r
, "", 1, TYPE_MODE (type
));
4791 rstr
= mpfr_get_str (NULL
, &exp
, 16, 0, m
, rndmode
);
4793 /* The additional 12 chars add space for the sprintf below. This
4794 leaves 6 digits for the exponent which is supposedly enough. */
4795 gcc_assert (rstr
!= NULL
&& strlen (rstr
) < sizeof (buf
) - 12);
4797 /* REAL_VALUE_ATOF expects the exponent for mantissa * 2**exp,
4798 mpfr_get_str returns the exponent for mantissa * 16**exp, adjust
4803 sprintf (buf
, "-0x.%sp%d", &rstr
[1], (int) exp
);
4805 sprintf (buf
, "0x.%sp%d", rstr
, (int) exp
);
4807 mpfr_free_str (rstr
);
4809 real_from_string (r
, buf
);
4812 /* Check whether the real constant value given is an integer. */
4815 real_isinteger (const REAL_VALUE_TYPE
*c
, enum machine_mode mode
)
4817 REAL_VALUE_TYPE cint
;
4819 real_trunc (&cint
, mode
, c
);
4820 return real_identical (c
, &cint
);