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 non-zero. */
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 non-zero. */
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 u
.class = rvc_normal
;
747 /* Collect all the partial products. Since we don't have sure access
748 to a widening multiply, we split each long into two half-words.
750 Consider the long-hand form of a four half-word multiplication:
760 We construct partial products of the widened half-word products
761 that are known to not overlap, e.g. DF+DH. Each such partial
762 product is given its proper exponent, which allows us to sum them
763 and obtain the finished product. */
765 for (i
= 0; i
< SIGSZ
* 2; ++i
)
767 unsigned long ai
= a
->sig
[i
/ 2];
769 ai
>>= HOST_BITS_PER_LONG
/ 2;
771 ai
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
776 for (j
= 0; j
< 2; ++j
)
778 int exp
= (a
->exp
- (2*SIGSZ
-1-i
)*(HOST_BITS_PER_LONG
/2)
779 + (b
->exp
- (1-j
)*(HOST_BITS_PER_LONG
/2)));
784 /* Would underflow to zero, which we shouldn't bother adding. */
789 for (k
= j
; k
< SIGSZ
* 2; k
+= 2)
791 unsigned long bi
= b
->sig
[k
/ 2];
793 bi
>>= HOST_BITS_PER_LONG
/ 2;
795 bi
&= ((unsigned long)1 << (HOST_BITS_PER_LONG
/ 2)) - 1;
797 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 non-zero
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 /* IEEE quad precision format. */
2956 static void encode_ieee_quad
PARAMS ((const struct real_format
*fmt
,
2957 long *, const REAL_VALUE_TYPE
*));
2958 static void decode_ieee_quad
PARAMS ((const struct real_format
*,
2959 REAL_VALUE_TYPE
*, const long *));
2962 encode_ieee_quad (fmt
, buf
, r
)
2963 const struct real_format
*fmt
;
2965 const REAL_VALUE_TYPE
*r
;
2967 unsigned long image3
, image2
, image1
, image0
, exp
;
2968 bool denormal
= (r
->sig
[SIGSZ
-1] & SIG_MSB
) == 0;
2971 image3
= r
->sign
<< 31;
2976 rshift_significand (&u
, r
, SIGNIFICAND_BITS
- 113);
2985 image3
|= 32767 << 16;
2988 image3
|= 0x7fffffff;
2989 image2
= 0xffffffff;
2990 image1
= 0xffffffff;
2991 image0
= 0xffffffff;
2998 image3
|= 32767 << 16;
3000 if (HOST_BITS_PER_LONG
== 32)
3005 image3
|= u
.sig
[3] & 0xffff;
3010 image1
= image0
>> 31 >> 1;
3012 image3
|= (image2
>> 31 >> 1) & 0xffff;
3013 image0
&= 0xffffffff;
3014 image2
&= 0xffffffff;
3017 if (!fmt
->qnan_msb_set
)
3018 image3
^= 1 << 15 | 1 << 14;
3022 image3
|= 0x7fffffff;
3023 image2
= 0xffffffff;
3024 image1
= 0xffffffff;
3025 image0
= 0xffffffff;
3030 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3031 whereas the intermediate representation is 0.F x 2**exp.
3032 Which means we're off by one. */
3036 exp
= r
->exp
+ 16383 - 1;
3037 image3
|= exp
<< 16;
3039 if (HOST_BITS_PER_LONG
== 32)
3044 image3
|= u
.sig
[3] & 0xffff;
3049 image1
= image0
>> 31 >> 1;
3051 image3
|= (image2
>> 31 >> 1) & 0xffff;
3052 image0
&= 0xffffffff;
3053 image2
&= 0xffffffff;
3061 if (FLOAT_WORDS_BIG_ENDIAN
)
3078 decode_ieee_quad (fmt
, r
, buf
)
3079 const struct real_format
*fmt
;
3083 unsigned long image3
, image2
, image1
, image0
;
3087 if (FLOAT_WORDS_BIG_ENDIAN
)
3101 image0
&= 0xffffffff;
3102 image1
&= 0xffffffff;
3103 image2
&= 0xffffffff;
3105 sign
= (image3
>> 31) & 1;
3106 exp
= (image3
>> 16) & 0x7fff;
3109 memset (r
, 0, sizeof (*r
));
3113 if ((image3
| image2
| image1
| image0
) && fmt
->has_denorm
)
3115 r
->class = rvc_normal
;
3118 r
->exp
= -16382 + (SIGNIFICAND_BITS
- 112);
3119 if (HOST_BITS_PER_LONG
== 32)
3128 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3129 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3134 else if (fmt
->has_signed_zero
)
3137 else if (exp
== 32767 && (fmt
->has_nans
|| fmt
->has_inf
))
3139 if (image3
| image2
| image1
| image0
)
3144 if (HOST_BITS_PER_LONG
== 32)
3153 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3154 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3156 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3158 if (!fmt
->qnan_msb_set
)
3159 r
->sig
[SIGSZ
-1] ^= (SIG_MSB
>> 1 | SIG_MSB
>> 2);
3169 r
->class = rvc_normal
;
3171 r
->exp
= exp
- 16383 + 1;
3173 if (HOST_BITS_PER_LONG
== 32)
3182 r
->sig
[0] = (image1
<< 31 << 1) | image0
;
3183 r
->sig
[1] = (image3
<< 31 << 1) | image2
;
3185 lshift_significand (r
, r
, SIGNIFICAND_BITS
- 113);
3186 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3190 const struct real_format ieee_quad_format
=
3206 /* Descriptions of VAX floating point formats can be found beginning at
3208 http://www.openvms.compaq.com:8000/73final/4515/4515pro_013.html#f_floating_point_format
3210 The thing to remember is that they're almost IEEE, except for word
3211 order, exponent bias, and the lack of infinities, nans, and denormals.
3213 We don't implement the H_floating format here, simply because neither
3214 the VAX or Alpha ports use it. */
3216 static void encode_vax_f
PARAMS ((const struct real_format
*fmt
,
3217 long *, const REAL_VALUE_TYPE
*));
3218 static void decode_vax_f
PARAMS ((const struct real_format
*,
3219 REAL_VALUE_TYPE
*, const long *));
3220 static void encode_vax_d
PARAMS ((const struct real_format
*fmt
,
3221 long *, const REAL_VALUE_TYPE
*));
3222 static void decode_vax_d
PARAMS ((const struct real_format
*,
3223 REAL_VALUE_TYPE
*, const long *));
3224 static void encode_vax_g
PARAMS ((const struct real_format
*fmt
,
3225 long *, const REAL_VALUE_TYPE
*));
3226 static void decode_vax_g
PARAMS ((const struct real_format
*,
3227 REAL_VALUE_TYPE
*, const long *));
3230 encode_vax_f (fmt
, buf
, r
)
3231 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3233 const REAL_VALUE_TYPE
*r
;
3235 unsigned long sign
, exp
, sig
, image
;
3237 sign
= r
->sign
<< 15;
3247 image
= 0xffff7fff | sign
;
3251 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
3254 image
= (sig
<< 16) & 0xffff0000;
3268 decode_vax_f (fmt
, r
, buf
)
3269 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3273 unsigned long image
= buf
[0] & 0xffffffff;
3274 int exp
= (image
>> 7) & 0xff;
3276 memset (r
, 0, sizeof (*r
));
3280 r
->class = rvc_normal
;
3281 r
->sign
= (image
>> 15) & 1;
3284 image
= ((image
& 0x7f) << 16) | ((image
>> 16) & 0xffff);
3285 r
->sig
[SIGSZ
-1] = (image
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
3290 encode_vax_d (fmt
, buf
, r
)
3291 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3293 const REAL_VALUE_TYPE
*r
;
3295 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
3300 image0
= image1
= 0;
3305 image0
= 0xffff7fff | sign
;
3306 image1
= 0xffffffff;
3310 /* Extract the significand into straight hi:lo. */
3311 if (HOST_BITS_PER_LONG
== 64)
3313 image0
= r
->sig
[SIGSZ
-1];
3314 image1
= (image0
>> (64 - 56)) & 0xffffffff;
3315 image0
= (image0
>> (64 - 56 + 1) >> 31) & 0x7fffff;
3319 image0
= r
->sig
[SIGSZ
-1];
3320 image1
= r
->sig
[SIGSZ
-2];
3321 image1
= (image0
<< 24) | (image1
>> 8);
3322 image0
= (image0
>> 8) & 0xffffff;
3325 /* Rearrange the half-words of the significand to match the
3327 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff007f;
3328 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
3330 /* Add the sign and exponent. */
3332 image0
|= (r
->exp
+ 128) << 7;
3339 if (FLOAT_WORDS_BIG_ENDIAN
)
3340 buf
[0] = image1
, buf
[1] = image0
;
3342 buf
[0] = image0
, buf
[1] = image1
;
3346 decode_vax_d (fmt
, r
, buf
)
3347 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3351 unsigned long image0
, image1
;
3354 if (FLOAT_WORDS_BIG_ENDIAN
)
3355 image1
= buf
[0], image0
= buf
[1];
3357 image0
= buf
[0], image1
= buf
[1];
3358 image0
&= 0xffffffff;
3359 image1
&= 0xffffffff;
3361 exp
= (image0
>> 7) & 0x7f;
3363 memset (r
, 0, sizeof (*r
));
3367 r
->class = rvc_normal
;
3368 r
->sign
= (image0
>> 15) & 1;
3371 /* Rearrange the half-words of the external format into
3372 proper ascending order. */
3373 image0
= ((image0
& 0x7f) << 16) | ((image0
>> 16) & 0xffff);
3374 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
3376 if (HOST_BITS_PER_LONG
== 64)
3378 image0
= (image0
<< 31 << 1) | image1
;
3381 r
->sig
[SIGSZ
-1] = image0
;
3385 r
->sig
[SIGSZ
-1] = image0
;
3386 r
->sig
[SIGSZ
-2] = image1
;
3387 lshift_significand (r
, r
, 2*HOST_BITS_PER_LONG
- 56);
3388 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3394 encode_vax_g (fmt
, buf
, r
)
3395 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3397 const REAL_VALUE_TYPE
*r
;
3399 unsigned long image0
, image1
, sign
= r
->sign
<< 15;
3404 image0
= image1
= 0;
3409 image0
= 0xffff7fff | sign
;
3410 image1
= 0xffffffff;
3414 /* Extract the significand into straight hi:lo. */
3415 if (HOST_BITS_PER_LONG
== 64)
3417 image0
= r
->sig
[SIGSZ
-1];
3418 image1
= (image0
>> (64 - 53)) & 0xffffffff;
3419 image0
= (image0
>> (64 - 53 + 1) >> 31) & 0xfffff;
3423 image0
= r
->sig
[SIGSZ
-1];
3424 image1
= r
->sig
[SIGSZ
-2];
3425 image1
= (image0
<< 21) | (image1
>> 11);
3426 image0
= (image0
>> 11) & 0xfffff;
3429 /* Rearrange the half-words of the significand to match the
3431 image0
= ((image0
<< 16) | (image0
>> 16)) & 0xffff000f;
3432 image1
= ((image1
<< 16) | (image1
>> 16)) & 0xffffffff;
3434 /* Add the sign and exponent. */
3436 image0
|= (r
->exp
+ 1024) << 4;
3443 if (FLOAT_WORDS_BIG_ENDIAN
)
3444 buf
[0] = image1
, buf
[1] = image0
;
3446 buf
[0] = image0
, buf
[1] = image1
;
3450 decode_vax_g (fmt
, r
, buf
)
3451 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3455 unsigned long image0
, image1
;
3458 if (FLOAT_WORDS_BIG_ENDIAN
)
3459 image1
= buf
[0], image0
= buf
[1];
3461 image0
= buf
[0], image1
= buf
[1];
3462 image0
&= 0xffffffff;
3463 image1
&= 0xffffffff;
3465 exp
= (image0
>> 4) & 0x7ff;
3467 memset (r
, 0, sizeof (*r
));
3471 r
->class = rvc_normal
;
3472 r
->sign
= (image0
>> 15) & 1;
3473 r
->exp
= exp
- 1024;
3475 /* Rearrange the half-words of the external format into
3476 proper ascending order. */
3477 image0
= ((image0
& 0xf) << 16) | ((image0
>> 16) & 0xffff);
3478 image1
= ((image1
& 0xffff) << 16) | ((image1
>> 16) & 0xffff);
3480 if (HOST_BITS_PER_LONG
== 64)
3482 image0
= (image0
<< 31 << 1) | image1
;
3485 r
->sig
[SIGSZ
-1] = image0
;
3489 r
->sig
[SIGSZ
-1] = image0
;
3490 r
->sig
[SIGSZ
-2] = image1
;
3491 lshift_significand (r
, r
, 64 - 53);
3492 r
->sig
[SIGSZ
-1] |= SIG_MSB
;
3497 const struct real_format vax_f_format
=
3513 const struct real_format vax_d_format
=
3529 const struct real_format vax_g_format
=
3545 /* A good reference for these can be found in chapter 9 of
3546 "ESA/390 Principles of Operation", IBM document number SA22-7201-01.
3547 An on-line version can be found here:
3549 http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/DZ9AR001/9.1?DT=19930923083613
3552 static void encode_i370_single
PARAMS ((const struct real_format
*fmt
,
3553 long *, const REAL_VALUE_TYPE
*));
3554 static void decode_i370_single
PARAMS ((const struct real_format
*,
3555 REAL_VALUE_TYPE
*, const long *));
3556 static void encode_i370_double
PARAMS ((const struct real_format
*fmt
,
3557 long *, const REAL_VALUE_TYPE
*));
3558 static void decode_i370_double
PARAMS ((const struct real_format
*,
3559 REAL_VALUE_TYPE
*, const long *));
3562 encode_i370_single (fmt
, buf
, r
)
3563 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3565 const REAL_VALUE_TYPE
*r
;
3567 unsigned long sign
, exp
, sig
, image
;
3569 sign
= r
->sign
<< 31;
3579 image
= 0x7fffffff | sign
;
3583 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0xffffff;
3584 exp
= ((r
->exp
/ 4) + 64) << 24;
3585 image
= sign
| exp
| sig
;
3596 decode_i370_single (fmt
, r
, buf
)
3597 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3601 unsigned long sign
, sig
, image
= buf
[0];
3604 sign
= (image
>> 31) & 1;
3605 exp
= (image
>> 24) & 0x7f;
3606 sig
= image
& 0xffffff;
3608 memset (r
, 0, sizeof (*r
));
3612 r
->class = rvc_normal
;
3614 r
->exp
= (exp
- 64) * 4;
3615 r
->sig
[SIGSZ
-1] = sig
<< (HOST_BITS_PER_LONG
- 24);
3621 encode_i370_double (fmt
, buf
, r
)
3622 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3624 const REAL_VALUE_TYPE
*r
;
3626 unsigned long sign
, exp
, image_hi
, image_lo
;
3628 sign
= r
->sign
<< 31;
3633 image_hi
= image_lo
= 0;
3638 image_hi
= 0x7fffffff | sign
;
3639 image_lo
= 0xffffffff;
3643 if (HOST_BITS_PER_LONG
== 64)
3645 image_hi
= r
->sig
[SIGSZ
-1];
3646 image_lo
= (image_hi
>> (64 - 56)) & 0xffffffff;
3647 image_hi
= (image_hi
>> (64 - 56 + 1) >> 31) & 0xffffff;
3651 image_hi
= r
->sig
[SIGSZ
-1];
3652 image_lo
= r
->sig
[SIGSZ
-2];
3653 image_lo
= (image_lo
>> 8) | (image_hi
<< 24);
3657 exp
= ((r
->exp
/ 4) + 64) << 24;
3658 image_hi
|= sign
| exp
;
3665 if (FLOAT_WORDS_BIG_ENDIAN
)
3666 buf
[0] = image_hi
, buf
[1] = image_lo
;
3668 buf
[0] = image_lo
, buf
[1] = image_hi
;
3672 decode_i370_double (fmt
, r
, buf
)
3673 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3677 unsigned long sign
, image_hi
, image_lo
;
3680 if (FLOAT_WORDS_BIG_ENDIAN
)
3681 image_hi
= buf
[0], image_lo
= buf
[1];
3683 image_lo
= buf
[0], image_hi
= buf
[1];
3685 sign
= (image_hi
>> 31) & 1;
3686 exp
= (image_hi
>> 24) & 0x7f;
3687 image_hi
&= 0xffffff;
3688 image_lo
&= 0xffffffff;
3690 memset (r
, 0, sizeof (*r
));
3692 if (exp
|| image_hi
|| image_lo
)
3694 r
->class = rvc_normal
;
3696 r
->exp
= (exp
- 64) * 4 + (SIGNIFICAND_BITS
- 56);
3698 if (HOST_BITS_PER_LONG
== 32)
3700 r
->sig
[0] = image_lo
;
3701 r
->sig
[1] = image_hi
;
3704 r
->sig
[0] = image_lo
| (image_hi
<< 31 << 1);
3710 const struct real_format i370_single_format
=
3721 false, /* ??? The encoding does allow for "unnormals". */
3722 false, /* ??? The encoding does allow for "unnormals". */
3726 const struct real_format i370_double_format
=
3737 false, /* ??? The encoding does allow for "unnormals". */
3738 false, /* ??? The encoding does allow for "unnormals". */
3742 /* The "twos-compliment" c4x format is officially defined as
3746 This is rather misleading. One must remember that F is signed.
3747 A better description would be
3749 x = -1**s * ((s + 1 + .f) * 2**e
3751 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
3752 that's -1 * (1+1+(-.5)) == -1.5. I think.
3754 The constructions here are taken from Tables 5-1 and 5-2 of the
3755 TMS320C4x User's Guide wherein step-by-step instructions for
3756 conversion from IEEE are presented. That's close enough to our
3757 internal representation so as to make things easy.
3759 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
3761 static void encode_c4x_single
PARAMS ((const struct real_format
*fmt
,
3762 long *, const REAL_VALUE_TYPE
*));
3763 static void decode_c4x_single
PARAMS ((const struct real_format
*,
3764 REAL_VALUE_TYPE
*, const long *));
3765 static void encode_c4x_extended
PARAMS ((const struct real_format
*fmt
,
3766 long *, const REAL_VALUE_TYPE
*));
3767 static void decode_c4x_extended
PARAMS ((const struct real_format
*,
3768 REAL_VALUE_TYPE
*, const long *));
3771 encode_c4x_single (fmt
, buf
, r
)
3772 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3774 const REAL_VALUE_TYPE
*r
;
3776 unsigned long image
, exp
, sig
;
3788 sig
= 0x800000 - r
->sign
;
3793 sig
= (r
->sig
[SIGSZ
-1] >> (HOST_BITS_PER_LONG
- 24)) & 0x7fffff;
3808 image
= ((exp
& 0xff) << 24) | (sig
& 0xffffff);
3813 decode_c4x_single (fmt
, r
, buf
)
3814 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3818 unsigned long image
= buf
[0];
3822 exp
= (((image
>> 24) & 0xff) ^ 0x80) - 0x80;
3823 sf
= ((image
& 0xffffff) ^ 0x800000) - 0x800000;
3825 memset (r
, 0, sizeof (*r
));
3829 r
->class = rvc_normal
;
3831 sig
= sf
& 0x7fffff;
3840 sig
= (sig
<< (HOST_BITS_PER_LONG
- 24)) | SIG_MSB
;
3843 r
->sig
[SIGSZ
-1] = sig
;
3848 encode_c4x_extended (fmt
, buf
, r
)
3849 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3851 const REAL_VALUE_TYPE
*r
;
3853 unsigned long exp
, sig
;
3865 sig
= 0x80000000 - r
->sign
;
3871 sig
= r
->sig
[SIGSZ
-1];
3872 if (HOST_BITS_PER_LONG
== 64)
3873 sig
= sig
>> 1 >> 31;
3890 exp
= (exp
& 0xff) << 24;
3893 if (FLOAT_WORDS_BIG_ENDIAN
)
3894 buf
[0] = exp
, buf
[1] = sig
;
3896 buf
[0] = sig
, buf
[0] = exp
;
3900 decode_c4x_extended (fmt
, r
, buf
)
3901 const struct real_format
*fmt ATTRIBUTE_UNUSED
;
3908 if (FLOAT_WORDS_BIG_ENDIAN
)
3909 exp
= buf
[0], sf
= buf
[1];
3911 sf
= buf
[0], exp
= buf
[1];
3913 exp
= (((exp
>> 24) & 0xff) & 0x80) - 0x80;
3914 sf
= ((sf
& 0xffffffff) ^ 0x80000000) - 0x80000000;
3916 memset (r
, 0, sizeof (*r
));
3920 r
->class = rvc_normal
;
3922 sig
= sf
& 0x7fffffff;
3931 if (HOST_BITS_PER_LONG
== 64)
3932 sig
= sig
<< 1 << 31;
3936 r
->sig
[SIGSZ
-1] = sig
;
3940 const struct real_format c4x_single_format
=
3956 const struct real_format c4x_extended_format
=
3958 encode_c4x_extended
,
3959 decode_c4x_extended
,
3972 /* Set up default mode to format mapping for IEEE. Everyone else has
3973 to set these values in OVERRIDE_OPTIONS. */
3975 const struct real_format
*real_format_for_mode
[TFmode
- QFmode
+ 1] =
3980 &ieee_single_format
, /* SFmode */
3981 &ieee_double_format
, /* DFmode */
3983 /* We explicitly don't handle XFmode. There are two formats,
3984 pretty much equally common. Choose one in OVERRIDE_OPTIONS. */
3986 &ieee_quad_format
/* TFmode */