2005-01-16 Steven G. Kargl <kargls@comcast.net>
[official-gcc.git] / gcc / real.c
blobebd402a32fac1a0d3c7697a220de9adfe15de15c
1 /* real.c - software floating point emulation.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2002, 2003, 2004 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
12 version.
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
17 for more details.
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
22 02111-1307, USA. */
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "tree.h"
29 #include "toplev.h"
30 #include "real.h"
31 #include "tm_p.h"
33 /* The floating point model used internally is not exactly IEEE 754
34 compliant, and close to the description in the ISO C99 standard,
35 section 5.2.4.2.2 Characteristics of floating types.
37 Specifically
39 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
41 where
42 s = sign (+- 1)
43 b = base or radix, here always 2
44 e = exponent
45 p = precision (the number of base-b digits in the significand)
46 f_k = the digits of the significand.
48 We differ from typical IEEE 754 encodings in that the entire
49 significand is fractional. Normalized significands are in the
50 range [0.5, 1.0).
52 A requirement of the model is that P be larger than the largest
53 supported target floating-point type by at least 2 bits. This gives
54 us proper rounding when we truncate to the target type. In addition,
55 E must be large enough to hold the smallest supported denormal number
56 in a normalized form.
58 Both of these requirements are easily satisfied. The largest target
59 significand is 113 bits; we store at least 160. The smallest
60 denormal number fits in 17 exponent bits; we store 27.
62 Note that the decimal string conversion routines are sensitive to
63 rounding errors. Since the raw arithmetic routines do not themselves
64 have guard digits or rounding, the computation of 10**exp can
65 accumulate more than a few digits of error. The previous incarnation
66 of real.c successfully used a 144-bit fraction; given the current
67 layout of REAL_VALUE_TYPE we're forced to expand to at least 160 bits.
69 Target floating point models that use base 16 instead of base 2
70 (i.e. IBM 370), are handled during round_for_format, in which we
71 canonicalize the exponent to be a multiple of 4 (log2(16)), and
72 adjust the significand to match. */
75 /* Used to classify two numbers simultaneously. */
76 #define CLASS2(A, B) ((A) << 2 | (B))
78 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
79 #error "Some constant folding done by hand to avoid shift count warnings"
80 #endif
82 static void get_zero (REAL_VALUE_TYPE *, int);
83 static void get_canonical_qnan (REAL_VALUE_TYPE *, int);
84 static void get_canonical_snan (REAL_VALUE_TYPE *, int);
85 static void get_inf (REAL_VALUE_TYPE *, int);
86 static bool sticky_rshift_significand (REAL_VALUE_TYPE *,
87 const REAL_VALUE_TYPE *, unsigned int);
88 static void rshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
89 unsigned int);
90 static void lshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
91 unsigned int);
92 static void lshift_significand_1 (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
93 static bool add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *,
94 const REAL_VALUE_TYPE *);
95 static bool sub_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
96 const REAL_VALUE_TYPE *, int);
97 static void neg_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
98 static int cmp_significands (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
99 static int cmp_significand_0 (const REAL_VALUE_TYPE *);
100 static void set_significand_bit (REAL_VALUE_TYPE *, unsigned int);
101 static void clear_significand_bit (REAL_VALUE_TYPE *, unsigned int);
102 static bool test_significand_bit (REAL_VALUE_TYPE *, unsigned int);
103 static void clear_significand_below (REAL_VALUE_TYPE *, unsigned int);
104 static bool div_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
105 const REAL_VALUE_TYPE *);
106 static void normalize (REAL_VALUE_TYPE *);
108 static bool do_add (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
109 const REAL_VALUE_TYPE *, int);
110 static bool do_multiply (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
111 const REAL_VALUE_TYPE *);
112 static bool do_divide (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
113 const REAL_VALUE_TYPE *);
114 static int do_compare (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
115 static void do_fix_trunc (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
117 static unsigned long rtd_divmod (REAL_VALUE_TYPE *, REAL_VALUE_TYPE *);
119 static const REAL_VALUE_TYPE * ten_to_ptwo (int);
120 static const REAL_VALUE_TYPE * ten_to_mptwo (int);
121 static const REAL_VALUE_TYPE * real_digit (int);
122 static void times_pten (REAL_VALUE_TYPE *, int);
124 static void round_for_format (const struct real_format *, REAL_VALUE_TYPE *);
126 /* Initialize R with a positive zero. */
128 static inline void
129 get_zero (REAL_VALUE_TYPE *r, int sign)
131 memset (r, 0, sizeof (*r));
132 r->sign = sign;
135 /* Initialize R with the canonical quiet NaN. */
137 static inline void
138 get_canonical_qnan (REAL_VALUE_TYPE *r, int sign)
140 memset (r, 0, sizeof (*r));
141 r->cl = rvc_nan;
142 r->sign = sign;
143 r->canonical = 1;
146 static inline void
147 get_canonical_snan (REAL_VALUE_TYPE *r, int sign)
149 memset (r, 0, sizeof (*r));
150 r->cl = rvc_nan;
151 r->sign = sign;
152 r->signalling = 1;
153 r->canonical = 1;
156 static inline void
157 get_inf (REAL_VALUE_TYPE *r, int sign)
159 memset (r, 0, sizeof (*r));
160 r->cl = rvc_inf;
161 r->sign = sign;
165 /* Right-shift the significand of A by N bits; put the result in the
166 significand of R. If any one bits are shifted out, return true. */
168 static bool
169 sticky_rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
170 unsigned int n)
172 unsigned long sticky = 0;
173 unsigned int i, ofs = 0;
175 if (n >= HOST_BITS_PER_LONG)
177 for (i = 0, ofs = n / HOST_BITS_PER_LONG; i < ofs; ++i)
178 sticky |= a->sig[i];
179 n &= HOST_BITS_PER_LONG - 1;
182 if (n != 0)
184 sticky |= a->sig[ofs] & (((unsigned long)1 << n) - 1);
185 for (i = 0; i < SIGSZ; ++i)
187 r->sig[i]
188 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
189 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
190 << (HOST_BITS_PER_LONG - n)));
193 else
195 for (i = 0; ofs + i < SIGSZ; ++i)
196 r->sig[i] = a->sig[ofs + i];
197 for (; i < SIGSZ; ++i)
198 r->sig[i] = 0;
201 return sticky != 0;
204 /* Right-shift the significand of A by N bits; put the result in the
205 significand of R. */
207 static void
208 rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
209 unsigned int n)
211 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
213 n &= HOST_BITS_PER_LONG - 1;
214 if (n != 0)
216 for (i = 0; i < SIGSZ; ++i)
218 r->sig[i]
219 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
220 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
221 << (HOST_BITS_PER_LONG - n)));
224 else
226 for (i = 0; ofs + i < SIGSZ; ++i)
227 r->sig[i] = a->sig[ofs + i];
228 for (; i < SIGSZ; ++i)
229 r->sig[i] = 0;
233 /* Left-shift the significand of A by N bits; put the result in the
234 significand of R. */
236 static void
237 lshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
238 unsigned int n)
240 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
242 n &= HOST_BITS_PER_LONG - 1;
243 if (n == 0)
245 for (i = 0; ofs + i < SIGSZ; ++i)
246 r->sig[SIGSZ-1-i] = a->sig[SIGSZ-1-i-ofs];
247 for (; i < SIGSZ; ++i)
248 r->sig[SIGSZ-1-i] = 0;
250 else
251 for (i = 0; i < SIGSZ; ++i)
253 r->sig[SIGSZ-1-i]
254 = (((ofs + i >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs]) << n)
255 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs-1])
256 >> (HOST_BITS_PER_LONG - n)));
260 /* Likewise, but N is specialized to 1. */
262 static inline void
263 lshift_significand_1 (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
265 unsigned int i;
267 for (i = SIGSZ - 1; i > 0; --i)
268 r->sig[i] = (a->sig[i] << 1) | (a->sig[i-1] >> (HOST_BITS_PER_LONG - 1));
269 r->sig[0] = a->sig[0] << 1;
272 /* Add the significands of A and B, placing the result in R. Return
273 true if there was carry out of the most significant word. */
275 static inline bool
276 add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
277 const REAL_VALUE_TYPE *b)
279 bool carry = false;
280 int i;
282 for (i = 0; i < SIGSZ; ++i)
284 unsigned long ai = a->sig[i];
285 unsigned long ri = ai + b->sig[i];
287 if (carry)
289 carry = ri < ai;
290 carry |= ++ri == 0;
292 else
293 carry = ri < ai;
295 r->sig[i] = ri;
298 return carry;
301 /* Subtract the significands of A and B, placing the result in R. CARRY is
302 true if there's a borrow incoming to the least significant word.
303 Return true if there was borrow out of the most significant word. */
305 static inline bool
306 sub_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
307 const REAL_VALUE_TYPE *b, int carry)
309 int i;
311 for (i = 0; i < SIGSZ; ++i)
313 unsigned long ai = a->sig[i];
314 unsigned long ri = ai - b->sig[i];
316 if (carry)
318 carry = ri > ai;
319 carry |= ~--ri == 0;
321 else
322 carry = ri > ai;
324 r->sig[i] = ri;
327 return carry;
330 /* Negate the significand A, placing the result in R. */
332 static inline void
333 neg_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
335 bool carry = true;
336 int i;
338 for (i = 0; i < SIGSZ; ++i)
340 unsigned long ri, ai = a->sig[i];
342 if (carry)
344 if (ai)
346 ri = -ai;
347 carry = false;
349 else
350 ri = ai;
352 else
353 ri = ~ai;
355 r->sig[i] = ri;
359 /* Compare significands. Return tri-state vs zero. */
361 static inline int
362 cmp_significands (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
364 int i;
366 for (i = SIGSZ - 1; i >= 0; --i)
368 unsigned long ai = a->sig[i];
369 unsigned long bi = b->sig[i];
371 if (ai > bi)
372 return 1;
373 if (ai < bi)
374 return -1;
377 return 0;
380 /* Return true if A is nonzero. */
382 static inline int
383 cmp_significand_0 (const REAL_VALUE_TYPE *a)
385 int i;
387 for (i = SIGSZ - 1; i >= 0; --i)
388 if (a->sig[i])
389 return 1;
391 return 0;
394 /* Set bit N of the significand of R. */
396 static inline void
397 set_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
399 r->sig[n / HOST_BITS_PER_LONG]
400 |= (unsigned long)1 << (n % HOST_BITS_PER_LONG);
403 /* Clear bit N of the significand of R. */
405 static inline void
406 clear_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
408 r->sig[n / HOST_BITS_PER_LONG]
409 &= ~((unsigned long)1 << (n % HOST_BITS_PER_LONG));
412 /* Test bit N of the significand of R. */
414 static inline bool
415 test_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
417 /* ??? Compiler bug here if we return this expression directly.
418 The conversion to bool strips the "&1" and we wind up testing
419 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
420 int t = (r->sig[n / HOST_BITS_PER_LONG] >> (n % HOST_BITS_PER_LONG)) & 1;
421 return t;
424 /* Clear bits 0..N-1 of the significand of R. */
426 static void
427 clear_significand_below (REAL_VALUE_TYPE *r, unsigned int n)
429 int i, w = n / HOST_BITS_PER_LONG;
431 for (i = 0; i < w; ++i)
432 r->sig[i] = 0;
434 r->sig[w] &= ~(((unsigned long)1 << (n % HOST_BITS_PER_LONG)) - 1);
437 /* Divide the significands of A and B, placing the result in R. Return
438 true if the division was inexact. */
440 static inline bool
441 div_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
442 const REAL_VALUE_TYPE *b)
444 REAL_VALUE_TYPE u;
445 int i, bit = SIGNIFICAND_BITS - 1;
446 unsigned long msb, inexact;
448 u = *a;
449 memset (r->sig, 0, sizeof (r->sig));
451 msb = 0;
452 goto start;
455 msb = u.sig[SIGSZ-1] & SIG_MSB;
456 lshift_significand_1 (&u, &u);
457 start:
458 if (msb || cmp_significands (&u, b) >= 0)
460 sub_significands (&u, &u, b, 0);
461 set_significand_bit (r, bit);
464 while (--bit >= 0);
466 for (i = 0, inexact = 0; i < SIGSZ; i++)
467 inexact |= u.sig[i];
469 return inexact != 0;
472 /* Adjust the exponent and significand of R such that the most
473 significant bit is set. We underflow to zero and overflow to
474 infinity here, without denormals. (The intermediate representation
475 exponent is large enough to handle target denormals normalized.) */
477 static void
478 normalize (REAL_VALUE_TYPE *r)
480 int shift = 0, exp;
481 int i, j;
483 /* Find the first word that is nonzero. */
484 for (i = SIGSZ - 1; i >= 0; i--)
485 if (r->sig[i] == 0)
486 shift += HOST_BITS_PER_LONG;
487 else
488 break;
490 /* Zero significand flushes to zero. */
491 if (i < 0)
493 r->cl = rvc_zero;
494 SET_REAL_EXP (r, 0);
495 return;
498 /* Find the first bit that is nonzero. */
499 for (j = 0; ; j++)
500 if (r->sig[i] & ((unsigned long)1 << (HOST_BITS_PER_LONG - 1 - j)))
501 break;
502 shift += j;
504 if (shift > 0)
506 exp = REAL_EXP (r) - shift;
507 if (exp > MAX_EXP)
508 get_inf (r, r->sign);
509 else if (exp < -MAX_EXP)
510 get_zero (r, r->sign);
511 else
513 SET_REAL_EXP (r, exp);
514 lshift_significand (r, r, shift);
519 /* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the
520 result may be inexact due to a loss of precision. */
522 static bool
523 do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
524 const REAL_VALUE_TYPE *b, int subtract_p)
526 int dexp, sign, exp;
527 REAL_VALUE_TYPE t;
528 bool inexact = false;
530 /* Determine if we need to add or subtract. */
531 sign = a->sign;
532 subtract_p = (sign ^ b->sign) ^ subtract_p;
534 switch (CLASS2 (a->cl, b->cl))
536 case CLASS2 (rvc_zero, rvc_zero):
537 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
538 get_zero (r, sign & !subtract_p);
539 return false;
541 case CLASS2 (rvc_zero, rvc_normal):
542 case CLASS2 (rvc_zero, rvc_inf):
543 case CLASS2 (rvc_zero, rvc_nan):
544 /* 0 + ANY = ANY. */
545 case CLASS2 (rvc_normal, rvc_nan):
546 case CLASS2 (rvc_inf, rvc_nan):
547 case CLASS2 (rvc_nan, rvc_nan):
548 /* ANY + NaN = NaN. */
549 case CLASS2 (rvc_normal, rvc_inf):
550 /* R + Inf = Inf. */
551 *r = *b;
552 r->sign = sign ^ subtract_p;
553 return false;
555 case CLASS2 (rvc_normal, rvc_zero):
556 case CLASS2 (rvc_inf, rvc_zero):
557 case CLASS2 (rvc_nan, rvc_zero):
558 /* ANY + 0 = ANY. */
559 case CLASS2 (rvc_nan, rvc_normal):
560 case CLASS2 (rvc_nan, rvc_inf):
561 /* NaN + ANY = NaN. */
562 case CLASS2 (rvc_inf, rvc_normal):
563 /* Inf + R = Inf. */
564 *r = *a;
565 return false;
567 case CLASS2 (rvc_inf, rvc_inf):
568 if (subtract_p)
569 /* Inf - Inf = NaN. */
570 get_canonical_qnan (r, 0);
571 else
572 /* Inf + Inf = Inf. */
573 *r = *a;
574 return false;
576 case CLASS2 (rvc_normal, rvc_normal):
577 break;
579 default:
580 gcc_unreachable ();
583 /* Swap the arguments such that A has the larger exponent. */
584 dexp = REAL_EXP (a) - REAL_EXP (b);
585 if (dexp < 0)
587 const REAL_VALUE_TYPE *t;
588 t = a, a = b, b = t;
589 dexp = -dexp;
590 sign ^= subtract_p;
592 exp = REAL_EXP (a);
594 /* If the exponents are not identical, we need to shift the
595 significand of B down. */
596 if (dexp > 0)
598 /* If the exponents are too far apart, the significands
599 do not overlap, which makes the subtraction a noop. */
600 if (dexp >= SIGNIFICAND_BITS)
602 *r = *a;
603 r->sign = sign;
604 return true;
607 inexact |= sticky_rshift_significand (&t, b, dexp);
608 b = &t;
611 if (subtract_p)
613 if (sub_significands (r, a, b, inexact))
615 /* We got a borrow out of the subtraction. That means that
616 A and B had the same exponent, and B had the larger
617 significand. We need to swap the sign and negate the
618 significand. */
619 sign ^= 1;
620 neg_significand (r, r);
623 else
625 if (add_significands (r, a, b))
627 /* We got carry out of the addition. This means we need to
628 shift the significand back down one bit and increase the
629 exponent. */
630 inexact |= sticky_rshift_significand (r, r, 1);
631 r->sig[SIGSZ-1] |= SIG_MSB;
632 if (++exp > MAX_EXP)
634 get_inf (r, sign);
635 return true;
640 r->cl = rvc_normal;
641 r->sign = sign;
642 SET_REAL_EXP (r, exp);
644 /* Re-normalize the result. */
645 normalize (r);
647 /* Special case: if the subtraction results in zero, the result
648 is positive. */
649 if (r->cl == rvc_zero)
650 r->sign = 0;
651 else
652 r->sig[0] |= inexact;
654 return inexact;
657 /* Calculate R = A * B. Return true if the result may be inexact. */
659 static bool
660 do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
661 const REAL_VALUE_TYPE *b)
663 REAL_VALUE_TYPE u, t, *rr;
664 unsigned int i, j, k;
665 int sign = a->sign ^ b->sign;
666 bool inexact = false;
668 switch (CLASS2 (a->cl, b->cl))
670 case CLASS2 (rvc_zero, rvc_zero):
671 case CLASS2 (rvc_zero, rvc_normal):
672 case CLASS2 (rvc_normal, rvc_zero):
673 /* +-0 * ANY = 0 with appropriate sign. */
674 get_zero (r, sign);
675 return false;
677 case CLASS2 (rvc_zero, rvc_nan):
678 case CLASS2 (rvc_normal, rvc_nan):
679 case CLASS2 (rvc_inf, rvc_nan):
680 case CLASS2 (rvc_nan, rvc_nan):
681 /* ANY * NaN = NaN. */
682 *r = *b;
683 r->sign = sign;
684 return false;
686 case CLASS2 (rvc_nan, rvc_zero):
687 case CLASS2 (rvc_nan, rvc_normal):
688 case CLASS2 (rvc_nan, rvc_inf):
689 /* NaN * ANY = NaN. */
690 *r = *a;
691 r->sign = sign;
692 return false;
694 case CLASS2 (rvc_zero, rvc_inf):
695 case CLASS2 (rvc_inf, rvc_zero):
696 /* 0 * Inf = NaN */
697 get_canonical_qnan (r, sign);
698 return false;
700 case CLASS2 (rvc_inf, rvc_inf):
701 case CLASS2 (rvc_normal, rvc_inf):
702 case CLASS2 (rvc_inf, rvc_normal):
703 /* Inf * Inf = Inf, R * Inf = Inf */
704 get_inf (r, sign);
705 return false;
707 case CLASS2 (rvc_normal, rvc_normal):
708 break;
710 default:
711 gcc_unreachable ();
714 if (r == a || r == b)
715 rr = &t;
716 else
717 rr = r;
718 get_zero (rr, 0);
720 /* Collect all the partial products. Since we don't have sure access
721 to a widening multiply, we split each long into two half-words.
723 Consider the long-hand form of a four half-word multiplication:
725 A B C D
726 * E F G H
727 --------------
728 DE DF DG DH
729 CE CF CG CH
730 BE BF BG BH
731 AE AF AG AH
733 We construct partial products of the widened half-word products
734 that are known to not overlap, e.g. DF+DH. Each such partial
735 product is given its proper exponent, which allows us to sum them
736 and obtain the finished product. */
738 for (i = 0; i < SIGSZ * 2; ++i)
740 unsigned long ai = a->sig[i / 2];
741 if (i & 1)
742 ai >>= HOST_BITS_PER_LONG / 2;
743 else
744 ai &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
746 if (ai == 0)
747 continue;
749 for (j = 0; j < 2; ++j)
751 int exp = (REAL_EXP (a) - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2)
752 + (REAL_EXP (b) - (1-j)*(HOST_BITS_PER_LONG/2)));
754 if (exp > MAX_EXP)
756 get_inf (r, sign);
757 return true;
759 if (exp < -MAX_EXP)
761 /* Would underflow to zero, which we shouldn't bother adding. */
762 inexact = true;
763 continue;
766 memset (&u, 0, sizeof (u));
767 u.cl = rvc_normal;
768 SET_REAL_EXP (&u, exp);
770 for (k = j; k < SIGSZ * 2; k += 2)
772 unsigned long bi = b->sig[k / 2];
773 if (k & 1)
774 bi >>= HOST_BITS_PER_LONG / 2;
775 else
776 bi &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
778 u.sig[k / 2] = ai * bi;
781 normalize (&u);
782 inexact |= do_add (rr, rr, &u, 0);
786 rr->sign = sign;
787 if (rr != r)
788 *r = t;
790 return inexact;
793 /* Calculate R = A / B. Return true if the result may be inexact. */
795 static bool
796 do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
797 const REAL_VALUE_TYPE *b)
799 int exp, sign = a->sign ^ b->sign;
800 REAL_VALUE_TYPE t, *rr;
801 bool inexact;
803 switch (CLASS2 (a->cl, b->cl))
805 case CLASS2 (rvc_zero, rvc_zero):
806 /* 0 / 0 = NaN. */
807 case CLASS2 (rvc_inf, rvc_inf):
808 /* Inf / Inf = NaN. */
809 get_canonical_qnan (r, sign);
810 return false;
812 case CLASS2 (rvc_zero, rvc_normal):
813 case CLASS2 (rvc_zero, rvc_inf):
814 /* 0 / ANY = 0. */
815 case CLASS2 (rvc_normal, rvc_inf):
816 /* R / Inf = 0. */
817 get_zero (r, sign);
818 return false;
820 case CLASS2 (rvc_normal, rvc_zero):
821 /* R / 0 = Inf. */
822 case CLASS2 (rvc_inf, rvc_zero):
823 /* Inf / 0 = Inf. */
824 get_inf (r, sign);
825 return false;
827 case CLASS2 (rvc_zero, rvc_nan):
828 case CLASS2 (rvc_normal, rvc_nan):
829 case CLASS2 (rvc_inf, rvc_nan):
830 case CLASS2 (rvc_nan, rvc_nan):
831 /* ANY / NaN = NaN. */
832 *r = *b;
833 r->sign = sign;
834 return false;
836 case CLASS2 (rvc_nan, rvc_zero):
837 case CLASS2 (rvc_nan, rvc_normal):
838 case CLASS2 (rvc_nan, rvc_inf):
839 /* NaN / ANY = NaN. */
840 *r = *a;
841 r->sign = sign;
842 return false;
844 case CLASS2 (rvc_inf, rvc_normal):
845 /* Inf / R = Inf. */
846 get_inf (r, sign);
847 return false;
849 case CLASS2 (rvc_normal, rvc_normal):
850 break;
852 default:
853 gcc_unreachable ();
856 if (r == a || r == b)
857 rr = &t;
858 else
859 rr = r;
861 /* Make sure all fields in the result are initialized. */
862 get_zero (rr, 0);
863 rr->cl = rvc_normal;
864 rr->sign = sign;
866 exp = REAL_EXP (a) - REAL_EXP (b) + 1;
867 if (exp > MAX_EXP)
869 get_inf (r, sign);
870 return true;
872 if (exp < -MAX_EXP)
874 get_zero (r, sign);
875 return true;
877 SET_REAL_EXP (rr, exp);
879 inexact = div_significands (rr, a, b);
881 /* Re-normalize the result. */
882 normalize (rr);
883 rr->sig[0] |= inexact;
885 if (rr != r)
886 *r = t;
888 return inexact;
891 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
892 one of the two operands is a NaN. */
894 static int
895 do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
896 int nan_result)
898 int ret;
900 switch (CLASS2 (a->cl, b->cl))
902 case CLASS2 (rvc_zero, rvc_zero):
903 /* Sign of zero doesn't matter for compares. */
904 return 0;
906 case CLASS2 (rvc_inf, rvc_zero):
907 case CLASS2 (rvc_inf, rvc_normal):
908 case CLASS2 (rvc_normal, rvc_zero):
909 return (a->sign ? -1 : 1);
911 case CLASS2 (rvc_inf, rvc_inf):
912 return -a->sign - -b->sign;
914 case CLASS2 (rvc_zero, rvc_normal):
915 case CLASS2 (rvc_zero, rvc_inf):
916 case CLASS2 (rvc_normal, rvc_inf):
917 return (b->sign ? 1 : -1);
919 case CLASS2 (rvc_zero, rvc_nan):
920 case CLASS2 (rvc_normal, rvc_nan):
921 case CLASS2 (rvc_inf, rvc_nan):
922 case CLASS2 (rvc_nan, rvc_nan):
923 case CLASS2 (rvc_nan, rvc_zero):
924 case CLASS2 (rvc_nan, rvc_normal):
925 case CLASS2 (rvc_nan, rvc_inf):
926 return nan_result;
928 case CLASS2 (rvc_normal, rvc_normal):
929 break;
931 default:
932 gcc_unreachable ();
935 if (a->sign != b->sign)
936 return -a->sign - -b->sign;
938 if (REAL_EXP (a) > REAL_EXP (b))
939 ret = 1;
940 else if (REAL_EXP (a) < REAL_EXP (b))
941 ret = -1;
942 else
943 ret = cmp_significands (a, b);
945 return (a->sign ? -ret : ret);
948 /* Return A truncated to an integral value toward zero. */
950 static void
951 do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
953 *r = *a;
955 switch (r->cl)
957 case rvc_zero:
958 case rvc_inf:
959 case rvc_nan:
960 break;
962 case rvc_normal:
963 if (REAL_EXP (r) <= 0)
964 get_zero (r, r->sign);
965 else if (REAL_EXP (r) < SIGNIFICAND_BITS)
966 clear_significand_below (r, SIGNIFICAND_BITS - REAL_EXP (r));
967 break;
969 default:
970 gcc_unreachable ();
974 /* Perform the binary or unary operation described by CODE.
975 For a unary operation, leave OP1 NULL. */
977 void
978 real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
979 const REAL_VALUE_TYPE *op1)
981 enum tree_code code = icode;
983 switch (code)
985 case PLUS_EXPR:
986 do_add (r, op0, op1, 0);
987 break;
989 case MINUS_EXPR:
990 do_add (r, op0, op1, 1);
991 break;
993 case MULT_EXPR:
994 do_multiply (r, op0, op1);
995 break;
997 case RDIV_EXPR:
998 do_divide (r, op0, op1);
999 break;
1001 case MIN_EXPR:
1002 if (op1->cl == rvc_nan)
1003 *r = *op1;
1004 else if (do_compare (op0, op1, -1) < 0)
1005 *r = *op0;
1006 else
1007 *r = *op1;
1008 break;
1010 case MAX_EXPR:
1011 if (op1->cl == rvc_nan)
1012 *r = *op1;
1013 else if (do_compare (op0, op1, 1) < 0)
1014 *r = *op1;
1015 else
1016 *r = *op0;
1017 break;
1019 case NEGATE_EXPR:
1020 *r = *op0;
1021 r->sign ^= 1;
1022 break;
1024 case ABS_EXPR:
1025 *r = *op0;
1026 r->sign = 0;
1027 break;
1029 case FIX_TRUNC_EXPR:
1030 do_fix_trunc (r, op0);
1031 break;
1033 default:
1034 gcc_unreachable ();
1038 /* Legacy. Similar, but return the result directly. */
1040 REAL_VALUE_TYPE
1041 real_arithmetic2 (int icode, const REAL_VALUE_TYPE *op0,
1042 const REAL_VALUE_TYPE *op1)
1044 REAL_VALUE_TYPE r;
1045 real_arithmetic (&r, icode, op0, op1);
1046 return r;
1049 bool
1050 real_compare (int icode, const REAL_VALUE_TYPE *op0,
1051 const REAL_VALUE_TYPE *op1)
1053 enum tree_code code = icode;
1055 switch (code)
1057 case LT_EXPR:
1058 return do_compare (op0, op1, 1) < 0;
1059 case LE_EXPR:
1060 return do_compare (op0, op1, 1) <= 0;
1061 case GT_EXPR:
1062 return do_compare (op0, op1, -1) > 0;
1063 case GE_EXPR:
1064 return do_compare (op0, op1, -1) >= 0;
1065 case EQ_EXPR:
1066 return do_compare (op0, op1, -1) == 0;
1067 case NE_EXPR:
1068 return do_compare (op0, op1, -1) != 0;
1069 case UNORDERED_EXPR:
1070 return op0->cl == rvc_nan || op1->cl == rvc_nan;
1071 case ORDERED_EXPR:
1072 return op0->cl != rvc_nan && op1->cl != rvc_nan;
1073 case UNLT_EXPR:
1074 return do_compare (op0, op1, -1) < 0;
1075 case UNLE_EXPR:
1076 return do_compare (op0, op1, -1) <= 0;
1077 case UNGT_EXPR:
1078 return do_compare (op0, op1, 1) > 0;
1079 case UNGE_EXPR:
1080 return do_compare (op0, op1, 1) >= 0;
1081 case UNEQ_EXPR:
1082 return do_compare (op0, op1, 0) == 0;
1083 case LTGT_EXPR:
1084 return do_compare (op0, op1, 0) != 0;
1086 default:
1087 gcc_unreachable ();
1091 /* Return floor log2(R). */
1094 real_exponent (const REAL_VALUE_TYPE *r)
1096 switch (r->cl)
1098 case rvc_zero:
1099 return 0;
1100 case rvc_inf:
1101 case rvc_nan:
1102 return (unsigned int)-1 >> 1;
1103 case rvc_normal:
1104 return REAL_EXP (r);
1105 default:
1106 gcc_unreachable ();
1110 /* R = OP0 * 2**EXP. */
1112 void
1113 real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
1115 *r = *op0;
1116 switch (r->cl)
1118 case rvc_zero:
1119 case rvc_inf:
1120 case rvc_nan:
1121 break;
1123 case rvc_normal:
1124 exp += REAL_EXP (op0);
1125 if (exp > MAX_EXP)
1126 get_inf (r, r->sign);
1127 else if (exp < -MAX_EXP)
1128 get_zero (r, r->sign);
1129 else
1130 SET_REAL_EXP (r, exp);
1131 break;
1133 default:
1134 gcc_unreachable ();
1138 /* Determine whether a floating-point value X is infinite. */
1140 bool
1141 real_isinf (const REAL_VALUE_TYPE *r)
1143 return (r->cl == rvc_inf);
1146 /* Determine whether a floating-point value X is a NaN. */
1148 bool
1149 real_isnan (const REAL_VALUE_TYPE *r)
1151 return (r->cl == rvc_nan);
1154 /* Determine whether a floating-point value X is negative. */
1156 bool
1157 real_isneg (const REAL_VALUE_TYPE *r)
1159 return r->sign;
1162 /* Determine whether a floating-point value X is minus zero. */
1164 bool
1165 real_isnegzero (const REAL_VALUE_TYPE *r)
1167 return r->sign && r->cl == rvc_zero;
1170 /* Compare two floating-point objects for bitwise identity. */
1172 bool
1173 real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
1175 int i;
1177 if (a->cl != b->cl)
1178 return false;
1179 if (a->sign != b->sign)
1180 return false;
1182 switch (a->cl)
1184 case rvc_zero:
1185 case rvc_inf:
1186 return true;
1188 case rvc_normal:
1189 if (REAL_EXP (a) != REAL_EXP (b))
1190 return false;
1191 break;
1193 case rvc_nan:
1194 if (a->signalling != b->signalling)
1195 return false;
1196 /* The significand is ignored for canonical NaNs. */
1197 if (a->canonical || b->canonical)
1198 return a->canonical == b->canonical;
1199 break;
1201 default:
1202 gcc_unreachable ();
1205 for (i = 0; i < SIGSZ; ++i)
1206 if (a->sig[i] != b->sig[i])
1207 return false;
1209 return true;
1212 /* Try to change R into its exact multiplicative inverse in machine
1213 mode MODE. Return true if successful. */
1215 bool
1216 exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
1218 const REAL_VALUE_TYPE *one = real_digit (1);
1219 REAL_VALUE_TYPE u;
1220 int i;
1222 if (r->cl != rvc_normal)
1223 return false;
1225 /* Check for a power of two: all significand bits zero except the MSB. */
1226 for (i = 0; i < SIGSZ-1; ++i)
1227 if (r->sig[i] != 0)
1228 return false;
1229 if (r->sig[SIGSZ-1] != SIG_MSB)
1230 return false;
1232 /* Find the inverse and truncate to the required mode. */
1233 do_divide (&u, one, r);
1234 real_convert (&u, mode, &u);
1236 /* The rounding may have overflowed. */
1237 if (u.cl != rvc_normal)
1238 return false;
1239 for (i = 0; i < SIGSZ-1; ++i)
1240 if (u.sig[i] != 0)
1241 return false;
1242 if (u.sig[SIGSZ-1] != SIG_MSB)
1243 return false;
1245 *r = u;
1246 return true;
1249 /* Render R as an integer. */
1251 HOST_WIDE_INT
1252 real_to_integer (const REAL_VALUE_TYPE *r)
1254 unsigned HOST_WIDE_INT i;
1256 switch (r->cl)
1258 case rvc_zero:
1259 underflow:
1260 return 0;
1262 case rvc_inf:
1263 case rvc_nan:
1264 overflow:
1265 i = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1266 if (!r->sign)
1267 i--;
1268 return i;
1270 case rvc_normal:
1271 if (REAL_EXP (r) <= 0)
1272 goto underflow;
1273 /* Only force overflow for unsigned overflow. Signed overflow is
1274 undefined, so it doesn't matter what we return, and some callers
1275 expect to be able to use this routine for both signed and
1276 unsigned conversions. */
1277 if (REAL_EXP (r) > HOST_BITS_PER_WIDE_INT)
1278 goto overflow;
1280 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1281 i = r->sig[SIGSZ-1];
1282 else
1284 gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
1285 i = r->sig[SIGSZ-1];
1286 i = i << (HOST_BITS_PER_LONG - 1) << 1;
1287 i |= r->sig[SIGSZ-2];
1290 i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
1292 if (r->sign)
1293 i = -i;
1294 return i;
1296 default:
1297 gcc_unreachable ();
1301 /* Likewise, but to an integer pair, HI+LOW. */
1303 void
1304 real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
1305 const REAL_VALUE_TYPE *r)
1307 REAL_VALUE_TYPE t;
1308 HOST_WIDE_INT low, high;
1309 int exp;
1311 switch (r->cl)
1313 case rvc_zero:
1314 underflow:
1315 low = high = 0;
1316 break;
1318 case rvc_inf:
1319 case rvc_nan:
1320 overflow:
1321 high = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1322 if (r->sign)
1323 low = 0;
1324 else
1326 high--;
1327 low = -1;
1329 break;
1331 case rvc_normal:
1332 exp = REAL_EXP (r);
1333 if (exp <= 0)
1334 goto underflow;
1335 /* Only force overflow for unsigned overflow. Signed overflow is
1336 undefined, so it doesn't matter what we return, and some callers
1337 expect to be able to use this routine for both signed and
1338 unsigned conversions. */
1339 if (exp > 2*HOST_BITS_PER_WIDE_INT)
1340 goto overflow;
1342 rshift_significand (&t, r, 2*HOST_BITS_PER_WIDE_INT - exp);
1343 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1345 high = t.sig[SIGSZ-1];
1346 low = t.sig[SIGSZ-2];
1348 else
1350 gcc_assert (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG);
1351 high = t.sig[SIGSZ-1];
1352 high = high << (HOST_BITS_PER_LONG - 1) << 1;
1353 high |= t.sig[SIGSZ-2];
1355 low = t.sig[SIGSZ-3];
1356 low = low << (HOST_BITS_PER_LONG - 1) << 1;
1357 low |= t.sig[SIGSZ-4];
1360 if (r->sign)
1362 if (low == 0)
1363 high = -high;
1364 else
1365 low = -low, high = ~high;
1367 break;
1369 default:
1370 gcc_unreachable ();
1373 *plow = low;
1374 *phigh = high;
1377 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1378 of NUM / DEN. Return the quotient and place the remainder in NUM.
1379 It is expected that NUM / DEN are close enough that the quotient is
1380 small. */
1382 static unsigned long
1383 rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den)
1385 unsigned long q, msb;
1386 int expn = REAL_EXP (num), expd = REAL_EXP (den);
1388 if (expn < expd)
1389 return 0;
1391 q = msb = 0;
1392 goto start;
1395 msb = num->sig[SIGSZ-1] & SIG_MSB;
1396 q <<= 1;
1397 lshift_significand_1 (num, num);
1398 start:
1399 if (msb || cmp_significands (num, den) >= 0)
1401 sub_significands (num, num, den, 0);
1402 q |= 1;
1405 while (--expn >= expd);
1407 SET_REAL_EXP (num, expd);
1408 normalize (num);
1410 return q;
1413 /* Render R as a decimal floating point constant. Emit DIGITS significant
1414 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1415 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1416 zeros. */
1418 #define M_LOG10_2 0.30102999566398119521
1420 void
1421 real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
1422 size_t digits, int crop_trailing_zeros)
1424 const REAL_VALUE_TYPE *one, *ten;
1425 REAL_VALUE_TYPE r, pten, u, v;
1426 int dec_exp, cmp_one, digit;
1427 size_t max_digits;
1428 char *p, *first, *last;
1429 bool sign;
1431 r = *r_orig;
1432 switch (r.cl)
1434 case rvc_zero:
1435 strcpy (str, (r.sign ? "-0.0" : "0.0"));
1436 return;
1437 case rvc_normal:
1438 break;
1439 case rvc_inf:
1440 strcpy (str, (r.sign ? "-Inf" : "+Inf"));
1441 return;
1442 case rvc_nan:
1443 /* ??? Print the significand as well, if not canonical? */
1444 strcpy (str, (r.sign ? "-NaN" : "+NaN"));
1445 return;
1446 default:
1447 gcc_unreachable ();
1450 /* Bound the number of digits printed by the size of the representation. */
1451 max_digits = SIGNIFICAND_BITS * M_LOG10_2;
1452 if (digits == 0 || digits > max_digits)
1453 digits = max_digits;
1455 /* Estimate the decimal exponent, and compute the length of the string it
1456 will print as. Be conservative and add one to account for possible
1457 overflow or rounding error. */
1458 dec_exp = REAL_EXP (&r) * M_LOG10_2;
1459 for (max_digits = 1; dec_exp ; max_digits++)
1460 dec_exp /= 10;
1462 /* Bound the number of digits printed by the size of the output buffer. */
1463 max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
1464 gcc_assert (max_digits <= buf_size);
1465 if (digits > max_digits)
1466 digits = max_digits;
1468 one = real_digit (1);
1469 ten = ten_to_ptwo (0);
1471 sign = r.sign;
1472 r.sign = 0;
1474 dec_exp = 0;
1475 pten = *one;
1477 cmp_one = do_compare (&r, one, 0);
1478 if (cmp_one > 0)
1480 int m;
1482 /* Number is greater than one. Convert significand to an integer
1483 and strip trailing decimal zeros. */
1485 u = r;
1486 SET_REAL_EXP (&u, SIGNIFICAND_BITS - 1);
1488 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1489 m = floor_log2 (max_digits);
1491 /* Iterate over the bits of the possible powers of 10 that might
1492 be present in U and eliminate them. That is, if we find that
1493 10**2**M divides U evenly, keep the division and increase
1494 DEC_EXP by 2**M. */
1497 REAL_VALUE_TYPE t;
1499 do_divide (&t, &u, ten_to_ptwo (m));
1500 do_fix_trunc (&v, &t);
1501 if (cmp_significands (&v, &t) == 0)
1503 u = t;
1504 dec_exp += 1 << m;
1507 while (--m >= 0);
1509 /* Revert the scaling to integer that we performed earlier. */
1510 SET_REAL_EXP (&u, REAL_EXP (&u) + REAL_EXP (&r)
1511 - (SIGNIFICAND_BITS - 1));
1512 r = u;
1514 /* Find power of 10. Do this by dividing out 10**2**M when
1515 this is larger than the current remainder. Fill PTEN with
1516 the power of 10 that we compute. */
1517 if (REAL_EXP (&r) > 0)
1519 m = floor_log2 ((int)(REAL_EXP (&r) * M_LOG10_2)) + 1;
1522 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1523 if (do_compare (&u, ptentwo, 0) >= 0)
1525 do_divide (&u, &u, ptentwo);
1526 do_multiply (&pten, &pten, ptentwo);
1527 dec_exp += 1 << m;
1530 while (--m >= 0);
1532 else
1533 /* We managed to divide off enough tens in the above reduction
1534 loop that we've now got a negative exponent. Fall into the
1535 less-than-one code to compute the proper value for PTEN. */
1536 cmp_one = -1;
1538 if (cmp_one < 0)
1540 int m;
1542 /* Number is less than one. Pad significand with leading
1543 decimal zeros. */
1545 v = r;
1546 while (1)
1548 /* Stop if we'd shift bits off the bottom. */
1549 if (v.sig[0] & 7)
1550 break;
1552 do_multiply (&u, &v, ten);
1554 /* Stop if we're now >= 1. */
1555 if (REAL_EXP (&u) > 0)
1556 break;
1558 v = u;
1559 dec_exp -= 1;
1561 r = v;
1563 /* Find power of 10. Do this by multiplying in P=10**2**M when
1564 the current remainder is smaller than 1/P. Fill PTEN with the
1565 power of 10 that we compute. */
1566 m = floor_log2 ((int)(-REAL_EXP (&r) * M_LOG10_2)) + 1;
1569 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1570 const REAL_VALUE_TYPE *ptenmtwo = ten_to_mptwo (m);
1572 if (do_compare (&v, ptenmtwo, 0) <= 0)
1574 do_multiply (&v, &v, ptentwo);
1575 do_multiply (&pten, &pten, ptentwo);
1576 dec_exp -= 1 << m;
1579 while (--m >= 0);
1581 /* Invert the positive power of 10 that we've collected so far. */
1582 do_divide (&pten, one, &pten);
1585 p = str;
1586 if (sign)
1587 *p++ = '-';
1588 first = p++;
1590 /* At this point, PTEN should contain the nearest power of 10 smaller
1591 than R, such that this division produces the first digit.
1593 Using a divide-step primitive that returns the complete integral
1594 remainder avoids the rounding error that would be produced if
1595 we were to use do_divide here and then simply multiply by 10 for
1596 each subsequent digit. */
1598 digit = rtd_divmod (&r, &pten);
1600 /* Be prepared for error in that division via underflow ... */
1601 if (digit == 0 && cmp_significand_0 (&r))
1603 /* Multiply by 10 and try again. */
1604 do_multiply (&r, &r, ten);
1605 digit = rtd_divmod (&r, &pten);
1606 dec_exp -= 1;
1607 gcc_assert (digit != 0);
1610 /* ... or overflow. */
1611 if (digit == 10)
1613 *p++ = '1';
1614 if (--digits > 0)
1615 *p++ = '0';
1616 dec_exp += 1;
1618 else
1620 gcc_assert (digit <= 10);
1621 *p++ = digit + '0';
1624 /* Generate subsequent digits. */
1625 while (--digits > 0)
1627 do_multiply (&r, &r, ten);
1628 digit = rtd_divmod (&r, &pten);
1629 *p++ = digit + '0';
1631 last = p;
1633 /* Generate one more digit with which to do rounding. */
1634 do_multiply (&r, &r, ten);
1635 digit = rtd_divmod (&r, &pten);
1637 /* Round the result. */
1638 if (digit == 5)
1640 /* Round to nearest. If R is nonzero there are additional
1641 nonzero digits to be extracted. */
1642 if (cmp_significand_0 (&r))
1643 digit++;
1644 /* Round to even. */
1645 else if ((p[-1] - '0') & 1)
1646 digit++;
1648 if (digit > 5)
1650 while (p > first)
1652 digit = *--p;
1653 if (digit == '9')
1654 *p = '0';
1655 else
1657 *p = digit + 1;
1658 break;
1662 /* Carry out of the first digit. This means we had all 9's and
1663 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1664 if (p == first)
1666 first[1] = '1';
1667 dec_exp++;
1671 /* Insert the decimal point. */
1672 first[0] = first[1];
1673 first[1] = '.';
1675 /* If requested, drop trailing zeros. Never crop past "1.0". */
1676 if (crop_trailing_zeros)
1677 while (last > first + 3 && last[-1] == '0')
1678 last--;
1680 /* Append the exponent. */
1681 sprintf (last, "e%+d", dec_exp);
1684 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1685 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1686 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1687 strip trailing zeros. */
1689 void
1690 real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
1691 size_t digits, int crop_trailing_zeros)
1693 int i, j, exp = REAL_EXP (r);
1694 char *p, *first;
1695 char exp_buf[16];
1696 size_t max_digits;
1698 switch (r->cl)
1700 case rvc_zero:
1701 exp = 0;
1702 break;
1703 case rvc_normal:
1704 break;
1705 case rvc_inf:
1706 strcpy (str, (r->sign ? "-Inf" : "+Inf"));
1707 return;
1708 case rvc_nan:
1709 /* ??? Print the significand as well, if not canonical? */
1710 strcpy (str, (r->sign ? "-NaN" : "+NaN"));
1711 return;
1712 default:
1713 gcc_unreachable ();
1716 if (digits == 0)
1717 digits = SIGNIFICAND_BITS / 4;
1719 /* Bound the number of digits printed by the size of the output buffer. */
1721 sprintf (exp_buf, "p%+d", exp);
1722 max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1;
1723 gcc_assert (max_digits <= buf_size);
1724 if (digits > max_digits)
1725 digits = max_digits;
1727 p = str;
1728 if (r->sign)
1729 *p++ = '-';
1730 *p++ = '0';
1731 *p++ = 'x';
1732 *p++ = '0';
1733 *p++ = '.';
1734 first = p;
1736 for (i = SIGSZ - 1; i >= 0; --i)
1737 for (j = HOST_BITS_PER_LONG - 4; j >= 0; j -= 4)
1739 *p++ = "0123456789abcdef"[(r->sig[i] >> j) & 15];
1740 if (--digits == 0)
1741 goto out;
1744 out:
1745 if (crop_trailing_zeros)
1746 while (p > first + 1 && p[-1] == '0')
1747 p--;
1749 sprintf (p, "p%+d", exp);
1752 /* Initialize R from a decimal or hexadecimal string. The string is
1753 assumed to have been syntax checked already. */
1755 void
1756 real_from_string (REAL_VALUE_TYPE *r, const char *str)
1758 int exp = 0;
1759 bool sign = false;
1761 get_zero (r, 0);
1763 if (*str == '-')
1765 sign = true;
1766 str++;
1768 else if (*str == '+')
1769 str++;
1771 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
1773 /* Hexadecimal floating point. */
1774 int pos = SIGNIFICAND_BITS - 4, d;
1776 str += 2;
1778 while (*str == '0')
1779 str++;
1780 while (1)
1782 d = hex_value (*str);
1783 if (d == _hex_bad)
1784 break;
1785 if (pos >= 0)
1787 r->sig[pos / HOST_BITS_PER_LONG]
1788 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1789 pos -= 4;
1791 exp += 4;
1792 str++;
1794 if (*str == '.')
1796 str++;
1797 if (pos == SIGNIFICAND_BITS - 4)
1799 while (*str == '0')
1800 str++, exp -= 4;
1802 while (1)
1804 d = hex_value (*str);
1805 if (d == _hex_bad)
1806 break;
1807 if (pos >= 0)
1809 r->sig[pos / HOST_BITS_PER_LONG]
1810 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1811 pos -= 4;
1813 str++;
1816 if (*str == 'p' || *str == 'P')
1818 bool exp_neg = false;
1820 str++;
1821 if (*str == '-')
1823 exp_neg = true;
1824 str++;
1826 else if (*str == '+')
1827 str++;
1829 d = 0;
1830 while (ISDIGIT (*str))
1832 d *= 10;
1833 d += *str - '0';
1834 if (d > MAX_EXP)
1836 /* Overflowed the exponent. */
1837 if (exp_neg)
1838 goto underflow;
1839 else
1840 goto overflow;
1842 str++;
1844 if (exp_neg)
1845 d = -d;
1847 exp += d;
1850 r->cl = rvc_normal;
1851 SET_REAL_EXP (r, exp);
1853 normalize (r);
1855 else
1857 /* Decimal floating point. */
1858 const REAL_VALUE_TYPE *ten = ten_to_ptwo (0);
1859 int d;
1861 while (*str == '0')
1862 str++;
1863 while (ISDIGIT (*str))
1865 d = *str++ - '0';
1866 do_multiply (r, r, ten);
1867 if (d)
1868 do_add (r, r, real_digit (d), 0);
1870 if (*str == '.')
1872 str++;
1873 if (r->cl == rvc_zero)
1875 while (*str == '0')
1876 str++, exp--;
1878 while (ISDIGIT (*str))
1880 d = *str++ - '0';
1881 do_multiply (r, r, ten);
1882 if (d)
1883 do_add (r, r, real_digit (d), 0);
1884 exp--;
1888 if (*str == 'e' || *str == 'E')
1890 bool exp_neg = false;
1892 str++;
1893 if (*str == '-')
1895 exp_neg = true;
1896 str++;
1898 else if (*str == '+')
1899 str++;
1901 d = 0;
1902 while (ISDIGIT (*str))
1904 d *= 10;
1905 d += *str - '0';
1906 if (d > MAX_EXP)
1908 /* Overflowed the exponent. */
1909 if (exp_neg)
1910 goto underflow;
1911 else
1912 goto overflow;
1914 str++;
1916 if (exp_neg)
1917 d = -d;
1918 exp += d;
1921 if (exp)
1922 times_pten (r, exp);
1925 r->sign = sign;
1926 return;
1928 underflow:
1929 get_zero (r, sign);
1930 return;
1932 overflow:
1933 get_inf (r, sign);
1934 return;
1937 /* Legacy. Similar, but return the result directly. */
1939 REAL_VALUE_TYPE
1940 real_from_string2 (const char *s, enum machine_mode mode)
1942 REAL_VALUE_TYPE r;
1944 real_from_string (&r, s);
1945 if (mode != VOIDmode)
1946 real_convert (&r, mode, &r);
1948 return r;
1951 /* Initialize R from the integer pair HIGH+LOW. */
1953 void
1954 real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
1955 unsigned HOST_WIDE_INT low, HOST_WIDE_INT high,
1956 int unsigned_p)
1958 if (low == 0 && high == 0)
1959 get_zero (r, 0);
1960 else
1962 r->cl = rvc_normal;
1963 r->sign = high < 0 && !unsigned_p;
1964 SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT);
1966 if (r->sign)
1968 high = ~high;
1969 if (low == 0)
1970 high += 1;
1971 else
1972 low = -low;
1975 if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT)
1977 r->sig[SIGSZ-1] = high;
1978 r->sig[SIGSZ-2] = low;
1979 memset (r->sig, 0, sizeof(long)*(SIGSZ-2));
1981 else
1983 gcc_assert (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT);
1984 r->sig[SIGSZ-1] = high >> (HOST_BITS_PER_LONG - 1) >> 1;
1985 r->sig[SIGSZ-2] = high;
1986 r->sig[SIGSZ-3] = low >> (HOST_BITS_PER_LONG - 1) >> 1;
1987 r->sig[SIGSZ-4] = low;
1988 if (SIGSZ > 4)
1989 memset (r->sig, 0, sizeof(long)*(SIGSZ-4));
1992 normalize (r);
1995 if (mode != VOIDmode)
1996 real_convert (r, mode, r);
1999 /* Returns 10**2**N. */
2001 static const REAL_VALUE_TYPE *
2002 ten_to_ptwo (int n)
2004 static REAL_VALUE_TYPE tens[EXP_BITS];
2006 gcc_assert (n >= 0);
2007 gcc_assert (n < EXP_BITS);
2009 if (tens[n].cl == rvc_zero)
2011 if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
2013 HOST_WIDE_INT t = 10;
2014 int i;
2016 for (i = 0; i < n; ++i)
2017 t *= t;
2019 real_from_integer (&tens[n], VOIDmode, t, 0, 1);
2021 else
2023 const REAL_VALUE_TYPE *t = ten_to_ptwo (n - 1);
2024 do_multiply (&tens[n], t, t);
2028 return &tens[n];
2031 /* Returns 10**(-2**N). */
2033 static const REAL_VALUE_TYPE *
2034 ten_to_mptwo (int n)
2036 static REAL_VALUE_TYPE tens[EXP_BITS];
2038 gcc_assert (n >= 0);
2039 gcc_assert (n < EXP_BITS);
2041 if (tens[n].cl == rvc_zero)
2042 do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
2044 return &tens[n];
2047 /* Returns N. */
2049 static const REAL_VALUE_TYPE *
2050 real_digit (int n)
2052 static REAL_VALUE_TYPE num[10];
2054 gcc_assert (n >= 0);
2055 gcc_assert (n <= 9);
2057 if (n > 0 && num[n].cl == rvc_zero)
2058 real_from_integer (&num[n], VOIDmode, n, 0, 1);
2060 return &num[n];
2063 /* Multiply R by 10**EXP. */
2065 static void
2066 times_pten (REAL_VALUE_TYPE *r, int exp)
2068 REAL_VALUE_TYPE pten, *rr;
2069 bool negative = (exp < 0);
2070 int i;
2072 if (negative)
2074 exp = -exp;
2075 pten = *real_digit (1);
2076 rr = &pten;
2078 else
2079 rr = r;
2081 for (i = 0; exp > 0; ++i, exp >>= 1)
2082 if (exp & 1)
2083 do_multiply (rr, rr, ten_to_ptwo (i));
2085 if (negative)
2086 do_divide (r, r, &pten);
2089 /* Fills R with +Inf. */
2091 void
2092 real_inf (REAL_VALUE_TYPE *r)
2094 get_inf (r, 0);
2097 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2098 we force a QNaN, else we force an SNaN. The string, if not empty,
2099 is parsed as a number and placed in the significand. Return true
2100 if the string was successfully parsed. */
2102 bool
2103 real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
2104 enum machine_mode mode)
2106 const struct real_format *fmt;
2108 fmt = REAL_MODE_FORMAT (mode);
2109 gcc_assert (fmt);
2111 if (*str == 0)
2113 if (quiet)
2114 get_canonical_qnan (r, 0);
2115 else
2116 get_canonical_snan (r, 0);
2118 else
2120 int base = 10, d;
2121 bool neg = false;
2123 memset (r, 0, sizeof (*r));
2124 r->cl = rvc_nan;
2126 /* Parse akin to strtol into the significand of R. */
2128 while (ISSPACE (*str))
2129 str++;
2130 if (*str == '-')
2131 str++, neg = true;
2132 else if (*str == '+')
2133 str++;
2134 if (*str == '0')
2136 if (*++str == 'x')
2137 str++, base = 16;
2138 else
2139 base = 8;
2142 while ((d = hex_value (*str)) < base)
2144 REAL_VALUE_TYPE u;
2146 switch (base)
2148 case 8:
2149 lshift_significand (r, r, 3);
2150 break;
2151 case 16:
2152 lshift_significand (r, r, 4);
2153 break;
2154 case 10:
2155 lshift_significand_1 (&u, r);
2156 lshift_significand (r, r, 3);
2157 add_significands (r, r, &u);
2158 break;
2159 default:
2160 gcc_unreachable ();
2163 get_zero (&u, 0);
2164 u.sig[0] = d;
2165 add_significands (r, r, &u);
2167 str++;
2170 /* Must have consumed the entire string for success. */
2171 if (*str != 0)
2172 return false;
2174 /* Shift the significand into place such that the bits
2175 are in the most significant bits for the format. */
2176 lshift_significand (r, r, SIGNIFICAND_BITS - fmt->pnan);
2178 /* Our MSB is always unset for NaNs. */
2179 r->sig[SIGSZ-1] &= ~SIG_MSB;
2181 /* Force quiet or signalling NaN. */
2182 r->signalling = !quiet;
2185 return true;
2188 /* Fills R with the largest finite value representable in mode MODE.
2189 If SIGN is nonzero, R is set to the most negative finite value. */
2191 void
2192 real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
2194 const struct real_format *fmt;
2195 int np2;
2197 fmt = REAL_MODE_FORMAT (mode);
2198 gcc_assert (fmt);
2200 r->cl = rvc_normal;
2201 r->sign = sign;
2202 r->signalling = 0;
2203 r->canonical = 0;
2204 SET_REAL_EXP (r, fmt->emax * fmt->log2_b);
2206 np2 = SIGNIFICAND_BITS - fmt->p * fmt->log2_b;
2207 memset (r->sig, -1, SIGSZ * sizeof (unsigned long));
2208 clear_significand_below (r, np2);
2211 /* Fills R with 2**N. */
2213 void
2214 real_2expN (REAL_VALUE_TYPE *r, int n)
2216 memset (r, 0, sizeof (*r));
2218 n++;
2219 if (n > MAX_EXP)
2220 r->cl = rvc_inf;
2221 else if (n < -MAX_EXP)
2223 else
2225 r->cl = rvc_normal;
2226 SET_REAL_EXP (r, n);
2227 r->sig[SIGSZ-1] = SIG_MSB;
2232 static void
2233 round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
2235 int p2, np2, i, w;
2236 unsigned long sticky;
2237 bool guard, lsb;
2238 int emin2m1, emax2;
2240 p2 = fmt->p * fmt->log2_b;
2241 emin2m1 = (fmt->emin - 1) * fmt->log2_b;
2242 emax2 = fmt->emax * fmt->log2_b;
2244 np2 = SIGNIFICAND_BITS - p2;
2245 switch (r->cl)
2247 underflow:
2248 get_zero (r, r->sign);
2249 case rvc_zero:
2250 if (!fmt->has_signed_zero)
2251 r->sign = 0;
2252 return;
2254 overflow:
2255 get_inf (r, r->sign);
2256 case rvc_inf:
2257 return;
2259 case rvc_nan:
2260 clear_significand_below (r, np2);
2261 return;
2263 case rvc_normal:
2264 break;
2266 default:
2267 gcc_unreachable ();
2270 /* If we're not base2, normalize the exponent to a multiple of
2271 the true base. */
2272 if (fmt->log2_b != 1)
2274 int shift = REAL_EXP (r) & (fmt->log2_b - 1);
2275 if (shift)
2277 shift = fmt->log2_b - shift;
2278 r->sig[0] |= sticky_rshift_significand (r, r, shift);
2279 SET_REAL_EXP (r, REAL_EXP (r) + shift);
2283 /* Check the range of the exponent. If we're out of range,
2284 either underflow or overflow. */
2285 if (REAL_EXP (r) > emax2)
2286 goto overflow;
2287 else if (REAL_EXP (r) <= emin2m1)
2289 int diff;
2291 if (!fmt->has_denorm)
2293 /* Don't underflow completely until we've had a chance to round. */
2294 if (REAL_EXP (r) < emin2m1)
2295 goto underflow;
2297 else
2299 diff = emin2m1 - REAL_EXP (r) + 1;
2300 if (diff > p2)
2301 goto underflow;
2303 /* De-normalize the significand. */
2304 r->sig[0] |= sticky_rshift_significand (r, r, diff);
2305 SET_REAL_EXP (r, REAL_EXP (r) + diff);
2309 /* There are P2 true significand bits, followed by one guard bit,
2310 followed by one sticky bit, followed by stuff. Fold nonzero
2311 stuff into the sticky bit. */
2313 sticky = 0;
2314 for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
2315 sticky |= r->sig[i];
2316 sticky |=
2317 r->sig[w] & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
2319 guard = test_significand_bit (r, np2 - 1);
2320 lsb = test_significand_bit (r, np2);
2322 /* Round to even. */
2323 if (guard && (sticky || lsb))
2325 REAL_VALUE_TYPE u;
2326 get_zero (&u, 0);
2327 set_significand_bit (&u, np2);
2329 if (add_significands (r, r, &u))
2331 /* Overflow. Means the significand had been all ones, and
2332 is now all zeros. Need to increase the exponent, and
2333 possibly re-normalize it. */
2334 SET_REAL_EXP (r, REAL_EXP (r) + 1);
2335 if (REAL_EXP (r) > emax2)
2336 goto overflow;
2337 r->sig[SIGSZ-1] = SIG_MSB;
2339 if (fmt->log2_b != 1)
2341 int shift = REAL_EXP (r) & (fmt->log2_b - 1);
2342 if (shift)
2344 shift = fmt->log2_b - shift;
2345 rshift_significand (r, r, shift);
2346 SET_REAL_EXP (r, REAL_EXP (r) + shift);
2347 if (REAL_EXP (r) > emax2)
2348 goto overflow;
2354 /* Catch underflow that we deferred until after rounding. */
2355 if (REAL_EXP (r) <= emin2m1)
2356 goto underflow;
2358 /* Clear out trailing garbage. */
2359 clear_significand_below (r, np2);
2362 /* Extend or truncate to a new mode. */
2364 void
2365 real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
2366 const REAL_VALUE_TYPE *a)
2368 const struct real_format *fmt;
2370 fmt = REAL_MODE_FORMAT (mode);
2371 gcc_assert (fmt);
2373 *r = *a;
2374 round_for_format (fmt, r);
2376 /* round_for_format de-normalizes denormals. Undo just that part. */
2377 if (r->cl == rvc_normal)
2378 normalize (r);
2381 /* Legacy. Likewise, except return the struct directly. */
2383 REAL_VALUE_TYPE
2384 real_value_truncate (enum machine_mode mode, REAL_VALUE_TYPE a)
2386 REAL_VALUE_TYPE r;
2387 real_convert (&r, mode, &a);
2388 return r;
2391 /* Return true if truncating to MODE is exact. */
2393 bool
2394 exact_real_truncate (enum machine_mode mode, const REAL_VALUE_TYPE *a)
2396 REAL_VALUE_TYPE t;
2397 real_convert (&t, mode, a);
2398 return real_identical (&t, a);
2401 /* Write R to the given target format. Place the words of the result
2402 in target word order in BUF. There are always 32 bits in each
2403 long, no matter the size of the host long.
2405 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2407 long
2408 real_to_target_fmt (long *buf, const REAL_VALUE_TYPE *r_orig,
2409 const struct real_format *fmt)
2411 REAL_VALUE_TYPE r;
2412 long buf1;
2414 r = *r_orig;
2415 round_for_format (fmt, &r);
2417 if (!buf)
2418 buf = &buf1;
2419 (*fmt->encode) (fmt, buf, &r);
2421 return *buf;
2424 /* Similar, but look up the format from MODE. */
2426 long
2427 real_to_target (long *buf, const REAL_VALUE_TYPE *r, enum machine_mode mode)
2429 const struct real_format *fmt;
2431 fmt = REAL_MODE_FORMAT (mode);
2432 gcc_assert (fmt);
2434 return real_to_target_fmt (buf, r, fmt);
2437 /* Read R from the given target format. Read the words of the result
2438 in target word order in BUF. There are always 32 bits in each
2439 long, no matter the size of the host long. */
2441 void
2442 real_from_target_fmt (REAL_VALUE_TYPE *r, const long *buf,
2443 const struct real_format *fmt)
2445 (*fmt->decode) (fmt, r, buf);
2448 /* Similar, but look up the format from MODE. */
2450 void
2451 real_from_target (REAL_VALUE_TYPE *r, const long *buf, enum machine_mode mode)
2453 const struct real_format *fmt;
2455 fmt = REAL_MODE_FORMAT (mode);
2456 gcc_assert (fmt);
2458 (*fmt->decode) (fmt, r, buf);
2461 /* Return the number of bits in the significand for MODE. */
2462 /* ??? Legacy. Should get access to real_format directly. */
2465 significand_size (enum machine_mode mode)
2467 const struct real_format *fmt;
2469 fmt = REAL_MODE_FORMAT (mode);
2470 if (fmt == NULL)
2471 return 0;
2473 return fmt->p * fmt->log2_b;
2476 /* Return a hash value for the given real value. */
2477 /* ??? The "unsigned int" return value is intended to be hashval_t,
2478 but I didn't want to pull hashtab.h into real.h. */
2480 unsigned int
2481 real_hash (const REAL_VALUE_TYPE *r)
2483 unsigned int h;
2484 size_t i;
2486 h = r->cl | (r->sign << 2);
2487 switch (r->cl)
2489 case rvc_zero:
2490 case rvc_inf:
2491 return h;
2493 case rvc_normal:
2494 h |= REAL_EXP (r) << 3;
2495 break;
2497 case rvc_nan:
2498 if (r->signalling)
2499 h ^= (unsigned int)-1;
2500 if (r->canonical)
2501 return h;
2502 break;
2504 default:
2505 gcc_unreachable ();
2508 if (sizeof(unsigned long) > sizeof(unsigned int))
2509 for (i = 0; i < SIGSZ; ++i)
2511 unsigned long s = r->sig[i];
2512 h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2));
2514 else
2515 for (i = 0; i < SIGSZ; ++i)
2516 h ^= r->sig[i];
2518 return h;
2521 /* IEEE single-precision format. */
2523 static void encode_ieee_single (const struct real_format *fmt,
2524 long *, const REAL_VALUE_TYPE *);
2525 static void decode_ieee_single (const struct real_format *,
2526 REAL_VALUE_TYPE *, const long *);
2528 static void
2529 encode_ieee_single (const struct real_format *fmt, long *buf,
2530 const REAL_VALUE_TYPE *r)
2532 unsigned long image, sig, exp;
2533 unsigned long sign = r->sign;
2534 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2536 image = sign << 31;
2537 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
2539 switch (r->cl)
2541 case rvc_zero:
2542 break;
2544 case rvc_inf:
2545 if (fmt->has_inf)
2546 image |= 255 << 23;
2547 else
2548 image |= 0x7fffffff;
2549 break;
2551 case rvc_nan:
2552 if (fmt->has_nans)
2554 if (r->canonical)
2555 sig = 0;
2556 if (r->signalling == fmt->qnan_msb_set)
2557 sig &= ~(1 << 22);
2558 else
2559 sig |= 1 << 22;
2560 /* We overload qnan_msb_set here: it's only clear for
2561 mips_ieee_single, which wants all mantissa bits but the
2562 quiet/signalling one set in canonical NaNs (at least
2563 Quiet ones). */
2564 if (r->canonical && !fmt->qnan_msb_set)
2565 sig |= (1 << 22) - 1;
2566 else if (sig == 0)
2567 sig = 1 << 21;
2569 image |= 255 << 23;
2570 image |= sig;
2572 else
2573 image |= 0x7fffffff;
2574 break;
2576 case rvc_normal:
2577 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2578 whereas the intermediate representation is 0.F x 2**exp.
2579 Which means we're off by one. */
2580 if (denormal)
2581 exp = 0;
2582 else
2583 exp = REAL_EXP (r) + 127 - 1;
2584 image |= exp << 23;
2585 image |= sig;
2586 break;
2588 default:
2589 gcc_unreachable ();
2592 buf[0] = image;
2595 static void
2596 decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
2597 const long *buf)
2599 unsigned long image = buf[0] & 0xffffffff;
2600 bool sign = (image >> 31) & 1;
2601 int exp = (image >> 23) & 0xff;
2603 memset (r, 0, sizeof (*r));
2604 image <<= HOST_BITS_PER_LONG - 24;
2605 image &= ~SIG_MSB;
2607 if (exp == 0)
2609 if (image && fmt->has_denorm)
2611 r->cl = rvc_normal;
2612 r->sign = sign;
2613 SET_REAL_EXP (r, -126);
2614 r->sig[SIGSZ-1] = image << 1;
2615 normalize (r);
2617 else if (fmt->has_signed_zero)
2618 r->sign = sign;
2620 else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
2622 if (image)
2624 r->cl = rvc_nan;
2625 r->sign = sign;
2626 r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
2627 ^ fmt->qnan_msb_set);
2628 r->sig[SIGSZ-1] = image;
2630 else
2632 r->cl = rvc_inf;
2633 r->sign = sign;
2636 else
2638 r->cl = rvc_normal;
2639 r->sign = sign;
2640 SET_REAL_EXP (r, exp - 127 + 1);
2641 r->sig[SIGSZ-1] = image | SIG_MSB;
2645 const struct real_format ieee_single_format =
2647 encode_ieee_single,
2648 decode_ieee_single,
2653 -125,
2654 128,
2656 true,
2657 true,
2658 true,
2659 true,
2660 true
2663 const struct real_format mips_single_format =
2665 encode_ieee_single,
2666 decode_ieee_single,
2671 -125,
2672 128,
2674 true,
2675 true,
2676 true,
2677 true,
2678 false
2682 /* IEEE double-precision format. */
2684 static void encode_ieee_double (const struct real_format *fmt,
2685 long *, const REAL_VALUE_TYPE *);
2686 static void decode_ieee_double (const struct real_format *,
2687 REAL_VALUE_TYPE *, const long *);
2689 static void
2690 encode_ieee_double (const struct real_format *fmt, long *buf,
2691 const REAL_VALUE_TYPE *r)
2693 unsigned long image_lo, image_hi, sig_lo, sig_hi, exp;
2694 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2696 image_hi = r->sign << 31;
2697 image_lo = 0;
2699 if (HOST_BITS_PER_LONG == 64)
2701 sig_hi = r->sig[SIGSZ-1];
2702 sig_lo = (sig_hi >> (64 - 53)) & 0xffffffff;
2703 sig_hi = (sig_hi >> (64 - 53 + 1) >> 31) & 0xfffff;
2705 else
2707 sig_hi = r->sig[SIGSZ-1];
2708 sig_lo = r->sig[SIGSZ-2];
2709 sig_lo = (sig_hi << 21) | (sig_lo >> 11);
2710 sig_hi = (sig_hi >> 11) & 0xfffff;
2713 switch (r->cl)
2715 case rvc_zero:
2716 break;
2718 case rvc_inf:
2719 if (fmt->has_inf)
2720 image_hi |= 2047 << 20;
2721 else
2723 image_hi |= 0x7fffffff;
2724 image_lo = 0xffffffff;
2726 break;
2728 case rvc_nan:
2729 if (fmt->has_nans)
2731 if (r->canonical)
2732 sig_hi = sig_lo = 0;
2733 if (r->signalling == fmt->qnan_msb_set)
2734 sig_hi &= ~(1 << 19);
2735 else
2736 sig_hi |= 1 << 19;
2737 /* We overload qnan_msb_set here: it's only clear for
2738 mips_ieee_single, which wants all mantissa bits but the
2739 quiet/signalling one set in canonical NaNs (at least
2740 Quiet ones). */
2741 if (r->canonical && !fmt->qnan_msb_set)
2743 sig_hi |= (1 << 19) - 1;
2744 sig_lo = 0xffffffff;
2746 else if (sig_hi == 0 && sig_lo == 0)
2747 sig_hi = 1 << 18;
2749 image_hi |= 2047 << 20;
2750 image_hi |= sig_hi;
2751 image_lo = sig_lo;
2753 else
2755 image_hi |= 0x7fffffff;
2756 image_lo = 0xffffffff;
2758 break;
2760 case rvc_normal:
2761 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2762 whereas the intermediate representation is 0.F x 2**exp.
2763 Which means we're off by one. */
2764 if (denormal)
2765 exp = 0;
2766 else
2767 exp = REAL_EXP (r) + 1023 - 1;
2768 image_hi |= exp << 20;
2769 image_hi |= sig_hi;
2770 image_lo = sig_lo;
2771 break;
2773 default:
2774 gcc_unreachable ();
2777 if (FLOAT_WORDS_BIG_ENDIAN)
2778 buf[0] = image_hi, buf[1] = image_lo;
2779 else
2780 buf[0] = image_lo, buf[1] = image_hi;
2783 static void
2784 decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
2785 const long *buf)
2787 unsigned long image_hi, image_lo;
2788 bool sign;
2789 int exp;
2791 if (FLOAT_WORDS_BIG_ENDIAN)
2792 image_hi = buf[0], image_lo = buf[1];
2793 else
2794 image_lo = buf[0], image_hi = buf[1];
2795 image_lo &= 0xffffffff;
2796 image_hi &= 0xffffffff;
2798 sign = (image_hi >> 31) & 1;
2799 exp = (image_hi >> 20) & 0x7ff;
2801 memset (r, 0, sizeof (*r));
2803 image_hi <<= 32 - 21;
2804 image_hi |= image_lo >> 21;
2805 image_hi &= 0x7fffffff;
2806 image_lo <<= 32 - 21;
2808 if (exp == 0)
2810 if ((image_hi || image_lo) && fmt->has_denorm)
2812 r->cl = rvc_normal;
2813 r->sign = sign;
2814 SET_REAL_EXP (r, -1022);
2815 if (HOST_BITS_PER_LONG == 32)
2817 image_hi = (image_hi << 1) | (image_lo >> 31);
2818 image_lo <<= 1;
2819 r->sig[SIGSZ-1] = image_hi;
2820 r->sig[SIGSZ-2] = image_lo;
2822 else
2824 image_hi = (image_hi << 31 << 2) | (image_lo << 1);
2825 r->sig[SIGSZ-1] = image_hi;
2827 normalize (r);
2829 else if (fmt->has_signed_zero)
2830 r->sign = sign;
2832 else if (exp == 2047 && (fmt->has_nans || fmt->has_inf))
2834 if (image_hi || image_lo)
2836 r->cl = rvc_nan;
2837 r->sign = sign;
2838 r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set;
2839 if (HOST_BITS_PER_LONG == 32)
2841 r->sig[SIGSZ-1] = image_hi;
2842 r->sig[SIGSZ-2] = image_lo;
2844 else
2845 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo;
2847 else
2849 r->cl = rvc_inf;
2850 r->sign = sign;
2853 else
2855 r->cl = rvc_normal;
2856 r->sign = sign;
2857 SET_REAL_EXP (r, exp - 1023 + 1);
2858 if (HOST_BITS_PER_LONG == 32)
2860 r->sig[SIGSZ-1] = image_hi | SIG_MSB;
2861 r->sig[SIGSZ-2] = image_lo;
2863 else
2864 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo | SIG_MSB;
2868 const struct real_format ieee_double_format =
2870 encode_ieee_double,
2871 decode_ieee_double,
2876 -1021,
2877 1024,
2879 true,
2880 true,
2881 true,
2882 true,
2883 true
2886 const struct real_format mips_double_format =
2888 encode_ieee_double,
2889 decode_ieee_double,
2894 -1021,
2895 1024,
2897 true,
2898 true,
2899 true,
2900 true,
2901 false
2905 /* IEEE extended real format. This comes in three flavors: Intel's as
2906 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
2907 12- and 16-byte images may be big- or little endian; Motorola's is
2908 always big endian. */
2910 /* Helper subroutine which converts from the internal format to the
2911 12-byte little-endian Intel format. Functions below adjust this
2912 for the other possible formats. */
2913 static void
2914 encode_ieee_extended (const struct real_format *fmt, long *buf,
2915 const REAL_VALUE_TYPE *r)
2917 unsigned long image_hi, sig_hi, sig_lo;
2918 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2920 image_hi = r->sign << 15;
2921 sig_hi = sig_lo = 0;
2923 switch (r->cl)
2925 case rvc_zero:
2926 break;
2928 case rvc_inf:
2929 if (fmt->has_inf)
2931 image_hi |= 32767;
2933 /* Intel requires the explicit integer bit to be set, otherwise
2934 it considers the value a "pseudo-infinity". Motorola docs
2935 say it doesn't care. */
2936 sig_hi = 0x80000000;
2938 else
2940 image_hi |= 32767;
2941 sig_lo = sig_hi = 0xffffffff;
2943 break;
2945 case rvc_nan:
2946 if (fmt->has_nans)
2948 image_hi |= 32767;
2949 if (HOST_BITS_PER_LONG == 32)
2951 sig_hi = r->sig[SIGSZ-1];
2952 sig_lo = r->sig[SIGSZ-2];
2954 else
2956 sig_lo = r->sig[SIGSZ-1];
2957 sig_hi = sig_lo >> 31 >> 1;
2958 sig_lo &= 0xffffffff;
2960 if (r->signalling == fmt->qnan_msb_set)
2961 sig_hi &= ~(1 << 30);
2962 else
2963 sig_hi |= 1 << 30;
2964 if ((sig_hi & 0x7fffffff) == 0 && sig_lo == 0)
2965 sig_hi = 1 << 29;
2967 /* Intel requires the explicit integer bit to be set, otherwise
2968 it considers the value a "pseudo-nan". Motorola docs say it
2969 doesn't care. */
2970 sig_hi |= 0x80000000;
2972 else
2974 image_hi |= 32767;
2975 sig_lo = sig_hi = 0xffffffff;
2977 break;
2979 case rvc_normal:
2981 int exp = REAL_EXP (r);
2983 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2984 whereas the intermediate representation is 0.F x 2**exp.
2985 Which means we're off by one.
2987 Except for Motorola, which consider exp=0 and explicit
2988 integer bit set to continue to be normalized. In theory
2989 this discrepancy has been taken care of by the difference
2990 in fmt->emin in round_for_format. */
2992 if (denormal)
2993 exp = 0;
2994 else
2996 exp += 16383 - 1;
2997 gcc_assert (exp >= 0);
2999 image_hi |= exp;
3001 if (HOST_BITS_PER_LONG == 32)
3003 sig_hi = r->sig[SIGSZ-1];
3004 sig_lo = r->sig[SIGSZ-2];
3006 else
3008 sig_lo = r->sig[SIGSZ-1];
3009 sig_hi = sig_lo >> 31 >> 1;
3010 sig_lo &= 0xffffffff;
3013 break;
3015 default:
3016 gcc_unreachable ();
3019 buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
3022 /* Convert from the internal format to the 12-byte Motorola format
3023 for an IEEE extended real. */
3024 static void
3025 encode_ieee_extended_motorola (const struct real_format *fmt, long *buf,
3026 const REAL_VALUE_TYPE *r)
3028 long intermed[3];
3029 encode_ieee_extended (fmt, intermed, r);
3031 /* Motorola chips are assumed always to be big-endian. Also, the
3032 padding in a Motorola extended real goes between the exponent and
3033 the mantissa. At this point the mantissa is entirely within
3034 elements 0 and 1 of intermed, and the exponent entirely within
3035 element 2, so all we have to do is swap the order around, and
3036 shift element 2 left 16 bits. */
3037 buf[0] = intermed[2] << 16;
3038 buf[1] = intermed[1];
3039 buf[2] = intermed[0];
3042 /* Convert from the internal format to the 12-byte Intel format for
3043 an IEEE extended real. */
3044 static void
3045 encode_ieee_extended_intel_96 (const struct real_format *fmt, long *buf,
3046 const REAL_VALUE_TYPE *r)
3048 if (FLOAT_WORDS_BIG_ENDIAN)
3050 /* All the padding in an Intel-format extended real goes at the high
3051 end, which in this case is after the mantissa, not the exponent.
3052 Therefore we must shift everything down 16 bits. */
3053 long intermed[3];
3054 encode_ieee_extended (fmt, intermed, r);
3055 buf[0] = ((intermed[2] << 16) | ((unsigned long)(intermed[1] & 0xFFFF0000) >> 16));
3056 buf[1] = ((intermed[1] << 16) | ((unsigned long)(intermed[0] & 0xFFFF0000) >> 16));
3057 buf[2] = (intermed[0] << 16);
3059 else
3060 /* encode_ieee_extended produces what we want directly. */
3061 encode_ieee_extended (fmt, buf, r);
3064 /* Convert from the internal format to the 16-byte Intel format for
3065 an IEEE extended real. */
3066 static void
3067 encode_ieee_extended_intel_128 (const struct real_format *fmt, long *buf,
3068 const REAL_VALUE_TYPE *r)
3070 /* All the padding in an Intel-format extended real goes at the high end. */
3071 encode_ieee_extended_intel_96 (fmt, buf, r);
3072 buf[3] = 0;
3075 /* As above, we have a helper function which converts from 12-byte
3076 little-endian Intel format to internal format. Functions below
3077 adjust for the other possible formats. */
3078 static void
3079 decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3080 const long *buf)
3082 unsigned long image_hi, sig_hi, sig_lo;
3083 bool sign;
3084 int exp;
3086 sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
3087 sig_lo &= 0xffffffff;
3088 sig_hi &= 0xffffffff;
3089 image_hi &= 0xffffffff;
3091 sign = (image_hi >> 15) & 1;
3092 exp = image_hi & 0x7fff;
3094 memset (r, 0, sizeof (*r));
3096 if (exp == 0)
3098 if ((sig_hi || sig_lo) && fmt->has_denorm)
3100 r->cl = rvc_normal;
3101 r->sign = sign;
3103 /* When the IEEE format contains a hidden bit, we know that
3104 it's zero at this point, and so shift up the significand
3105 and decrease the exponent to match. In this case, Motorola
3106 defines the explicit integer bit to be valid, so we don't
3107 know whether the msb is set or not. */
3108 SET_REAL_EXP (r, fmt->emin);
3109 if (HOST_BITS_PER_LONG == 32)
3111 r->sig[SIGSZ-1] = sig_hi;
3112 r->sig[SIGSZ-2] = sig_lo;
3114 else
3115 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3117 normalize (r);
3119 else if (fmt->has_signed_zero)
3120 r->sign = sign;
3122 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3124 /* See above re "pseudo-infinities" and "pseudo-nans".
3125 Short summary is that the MSB will likely always be
3126 set, and that we don't care about it. */
3127 sig_hi &= 0x7fffffff;
3129 if (sig_hi || sig_lo)
3131 r->cl = rvc_nan;
3132 r->sign = sign;
3133 r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set;
3134 if (HOST_BITS_PER_LONG == 32)
3136 r->sig[SIGSZ-1] = sig_hi;
3137 r->sig[SIGSZ-2] = sig_lo;
3139 else
3140 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3142 else
3144 r->cl = rvc_inf;
3145 r->sign = sign;
3148 else
3150 r->cl = rvc_normal;
3151 r->sign = sign;
3152 SET_REAL_EXP (r, exp - 16383 + 1);
3153 if (HOST_BITS_PER_LONG == 32)
3155 r->sig[SIGSZ-1] = sig_hi;
3156 r->sig[SIGSZ-2] = sig_lo;
3158 else
3159 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3163 /* Convert from the internal format to the 12-byte Motorola format
3164 for an IEEE extended real. */
3165 static void
3166 decode_ieee_extended_motorola (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3167 const long *buf)
3169 long intermed[3];
3171 /* Motorola chips are assumed always to be big-endian. Also, the
3172 padding in a Motorola extended real goes between the exponent and
3173 the mantissa; remove it. */
3174 intermed[0] = buf[2];
3175 intermed[1] = buf[1];
3176 intermed[2] = (unsigned long)buf[0] >> 16;
3178 decode_ieee_extended (fmt, r, intermed);
3181 /* Convert from the internal format to the 12-byte Intel format for
3182 an IEEE extended real. */
3183 static void
3184 decode_ieee_extended_intel_96 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3185 const long *buf)
3187 if (FLOAT_WORDS_BIG_ENDIAN)
3189 /* All the padding in an Intel-format extended real goes at the high
3190 end, which in this case is after the mantissa, not the exponent.
3191 Therefore we must shift everything up 16 bits. */
3192 long intermed[3];
3194 intermed[0] = (((unsigned long)buf[2] >> 16) | (buf[1] << 16));
3195 intermed[1] = (((unsigned long)buf[1] >> 16) | (buf[0] << 16));
3196 intermed[2] = ((unsigned long)buf[0] >> 16);
3198 decode_ieee_extended (fmt, r, intermed);
3200 else
3201 /* decode_ieee_extended produces what we want directly. */
3202 decode_ieee_extended (fmt, r, buf);
3205 /* Convert from the internal format to the 16-byte Intel format for
3206 an IEEE extended real. */
3207 static void
3208 decode_ieee_extended_intel_128 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3209 const long *buf)
3211 /* All the padding in an Intel-format extended real goes at the high end. */
3212 decode_ieee_extended_intel_96 (fmt, r, buf);
3215 const struct real_format ieee_extended_motorola_format =
3217 encode_ieee_extended_motorola,
3218 decode_ieee_extended_motorola,
3223 -16382,
3224 16384,
3226 true,
3227 true,
3228 true,
3229 true,
3230 true
3233 const struct real_format ieee_extended_intel_96_format =
3235 encode_ieee_extended_intel_96,
3236 decode_ieee_extended_intel_96,
3241 -16381,
3242 16384,
3244 true,
3245 true,
3246 true,
3247 true,
3248 true
3251 const struct real_format ieee_extended_intel_128_format =
3253 encode_ieee_extended_intel_128,
3254 decode_ieee_extended_intel_128,
3259 -16381,
3260 16384,
3262 true,
3263 true,
3264 true,
3265 true,
3266 true
3269 /* The following caters to i386 systems that set the rounding precision
3270 to 53 bits instead of 64, e.g. FreeBSD. */
3271 const struct real_format ieee_extended_intel_96_round_53_format =
3273 encode_ieee_extended_intel_96,
3274 decode_ieee_extended_intel_96,
3279 -16381,
3280 16384,
3282 true,
3283 true,
3284 true,
3285 true,
3286 true
3289 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3290 numbers whose sum is equal to the extended precision value. The number
3291 with greater magnitude is first. This format has the same magnitude
3292 range as an IEEE double precision value, but effectively 106 bits of
3293 significand precision. Infinity and NaN are represented by their IEEE
3294 double precision value stored in the first number, the second number is
3295 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3297 static void encode_ibm_extended (const struct real_format *fmt,
3298 long *, const REAL_VALUE_TYPE *);
3299 static void decode_ibm_extended (const struct real_format *,
3300 REAL_VALUE_TYPE *, const long *);
3302 static void
3303 encode_ibm_extended (const struct real_format *fmt, long *buf,
3304 const REAL_VALUE_TYPE *r)
3306 REAL_VALUE_TYPE u, normr, v;
3307 const struct real_format *base_fmt;
3309 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3311 /* Renormlize R before doing any arithmetic on it. */
3312 normr = *r;
3313 if (normr.cl == rvc_normal)
3314 normalize (&normr);
3316 /* u = IEEE double precision portion of significand. */
3317 u = normr;
3318 round_for_format (base_fmt, &u);
3319 encode_ieee_double (base_fmt, &buf[0], &u);
3321 if (u.cl == rvc_normal)
3323 do_add (&v, &normr, &u, 1);
3324 /* Call round_for_format since we might need to denormalize. */
3325 round_for_format (base_fmt, &v);
3326 encode_ieee_double (base_fmt, &buf[2], &v);
3328 else
3330 /* Inf, NaN, 0 are all representable as doubles, so the
3331 least-significant part can be 0.0. */
3332 buf[2] = 0;
3333 buf[3] = 0;
3337 static void
3338 decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_TYPE *r,
3339 const long *buf)
3341 REAL_VALUE_TYPE u, v;
3342 const struct real_format *base_fmt;
3344 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3345 decode_ieee_double (base_fmt, &u, &buf[0]);
3347 if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan)
3349 decode_ieee_double (base_fmt, &v, &buf[2]);
3350 do_add (r, &u, &v, 0);
3352 else
3353 *r = u;
3356 const struct real_format ibm_extended_format =
3358 encode_ibm_extended,
3359 decode_ibm_extended,
3362 53 + 53,
3364 -1021 + 53,
3365 1024,
3367 true,
3368 true,
3369 true,
3370 true,
3371 true
3374 const struct real_format mips_extended_format =
3376 encode_ibm_extended,
3377 decode_ibm_extended,
3380 53 + 53,
3382 -1021 + 53,
3383 1024,
3385 true,
3386 true,
3387 true,
3388 true,
3389 false
3393 /* IEEE quad precision format. */
3395 static void encode_ieee_quad (const struct real_format *fmt,
3396 long *, const REAL_VALUE_TYPE *);
3397 static void decode_ieee_quad (const struct real_format *,
3398 REAL_VALUE_TYPE *, const long *);
3400 static void
3401 encode_ieee_quad (const struct real_format *fmt, long *buf,
3402 const REAL_VALUE_TYPE *r)
3404 unsigned long image3, image2, image1, image0, exp;
3405 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
3406 REAL_VALUE_TYPE u;
3408 image3 = r->sign << 31;
3409 image2 = 0;
3410 image1 = 0;
3411 image0 = 0;
3413 rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
3415 switch (r->cl)
3417 case rvc_zero:
3418 break;
3420 case rvc_inf:
3421 if (fmt->has_inf)
3422 image3 |= 32767 << 16;
3423 else
3425 image3 |= 0x7fffffff;
3426 image2 = 0xffffffff;
3427 image1 = 0xffffffff;
3428 image0 = 0xffffffff;
3430 break;
3432 case rvc_nan:
3433 if (fmt->has_nans)
3435 image3 |= 32767 << 16;
3437 if (r->canonical)
3439 /* Don't use bits from the significand. The
3440 initialization above is right. */
3442 else if (HOST_BITS_PER_LONG == 32)
3444 image0 = u.sig[0];
3445 image1 = u.sig[1];
3446 image2 = u.sig[2];
3447 image3 |= u.sig[3] & 0xffff;
3449 else
3451 image0 = u.sig[0];
3452 image1 = image0 >> 31 >> 1;
3453 image2 = u.sig[1];
3454 image3 |= (image2 >> 31 >> 1) & 0xffff;
3455 image0 &= 0xffffffff;
3456 image2 &= 0xffffffff;
3458 if (r->signalling == fmt->qnan_msb_set)
3459 image3 &= ~0x8000;
3460 else
3461 image3 |= 0x8000;
3462 /* We overload qnan_msb_set here: it's only clear for
3463 mips_ieee_single, which wants all mantissa bits but the
3464 quiet/signalling one set in canonical NaNs (at least
3465 Quiet ones). */
3466 if (r->canonical && !fmt->qnan_msb_set)
3468 image3 |= 0x7fff;
3469 image2 = image1 = image0 = 0xffffffff;
3471 else if (((image3 & 0xffff) | image2 | image1 | image0) == 0)
3472 image3 |= 0x4000;
3474 else
3476 image3 |= 0x7fffffff;
3477 image2 = 0xffffffff;
3478 image1 = 0xffffffff;
3479 image0 = 0xffffffff;
3481 break;
3483 case rvc_normal:
3484 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3485 whereas the intermediate representation is 0.F x 2**exp.
3486 Which means we're off by one. */
3487 if (denormal)
3488 exp = 0;
3489 else
3490 exp = REAL_EXP (r) + 16383 - 1;
3491 image3 |= exp << 16;
3493 if (HOST_BITS_PER_LONG == 32)
3495 image0 = u.sig[0];
3496 image1 = u.sig[1];
3497 image2 = u.sig[2];
3498 image3 |= u.sig[3] & 0xffff;
3500 else
3502 image0 = u.sig[0];
3503 image1 = image0 >> 31 >> 1;
3504 image2 = u.sig[1];
3505 image3 |= (image2 >> 31 >> 1) & 0xffff;
3506 image0 &= 0xffffffff;
3507 image2 &= 0xffffffff;
3509 break;
3511 default:
3512 gcc_unreachable ();
3515 if (FLOAT_WORDS_BIG_ENDIAN)
3517 buf[0] = image3;
3518 buf[1] = image2;
3519 buf[2] = image1;
3520 buf[3] = image0;
3522 else
3524 buf[0] = image0;
3525 buf[1] = image1;
3526 buf[2] = image2;
3527 buf[3] = image3;
3531 static void
3532 decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3533 const long *buf)
3535 unsigned long image3, image2, image1, image0;
3536 bool sign;
3537 int exp;
3539 if (FLOAT_WORDS_BIG_ENDIAN)
3541 image3 = buf[0];
3542 image2 = buf[1];
3543 image1 = buf[2];
3544 image0 = buf[3];
3546 else
3548 image0 = buf[0];
3549 image1 = buf[1];
3550 image2 = buf[2];
3551 image3 = buf[3];
3553 image0 &= 0xffffffff;
3554 image1 &= 0xffffffff;
3555 image2 &= 0xffffffff;
3557 sign = (image3 >> 31) & 1;
3558 exp = (image3 >> 16) & 0x7fff;
3559 image3 &= 0xffff;
3561 memset (r, 0, sizeof (*r));
3563 if (exp == 0)
3565 if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
3567 r->cl = rvc_normal;
3568 r->sign = sign;
3570 SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
3571 if (HOST_BITS_PER_LONG == 32)
3573 r->sig[0] = image0;
3574 r->sig[1] = image1;
3575 r->sig[2] = image2;
3576 r->sig[3] = image3;
3578 else
3580 r->sig[0] = (image1 << 31 << 1) | image0;
3581 r->sig[1] = (image3 << 31 << 1) | image2;
3584 normalize (r);
3586 else if (fmt->has_signed_zero)
3587 r->sign = sign;
3589 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3591 if (image3 | image2 | image1 | image0)
3593 r->cl = rvc_nan;
3594 r->sign = sign;
3595 r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set;
3597 if (HOST_BITS_PER_LONG == 32)
3599 r->sig[0] = image0;
3600 r->sig[1] = image1;
3601 r->sig[2] = image2;
3602 r->sig[3] = image3;
3604 else
3606 r->sig[0] = (image1 << 31 << 1) | image0;
3607 r->sig[1] = (image3 << 31 << 1) | image2;
3609 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3611 else
3613 r->cl = rvc_inf;
3614 r->sign = sign;
3617 else
3619 r->cl = rvc_normal;
3620 r->sign = sign;
3621 SET_REAL_EXP (r, exp - 16383 + 1);
3623 if (HOST_BITS_PER_LONG == 32)
3625 r->sig[0] = image0;
3626 r->sig[1] = image1;
3627 r->sig[2] = image2;
3628 r->sig[3] = image3;
3630 else
3632 r->sig[0] = (image1 << 31 << 1) | image0;
3633 r->sig[1] = (image3 << 31 << 1) | image2;
3635 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3636 r->sig[SIGSZ-1] |= SIG_MSB;
3640 const struct real_format ieee_quad_format =
3642 encode_ieee_quad,
3643 decode_ieee_quad,
3646 113,
3647 113,
3648 -16381,
3649 16384,
3650 127,
3651 true,
3652 true,
3653 true,
3654 true,
3655 true
3658 const struct real_format mips_quad_format =
3660 encode_ieee_quad,
3661 decode_ieee_quad,
3664 113,
3665 113,
3666 -16381,
3667 16384,
3668 127,
3669 true,
3670 true,
3671 true,
3672 true,
3673 false
3676 /* Descriptions of VAX floating point formats can be found beginning at
3678 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
3680 The thing to remember is that they're almost IEEE, except for word
3681 order, exponent bias, and the lack of infinities, nans, and denormals.
3683 We don't implement the H_floating format here, simply because neither
3684 the VAX or Alpha ports use it. */
3686 static void encode_vax_f (const struct real_format *fmt,
3687 long *, const REAL_VALUE_TYPE *);
3688 static void decode_vax_f (const struct real_format *,
3689 REAL_VALUE_TYPE *, const long *);
3690 static void encode_vax_d (const struct real_format *fmt,
3691 long *, const REAL_VALUE_TYPE *);
3692 static void decode_vax_d (const struct real_format *,
3693 REAL_VALUE_TYPE *, const long *);
3694 static void encode_vax_g (const struct real_format *fmt,
3695 long *, const REAL_VALUE_TYPE *);
3696 static void decode_vax_g (const struct real_format *,
3697 REAL_VALUE_TYPE *, const long *);
3699 static void
3700 encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
3701 const REAL_VALUE_TYPE *r)
3703 unsigned long sign, exp, sig, image;
3705 sign = r->sign << 15;
3707 switch (r->cl)
3709 case rvc_zero:
3710 image = 0;
3711 break;
3713 case rvc_inf:
3714 case rvc_nan:
3715 image = 0xffff7fff | sign;
3716 break;
3718 case rvc_normal:
3719 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
3720 exp = REAL_EXP (r) + 128;
3722 image = (sig << 16) & 0xffff0000;
3723 image |= sign;
3724 image |= exp << 7;
3725 image |= sig >> 16;
3726 break;
3728 default:
3729 gcc_unreachable ();
3732 buf[0] = image;
3735 static void
3736 decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED,
3737 REAL_VALUE_TYPE *r, const long *buf)
3739 unsigned long image = buf[0] & 0xffffffff;
3740 int exp = (image >> 7) & 0xff;
3742 memset (r, 0, sizeof (*r));
3744 if (exp != 0)
3746 r->cl = rvc_normal;
3747 r->sign = (image >> 15) & 1;
3748 SET_REAL_EXP (r, exp - 128);
3750 image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff);
3751 r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
3755 static void
3756 encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
3757 const REAL_VALUE_TYPE *r)
3759 unsigned long image0, image1, sign = r->sign << 15;
3761 switch (r->cl)
3763 case rvc_zero:
3764 image0 = image1 = 0;
3765 break;
3767 case rvc_inf:
3768 case rvc_nan:
3769 image0 = 0xffff7fff | sign;
3770 image1 = 0xffffffff;
3771 break;
3773 case rvc_normal:
3774 /* Extract the significand into straight hi:lo. */
3775 if (HOST_BITS_PER_LONG == 64)
3777 image0 = r->sig[SIGSZ-1];
3778 image1 = (image0 >> (64 - 56)) & 0xffffffff;
3779 image0 = (image0 >> (64 - 56 + 1) >> 31) & 0x7fffff;
3781 else
3783 image0 = r->sig[SIGSZ-1];
3784 image1 = r->sig[SIGSZ-2];
3785 image1 = (image0 << 24) | (image1 >> 8);
3786 image0 = (image0 >> 8) & 0xffffff;
3789 /* Rearrange the half-words of the significand to match the
3790 external format. */
3791 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff007f;
3792 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
3794 /* Add the sign and exponent. */
3795 image0 |= sign;
3796 image0 |= (REAL_EXP (r) + 128) << 7;
3797 break;
3799 default:
3800 gcc_unreachable ();
3803 if (FLOAT_WORDS_BIG_ENDIAN)
3804 buf[0] = image1, buf[1] = image0;
3805 else
3806 buf[0] = image0, buf[1] = image1;
3809 static void
3810 decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED,
3811 REAL_VALUE_TYPE *r, const long *buf)
3813 unsigned long image0, image1;
3814 int exp;
3816 if (FLOAT_WORDS_BIG_ENDIAN)
3817 image1 = buf[0], image0 = buf[1];
3818 else
3819 image0 = buf[0], image1 = buf[1];
3820 image0 &= 0xffffffff;
3821 image1 &= 0xffffffff;
3823 exp = (image0 >> 7) & 0xff;
3825 memset (r, 0, sizeof (*r));
3827 if (exp != 0)
3829 r->cl = rvc_normal;
3830 r->sign = (image0 >> 15) & 1;
3831 SET_REAL_EXP (r, exp - 128);
3833 /* Rearrange the half-words of the external format into
3834 proper ascending order. */
3835 image0 = ((image0 & 0x7f) << 16) | ((image0 >> 16) & 0xffff);
3836 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
3838 if (HOST_BITS_PER_LONG == 64)
3840 image0 = (image0 << 31 << 1) | image1;
3841 image0 <<= 64 - 56;
3842 image0 |= SIG_MSB;
3843 r->sig[SIGSZ-1] = image0;
3845 else
3847 r->sig[SIGSZ-1] = image0;
3848 r->sig[SIGSZ-2] = image1;
3849 lshift_significand (r, r, 2*HOST_BITS_PER_LONG - 56);
3850 r->sig[SIGSZ-1] |= SIG_MSB;
3855 static void
3856 encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
3857 const REAL_VALUE_TYPE *r)
3859 unsigned long image0, image1, sign = r->sign << 15;
3861 switch (r->cl)
3863 case rvc_zero:
3864 image0 = image1 = 0;
3865 break;
3867 case rvc_inf:
3868 case rvc_nan:
3869 image0 = 0xffff7fff | sign;
3870 image1 = 0xffffffff;
3871 break;
3873 case rvc_normal:
3874 /* Extract the significand into straight hi:lo. */
3875 if (HOST_BITS_PER_LONG == 64)
3877 image0 = r->sig[SIGSZ-1];
3878 image1 = (image0 >> (64 - 53)) & 0xffffffff;
3879 image0 = (image0 >> (64 - 53 + 1) >> 31) & 0xfffff;
3881 else
3883 image0 = r->sig[SIGSZ-1];
3884 image1 = r->sig[SIGSZ-2];
3885 image1 = (image0 << 21) | (image1 >> 11);
3886 image0 = (image0 >> 11) & 0xfffff;
3889 /* Rearrange the half-words of the significand to match the
3890 external format. */
3891 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff000f;
3892 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
3894 /* Add the sign and exponent. */
3895 image0 |= sign;
3896 image0 |= (REAL_EXP (r) + 1024) << 4;
3897 break;
3899 default:
3900 gcc_unreachable ();
3903 if (FLOAT_WORDS_BIG_ENDIAN)
3904 buf[0] = image1, buf[1] = image0;
3905 else
3906 buf[0] = image0, buf[1] = image1;
3909 static void
3910 decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED,
3911 REAL_VALUE_TYPE *r, const long *buf)
3913 unsigned long image0, image1;
3914 int exp;
3916 if (FLOAT_WORDS_BIG_ENDIAN)
3917 image1 = buf[0], image0 = buf[1];
3918 else
3919 image0 = buf[0], image1 = buf[1];
3920 image0 &= 0xffffffff;
3921 image1 &= 0xffffffff;
3923 exp = (image0 >> 4) & 0x7ff;
3925 memset (r, 0, sizeof (*r));
3927 if (exp != 0)
3929 r->cl = rvc_normal;
3930 r->sign = (image0 >> 15) & 1;
3931 SET_REAL_EXP (r, exp - 1024);
3933 /* Rearrange the half-words of the external format into
3934 proper ascending order. */
3935 image0 = ((image0 & 0xf) << 16) | ((image0 >> 16) & 0xffff);
3936 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
3938 if (HOST_BITS_PER_LONG == 64)
3940 image0 = (image0 << 31 << 1) | image1;
3941 image0 <<= 64 - 53;
3942 image0 |= SIG_MSB;
3943 r->sig[SIGSZ-1] = image0;
3945 else
3947 r->sig[SIGSZ-1] = image0;
3948 r->sig[SIGSZ-2] = image1;
3949 lshift_significand (r, r, 64 - 53);
3950 r->sig[SIGSZ-1] |= SIG_MSB;
3955 const struct real_format vax_f_format =
3957 encode_vax_f,
3958 decode_vax_f,
3963 -127,
3964 127,
3966 false,
3967 false,
3968 false,
3969 false,
3970 false
3973 const struct real_format vax_d_format =
3975 encode_vax_d,
3976 decode_vax_d,
3981 -127,
3982 127,
3984 false,
3985 false,
3986 false,
3987 false,
3988 false
3991 const struct real_format vax_g_format =
3993 encode_vax_g,
3994 decode_vax_g,
3999 -1023,
4000 1023,
4002 false,
4003 false,
4004 false,
4005 false,
4006 false
4009 /* A good reference for these can be found in chapter 9 of
4010 "ESA/390 Principles of Operation", IBM document number SA22-7201-01.
4011 An on-line version can be found here:
4013 http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/DZ9AR001/9.1?DT=19930923083613
4016 static void encode_i370_single (const struct real_format *fmt,
4017 long *, const REAL_VALUE_TYPE *);
4018 static void decode_i370_single (const struct real_format *,
4019 REAL_VALUE_TYPE *, const long *);
4020 static void encode_i370_double (const struct real_format *fmt,
4021 long *, const REAL_VALUE_TYPE *);
4022 static void decode_i370_double (const struct real_format *,
4023 REAL_VALUE_TYPE *, const long *);
4025 static void
4026 encode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4027 long *buf, const REAL_VALUE_TYPE *r)
4029 unsigned long sign, exp, sig, image;
4031 sign = r->sign << 31;
4033 switch (r->cl)
4035 case rvc_zero:
4036 image = 0;
4037 break;
4039 case rvc_inf:
4040 case rvc_nan:
4041 image = 0x7fffffff | sign;
4042 break;
4044 case rvc_normal:
4045 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0xffffff;
4046 exp = ((REAL_EXP (r) / 4) + 64) << 24;
4047 image = sign | exp | sig;
4048 break;
4050 default:
4051 gcc_unreachable ();
4054 buf[0] = image;
4057 static void
4058 decode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4059 REAL_VALUE_TYPE *r, const long *buf)
4061 unsigned long sign, sig, image = buf[0];
4062 int exp;
4064 sign = (image >> 31) & 1;
4065 exp = (image >> 24) & 0x7f;
4066 sig = image & 0xffffff;
4068 memset (r, 0, sizeof (*r));
4070 if (exp || sig)
4072 r->cl = rvc_normal;
4073 r->sign = sign;
4074 SET_REAL_EXP (r, (exp - 64) * 4);
4075 r->sig[SIGSZ-1] = sig << (HOST_BITS_PER_LONG - 24);
4076 normalize (r);
4080 static void
4081 encode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4082 long *buf, const REAL_VALUE_TYPE *r)
4084 unsigned long sign, exp, image_hi, image_lo;
4086 sign = r->sign << 31;
4088 switch (r->cl)
4090 case rvc_zero:
4091 image_hi = image_lo = 0;
4092 break;
4094 case rvc_inf:
4095 case rvc_nan:
4096 image_hi = 0x7fffffff | sign;
4097 image_lo = 0xffffffff;
4098 break;
4100 case rvc_normal:
4101 if (HOST_BITS_PER_LONG == 64)
4103 image_hi = r->sig[SIGSZ-1];
4104 image_lo = (image_hi >> (64 - 56)) & 0xffffffff;
4105 image_hi = (image_hi >> (64 - 56 + 1) >> 31) & 0xffffff;
4107 else
4109 image_hi = r->sig[SIGSZ-1];
4110 image_lo = r->sig[SIGSZ-2];
4111 image_lo = (image_lo >> 8) | (image_hi << 24);
4112 image_hi >>= 8;
4115 exp = ((REAL_EXP (r) / 4) + 64) << 24;
4116 image_hi |= sign | exp;
4117 break;
4119 default:
4120 gcc_unreachable ();
4123 if (FLOAT_WORDS_BIG_ENDIAN)
4124 buf[0] = image_hi, buf[1] = image_lo;
4125 else
4126 buf[0] = image_lo, buf[1] = image_hi;
4129 static void
4130 decode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4131 REAL_VALUE_TYPE *r, const long *buf)
4133 unsigned long sign, image_hi, image_lo;
4134 int exp;
4136 if (FLOAT_WORDS_BIG_ENDIAN)
4137 image_hi = buf[0], image_lo = buf[1];
4138 else
4139 image_lo = buf[0], image_hi = buf[1];
4141 sign = (image_hi >> 31) & 1;
4142 exp = (image_hi >> 24) & 0x7f;
4143 image_hi &= 0xffffff;
4144 image_lo &= 0xffffffff;
4146 memset (r, 0, sizeof (*r));
4148 if (exp || image_hi || image_lo)
4150 r->cl = rvc_normal;
4151 r->sign = sign;
4152 SET_REAL_EXP (r, (exp - 64) * 4 + (SIGNIFICAND_BITS - 56));
4154 if (HOST_BITS_PER_LONG == 32)
4156 r->sig[0] = image_lo;
4157 r->sig[1] = image_hi;
4159 else
4160 r->sig[0] = image_lo | (image_hi << 31 << 1);
4162 normalize (r);
4166 const struct real_format i370_single_format =
4168 encode_i370_single,
4169 decode_i370_single,
4174 -64,
4177 false,
4178 false,
4179 false, /* ??? The encoding does allow for "unnormals". */
4180 false, /* ??? The encoding does allow for "unnormals". */
4181 false
4184 const struct real_format i370_double_format =
4186 encode_i370_double,
4187 decode_i370_double,
4192 -64,
4195 false,
4196 false,
4197 false, /* ??? The encoding does allow for "unnormals". */
4198 false, /* ??? The encoding does allow for "unnormals". */
4199 false
4202 /* The "twos-complement" c4x format is officially defined as
4204 x = s(~s).f * 2**e
4206 This is rather misleading. One must remember that F is signed.
4207 A better description would be
4209 x = -1**s * ((s + 1 + .f) * 2**e
4211 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
4212 that's -1 * (1+1+(-.5)) == -1.5. I think.
4214 The constructions here are taken from Tables 5-1 and 5-2 of the
4215 TMS320C4x User's Guide wherein step-by-step instructions for
4216 conversion from IEEE are presented. That's close enough to our
4217 internal representation so as to make things easy.
4219 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
4221 static void encode_c4x_single (const struct real_format *fmt,
4222 long *, const REAL_VALUE_TYPE *);
4223 static void decode_c4x_single (const struct real_format *,
4224 REAL_VALUE_TYPE *, const long *);
4225 static void encode_c4x_extended (const struct real_format *fmt,
4226 long *, const REAL_VALUE_TYPE *);
4227 static void decode_c4x_extended (const struct real_format *,
4228 REAL_VALUE_TYPE *, const long *);
4230 static void
4231 encode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4232 long *buf, const REAL_VALUE_TYPE *r)
4234 unsigned long image, exp, sig;
4236 switch (r->cl)
4238 case rvc_zero:
4239 exp = -128;
4240 sig = 0;
4241 break;
4243 case rvc_inf:
4244 case rvc_nan:
4245 exp = 127;
4246 sig = 0x800000 - r->sign;
4247 break;
4249 case rvc_normal:
4250 exp = REAL_EXP (r) - 1;
4251 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
4252 if (r->sign)
4254 if (sig)
4255 sig = -sig;
4256 else
4257 exp--;
4258 sig |= 0x800000;
4260 break;
4262 default:
4263 gcc_unreachable ();
4266 image = ((exp & 0xff) << 24) | (sig & 0xffffff);
4267 buf[0] = image;
4270 static void
4271 decode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4272 REAL_VALUE_TYPE *r, const long *buf)
4274 unsigned long image = buf[0];
4275 unsigned long sig;
4276 int exp, sf;
4278 exp = (((image >> 24) & 0xff) ^ 0x80) - 0x80;
4279 sf = ((image & 0xffffff) ^ 0x800000) - 0x800000;
4281 memset (r, 0, sizeof (*r));
4283 if (exp != -128)
4285 r->cl = rvc_normal;
4287 sig = sf & 0x7fffff;
4288 if (sf < 0)
4290 r->sign = 1;
4291 if (sig)
4292 sig = -sig;
4293 else
4294 exp++;
4296 sig = (sig << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
4298 SET_REAL_EXP (r, exp + 1);
4299 r->sig[SIGSZ-1] = sig;
4303 static void
4304 encode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
4305 long *buf, const REAL_VALUE_TYPE *r)
4307 unsigned long exp, sig;
4309 switch (r->cl)
4311 case rvc_zero:
4312 exp = -128;
4313 sig = 0;
4314 break;
4316 case rvc_inf:
4317 case rvc_nan:
4318 exp = 127;
4319 sig = 0x80000000 - r->sign;
4320 break;
4322 case rvc_normal:
4323 exp = REAL_EXP (r) - 1;
4325 sig = r->sig[SIGSZ-1];
4326 if (HOST_BITS_PER_LONG == 64)
4327 sig = sig >> 1 >> 31;
4328 sig &= 0x7fffffff;
4330 if (r->sign)
4332 if (sig)
4333 sig = -sig;
4334 else
4335 exp--;
4336 sig |= 0x80000000;
4338 break;
4340 default:
4341 gcc_unreachable ();
4344 exp = (exp & 0xff) << 24;
4345 sig &= 0xffffffff;
4347 if (FLOAT_WORDS_BIG_ENDIAN)
4348 buf[0] = exp, buf[1] = sig;
4349 else
4350 buf[0] = sig, buf[0] = exp;
4353 static void
4354 decode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
4355 REAL_VALUE_TYPE *r, const long *buf)
4357 unsigned long sig;
4358 int exp, sf;
4360 if (FLOAT_WORDS_BIG_ENDIAN)
4361 exp = buf[0], sf = buf[1];
4362 else
4363 sf = buf[0], exp = buf[1];
4365 exp = (((exp >> 24) & 0xff) & 0x80) - 0x80;
4366 sf = ((sf & 0xffffffff) ^ 0x80000000) - 0x80000000;
4368 memset (r, 0, sizeof (*r));
4370 if (exp != -128)
4372 r->cl = rvc_normal;
4374 sig = sf & 0x7fffffff;
4375 if (sf < 0)
4377 r->sign = 1;
4378 if (sig)
4379 sig = -sig;
4380 else
4381 exp++;
4383 if (HOST_BITS_PER_LONG == 64)
4384 sig = sig << 1 << 31;
4385 sig |= SIG_MSB;
4387 SET_REAL_EXP (r, exp + 1);
4388 r->sig[SIGSZ-1] = sig;
4392 const struct real_format c4x_single_format =
4394 encode_c4x_single,
4395 decode_c4x_single,
4400 -126,
4401 128,
4403 false,
4404 false,
4405 false,
4406 false,
4407 false
4410 const struct real_format c4x_extended_format =
4412 encode_c4x_extended,
4413 decode_c4x_extended,
4418 -126,
4419 128,
4421 false,
4422 false,
4423 false,
4424 false,
4425 false
4429 /* A synthetic "format" for internal arithmetic. It's the size of the
4430 internal significand minus the two bits needed for proper rounding.
4431 The encode and decode routines exist only to satisfy our paranoia
4432 harness. */
4434 static void encode_internal (const struct real_format *fmt,
4435 long *, const REAL_VALUE_TYPE *);
4436 static void decode_internal (const struct real_format *,
4437 REAL_VALUE_TYPE *, const long *);
4439 static void
4440 encode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4441 const REAL_VALUE_TYPE *r)
4443 memcpy (buf, r, sizeof (*r));
4446 static void
4447 decode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED,
4448 REAL_VALUE_TYPE *r, const long *buf)
4450 memcpy (r, buf, sizeof (*r));
4453 const struct real_format real_internal_format =
4455 encode_internal,
4456 decode_internal,
4459 SIGNIFICAND_BITS - 2,
4460 SIGNIFICAND_BITS - 2,
4461 -MAX_EXP,
4462 MAX_EXP,
4464 true,
4465 true,
4466 false,
4467 true,
4468 true
4471 /* Calculate the square root of X in mode MODE, and store the result
4472 in R. Return TRUE if the operation does not raise an exception.
4473 For details see "High Precision Division and Square Root",
4474 Alan H. Karp and Peter Markstein, HP Lab Report 93-93-42, June
4475 1993. http://www.hpl.hp.com/techreports/93/HPL-93-42.pdf. */
4477 bool
4478 real_sqrt (REAL_VALUE_TYPE *r, enum machine_mode mode,
4479 const REAL_VALUE_TYPE *x)
4481 static REAL_VALUE_TYPE halfthree;
4482 static bool init = false;
4483 REAL_VALUE_TYPE h, t, i;
4484 int iter, exp;
4486 /* sqrt(-0.0) is -0.0. */
4487 if (real_isnegzero (x))
4489 *r = *x;
4490 return false;
4493 /* Negative arguments return NaN. */
4494 if (real_isneg (x))
4496 get_canonical_qnan (r, 0);
4497 return false;
4500 /* Infinity and NaN return themselves. */
4501 if (real_isinf (x) || real_isnan (x))
4503 *r = *x;
4504 return false;
4507 if (!init)
4509 do_add (&halfthree, &dconst1, &dconsthalf, 0);
4510 init = true;
4513 /* Initial guess for reciprocal sqrt, i. */
4514 exp = real_exponent (x);
4515 real_ldexp (&i, &dconst1, -exp/2);
4517 /* Newton's iteration for reciprocal sqrt, i. */
4518 for (iter = 0; iter < 16; iter++)
4520 /* i(n+1) = i(n) * (1.5 - 0.5*i(n)*i(n)*x). */
4521 do_multiply (&t, x, &i);
4522 do_multiply (&h, &t, &i);
4523 do_multiply (&t, &h, &dconsthalf);
4524 do_add (&h, &halfthree, &t, 1);
4525 do_multiply (&t, &i, &h);
4527 /* Check for early convergence. */
4528 if (iter >= 6 && real_identical (&i, &t))
4529 break;
4531 /* ??? Unroll loop to avoid copying. */
4532 i = t;
4535 /* Final iteration: r = i*x + 0.5*i*x*(1.0 - i*(i*x)). */
4536 do_multiply (&t, x, &i);
4537 do_multiply (&h, &t, &i);
4538 do_add (&i, &dconst1, &h, 1);
4539 do_multiply (&h, &t, &i);
4540 do_multiply (&i, &dconsthalf, &h);
4541 do_add (&h, &t, &i, 0);
4543 /* ??? We need a Tuckerman test to get the last bit. */
4545 real_convert (r, mode, &h);
4546 return true;
4549 /* Calculate X raised to the integer exponent N in mode MODE and store
4550 the result in R. Return true if the result may be inexact due to
4551 loss of precision. The algorithm is the classic "left-to-right binary
4552 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
4553 Algorithms", "The Art of Computer Programming", Volume 2. */
4555 bool
4556 real_powi (REAL_VALUE_TYPE *r, enum machine_mode mode,
4557 const REAL_VALUE_TYPE *x, HOST_WIDE_INT n)
4559 unsigned HOST_WIDE_INT bit;
4560 REAL_VALUE_TYPE t;
4561 bool inexact = false;
4562 bool init = false;
4563 bool neg;
4564 int i;
4566 if (n == 0)
4568 *r = dconst1;
4569 return false;
4571 else if (n < 0)
4573 /* Don't worry about overflow, from now on n is unsigned. */
4574 neg = true;
4575 n = -n;
4577 else
4578 neg = false;
4580 t = *x;
4581 bit = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
4582 for (i = 0; i < HOST_BITS_PER_WIDE_INT; i++)
4584 if (init)
4586 inexact |= do_multiply (&t, &t, &t);
4587 if (n & bit)
4588 inexact |= do_multiply (&t, &t, x);
4590 else if (n & bit)
4591 init = true;
4592 bit >>= 1;
4595 if (neg)
4596 inexact |= do_divide (&t, &dconst1, &t);
4598 real_convert (r, mode, &t);
4599 return inexact;
4602 /* Round X to the nearest integer not larger in absolute value, i.e.
4603 towards zero, placing the result in R in mode MODE. */
4605 void
4606 real_trunc (REAL_VALUE_TYPE *r, enum machine_mode mode,
4607 const REAL_VALUE_TYPE *x)
4609 do_fix_trunc (r, x);
4610 if (mode != VOIDmode)
4611 real_convert (r, mode, r);
4614 /* Round X to the largest integer not greater in value, i.e. round
4615 down, placing the result in R in mode MODE. */
4617 void
4618 real_floor (REAL_VALUE_TYPE *r, enum machine_mode mode,
4619 const REAL_VALUE_TYPE *x)
4621 REAL_VALUE_TYPE t;
4623 do_fix_trunc (&t, x);
4624 if (! real_identical (&t, x) && x->sign)
4625 do_add (&t, &t, &dconstm1, 0);
4626 if (mode != VOIDmode)
4627 real_convert (r, mode, &t);
4630 /* Round X to the smallest integer not less then argument, i.e. round
4631 up, placing the result in R in mode MODE. */
4633 void
4634 real_ceil (REAL_VALUE_TYPE *r, enum machine_mode mode,
4635 const REAL_VALUE_TYPE *x)
4637 REAL_VALUE_TYPE t;
4639 do_fix_trunc (&t, x);
4640 if (! real_identical (&t, x) && ! x->sign)
4641 do_add (&t, &t, &dconst1, 0);
4642 if (mode != VOIDmode)
4643 real_convert (r, mode, &t);
4646 /* Round X to the nearest integer, but round halfway cases away from
4647 zero. */
4649 void
4650 real_round (REAL_VALUE_TYPE *r, enum machine_mode mode,
4651 const REAL_VALUE_TYPE *x)
4653 do_add (r, x, &dconsthalf, x->sign);
4654 do_fix_trunc (r, r);
4655 if (mode != VOIDmode)
4656 real_convert (r, mode, r);
4659 /* Set the sign of R to the sign of X. */
4661 void
4662 real_copysign (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *x)
4664 r->sign = x->sign;