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, 59 Temple Place - Suite 330, 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
);
1798 if (pos
== SIGNIFICAND_BITS
- 4)
1805 d
= hex_value (*str
);
1810 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1811 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1817 if (*str
== 'p' || *str
== 'P')
1819 bool exp_neg
= false;
1827 else if (*str
== '+')
1831 while (ISDIGIT (*str
))
1837 /* Overflowed the exponent. */
1852 SET_REAL_EXP (r
, exp
);
1858 /* Decimal floating point. */
1859 const REAL_VALUE_TYPE
*ten
= ten_to_ptwo (0);
1864 while (ISDIGIT (*str
))
1867 do_multiply (r
, r
, ten
);
1869 do_add (r
, r
, real_digit (d
), 0);
1874 if (r
->cl
== rvc_zero
)
1879 while (ISDIGIT (*str
))
1882 do_multiply (r
, r
, ten
);
1884 do_add (r
, r
, real_digit (d
), 0);
1889 if (*str
== 'e' || *str
== 'E')
1891 bool exp_neg
= false;
1899 else if (*str
== '+')
1903 while (ISDIGIT (*str
))
1909 /* Overflowed the exponent. */
1923 times_pten (r
, exp
);
1938 /* Legacy. Similar, but return the result directly. */
1941 real_from_string2 (const char *s
, enum machine_mode mode
)
1945 real_from_string (&r
, s
);
1946 if (mode
!= VOIDmode
)
1947 real_convert (&r
, mode
, &r
);
1952 /* Initialize R from the integer pair HIGH+LOW. */
1955 real_from_integer (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
1956 unsigned HOST_WIDE_INT low
, HOST_WIDE_INT high
,
1959 if (low
== 0 && high
== 0)
1963 memset (r
, 0, sizeof (*r
));
1965 r
->sign
= high
< 0 && !unsigned_p
;
1966 SET_REAL_EXP (r
, 2 * HOST_BITS_PER_WIDE_INT
);
1977 if (HOST_BITS_PER_LONG
== HOST_BITS_PER_WIDE_INT
)
1979 r
->sig
[SIGSZ
-1] = high
;
1980 r
->sig
[SIGSZ
-2] = low
;
1984 gcc_assert (HOST_BITS_PER_LONG
*2 == HOST_BITS_PER_WIDE_INT
);
1985 r
->sig
[SIGSZ
-1] = high
>> (HOST_BITS_PER_LONG
- 1) >> 1;
1986 r
->sig
[SIGSZ
-2] = high
;
1987 r
->sig
[SIGSZ
-3] = low
>> (HOST_BITS_PER_LONG
- 1) >> 1;
1988 r
->sig
[SIGSZ
-4] = low
;
1994 if (mode
!= VOIDmode
)
1995 real_convert (r
, mode
, r
);
1998 /* Returns 10**2**N. */
2000 static const REAL_VALUE_TYPE
*
2003 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2005 gcc_assert (n
>= 0);
2006 gcc_assert (n
< EXP_BITS
);
2008 if (tens
[n
].cl
== rvc_zero
)
2010 if (n
< (HOST_BITS_PER_WIDE_INT
== 64 ? 5 : 4))
2012 HOST_WIDE_INT t
= 10;
2015 for (i
= 0; i
< n
; ++i
)
2018 real_from_integer (&tens
[n
], VOIDmode
, t
, 0, 1);
2022 const REAL_VALUE_TYPE
*t
= ten_to_ptwo (n
- 1);
2023 do_multiply (&tens
[n
], t
, t
);
2030 /* Returns 10**(-2**N). */
2032 static const REAL_VALUE_TYPE
*
2033 ten_to_mptwo (int n
)
2035 static REAL_VALUE_TYPE tens
[EXP_BITS
];
2037 gcc_assert (n
>= 0);
2038 gcc_assert (n
< EXP_BITS
);
2040 if (tens
[n
].cl
== rvc_zero
)
2041 do_divide (&tens
[n
], real_digit (1), ten_to_ptwo (n
));
2048 static const REAL_VALUE_TYPE
*
2051 static REAL_VALUE_TYPE num
[10];
2053 gcc_assert (n
>= 0);
2054 gcc_assert (n
<= 9);
2056 if (n
> 0 && num
[n
].cl
== rvc_zero
)
2057 real_from_integer (&num
[n
], VOIDmode
, n
, 0, 1);
2062 /* Multiply R by 10**EXP. */
2065 times_pten (REAL_VALUE_TYPE
*r
, int exp
)
2067 REAL_VALUE_TYPE pten
, *rr
;
2068 bool negative
= (exp
< 0);
2074 pten
= *real_digit (1);
2080 for (i
= 0; exp
> 0; ++i
, exp
>>= 1)
2082 do_multiply (rr
, rr
, ten_to_ptwo (i
));
2085 do_divide (r
, r
, &pten
);
2088 /* Fills R with +Inf. */
2091 real_inf (REAL_VALUE_TYPE
*r
)
2096 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2097 we force a QNaN, else we force an SNaN. The string, if not empty,
2098 is parsed as a number and placed in the significand. Return true
2099 if the string was successfully parsed. */
2102 real_nan (REAL_VALUE_TYPE
*r
, const char *str
, int quiet
,
2103 enum machine_mode mode
)
2105 const struct real_format
*fmt
;
2107 fmt
= REAL_MODE_FORMAT (mode
);
2113 get_canonical_qnan (r
, 0);
2115 get_canonical_snan (r
, 0);
2122 memset (r
, 0, sizeof (*r
));
2125 /* Parse akin to strtol into the significand of R. */
2127 while (ISSPACE (*str
))
2131 else if (*str
== '+')
2141 while ((d
= hex_value (*str
)) < base
)
2148 lshift_significand (r
, r
, 3);
2151 lshift_significand (r
, r
, 4);
2154 lshift_significand_1 (&u
, r
);
2155 lshift_significand (r
, r
, 3);
2156 add_significands (r
, r
, &u
);
2164 add_significands (r
, r
, &u
);
2169 /* Must have consumed the entire string for success. */
2173 /* Shift the significand into place such that the bits
2174 are in the most significant bits for the format. */
2175 lshift_significand (r
, r
, SIGNIFICAND_BITS
- fmt
->pnan
);
2177 /* Our MSB is always unset for NaNs. */
2178 r
->sig
[SIGSZ
-1] &= ~SIG_MSB
;
2180 /* Force quiet or signalling NaN. */
2181 r
->signalling
= !quiet
;
2187 /* Fills R with the largest finite value representable in mode MODE.
2188 If SIGN is nonzero, R is set to the most negative finite value. */
2191 real_maxval (REAL_VALUE_TYPE
*r
, int sign
, enum machine_mode mode
)
2193 const struct real_format
*fmt
;
2196 fmt
= REAL_MODE_FORMAT (mode
);
2203 SET_REAL_EXP (r
, fmt
->emax
* fmt
->log2_b
);
2205 np2
= SIGNIFICAND_BITS
- fmt
->p
* fmt
->log2_b
;
2206 memset (r
->sig
, -1, SIGSZ
* sizeof (unsigned long));
2207 clear_significand_below (r
, np2
);
2210 /* Fills R with 2**N. */
2213 real_2expN (REAL_VALUE_TYPE
*r
, int n
)
2215 memset (r
, 0, sizeof (*r
));
2220 else if (n
< -MAX_EXP
)
2225 SET_REAL_EXP (r
, n
);
2226 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2232 round_for_format (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
)
2235 unsigned long sticky
;
2239 p2
= fmt
->p
* fmt
->log2_b
;
2240 emin2m1
= (fmt
->emin
- 1) * fmt
->log2_b
;
2241 emax2
= fmt
->emax
* fmt
->log2_b
;
2243 np2
= SIGNIFICAND_BITS
- p2
;
2247 get_zero (r
, r
->sign
);
2249 if (!fmt
->has_signed_zero
)
2254 get_inf (r
, r
->sign
);
2259 clear_significand_below (r
, np2
);
2269 /* If we're not base2, normalize the exponent to a multiple of
2271 if (fmt
->log2_b
!= 1)
2273 int shift
= REAL_EXP (r
) & (fmt
->log2_b
- 1);
2276 shift
= fmt
->log2_b
- shift
;
2277 r
->sig
[0] |= sticky_rshift_significand (r
, r
, shift
);
2278 SET_REAL_EXP (r
, REAL_EXP (r
) + shift
);
2282 /* Check the range of the exponent. If we're out of range,
2283 either underflow or overflow. */
2284 if (REAL_EXP (r
) > emax2
)
2286 else if (REAL_EXP (r
) <= emin2m1
)
2290 if (!fmt
->has_denorm
)
2292 /* Don't underflow completely until we've had a chance to round. */
2293 if (REAL_EXP (r
) < emin2m1
)
2298 diff
= emin2m1
- REAL_EXP (r
) + 1;
2302 /* De-normalize the significand. */
2303 r
->sig
[0] |= sticky_rshift_significand (r
, r
, diff
);
2304 SET_REAL_EXP (r
, REAL_EXP (r
) + diff
);
2308 /* There are P2 true significand bits, followed by one guard bit,
2309 followed by one sticky bit, followed by stuff. Fold nonzero
2310 stuff into the sticky bit. */
2313 for (i
= 0, w
= (np2
- 1) / HOST_BITS_PER_LONG
; i
< w
; ++i
)
2314 sticky
|= r
->sig
[i
];
2316 r
->sig
[w
] & (((unsigned long)1 << ((np2
- 1) % HOST_BITS_PER_LONG
)) - 1);
2318 guard
= test_significand_bit (r
, np2
- 1);
2319 lsb
= test_significand_bit (r
, np2
);
2321 /* Round to even. */
2322 if (guard
&& (sticky
|| lsb
))
2326 set_significand_bit (&u
, np2
);
2328 if (add_significands (r
, r
, &u
))
2330 /* Overflow. Means the significand had been all ones, and
2331 is now all zeros. Need to increase the exponent, and
2332 possibly re-normalize it. */
2333 SET_REAL_EXP (r
, REAL_EXP (r
) + 1);
2334 if (REAL_EXP (r
) > emax2
)
2336 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2338 if (fmt
->log2_b
!= 1)
2340 int shift
= REAL_EXP (r
) & (fmt
->log2_b
- 1);
2343 shift
= fmt
->log2_b
- shift
;
2344 rshift_significand (r
, r
, shift
);
2345 SET_REAL_EXP (r
, REAL_EXP (r
) + shift
);
2346 if (REAL_EXP (r
) > emax2
)
2353 /* Catch underflow that we deferred until after rounding. */
2354 if (REAL_EXP (r
) <= emin2m1
)
2357 /* Clear out trailing garbage. */
2358 clear_significand_below (r
, np2
);
2361 /* Extend or truncate to a new mode. */
2364 real_convert (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
2365 const REAL_VALUE_TYPE
*a
)
2367 const struct real_format
*fmt
;
2369 fmt
= REAL_MODE_FORMAT (mode
);
2373 round_for_format (fmt
, r
);
2375 /* round_for_format de-normalizes denormals. Undo just that part. */
2376 if (r
->cl
== rvc_normal
)
2380 /* Legacy. Likewise, except return the struct directly. */
2383 real_value_truncate (enum machine_mode mode
, REAL_VALUE_TYPE a
)
2386 real_convert (&r
, mode
, &a
);
2390 /* Return true if truncating to MODE is exact. */
2393 exact_real_truncate (enum machine_mode mode
, const REAL_VALUE_TYPE
*a
)
2395 const struct real_format
*fmt
;
2399 fmt
= REAL_MODE_FORMAT (mode
);
2402 /* Don't allow conversion to denormals. */
2403 emin2m1
= (fmt
->emin
- 1) * fmt
->log2_b
;
2404 if (REAL_EXP (a
) <= emin2m1
)
2407 /* After conversion to the new mode, the value must be identical. */
2408 real_convert (&t
, mode
, a
);
2409 return real_identical (&t
, a
);
2412 /* Write R to the given target format. Place the words of the result
2413 in target word order in BUF. There are always 32 bits in each
2414 long, no matter the size of the host long.
2416 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2419 real_to_target_fmt (long *buf
, const REAL_VALUE_TYPE
*r_orig
,
2420 const struct real_format
*fmt
)
2426 round_for_format (fmt
, &r
);
2430 (*fmt
->encode
) (fmt
, buf
, &r
);
2435 /* Similar, but look up the format from MODE. */
2438 real_to_target (long *buf
, const REAL_VALUE_TYPE
*r
, enum machine_mode mode
)
2440 const struct real_format
*fmt
;
2442 fmt
= REAL_MODE_FORMAT (mode
);
2445 return real_to_target_fmt (buf
, r
, fmt
);
2448 /* Read R from the given target format. Read the words of the result
2449 in target word order in BUF. There are always 32 bits in each
2450 long, no matter the size of the host long. */
2453 real_from_target_fmt (REAL_VALUE_TYPE
*r
, const long *buf
,
2454 const struct real_format
*fmt
)
2456 (*fmt
->decode
) (fmt
, r
, buf
);
2459 /* Similar, but look up the format from MODE. */
2462 real_from_target (REAL_VALUE_TYPE
*r
, const long *buf
, enum machine_mode mode
)
2464 const struct real_format
*fmt
;
2466 fmt
= REAL_MODE_FORMAT (mode
);
2469 (*fmt
->decode
) (fmt
, r
, buf
);
2472 /* Return the number of bits in the significand for MODE. */
2473 /* ??? Legacy. Should get access to real_format directly. */
2476 significand_size (enum machine_mode mode
)
2478 const struct real_format
*fmt
;
2480 fmt
= REAL_MODE_FORMAT (mode
);
2484 return fmt
->p
* fmt
->log2_b
;
2487 /* Return a hash value for the given real value. */
2488 /* ??? The "unsigned int" return value is intended to be hashval_t,
2489 but I didn't want to pull hashtab.h into real.h. */
2492 real_hash (const REAL_VALUE_TYPE
*r
)
2497 h
= r
->cl
| (r
->sign
<< 2);
2505 h
|= REAL_EXP (r
) << 3;
2510 h
^= (unsigned int)-1;
2519 if (sizeof(unsigned long) > sizeof(unsigned int))
2520 for (i
= 0; i
< SIGSZ
; ++i
)
2522 unsigned long s
= r
->sig
[i
];
2523 h
^= s
^ (s
>> (HOST_BITS_PER_LONG
/ 2));
2526 for (i
= 0; i
< SIGSZ
; ++i
)
2532 /* IEEE single-precision format. */
2534 static void encode_ieee_single (const struct real_format
*fmt
,
2535 long *, const REAL_VALUE_TYPE
*);
2536 static void decode_ieee_single (const struct real_format
*,
2537 REAL_VALUE_TYPE
*, const long *);
2540 encode_ieee_single (const struct real_format
*fmt
, long *buf
,
2541 const REAL_VALUE_TYPE
*r
)
2543 unsigned long image
, sig
, exp
;
2544 unsigned long sign
= r
->sign
;
2545 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2548 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
2559 image
|= 0x7fffffff;
2567 if (r
->signalling
== fmt
->qnan_msb_set
)
2571 /* We overload qnan_msb_set here: it's only clear for
2572 mips_ieee_single, which wants all mantissa bits but the
2573 quiet/signalling one set in canonical NaNs (at least
2575 if (r
->canonical
&& !fmt
->qnan_msb_set
)
2576 sig
|= (1 << 22) - 1;
2584 image
|= 0x7fffffff;
2588 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2589 whereas the intermediate representation is 0.F x 2**exp.
2590 Which means we're off by one. */
2594 exp
= REAL_EXP (r
) + 127 - 1;
2607 decode_ieee_single (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
2610 unsigned long image
= buf
[0] & 0xffffffff;
2611 bool sign
= (image
>> 31) & 1;
2612 int exp
= (image
>> 23) & 0xff;
2614 memset (r
, 0, sizeof (*r
));
2615 image
<<= HOST_BITS_PER_LONG
- 24;
2620 if (image
&& fmt
->has_denorm
)
2624 SET_REAL_EXP (r
, -126);
2625 r
->sig
[SIGSZ
-1] = image
<< 1;
2628 else if (fmt
->has_signed_zero
)
2631 else if (exp
== 255 && (fmt
->has_nans
|| fmt
->has_inf
))
2637 r
->signalling
= (((image
>> (HOST_BITS_PER_LONG
- 2)) & 1)
2638 ^ fmt
->qnan_msb_set
);
2639 r
->sig
[SIGSZ
-1] = image
;
2651 SET_REAL_EXP (r
, exp
- 127 + 1);
2652 r
->sig
[SIGSZ
-1] = image
| SIG_MSB
;
2656 const struct real_format ieee_single_format
=
2674 const struct real_format mips_single_format
=
2693 /* IEEE double-precision format. */
2695 static void encode_ieee_double (const struct real_format
*fmt
,
2696 long *, const REAL_VALUE_TYPE
*);
2697 static void decode_ieee_double (const struct real_format
*,
2698 REAL_VALUE_TYPE
*, const long *);
2701 encode_ieee_double (const struct real_format
*fmt
, long *buf
,
2702 const REAL_VALUE_TYPE
*r
)
2704 unsigned long image_lo
, image_hi
, sig_lo
, sig_hi
, exp
;
2705 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2707 image_hi
= r
->sign
<< 31;
2710 if (HOST_BITS_PER_LONG
== 64)
2712 sig_hi
= r
->sig
[SIGSZ
-1];
2713 sig_lo
= (sig_hi
>> (64 - 53)) & 0xffffffff;
2714 sig_hi
= (sig_hi
>> (64 - 53 + 1) >> 31) & 0xfffff;
2718 sig_hi
= r
->sig
[SIGSZ
-1];
2719 sig_lo
= r
->sig
[SIGSZ
-2];
2720 sig_lo
= (sig_hi
<< 21) | (sig_lo
>> 11);
2721 sig_hi
= (sig_hi
>> 11) & 0xfffff;
2731 image_hi
|= 2047 << 20;
2734 image_hi
|= 0x7fffffff;
2735 image_lo
= 0xffffffff;
2743 sig_hi
= sig_lo
= 0;
2744 if (r
->signalling
== fmt
->qnan_msb_set
)
2745 sig_hi
&= ~(1 << 19);
2748 /* We overload qnan_msb_set here: it's only clear for
2749 mips_ieee_single, which wants all mantissa bits but the
2750 quiet/signalling one set in canonical NaNs (at least
2752 if (r
->canonical
&& !fmt
->qnan_msb_set
)
2754 sig_hi
|= (1 << 19) - 1;
2755 sig_lo
= 0xffffffff;
2757 else if (sig_hi
== 0 && sig_lo
== 0)
2760 image_hi
|= 2047 << 20;
2766 image_hi
|= 0x7fffffff;
2767 image_lo
= 0xffffffff;
2772 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2773 whereas the intermediate representation is 0.F x 2**exp.
2774 Which means we're off by one. */
2778 exp
= REAL_EXP (r
) + 1023 - 1;
2779 image_hi
|= exp
<< 20;
2788 if (FLOAT_WORDS_BIG_ENDIAN
)
2789 buf
[0] = image_hi
, buf
[1] = image_lo
;
2791 buf
[0] = image_lo
, buf
[1] = image_hi
;
2795 decode_ieee_double (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
2798 unsigned long image_hi
, image_lo
;
2802 if (FLOAT_WORDS_BIG_ENDIAN
)
2803 image_hi
= buf
[0], image_lo
= buf
[1];
2805 image_lo
= buf
[0], image_hi
= buf
[1];
2806 image_lo
&= 0xffffffff;
2807 image_hi
&= 0xffffffff;
2809 sign
= (image_hi
>> 31) & 1;
2810 exp
= (image_hi
>> 20) & 0x7ff;
2812 memset (r
, 0, sizeof (*r
));
2814 image_hi
<<= 32 - 21;
2815 image_hi
|= image_lo
>> 21;
2816 image_hi
&= 0x7fffffff;
2817 image_lo
<<= 32 - 21;
2821 if ((image_hi
|| image_lo
) && fmt
->has_denorm
)
2825 SET_REAL_EXP (r
, -1022);
2826 if (HOST_BITS_PER_LONG
== 32)
2828 image_hi
= (image_hi
<< 1) | (image_lo
>> 31);
2830 r
->sig
[SIGSZ
-1] = image_hi
;
2831 r
->sig
[SIGSZ
-2] = image_lo
;
2835 image_hi
= (image_hi
<< 31 << 2) | (image_lo
<< 1);
2836 r
->sig
[SIGSZ
-1] = image_hi
;
2840 else if (fmt
->has_signed_zero
)
2843 else if (exp
== 2047 && (fmt
->has_nans
|| fmt
->has_inf
))
2845 if (image_hi
|| image_lo
)
2849 r
->signalling
= ((image_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
2850 if (HOST_BITS_PER_LONG
== 32)
2852 r
->sig
[SIGSZ
-1] = image_hi
;
2853 r
->sig
[SIGSZ
-2] = image_lo
;
2856 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
;
2868 SET_REAL_EXP (r
, exp
- 1023 + 1);
2869 if (HOST_BITS_PER_LONG
== 32)
2871 r
->sig
[SIGSZ
-1] = image_hi
| SIG_MSB
;
2872 r
->sig
[SIGSZ
-2] = image_lo
;
2875 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
| SIG_MSB
;
2879 const struct real_format ieee_double_format
=
2897 const struct real_format mips_double_format
=
2916 /* IEEE extended real format. This comes in three flavors: Intel's as
2917 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
2918 12- and 16-byte images may be big- or little endian; Motorola's is
2919 always big endian. */
2921 /* Helper subroutine which converts from the internal format to the
2922 12-byte little-endian Intel format. Functions below adjust this
2923 for the other possible formats. */
2925 encode_ieee_extended (const struct real_format
*fmt
, long *buf
,
2926 const REAL_VALUE_TYPE
*r
)
2928 unsigned long image_hi
, sig_hi
, sig_lo
;
2929 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2931 image_hi
= r
->sign
<< 15;
2932 sig_hi
= sig_lo
= 0;
2944 /* Intel requires the explicit integer bit to be set, otherwise
2945 it considers the value a "pseudo-infinity". Motorola docs
2946 say it doesn't care. */
2947 sig_hi
= 0x80000000;
2952 sig_lo
= sig_hi
= 0xffffffff;
2960 if (HOST_BITS_PER_LONG
== 32)
2962 sig_hi
= r
->sig
[SIGSZ
-1];
2963 sig_lo
= r
->sig
[SIGSZ
-2];
2967 sig_lo
= r
->sig
[SIGSZ
-1];
2968 sig_hi
= sig_lo
>> 31 >> 1;
2969 sig_lo
&= 0xffffffff;
2971 if (r
->signalling
== fmt
->qnan_msb_set
)
2972 sig_hi
&= ~(1 << 30);
2975 if ((sig_hi
& 0x7fffffff) == 0 && sig_lo
== 0)
2978 /* Intel requires the explicit integer bit to be set, otherwise
2979 it considers the value a "pseudo-nan". Motorola docs say it
2981 sig_hi
|= 0x80000000;
2986 sig_lo
= sig_hi
= 0xffffffff;
2992 int exp
= REAL_EXP (r
);
2994 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2995 whereas the intermediate representation is 0.F x 2**exp.
2996 Which means we're off by one.
2998 Except for Motorola, which consider exp=0 and explicit
2999 integer bit set to continue to be normalized. In theory
3000 this discrepancy has been taken care of by the difference
3001 in fmt->emin in round_for_format. */
3008 gcc_assert (exp
>= 0);
3012 if (HOST_BITS_PER_LONG
== 32)
3014 sig_hi
= r
->sig
[SIGSZ
-1];
3015 sig_lo
= r
->sig
[SIGSZ
-2];
3019 sig_lo
= r
->sig
[SIGSZ
-1];
3020 sig_hi
= sig_lo
>> 31 >> 1;
3021 sig_lo
&= 0xffffffff;
3030 buf
[0] = sig_lo
, buf
[1] = sig_hi
, buf
[2] = image_hi
;
3033 /* Convert from the internal format to the 12-byte Motorola format
3034 for an IEEE extended real. */
3036 encode_ieee_extended_motorola (const struct real_format
*fmt
, long *buf
,
3037 const REAL_VALUE_TYPE
*r
)
3040 encode_ieee_extended (fmt
, intermed
, r
);
3042 /* Motorola chips are assumed always to be big-endian. Also, the
3043 padding in a Motorola extended real goes between the exponent and
3044 the mantissa. At this point the mantissa is entirely within
3045 elements 0 and 1 of intermed, and the exponent entirely within
3046 element 2, so all we have to do is swap the order around, and
3047 shift element 2 left 16 bits. */
3048 buf
[0] = intermed
[2] << 16;
3049 buf
[1] = intermed
[1];
3050 buf
[2] = intermed
[0];
3053 /* Convert from the internal format to the 12-byte Intel format for
3054 an IEEE extended real. */
3056 encode_ieee_extended_intel_96 (const struct real_format
*fmt
, long *buf
,
3057 const REAL_VALUE_TYPE
*r
)
3059 if (FLOAT_WORDS_BIG_ENDIAN
)
3061 /* All the padding in an Intel-format extended real goes at the high
3062 end, which in this case is after the mantissa, not the exponent.
3063 Therefore we must shift everything down 16 bits. */
3065 encode_ieee_extended (fmt
, intermed
, r
);
3066 buf
[0] = ((intermed
[2] << 16) | ((unsigned long)(intermed
[1] & 0xFFFF0000) >> 16));
3067 buf
[1] = ((intermed
[1] << 16) | ((unsigned long)(intermed
[0] & 0xFFFF0000) >> 16));
3068 buf
[2] = (intermed
[0] << 16);
3071 /* encode_ieee_extended produces what we want directly. */
3072 encode_ieee_extended (fmt
, buf
, r
);
3075 /* Convert from the internal format to the 16-byte Intel format for
3076 an IEEE extended real. */
3078 encode_ieee_extended_intel_128 (const struct real_format
*fmt
, long *buf
,
3079 const REAL_VALUE_TYPE
*r
)
3081 /* All the padding in an Intel-format extended real goes at the high end. */
3082 encode_ieee_extended_intel_96 (fmt
, buf
, r
);
3086 /* As above, we have a helper function which converts from 12-byte
3087 little-endian Intel format to internal format. Functions below
3088 adjust for the other possible formats. */
3090 decode_ieee_extended (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3093 unsigned long image_hi
, sig_hi
, sig_lo
;
3097 sig_lo
= buf
[0], sig_hi
= buf
[1], image_hi
= buf
[2];
3098 sig_lo
&= 0xffffffff;
3099 sig_hi
&= 0xffffffff;
3100 image_hi
&= 0xffffffff;
3102 sign
= (image_hi
>> 15) & 1;
3103 exp
= image_hi
& 0x7fff;
3105 memset (r
, 0, sizeof (*r
));
3109 if ((sig_hi
|| sig_lo
) && fmt
->has_denorm
)
3114 /* When the IEEE format contains a hidden bit, we know that
3115 it's zero at this point, and so shift up the significand
3116 and decrease the exponent to match. In this case, Motorola
3117 defines the explicit integer bit to be valid, so we don't
3118 know whether the msb is set or not. */
3119 SET_REAL_EXP (r
, fmt
->emin
);
3120 if (HOST_BITS_PER_LONG
== 32)
3122 r
->sig
[SIGSZ
-1] = sig_hi
;
3123 r
->sig
[SIGSZ
-2] = sig_lo
;
3126 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3130 else if (fmt
->has_signed_zero
)
3133 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3135 /* See above re "pseudo-infinities" and "pseudo-nans".
3136 Short summary is that the MSB will likely always be
3137 set, and that we don't care about it. */
3138 sig_hi
&= 0x7fffffff;
3140 if (sig_hi
|| sig_lo
)
3144 r
->signalling
= ((sig_hi
>> 30) & 1) ^ fmt
->qnan_msb_set
;
3145 if (HOST_BITS_PER_LONG
== 32)
3147 r
->sig
[SIGSZ
-1] = sig_hi
;
3148 r
->sig
[SIGSZ
-2] = sig_lo
;
3151 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3163 SET_REAL_EXP (r
, exp
- 16383 + 1);
3164 if (HOST_BITS_PER_LONG
== 32)
3166 r
->sig
[SIGSZ
-1] = sig_hi
;
3167 r
->sig
[SIGSZ
-2] = sig_lo
;
3170 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
3174 /* Convert from the internal format to the 12-byte Motorola format
3175 for an IEEE extended real. */
3177 decode_ieee_extended_motorola (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3182 /* Motorola chips are assumed always to be big-endian. Also, the
3183 padding in a Motorola extended real goes between the exponent and
3184 the mantissa; remove it. */
3185 intermed
[0] = buf
[2];
3186 intermed
[1] = buf
[1];
3187 intermed
[2] = (unsigned long)buf
[0] >> 16;
3189 decode_ieee_extended (fmt
, r
, intermed
);
3192 /* Convert from the internal format to the 12-byte Intel format for
3193 an IEEE extended real. */
3195 decode_ieee_extended_intel_96 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3198 if (FLOAT_WORDS_BIG_ENDIAN
)
3200 /* All the padding in an Intel-format extended real goes at the high
3201 end, which in this case is after the mantissa, not the exponent.
3202 Therefore we must shift everything up 16 bits. */
3205 intermed
[0] = (((unsigned long)buf
[2] >> 16) | (buf
[1] << 16));
3206 intermed
[1] = (((unsigned long)buf
[1] >> 16) | (buf
[0] << 16));
3207 intermed
[2] = ((unsigned long)buf
[0] >> 16);
3209 decode_ieee_extended (fmt
, r
, intermed
);
3212 /* decode_ieee_extended produces what we want directly. */
3213 decode_ieee_extended (fmt
, r
, buf
);
3216 /* Convert from the internal format to the 16-byte Intel format for
3217 an IEEE extended real. */
3219 decode_ieee_extended_intel_128 (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3222 /* All the padding in an Intel-format extended real goes at the high end. */
3223 decode_ieee_extended_intel_96 (fmt
, r
, buf
);
3226 const struct real_format ieee_extended_motorola_format
=
3228 encode_ieee_extended_motorola
,
3229 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
,
3262 const struct real_format ieee_extended_intel_128_format
=
3264 encode_ieee_extended_intel_128
,
3265 decode_ieee_extended_intel_128
,
3280 /* The following caters to i386 systems that set the rounding precision
3281 to 53 bits instead of 64, e.g. FreeBSD. */
3282 const struct real_format ieee_extended_intel_96_round_53_format
=
3284 encode_ieee_extended_intel_96
,
3285 decode_ieee_extended_intel_96
,
3300 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3301 numbers whose sum is equal to the extended precision value. The number
3302 with greater magnitude is first. This format has the same magnitude
3303 range as an IEEE double precision value, but effectively 106 bits of
3304 significand precision. Infinity and NaN are represented by their IEEE
3305 double precision value stored in the first number, the second number is
3306 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3308 static void encode_ibm_extended (const struct real_format
*fmt
,
3309 long *, const REAL_VALUE_TYPE
*);
3310 static void decode_ibm_extended (const struct real_format
*,
3311 REAL_VALUE_TYPE
*, const long *);
3314 encode_ibm_extended (const struct real_format
*fmt
, long *buf
,
3315 const REAL_VALUE_TYPE
*r
)
3317 REAL_VALUE_TYPE u
, normr
, v
;
3318 const struct real_format
*base_fmt
;
3320 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3322 /* Renormlize R before doing any arithmetic on it. */
3324 if (normr
.cl
== rvc_normal
)
3327 /* u = IEEE double precision portion of significand. */
3329 round_for_format (base_fmt
, &u
);
3330 encode_ieee_double (base_fmt
, &buf
[0], &u
);
3332 if (u
.cl
== rvc_normal
)
3334 do_add (&v
, &normr
, &u
, 1);
3335 /* Call round_for_format since we might need to denormalize. */
3336 round_for_format (base_fmt
, &v
);
3337 encode_ieee_double (base_fmt
, &buf
[2], &v
);
3341 /* Inf, NaN, 0 are all representable as doubles, so the
3342 least-significant part can be 0.0. */
3349 decode_ibm_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
, REAL_VALUE_TYPE
*r
,
3352 REAL_VALUE_TYPE u
, v
;
3353 const struct real_format
*base_fmt
;
3355 base_fmt
= fmt
->qnan_msb_set
? &ieee_double_format
: &mips_double_format
;
3356 decode_ieee_double (base_fmt
, &u
, &buf
[0]);
3358 if (u
.cl
!= rvc_zero
&& u
.cl
!= rvc_inf
&& u
.cl
!= rvc_nan
)
3360 decode_ieee_double (base_fmt
, &v
, &buf
[2]);
3361 do_add (r
, &u
, &v
, 0);
3367 const struct real_format ibm_extended_format
=
3369 encode_ibm_extended
,
3370 decode_ibm_extended
,
3385 const struct real_format mips_extended_format
=
3387 encode_ibm_extended
,
3388 decode_ibm_extended
,
3404 /* IEEE quad precision format. */
3406 static void encode_ieee_quad (const struct real_format
*fmt
,
3407 long *, const REAL_VALUE_TYPE
*);
3408 static void decode_ieee_quad (const struct real_format
*,
3409 REAL_VALUE_TYPE
*, const long *);
3412 encode_ieee_quad (const struct real_format
*fmt
, long *buf
,
3413 const REAL_VALUE_TYPE
*r
)
3415 unsigned long image3
, image2
, image1
, image0
, exp
;
3416 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3419 image3
= r
->sign
<< 31;
3424 rshift_significand (&u
, r
, SIGNIFICAND_BITS
- 113);
3433 image3
|= 32767 << 16;
3436 image3
|= 0x7fffffff;
3437 image2
= 0xffffffff;
3438 image1
= 0xffffffff;
3439 image0
= 0xffffffff;
3446 image3
|= 32767 << 16;
3450 /* Don't use bits from the significand. The
3451 initialization above is right. */
3453 else if (HOST_BITS_PER_LONG
== 32)
3458 image3
|= u
.sig
[3] & 0xffff;
3463 image1
= image0
>> 31 >> 1;
3465 image3
|= (image2
>> 31 >> 1) & 0xffff;
3466 image0
&= 0xffffffff;
3467 image2
&= 0xffffffff;
3469 if (r
->signalling
== fmt
->qnan_msb_set
)
3473 /* We overload qnan_msb_set here: it's only clear for
3474 mips_ieee_single, which wants all mantissa bits but the
3475 quiet/signalling one set in canonical NaNs (at least
3477 if (r
->canonical
&& !fmt
->qnan_msb_set
)
3480 image2
= image1
= image0
= 0xffffffff;
3482 else if (((image3
& 0xffff) | image2
| image1
| image0
) == 0)
3487 image3
|= 0x7fffffff;
3488 image2
= 0xffffffff;
3489 image1
= 0xffffffff;
3490 image0
= 0xffffffff;
3495 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3496 whereas the intermediate representation is 0.F x 2**exp.
3497 Which means we're off by one. */
3501 exp
= REAL_EXP (r
) + 16383 - 1;
3502 image3
|= exp
<< 16;
3504 if (HOST_BITS_PER_LONG
== 32)
3509 image3
|= u
.sig
[3] & 0xffff;
3514 image1
= image0
>> 31 >> 1;
3516 image3
|= (image2
>> 31 >> 1) & 0xffff;
3517 image0
&= 0xffffffff;
3518 image2
&= 0xffffffff;
3526 if (FLOAT_WORDS_BIG_ENDIAN
)
3543 decode_ieee_quad (const struct real_format
*fmt
, REAL_VALUE_TYPE
*r
,
3546 unsigned long image3
, image2
, image1
, image0
;
3550 if (FLOAT_WORDS_BIG_ENDIAN
)
3564 image0
&= 0xffffffff;
3565 image1
&= 0xffffffff;
3566 image2
&= 0xffffffff;
3568 sign
= (image3
>> 31) & 1;
3569 exp
= (image3
>> 16) & 0x7fff;
3572 memset (r
, 0, sizeof (*r
));
3576 if ((image3
| image2
| image1
| image0
) && fmt
->has_denorm
)
3581 SET_REAL_EXP (r
, -16382 + (SIGNIFICAND_BITS
- 112));
3582 if (HOST_BITS_PER_LONG
== 32)
3591 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3592 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3597 else if (fmt
->has_signed_zero
)
3600 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3602 if (image3
| image2
| image1
| image0
)
3606 r
->signalling
= ((image3
>> 15) & 1) ^ fmt
->qnan_msb_set
;
3608 if (HOST_BITS_PER_LONG
== 32)
3617 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3618 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3620 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3632 SET_REAL_EXP (r
, exp
- 16383 + 1);
3634 if (HOST_BITS_PER_LONG
== 32)
3643 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3644 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3646 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3647 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3651 const struct real_format ieee_quad_format
=
3669 const struct real_format mips_quad_format
=
3687 /* Descriptions of VAX floating point formats can be found beginning at
3689 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
3691 The thing to remember is that they're almost IEEE, except for word
3692 order, exponent bias, and the lack of infinities, nans, and denormals.
3694 We don't implement the H_floating format here, simply because neither
3695 the VAX or Alpha ports use it. */
3697 static void encode_vax_f (const struct real_format
*fmt
,
3698 long *, const REAL_VALUE_TYPE
*);
3699 static void decode_vax_f (const struct real_format
*,
3700 REAL_VALUE_TYPE
*, const long *);
3701 static void encode_vax_d (const struct real_format
*fmt
,
3702 long *, const REAL_VALUE_TYPE
*);
3703 static void decode_vax_d (const struct real_format
*,
3704 REAL_VALUE_TYPE
*, const long *);
3705 static void encode_vax_g (const struct real_format
*fmt
,
3706 long *, const REAL_VALUE_TYPE
*);
3707 static void decode_vax_g (const struct real_format
*,
3708 REAL_VALUE_TYPE
*, const long *);
3711 encode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3712 const REAL_VALUE_TYPE
*r
)
3714 unsigned long sign
, exp
, sig
, image
;
3716 sign
= r
->sign
<< 15;
3726 image
= 0xffff7fff | sign
;
3730 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
3731 exp
= REAL_EXP (r
) + 128;
3733 image
= (sig
<< 16) & 0xffff0000;
3747 decode_vax_f (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3748 REAL_VALUE_TYPE
*r
, const long *buf
)
3750 unsigned long image
= buf
[0] & 0xffffffff;
3751 int exp
= (image
>> 7) & 0xff;
3753 memset (r
, 0, sizeof (*r
));
3758 r
->sign
= (image
>> 15) & 1;
3759 SET_REAL_EXP (r
, exp
- 128);
3761 image
= ((image
& 0x7f) << 16) | ((image
>> 16) & 0xffff);
3762 r
->sig
[SIGSZ
-1] = (image
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
3767 encode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3768 const REAL_VALUE_TYPE
*r
)
3770 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
3775 image0
= image1
= 0;
3780 image0
= 0xffff7fff | sign
;
3781 image1
= 0xffffffff;
3785 /* Extract the significand into straight hi:lo. */
3786 if (HOST_BITS_PER_LONG
== 64)
3788 image0
= r
->sig
[SIGSZ
-1];
3789 image1
= (image0
>> (64 - 56)) & 0xffffffff;
3790 image0
= (image0
>> (64 - 56 + 1) >> 31) & 0x7fffff;
3794 image0
= r
->sig
[SIGSZ
-1];
3795 image1
= r
->sig
[SIGSZ
-2];
3796 image1
= (image0
<< 24) | (image1
>> 8);
3797 image0
= (image0
>> 8) & 0xffffff;
3800 /* Rearrange the half-words of the significand to match the
3802 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff007f;
3803 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
3805 /* Add the sign and exponent. */
3807 image0
|= (REAL_EXP (r
) + 128) << 7;
3814 if (FLOAT_WORDS_BIG_ENDIAN
)
3815 buf
[0] = image1
, buf
[1] = image0
;
3817 buf
[0] = image0
, buf
[1] = image1
;
3821 decode_vax_d (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3822 REAL_VALUE_TYPE
*r
, const long *buf
)
3824 unsigned long image0
, image1
;
3827 if (FLOAT_WORDS_BIG_ENDIAN
)
3828 image1
= buf
[0], image0
= buf
[1];
3830 image0
= buf
[0], image1
= buf
[1];
3831 image0
&= 0xffffffff;
3832 image1
&= 0xffffffff;
3834 exp
= (image0
>> 7) & 0xff;
3836 memset (r
, 0, sizeof (*r
));
3841 r
->sign
= (image0
>> 15) & 1;
3842 SET_REAL_EXP (r
, exp
- 128);
3844 /* Rearrange the half-words of the external format into
3845 proper ascending order. */
3846 image0
= ((image0
& 0x7f) << 16) | ((image0
>> 16) & 0xffff);
3847 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
3849 if (HOST_BITS_PER_LONG
== 64)
3851 image0
= (image0
<< 31 << 1) | image1
;
3854 r
->sig
[SIGSZ
-1] = image0
;
3858 r
->sig
[SIGSZ
-1] = image0
;
3859 r
->sig
[SIGSZ
-2] = image1
;
3860 lshift_significand (r
, r
, 2*HOST_BITS_PER_LONG
- 56);
3861 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3867 encode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
3868 const REAL_VALUE_TYPE
*r
)
3870 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
3875 image0
= image1
= 0;
3880 image0
= 0xffff7fff | sign
;
3881 image1
= 0xffffffff;
3885 /* Extract the significand into straight hi:lo. */
3886 if (HOST_BITS_PER_LONG
== 64)
3888 image0
= r
->sig
[SIGSZ
-1];
3889 image1
= (image0
>> (64 - 53)) & 0xffffffff;
3890 image0
= (image0
>> (64 - 53 + 1) >> 31) & 0xfffff;
3894 image0
= r
->sig
[SIGSZ
-1];
3895 image1
= r
->sig
[SIGSZ
-2];
3896 image1
= (image0
<< 21) | (image1
>> 11);
3897 image0
= (image0
>> 11) & 0xfffff;
3900 /* Rearrange the half-words of the significand to match the
3902 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff000f;
3903 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
3905 /* Add the sign and exponent. */
3907 image0
|= (REAL_EXP (r
) + 1024) << 4;
3914 if (FLOAT_WORDS_BIG_ENDIAN
)
3915 buf
[0] = image1
, buf
[1] = image0
;
3917 buf
[0] = image0
, buf
[1] = image1
;
3921 decode_vax_g (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
3922 REAL_VALUE_TYPE
*r
, const long *buf
)
3924 unsigned long image0
, image1
;
3927 if (FLOAT_WORDS_BIG_ENDIAN
)
3928 image1
= buf
[0], image0
= buf
[1];
3930 image0
= buf
[0], image1
= buf
[1];
3931 image0
&= 0xffffffff;
3932 image1
&= 0xffffffff;
3934 exp
= (image0
>> 4) & 0x7ff;
3936 memset (r
, 0, sizeof (*r
));
3941 r
->sign
= (image0
>> 15) & 1;
3942 SET_REAL_EXP (r
, exp
- 1024);
3944 /* Rearrange the half-words of the external format into
3945 proper ascending order. */
3946 image0
= ((image0
& 0xf) << 16) | ((image0
>> 16) & 0xffff);
3947 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
3949 if (HOST_BITS_PER_LONG
== 64)
3951 image0
= (image0
<< 31 << 1) | image1
;
3954 r
->sig
[SIGSZ
-1] = image0
;
3958 r
->sig
[SIGSZ
-1] = image0
;
3959 r
->sig
[SIGSZ
-2] = image1
;
3960 lshift_significand (r
, r
, 64 - 53);
3961 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3966 const struct real_format vax_f_format
=
3984 const struct real_format vax_d_format
=
4002 const struct real_format vax_g_format
=
4020 /* A good reference for these can be found in chapter 9 of
4021 "ESA/390 Principles of Operation", IBM document number SA22-7201-01.
4022 An on-line version can be found here:
4024 http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/DZ9AR001/9.1?DT=19930923083613
4027 static void encode_i370_single (const struct real_format
*fmt
,
4028 long *, const REAL_VALUE_TYPE
*);
4029 static void decode_i370_single (const struct real_format
*,
4030 REAL_VALUE_TYPE
*, const long *);
4031 static void encode_i370_double (const struct real_format
*fmt
,
4032 long *, const REAL_VALUE_TYPE
*);
4033 static void decode_i370_double (const struct real_format
*,
4034 REAL_VALUE_TYPE
*, const long *);
4037 encode_i370_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4038 long *buf
, const REAL_VALUE_TYPE
*r
)
4040 unsigned long sign
, exp
, sig
, image
;
4042 sign
= r
->sign
<< 31;
4052 image
= 0x7fffffff | sign
;
4056 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0xffffff;
4057 exp
= ((REAL_EXP (r
) / 4) + 64) << 24;
4058 image
= sign
| exp
| sig
;
4069 decode_i370_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4070 REAL_VALUE_TYPE
*r
, const long *buf
)
4072 unsigned long sign
, sig
, image
= buf
[0];
4075 sign
= (image
>> 31) & 1;
4076 exp
= (image
>> 24) & 0x7f;
4077 sig
= image
& 0xffffff;
4079 memset (r
, 0, sizeof (*r
));
4085 SET_REAL_EXP (r
, (exp
- 64) * 4);
4086 r
->sig
[SIGSZ
-1] = sig
<< (HOST_BITS_PER_LONG
- 24);
4092 encode_i370_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4093 long *buf
, const REAL_VALUE_TYPE
*r
)
4095 unsigned long sign
, exp
, image_hi
, image_lo
;
4097 sign
= r
->sign
<< 31;
4102 image_hi
= image_lo
= 0;
4107 image_hi
= 0x7fffffff | sign
;
4108 image_lo
= 0xffffffff;
4112 if (HOST_BITS_PER_LONG
== 64)
4114 image_hi
= r
->sig
[SIGSZ
-1];
4115 image_lo
= (image_hi
>> (64 - 56)) & 0xffffffff;
4116 image_hi
= (image_hi
>> (64 - 56 + 1) >> 31) & 0xffffff;
4120 image_hi
= r
->sig
[SIGSZ
-1];
4121 image_lo
= r
->sig
[SIGSZ
-2];
4122 image_lo
= (image_lo
>> 8) | (image_hi
<< 24);
4126 exp
= ((REAL_EXP (r
) / 4) + 64) << 24;
4127 image_hi
|= sign
| exp
;
4134 if (FLOAT_WORDS_BIG_ENDIAN
)
4135 buf
[0] = image_hi
, buf
[1] = image_lo
;
4137 buf
[0] = image_lo
, buf
[1] = image_hi
;
4141 decode_i370_double (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4142 REAL_VALUE_TYPE
*r
, const long *buf
)
4144 unsigned long sign
, image_hi
, image_lo
;
4147 if (FLOAT_WORDS_BIG_ENDIAN
)
4148 image_hi
= buf
[0], image_lo
= buf
[1];
4150 image_lo
= buf
[0], image_hi
= buf
[1];
4152 sign
= (image_hi
>> 31) & 1;
4153 exp
= (image_hi
>> 24) & 0x7f;
4154 image_hi
&= 0xffffff;
4155 image_lo
&= 0xffffffff;
4157 memset (r
, 0, sizeof (*r
));
4159 if (exp
|| image_hi
|| image_lo
)
4163 SET_REAL_EXP (r
, (exp
- 64) * 4 + (SIGNIFICAND_BITS
- 56));
4165 if (HOST_BITS_PER_LONG
== 32)
4167 r
->sig
[0] = image_lo
;
4168 r
->sig
[1] = image_hi
;
4171 r
->sig
[0] = image_lo
| (image_hi
<< 31 << 1);
4177 const struct real_format i370_single_format
=
4190 false, /* ??? The encoding does allow for "unnormals". */
4191 false, /* ??? The encoding does allow for "unnormals". */
4195 const struct real_format i370_double_format
=
4208 false, /* ??? The encoding does allow for "unnormals". */
4209 false, /* ??? The encoding does allow for "unnormals". */
4213 /* The "twos-complement" c4x format is officially defined as
4217 This is rather misleading. One must remember that F is signed.
4218 A better description would be
4220 x = -1**s * ((s + 1 + .f) * 2**e
4222 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
4223 that's -1 * (1+1+(-.5)) == -1.5. I think.
4225 The constructions here are taken from Tables 5-1 and 5-2 of the
4226 TMS320C4x User's Guide wherein step-by-step instructions for
4227 conversion from IEEE are presented. That's close enough to our
4228 internal representation so as to make things easy.
4230 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
4232 static void encode_c4x_single (const struct real_format
*fmt
,
4233 long *, const REAL_VALUE_TYPE
*);
4234 static void decode_c4x_single (const struct real_format
*,
4235 REAL_VALUE_TYPE
*, const long *);
4236 static void encode_c4x_extended (const struct real_format
*fmt
,
4237 long *, const REAL_VALUE_TYPE
*);
4238 static void decode_c4x_extended (const struct real_format
*,
4239 REAL_VALUE_TYPE
*, const long *);
4242 encode_c4x_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4243 long *buf
, const REAL_VALUE_TYPE
*r
)
4245 unsigned long image
, exp
, sig
;
4257 sig
= 0x800000 - r
->sign
;
4261 exp
= REAL_EXP (r
) - 1;
4262 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
4277 image
= ((exp
& 0xff) << 24) | (sig
& 0xffffff);
4282 decode_c4x_single (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4283 REAL_VALUE_TYPE
*r
, const long *buf
)
4285 unsigned long image
= buf
[0];
4289 exp
= (((image
>> 24) & 0xff) ^ 0x80) - 0x80;
4290 sf
= ((image
& 0xffffff) ^ 0x800000) - 0x800000;
4292 memset (r
, 0, sizeof (*r
));
4298 sig
= sf
& 0x7fffff;
4307 sig
= (sig
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
4309 SET_REAL_EXP (r
, exp
+ 1);
4310 r
->sig
[SIGSZ
-1] = sig
;
4315 encode_c4x_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4316 long *buf
, const REAL_VALUE_TYPE
*r
)
4318 unsigned long exp
, sig
;
4330 sig
= 0x80000000 - r
->sign
;
4334 exp
= REAL_EXP (r
) - 1;
4336 sig
= r
->sig
[SIGSZ
-1];
4337 if (HOST_BITS_PER_LONG
== 64)
4338 sig
= sig
>> 1 >> 31;
4355 exp
= (exp
& 0xff) << 24;
4358 if (FLOAT_WORDS_BIG_ENDIAN
)
4359 buf
[0] = exp
, buf
[1] = sig
;
4361 buf
[0] = sig
, buf
[0] = exp
;
4365 decode_c4x_extended (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4366 REAL_VALUE_TYPE
*r
, const long *buf
)
4371 if (FLOAT_WORDS_BIG_ENDIAN
)
4372 exp
= buf
[0], sf
= buf
[1];
4374 sf
= buf
[0], exp
= buf
[1];
4376 exp
= (((exp
>> 24) & 0xff) & 0x80) - 0x80;
4377 sf
= ((sf
& 0xffffffff) ^ 0x80000000) - 0x80000000;
4379 memset (r
, 0, sizeof (*r
));
4385 sig
= sf
& 0x7fffffff;
4394 if (HOST_BITS_PER_LONG
== 64)
4395 sig
= sig
<< 1 << 31;
4398 SET_REAL_EXP (r
, exp
+ 1);
4399 r
->sig
[SIGSZ
-1] = sig
;
4403 const struct real_format c4x_single_format
=
4421 const struct real_format c4x_extended_format
=
4423 encode_c4x_extended
,
4424 decode_c4x_extended
,
4440 /* A synthetic "format" for internal arithmetic. It's the size of the
4441 internal significand minus the two bits needed for proper rounding.
4442 The encode and decode routines exist only to satisfy our paranoia
4445 static void encode_internal (const struct real_format
*fmt
,
4446 long *, const REAL_VALUE_TYPE
*);
4447 static void decode_internal (const struct real_format
*,
4448 REAL_VALUE_TYPE
*, const long *);
4451 encode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
, long *buf
,
4452 const REAL_VALUE_TYPE
*r
)
4454 memcpy (buf
, r
, sizeof (*r
));
4458 decode_internal (const struct real_format
*fmt ATTRIBUTE_UNUSED
,
4459 REAL_VALUE_TYPE
*r
, const long *buf
)
4461 memcpy (r
, buf
, sizeof (*r
));
4464 const struct real_format real_internal_format
=
4470 SIGNIFICAND_BITS
- 2,
4471 SIGNIFICAND_BITS
- 2,
4482 /* Calculate the square root of X in mode MODE, and store the result
4483 in R. Return TRUE if the operation does not raise an exception.
4484 For details see "High Precision Division and Square Root",
4485 Alan H. Karp and Peter Markstein, HP Lab Report 93-93-42, June
4486 1993. http://www.hpl.hp.com/techreports/93/HPL-93-42.pdf. */
4489 real_sqrt (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4490 const REAL_VALUE_TYPE
*x
)
4492 static REAL_VALUE_TYPE halfthree
;
4493 static bool init
= false;
4494 REAL_VALUE_TYPE h
, t
, i
;
4497 /* sqrt(-0.0) is -0.0. */
4498 if (real_isnegzero (x
))
4504 /* Negative arguments return NaN. */
4507 get_canonical_qnan (r
, 0);
4511 /* Infinity and NaN return themselves. */
4512 if (real_isinf (x
) || real_isnan (x
))
4520 do_add (&halfthree
, &dconst1
, &dconsthalf
, 0);
4524 /* Initial guess for reciprocal sqrt, i. */
4525 exp
= real_exponent (x
);
4526 real_ldexp (&i
, &dconst1
, -exp
/2);
4528 /* Newton's iteration for reciprocal sqrt, i. */
4529 for (iter
= 0; iter
< 16; iter
++)
4531 /* i(n+1) = i(n) * (1.5 - 0.5*i(n)*i(n)*x). */
4532 do_multiply (&t
, x
, &i
);
4533 do_multiply (&h
, &t
, &i
);
4534 do_multiply (&t
, &h
, &dconsthalf
);
4535 do_add (&h
, &halfthree
, &t
, 1);
4536 do_multiply (&t
, &i
, &h
);
4538 /* Check for early convergence. */
4539 if (iter
>= 6 && real_identical (&i
, &t
))
4542 /* ??? Unroll loop to avoid copying. */
4546 /* Final iteration: r = i*x + 0.5*i*x*(1.0 - i*(i*x)). */
4547 do_multiply (&t
, x
, &i
);
4548 do_multiply (&h
, &t
, &i
);
4549 do_add (&i
, &dconst1
, &h
, 1);
4550 do_multiply (&h
, &t
, &i
);
4551 do_multiply (&i
, &dconsthalf
, &h
);
4552 do_add (&h
, &t
, &i
, 0);
4554 /* ??? We need a Tuckerman test to get the last bit. */
4556 real_convert (r
, mode
, &h
);
4560 /* Calculate X raised to the integer exponent N in mode MODE and store
4561 the result in R. Return true if the result may be inexact due to
4562 loss of precision. The algorithm is the classic "left-to-right binary
4563 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
4564 Algorithms", "The Art of Computer Programming", Volume 2. */
4567 real_powi (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4568 const REAL_VALUE_TYPE
*x
, HOST_WIDE_INT n
)
4570 unsigned HOST_WIDE_INT bit
;
4572 bool inexact
= false;
4584 /* Don't worry about overflow, from now on n is unsigned. */
4592 bit
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
4593 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
; i
++)
4597 inexact
|= do_multiply (&t
, &t
, &t
);
4599 inexact
|= do_multiply (&t
, &t
, x
);
4607 inexact
|= do_divide (&t
, &dconst1
, &t
);
4609 real_convert (r
, mode
, &t
);
4613 /* Round X to the nearest integer not larger in absolute value, i.e.
4614 towards zero, placing the result in R in mode MODE. */
4617 real_trunc (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4618 const REAL_VALUE_TYPE
*x
)
4620 do_fix_trunc (r
, x
);
4621 if (mode
!= VOIDmode
)
4622 real_convert (r
, mode
, r
);
4625 /* Round X to the largest integer not greater in value, i.e. round
4626 down, placing the result in R in mode MODE. */
4629 real_floor (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4630 const REAL_VALUE_TYPE
*x
)
4634 do_fix_trunc (&t
, x
);
4635 if (! real_identical (&t
, x
) && x
->sign
)
4636 do_add (&t
, &t
, &dconstm1
, 0);
4637 if (mode
!= VOIDmode
)
4638 real_convert (r
, mode
, &t
);
4643 /* Round X to the smallest integer not less then argument, i.e. round
4644 up, placing the result in R in mode MODE. */
4647 real_ceil (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4648 const REAL_VALUE_TYPE
*x
)
4652 do_fix_trunc (&t
, x
);
4653 if (! real_identical (&t
, x
) && ! x
->sign
)
4654 do_add (&t
, &t
, &dconst1
, 0);
4655 if (mode
!= VOIDmode
)
4656 real_convert (r
, mode
, &t
);
4661 /* Round X to the nearest integer, but round halfway cases away from
4665 real_round (REAL_VALUE_TYPE
*r
, enum machine_mode mode
,
4666 const REAL_VALUE_TYPE
*x
)
4668 do_add (r
, x
, &dconsthalf
, x
->sign
);
4669 do_fix_trunc (r
, r
);
4670 if (mode
!= VOIDmode
)
4671 real_convert (r
, mode
, r
);
4674 /* Set the sign of R to the sign of X. */
4677 real_copysign (REAL_VALUE_TYPE
*r
, const REAL_VALUE_TYPE
*x
)