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"
33 /* The floating point model used internally is not exactly IEEE 754
34 compliant, and close to the description in the ISO C99 standard,
35 section 5.2.4.2.2 Characteristics of floating types.
39 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
43 b = base or radix, here always 2
45 p = precision (the number of base-b digits in the significand)
46 f_k = the digits of the significand.
48 We differ from typical IEEE 754 encodings in that the entire
49 significand is fractional. Normalized significands are in the
52 A requirement of the model is that P be larger than the largest
53 supported target floating-point type by at least 2 bits. This gives
54 us proper rounding when we truncate to the target type. In addition,
55 E must be large enough to hold the smallest supported denormal number
58 Both of these requirements are easily satisfied. The largest target
59 significand is 113 bits; we store at least 160. The smallest
60 denormal number fits in 17 exponent bits; we store 27.
62 Note that the decimal string conversion routines are sensitive to
63 rounding errors. Since the raw arithmetic routines do not themselves
64 have guard digits or rounding, the computation of 10**exp can
65 accumulate more than a few digits of error. The previous incarnation
66 of real.c successfully used a 144-bit fraction; given the current
67 layout of REAL_VALUE_TYPE we're forced to expand to at least 160 bits.
69 Target floating point models that use base 16 instead of base 2
70 (i.e. IBM 370), are handled during round_for_format, in which we
71 canonicalize the exponent to be a multiple of 4 (log2(16)), and
72 adjust the significand to match. */
75 /* Used to classify two numbers simultaneously. */
76 #define CLASS2(A, B) ((A) << 2 | (B))
78 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
79 #error "Some constant folding done by hand to avoid shift count warnings"
82 static void get_zero (REAL_VALUE_TYPE
*, int);
83 static void get_canonical_qnan (REAL_VALUE_TYPE
*, int);
84 static void get_canonical_snan (REAL_VALUE_TYPE
*, int);
85 static void get_inf (REAL_VALUE_TYPE
*, int);
86 static bool sticky_rshift_significand (REAL_VALUE_TYPE
*,
87 const REAL_VALUE_TYPE
*, unsigned int);
88 static void rshift_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
90 static void lshift_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
92 static void lshift_significand_1 (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
93 static bool add_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*,
94 const REAL_VALUE_TYPE
*);
95 static bool sub_significands (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
96 const REAL_VALUE_TYPE
*, int);
97 static void neg_significand (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
98 static int cmp_significands (const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
99 static int cmp_significand_0 (const REAL_VALUE_TYPE
*);
100 static void set_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
101 static void clear_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
102 static bool test_significand_bit (REAL_VALUE_TYPE
*, unsigned int);
103 static void clear_significand_below (REAL_VALUE_TYPE
*, unsigned int);
104 static bool div_significands (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
105 const REAL_VALUE_TYPE
*);
106 static void normalize (REAL_VALUE_TYPE
*);
108 static bool do_add (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
109 const REAL_VALUE_TYPE
*, int);
110 static bool do_multiply (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
111 const REAL_VALUE_TYPE
*);
112 static bool do_divide (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
113 const REAL_VALUE_TYPE
*);
114 static int do_compare (const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*, int);
115 static void do_fix_trunc (REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*);
117 static unsigned long rtd_divmod (REAL_VALUE_TYPE
*, REAL_VALUE_TYPE
*);
119 static const REAL_VALUE_TYPE
* ten_to_ptwo (int);
120 static const REAL_VALUE_TYPE
* ten_to_mptwo (int);
121 static const REAL_VALUE_TYPE
* real_digit (int);
122 static void times_pten (REAL_VALUE_TYPE
*, int);
124 static void round_for_format (const struct real_format
*, REAL_VALUE_TYPE
*);
126 /* Initialize R with a positive zero. */
129 get_zero (REAL_VALUE_TYPE
*r
, int sign
)
131 memset (r
, 0, sizeof (*r
));
135 /* Initialize R with the canonical quiet NaN. */
138 get_canonical_qnan (REAL_VALUE_TYPE
*r
, int sign
)
140 memset (r
, 0, sizeof (*r
));
147 get_canonical_snan (REAL_VALUE_TYPE
*r
, int sign
)
149 memset (r
, 0, sizeof (*r
));
157 get_inf (REAL_VALUE_TYPE
*r
, int sign
)
159 memset (r
, 0, sizeof (*r
));
165 /* Right-shift the significand of A by N bits; put the result in the
166 significand of R. If any one bits are shifted out, return true. */
169 sticky_rshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
172 unsigned long sticky
= 0;
173 unsigned int i
, ofs
= 0;
175 if (n
>= HOST_BITS_PER_LONG
)
177 for (i
= 0, ofs
= n
/ HOST_BITS_PER_LONG
; i
< ofs
; ++i
)
179 n
&= HOST_BITS_PER_LONG
- 1;
184 sticky
|= a
->sig
[ofs
] & (((unsigned long)1 << n
) - 1);
185 for (i
= 0; i
< SIGSZ
; ++i
)
188 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
189 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
190 << (HOST_BITS_PER_LONG
- n
)));
195 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
196 r
->sig
[i
] = a
->sig
[ofs
+ i
];
197 for (; i
< SIGSZ
; ++i
)
204 /* Right-shift the significand of A by N bits; put the result in the
208 rshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
211 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
213 n
&= HOST_BITS_PER_LONG
- 1;
216 for (i
= 0; i
< SIGSZ
; ++i
)
219 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
220 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
221 << (HOST_BITS_PER_LONG
- n
)));
226 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
227 r
->sig
[i
] = a
->sig
[ofs
+ i
];
228 for (; i
< SIGSZ
; ++i
)
233 /* Left-shift the significand of A by N bits; put the result in the
237 lshift_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
240 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
242 n
&= HOST_BITS_PER_LONG
- 1;
245 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
246 r
->sig
[SIGSZ
-1-i
] = a
->sig
[SIGSZ
-1-i
-ofs
];
247 for (; i
< SIGSZ
; ++i
)
248 r
->sig
[SIGSZ
-1-i
] = 0;
251 for (i
= 0; i
< SIGSZ
; ++i
)
254 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
]) << n
)
255 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
-1])
256 >> (HOST_BITS_PER_LONG
- n
)));
260 /* Likewise, but N is specialized to 1. */
263 lshift_significand_1 (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
267 for (i
= SIGSZ
- 1; i
> 0; --i
)
268 r
->sig
[i
] = (a
->sig
[i
] << 1) | (a
->sig
[i
-1] >> (HOST_BITS_PER_LONG
- 1));
269 r
->sig
[0] = a
->sig
[0] << 1;
272 /* Add the significands of A and B, placing the result in R. Return
273 true if there was carry out of the most significant word. */
276 add_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
277 const REAL_VALUE_TYPE
*b
)
282 for (i
= 0; i
< SIGSZ
; ++i
)
284 unsigned long ai
= a
->sig
[i
];
285 unsigned long ri
= ai
+ b
->sig
[i
];
301 /* Subtract the significands of A and B, placing the result in R. CARRY is
302 true if there's a borrow incoming to the least significant word.
303 Return true if there was borrow out of the most significant word. */
306 sub_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
307 const REAL_VALUE_TYPE
*b
, int carry
)
311 for (i
= 0; i
< SIGSZ
; ++i
)
313 unsigned long ai
= a
->sig
[i
];
314 unsigned long ri
= ai
- b
->sig
[i
];
330 /* Negate the significand A, placing the result in R. */
333 neg_significand (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
338 for (i
= 0; i
< SIGSZ
; ++i
)
340 unsigned long ri
, ai
= a
->sig
[i
];
359 /* Compare significands. Return tri-state vs zero. */
362 cmp_significands (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
366 for (i
= SIGSZ
- 1; i
>= 0; --i
)
368 unsigned long ai
= a
->sig
[i
];
369 unsigned long bi
= b
->sig
[i
];
380 /* Return true if A is nonzero. */
383 cmp_significand_0 (const REAL_VALUE_TYPE
*a
)
387 for (i
= SIGSZ
- 1; i
>= 0; --i
)
394 /* Set bit N of the significand of R. */
397 set_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
399 r
->sig
[n
/ HOST_BITS_PER_LONG
]
400 |= (unsigned long)1 << (n
% HOST_BITS_PER_LONG
);
403 /* Clear bit N of the significand of R. */
406 clear_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
408 r
->sig
[n
/ HOST_BITS_PER_LONG
]
409 &= ~((unsigned long)1 << (n
% HOST_BITS_PER_LONG
));
412 /* Test bit N of the significand of R. */
415 test_significand_bit (REAL_VALUE_TYPE
*r
, unsigned int n
)
417 /* ??? Compiler bug here if we return this expression directly.
418 The conversion to bool strips the "&1" and we wind up testing
419 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
420 int t
= (r
->sig
[n
/ HOST_BITS_PER_LONG
] >> (n
% HOST_BITS_PER_LONG
)) & 1;
424 /* Clear bits 0..N-1 of the significand of R. */
427 clear_significand_below (REAL_VALUE_TYPE
*r
, unsigned int n
)
429 int i
, w
= n
/ HOST_BITS_PER_LONG
;
431 for (i
= 0; i
< w
; ++i
)
434 r
->sig
[w
] &= ~(((unsigned long)1 << (n
% HOST_BITS_PER_LONG
)) - 1);
437 /* Divide the significands of A and B, placing the result in R. Return
438 true if the division was inexact. */
441 div_significands (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
442 const REAL_VALUE_TYPE
*b
)
445 int i
, bit
= SIGNIFICAND_BITS
- 1;
446 unsigned long msb
, inexact
;
449 memset (r
->sig
, 0, sizeof (r
->sig
));
455 msb
= u
.sig
[SIGSZ
-1] & SIG_MSB
;
456 lshift_significand_1 (&u
, &u
);
458 if (msb
|| cmp_significands (&u
, b
) >= 0)
460 sub_significands (&u
, &u
, b
, 0);
461 set_significand_bit (r
, bit
);
466 for (i
= 0, inexact
= 0; i
< SIGSZ
; i
++)
472 /* Adjust the exponent and significand of R such that the most
473 significant bit is set. We underflow to zero and overflow to
474 infinity here, without denormals. (The intermediate representation
475 exponent is large enough to handle target denormals normalized.) */
478 normalize (REAL_VALUE_TYPE
*r
)
483 /* Find the first word that is nonzero. */
484 for (i
= SIGSZ
- 1; i
>= 0; i
--)
486 shift
+= HOST_BITS_PER_LONG
;
490 /* Zero significand flushes to zero. */
498 /* Find the first bit that is nonzero. */
500 if (r
->sig
[i
] & ((unsigned long)1 << (HOST_BITS_PER_LONG
- 1 - j
)))
506 exp
= REAL_EXP (r
) - shift
;
508 get_inf (r
, r
->sign
);
509 else if (exp
< -MAX_EXP
)
510 get_zero (r
, r
->sign
);
513 SET_REAL_EXP (r
, exp
);
514 lshift_significand (r
, r
, shift
);
519 /* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the
520 result may be inexact due to a loss of precision. */
523 do_add (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
,
524 const REAL_VALUE_TYPE
*b
, int subtract_p
)
528 bool inexact
= false;
530 /* Determine if we need to add or subtract. */
532 subtract_p
= (sign
^ b
->sign
) ^ subtract_p
;
534 switch (CLASS2 (a
->cl
, b
->cl
))
536 case CLASS2 (rvc_zero
, rvc_zero
):
537 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
538 get_zero (r
, sign
& !subtract_p
);
541 case CLASS2 (rvc_zero
, rvc_normal
):
542 case CLASS2 (rvc_zero
, rvc_inf
):
543 case CLASS2 (rvc_zero
, rvc_nan
):
545 case CLASS2 (rvc_normal
, rvc_nan
):
546 case CLASS2 (rvc_inf
, rvc_nan
):
547 case CLASS2 (rvc_nan
, rvc_nan
):
548 /* ANY + NaN = NaN. */
549 case CLASS2 (rvc_normal
, rvc_inf
):
552 r
->sign
= sign
^ subtract_p
;
555 case CLASS2 (rvc_normal
, rvc_zero
):
556 case CLASS2 (rvc_inf
, rvc_zero
):
557 case CLASS2 (rvc_nan
, rvc_zero
):
559 case CLASS2 (rvc_nan
, rvc_normal
):
560 case CLASS2 (rvc_nan
, rvc_inf
):
561 /* NaN + ANY = NaN. */
562 case CLASS2 (rvc_inf
, rvc_normal
):
567 case CLASS2 (rvc_inf
, rvc_inf
):
569 /* Inf - Inf = NaN. */
570 get_canonical_qnan (r
, 0);
572 /* Inf + Inf = Inf. */
576 case CLASS2 (rvc_normal
, rvc_normal
):
583 /* Swap the arguments such that A has the larger exponent. */
584 dexp
= REAL_EXP (a
) - REAL_EXP (b
);
587 const REAL_VALUE_TYPE
*t
;
594 /* If the exponents are not identical, we need to shift the
595 significand of B down. */
598 /* If the exponents are too far apart, the significands
599 do not overlap, which makes the subtraction a noop. */
600 if (dexp
>= SIGNIFICAND_BITS
)
607 inexact
|= sticky_rshift_significand (&t
, b
, dexp
);
613 if (sub_significands (r
, a
, b
, inexact
))
615 /* We got a borrow out of the subtraction. That means that
616 A and B had the same exponent, and B had the larger
617 significand. We need to swap the sign and negate the
620 neg_significand (r
, r
);
625 if (add_significands (r
, a
, b
))
627 /* We got carry out of the addition. This means we need to
628 shift the significand back down one bit and increase the
630 inexact
|= sticky_rshift_significand (r
, r
, 1);
631 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
642 SET_REAL_EXP (r
, exp
);
643 /* 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 (REAL_EXP (a
) > REAL_EXP (b
))
943 else if (REAL_EXP (a
) < REAL_EXP (b
))
946 ret
= cmp_significands (a
, b
);
948 return (a
->sign
? -ret
: ret
);
951 /* Return A truncated to an integral value toward zero. */
954 do_fix_trunc (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*a
)
966 if (REAL_EXP (r
) <= 0)
967 get_zero (r
, r
->sign
);
968 else if (REAL_EXP (r
) < SIGNIFICAND_BITS
)
969 clear_significand_below (r
, SIGNIFICAND_BITS
- REAL_EXP (r
));
977 /* Perform the binary or unary operation described by CODE.
978 For a unary operation, leave OP1 NULL. This function returns
979 true if the result may be inexact due to loss of precision. */
982 real_arithmetic (REAL_VALUE_TYPE
*r
, int icode
, const REAL_VALUE_TYPE
*op0
,
983 const REAL_VALUE_TYPE
*op1
)
985 enum tree_code code
= icode
;
990 return do_add (r
, op0
, op1
, 0);
993 return do_add (r
, op0
, op1
, 1);
996 return do_multiply (r
, op0
, op1
);
999 return do_divide (r
, op0
, op1
);
1002 if (op1
->cl
== rvc_nan
)
1004 else if (do_compare (op0
, op1
, -1) < 0)
1011 if (op1
->cl
== rvc_nan
)
1013 else if (do_compare (op0
, op1
, 1) < 0)
1029 case FIX_TRUNC_EXPR
:
1030 do_fix_trunc (r
, op0
);
1039 /* Legacy. Similar, but return the result directly. */
1042 real_arithmetic2 (int icode
, const REAL_VALUE_TYPE
*op0
,
1043 const REAL_VALUE_TYPE
*op1
)
1046 real_arithmetic (&r
, icode
, op0
, op1
);
1051 real_compare (int icode
, const REAL_VALUE_TYPE
*op0
,
1052 const REAL_VALUE_TYPE
*op1
)
1054 enum tree_code code
= icode
;
1059 return do_compare (op0
, op1
, 1) < 0;
1061 return do_compare (op0
, op1
, 1) <= 0;
1063 return do_compare (op0
, op1
, -1) > 0;
1065 return do_compare (op0
, op1
, -1) >= 0;
1067 return do_compare (op0
, op1
, -1) == 0;
1069 return do_compare (op0
, op1
, -1) != 0;
1070 case UNORDERED_EXPR
:
1071 return op0
->cl
== rvc_nan
|| op1
->cl
== rvc_nan
;
1073 return op0
->cl
!= rvc_nan
&& op1
->cl
!= rvc_nan
;
1075 return do_compare (op0
, op1
, -1) < 0;
1077 return do_compare (op0
, op1
, -1) <= 0;
1079 return do_compare (op0
, op1
, 1) > 0;
1081 return do_compare (op0
, op1
, 1) >= 0;
1083 return do_compare (op0
, op1
, 0) == 0;
1085 return do_compare (op0
, op1
, 0) != 0;
1092 /* Return floor log2(R). */
1095 real_exponent (const REAL_VALUE_TYPE
*r
)
1103 return (unsigned int)-1 >> 1;
1105 return REAL_EXP (r
);
1111 /* R = OP0 * 2**EXP. */
1114 real_ldexp (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*op0
, int exp
)
1125 exp
+= REAL_EXP (op0
);
1127 get_inf (r
, r
->sign
);
1128 else if (exp
< -MAX_EXP
)
1129 get_zero (r
, r
->sign
);
1131 SET_REAL_EXP (r
, exp
);
1139 /* Determine whether a floating-point value X is infinite. */
1142 real_isinf (const REAL_VALUE_TYPE
*r
)
1144 return (r
->cl
== rvc_inf
);
1147 /* Determine whether a floating-point value X is a NaN. */
1150 real_isnan (const REAL_VALUE_TYPE
*r
)
1152 return (r
->cl
== rvc_nan
);
1155 /* Determine whether a floating-point value X is negative. */
1158 real_isneg (const REAL_VALUE_TYPE
*r
)
1163 /* Determine whether a floating-point value X is minus zero. */
1166 real_isnegzero (const REAL_VALUE_TYPE
*r
)
1168 return r
->sign
&& r
->cl
== rvc_zero
;
1171 /* Compare two floating-point objects for bitwise identity. */
1174 real_identical (const REAL_VALUE_TYPE
*a
, const REAL_VALUE_TYPE
*b
)
1180 if (a
->sign
!= b
->sign
)
1190 if (REAL_EXP (a
) != REAL_EXP (b
))
1195 if (a
->signalling
!= b
->signalling
)
1197 /* The significand is ignored for canonical NaNs. */
1198 if (a
->canonical
|| b
->canonical
)
1199 return a
->canonical
== b
->canonical
;
1206 for (i
= 0; i
< SIGSZ
; ++i
)
1207 if (a
->sig
[i
] != b
->sig
[i
])
1213 /* Try to change R into its exact multiplicative inverse in machine
1214 mode MODE. Return true if successful. */
1217 exact_real_inverse (enum machine_mode mode
, REAL_VALUE_TYPE
*r
)
1219 const REAL_VALUE_TYPE
*one
= real_digit (1);
1223 if (r
->cl
!= rvc_normal
)
1226 /* Check for a power of two: all significand bits zero except the MSB. */
1227 for (i
= 0; i
< SIGSZ
-1; ++i
)
1230 if (r
->sig
[SIGSZ
-1] != SIG_MSB
)
1233 /* Find the inverse and truncate to the required mode. */
1234 do_divide (&u
, one
, r
);
1235 real_convert (&u
, mode
, &u
);
1237 /* The rounding may have overflowed. */
1238 if (u
.cl
!= rvc_normal
)
1240 for (i
= 0; i
< SIGSZ
-1; ++i
)
1243 if (u
.sig
[SIGSZ
-1] != SIG_MSB
)
1250 /* Render R as an integer. */
1253 real_to_integer (const REAL_VALUE_TYPE
*r
)
1255 unsigned HOST_WIDE_INT i
;
1266 i
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1272 if (REAL_EXP (r
) <= 0)
1274 /* Only force overflow for unsigned overflow. Signed overflow is
1275 undefined, so it doesn't matter what we return, and some callers
1276 expect to be able to use this routine for both signed and
1277 unsigned conversions. */
1278 if (REAL_EXP (r
) > HOST_BITS_PER_WIDE_INT
)
1281 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1282 i
= r
->sig
[SIGSZ
-1];
1285 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2 * HOST_BITS_PER_LONG
);
1286 i
= r
->sig
[SIGSZ
-1];
1287 i
= i
<< (HOST_BITS_PER_LONG
- 1) << 1;
1288 i
|= r
->sig
[SIGSZ
-2];
1291 i
>>= HOST_BITS_PER_WIDE_INT
- REAL_EXP (r
);
1302 /* Likewise, but to an integer pair, HI+LOW. */
1305 real_to_integer2 (HOST_WIDE_INT
*plow
, HOST_WIDE_INT
*phigh
,
1306 const REAL_VALUE_TYPE
*r
)
1309 HOST_WIDE_INT low
, high
;
1322 high
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1336 /* Only force overflow for unsigned overflow. Signed overflow is
1337 undefined, so it doesn't matter what we return, and some callers
1338 expect to be able to use this routine for both signed and
1339 unsigned conversions. */
1340 if (exp
> 2*HOST_BITS_PER_WIDE_INT
)
1343 rshift_significand (&t
, r
, 2*HOST_BITS_PER_WIDE_INT
- exp
);
1344 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1346 high
= t
.sig
[SIGSZ
-1];
1347 low
= t
.sig
[SIGSZ
-2];
1351 gcc_assert (HOST_BITS_PER_WIDE_INT
== 2*HOST_BITS_PER_LONG
);
1352 high
= t
.sig
[SIGSZ
-1];
1353 high
= high
<< (HOST_BITS_PER_LONG
- 1) << 1;
1354 high
|= t
.sig
[SIGSZ
-2];
1356 low
= t
.sig
[SIGSZ
-3];
1357 low
= low
<< (HOST_BITS_PER_LONG
- 1) << 1;
1358 low
|= t
.sig
[SIGSZ
-4];
1366 low
= -low
, high
= ~high
;
1378 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1379 of NUM / DEN. Return the quotient and place the remainder in NUM.
1380 It is expected that NUM / DEN are close enough that the quotient is
1383 static unsigned long
1384 rtd_divmod (REAL_VALUE_TYPE
*num
, REAL_VALUE_TYPE
*den
)
1386 unsigned long q
, msb
;
1387 int expn
= REAL_EXP (num
), expd
= REAL_EXP (den
);
1396 msb
= num
->sig
[SIGSZ
-1] & SIG_MSB
;
1398 lshift_significand_1 (num
, num
);
1400 if (msb
|| cmp_significands (num
, den
) >= 0)
1402 sub_significands (num
, num
, den
, 0);
1406 while (--expn
>= expd
);
1408 SET_REAL_EXP (num
, expd
);
1414 /* Render R as a decimal floating point constant. Emit DIGITS significant
1415 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1416 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1419 #define M_LOG10_2 0.30102999566398119521
1422 real_to_decimal (char *str
, const REAL_VALUE_TYPE
*r_orig
, size_t buf_size
,
1423 size_t digits
, int crop_trailing_zeros
)
1425 const REAL_VALUE_TYPE
*one
, *ten
;
1426 REAL_VALUE_TYPE r
, pten
, u
, v
;
1427 int dec_exp
, cmp_one
, digit
;
1429 char *p
, *first
, *last
;
1436 strcpy (str
, (r
.sign
? "-0.0" : "0.0"));
1441 strcpy (str
, (r
.sign
? "-Inf" : "+Inf"));
1444 /* ??? Print the significand as well, if not canonical? */
1445 strcpy (str
, (r
.sign
? "-NaN" : "+NaN"));
1451 /* Bound the number of digits printed by the size of the representation. */
1452 max_digits
= SIGNIFICAND_BITS
* M_LOG10_2
;
1453 if (digits
== 0 || digits
> max_digits
)
1454 digits
= max_digits
;
1456 /* Estimate the decimal exponent, and compute the length of the string it
1457 will print as. Be conservative and add one to account for possible
1458 overflow or rounding error. */
1459 dec_exp
= REAL_EXP (&r
) * M_LOG10_2
;
1460 for (max_digits
= 1; dec_exp
; max_digits
++)
1463 /* Bound the number of digits printed by the size of the output buffer. */
1464 max_digits
= buf_size
- 1 - 1 - 2 - max_digits
- 1;
1465 gcc_assert (max_digits
<= buf_size
);
1466 if (digits
> max_digits
)
1467 digits
= max_digits
;
1469 one
= real_digit (1);
1470 ten
= ten_to_ptwo (0);
1478 cmp_one
= do_compare (&r
, one
, 0);
1483 /* Number is greater than one. Convert significand to an integer
1484 and strip trailing decimal zeros. */
1487 SET_REAL_EXP (&u
, SIGNIFICAND_BITS
- 1);
1489 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1490 m
= floor_log2 (max_digits
);
1492 /* Iterate over the bits of the possible powers of 10 that might
1493 be present in U and eliminate them. That is, if we find that
1494 10**2**M divides U evenly, keep the division and increase
1500 do_divide (&t
, &u
, ten_to_ptwo (m
));
1501 do_fix_trunc (&v
, &t
);
1502 if (cmp_significands (&v
, &t
) == 0)
1510 /* Revert the scaling to integer that we performed earlier. */
1511 SET_REAL_EXP (&u
, REAL_EXP (&u
) + REAL_EXP (&r
)
1512 - (SIGNIFICAND_BITS
- 1));
1515 /* Find power of 10. Do this by dividing out 10**2**M when
1516 this is larger than the current remainder. Fill PTEN with
1517 the power of 10 that we compute. */
1518 if (REAL_EXP (&r
) > 0)
1520 m
= floor_log2 ((int)(REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1523 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1524 if (do_compare (&u
, ptentwo
, 0) >= 0)
1526 do_divide (&u
, &u
, ptentwo
);
1527 do_multiply (&pten
, &pten
, ptentwo
);
1534 /* We managed to divide off enough tens in the above reduction
1535 loop that we've now got a negative exponent. Fall into the
1536 less-than-one code to compute the proper value for PTEN. */
1543 /* Number is less than one. Pad significand with leading
1549 /* Stop if we'd shift bits off the bottom. */
1553 do_multiply (&u
, &v
, ten
);
1555 /* Stop if we're now >= 1. */
1556 if (REAL_EXP (&u
) > 0)
1564 /* Find power of 10. Do this by multiplying in P=10**2**M when
1565 the current remainder is smaller than 1/P. Fill PTEN with the
1566 power of 10 that we compute. */
1567 m
= floor_log2 ((int)(-REAL_EXP (&r
) * M_LOG10_2
)) + 1;
1570 const REAL_VALUE_TYPE
*ptentwo
= ten_to_ptwo (m
);
1571 const REAL_VALUE_TYPE
*ptenmtwo
= ten_to_mptwo (m
);
1573 if (do_compare (&v
, ptenmtwo
, 0) <= 0)
1575 do_multiply (&v
, &v
, ptentwo
);
1576 do_multiply (&pten
, &pten
, ptentwo
);
1582 /* Invert the positive power of 10 that we've collected so far. */
1583 do_divide (&pten
, one
, &pten
);
1591 /* At this point, PTEN should contain the nearest power of 10 smaller
1592 than R, such that this division produces the first digit.
1594 Using a divide-step primitive that returns the complete integral
1595 remainder avoids the rounding error that would be produced if
1596 we were to use do_divide here and then simply multiply by 10 for
1597 each subsequent digit. */
1599 digit
= rtd_divmod (&r
, &pten
);
1601 /* Be prepared for error in that division via underflow ... */
1602 if (digit
== 0 && cmp_significand_0 (&r
))
1604 /* Multiply by 10 and try again. */
1605 do_multiply (&r
, &r
, ten
);
1606 digit
= rtd_divmod (&r
, &pten
);
1608 gcc_assert (digit
!= 0);
1611 /* ... or overflow. */
1621 gcc_assert (digit
<= 10);
1625 /* Generate subsequent digits. */
1626 while (--digits
> 0)
1628 do_multiply (&r
, &r
, ten
);
1629 digit
= rtd_divmod (&r
, &pten
);
1634 /* Generate one more digit with which to do rounding. */
1635 do_multiply (&r
, &r
, ten
);
1636 digit
= rtd_divmod (&r
, &pten
);
1638 /* Round the result. */
1641 /* Round to nearest. If R is nonzero there are additional
1642 nonzero digits to be extracted. */
1643 if (cmp_significand_0 (&r
))
1645 /* Round to even. */
1646 else if ((p
[-1] - '0') & 1)
1663 /* Carry out of the first digit. This means we had all 9's and
1664 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1672 /* Insert the decimal point. */
1673 first
[0] = first
[1];
1676 /* If requested, drop trailing zeros. Never crop past "1.0". */
1677 if (crop_trailing_zeros
)
1678 while (last
> first
+ 3 && last
[-1] == '0')
1681 /* Append the exponent. */
1682 sprintf (last
, "e%+d", dec_exp
);
1685 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1686 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1687 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1688 strip trailing zeros. */
1691 real_to_hexadecimal (char *str
, const REAL_VALUE_TYPE
*r
, size_t buf_size
,
1692 size_t digits
, int crop_trailing_zeros
)
1694 int i
, j
, exp
= REAL_EXP (r
);
1707 strcpy (str
, (r
->sign
? "-Inf" : "+Inf"));
1710 /* ??? Print the significand as well, if not canonical? */
1711 strcpy (str
, (r
->sign
? "-NaN" : "+NaN"));
1718 digits
= SIGNIFICAND_BITS
/ 4;
1720 /* Bound the number of digits printed by the size of the output buffer. */
1722 sprintf (exp_buf
, "p%+d", exp
);
1723 max_digits
= buf_size
- strlen (exp_buf
) - r
->sign
- 4 - 1;
1724 gcc_assert (max_digits
<= buf_size
);
1725 if (digits
> max_digits
)
1726 digits
= max_digits
;
1737 for (i
= SIGSZ
- 1; i
>= 0; --i
)
1738 for (j
= HOST_BITS_PER_LONG
- 4; j
>= 0; j
-= 4)
1740 *p
++ = "0123456789abcdef"[(r
->sig
[i
] >> j
) & 15];
1746 if (crop_trailing_zeros
)
1747 while (p
> first
+ 1 && p
[-1] == '0')
1750 sprintf (p
, "p%+d", exp
);
1753 /* Initialize R from a decimal or hexadecimal string. The string is
1754 assumed to have been syntax checked already. */
1757 real_from_string (REAL_VALUE_TYPE
*r
, const char *str
)
1769 else if (*str
== '+')
1772 if (str
[0] == '0' && (str
[1] == 'x' || str
[1] == 'X'))
1774 /* Hexadecimal floating point. */
1775 int pos
= SIGNIFICAND_BITS
- 4, d
;
1783 d
= hex_value (*str
);
1788 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1789 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1793 /* Ensure correct rounding by setting last bit if there is
1794 a subsequent nonzero digit. */
1802 if (pos
== SIGNIFICAND_BITS
- 4)
1809 d
= hex_value (*str
);
1814 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1815 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1819 /* Ensure correct rounding by setting last bit if there is
1820 a subsequent nonzero digit. */
1825 if (*str
== 'p' || *str
== 'P')
1827 bool exp_neg
= false;
1835 else if (*str
== '+')
1839 while (ISDIGIT (*str
))
1845 /* Overflowed the exponent. */
1860 SET_REAL_EXP (r
, exp
);
1866 /* Decimal floating point. */
1867 const REAL_VALUE_TYPE
*ten
= ten_to_ptwo (0);
1872 while (ISDIGIT (*str
))
1875 do_multiply (r
, r
, ten
);
1877 do_add (r
, r
, real_digit (d
), 0);
1882 if (r
->cl
== rvc_zero
)
1887 while (ISDIGIT (*str
))
1890 do_multiply (r
, r
, ten
);
1892 do_add (r
, r
, real_digit (d
), 0);
1897 if (*str
== 'e' || *str
== 'E')
1899 bool exp_neg
= false;
1907 else if (*str
== '+')
1911 while (ISDIGIT (*str
))
1917 /* Overflowed the exponent. */
1931 times_pten (r
, exp
);
1946 /* Legacy. Similar, but return the result directly. */
1949 real_from_string2 (const char *s
, enum machine_mode mode
)
1953 real_from_string (&r
, s
);
1954 if (mode
!= VOIDmode
)
1955 real_convert (&r
, mode
, &r
);
1960 /* Initialize R from the integer pair HIGH+LOW. */
1963 real_from_integer (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
1964 unsigned HOST_WIDE_INT low
, HOST_WIDE_INT high
,
1967 if (low
== 0 && high
== 0)
1971 memset (r
, 0, sizeof (*r
));
1973 r
->sign
= high
< 0 && !unsigned_p
;
1974 SET_REAL_EXP (r
, 2 * HOST_BITS_PER_WIDE_INT
);
1985 if (HOST_BITS_PER_LONG
== HOST_BITS_PER_WIDE_INT
)
1987 r
->sig
[SIGSZ
-1] = high
;
1988 r
->sig
[SIGSZ
-2] = low
;
1992 gcc_assert (HOST_BITS_PER_LONG
*2 == HOST_BITS_PER_WIDE_INT
);
1993 r
->sig
[SIGSZ
-1] = high
>> (HOST_BITS_PER_LONG
- 1) >> 1;
1994 r
->sig
[SIGSZ
-2] = high
;
1995 r
->sig
[SIGSZ
-3] = low
>> (HOST_BITS_PER_LONG
- 1) >> 1;
1996 r
->sig
[SIGSZ
-4] = low
;
2002 if (mode
!= VOIDmode
)
2003 real_convert (r
, mode
, r
);
2006 /* Returns 10**2**N. */
2008 static const REAL_VALUE_TYPE
*
2011 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2013 gcc_assert (n
>= 0);
2014 gcc_assert (n
< EXP_BITS
);
2016 if (tens
[n
].cl
== rvc_zero
)
2018 if (n
< (HOST_BITS_PER_WIDE_INT
== 64 ? 5 : 4))
2020 HOST_WIDE_INT t
= 10;
2023 for (i
= 0; i
< n
; ++i
)
2026 real_from_integer (&tens
[n
], VOIDmode
, t
, 0, 1);
2030 const REAL_VALUE_TYPE
*t
= ten_to_ptwo (n
- 1);
2031 do_multiply (&tens
[n
], t
, t
);
2038 /* Returns 10**(-2**N). */
2040 static const REAL_VALUE_TYPE
*
2041 ten_to_mptwo (int n
)
2043 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2045 gcc_assert (n
>= 0);
2046 gcc_assert (n
< EXP_BITS
);
2048 if (tens
[n
].cl
== rvc_zero
)
2049 do_divide (&tens
[n
], real_digit (1), ten_to_ptwo (n
));
2056 static const REAL_VALUE_TYPE
*
2059 static REAL_VALUE_TYPE num
[10];
2061 gcc_assert (n
>= 0);
2062 gcc_assert (n
<= 9);
2064 if (n
> 0 && num
[n
].cl
== rvc_zero
)
2065 real_from_integer (&num
[n
], VOIDmode
, n
, 0, 1);
2070 /* Multiply R by 10**EXP. */
2073 times_pten (REAL_VALUE_TYPE
*r
, int exp
)
2075 REAL_VALUE_TYPE pten
, *rr
;
2076 bool negative
= (exp
< 0);
2082 pten
= *real_digit (1);
2088 for (i
= 0; exp
> 0; ++i
, exp
>>= 1)
2090 do_multiply (rr
, rr
, ten_to_ptwo (i
));
2093 do_divide (r
, r
, &pten
);
2096 /* Fills R with +Inf. */
2099 real_inf (REAL_VALUE_TYPE
*r
)
2104 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2105 we force a QNaN, else we force an SNaN. The string, if not empty,
2106 is parsed as a number and placed in the significand. Return true
2107 if the string was successfully parsed. */
2110 real_nan (REAL_VALUE_TYPE
*r
, const char *str
, int quiet
,
2111 enum machine_mode mode
)
2113 const struct real_format
*fmt
;
2115 fmt
= REAL_MODE_FORMAT (mode
);
2121 get_canonical_qnan (r
, 0);
2123 get_canonical_snan (r
, 0);
2129 memset (r
, 0, sizeof (*r
));
2132 /* Parse akin to strtol into the significand of R. */
2134 while (ISSPACE (*str
))
2138 else if (*str
== '+')
2148 while ((d
= hex_value (*str
)) < base
)
2155 lshift_significand (r
, r
, 3);
2158 lshift_significand (r
, r
, 4);
2161 lshift_significand_1 (&u
, r
);
2162 lshift_significand (r
, r
, 3);
2163 add_significands (r
, r
, &u
);
2171 add_significands (r
, r
, &u
);
2176 /* Must have consumed the entire string for success. */
2180 /* Shift the significand into place such that the bits
2181 are in the most significant bits for the format. */
2182 lshift_significand (r
, r
, SIGNIFICAND_BITS
- fmt
->pnan
);
2184 /* Our MSB is always unset for NaNs. */
2185 r
->sig
[SIGSZ
-1] &= ~SIG_MSB
;
2187 /* Force quiet or signalling NaN. */
2188 r
->signalling
= !quiet
;
2194 /* Fills R with the largest finite value representable in mode MODE.
2195 If SIGN is nonzero, R is set to the most negative finite value. */
2198 real_maxval (REAL_VALUE_TYPE
*r
, int sign
, enum machine_mode mode
)
2200 const struct real_format
*fmt
;
2203 fmt
= REAL_MODE_FORMAT (mode
);
2210 SET_REAL_EXP (r
, fmt
->emax
* fmt
->log2_b
);
2212 np2
= SIGNIFICAND_BITS
- fmt
->p
* fmt
->log2_b
;
2213 memset (r
->sig
, -1, SIGSZ
* sizeof (unsigned long));
2214 clear_significand_below (r
, np2
);
2217 /* Fills R with 2**N. */
2220 real_2expN (REAL_VALUE_TYPE
*r
, int n
)
2222 memset (r
, 0, sizeof (*r
));
2227 else if (n
< -MAX_EXP
)
2232 SET_REAL_EXP (r
, n
);
2233 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2239 round_for_format (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
)
2242 unsigned long sticky
;
2246 p2
= fmt
->p
* fmt
->log2_b
;
2247 emin2m1
= (fmt
->emin
- 1) * fmt
->log2_b
;
2248 emax2
= fmt
->emax
* fmt
->log2_b
;
2250 np2
= SIGNIFICAND_BITS
- p2
;
2254 get_zero (r
, r
->sign
);
2256 if (!fmt
->has_signed_zero
)
2261 get_inf (r
, r
->sign
);
2266 clear_significand_below (r
, np2
);
2276 /* If we're not base2, normalize the exponent to a multiple of
2278 if (fmt
->log2_b
!= 1)
2280 int shift
= REAL_EXP (r
) & (fmt
->log2_b
- 1);
2283 shift
= fmt
->log2_b
- shift
;
2284 r
->sig
[0] |= sticky_rshift_significand (r
, r
, shift
);
2285 SET_REAL_EXP (r
, REAL_EXP (r
) + shift
);
2289 /* Check the range of the exponent. If we're out of range,
2290 either underflow or overflow. */
2291 if (REAL_EXP (r
) > emax2
)
2293 else if (REAL_EXP (r
) <= emin2m1
)
2297 if (!fmt
->has_denorm
)
2299 /* Don't underflow completely until we've had a chance to round. */
2300 if (REAL_EXP (r
) < emin2m1
)
2305 diff
= emin2m1
- REAL_EXP (r
) + 1;
2309 /* De-normalize the significand. */
2310 r
->sig
[0] |= sticky_rshift_significand (r
, r
, diff
);
2311 SET_REAL_EXP (r
, REAL_EXP (r
) + diff
);
2315 /* There are P2 true significand bits, followed by one guard bit,
2316 followed by one sticky bit, followed by stuff. Fold nonzero
2317 stuff into the sticky bit. */
2320 for (i
= 0, w
= (np2
- 1) / HOST_BITS_PER_LONG
; i
< w
; ++i
)
2321 sticky
|= r
->sig
[i
];
2323 r
->sig
[w
] & (((unsigned long)1 << ((np2
- 1) % HOST_BITS_PER_LONG
)) - 1);
2325 guard
= test_significand_bit (r
, np2
- 1);
2326 lsb
= test_significand_bit (r
, np2
);
2328 /* Round to even. */
2329 if (guard
&& (sticky
|| lsb
))
2333 set_significand_bit (&u
, np2
);
2335 if (add_significands (r
, r
, &u
))
2337 /* Overflow. Means the significand had been all ones, and
2338 is now all zeros. Need to increase the exponent, and
2339 possibly re-normalize it. */
2340 SET_REAL_EXP (r
, REAL_EXP (r
) + 1);
2341 if (REAL_EXP (r
) > emax2
)
2343 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2345 if (fmt
->log2_b
!= 1)
2347 int shift
= REAL_EXP (r
) & (fmt
->log2_b
- 1);
2350 shift
= fmt
->log2_b
- shift
;
2351 rshift_significand (r
, r
, shift
);
2352 SET_REAL_EXP (r
, REAL_EXP (r
) + shift
);
2353 if (REAL_EXP (r
) > emax2
)
2360 /* Catch underflow that we deferred until after rounding. */
2361 if (REAL_EXP (r
) <= emin2m1
)
2364 /* Clear out trailing garbage. */
2365 clear_significand_below (r
, np2
);
2368 /* Extend or truncate to a new mode. */
2371 real_convert (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
2372 const REAL_VALUE_TYPE
*a
)
2374 const struct real_format
*fmt
;
2376 fmt
= REAL_MODE_FORMAT (mode
);
2380 round_for_format (fmt
, r
);
2382 /* round_for_format de-normalizes denormals. Undo just that part. */
2383 if (r
->cl
== rvc_normal
)
2387 /* Legacy. Likewise, except return the struct directly. */
2390 real_value_truncate (enum machine_mode mode
, REAL_VALUE_TYPE a
)
2393 real_convert (&r
, mode
, &a
);
2397 /* Return true if truncating to MODE is exact. */
2400 exact_real_truncate (enum machine_mode mode
, const REAL_VALUE_TYPE
*a
)
2403 real_convert (&t
, mode
, a
);
2404 return real_identical (&t
, a
);
2407 /* Write R to the given target format. Place the words of the result
2408 in target word order in BUF. There are always 32 bits in each
2409 long, no matter the size of the host long.
2411 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2414 real_to_target_fmt (long *buf
, const REAL_VALUE_TYPE
*r_orig
,
2415 const struct real_format
*fmt
)
2421 round_for_format (fmt
, &r
);
2425 (*fmt
->encode
) (fmt
, buf
, &r
);
2430 /* Similar, but look up the format from MODE. */
2433 real_to_target (long *buf
, const REAL_VALUE_TYPE
*r
, enum machine_mode mode
)
2435 const struct real_format
*fmt
;
2437 fmt
= REAL_MODE_FORMAT (mode
);
2440 return real_to_target_fmt (buf
, r
, fmt
);
2443 /* Read R from the given target format. Read the words of the result
2444 in target word order in BUF. There are always 32 bits in each
2445 long, no matter the size of the host long. */
2448 real_from_target_fmt (REAL_VALUE_TYPE
*r
, const long *buf
,
2449 const struct real_format
*fmt
)
2451 (*fmt
->decode
) (fmt
, r
, buf
);
2454 /* Similar, but look up the format from MODE. */
2457 real_from_target (REAL_VALUE_TYPE
*r
, const long *buf
, enum machine_mode mode
)
2459 const struct real_format
*fmt
;
2461 fmt
= REAL_MODE_FORMAT (mode
);
2464 (*fmt
->decode
) (fmt
, r
, buf
);
2467 /* Return the number of bits in the significand for MODE. */
2468 /* ??? Legacy. Should get access to real_format directly. */
2471 significand_size (enum machine_mode mode
)
2473 const struct real_format
*fmt
;
2475 fmt
= REAL_MODE_FORMAT (mode
);
2479 return fmt
->p
* fmt
->log2_b
;
2482 /* Return a hash value for the given real value. */
2483 /* ??? The "unsigned int" return value is intended to be hashval_t,
2484 but I didn't want to pull hashtab.h into real.h. */
2487 real_hash (const REAL_VALUE_TYPE
*r
)
2492 h
= r
->cl
| (r
->sign
<< 2);
2500 h
|= REAL_EXP (r
) << 3;
2505 h
^= (unsigned int)-1;
2514 if (sizeof(unsigned long) > sizeof(unsigned int))
2515 for (i
= 0; i
< SIGSZ
; ++i
)
2517 unsigned long s
= r
->sig
[i
];
2518 h
^= s
^ (s
>> (HOST_BITS_PER_LONG
/ 2));
2521 for (i
= 0; i
< SIGSZ
; ++i
)
2527 /* IEEE single-precision format. */
2529 static void encode_ieee_single (const struct real_format
*fmt
,
2530 long *, const REAL_VALUE_TYPE
*);
2531 static void decode_ieee_single (const struct real_format
*,
2532 REAL_VALUE_TYPE
*, const long *);
2535 encode_ieee_single (const struct real_format
*fmt
, long *buf
,
2536 const REAL_VALUE_TYPE
*r
)
2538 unsigned long image
, sig
, exp
;
2539 unsigned long sign
= r
->sign
;
2540 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2543 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
2554 image
|= 0x7fffffff;
2562 if (r
->signalling
== fmt
->qnan_msb_set
)
2566 /* We overload qnan_msb_set here: it's only clear for
2567 mips_ieee_single, which wants all mantissa bits but the
2568 quiet/signalling one set in canonical NaNs (at least
2570 if (r
->canonical
&& !fmt
->qnan_msb_set
)
2571 sig
|= (1 << 22) - 1;
2579 image
|= 0x7fffffff;
2583 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2584 whereas the intermediate representation is 0.F x 2**exp.
2585 Which means we're off by one. */
2589 exp
= REAL_EXP (r
) + 127 - 1;
2602 decode_ieee_single (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
2605 unsigned long image
= buf
[0] & 0xffffffff;
2606 bool sign
= (image
>> 31) & 1;
2607 int exp
= (image
>> 23) & 0xff;
2609 memset (r
, 0, sizeof (*r
));
2610 image
<<= HOST_BITS_PER_LONG
- 24;
2615 if (image
&& fmt
->has_denorm
)
2619 SET_REAL_EXP (r
, -126);
2620 r
->sig
[SIGSZ
-1] = image
<< 1;
2623 else if (fmt
->has_signed_zero
)
2626 else if (exp
== 255 && (fmt
->has_nans
|| fmt
->has_inf
))
2632 r
->signalling
= (((image
>> (HOST_BITS_PER_LONG
- 2)) & 1)
2633 ^ fmt
->qnan_msb_set
);
2634 r
->sig
[SIGSZ
-1] = image
;
2646 SET_REAL_EXP (r
, exp
- 127 + 1);
2647 r
->sig
[SIGSZ
-1] = image
| SIG_MSB
;
2651 const struct real_format ieee_single_format
=
2670 const struct real_format mips_single_format
=
2690 /* IEEE double-precision format. */
2692 static void encode_ieee_double (const struct real_format
*fmt
,
2693 long *, const REAL_VALUE_TYPE
*);
2694 static void decode_ieee_double (const struct real_format
*,
2695 REAL_VALUE_TYPE
*, const long *);
2698 encode_ieee_double (const struct real_format
*fmt
, long *buf
,
2699 const REAL_VALUE_TYPE
*r
)
2701 unsigned long image_lo
, image_hi
, sig_lo
, sig_hi
, exp
;
2702 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2704 image_hi
= r
->sign
<< 31;
2707 if (HOST_BITS_PER_LONG
== 64)
2709 sig_hi
= r
->sig
[SIGSZ
-1];
2710 sig_lo
= (sig_hi
>> (64 - 53)) & 0xffffffff;
2711 sig_hi
= (sig_hi
>> (64 - 53 + 1) >> 31) & 0xfffff;
2715 sig_hi
= r
->sig
[SIGSZ
-1];
2716 sig_lo
= r
->sig
[SIGSZ
-2];
2717 sig_lo
= (sig_hi
<< 21) | (sig_lo
>> 11);
2718 sig_hi
= (sig_hi
>> 11) & 0xfffff;
2728 image_hi
|= 2047 << 20;
2731 image_hi
|= 0x7fffffff;
2732 image_lo
= 0xffffffff;
2740 sig_hi
= sig_lo
= 0;
2741 if (r
->signalling
== fmt
->qnan_msb_set
)
2742 sig_hi
&= ~(1 << 19);
2745 /* We overload qnan_msb_set here: it's only clear for
2746 mips_ieee_single, which wants all mantissa bits but the
2747 quiet/signalling one set in canonical NaNs (at least
2749 if (r
->canonical
&& !fmt
->qnan_msb_set
)
2751 sig_hi
|= (1 << 19) - 1;
2752 sig_lo
= 0xffffffff;
2754 else if (sig_hi
== 0 && sig_lo
== 0)
2757 image_hi
|= 2047 << 20;
2763 image_hi
|= 0x7fffffff;
2764 image_lo
= 0xffffffff;
2769 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2770 whereas the intermediate representation is 0.F x 2**exp.
2771 Which means we're off by one. */
2775 exp
= REAL_EXP (r
) + 1023 - 1;
2776 image_hi
|= exp
<< 20;
2785 if (FLOAT_WORDS_BIG_ENDIAN
)
2786 buf
[0] = image_hi
, buf
[1] = image_lo
;
2788 buf
[0] = image_lo
, buf
[1] = image_hi
;
2792 decode_ieee_double (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
2795 unsigned long image_hi
, image_lo
;
2799 if (FLOAT_WORDS_BIG_ENDIAN
)
2800 image_hi
= buf
[0], image_lo
= buf
[1];
2802 image_lo
= buf
[0], image_hi
= buf
[1];
2803 image_lo
&= 0xffffffff;
2804 image_hi
&= 0xffffffff;
2806 sign
= (image_hi
>> 31) & 1;
2807 exp
= (image_hi
>> 20) & 0x7ff;
2809 memset (r
, 0, sizeof (*r
));
2811 image_hi
<<= 32 - 21;
2812 image_hi
|= image_lo
>> 21;
2813 image_hi
&= 0x7fffffff;
2814 image_lo
<<= 32 - 21;
2818 if ((image_hi
|| image_lo
) && fmt
->has_denorm
)
2822 SET_REAL_EXP (r
, -1022);
2823 if (HOST_BITS_PER_LONG
== 32)
2825 image_hi
= (image_hi
<< 1) | (image_lo
>> 31);
2827 r
->sig
[SIGSZ
-1] = image_hi
;
2828 r
->sig
[SIGSZ
-2] = image_lo
;
2832 image_hi
= (image_hi
<< 31 << 2) | (image_lo
<< 1);
2833 r
->sig
[SIGSZ
-1] = image_hi
;
2837 else if (fmt
->has_signed_zero
)
2840 else if (exp
== 2047 && (fmt
->has_nans
|| fmt
->has_inf
))
2842 if (image_hi
|| image_lo
)
2846 r
->signalling
= ((image_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
2847 if (HOST_BITS_PER_LONG
== 32)
2849 r
->sig
[SIGSZ
-1] = image_hi
;
2850 r
->sig
[SIGSZ
-2] = image_lo
;
2853 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
;
2865 SET_REAL_EXP (r
, exp
- 1023 + 1);
2866 if (HOST_BITS_PER_LONG
== 32)
2868 r
->sig
[SIGSZ
-1] = image_hi
| SIG_MSB
;
2869 r
->sig
[SIGSZ
-2] = image_lo
;
2872 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
| SIG_MSB
;
2876 const struct real_format ieee_double_format
=
2895 const struct real_format mips_double_format
=
2915 /* IEEE extended real format. This comes in three flavors: Intel's as
2916 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
2917 12- and 16-byte images may be big- or little endian; Motorola's is
2918 always big endian. */
2920 /* Helper subroutine which converts from the internal format to the
2921 12-byte little-endian Intel format. Functions below adjust this
2922 for the other possible formats. */
2924 encode_ieee_extended (const struct real_format
*fmt
, long *buf
,
2925 const REAL_VALUE_TYPE
*r
)
2927 unsigned long image_hi
, sig_hi
, sig_lo
;
2928 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2930 image_hi
= r
->sign
<< 15;
2931 sig_hi
= sig_lo
= 0;
2943 /* Intel requires the explicit integer bit to be set, otherwise
2944 it considers the value a "pseudo-infinity". Motorola docs
2945 say it doesn't care. */
2946 sig_hi
= 0x80000000;
2951 sig_lo
= sig_hi
= 0xffffffff;
2959 if (HOST_BITS_PER_LONG
== 32)
2961 sig_hi
= r
->sig
[SIGSZ
-1];
2962 sig_lo
= r
->sig
[SIGSZ
-2];
2966 sig_lo
= r
->sig
[SIGSZ
-1];
2967 sig_hi
= sig_lo
>> 31 >> 1;
2968 sig_lo
&= 0xffffffff;
2970 if (r
->signalling
== fmt
->qnan_msb_set
)
2971 sig_hi
&= ~(1 << 30);
2974 if ((sig_hi
& 0x7fffffff) == 0 && sig_lo
== 0)
2977 /* Intel requires the explicit integer bit to be set, otherwise
2978 it considers the value a "pseudo-nan". Motorola docs say it
2980 sig_hi
|= 0x80000000;
2985 sig_lo
= sig_hi
= 0xffffffff;
2991 int exp
= REAL_EXP (r
);
2993 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2994 whereas the intermediate representation is 0.F x 2**exp.
2995 Which means we're off by one.
2997 Except for Motorola, which consider exp=0 and explicit
2998 integer bit set to continue to be normalized. In theory
2999 this discrepancy has been taken care of by the difference
3000 in fmt->emin in round_for_format. */
3007 gcc_assert (exp
>= 0);
3011 if (HOST_BITS_PER_LONG
== 32)
3013 sig_hi
= r
->sig
[SIGSZ
-1];
3014 sig_lo
= r
->sig
[SIGSZ
-2];
3018 sig_lo
= r
->sig
[SIGSZ
-1];
3019 sig_hi
= sig_lo
>> 31 >> 1;
3020 sig_lo
&= 0xffffffff;
3029 buf
[0] = sig_lo
, buf
[1] = sig_hi
, buf
[2] = image_hi
;
3032 /* Convert from the internal format to the 12-byte Motorola format
3033 for an IEEE extended real. */
3035 encode_ieee_extended_motorola (const struct real_format
*fmt
, long *buf
,
3036 const REAL_VALUE_TYPE
*r
)
3039 encode_ieee_extended (fmt
, intermed
, r
);
3041 /* Motorola chips are assumed always to be big-endian. Also, the
3042 padding in a Motorola extended real goes between the exponent and
3043 the mantissa. At this point the mantissa is entirely within
3044 elements 0 and 1 of intermed, and the exponent entirely within
3045 element 2, so all we have to do is swap the order around, and
3046 shift element 2 left 16 bits. */
3047 buf
[0] = intermed
[2] << 16;
3048 buf
[1] = intermed
[1];
3049 buf
[2] = intermed
[0];
3052 /* Convert from the internal format to the 12-byte Intel format for
3053 an IEEE extended real. */
3055 encode_ieee_extended_intel_96 (const struct real_format
*fmt
, long *buf
,
3056 const REAL_VALUE_TYPE
*r
)
3058 if (FLOAT_WORDS_BIG_ENDIAN
)
3060 /* All the padding in an Intel-format extended real goes at the high
3061 end, which in this case is after the mantissa, not the exponent.
3062 Therefore we must shift everything down 16 bits. */
3064 encode_ieee_extended (fmt
, intermed
, r
);
3065 buf
[0] = ((intermed
[2] << 16) | ((unsigned long)(intermed
[1] & 0xFFFF0000) >> 16));
3066 buf
[1] = ((intermed
[1] << 16) | ((unsigned long)(intermed
[0] & 0xFFFF0000) >> 16));
3067 buf
[2] = (intermed
[0] << 16);
3070 /* encode_ieee_extended produces what we want directly. */
3071 encode_ieee_extended (fmt
, buf
, r
);
3074 /* Convert from the internal format to the 16-byte Intel format for
3075 an IEEE extended real. */
3077 encode_ieee_extended_intel_128 (const struct real_format
*fmt
, long *buf
,
3078 const REAL_VALUE_TYPE
*r
)
3080 /* All the padding in an Intel-format extended real goes at the high end. */
3081 encode_ieee_extended_intel_96 (fmt
, buf
, r
);
3085 /* As above, we have a helper function which converts from 12-byte
3086 little-endian Intel format to internal format. Functions below
3087 adjust for the other possible formats. */
3089 decode_ieee_extended (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3092 unsigned long image_hi
, sig_hi
, sig_lo
;
3096 sig_lo
= buf
[0], sig_hi
= buf
[1], image_hi
= buf
[2];
3097 sig_lo
&= 0xffffffff;
3098 sig_hi
&= 0xffffffff;
3099 image_hi
&= 0xffffffff;
3101 sign
= (image_hi
>> 15) & 1;
3102 exp
= image_hi
& 0x7fff;
3104 memset (r
, 0, sizeof (*r
));
3108 if ((sig_hi
|| sig_lo
) && fmt
->has_denorm
)
3113 /* When the IEEE format contains a hidden bit, we know that
3114 it's zero at this point, and so shift up the significand
3115 and decrease the exponent to match. In this case, Motorola
3116 defines the explicit integer bit to be valid, so we don't
3117 know whether the msb is set or not. */
3118 SET_REAL_EXP (r
, fmt
->emin
);
3119 if (HOST_BITS_PER_LONG
== 32)
3121 r
->sig
[SIGSZ
-1] = sig_hi
;
3122 r
->sig
[SIGSZ
-2] = sig_lo
;
3125 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3129 else if (fmt
->has_signed_zero
)
3132 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3134 /* See above re "pseudo-infinities" and "pseudo-nans".
3135 Short summary is that the MSB will likely always be
3136 set, and that we don't care about it. */
3137 sig_hi
&= 0x7fffffff;
3139 if (sig_hi
|| sig_lo
)
3143 r
->signalling
= ((sig_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
3144 if (HOST_BITS_PER_LONG
== 32)
3146 r
->sig
[SIGSZ
-1] = sig_hi
;
3147 r
->sig
[SIGSZ
-2] = sig_lo
;
3150 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3162 SET_REAL_EXP (r
, exp
- 16383 + 1);
3163 if (HOST_BITS_PER_LONG
== 32)
3165 r
->sig
[SIGSZ
-1] = sig_hi
;
3166 r
->sig
[SIGSZ
-2] = sig_lo
;
3169 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3173 /* Convert from the internal format to the 12-byte Motorola format
3174 for an IEEE extended real. */
3176 decode_ieee_extended_motorola (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3181 /* Motorola chips are assumed always to be big-endian. Also, the
3182 padding in a Motorola extended real goes between the exponent and
3183 the mantissa; remove it. */
3184 intermed
[0] = buf
[2];
3185 intermed
[1] = buf
[1];
3186 intermed
[2] = (unsigned long)buf
[0] >> 16;
3188 decode_ieee_extended (fmt
, r
, intermed
);
3191 /* Convert from the internal format to the 12-byte Intel format for
3192 an IEEE extended real. */
3194 decode_ieee_extended_intel_96 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3197 if (FLOAT_WORDS_BIG_ENDIAN
)
3199 /* All the padding in an Intel-format extended real goes at the high
3200 end, which in this case is after the mantissa, not the exponent.
3201 Therefore we must shift everything up 16 bits. */
3204 intermed
[0] = (((unsigned long)buf
[2] >> 16) | (buf
[1] << 16));
3205 intermed
[1] = (((unsigned long)buf
[1] >> 16) | (buf
[0] << 16));
3206 intermed
[2] = ((unsigned long)buf
[0] >> 16);
3208 decode_ieee_extended (fmt
, r
, intermed
);
3211 /* decode_ieee_extended produces what we want directly. */
3212 decode_ieee_extended (fmt
, r
, buf
);
3215 /* Convert from the internal format to the 16-byte Intel format for
3216 an IEEE extended real. */
3218 decode_ieee_extended_intel_128 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3221 /* All the padding in an Intel-format extended real goes at the high end. */
3222 decode_ieee_extended_intel_96 (fmt
, r
, buf
);
3225 const struct real_format ieee_extended_motorola_format
=
3227 encode_ieee_extended_motorola
,
3228 decode_ieee_extended_motorola
,
3244 const struct real_format ieee_extended_intel_96_format
=
3246 encode_ieee_extended_intel_96
,
3247 decode_ieee_extended_intel_96
,
3263 const struct real_format ieee_extended_intel_128_format
=
3265 encode_ieee_extended_intel_128
,
3266 decode_ieee_extended_intel_128
,
3282 /* The following caters to i386 systems that set the rounding precision
3283 to 53 bits instead of 64, e.g. FreeBSD. */
3284 const struct real_format ieee_extended_intel_96_round_53_format
=
3286 encode_ieee_extended_intel_96
,
3287 decode_ieee_extended_intel_96
,
3303 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3304 numbers whose sum is equal to the extended precision value. The number
3305 with greater magnitude is first. This format has the same magnitude
3306 range as an IEEE double precision value, but effectively 106 bits of
3307 significand precision. Infinity and NaN are represented by their IEEE
3308 double precision value stored in the first number, the second number is
3309 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3311 static void encode_ibm_extended (const struct real_format
*fmt
,
3312 long *, const REAL_VALUE_TYPE
*);
3313 static void decode_ibm_extended (const struct real_format
*,
3314 REAL_VALUE_TYPE
*, const long *);
3317 encode_ibm_extended (const struct real_format
*fmt
, long *buf
,
3318 const REAL_VALUE_TYPE
*r
)
3320 REAL_VALUE_TYPE u
, normr
, v
;
3321 const struct real_format
*base_fmt
;
3323 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3325 /* Renormlize R before doing any arithmetic on it. */
3327 if (normr
.cl
== rvc_normal
)
3330 /* u = IEEE double precision portion of significand. */
3332 round_for_format (base_fmt
, &u
);
3333 encode_ieee_double (base_fmt
, &buf
[0], &u
);
3335 if (u
.cl
== rvc_normal
)
3337 do_add (&v
, &normr
, &u
, 1);
3338 /* Call round_for_format since we might need to denormalize. */
3339 round_for_format (base_fmt
, &v
);
3340 encode_ieee_double (base_fmt
, &buf
[2], &v
);
3344 /* Inf, NaN, 0 are all representable as doubles, so the
3345 least-significant part can be 0.0. */
3352 decode_ibm_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
, REAL_VALUE_TYPE
*r
,
3355 REAL_VALUE_TYPE u
, v
;
3356 const struct real_format
*base_fmt
;
3358 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3359 decode_ieee_double (base_fmt
, &u
, &buf
[0]);
3361 if (u
.cl
!= rvc_zero
&& u
.cl
!= rvc_inf
&& u
.cl
!= rvc_nan
)
3363 decode_ieee_double (base_fmt
, &v
, &buf
[2]);
3364 do_add (r
, &u
, &v
, 0);
3370 const struct real_format ibm_extended_format
=
3372 encode_ibm_extended
,
3373 decode_ibm_extended
,
3389 const struct real_format mips_extended_format
=
3391 encode_ibm_extended
,
3392 decode_ibm_extended
,
3409 /* IEEE quad precision format. */
3411 static void encode_ieee_quad (const struct real_format
*fmt
,
3412 long *, const REAL_VALUE_TYPE
*);
3413 static void decode_ieee_quad (const struct real_format
*,
3414 REAL_VALUE_TYPE
*, const long *);
3417 encode_ieee_quad (const struct real_format
*fmt
, long *buf
,
3418 const REAL_VALUE_TYPE
*r
)
3420 unsigned long image3
, image2
, image1
, image0
, exp
;
3421 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3424 image3
= r
->sign
<< 31;
3429 rshift_significand (&u
, r
, SIGNIFICAND_BITS
- 113);
3438 image3
|= 32767 << 16;
3441 image3
|= 0x7fffffff;
3442 image2
= 0xffffffff;
3443 image1
= 0xffffffff;
3444 image0
= 0xffffffff;
3451 image3
|= 32767 << 16;
3455 /* Don't use bits from the significand. The
3456 initialization above is right. */
3458 else if (HOST_BITS_PER_LONG
== 32)
3463 image3
|= u
.sig
[3] & 0xffff;
3468 image1
= image0
>> 31 >> 1;
3470 image3
|= (image2
>> 31 >> 1) & 0xffff;
3471 image0
&= 0xffffffff;
3472 image2
&= 0xffffffff;
3474 if (r
->signalling
== fmt
->qnan_msb_set
)
3478 /* We overload qnan_msb_set here: it's only clear for
3479 mips_ieee_single, which wants all mantissa bits but the
3480 quiet/signalling one set in canonical NaNs (at least
3482 if (r
->canonical
&& !fmt
->qnan_msb_set
)
3485 image2
= image1
= image0
= 0xffffffff;
3487 else if (((image3
& 0xffff) | image2
| image1
| image0
) == 0)
3492 image3
|= 0x7fffffff;
3493 image2
= 0xffffffff;
3494 image1
= 0xffffffff;
3495 image0
= 0xffffffff;
3500 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3501 whereas the intermediate representation is 0.F x 2**exp.
3502 Which means we're off by one. */
3506 exp
= REAL_EXP (r
) + 16383 - 1;
3507 image3
|= exp
<< 16;
3509 if (HOST_BITS_PER_LONG
== 32)
3514 image3
|= u
.sig
[3] & 0xffff;
3519 image1
= image0
>> 31 >> 1;
3521 image3
|= (image2
>> 31 >> 1) & 0xffff;
3522 image0
&= 0xffffffff;
3523 image2
&= 0xffffffff;
3531 if (FLOAT_WORDS_BIG_ENDIAN
)
3548 decode_ieee_quad (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3551 unsigned long image3
, image2
, image1
, image0
;
3555 if (FLOAT_WORDS_BIG_ENDIAN
)
3569 image0
&= 0xffffffff;
3570 image1
&= 0xffffffff;
3571 image2
&= 0xffffffff;
3573 sign
= (image3
>> 31) & 1;
3574 exp
= (image3
>> 16) & 0x7fff;
3577 memset (r
, 0, sizeof (*r
));
3581 if ((image3
| image2
| image1
| image0
) && fmt
->has_denorm
)
3586 SET_REAL_EXP (r
, -16382 + (SIGNIFICAND_BITS
- 112));
3587 if (HOST_BITS_PER_LONG
== 32)
3596 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3597 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3602 else if (fmt
->has_signed_zero
)
3605 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3607 if (image3
| image2
| image1
| image0
)
3611 r
->signalling
= ((image3
>> 15) & 1) ^ fmt
->qnan_msb_set
;
3613 if (HOST_BITS_PER_LONG
== 32)
3622 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3623 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3625 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3637 SET_REAL_EXP (r
, exp
- 16383 + 1);
3639 if (HOST_BITS_PER_LONG
== 32)
3648 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3649 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3651 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3652 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3656 const struct real_format ieee_quad_format
=
3675 const struct real_format mips_quad_format
=
3694 /* Descriptions of VAX floating point formats can be found beginning at
3696 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
3698 The thing to remember is that they're almost IEEE, except for word
3699 order, exponent bias, and the lack of infinities, nans, and denormals.
3701 We don't implement the H_floating format here, simply because neither
3702 the VAX or Alpha ports use it. */
3704 static void encode_vax_f (const struct real_format
*fmt
,
3705 long *, const REAL_VALUE_TYPE
*);
3706 static void decode_vax_f (const struct real_format
*,
3707 REAL_VALUE_TYPE
*, const long *);
3708 static void encode_vax_d (const struct real_format
*fmt
,
3709 long *, const REAL_VALUE_TYPE
*);
3710 static void decode_vax_d (const struct real_format
*,
3711 REAL_VALUE_TYPE
*, const long *);
3712 static void encode_vax_g (const struct real_format
*fmt
,
3713 long *, const REAL_VALUE_TYPE
*);
3714 static void decode_vax_g (const struct real_format
*,
3715 REAL_VALUE_TYPE
*, const long *);
3718 encode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3719 const REAL_VALUE_TYPE
*r
)
3721 unsigned long sign
, exp
, sig
, image
;
3723 sign
= r
->sign
<< 15;
3733 image
= 0xffff7fff | sign
;
3737 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
3738 exp
= REAL_EXP (r
) + 128;
3740 image
= (sig
<< 16) & 0xffff0000;
3754 decode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3755 REAL_VALUE_TYPE
*r
, const long *buf
)
3757 unsigned long image
= buf
[0] & 0xffffffff;
3758 int exp
= (image
>> 7) & 0xff;
3760 memset (r
, 0, sizeof (*r
));
3765 r
->sign
= (image
>> 15) & 1;
3766 SET_REAL_EXP (r
, exp
- 128);
3768 image
= ((image
& 0x7f) << 16) | ((image
>> 16) & 0xffff);
3769 r
->sig
[SIGSZ
-1] = (image
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
3774 encode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3775 const REAL_VALUE_TYPE
*r
)
3777 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
3782 image0
= image1
= 0;
3787 image0
= 0xffff7fff | sign
;
3788 image1
= 0xffffffff;
3792 /* Extract the significand into straight hi:lo. */
3793 if (HOST_BITS_PER_LONG
== 64)
3795 image0
= r
->sig
[SIGSZ
-1];
3796 image1
= (image0
>> (64 - 56)) & 0xffffffff;
3797 image0
= (image0
>> (64 - 56 + 1) >> 31) & 0x7fffff;
3801 image0
= r
->sig
[SIGSZ
-1];
3802 image1
= r
->sig
[SIGSZ
-2];
3803 image1
= (image0
<< 24) | (image1
>> 8);
3804 image0
= (image0
>> 8) & 0xffffff;
3807 /* Rearrange the half-words of the significand to match the
3809 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff007f;
3810 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
3812 /* Add the sign and exponent. */
3814 image0
|= (REAL_EXP (r
) + 128) << 7;
3821 if (FLOAT_WORDS_BIG_ENDIAN
)
3822 buf
[0] = image1
, buf
[1] = image0
;
3824 buf
[0] = image0
, buf
[1] = image1
;
3828 decode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3829 REAL_VALUE_TYPE
*r
, const long *buf
)
3831 unsigned long image0
, image1
;
3834 if (FLOAT_WORDS_BIG_ENDIAN
)
3835 image1
= buf
[0], image0
= buf
[1];
3837 image0
= buf
[0], image1
= buf
[1];
3838 image0
&= 0xffffffff;
3839 image1
&= 0xffffffff;
3841 exp
= (image0
>> 7) & 0xff;
3843 memset (r
, 0, sizeof (*r
));
3848 r
->sign
= (image0
>> 15) & 1;
3849 SET_REAL_EXP (r
, exp
- 128);
3851 /* Rearrange the half-words of the external format into
3852 proper ascending order. */
3853 image0
= ((image0
& 0x7f) << 16) | ((image0
>> 16) & 0xffff);
3854 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
3856 if (HOST_BITS_PER_LONG
== 64)
3858 image0
= (image0
<< 31 << 1) | image1
;
3861 r
->sig
[SIGSZ
-1] = image0
;
3865 r
->sig
[SIGSZ
-1] = image0
;
3866 r
->sig
[SIGSZ
-2] = image1
;
3867 lshift_significand (r
, r
, 2*HOST_BITS_PER_LONG
- 56);
3868 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3874 encode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3875 const REAL_VALUE_TYPE
*r
)
3877 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
3882 image0
= image1
= 0;
3887 image0
= 0xffff7fff | sign
;
3888 image1
= 0xffffffff;
3892 /* Extract the significand into straight hi:lo. */
3893 if (HOST_BITS_PER_LONG
== 64)
3895 image0
= r
->sig
[SIGSZ
-1];
3896 image1
= (image0
>> (64 - 53)) & 0xffffffff;
3897 image0
= (image0
>> (64 - 53 + 1) >> 31) & 0xfffff;
3901 image0
= r
->sig
[SIGSZ
-1];
3902 image1
= r
->sig
[SIGSZ
-2];
3903 image1
= (image0
<< 21) | (image1
>> 11);
3904 image0
= (image0
>> 11) & 0xfffff;
3907 /* Rearrange the half-words of the significand to match the
3909 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff000f;
3910 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
3912 /* Add the sign and exponent. */
3914 image0
|= (REAL_EXP (r
) + 1024) << 4;
3921 if (FLOAT_WORDS_BIG_ENDIAN
)
3922 buf
[0] = image1
, buf
[1] = image0
;
3924 buf
[0] = image0
, buf
[1] = image1
;
3928 decode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3929 REAL_VALUE_TYPE
*r
, const long *buf
)
3931 unsigned long image0
, image1
;
3934 if (FLOAT_WORDS_BIG_ENDIAN
)
3935 image1
= buf
[0], image0
= buf
[1];
3937 image0
= buf
[0], image1
= buf
[1];
3938 image0
&= 0xffffffff;
3939 image1
&= 0xffffffff;
3941 exp
= (image0
>> 4) & 0x7ff;
3943 memset (r
, 0, sizeof (*r
));
3948 r
->sign
= (image0
>> 15) & 1;
3949 SET_REAL_EXP (r
, exp
- 1024);
3951 /* Rearrange the half-words of the external format into
3952 proper ascending order. */
3953 image0
= ((image0
& 0xf) << 16) | ((image0
>> 16) & 0xffff);
3954 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
3956 if (HOST_BITS_PER_LONG
== 64)
3958 image0
= (image0
<< 31 << 1) | image1
;
3961 r
->sig
[SIGSZ
-1] = image0
;
3965 r
->sig
[SIGSZ
-1] = image0
;
3966 r
->sig
[SIGSZ
-2] = image1
;
3967 lshift_significand (r
, r
, 64 - 53);
3968 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3973 const struct real_format vax_f_format
=
3992 const struct real_format vax_d_format
=
4011 const struct real_format vax_g_format
=
4030 /* A good reference for these can be found in chapter 9 of
4031 "ESA/390 Principles of Operation", IBM document number SA22-7201-01.
4032 An on-line version can be found here:
4034 http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/DZ9AR001/9.1?DT=19930923083613
4037 static void encode_i370_single (const struct real_format
*fmt
,
4038 long *, const REAL_VALUE_TYPE
*);
4039 static void decode_i370_single (const struct real_format
*,
4040 REAL_VALUE_TYPE
*, const long *);
4041 static void encode_i370_double (const struct real_format
*fmt
,
4042 long *, const REAL_VALUE_TYPE
*);
4043 static void decode_i370_double (const struct real_format
*,
4044 REAL_VALUE_TYPE
*, const long *);
4047 encode_i370_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4048 long *buf
, const REAL_VALUE_TYPE
*r
)
4050 unsigned long sign
, exp
, sig
, image
;
4052 sign
= r
->sign
<< 31;
4062 image
= 0x7fffffff | sign
;
4066 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0xffffff;
4067 exp
= ((REAL_EXP (r
) / 4) + 64) << 24;
4068 image
= sign
| exp
| sig
;
4079 decode_i370_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4080 REAL_VALUE_TYPE
*r
, const long *buf
)
4082 unsigned long sign
, sig
, image
= buf
[0];
4085 sign
= (image
>> 31) & 1;
4086 exp
= (image
>> 24) & 0x7f;
4087 sig
= image
& 0xffffff;
4089 memset (r
, 0, sizeof (*r
));
4095 SET_REAL_EXP (r
, (exp
- 64) * 4);
4096 r
->sig
[SIGSZ
-1] = sig
<< (HOST_BITS_PER_LONG
- 24);
4102 encode_i370_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4103 long *buf
, const REAL_VALUE_TYPE
*r
)
4105 unsigned long sign
, exp
, image_hi
, image_lo
;
4107 sign
= r
->sign
<< 31;
4112 image_hi
= image_lo
= 0;
4117 image_hi
= 0x7fffffff | sign
;
4118 image_lo
= 0xffffffff;
4122 if (HOST_BITS_PER_LONG
== 64)
4124 image_hi
= r
->sig
[SIGSZ
-1];
4125 image_lo
= (image_hi
>> (64 - 56)) & 0xffffffff;
4126 image_hi
= (image_hi
>> (64 - 56 + 1) >> 31) & 0xffffff;
4130 image_hi
= r
->sig
[SIGSZ
-1];
4131 image_lo
= r
->sig
[SIGSZ
-2];
4132 image_lo
= (image_lo
>> 8) | (image_hi
<< 24);
4136 exp
= ((REAL_EXP (r
) / 4) + 64) << 24;
4137 image_hi
|= sign
| exp
;
4144 if (FLOAT_WORDS_BIG_ENDIAN
)
4145 buf
[0] = image_hi
, buf
[1] = image_lo
;
4147 buf
[0] = image_lo
, buf
[1] = image_hi
;
4151 decode_i370_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4152 REAL_VALUE_TYPE
*r
, const long *buf
)
4154 unsigned long sign
, image_hi
, image_lo
;
4157 if (FLOAT_WORDS_BIG_ENDIAN
)
4158 image_hi
= buf
[0], image_lo
= buf
[1];
4160 image_lo
= buf
[0], image_hi
= buf
[1];
4162 sign
= (image_hi
>> 31) & 1;
4163 exp
= (image_hi
>> 24) & 0x7f;
4164 image_hi
&= 0xffffff;
4165 image_lo
&= 0xffffffff;
4167 memset (r
, 0, sizeof (*r
));
4169 if (exp
|| image_hi
|| image_lo
)
4173 SET_REAL_EXP (r
, (exp
- 64) * 4 + (SIGNIFICAND_BITS
- 56));
4175 if (HOST_BITS_PER_LONG
== 32)
4177 r
->sig
[0] = image_lo
;
4178 r
->sig
[1] = image_hi
;
4181 r
->sig
[0] = image_lo
| (image_hi
<< 31 << 1);
4187 const struct real_format i370_single_format
=
4201 false, /* ??? The encoding does allow for "unnormals". */
4202 false, /* ??? The encoding does allow for "unnormals". */
4206 const struct real_format i370_double_format
=
4220 false, /* ??? The encoding does allow for "unnormals". */
4221 false, /* ??? The encoding does allow for "unnormals". */
4225 /* The "twos-complement" c4x format is officially defined as
4229 This is rather misleading. One must remember that F is signed.
4230 A better description would be
4232 x = -1**s * ((s + 1 + .f) * 2**e
4234 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
4235 that's -1 * (1+1+(-.5)) == -1.5. I think.
4237 The constructions here are taken from Tables 5-1 and 5-2 of the
4238 TMS320C4x User's Guide wherein step-by-step instructions for
4239 conversion from IEEE are presented. That's close enough to our
4240 internal representation so as to make things easy.
4242 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
4244 static void encode_c4x_single (const struct real_format
*fmt
,
4245 long *, const REAL_VALUE_TYPE
*);
4246 static void decode_c4x_single (const struct real_format
*,
4247 REAL_VALUE_TYPE
*, const long *);
4248 static void encode_c4x_extended (const struct real_format
*fmt
,
4249 long *, const REAL_VALUE_TYPE
*);
4250 static void decode_c4x_extended (const struct real_format
*,
4251 REAL_VALUE_TYPE
*, const long *);
4254 encode_c4x_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4255 long *buf
, const REAL_VALUE_TYPE
*r
)
4257 unsigned long image
, exp
, sig
;
4269 sig
= 0x800000 - r
->sign
;
4273 exp
= REAL_EXP (r
) - 1;
4274 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
4289 image
= ((exp
& 0xff) << 24) | (sig
& 0xffffff);
4294 decode_c4x_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4295 REAL_VALUE_TYPE
*r
, const long *buf
)
4297 unsigned long image
= buf
[0];
4301 exp
= (((image
>> 24) & 0xff) ^ 0x80) - 0x80;
4302 sf
= ((image
& 0xffffff) ^ 0x800000) - 0x800000;
4304 memset (r
, 0, sizeof (*r
));
4310 sig
= sf
& 0x7fffff;
4319 sig
= (sig
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
4321 SET_REAL_EXP (r
, exp
+ 1);
4322 r
->sig
[SIGSZ
-1] = sig
;
4327 encode_c4x_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4328 long *buf
, const REAL_VALUE_TYPE
*r
)
4330 unsigned long exp
, sig
;
4342 sig
= 0x80000000 - r
->sign
;
4346 exp
= REAL_EXP (r
) - 1;
4348 sig
= r
->sig
[SIGSZ
-1];
4349 if (HOST_BITS_PER_LONG
== 64)
4350 sig
= sig
>> 1 >> 31;
4367 exp
= (exp
& 0xff) << 24;
4370 if (FLOAT_WORDS_BIG_ENDIAN
)
4371 buf
[0] = exp
, buf
[1] = sig
;
4373 buf
[0] = sig
, buf
[0] = exp
;
4377 decode_c4x_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4378 REAL_VALUE_TYPE
*r
, const long *buf
)
4383 if (FLOAT_WORDS_BIG_ENDIAN
)
4384 exp
= buf
[0], sf
= buf
[1];
4386 sf
= buf
[0], exp
= buf
[1];
4388 exp
= (((exp
>> 24) & 0xff) & 0x80) - 0x80;
4389 sf
= ((sf
& 0xffffffff) ^ 0x80000000) - 0x80000000;
4391 memset (r
, 0, sizeof (*r
));
4397 sig
= sf
& 0x7fffffff;
4406 if (HOST_BITS_PER_LONG
== 64)
4407 sig
= sig
<< 1 << 31;
4410 SET_REAL_EXP (r
, exp
+ 1);
4411 r
->sig
[SIGSZ
-1] = sig
;
4415 const struct real_format c4x_single_format
=
4434 const struct real_format c4x_extended_format
=
4436 encode_c4x_extended
,
4437 decode_c4x_extended
,
4454 /* A synthetic "format" for internal arithmetic. It's the size of the
4455 internal significand minus the two bits needed for proper rounding.
4456 The encode and decode routines exist only to satisfy our paranoia
4459 static void encode_internal (const struct real_format
*fmt
,
4460 long *, const REAL_VALUE_TYPE
*);
4461 static void decode_internal (const struct real_format
*,
4462 REAL_VALUE_TYPE
*, const long *);
4465 encode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4466 const REAL_VALUE_TYPE
*r
)
4468 memcpy (buf
, r
, sizeof (*r
));
4472 decode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4473 REAL_VALUE_TYPE
*r
, const long *buf
)
4475 memcpy (r
, buf
, sizeof (*r
));
4478 const struct real_format real_internal_format
=
4484 SIGNIFICAND_BITS
- 2,
4485 SIGNIFICAND_BITS
- 2,
4497 /* Calculate the square root of X in mode MODE, and store the result
4498 in R. Return TRUE if the operation does not raise an exception.
4499 For details see "High Precision Division and Square Root",
4500 Alan H. Karp and Peter Markstein, HP Lab Report 93-93-42, June
4501 1993. http://www.hpl.hp.com/techreports/93/HPL-93-42.pdf. */
4504 real_sqrt (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4505 const REAL_VALUE_TYPE
*x
)
4507 static REAL_VALUE_TYPE halfthree
;
4508 static bool init
= false;
4509 REAL_VALUE_TYPE h
, t
, i
;
4512 /* sqrt(-0.0) is -0.0. */
4513 if (real_isnegzero (x
))
4519 /* Negative arguments return NaN. */
4522 get_canonical_qnan (r
, 0);
4526 /* Infinity and NaN return themselves. */
4527 if (real_isinf (x
) || real_isnan (x
))
4535 do_add (&halfthree
, &dconst1
, &dconsthalf
, 0);
4539 /* Initial guess for reciprocal sqrt, i. */
4540 exp
= real_exponent (x
);
4541 real_ldexp (&i
, &dconst1
, -exp
/2);
4543 /* Newton's iteration for reciprocal sqrt, i. */
4544 for (iter
= 0; iter
< 16; iter
++)
4546 /* i(n+1) = i(n) * (1.5 - 0.5*i(n)*i(n)*x). */
4547 do_multiply (&t
, x
, &i
);
4548 do_multiply (&h
, &t
, &i
);
4549 do_multiply (&t
, &h
, &dconsthalf
);
4550 do_add (&h
, &halfthree
, &t
, 1);
4551 do_multiply (&t
, &i
, &h
);
4553 /* Check for early convergence. */
4554 if (iter
>= 6 && real_identical (&i
, &t
))
4557 /* ??? Unroll loop to avoid copying. */
4561 /* Final iteration: r = i*x + 0.5*i*x*(1.0 - i*(i*x)). */
4562 do_multiply (&t
, x
, &i
);
4563 do_multiply (&h
, &t
, &i
);
4564 do_add (&i
, &dconst1
, &h
, 1);
4565 do_multiply (&h
, &t
, &i
);
4566 do_multiply (&i
, &dconsthalf
, &h
);
4567 do_add (&h
, &t
, &i
, 0);
4569 /* ??? We need a Tuckerman test to get the last bit. */
4571 real_convert (r
, mode
, &h
);
4575 /* Calculate X raised to the integer exponent N in mode MODE and store
4576 the result in R. Return true if the result may be inexact due to
4577 loss of precision. The algorithm is the classic "left-to-right binary
4578 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
4579 Algorithms", "The Art of Computer Programming", Volume 2. */
4582 real_powi (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4583 const REAL_VALUE_TYPE
*x
, HOST_WIDE_INT n
)
4585 unsigned HOST_WIDE_INT bit
;
4587 bool inexact
= false;
4599 /* Don't worry about overflow, from now on n is unsigned. */
4607 bit
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
4608 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
; i
++)
4612 inexact
|= do_multiply (&t
, &t
, &t
);
4614 inexact
|= do_multiply (&t
, &t
, x
);
4622 inexact
|= do_divide (&t
, &dconst1
, &t
);
4624 real_convert (r
, mode
, &t
);
4628 /* Round X to the nearest integer not larger in absolute value, i.e.
4629 towards zero, placing the result in R in mode MODE. */
4632 real_trunc (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4633 const REAL_VALUE_TYPE
*x
)
4635 do_fix_trunc (r
, x
);
4636 if (mode
!= VOIDmode
)
4637 real_convert (r
, mode
, r
);
4640 /* Round X to the largest integer not greater in value, i.e. round
4641 down, placing the result in R in mode MODE. */
4644 real_floor (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4645 const REAL_VALUE_TYPE
*x
)
4649 do_fix_trunc (&t
, x
);
4650 if (! real_identical (&t
, x
) && x
->sign
)
4651 do_add (&t
, &t
, &dconstm1
, 0);
4652 if (mode
!= VOIDmode
)
4653 real_convert (r
, mode
, &t
);
4658 /* Round X to the smallest integer not less then argument, i.e. round
4659 up, placing the result in R in mode MODE. */
4662 real_ceil (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4663 const REAL_VALUE_TYPE
*x
)
4667 do_fix_trunc (&t
, x
);
4668 if (! real_identical (&t
, x
) && ! x
->sign
)
4669 do_add (&t
, &t
, &dconst1
, 0);
4670 if (mode
!= VOIDmode
)
4671 real_convert (r
, mode
, &t
);
4676 /* Round X to the nearest integer, but round halfway cases away from
4680 real_round (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4681 const REAL_VALUE_TYPE
*x
)
4683 do_add (r
, x
, &dconsthalf
, x
->sign
);
4684 do_fix_trunc (r
, r
);
4685 if (mode
!= VOIDmode
)
4686 real_convert (r
, mode
, r
);
4689 /* Set the sign of R to the sign of X. */
4692 real_copysign (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*x
)