1 /* real.c - software floating point emulation.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2002 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
31 /* The floating point model used internally is not exactly IEEE 754
32 compliant, and close to the description in the ISO C standard,
33 section 5.2.4.2.2 Characteristics of floating types.
37 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
41 b = base or radix, here always 2
43 p = precision (the number of base-b digits in the significand)
44 f_k = the digits of the significand.
46 We differ from typical IEEE 754 encodings in that the entire
47 significand is fractional. Normalized significands are in the
50 A requirement of the model is that P be larger than than the
51 largest supported target floating-point type by at least 2 bits.
52 This gives us proper rounding when we truncate to the target type.
53 In addition, E must be large enough to hold the smallest supported
54 denormal number in a normalized form.
56 Both of these requirements are easily satisfied. The largest
57 target significand is 113 bits; we store 128. The smallest
58 denormal number fits in 17 exponent bits; we store 29.
60 Target floating point models that use base 16 instead of base 2
61 (i.e. IBM 370), are handled during round_for_format, in which we
62 canonicalize the exponent to be a multiple of 4 (log2(16)), and
63 adjust the significand to match. */
66 /* Used to classify two numbers simultaneously. */
67 #define CLASS2(A, B) ((A) << 2 | (B))
69 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
70 #error "Some constant folding done by hand to avoid shift count warnings"
73 static void get_zero
PARAMS ((REAL_VALUE_TYPE
*, int));
74 static void get_canonical_qnan
PARAMS ((REAL_VALUE_TYPE
*, int));
75 static void get_canonical_snan
PARAMS ((REAL_VALUE_TYPE
*, int));
76 static void get_inf
PARAMS ((REAL_VALUE_TYPE
*, int));
77 static void sticky_rshift_significand
PARAMS ((REAL_VALUE_TYPE
*,
78 const REAL_VALUE_TYPE
*,
80 static void rshift_significand
PARAMS ((REAL_VALUE_TYPE
*,
81 const REAL_VALUE_TYPE
*,
83 static void lshift_significand
PARAMS ((REAL_VALUE_TYPE
*,
84 const REAL_VALUE_TYPE
*,
86 static void lshift_significand_1
PARAMS ((REAL_VALUE_TYPE
*,
87 const REAL_VALUE_TYPE
*));
88 static bool add_significands
PARAMS ((REAL_VALUE_TYPE
*r
,
89 const REAL_VALUE_TYPE
*,
90 const REAL_VALUE_TYPE
*));
91 static bool sub_significands
PARAMS ((REAL_VALUE_TYPE
*,
92 const REAL_VALUE_TYPE
*,
93 const REAL_VALUE_TYPE
*));
94 static void neg_significand
PARAMS ((REAL_VALUE_TYPE
*,
95 const REAL_VALUE_TYPE
*));
96 static int cmp_significands
PARAMS ((const REAL_VALUE_TYPE
*,
97 const REAL_VALUE_TYPE
*));
98 static void set_significand_bit
PARAMS ((REAL_VALUE_TYPE
*, unsigned int));
99 static void clear_significand_bit
PARAMS ((REAL_VALUE_TYPE
*, unsigned int));
100 static bool test_significand_bit
PARAMS ((REAL_VALUE_TYPE
*, unsigned int));
101 static void clear_significand_below
PARAMS ((REAL_VALUE_TYPE
*,
103 static bool div_significands
PARAMS ((REAL_VALUE_TYPE
*,
104 const REAL_VALUE_TYPE
*,
105 const REAL_VALUE_TYPE
*));
106 static void normalize
PARAMS ((REAL_VALUE_TYPE
*));
108 static void do_add
PARAMS ((REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
109 const REAL_VALUE_TYPE
*, int));
110 static void do_multiply
PARAMS ((REAL_VALUE_TYPE
*,
111 const REAL_VALUE_TYPE
*,
112 const REAL_VALUE_TYPE
*));
113 static void do_divide
PARAMS ((REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*,
114 const REAL_VALUE_TYPE
*));
115 static int do_compare
PARAMS ((const REAL_VALUE_TYPE
*,
116 const REAL_VALUE_TYPE
*, int));
117 static void do_fix_trunc
PARAMS ((REAL_VALUE_TYPE
*,
118 const REAL_VALUE_TYPE
*));
120 static const REAL_VALUE_TYPE
* ten_to_ptwo
PARAMS ((int));
121 static const REAL_VALUE_TYPE
* real_digit
PARAMS ((int));
123 static void round_for_format
PARAMS ((const struct real_format
*,
126 /* Initialize R with a positive zero. */
133 memset (r
, 0, sizeof (*r
));
137 /* Initialize R with the canonical quiet NaN. */
140 get_canonical_qnan (r
, sign
)
144 memset (r
, 0, sizeof (*r
));
147 r
->sig
[SIGSZ
-1] = SIG_MSB
>> 1;
151 get_canonical_snan (r
, sign
)
155 memset (r
, 0, sizeof (*r
));
158 r
->sig
[SIGSZ
-1] = SIG_MSB
>> 2;
166 memset (r
, 0, sizeof (*r
));
172 /* Right-shift the significand of A by N bits; put the result in the
173 significand of R. If any one bits are shifted out, set the least
174 significant bit of R. */
177 sticky_rshift_significand (r
, a
, n
)
179 const REAL_VALUE_TYPE
*a
;
182 unsigned long sticky
= 0;
183 unsigned int i
, ofs
= 0;
185 if (n
>= HOST_BITS_PER_LONG
)
187 for (i
= 0, ofs
= n
/ HOST_BITS_PER_LONG
; i
< ofs
; ++i
)
189 n
-= ofs
* HOST_BITS_PER_LONG
;
194 sticky
|= a
->sig
[ofs
] & (((unsigned long)1 << n
) - 1);
195 for (i
= 0; i
< SIGSZ
; ++i
)
198 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
199 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
200 << (HOST_BITS_PER_LONG
- n
)));
205 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
206 r
->sig
[i
] = a
->sig
[ofs
+ i
];
207 for (; i
< SIGSZ
; ++i
)
211 r
->sig
[0] |= (sticky
!= 0);
214 /* Right-shift the significand of A by N bits; put the result in the
218 rshift_significand (r
, a
, n
)
220 const REAL_VALUE_TYPE
*a
;
223 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
225 n
-= ofs
* HOST_BITS_PER_LONG
;
228 for (i
= 0; i
< SIGSZ
; ++i
)
231 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[ofs
+ i
]) >> n
)
232 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[ofs
+ i
+ 1])
233 << (HOST_BITS_PER_LONG
- n
)));
238 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
239 r
->sig
[i
] = a
->sig
[ofs
+ i
];
240 for (; i
< SIGSZ
; ++i
)
245 /* Left-shift the significand of A by N bits; put the result in the
249 lshift_significand (r
, a
, n
)
251 const REAL_VALUE_TYPE
*a
;
254 unsigned int i
, ofs
= n
/ HOST_BITS_PER_LONG
;
256 n
-= ofs
* HOST_BITS_PER_LONG
;
259 for (i
= 0; ofs
+ i
< SIGSZ
; ++i
)
260 r
->sig
[SIGSZ
-1-i
] = a
->sig
[SIGSZ
-1-i
-ofs
];
261 for (; i
< SIGSZ
; ++i
)
262 r
->sig
[SIGSZ
-1-i
] = 0;
265 for (i
= 0; i
< SIGSZ
; ++i
)
268 = (((ofs
+ i
>= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
]) << n
)
269 | ((ofs
+ i
+ 1 >= SIGSZ
? 0 : a
->sig
[SIGSZ
-1-i
-ofs
-1])
270 >> (HOST_BITS_PER_LONG
- n
)));
274 /* Likewise, but N is specialized to 1. */
277 lshift_significand_1 (r
, a
)
279 const REAL_VALUE_TYPE
*a
;
283 for (i
= SIGSZ
- 1; i
> 0; --i
)
284 r
->sig
[i
] = (a
->sig
[i
] << 1) | (a
->sig
[i
-1] >> (HOST_BITS_PER_LONG
- 1));
285 r
->sig
[0] = a
->sig
[0] << 1;
288 /* Add the significands of A and B, placing the result in R. Return
289 true if there was carry out of the most significant word. */
292 add_significands (r
, a
, b
)
294 const REAL_VALUE_TYPE
*a
, *b
;
299 for (i
= 0; i
< SIGSZ
; ++i
)
301 unsigned long ai
= a
->sig
[i
];
302 unsigned long ri
= ai
+ b
->sig
[i
];
318 /* Subtract the significands of A and B, placing the result in R.
319 Return true if there was carry out of the most significant word. */
322 sub_significands (r
, a
, b
)
324 const REAL_VALUE_TYPE
*a
, *b
;
329 for (i
= 0; i
< SIGSZ
; ++i
)
331 unsigned long ai
= a
->sig
[i
];
332 unsigned long ri
= ai
- b
->sig
[i
];
348 /* Negate the significand A, placing the result in R. */
351 neg_significand (r
, a
)
353 const REAL_VALUE_TYPE
*a
;
358 for (i
= 0; i
< SIGSZ
; ++i
)
360 unsigned long ri
, ai
= a
->sig
[i
];
379 /* Compare significands. Return tri-state vs zero. */
382 cmp_significands (a
, b
)
383 const REAL_VALUE_TYPE
*a
, *b
;
387 for (i
= SIGSZ
- 1; i
>= 0; --i
)
389 unsigned long ai
= a
->sig
[i
];
390 unsigned long bi
= b
->sig
[i
];
401 /* Set bit N of the significand of R. */
404 set_significand_bit (r
, n
)
408 r
->sig
[n
/ HOST_BITS_PER_LONG
]
409 |= (unsigned long)1 << (n
% HOST_BITS_PER_LONG
);
412 /* Clear bit N of the significand of R. */
415 clear_significand_bit (r
, n
)
419 r
->sig
[n
/ HOST_BITS_PER_LONG
]
420 &= ~((unsigned long)1 << (n
% HOST_BITS_PER_LONG
));
423 /* Test bit N of the significand of R. */
426 test_significand_bit (r
, n
)
430 /* ??? Compiler bug here if we return this expression directly.
431 The conversion to bool strips the "&1" and we wind up testing
432 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
433 int t
= (r
->sig
[n
/ HOST_BITS_PER_LONG
] >> (n
% HOST_BITS_PER_LONG
)) & 1;
437 /* Clear bits 0..N-1 of the significand of R. */
440 clear_significand_below (r
, n
)
444 int i
, w
= n
/ HOST_BITS_PER_LONG
;
446 for (i
= 0; i
< w
; ++i
)
449 r
->sig
[w
] &= ~(((unsigned long)1 << (n
% HOST_BITS_PER_LONG
)) - 1);
452 /* Divide the significands of A and B, placing the result in R. Return
453 true if the division was inexact. */
456 div_significands (r
, a
, b
)
458 const REAL_VALUE_TYPE
*a
, *b
;
461 int bit
= SIGNIFICAND_BITS
- 1;
466 memset (r
->sig
, 0, sizeof (r
->sig
));
471 if ((u
.sig
[SIGSZ
-1] & SIG_MSB
) == 0)
473 lshift_significand_1 (&u
, &u
);
475 if (cmp_significands (&u
, b
) >= 0)
477 sub_significands (&u
, &u
, b
);
478 set_significand_bit (r
, bit
);
483 /* We lose a bit here, and thus know the next quotient bit
485 lshift_significand_1 (&u
, &u
);
486 sub_significands (&u
, &u
, b
);
487 set_significand_bit (r
, bit
);
492 for (i
= 0, inexact
= 0; i
< SIGSZ
; i
++)
498 /* Adjust the exponent and significand of R such that the most
499 significant bit is set. We underflow to zero and overflow to
500 infinity here, without denormals. (The intermediate representation
501 exponent is large enough to handle target denormals normalized.) */
510 /* Find the first word that is nonzero. */
511 for (i
= SIGSZ
- 1; i
>= 0; i
--)
513 shift
+= HOST_BITS_PER_LONG
;
517 /* Zero significand flushes to zero. */
525 /* Find the first bit that is nonzero. */
527 if (r
->sig
[i
] & ((unsigned long)1 << (HOST_BITS_PER_LONG
- 1 - j
)))
533 exp
= r
->exp
- shift
;
535 get_inf (r
, r
->sign
);
536 else if (exp
< -MAX_EXP
)
537 get_zero (r
, r
->sign
);
541 lshift_significand (r
, r
, shift
);
546 /* Return R = A + (SUBTRACT_P ? -B : B). */
549 do_add (r
, a
, b
, subtract_p
)
551 const REAL_VALUE_TYPE
*a
, *b
;
557 /* Determine if we need to add or subtract. */
559 subtract_p
= (sign
^ b
->sign
) ^ subtract_p
;
561 switch (CLASS2 (a
->class, b
->class))
563 case CLASS2 (rvc_zero
, rvc_zero
):
564 /* +-0 +/- +-0 = +0. */
568 case CLASS2 (rvc_zero
, rvc_normal
):
569 case CLASS2 (rvc_zero
, rvc_inf
):
570 case CLASS2 (rvc_zero
, rvc_nan
):
572 case CLASS2 (rvc_normal
, rvc_nan
):
573 case CLASS2 (rvc_inf
, rvc_nan
):
574 case CLASS2 (rvc_nan
, rvc_nan
):
575 /* ANY + NaN = NaN. */
576 case CLASS2 (rvc_normal
, rvc_inf
):
579 r
->sign
= sign
^ subtract_p
;
582 case CLASS2 (rvc_normal
, rvc_zero
):
583 case CLASS2 (rvc_inf
, rvc_zero
):
584 case CLASS2 (rvc_nan
, rvc_zero
):
586 case CLASS2 (rvc_nan
, rvc_normal
):
587 case CLASS2 (rvc_nan
, rvc_inf
):
588 /* NaN + ANY = NaN. */
589 case CLASS2 (rvc_inf
, rvc_normal
):
594 case CLASS2 (rvc_inf
, rvc_inf
):
596 /* Inf - Inf = NaN. */
597 get_canonical_qnan (r
, 0);
599 /* Inf + Inf = Inf. */
603 case CLASS2 (rvc_normal
, rvc_normal
):
610 /* Swap the arguments such that A has the larger exponent. */
611 dexp
= a
->exp
- b
->exp
;
614 const REAL_VALUE_TYPE
*t
;
621 /* If the exponents are not identical, we need to shift the
622 significand of B down. */
625 /* If the exponents are too far apart, the significands
626 do not overlap, which makes the subtraction a noop. */
627 if (dexp
>= SIGNIFICAND_BITS
)
634 sticky_rshift_significand (&t
, b
, dexp
);
640 if (sub_significands (r
, a
, b
))
642 /* We got a borrow out of the subtraction. That means that
643 A and B had the same exponent, and B had the larger
644 significand. We need to swap the sign and negate the
647 neg_significand (r
, r
);
652 if (add_significands (r
, a
, b
))
654 /* We got carry out of the addition. This means we need to
655 shift the significand back down one bit and increase the
657 sticky_rshift_significand (r
, r
, 1);
658 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
667 r
->class = rvc_normal
;
671 /* Re-normalize the result. */
674 /* Special case: if the subtraction results in zero, the result
676 if (r
->class == rvc_zero
)
680 /* Return R = A * B. */
683 do_multiply (r
, a
, b
)
685 const REAL_VALUE_TYPE
*a
, *b
;
687 REAL_VALUE_TYPE u
, t
, *rr
;
688 unsigned int i
, j
, k
;
689 int sign
= a
->sign
^ b
->sign
;
691 switch (CLASS2 (a
->class, b
->class))
693 case CLASS2 (rvc_zero
, rvc_zero
):
694 case CLASS2 (rvc_zero
, rvc_normal
):
695 case CLASS2 (rvc_normal
, rvc_zero
):
696 /* +-0 * ANY = 0 with appropriate sign. */
700 case CLASS2 (rvc_zero
, rvc_nan
):
701 case CLASS2 (rvc_normal
, rvc_nan
):
702 case CLASS2 (rvc_inf
, rvc_nan
):
703 case CLASS2 (rvc_nan
, rvc_nan
):
704 /* ANY * NaN = NaN. */
709 case CLASS2 (rvc_nan
, rvc_zero
):
710 case CLASS2 (rvc_nan
, rvc_normal
):
711 case CLASS2 (rvc_nan
, rvc_inf
):
712 /* NaN * ANY = NaN. */
717 case CLASS2 (rvc_zero
, rvc_inf
):
718 case CLASS2 (rvc_inf
, rvc_zero
):
720 get_canonical_qnan (r
, sign
);
723 case CLASS2 (rvc_inf
, rvc_inf
):
724 case CLASS2 (rvc_normal
, rvc_inf
):
725 case CLASS2 (rvc_inf
, rvc_normal
):
726 /* Inf * Inf = Inf, R * Inf = Inf */
731 case CLASS2 (rvc_normal
, rvc_normal
):
738 if (r
== a
|| r
== b
)
744 /* Collect all the partial products. Since we don't have sure access
745 to a widening multiply, we split each long into two half-words.
747 Consider the long-hand form of a four half-word multiplication:
757 We construct partial products of the widened half-word products
758 that are known to not overlap, e.g. DF+DH. Each such partial
759 product is given its proper exponent, which allows us to sum them
760 and obtain the finished product. */
762 for (i
= 0; i
< SIGSZ
* 2; ++i
)
764 unsigned long ai
= a
->sig
[i
/ 2];
766 ai
>>= HOST_BITS_PER_LONG
/ 2;
768 ai
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
773 for (j
= 0; j
< 2; ++j
)
775 int exp
= (a
->exp
- (2*SIGSZ
-1-i
)*(HOST_BITS_PER_LONG
/2)
776 + (b
->exp
- (1-j
)*(HOST_BITS_PER_LONG
/2)));
781 /* Would underflow to zero, which we shouldn't bother adding. */
784 u
.class = rvc_normal
;
788 for (k
= j
; k
< SIGSZ
* 2; k
+= 2)
790 unsigned long bi
= b
->sig
[k
/ 2];
792 bi
>>= HOST_BITS_PER_LONG
/ 2;
794 bi
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
796 u
.sig
[k
/ 2] = ai
* bi
;
800 do_add (rr
, rr
, &u
, 0);
809 /* Return R = A / B. */
814 const REAL_VALUE_TYPE
*a
, *b
;
816 int exp
, sign
= a
->sign
^ b
->sign
;
817 REAL_VALUE_TYPE t
, *rr
;
820 switch (CLASS2 (a
->class, b
->class))
822 case CLASS2 (rvc_zero
, rvc_zero
):
824 case CLASS2 (rvc_inf
, rvc_zero
):
826 case CLASS2 (rvc_inf
, rvc_inf
):
827 /* Inf / Inf = NaN. */
828 get_canonical_qnan (r
, sign
);
831 case CLASS2 (rvc_zero
, rvc_normal
):
832 case CLASS2 (rvc_zero
, rvc_inf
):
834 case CLASS2 (rvc_normal
, rvc_inf
):
840 case CLASS2 (rvc_normal
, rvc_zero
):
845 case CLASS2 (rvc_zero
, rvc_nan
):
846 case CLASS2 (rvc_normal
, rvc_nan
):
847 case CLASS2 (rvc_inf
, rvc_nan
):
848 case CLASS2 (rvc_nan
, rvc_nan
):
849 /* ANY / NaN = NaN. */
854 case CLASS2 (rvc_nan
, rvc_zero
):
855 case CLASS2 (rvc_nan
, rvc_normal
):
856 case CLASS2 (rvc_nan
, rvc_inf
):
857 /* NaN / ANY = NaN. */
862 case CLASS2 (rvc_inf
, rvc_normal
):
868 case CLASS2 (rvc_normal
, rvc_normal
):
875 if (r
== a
|| r
== b
)
880 rr
->class = rvc_normal
;
883 exp
= a
->exp
- b
->exp
+ 1;
890 inexact
= div_significands (rr
, a
, b
);
891 rr
->sig
[0] |= inexact
;
893 /* Re-normalize the result. */
900 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
901 one of the two operands is a NaN. */
904 do_compare (a
, b
, nan_result
)
905 const REAL_VALUE_TYPE
*a
, *b
;
910 switch (CLASS2 (a
->class, b
->class))
912 case CLASS2 (rvc_zero
, rvc_zero
):
913 /* Sign of zero doesn't matter for compares. */
916 case CLASS2 (rvc_inf
, rvc_zero
):
917 case CLASS2 (rvc_inf
, rvc_normal
):
918 case CLASS2 (rvc_normal
, rvc_zero
):
919 return (a
->sign
? -1 : 1);
921 case CLASS2 (rvc_inf
, rvc_inf
):
922 return -a
->sign
- -b
->sign
;
924 case CLASS2 (rvc_zero
, rvc_normal
):
925 case CLASS2 (rvc_zero
, rvc_inf
):
926 case CLASS2 (rvc_normal
, rvc_inf
):
927 return (b
->sign
? 1 : -1);
929 case CLASS2 (rvc_zero
, rvc_nan
):
930 case CLASS2 (rvc_normal
, rvc_nan
):
931 case CLASS2 (rvc_inf
, rvc_nan
):
932 case CLASS2 (rvc_nan
, rvc_nan
):
933 case CLASS2 (rvc_nan
, rvc_zero
):
934 case CLASS2 (rvc_nan
, rvc_normal
):
935 case CLASS2 (rvc_nan
, rvc_inf
):
938 case CLASS2 (rvc_normal
, rvc_normal
):
945 if (a
->sign
!= b
->sign
)
946 return -a
->sign
- -b
->sign
;
950 else if (a
->exp
< b
->exp
)
953 ret
= cmp_significands (a
, b
);
955 return (a
->sign
? -ret
: ret
);
958 /* Return A truncated to an integral value toward zero. */
963 const REAL_VALUE_TYPE
*a
;
976 get_zero (r
, r
->sign
);
977 else if (r
->exp
< SIGNIFICAND_BITS
)
978 clear_significand_below (r
, SIGNIFICAND_BITS
- r
->exp
);
986 /* Perform the binary or unary operation described by CODE.
987 For a unary operation, leave OP1 NULL. */
990 real_arithmetic (r
, icode
, op0
, op1
)
993 const REAL_VALUE_TYPE
*op0
, *op1
;
995 enum tree_code code
= icode
;
1000 do_add (r
, op0
, op1
, 0);
1004 do_add (r
, op0
, op1
, 1);
1008 do_multiply (r
, op0
, op1
);
1012 do_divide (r
, op0
, op1
);
1016 if (op1
->class == rvc_nan
)
1018 else if (do_compare (op0
, op1
, -1) < 0)
1025 if (op1
->class == rvc_nan
)
1027 else if (do_compare (op0
, op1
, 1) < 0)
1043 case FIX_TRUNC_EXPR
:
1044 do_fix_trunc (r
, op0
);
1052 /* Legacy. Similar, but return the result directly. */
1055 real_arithmetic2 (icode
, op0
, op1
)
1057 const REAL_VALUE_TYPE
*op0
, *op1
;
1060 real_arithmetic (&r
, icode
, op0
, op1
);
1065 real_compare (icode
, op0
, op1
)
1067 const REAL_VALUE_TYPE
*op0
, *op1
;
1069 enum tree_code code
= icode
;
1074 return do_compare (op0
, op1
, 1) < 0;
1076 return do_compare (op0
, op1
, 1) <= 0;
1078 return do_compare (op0
, op1
, -1) > 0;
1080 return do_compare (op0
, op1
, -1) >= 0;
1082 return do_compare (op0
, op1
, -1) == 0;
1084 return do_compare (op0
, op1
, -1) != 0;
1085 case UNORDERED_EXPR
:
1086 return op0
->class == rvc_nan
|| op1
->class == rvc_nan
;
1088 return op0
->class != rvc_nan
&& op1
->class != rvc_nan
;
1090 return do_compare (op0
, op1
, -1) < 0;
1092 return do_compare (op0
, op1
, -1) <= 0;
1094 return do_compare (op0
, op1
, 1) > 0;
1096 return do_compare (op0
, op1
, 1) >= 0;
1098 return do_compare (op0
, op1
, 0) == 0;
1105 /* Return floor log2(R). */
1109 const REAL_VALUE_TYPE
*r
;
1117 return (unsigned int)-1 >> 1;
1125 /* R = OP0 * 2**EXP. */
1128 real_ldexp (r
, op0
, exp
)
1130 const REAL_VALUE_TYPE
*op0
;
1144 get_inf (r
, r
->sign
);
1145 else if (exp
< -MAX_EXP
)
1146 get_zero (r
, r
->sign
);
1156 /* Determine whether a floating-point value X is infinite. */
1160 const REAL_VALUE_TYPE
*r
;
1162 return (r
->class == rvc_inf
);
1165 /* Determine whether a floating-point value X is a NaN. */
1169 const REAL_VALUE_TYPE
*r
;
1171 return (r
->class == rvc_nan
);
1174 /* Determine whether a floating-point value X is negative. */
1178 const REAL_VALUE_TYPE
*r
;
1183 /* Determine whether a floating-point value X is minus zero. */
1187 const REAL_VALUE_TYPE
*r
;
1189 return r
->sign
&& r
->class == rvc_zero
;
1192 /* Compare two floating-point objects for bitwise identity. */
1195 real_identical (a
, b
)
1196 const REAL_VALUE_TYPE
*a
, *b
;
1200 if (a
->class != b
->class)
1202 if (a
->sign
!= b
->sign
)
1212 if (a
->exp
!= b
->exp
)
1216 for (i
= 0; i
< SIGSZ
; ++i
)
1217 if (a
->sig
[i
] != b
->sig
[i
])
1228 /* Try to change R into its exact multiplicative inverse in machine
1229 mode MODE. Return true if successful. */
1232 exact_real_inverse (mode
, r
)
1233 enum machine_mode mode
;
1236 const REAL_VALUE_TYPE
*one
= real_digit (1);
1240 if (r
->class != rvc_normal
)
1243 /* Check for a power of two: all significand bits zero except the MSB. */
1244 for (i
= 0; i
< SIGSZ
-1; ++i
)
1247 if (r
->sig
[SIGSZ
-1] != SIG_MSB
)
1250 /* Find the inverse and truncate to the required mode. */
1251 do_divide (&u
, one
, r
);
1252 real_convert (&u
, mode
, &u
);
1254 /* The rounding may have overflowed. */
1255 if (u
.class != rvc_normal
)
1257 for (i
= 0; i
< SIGSZ
-1; ++i
)
1260 if (u
.sig
[SIGSZ
-1] != SIG_MSB
)
1267 /* Render R as an integer. */
1271 const REAL_VALUE_TYPE
*r
;
1273 unsigned HOST_WIDE_INT i
;
1284 i
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1292 if (r
->exp
> HOST_BITS_PER_WIDE_INT
)
1295 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1296 i
= r
->sig
[SIGSZ
-1];
1297 else if (HOST_BITS_PER_WIDE_INT
== 2*HOST_BITS_PER_LONG
)
1299 i
= r
->sig
[SIGSZ
-1];
1300 i
= i
<< (HOST_BITS_PER_LONG
- 1) << 1;
1301 i
|= r
->sig
[SIGSZ
-2];
1306 i
>>= HOST_BITS_PER_WIDE_INT
- r
->exp
;
1317 /* Likewise, but to an integer pair, HI+LOW. */
1320 real_to_integer2 (plow
, phigh
, r
)
1321 HOST_WIDE_INT
*plow
, *phigh
;
1322 const REAL_VALUE_TYPE
*r
;
1325 HOST_WIDE_INT low
, high
;
1338 high
= (unsigned HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
- 1);
1352 if (exp
>= 2*HOST_BITS_PER_WIDE_INT
)
1355 rshift_significand (&t
, r
, 2*HOST_BITS_PER_WIDE_INT
- exp
);
1356 if (HOST_BITS_PER_WIDE_INT
== HOST_BITS_PER_LONG
)
1358 high
= t
.sig
[SIGSZ
-1];
1359 low
= t
.sig
[SIGSZ
-2];
1361 else if (HOST_BITS_PER_WIDE_INT
== 2*HOST_BITS_PER_LONG
)
1363 high
= t
.sig
[SIGSZ
-1];
1364 high
= high
<< (HOST_BITS_PER_LONG
- 1) << 1;
1365 high
|= t
.sig
[SIGSZ
-2];
1367 low
= t
.sig
[SIGSZ
-3];
1368 low
= low
<< (HOST_BITS_PER_LONG
- 1) << 1;
1369 low
|= t
.sig
[SIGSZ
-4];
1379 low
= -low
, high
= ~high
;
1391 /* Render R as a decimal floating point constant. Emit DIGITS
1392 significant digits in the result. If DIGITS <= 0, choose the
1393 maximum for the representation. */
1395 #define M_LOG10_2 0.30102999566398119521
1398 real_to_decimal (str
, r_orig
, digits
)
1400 const REAL_VALUE_TYPE
*r_orig
;
1404 const REAL_VALUE_TYPE
*one
, *ten
;
1405 int dec_exp
, max_digits
, d
, cmp_half
;
1406 char *p
, *first
, *last
;
1413 strcpy (str
, (r
.sign
? "-0.0" : "0.0"));
1418 strcpy (str
, (r
.sign
? "+Inf" : "-Inf"));
1421 /* ??? Print the significand as well, if not canonical? */
1422 strcpy (str
, (r
.sign
? "+NaN" : "-NaN"));
1428 max_digits
= SIGNIFICAND_BITS
* M_LOG10_2
;
1429 if (digits
<= 0 || digits
> max_digits
)
1430 digits
= max_digits
;
1432 one
= real_digit (1);
1433 ten
= ten_to_ptwo (0);
1438 /* Estimate the decimal exponent. */
1439 dec_exp
= r
.exp
* M_LOG10_2
;
1441 /* Scale the number such that it is in [1, 10). */
1445 for (i
= EXP_BITS
- 1; i
>= 0; --i
)
1446 if (dec_exp
& (1 << i
))
1447 do_divide (&r
, &r
, ten_to_ptwo (i
));
1449 else if (dec_exp
< 0)
1451 int i
, pos_exp
= -(--dec_exp
);
1453 for (i
= EXP_BITS
- 1; i
>= 0; --i
)
1454 if (pos_exp
& (1 << i
))
1455 do_multiply (&r
, &r
, ten_to_ptwo (i
));
1458 /* Assert that the number is in the proper range. Round-off can
1459 prevent the above from working exactly. */
1460 if (do_compare (&r
, one
, -1) < 0)
1462 do_multiply (&r
, &r
, ten
);
1465 else if (do_compare (&r
, ten
, 1) >= 0)
1467 do_divide (&r
, &r
, ten
);
1477 d
= real_to_integer ((const REAL_VALUE_TYPE
*) &r
);
1478 do_add (&r
, &r
, real_digit (d
), 1);
1483 do_multiply (&r
, &r
, ten
);
1487 /* Round the result. Compare R vs 0.5 by doing R*2 vs 1.0. */
1489 cmp_half
= do_compare (&r
, one
, -1);
1491 /* Round to even. */
1514 first
[0] = first
[1];
1517 sprintf (last
, "e%+d", dec_exp
);
1520 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1521 significant digits in the result. If DIGITS <= 0, choose the maximum
1522 for the representation. */
1525 real_to_hexadecimal (str
, r
, digits
)
1527 const REAL_VALUE_TYPE
*r
;
1530 int i
, j
, exp
= r
->exp
;
1541 strcpy (str
, (r
->sign
? "+Inf" : "-Inf"));
1544 /* ??? Print the significand as well, if not canonical? */
1545 strcpy (str
, (r
->sign
? "+NaN" : "-NaN"));
1552 digits
= SIGNIFICAND_BITS
/ 4;
1562 for (i
= SIGSZ
- 1; i
>= 0; --i
)
1563 for (j
= HOST_BITS_PER_LONG
- 4; j
>= 0; j
-= 4)
1565 *p
++ = "0123456789abcdef"[(r
->sig
[i
] >> j
) & 15];
1570 sprintf (p
, "p%+d", exp
);
1573 /* Initialize R from a decimal or hexadecimal string. The string is
1574 assumed to have been syntax checked already. */
1577 real_from_string (r
, str
)
1590 else if (*str
== '+')
1593 if (str
[0] == '0' && str
[1] == 'x')
1595 /* Hexadecimal floating point. */
1596 int pos
= SIGNIFICAND_BITS
- 4, d
;
1604 d
= hex_value (*str
);
1609 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1610 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1621 d
= hex_value (*str
);
1626 r
->sig
[pos
/ HOST_BITS_PER_LONG
]
1627 |= (unsigned long) d
<< (pos
% HOST_BITS_PER_LONG
);
1633 if (*str
== 'p' || *str
== 'P')
1643 else if (*str
== '+')
1647 while (ISDIGIT (*str
))
1654 /* Overflowed the exponent. */
1668 r
->class = rvc_normal
;
1682 /* Decimal floating point. */
1683 const REAL_VALUE_TYPE
*ten
= ten_to_ptwo (0);
1688 while (ISDIGIT (*str
))
1691 do_multiply (r
, r
, ten
);
1693 do_add (r
, r
, real_digit (d
), 0);
1698 while (ISDIGIT (*str
))
1701 do_multiply (r
, r
, ten
);
1703 do_add (r
, r
, real_digit (d
), 0);
1708 if (*str
== 'e' || *str
== 'E')
1718 else if (*str
== '+')
1722 while (ISDIGIT (*str
))
1729 /* Overflowed the exponent. */
1745 for (d
= 0; d
< EXP_BITS
; ++d
)
1747 do_divide (r
, r
, ten_to_ptwo (d
));
1751 for (d
= 0; d
< EXP_BITS
; ++d
)
1753 do_multiply (r
, r
, ten_to_ptwo (d
));
1760 get_zero (r
, r
->sign
);
1764 get_inf (r
, r
->sign
);
1768 /* Legacy. Similar, but return the result directly. */
1771 real_from_string2 (s
, mode
)
1773 enum machine_mode mode
;
1777 real_from_string (&r
, s
);
1778 if (mode
!= VOIDmode
)
1779 real_convert (&r
, mode
, &r
);
1784 /* Initialize R from the integer pair HIGH+LOW. */
1787 real_from_integer (r
, mode
, low
, high
, unsigned_p
)
1789 enum machine_mode mode
;
1790 unsigned HOST_WIDE_INT low
;
1794 if (low
== 0 && high
== 0)
1798 r
->class = rvc_normal
;
1799 r
->sign
= high
< 0 && !unsigned_p
;
1800 r
->exp
= 2 * HOST_BITS_PER_WIDE_INT
;
1811 if (HOST_BITS_PER_LONG
== HOST_BITS_PER_WIDE_INT
)
1813 r
->sig
[SIGSZ
-1] = high
;
1814 r
->sig
[SIGSZ
-2] = low
;
1815 memset (r
->sig
, 0, sizeof(long)*(SIGSZ
-2));
1817 else if (HOST_BITS_PER_LONG
*2 == HOST_BITS_PER_WIDE_INT
)
1819 r
->sig
[SIGSZ
-1] = high
>> (HOST_BITS_PER_LONG
- 1) >> 1;
1820 r
->sig
[SIGSZ
-2] = high
;
1821 r
->sig
[SIGSZ
-3] = low
>> (HOST_BITS_PER_LONG
- 1) >> 1;
1822 r
->sig
[SIGSZ
-4] = low
;
1824 memset (r
->sig
, 0, sizeof(long)*(SIGSZ
-4));
1832 if (mode
!= VOIDmode
)
1833 real_convert (r
, mode
, r
);
1836 /* Returns 10**2**n. */
1838 static const REAL_VALUE_TYPE
*
1842 static REAL_VALUE_TYPE tens
[EXP_BITS
];
1844 if (n
< 0 || n
>= EXP_BITS
)
1847 if (tens
[n
].class == rvc_zero
)
1849 if (n
< (HOST_BITS_PER_WIDE_INT
== 64 ? 5 : 4))
1851 HOST_WIDE_INT t
= 10;
1854 for (i
= 0; i
< n
; ++i
)
1857 real_from_integer (&tens
[n
], VOIDmode
, t
, 0, 1);
1861 const REAL_VALUE_TYPE
*t
= ten_to_ptwo (n
- 1);
1862 do_multiply (&tens
[n
], t
, t
);
1871 static const REAL_VALUE_TYPE
*
1875 static REAL_VALUE_TYPE num
[10];
1880 if (n
> 0 && num
[n
].class == rvc_zero
)
1881 real_from_integer (&num
[n
], VOIDmode
, n
, 0, 1);
1886 /* Fills R with +Inf. */
1895 /* Fills R with a NaN whose significand is described by STR. If QUIET,
1896 we force a QNaN, else we force an SNaN. The string, if not empty,
1897 is parsed as a number and placed in the significand. Return true
1898 if the string was successfully parsed. */
1901 real_nan (r
, str
, quiet
, mode
)
1905 enum machine_mode mode
;
1907 const struct real_format
*fmt
;
1909 fmt
= real_format_for_mode
[mode
- QFmode
];
1916 get_canonical_qnan (r
, 0);
1918 get_canonical_snan (r
, 0);
1925 memset (r
, 0, sizeof (*r
));
1928 /* Parse akin to strtol into the significand of R. */
1930 while (ISSPACE (*str
))
1934 else if (*str
== '+')
1944 while ((d
= hex_value (*str
)) < base
)
1951 lshift_significand (r
, r
, 3);
1954 lshift_significand (r
, r
, 4);
1957 lshift_significand_1 (&u
, r
);
1958 lshift_significand (r
, r
, 3);
1959 add_significands (r
, r
, &u
);
1967 add_significands (r
, r
, &u
);
1972 /* Must have consumed the entire string for success. */
1976 /* Shift the significand into place such that the bits
1977 are in the most significant bits for the format. */
1978 lshift_significand (r
, r
, SIGNIFICAND_BITS
- fmt
->p
);
1980 /* Our MSB is always unset for NaNs. */
1981 r
->sig
[SIGSZ
-1] &= ~SIG_MSB
;
1983 /* Force quiet or signalling NaN. */
1985 r
->sig
[SIGSZ
-1] |= SIG_MSB
>> 1;
1987 r
->sig
[SIGSZ
-1] &= ~(SIG_MSB
>> 1);
1989 /* Force at least one bit of the significand set. */
1990 for (d
= 0; d
< SIGSZ
; ++d
)
1994 r
->sig
[SIGSZ
-1] |= SIG_MSB
>> 2;
1996 /* Our intermediate format forces QNaNs to have MSB-1 set.
1997 If the target format has QNaNs with the top bit unset,
1998 mirror the output routines and invert the top two bits. */
1999 if (!fmt
->qnan_msb_set
)
2000 r
->sig
[SIGSZ
-1] ^= (SIG_MSB
>> 1) | (SIG_MSB
>> 2);
2006 /* Fills R with 2**N. */
2013 memset (r
, 0, sizeof (*r
));
2018 else if (n
< -MAX_EXP
)
2022 r
->class = rvc_normal
;
2024 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2030 round_for_format (fmt
, r
)
2031 const struct real_format
*fmt
;
2035 unsigned long sticky
;
2039 p2
= fmt
->p
* fmt
->log2_b
;
2040 emin2m1
= (fmt
->emin
- 1) * fmt
->log2_b
;
2041 emax2
= fmt
->emax
* fmt
->log2_b
;
2043 np2
= SIGNIFICAND_BITS
- p2
;
2047 get_zero (r
, r
->sign
);
2049 if (!fmt
->has_signed_zero
)
2054 get_inf (r
, r
->sign
);
2059 clear_significand_below (r
, np2
);
2061 /* If we've cleared the entire significand, we need one bit
2062 set for this to continue to be a NaN. */
2063 for (i
= 0; i
< SIGSZ
; ++i
)
2067 r
->sig
[SIGSZ
-1] = SIG_MSB
>> 2;
2077 /* If we're not base2, normalize the exponent to a multiple of
2079 if (fmt
->log2_b
!= 1)
2081 int shift
= r
->exp
& (fmt
->log2_b
- 1);
2084 shift
= fmt
->log2_b
- shift
;
2085 sticky_rshift_significand (r
, r
, shift
);
2090 /* Check the range of the exponent. If we're out of range,
2091 either underflow or overflow. */
2094 else if (r
->exp
<= emin2m1
)
2098 if (!fmt
->has_denorm
)
2100 /* Don't underflow completely until we've had a chance to round. */
2101 if (r
->exp
< emin2m1
)
2106 diff
= emin2m1
- r
->exp
+ 1;
2110 /* De-normalize the significand. */
2111 sticky_rshift_significand (r
, r
, diff
);
2116 /* There are P2 true significand bits, followed by one guard bit,
2117 followed by one sticky bit, followed by stuff. Fold nonzero
2118 stuff into the sticky bit. */
2121 for (i
= 0, w
= (np2
- 1) / HOST_BITS_PER_LONG
; i
< w
; ++i
)
2122 sticky
|= r
->sig
[i
];
2124 r
->sig
[w
] & (((unsigned long)1 << ((np2
- 1) % HOST_BITS_PER_LONG
)) - 1);
2126 guard
= test_significand_bit (r
, np2
- 1);
2127 lsb
= test_significand_bit (r
, np2
);
2129 /* Round to even. */
2130 if (guard
&& (sticky
|| lsb
))
2134 set_significand_bit (&u
, np2
);
2136 if (add_significands (r
, r
, &u
))
2138 /* Overflow. Means the significand had been all ones, and
2139 is now all zeros. Need to increase the exponent, and
2140 possibly re-normalize it. */
2141 if (++r
->exp
> emax2
)
2143 r
->sig
[SIGSZ
-1] = SIG_MSB
;
2145 if (fmt
->log2_b
!= 1)
2147 int shift
= r
->exp
& (fmt
->log2_b
- 1);
2150 shift
= fmt
->log2_b
- shift
;
2151 sticky_rshift_significand (r
, r
, shift
);
2160 /* Catch underflow that we deferred until after rounding. */
2161 if (r
->exp
<= emin2m1
)
2164 /* Clear out trailing garbage. */
2165 clear_significand_below (r
, np2
);
2168 /* Extend or truncate to a new mode. */
2171 real_convert (r
, mode
, a
)
2173 enum machine_mode mode
;
2174 const REAL_VALUE_TYPE
*a
;
2176 const struct real_format
*fmt
;
2178 fmt
= real_format_for_mode
[mode
- QFmode
];
2183 round_for_format (fmt
, r
);
2185 /* round_for_format de-normalizes denormals. Undo just that part. */
2186 if (r
->class == rvc_normal
)
2190 /* Legacy. Likewise, except return the struct directly. */
2193 real_value_truncate (mode
, a
)
2194 enum machine_mode mode
;
2198 real_convert (&r
, mode
, &a
);
2202 /* Return true if truncating to MODE is exact. */
2205 exact_real_truncate (mode
, a
)
2206 enum machine_mode mode
;
2207 const REAL_VALUE_TYPE
*a
;
2210 real_convert (&t
, mode
, a
);
2211 return real_identical (&t
, a
);
2214 /* Write R to the given target format. Place the words of the result
2215 in target word order in BUF. There are always 32 bits in each
2216 long, no matter the size of the host long.
2218 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2221 real_to_target_fmt (buf
, r_orig
, fmt
)
2223 const REAL_VALUE_TYPE
*r_orig
;
2224 const struct real_format
*fmt
;
2230 round_for_format (fmt
, &r
);
2234 (*fmt
->encode
) (fmt
, buf
, &r
);
2239 /* Similar, but look up the format from MODE. */
2242 real_to_target (buf
, r
, mode
)
2244 const REAL_VALUE_TYPE
*r
;
2245 enum machine_mode mode
;
2247 const struct real_format
*fmt
;
2249 fmt
= real_format_for_mode
[mode
- QFmode
];
2253 return real_to_target_fmt (buf
, r
, fmt
);
2256 /* Read R from the given target format. Read the words of the result
2257 in target word order in BUF. There are always 32 bits in each
2258 long, no matter the size of the host long. */
2261 real_from_target_fmt (r
, buf
, fmt
)
2264 const struct real_format
*fmt
;
2266 (*fmt
->decode
) (fmt
, r
, buf
);
2269 /* Similar, but look up the format from MODE. */
2272 real_from_target (r
, buf
, mode
)
2275 enum machine_mode mode
;
2277 const struct real_format
*fmt
;
2279 fmt
= real_format_for_mode
[mode
- QFmode
];
2283 (*fmt
->decode
) (fmt
, r
, buf
);
2286 /* Return the number of bits in the significand for MODE. */
2287 /* ??? Legacy. Should get access to real_format directly. */
2290 significand_size (mode
)
2291 enum machine_mode mode
;
2293 const struct real_format
*fmt
;
2295 fmt
= real_format_for_mode
[mode
- QFmode
];
2299 return fmt
->p
* fmt
->log2_b
;
2302 /* Return a hash value for the given real value. */
2303 /* ??? The "unsigned int" return value is intended to be hashval_t,
2304 but I didn't want to pull hashtab.h into real.h. */
2308 const REAL_VALUE_TYPE
*r
;
2313 h
= r
->class | (r
->sign
<< 2);
2325 if (sizeof(unsigned long) > sizeof(unsigned int))
2326 for (i
= 0; i
< SIGSZ
; ++i
)
2328 unsigned long s
= r
->sig
[i
];
2329 h
^= s
^ (s
>> (HOST_BITS_PER_LONG
/ 2));
2332 for (i
= 0; i
< SIGSZ
; ++i
)
2343 /* IEEE single-precision format. */
2345 static void encode_ieee_single
PARAMS ((const struct real_format
*fmt
,
2346 long *, const REAL_VALUE_TYPE
*));
2347 static void decode_ieee_single
PARAMS ((const struct real_format
*,
2348 REAL_VALUE_TYPE
*, const long *));
2351 encode_ieee_single (fmt
, buf
, r
)
2352 const struct real_format
*fmt
;
2354 const REAL_VALUE_TYPE
*r
;
2356 unsigned long image
, sig
, exp
;
2357 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2359 image
= r
->sign
<< 31;
2360 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
2371 image
|= 0x7fffffff;
2379 if (!fmt
->qnan_msb_set
)
2380 image
^= 1 << 23 | 1 << 22;
2383 image
|= 0x7fffffff;
2387 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2388 whereas the intermediate representation is 0.F x 2**exp.
2389 Which means we're off by one. */
2393 exp
= r
->exp
+ 127 - 1;
2406 decode_ieee_single (fmt
, r
, buf
)
2407 const struct real_format
*fmt
;
2411 unsigned long image
= buf
[0] & 0xffffffff;
2412 bool sign
= (image
>> 31) & 1;
2413 int exp
= (image
>> 23) & 0xff;
2415 memset (r
, 0, sizeof (*r
));
2416 image
<<= HOST_BITS_PER_LONG
- 24;
2421 if (image
&& fmt
->has_denorm
)
2423 r
->class = rvc_normal
;
2426 r
->sig
[SIGSZ
-1] = image
<< 1;
2429 else if (fmt
->has_signed_zero
)
2432 else if (exp
== 255 && (fmt
->has_nans
|| fmt
->has_inf
))
2438 if (!fmt
->qnan_msb_set
)
2439 image
^= (SIG_MSB
>> 1 | SIG_MSB
>> 2);
2440 r
->sig
[SIGSZ
-1] = image
;
2450 r
->class = rvc_normal
;
2452 r
->exp
= exp
- 127 + 1;
2453 r
->sig
[SIGSZ
-1] = image
| SIG_MSB
;
2457 const struct real_format ieee_single_format
=
2474 /* IEEE double-precision format. */
2476 static void encode_ieee_double
PARAMS ((const struct real_format
*fmt
,
2477 long *, const REAL_VALUE_TYPE
*));
2478 static void decode_ieee_double
PARAMS ((const struct real_format
*,
2479 REAL_VALUE_TYPE
*, const long *));
2482 encode_ieee_double (fmt
, buf
, r
)
2483 const struct real_format
*fmt
;
2485 const REAL_VALUE_TYPE
*r
;
2487 unsigned long image_lo
, image_hi
, sig_lo
, sig_hi
, exp
;
2488 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2490 image_hi
= r
->sign
<< 31;
2493 if (HOST_BITS_PER_LONG
== 64)
2495 sig_hi
= r
->sig
[SIGSZ
-1];
2496 sig_lo
= (sig_hi
>> (64 - 53)) & 0xffffffff;
2497 sig_hi
= (sig_hi
>> (64 - 53 + 1) >> 31) & 0xfffff;
2501 sig_hi
= r
->sig
[SIGSZ
-1];
2502 sig_lo
= r
->sig
[SIGSZ
-2];
2503 sig_lo
= (sig_hi
<< 21) | (sig_lo
>> 11);
2504 sig_hi
= (sig_hi
>> 11) & 0xfffff;
2514 image_hi
|= 2047 << 20;
2517 image_hi
|= 0x7fffffff;
2518 image_lo
= 0xffffffff;
2525 image_hi
|= 2047 << 20;
2527 if (!fmt
->qnan_msb_set
)
2528 image_hi
^= 1 << 19 | 1 << 18;
2533 image_hi
|= 0x7fffffff;
2534 image_lo
= 0xffffffff;
2539 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2540 whereas the intermediate representation is 0.F x 2**exp.
2541 Which means we're off by one. */
2545 exp
= r
->exp
+ 1023 - 1;
2546 image_hi
|= exp
<< 20;
2555 if (FLOAT_WORDS_BIG_ENDIAN
)
2556 buf
[0] = image_hi
, buf
[1] = image_lo
;
2558 buf
[0] = image_lo
, buf
[1] = image_hi
;
2562 decode_ieee_double (fmt
, r
, buf
)
2563 const struct real_format
*fmt
;
2567 unsigned long image_hi
, image_lo
;
2571 if (FLOAT_WORDS_BIG_ENDIAN
)
2572 image_hi
= buf
[0], image_lo
= buf
[1];
2574 image_lo
= buf
[0], image_hi
= buf
[1];
2575 image_lo
&= 0xffffffff;
2576 image_hi
&= 0xffffffff;
2578 sign
= (image_hi
>> 31) & 1;
2579 exp
= (image_hi
>> 20) & 0x7ff;
2581 memset (r
, 0, sizeof (*r
));
2583 image_hi
<<= 32 - 21;
2584 image_hi
|= image_lo
>> 21;
2585 image_hi
&= 0x7fffffff;
2586 image_lo
<<= 32 - 21;
2590 if ((image_hi
|| image_lo
) && fmt
->has_denorm
)
2592 r
->class = rvc_normal
;
2595 if (HOST_BITS_PER_LONG
== 32)
2597 image_hi
= (image_hi
<< 1) | (image_lo
>> 31);
2599 r
->sig
[SIGSZ
-1] = image_hi
;
2600 r
->sig
[SIGSZ
-2] = image_lo
;
2604 image_hi
= (image_hi
<< 31 << 2) | (image_lo
<< 1);
2605 r
->sig
[SIGSZ
-1] = image_hi
;
2609 else if (fmt
->has_signed_zero
)
2612 else if (exp
== 2047 && (fmt
->has_nans
|| fmt
->has_inf
))
2614 if (image_hi
|| image_lo
)
2618 if (HOST_BITS_PER_LONG
== 32)
2620 r
->sig
[SIGSZ
-1] = image_hi
;
2621 r
->sig
[SIGSZ
-2] = image_lo
;
2624 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
;
2626 if (!fmt
->qnan_msb_set
)
2627 r
->sig
[SIGSZ
-1] ^= (SIG_MSB
>> 1 | SIG_MSB
>> 2);
2637 r
->class = rvc_normal
;
2639 r
->exp
= exp
- 1023 + 1;
2640 if (HOST_BITS_PER_LONG
== 32)
2642 r
->sig
[SIGSZ
-1] = image_hi
| SIG_MSB
;
2643 r
->sig
[SIGSZ
-2] = image_lo
;
2646 r
->sig
[SIGSZ
-1] = (image_hi
<< 31 << 1) | image_lo
| SIG_MSB
;
2650 const struct real_format ieee_double_format
=
2667 /* IEEE extended double precision format. This comes in three
2668 flavours: Intel's as a 12 byte image, Intel's as a 16 byte image,
2671 static void encode_ieee_extended
PARAMS ((const struct real_format
*fmt
,
2672 long *, const REAL_VALUE_TYPE
*));
2673 static void decode_ieee_extended
PARAMS ((const struct real_format
*,
2674 REAL_VALUE_TYPE
*, const long *));
2676 static void encode_ieee_extended_128
PARAMS ((const struct real_format
*fmt
,
2678 const REAL_VALUE_TYPE
*));
2679 static void decode_ieee_extended_128
PARAMS ((const struct real_format
*,
2684 encode_ieee_extended (fmt
, buf
, r
)
2685 const struct real_format
*fmt
;
2687 const REAL_VALUE_TYPE
*r
;
2689 unsigned long image_hi
, sig_hi
, sig_lo
;
2690 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2692 image_hi
= r
->sign
<< 15;
2693 sig_hi
= sig_lo
= 0;
2705 /* Intel requires the explicit integer bit to be set, otherwise
2706 it considers the value a "pseudo-infinity". Motorola docs
2707 say it doesn't care. */
2708 sig_hi
= 0x80000000;
2713 sig_lo
= sig_hi
= 0xffffffff;
2721 if (HOST_BITS_PER_LONG
== 32)
2723 sig_hi
= r
->sig
[SIGSZ
-1];
2724 sig_lo
= r
->sig
[SIGSZ
-2];
2728 sig_lo
= r
->sig
[SIGSZ
-1];
2729 sig_hi
= sig_lo
>> 31 >> 1;
2730 sig_lo
&= 0xffffffff;
2732 if (!fmt
->qnan_msb_set
)
2733 sig_hi
^= 1 << 30 | 1 << 29;
2735 /* Intel requires the explicit integer bit to be set, otherwise
2736 it considers the value a "pseudo-nan". Motorola docs say it
2738 sig_hi
|= 0x80000000;
2743 sig_lo
= sig_hi
= 0xffffffff;
2751 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2752 whereas the intermediate representation is 0.F x 2**exp.
2753 Which means we're off by one.
2755 Except for Motorola, which consider exp=0 and explicit
2756 integer bit set to continue to be normalized. In theory
2757 this descrepency has been taken care of by the difference
2758 in fmt->emin in round_for_format. */
2770 if (HOST_BITS_PER_LONG
== 32)
2772 sig_hi
= r
->sig
[SIGSZ
-1];
2773 sig_lo
= r
->sig
[SIGSZ
-2];
2777 sig_lo
= r
->sig
[SIGSZ
-1];
2778 sig_hi
= sig_lo
>> 31 >> 1;
2779 sig_lo
&= 0xffffffff;
2788 if (FLOAT_WORDS_BIG_ENDIAN
)
2789 buf
[0] = image_hi
<< 16, buf
[1] = sig_hi
, buf
[2] = sig_lo
;
2791 buf
[0] = sig_lo
, buf
[1] = sig_hi
, buf
[2] = image_hi
;
2795 encode_ieee_extended_128 (fmt
, buf
, r
)
2796 const struct real_format
*fmt
;
2798 const REAL_VALUE_TYPE
*r
;
2800 buf
[3 * !FLOAT_WORDS_BIG_ENDIAN
] = 0;
2801 encode_ieee_extended (fmt
, buf
+!!FLOAT_WORDS_BIG_ENDIAN
, r
);
2805 decode_ieee_extended (fmt
, r
, buf
)
2806 const struct real_format
*fmt
;
2810 unsigned long image_hi
, sig_hi
, sig_lo
;
2814 if (FLOAT_WORDS_BIG_ENDIAN
)
2815 image_hi
= buf
[0] >> 16, sig_hi
= buf
[1], sig_lo
= buf
[2];
2817 sig_lo
= buf
[0], sig_hi
= buf
[1], image_hi
= buf
[2];
2818 sig_lo
&= 0xffffffff;
2819 sig_hi
&= 0xffffffff;
2820 image_hi
&= 0xffffffff;
2822 sign
= (image_hi
>> 15) & 1;
2823 exp
= image_hi
& 0x7fff;
2825 memset (r
, 0, sizeof (*r
));
2829 if ((sig_hi
|| sig_lo
) && fmt
->has_denorm
)
2831 r
->class = rvc_normal
;
2834 /* When the IEEE format contains a hidden bit, we know that
2835 it's zero at this point, and so shift up the significand
2836 and decrease the exponent to match. In this case, Motorola
2837 defines the explicit integer bit to be valid, so we don't
2838 know whether the msb is set or not. */
2840 if (HOST_BITS_PER_LONG
== 32)
2842 r
->sig
[SIGSZ
-1] = sig_hi
;
2843 r
->sig
[SIGSZ
-2] = sig_lo
;
2846 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
2850 else if (fmt
->has_signed_zero
)
2853 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
2855 /* See above re "pseudo-infinities" and "pseudo-nans".
2856 Short summary is that the MSB will likely always be
2857 set, and that we don't care about it. */
2858 sig_hi
&= 0x7fffffff;
2860 if (sig_hi
|| sig_lo
)
2864 if (HOST_BITS_PER_LONG
== 32)
2866 r
->sig
[SIGSZ
-1] = sig_hi
;
2867 r
->sig
[SIGSZ
-2] = sig_lo
;
2870 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
2872 if (!fmt
->qnan_msb_set
)
2873 r
->sig
[SIGSZ
-1] ^= (SIG_MSB
>> 1 | SIG_MSB
>> 2);
2883 r
->class = rvc_normal
;
2885 r
->exp
= exp
- 16383 + 1;
2886 if (HOST_BITS_PER_LONG
== 32)
2888 r
->sig
[SIGSZ
-1] = sig_hi
;
2889 r
->sig
[SIGSZ
-2] = sig_lo
;
2892 r
->sig
[SIGSZ
-1] = (sig_hi
<< 31 << 1) | sig_lo
;
2897 decode_ieee_extended_128 (fmt
, r
, buf
)
2898 const struct real_format
*fmt
;
2902 decode_ieee_extended (fmt
, r
, buf
+!!FLOAT_WORDS_BIG_ENDIAN
);
2905 const struct real_format ieee_extended_motorola_format
=
2907 encode_ieee_extended
,
2908 decode_ieee_extended
,
2921 const struct real_format ieee_extended_intel_96_format
=
2923 encode_ieee_extended
,
2924 decode_ieee_extended
,
2937 const struct real_format ieee_extended_intel_128_format
=
2939 encode_ieee_extended_128
,
2940 decode_ieee_extended_128
,
2954 /* IBM 128-bit extended precision format: a pair of IEEE double precision
2955 numbers whose sum is equal to the extended precision value. The number
2956 with greater magnitude is first. This format has the same magnitude
2957 range as an IEEE double precision value, but effectively 106 bits of
2958 significand precision. Infinity and NaN are represented by their IEEE
2959 double precision value stored in the first number, the second number is
2960 ignored. Zeroes, Infinities, and NaNs are set in both doubles
2961 due to precedent. */
2963 static void encode_ibm_extended
PARAMS ((const struct real_format
*fmt
,
2964 long *, const REAL_VALUE_TYPE
*));
2965 static void decode_ibm_extended
PARAMS ((const struct real_format
*,
2966 REAL_VALUE_TYPE
*, const long *));
2969 encode_ibm_extended (fmt
, buf
, r
)
2970 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
2972 const REAL_VALUE_TYPE
*r
;
2974 REAL_VALUE_TYPE u
, v
;
2979 /* Both doubles have sign bit set. */
2980 buf
[0] = FLOAT_WORDS_BIG_ENDIAN
? r
->sign
<< 31 : 0;
2981 buf
[1] = FLOAT_WORDS_BIG_ENDIAN
? 0 : r
->sign
<< 31;
2988 /* Both doubles set to Inf / NaN. */
2989 encode_ieee_double (&ieee_double_format
, &buf
[0], r
);
2995 /* u = IEEE double precision portion of significand. */
2997 clear_significand_below (&u
, SIGNIFICAND_BITS
- 53);
2999 /* v = remainder containing additional 53 bits of significand. */
3000 do_add (&v
, r
, &u
, 1);
3002 encode_ieee_double (&ieee_double_format
, &buf
[0], &u
);
3003 encode_ieee_double (&ieee_double_format
, &buf
[2], &v
);
3012 decode_ibm_extended (fmt
, r
, buf
)
3013 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3017 REAL_VALUE_TYPE u
, v
;
3019 decode_ieee_double (&ieee_double_format
, &u
, &buf
[0]);
3021 if (u
.class != rvc_zero
&& u
.class != rvc_inf
&& u
.class != rvc_nan
)
3023 decode_ieee_double (&ieee_double_format
, &v
, &buf
[2]);
3024 do_add (r
, &u
, &v
, 0);
3030 const struct real_format ibm_extended_format
=
3032 encode_ibm_extended
,
3033 decode_ibm_extended
,
3047 /* IEEE quad precision format. */
3049 static void encode_ieee_quad
PARAMS ((const struct real_format
*fmt
,
3050 long *, const REAL_VALUE_TYPE
*));
3051 static void decode_ieee_quad
PARAMS ((const struct real_format
*,
3052 REAL_VALUE_TYPE
*, const long *));
3055 encode_ieee_quad (fmt
, buf
, r
)
3056 const struct real_format
*fmt
;
3058 const REAL_VALUE_TYPE
*r
;
3060 unsigned long image3
, image2
, image1
, image0
, exp
;
3061 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
3064 image3
= r
->sign
<< 31;
3069 rshift_significand (&u
, r
, SIGNIFICAND_BITS
- 113);
3078 image3
|= 32767 << 16;
3081 image3
|= 0x7fffffff;
3082 image2
= 0xffffffff;
3083 image1
= 0xffffffff;
3084 image0
= 0xffffffff;
3091 image3
|= 32767 << 16;
3093 if (HOST_BITS_PER_LONG
== 32)
3098 image3
|= u
.sig
[3] & 0xffff;
3103 image1
= image0
>> 31 >> 1;
3105 image3
|= (image2
>> 31 >> 1) & 0xffff;
3106 image0
&= 0xffffffff;
3107 image2
&= 0xffffffff;
3110 if (!fmt
->qnan_msb_set
)
3111 image3
^= 1 << 15 | 1 << 14;
3115 image3
|= 0x7fffffff;
3116 image2
= 0xffffffff;
3117 image1
= 0xffffffff;
3118 image0
= 0xffffffff;
3123 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3124 whereas the intermediate representation is 0.F x 2**exp.
3125 Which means we're off by one. */
3129 exp
= r
->exp
+ 16383 - 1;
3130 image3
|= exp
<< 16;
3132 if (HOST_BITS_PER_LONG
== 32)
3137 image3
|= u
.sig
[3] & 0xffff;
3142 image1
= image0
>> 31 >> 1;
3144 image3
|= (image2
>> 31 >> 1) & 0xffff;
3145 image0
&= 0xffffffff;
3146 image2
&= 0xffffffff;
3154 if (FLOAT_WORDS_BIG_ENDIAN
)
3171 decode_ieee_quad (fmt
, r
, buf
)
3172 const struct real_format
*fmt
;
3176 unsigned long image3
, image2
, image1
, image0
;
3180 if (FLOAT_WORDS_BIG_ENDIAN
)
3194 image0
&= 0xffffffff;
3195 image1
&= 0xffffffff;
3196 image2
&= 0xffffffff;
3198 sign
= (image3
>> 31) & 1;
3199 exp
= (image3
>> 16) & 0x7fff;
3202 memset (r
, 0, sizeof (*r
));
3206 if ((image3
| image2
| image1
| image0
) && fmt
->has_denorm
)
3208 r
->class = rvc_normal
;
3211 r
->exp
= -16382 + (SIGNIFICAND_BITS
- 112);
3212 if (HOST_BITS_PER_LONG
== 32)
3221 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3222 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3227 else if (fmt
->has_signed_zero
)
3230 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3232 if (image3
| image2
| image1
| image0
)
3237 if (HOST_BITS_PER_LONG
== 32)
3246 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3247 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3249 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3251 if (!fmt
->qnan_msb_set
)
3252 r
->sig
[SIGSZ
-1] ^= (SIG_MSB
>> 1 | SIG_MSB
>> 2);
3262 r
->class = rvc_normal
;
3264 r
->exp
= exp
- 16383 + 1;
3266 if (HOST_BITS_PER_LONG
== 32)
3275 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3276 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3278 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3279 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3283 const struct real_format ieee_quad_format
=
3299 /* Descriptions of VAX floating point formats can be found beginning at
3301 http://www.openvms.compaq.com:8000/73final/4515/4515pro_013.html#f_floating_point_format
3303 The thing to remember is that they're almost IEEE, except for word
3304 order, exponent bias, and the lack of infinities, nans, and denormals.
3306 We don't implement the H_floating format here, simply because neither
3307 the VAX or Alpha ports use it. */
3309 static void encode_vax_f
PARAMS ((const struct real_format
*fmt
,
3310 long *, const REAL_VALUE_TYPE
*));
3311 static void decode_vax_f
PARAMS ((const struct real_format
*,
3312 REAL_VALUE_TYPE
*, const long *));
3313 static void encode_vax_d
PARAMS ((const struct real_format
*fmt
,
3314 long *, const REAL_VALUE_TYPE
*));
3315 static void decode_vax_d
PARAMS ((const struct real_format
*,
3316 REAL_VALUE_TYPE
*, const long *));
3317 static void encode_vax_g
PARAMS ((const struct real_format
*fmt
,
3318 long *, const REAL_VALUE_TYPE
*));
3319 static void decode_vax_g
PARAMS ((const struct real_format
*,
3320 REAL_VALUE_TYPE
*, const long *));
3323 encode_vax_f (fmt
, buf
, r
)
3324 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3326 const REAL_VALUE_TYPE
*r
;
3328 unsigned long sign
, exp
, sig
, image
;
3330 sign
= r
->sign
<< 15;
3340 image
= 0xffff7fff | sign
;
3344 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
3347 image
= (sig
<< 16) & 0xffff0000;
3361 decode_vax_f (fmt
, r
, buf
)
3362 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3366 unsigned long image
= buf
[0] & 0xffffffff;
3367 int exp
= (image
>> 7) & 0xff;
3369 memset (r
, 0, sizeof (*r
));
3373 r
->class = rvc_normal
;
3374 r
->sign
= (image
>> 15) & 1;
3377 image
= ((image
& 0x7f) << 16) | ((image
>> 16) & 0xffff);
3378 r
->sig
[SIGSZ
-1] = (image
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
3383 encode_vax_d (fmt
, buf
, r
)
3384 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3386 const REAL_VALUE_TYPE
*r
;
3388 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
3393 image0
= image1
= 0;
3398 image0
= 0xffff7fff | sign
;
3399 image1
= 0xffffffff;
3403 /* Extract the significand into straight hi:lo. */
3404 if (HOST_BITS_PER_LONG
== 64)
3406 image0
= r
->sig
[SIGSZ
-1];
3407 image1
= (image0
>> (64 - 56)) & 0xffffffff;
3408 image0
= (image0
>> (64 - 56 + 1) >> 31) & 0x7fffff;
3412 image0
= r
->sig
[SIGSZ
-1];
3413 image1
= r
->sig
[SIGSZ
-2];
3414 image1
= (image0
<< 24) | (image1
>> 8);
3415 image0
= (image0
>> 8) & 0xffffff;
3418 /* Rearrange the half-words of the significand to match the
3420 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff007f;
3421 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
3423 /* Add the sign and exponent. */
3425 image0
|= (r
->exp
+ 128) << 7;
3432 if (FLOAT_WORDS_BIG_ENDIAN
)
3433 buf
[0] = image1
, buf
[1] = image0
;
3435 buf
[0] = image0
, buf
[1] = image1
;
3439 decode_vax_d (fmt
, r
, buf
)
3440 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3444 unsigned long image0
, image1
;
3447 if (FLOAT_WORDS_BIG_ENDIAN
)
3448 image1
= buf
[0], image0
= buf
[1];
3450 image0
= buf
[0], image1
= buf
[1];
3451 image0
&= 0xffffffff;
3452 image1
&= 0xffffffff;
3454 exp
= (image0
>> 7) & 0x7f;
3456 memset (r
, 0, sizeof (*r
));
3460 r
->class = rvc_normal
;
3461 r
->sign
= (image0
>> 15) & 1;
3464 /* Rearrange the half-words of the external format into
3465 proper ascending order. */
3466 image0
= ((image0
& 0x7f) << 16) | ((image0
>> 16) & 0xffff);
3467 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
3469 if (HOST_BITS_PER_LONG
== 64)
3471 image0
= (image0
<< 31 << 1) | image1
;
3474 r
->sig
[SIGSZ
-1] = image0
;
3478 r
->sig
[SIGSZ
-1] = image0
;
3479 r
->sig
[SIGSZ
-2] = image1
;
3480 lshift_significand (r
, r
, 2*HOST_BITS_PER_LONG
- 56);
3481 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3487 encode_vax_g (fmt
, buf
, r
)
3488 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3490 const REAL_VALUE_TYPE
*r
;
3492 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
3497 image0
= image1
= 0;
3502 image0
= 0xffff7fff | sign
;
3503 image1
= 0xffffffff;
3507 /* Extract the significand into straight hi:lo. */
3508 if (HOST_BITS_PER_LONG
== 64)
3510 image0
= r
->sig
[SIGSZ
-1];
3511 image1
= (image0
>> (64 - 53)) & 0xffffffff;
3512 image0
= (image0
>> (64 - 53 + 1) >> 31) & 0xfffff;
3516 image0
= r
->sig
[SIGSZ
-1];
3517 image1
= r
->sig
[SIGSZ
-2];
3518 image1
= (image0
<< 21) | (image1
>> 11);
3519 image0
= (image0
>> 11) & 0xfffff;
3522 /* Rearrange the half-words of the significand to match the
3524 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff000f;
3525 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
3527 /* Add the sign and exponent. */
3529 image0
|= (r
->exp
+ 1024) << 4;
3536 if (FLOAT_WORDS_BIG_ENDIAN
)
3537 buf
[0] = image1
, buf
[1] = image0
;
3539 buf
[0] = image0
, buf
[1] = image1
;
3543 decode_vax_g (fmt
, r
, buf
)
3544 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3548 unsigned long image0
, image1
;
3551 if (FLOAT_WORDS_BIG_ENDIAN
)
3552 image1
= buf
[0], image0
= buf
[1];
3554 image0
= buf
[0], image1
= buf
[1];
3555 image0
&= 0xffffffff;
3556 image1
&= 0xffffffff;
3558 exp
= (image0
>> 4) & 0x7ff;
3560 memset (r
, 0, sizeof (*r
));
3564 r
->class = rvc_normal
;
3565 r
->sign
= (image0
>> 15) & 1;
3566 r
->exp
= exp
- 1024;
3568 /* Rearrange the half-words of the external format into
3569 proper ascending order. */
3570 image0
= ((image0
& 0xf) << 16) | ((image0
>> 16) & 0xffff);
3571 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
3573 if (HOST_BITS_PER_LONG
== 64)
3575 image0
= (image0
<< 31 << 1) | image1
;
3578 r
->sig
[SIGSZ
-1] = image0
;
3582 r
->sig
[SIGSZ
-1] = image0
;
3583 r
->sig
[SIGSZ
-2] = image1
;
3584 lshift_significand (r
, r
, 64 - 53);
3585 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3590 const struct real_format vax_f_format
=
3606 const struct real_format vax_d_format
=
3622 const struct real_format vax_g_format
=
3638 /* A good reference for these can be found in chapter 9 of
3639 "ESA/390 Principles of Operation", IBM document number SA22-7201-01.
3640 An on-line version can be found here:
3642 http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/DZ9AR001/9.1?DT=19930923083613
3645 static void encode_i370_single
PARAMS ((const struct real_format
*fmt
,
3646 long *, const REAL_VALUE_TYPE
*));
3647 static void decode_i370_single
PARAMS ((const struct real_format
*,
3648 REAL_VALUE_TYPE
*, const long *));
3649 static void encode_i370_double
PARAMS ((const struct real_format
*fmt
,
3650 long *, const REAL_VALUE_TYPE
*));
3651 static void decode_i370_double
PARAMS ((const struct real_format
*,
3652 REAL_VALUE_TYPE
*, const long *));
3655 encode_i370_single (fmt
, buf
, r
)
3656 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3658 const REAL_VALUE_TYPE
*r
;
3660 unsigned long sign
, exp
, sig
, image
;
3662 sign
= r
->sign
<< 31;
3672 image
= 0x7fffffff | sign
;
3676 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0xffffff;
3677 exp
= ((r
->exp
/ 4) + 64) << 24;
3678 image
= sign
| exp
| sig
;
3689 decode_i370_single (fmt
, r
, buf
)
3690 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3694 unsigned long sign
, sig
, image
= buf
[0];
3697 sign
= (image
>> 31) & 1;
3698 exp
= (image
>> 24) & 0x7f;
3699 sig
= image
& 0xffffff;
3701 memset (r
, 0, sizeof (*r
));
3705 r
->class = rvc_normal
;
3707 r
->exp
= (exp
- 64) * 4;
3708 r
->sig
[SIGSZ
-1] = sig
<< (HOST_BITS_PER_LONG
- 24);
3714 encode_i370_double (fmt
, buf
, r
)
3715 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3717 const REAL_VALUE_TYPE
*r
;
3719 unsigned long sign
, exp
, image_hi
, image_lo
;
3721 sign
= r
->sign
<< 31;
3726 image_hi
= image_lo
= 0;
3731 image_hi
= 0x7fffffff | sign
;
3732 image_lo
= 0xffffffff;
3736 if (HOST_BITS_PER_LONG
== 64)
3738 image_hi
= r
->sig
[SIGSZ
-1];
3739 image_lo
= (image_hi
>> (64 - 56)) & 0xffffffff;
3740 image_hi
= (image_hi
>> (64 - 56 + 1) >> 31) & 0xffffff;
3744 image_hi
= r
->sig
[SIGSZ
-1];
3745 image_lo
= r
->sig
[SIGSZ
-2];
3746 image_lo
= (image_lo
>> 8) | (image_hi
<< 24);
3750 exp
= ((r
->exp
/ 4) + 64) << 24;
3751 image_hi
|= sign
| exp
;
3758 if (FLOAT_WORDS_BIG_ENDIAN
)
3759 buf
[0] = image_hi
, buf
[1] = image_lo
;
3761 buf
[0] = image_lo
, buf
[1] = image_hi
;
3765 decode_i370_double (fmt
, r
, buf
)
3766 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3770 unsigned long sign
, image_hi
, image_lo
;
3773 if (FLOAT_WORDS_BIG_ENDIAN
)
3774 image_hi
= buf
[0], image_lo
= buf
[1];
3776 image_lo
= buf
[0], image_hi
= buf
[1];
3778 sign
= (image_hi
>> 31) & 1;
3779 exp
= (image_hi
>> 24) & 0x7f;
3780 image_hi
&= 0xffffff;
3781 image_lo
&= 0xffffffff;
3783 memset (r
, 0, sizeof (*r
));
3785 if (exp
|| image_hi
|| image_lo
)
3787 r
->class = rvc_normal
;
3789 r
->exp
= (exp
- 64) * 4 + (SIGNIFICAND_BITS
- 56);
3791 if (HOST_BITS_PER_LONG
== 32)
3793 r
->sig
[0] = image_lo
;
3794 r
->sig
[1] = image_hi
;
3797 r
->sig
[0] = image_lo
| (image_hi
<< 31 << 1);
3803 const struct real_format i370_single_format
=
3814 false, /* ??? The encoding does allow for "unnormals". */
3815 false, /* ??? The encoding does allow for "unnormals". */
3819 const struct real_format i370_double_format
=
3830 false, /* ??? The encoding does allow for "unnormals". */
3831 false, /* ??? The encoding does allow for "unnormals". */
3835 /* The "twos-complement" c4x format is officially defined as
3839 This is rather misleading. One must remember that F is signed.
3840 A better description would be
3842 x = -1**s * ((s + 1 + .f) * 2**e
3844 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
3845 that's -1 * (1+1+(-.5)) == -1.5. I think.
3847 The constructions here are taken from Tables 5-1 and 5-2 of the
3848 TMS320C4x User's Guide wherein step-by-step instructions for
3849 conversion from IEEE are presented. That's close enough to our
3850 internal representation so as to make things easy.
3852 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
3854 static void encode_c4x_single
PARAMS ((const struct real_format
*fmt
,
3855 long *, const REAL_VALUE_TYPE
*));
3856 static void decode_c4x_single
PARAMS ((const struct real_format
*,
3857 REAL_VALUE_TYPE
*, const long *));
3858 static void encode_c4x_extended
PARAMS ((const struct real_format
*fmt
,
3859 long *, const REAL_VALUE_TYPE
*));
3860 static void decode_c4x_extended
PARAMS ((const struct real_format
*,
3861 REAL_VALUE_TYPE
*, const long *));
3864 encode_c4x_single (fmt
, buf
, r
)
3865 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3867 const REAL_VALUE_TYPE
*r
;
3869 unsigned long image
, exp
, sig
;
3881 sig
= 0x800000 - r
->sign
;
3886 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
3901 image
= ((exp
& 0xff) << 24) | (sig
& 0xffffff);
3906 decode_c4x_single (fmt
, r
, buf
)
3907 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3911 unsigned long image
= buf
[0];
3915 exp
= (((image
>> 24) & 0xff) ^ 0x80) - 0x80;
3916 sf
= ((image
& 0xffffff) ^ 0x800000) - 0x800000;
3918 memset (r
, 0, sizeof (*r
));
3922 r
->class = rvc_normal
;
3924 sig
= sf
& 0x7fffff;
3933 sig
= (sig
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
3936 r
->sig
[SIGSZ
-1] = sig
;
3941 encode_c4x_extended (fmt
, buf
, r
)
3942 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3944 const REAL_VALUE_TYPE
*r
;
3946 unsigned long exp
, sig
;
3958 sig
= 0x80000000 - r
->sign
;
3964 sig
= r
->sig
[SIGSZ
-1];
3965 if (HOST_BITS_PER_LONG
== 64)
3966 sig
= sig
>> 1 >> 31;
3983 exp
= (exp
& 0xff) << 24;
3986 if (FLOAT_WORDS_BIG_ENDIAN
)
3987 buf
[0] = exp
, buf
[1] = sig
;
3989 buf
[0] = sig
, buf
[0] = exp
;
3993 decode_c4x_extended (fmt
, r
, buf
)
3994 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
4001 if (FLOAT_WORDS_BIG_ENDIAN
)
4002 exp
= buf
[0], sf
= buf
[1];
4004 sf
= buf
[0], exp
= buf
[1];
4006 exp
= (((exp
>> 24) & 0xff) & 0x80) - 0x80;
4007 sf
= ((sf
& 0xffffffff) ^ 0x80000000) - 0x80000000;
4009 memset (r
, 0, sizeof (*r
));
4013 r
->class = rvc_normal
;
4015 sig
= sf
& 0x7fffffff;
4024 if (HOST_BITS_PER_LONG
== 64)
4025 sig
= sig
<< 1 << 31;
4029 r
->sig
[SIGSZ
-1] = sig
;
4033 const struct real_format c4x_single_format
=
4049 const struct real_format c4x_extended_format
=
4051 encode_c4x_extended
,
4052 decode_c4x_extended
,
4065 /* Set up default mode to format mapping for IEEE. Everyone else has
4066 to set these values in OVERRIDE_OPTIONS. */
4068 const struct real_format
*real_format_for_mode
[TFmode
- QFmode
+ 1] =
4073 &ieee_single_format
, /* SFmode */
4074 &ieee_double_format
, /* DFmode */
4076 /* We explicitly don't handle XFmode. There are two formats,
4077 pretty much equally common. Choose one in OVERRIDE_OPTIONS. */
4079 &ieee_quad_format
/* TFmode */