* gimple-ssa-evrp.c (class evrp_range_analyzer): New class extracted
[official-gcc.git] / gcc / real.c
bloba5671b2865bd10db1d26bfa02cc592aa109a43e2
1 /* real.c - software floating point emulation.
2 Copyright (C) 1993-2017 Free Software Foundation, Inc.
3 Contributed by Stephen L. Moshier (moshier@world.std.com).
4 Re-written by Richard Henderson <rth@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "tree.h"
28 #include "realmpfr.h"
29 #include "dfp.h"
31 /* The floating point model used internally is not exactly IEEE 754
32 compliant, and close to the description in the ISO C99 standard,
33 section 5.2.4.2.2 Characteristics of floating types.
35 Specifically
37 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
39 where
40 s = sign (+- 1)
41 b = base or radix, here always 2
42 e = exponent
43 p = precision (the number of base-b digits in the significand)
44 f_k = the digits of the significand.
46 We differ from typical IEEE 754 encodings in that the entire
47 significand is fractional. Normalized significands are in the
48 range [0.5, 1.0).
50 A requirement of the model is that P be larger than the largest
51 supported target floating-point type by at least 2 bits. This gives
52 us proper rounding when we truncate to the target type. In addition,
53 E must be large enough to hold the smallest supported denormal number
54 in a normalized form.
56 Both of these requirements are easily satisfied. The largest target
57 significand is 113 bits; we store at least 160. The smallest
58 denormal number fits in 17 exponent bits; we store 26. */
61 /* Used to classify two numbers simultaneously. */
62 #define CLASS2(A, B) ((A) << 2 | (B))
64 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
65 #error "Some constant folding done by hand to avoid shift count warnings"
66 #endif
68 static void get_zero (REAL_VALUE_TYPE *, int);
69 static void get_canonical_qnan (REAL_VALUE_TYPE *, int);
70 static void get_canonical_snan (REAL_VALUE_TYPE *, int);
71 static void get_inf (REAL_VALUE_TYPE *, int);
72 static bool sticky_rshift_significand (REAL_VALUE_TYPE *,
73 const REAL_VALUE_TYPE *, unsigned int);
74 static void rshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
75 unsigned int);
76 static void lshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
77 unsigned int);
78 static void lshift_significand_1 (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
79 static bool add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *,
80 const REAL_VALUE_TYPE *);
81 static bool sub_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
82 const REAL_VALUE_TYPE *, int);
83 static void neg_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
84 static int cmp_significands (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
85 static int cmp_significand_0 (const REAL_VALUE_TYPE *);
86 static void set_significand_bit (REAL_VALUE_TYPE *, unsigned int);
87 static void clear_significand_bit (REAL_VALUE_TYPE *, unsigned int);
88 static bool test_significand_bit (REAL_VALUE_TYPE *, unsigned int);
89 static void clear_significand_below (REAL_VALUE_TYPE *, unsigned int);
90 static bool div_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
91 const REAL_VALUE_TYPE *);
92 static void normalize (REAL_VALUE_TYPE *);
94 static bool do_add (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
95 const REAL_VALUE_TYPE *, int);
96 static bool do_multiply (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
97 const REAL_VALUE_TYPE *);
98 static bool do_divide (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
99 const REAL_VALUE_TYPE *);
100 static int do_compare (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
101 static void do_fix_trunc (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
103 static unsigned long rtd_divmod (REAL_VALUE_TYPE *, REAL_VALUE_TYPE *);
104 static void decimal_from_integer (REAL_VALUE_TYPE *);
105 static void decimal_integer_string (char *, const REAL_VALUE_TYPE *,
106 size_t);
108 static const REAL_VALUE_TYPE * ten_to_ptwo (int);
109 static const REAL_VALUE_TYPE * ten_to_mptwo (int);
110 static const REAL_VALUE_TYPE * real_digit (int);
111 static void times_pten (REAL_VALUE_TYPE *, int);
113 static void round_for_format (const struct real_format *, REAL_VALUE_TYPE *);
115 /* Initialize R with a positive zero. */
117 static inline void
118 get_zero (REAL_VALUE_TYPE *r, int sign)
120 memset (r, 0, sizeof (*r));
121 r->sign = sign;
124 /* Initialize R with the canonical quiet NaN. */
126 static inline void
127 get_canonical_qnan (REAL_VALUE_TYPE *r, int sign)
129 memset (r, 0, sizeof (*r));
130 r->cl = rvc_nan;
131 r->sign = sign;
132 r->canonical = 1;
135 static inline void
136 get_canonical_snan (REAL_VALUE_TYPE *r, int sign)
138 memset (r, 0, sizeof (*r));
139 r->cl = rvc_nan;
140 r->sign = sign;
141 r->signalling = 1;
142 r->canonical = 1;
145 static inline void
146 get_inf (REAL_VALUE_TYPE *r, int sign)
148 memset (r, 0, sizeof (*r));
149 r->cl = rvc_inf;
150 r->sign = sign;
154 /* Right-shift the significand of A by N bits; put the result in the
155 significand of R. If any one bits are shifted out, return true. */
157 static bool
158 sticky_rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
159 unsigned int n)
161 unsigned long sticky = 0;
162 unsigned int i, ofs = 0;
164 if (n >= HOST_BITS_PER_LONG)
166 for (i = 0, ofs = n / HOST_BITS_PER_LONG; i < ofs; ++i)
167 sticky |= a->sig[i];
168 n &= HOST_BITS_PER_LONG - 1;
171 if (n != 0)
173 sticky |= a->sig[ofs] & (((unsigned long)1 << n) - 1);
174 for (i = 0; i < SIGSZ; ++i)
176 r->sig[i]
177 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
178 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
179 << (HOST_BITS_PER_LONG - n)));
182 else
184 for (i = 0; ofs + i < SIGSZ; ++i)
185 r->sig[i] = a->sig[ofs + i];
186 for (; i < SIGSZ; ++i)
187 r->sig[i] = 0;
190 return sticky != 0;
193 /* Right-shift the significand of A by N bits; put the result in the
194 significand of R. */
196 static void
197 rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
198 unsigned int n)
200 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
202 n &= HOST_BITS_PER_LONG - 1;
203 if (n != 0)
205 for (i = 0; i < SIGSZ; ++i)
207 r->sig[i]
208 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
209 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
210 << (HOST_BITS_PER_LONG - n)));
213 else
215 for (i = 0; ofs + i < SIGSZ; ++i)
216 r->sig[i] = a->sig[ofs + i];
217 for (; i < SIGSZ; ++i)
218 r->sig[i] = 0;
222 /* Left-shift the significand of A by N bits; put the result in the
223 significand of R. */
225 static void
226 lshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
227 unsigned int n)
229 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
231 n &= HOST_BITS_PER_LONG - 1;
232 if (n == 0)
234 for (i = 0; ofs + i < SIGSZ; ++i)
235 r->sig[SIGSZ-1-i] = a->sig[SIGSZ-1-i-ofs];
236 for (; i < SIGSZ; ++i)
237 r->sig[SIGSZ-1-i] = 0;
239 else
240 for (i = 0; i < SIGSZ; ++i)
242 r->sig[SIGSZ-1-i]
243 = (((ofs + i >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs]) << n)
244 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs-1])
245 >> (HOST_BITS_PER_LONG - n)));
249 /* Likewise, but N is specialized to 1. */
251 static inline void
252 lshift_significand_1 (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
254 unsigned int i;
256 for (i = SIGSZ - 1; i > 0; --i)
257 r->sig[i] = (a->sig[i] << 1) | (a->sig[i-1] >> (HOST_BITS_PER_LONG - 1));
258 r->sig[0] = a->sig[0] << 1;
261 /* Add the significands of A and B, placing the result in R. Return
262 true if there was carry out of the most significant word. */
264 static inline bool
265 add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
266 const REAL_VALUE_TYPE *b)
268 bool carry = false;
269 int i;
271 for (i = 0; i < SIGSZ; ++i)
273 unsigned long ai = a->sig[i];
274 unsigned long ri = ai + b->sig[i];
276 if (carry)
278 carry = ri < ai;
279 carry |= ++ri == 0;
281 else
282 carry = ri < ai;
284 r->sig[i] = ri;
287 return carry;
290 /* Subtract the significands of A and B, placing the result in R. CARRY is
291 true if there's a borrow incoming to the least significant word.
292 Return true if there was borrow out of the most significant word. */
294 static inline bool
295 sub_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
296 const REAL_VALUE_TYPE *b, int carry)
298 int i;
300 for (i = 0; i < SIGSZ; ++i)
302 unsigned long ai = a->sig[i];
303 unsigned long ri = ai - b->sig[i];
305 if (carry)
307 carry = ri > ai;
308 carry |= ~--ri == 0;
310 else
311 carry = ri > ai;
313 r->sig[i] = ri;
316 return carry;
319 /* Negate the significand A, placing the result in R. */
321 static inline void
322 neg_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
324 bool carry = true;
325 int i;
327 for (i = 0; i < SIGSZ; ++i)
329 unsigned long ri, ai = a->sig[i];
331 if (carry)
333 if (ai)
335 ri = -ai;
336 carry = false;
338 else
339 ri = ai;
341 else
342 ri = ~ai;
344 r->sig[i] = ri;
348 /* Compare significands. Return tri-state vs zero. */
350 static inline int
351 cmp_significands (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
353 int i;
355 for (i = SIGSZ - 1; i >= 0; --i)
357 unsigned long ai = a->sig[i];
358 unsigned long bi = b->sig[i];
360 if (ai > bi)
361 return 1;
362 if (ai < bi)
363 return -1;
366 return 0;
369 /* Return true if A is nonzero. */
371 static inline int
372 cmp_significand_0 (const REAL_VALUE_TYPE *a)
374 int i;
376 for (i = SIGSZ - 1; i >= 0; --i)
377 if (a->sig[i])
378 return 1;
380 return 0;
383 /* Set bit N of the significand of R. */
385 static inline void
386 set_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
388 r->sig[n / HOST_BITS_PER_LONG]
389 |= (unsigned long)1 << (n % HOST_BITS_PER_LONG);
392 /* Clear bit N of the significand of R. */
394 static inline void
395 clear_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
397 r->sig[n / HOST_BITS_PER_LONG]
398 &= ~((unsigned long)1 << (n % HOST_BITS_PER_LONG));
401 /* Test bit N of the significand of R. */
403 static inline bool
404 test_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
406 /* ??? Compiler bug here if we return this expression directly.
407 The conversion to bool strips the "&1" and we wind up testing
408 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
409 int t = (r->sig[n / HOST_BITS_PER_LONG] >> (n % HOST_BITS_PER_LONG)) & 1;
410 return t;
413 /* Clear bits 0..N-1 of the significand of R. */
415 static void
416 clear_significand_below (REAL_VALUE_TYPE *r, unsigned int n)
418 int i, w = n / HOST_BITS_PER_LONG;
420 for (i = 0; i < w; ++i)
421 r->sig[i] = 0;
423 r->sig[w] &= ~(((unsigned long)1 << (n % HOST_BITS_PER_LONG)) - 1);
426 /* Divide the significands of A and B, placing the result in R. Return
427 true if the division was inexact. */
429 static inline bool
430 div_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
431 const REAL_VALUE_TYPE *b)
433 REAL_VALUE_TYPE u;
434 int i, bit = SIGNIFICAND_BITS - 1;
435 unsigned long msb, inexact;
437 u = *a;
438 memset (r->sig, 0, sizeof (r->sig));
440 msb = 0;
441 goto start;
444 msb = u.sig[SIGSZ-1] & SIG_MSB;
445 lshift_significand_1 (&u, &u);
446 start:
447 if (msb || cmp_significands (&u, b) >= 0)
449 sub_significands (&u, &u, b, 0);
450 set_significand_bit (r, bit);
453 while (--bit >= 0);
455 for (i = 0, inexact = 0; i < SIGSZ; i++)
456 inexact |= u.sig[i];
458 return inexact != 0;
461 /* Adjust the exponent and significand of R such that the most
462 significant bit is set. We underflow to zero and overflow to
463 infinity here, without denormals. (The intermediate representation
464 exponent is large enough to handle target denormals normalized.) */
466 static void
467 normalize (REAL_VALUE_TYPE *r)
469 int shift = 0, exp;
470 int i, j;
472 if (r->decimal)
473 return;
475 /* Find the first word that is nonzero. */
476 for (i = SIGSZ - 1; i >= 0; i--)
477 if (r->sig[i] == 0)
478 shift += HOST_BITS_PER_LONG;
479 else
480 break;
482 /* Zero significand flushes to zero. */
483 if (i < 0)
485 r->cl = rvc_zero;
486 SET_REAL_EXP (r, 0);
487 return;
490 /* Find the first bit that is nonzero. */
491 for (j = 0; ; j++)
492 if (r->sig[i] & ((unsigned long)1 << (HOST_BITS_PER_LONG - 1 - j)))
493 break;
494 shift += j;
496 if (shift > 0)
498 exp = REAL_EXP (r) - shift;
499 if (exp > MAX_EXP)
500 get_inf (r, r->sign);
501 else if (exp < -MAX_EXP)
502 get_zero (r, r->sign);
503 else
505 SET_REAL_EXP (r, exp);
506 lshift_significand (r, r, shift);
511 /* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the
512 result may be inexact due to a loss of precision. */
514 static bool
515 do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
516 const REAL_VALUE_TYPE *b, int subtract_p)
518 int dexp, sign, exp;
519 REAL_VALUE_TYPE t;
520 bool inexact = false;
522 /* Determine if we need to add or subtract. */
523 sign = a->sign;
524 subtract_p = (sign ^ b->sign) ^ subtract_p;
526 switch (CLASS2 (a->cl, b->cl))
528 case CLASS2 (rvc_zero, rvc_zero):
529 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
530 get_zero (r, sign & !subtract_p);
531 return false;
533 case CLASS2 (rvc_zero, rvc_normal):
534 case CLASS2 (rvc_zero, rvc_inf):
535 case CLASS2 (rvc_zero, rvc_nan):
536 /* 0 + ANY = ANY. */
537 case CLASS2 (rvc_normal, rvc_nan):
538 case CLASS2 (rvc_inf, rvc_nan):
539 case CLASS2 (rvc_nan, rvc_nan):
540 /* ANY + NaN = NaN. */
541 case CLASS2 (rvc_normal, rvc_inf):
542 /* R + Inf = Inf. */
543 *r = *b;
544 /* Make resulting NaN value to be qNaN. The caller has the
545 responsibility to avoid the operation if flag_signaling_nans
546 is on. */
547 r->signalling = 0;
548 r->sign = sign ^ subtract_p;
549 return false;
551 case CLASS2 (rvc_normal, rvc_zero):
552 case CLASS2 (rvc_inf, rvc_zero):
553 case CLASS2 (rvc_nan, rvc_zero):
554 /* ANY + 0 = ANY. */
555 case CLASS2 (rvc_nan, rvc_normal):
556 case CLASS2 (rvc_nan, rvc_inf):
557 /* NaN + ANY = NaN. */
558 case CLASS2 (rvc_inf, rvc_normal):
559 /* Inf + R = Inf. */
560 *r = *a;
561 /* Make resulting NaN value to be qNaN. The caller has the
562 responsibility to avoid the operation if flag_signaling_nans
563 is on. */
564 r->signalling = 0;
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);
643 /* Zero out the remaining fields. */
644 r->signalling = 0;
645 r->canonical = 0;
646 r->decimal = 0;
648 /* Re-normalize the result. */
649 normalize (r);
651 /* Special case: if the subtraction results in zero, the result
652 is positive. */
653 if (r->cl == rvc_zero)
654 r->sign = 0;
655 else
656 r->sig[0] |= inexact;
658 return inexact;
661 /* Calculate R = A * B. Return true if the result may be inexact. */
663 static bool
664 do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
665 const REAL_VALUE_TYPE *b)
667 REAL_VALUE_TYPE u, t, *rr;
668 unsigned int i, j, k;
669 int sign = a->sign ^ b->sign;
670 bool inexact = false;
672 switch (CLASS2 (a->cl, b->cl))
674 case CLASS2 (rvc_zero, rvc_zero):
675 case CLASS2 (rvc_zero, rvc_normal):
676 case CLASS2 (rvc_normal, rvc_zero):
677 /* +-0 * ANY = 0 with appropriate sign. */
678 get_zero (r, sign);
679 return false;
681 case CLASS2 (rvc_zero, rvc_nan):
682 case CLASS2 (rvc_normal, rvc_nan):
683 case CLASS2 (rvc_inf, rvc_nan):
684 case CLASS2 (rvc_nan, rvc_nan):
685 /* ANY * NaN = NaN. */
686 *r = *b;
687 /* Make resulting NaN value to be qNaN. The caller has the
688 responsibility to avoid the operation if flag_signaling_nans
689 is on. */
690 r->signalling = 0;
691 r->sign = sign;
692 return false;
694 case CLASS2 (rvc_nan, rvc_zero):
695 case CLASS2 (rvc_nan, rvc_normal):
696 case CLASS2 (rvc_nan, rvc_inf):
697 /* NaN * ANY = NaN. */
698 *r = *a;
699 /* Make resulting NaN value to be qNaN. The caller has the
700 responsibility to avoid the operation if flag_signaling_nans
701 is on. */
702 r->signalling = 0;
703 r->sign = sign;
704 return false;
706 case CLASS2 (rvc_zero, rvc_inf):
707 case CLASS2 (rvc_inf, rvc_zero):
708 /* 0 * Inf = NaN */
709 get_canonical_qnan (r, sign);
710 return false;
712 case CLASS2 (rvc_inf, rvc_inf):
713 case CLASS2 (rvc_normal, rvc_inf):
714 case CLASS2 (rvc_inf, rvc_normal):
715 /* Inf * Inf = Inf, R * Inf = Inf */
716 get_inf (r, sign);
717 return false;
719 case CLASS2 (rvc_normal, rvc_normal):
720 break;
722 default:
723 gcc_unreachable ();
726 if (r == a || r == b)
727 rr = &t;
728 else
729 rr = r;
730 get_zero (rr, 0);
732 /* Collect all the partial products. Since we don't have sure access
733 to a widening multiply, we split each long into two half-words.
735 Consider the long-hand form of a four half-word multiplication:
737 A B C D
738 * E F G H
739 --------------
740 DE DF DG DH
741 CE CF CG CH
742 BE BF BG BH
743 AE AF AG AH
745 We construct partial products of the widened half-word products
746 that are known to not overlap, e.g. DF+DH. Each such partial
747 product is given its proper exponent, which allows us to sum them
748 and obtain the finished product. */
750 for (i = 0; i < SIGSZ * 2; ++i)
752 unsigned long ai = a->sig[i / 2];
753 if (i & 1)
754 ai >>= HOST_BITS_PER_LONG / 2;
755 else
756 ai &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
758 if (ai == 0)
759 continue;
761 for (j = 0; j < 2; ++j)
763 int exp = (REAL_EXP (a) - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2)
764 + (REAL_EXP (b) - (1-j)*(HOST_BITS_PER_LONG/2)));
766 if (exp > MAX_EXP)
768 get_inf (r, sign);
769 return true;
771 if (exp < -MAX_EXP)
773 /* Would underflow to zero, which we shouldn't bother adding. */
774 inexact = true;
775 continue;
778 memset (&u, 0, sizeof (u));
779 u.cl = rvc_normal;
780 SET_REAL_EXP (&u, exp);
782 for (k = j; k < SIGSZ * 2; k += 2)
784 unsigned long bi = b->sig[k / 2];
785 if (k & 1)
786 bi >>= HOST_BITS_PER_LONG / 2;
787 else
788 bi &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
790 u.sig[k / 2] = ai * bi;
793 normalize (&u);
794 inexact |= do_add (rr, rr, &u, 0);
798 rr->sign = sign;
799 if (rr != r)
800 *r = t;
802 return inexact;
805 /* Calculate R = A / B. Return true if the result may be inexact. */
807 static bool
808 do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
809 const REAL_VALUE_TYPE *b)
811 int exp, sign = a->sign ^ b->sign;
812 REAL_VALUE_TYPE t, *rr;
813 bool inexact;
815 switch (CLASS2 (a->cl, b->cl))
817 case CLASS2 (rvc_zero, rvc_zero):
818 /* 0 / 0 = NaN. */
819 case CLASS2 (rvc_inf, rvc_inf):
820 /* Inf / Inf = NaN. */
821 get_canonical_qnan (r, sign);
822 return false;
824 case CLASS2 (rvc_zero, rvc_normal):
825 case CLASS2 (rvc_zero, rvc_inf):
826 /* 0 / ANY = 0. */
827 case CLASS2 (rvc_normal, rvc_inf):
828 /* R / Inf = 0. */
829 get_zero (r, sign);
830 return false;
832 case CLASS2 (rvc_normal, rvc_zero):
833 /* R / 0 = Inf. */
834 case CLASS2 (rvc_inf, rvc_zero):
835 /* Inf / 0 = Inf. */
836 get_inf (r, sign);
837 return false;
839 case CLASS2 (rvc_zero, rvc_nan):
840 case CLASS2 (rvc_normal, rvc_nan):
841 case CLASS2 (rvc_inf, rvc_nan):
842 case CLASS2 (rvc_nan, rvc_nan):
843 /* ANY / NaN = NaN. */
844 *r = *b;
845 /* Make resulting NaN value to be qNaN. The caller has the
846 responsibility to avoid the operation if flag_signaling_nans
847 is on. */
848 r->signalling = 0;
849 r->sign = sign;
850 return false;
852 case CLASS2 (rvc_nan, rvc_zero):
853 case CLASS2 (rvc_nan, rvc_normal):
854 case CLASS2 (rvc_nan, rvc_inf):
855 /* NaN / ANY = NaN. */
856 *r = *a;
857 /* Make resulting NaN value to be qNaN. The caller has the
858 responsibility to avoid the operation if flag_signaling_nans
859 is on. */
860 r->signalling = 0;
861 r->sign = sign;
862 return false;
864 case CLASS2 (rvc_inf, rvc_normal):
865 /* Inf / R = Inf. */
866 get_inf (r, sign);
867 return false;
869 case CLASS2 (rvc_normal, rvc_normal):
870 break;
872 default:
873 gcc_unreachable ();
876 if (r == a || r == b)
877 rr = &t;
878 else
879 rr = r;
881 /* Make sure all fields in the result are initialized. */
882 get_zero (rr, 0);
883 rr->cl = rvc_normal;
884 rr->sign = sign;
886 exp = REAL_EXP (a) - REAL_EXP (b) + 1;
887 if (exp > MAX_EXP)
889 get_inf (r, sign);
890 return true;
892 if (exp < -MAX_EXP)
894 get_zero (r, sign);
895 return true;
897 SET_REAL_EXP (rr, exp);
899 inexact = div_significands (rr, a, b);
901 /* Re-normalize the result. */
902 normalize (rr);
903 rr->sig[0] |= inexact;
905 if (rr != r)
906 *r = t;
908 return inexact;
911 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
912 one of the two operands is a NaN. */
914 static int
915 do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
916 int nan_result)
918 int ret;
920 switch (CLASS2 (a->cl, b->cl))
922 case CLASS2 (rvc_zero, rvc_zero):
923 /* Sign of zero doesn't matter for compares. */
924 return 0;
926 case CLASS2 (rvc_normal, rvc_zero):
927 /* Decimal float zero is special and uses rvc_normal, not rvc_zero. */
928 if (a->decimal)
929 return decimal_do_compare (a, b, nan_result);
930 /* Fall through. */
931 case CLASS2 (rvc_inf, rvc_zero):
932 case CLASS2 (rvc_inf, rvc_normal):
933 return (a->sign ? -1 : 1);
935 case CLASS2 (rvc_inf, rvc_inf):
936 return -a->sign - -b->sign;
938 case CLASS2 (rvc_zero, rvc_normal):
939 /* Decimal float zero is special and uses rvc_normal, not rvc_zero. */
940 if (b->decimal)
941 return decimal_do_compare (a, b, nan_result);
942 /* Fall through. */
943 case CLASS2 (rvc_zero, rvc_inf):
944 case CLASS2 (rvc_normal, rvc_inf):
945 return (b->sign ? 1 : -1);
947 case CLASS2 (rvc_zero, rvc_nan):
948 case CLASS2 (rvc_normal, rvc_nan):
949 case CLASS2 (rvc_inf, rvc_nan):
950 case CLASS2 (rvc_nan, rvc_nan):
951 case CLASS2 (rvc_nan, rvc_zero):
952 case CLASS2 (rvc_nan, rvc_normal):
953 case CLASS2 (rvc_nan, rvc_inf):
954 return nan_result;
956 case CLASS2 (rvc_normal, rvc_normal):
957 break;
959 default:
960 gcc_unreachable ();
963 if (a->decimal || b->decimal)
964 return decimal_do_compare (a, b, nan_result);
966 if (a->sign != b->sign)
967 return -a->sign - -b->sign;
969 if (REAL_EXP (a) > REAL_EXP (b))
970 ret = 1;
971 else if (REAL_EXP (a) < REAL_EXP (b))
972 ret = -1;
973 else
974 ret = cmp_significands (a, b);
976 return (a->sign ? -ret : ret);
979 /* Return A truncated to an integral value toward zero. */
981 static void
982 do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
984 *r = *a;
986 switch (r->cl)
988 case rvc_zero:
989 case rvc_inf:
990 case rvc_nan:
991 /* Make resulting NaN value to be qNaN. The caller has the
992 responsibility to avoid the operation if flag_signaling_nans
993 is on. */
994 r->signalling = 0;
995 break;
997 case rvc_normal:
998 if (r->decimal)
1000 decimal_do_fix_trunc (r, a);
1001 return;
1003 if (REAL_EXP (r) <= 0)
1004 get_zero (r, r->sign);
1005 else if (REAL_EXP (r) < SIGNIFICAND_BITS)
1006 clear_significand_below (r, SIGNIFICAND_BITS - REAL_EXP (r));
1007 break;
1009 default:
1010 gcc_unreachable ();
1014 /* Perform the binary or unary operation described by CODE.
1015 For a unary operation, leave OP1 NULL. This function returns
1016 true if the result may be inexact due to loss of precision. */
1018 bool
1019 real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
1020 const REAL_VALUE_TYPE *op1)
1022 enum tree_code code = (enum tree_code) icode;
1024 if (op0->decimal || (op1 && op1->decimal))
1025 return decimal_real_arithmetic (r, code, op0, op1);
1027 switch (code)
1029 case PLUS_EXPR:
1030 /* Clear any padding areas in *r if it isn't equal to one of the
1031 operands so that we can later do bitwise comparisons later on. */
1032 if (r != op0 && r != op1)
1033 memset (r, '\0', sizeof (*r));
1034 return do_add (r, op0, op1, 0);
1036 case MINUS_EXPR:
1037 if (r != op0 && r != op1)
1038 memset (r, '\0', sizeof (*r));
1039 return do_add (r, op0, op1, 1);
1041 case MULT_EXPR:
1042 if (r != op0 && r != op1)
1043 memset (r, '\0', sizeof (*r));
1044 return do_multiply (r, op0, op1);
1046 case RDIV_EXPR:
1047 if (r != op0 && r != op1)
1048 memset (r, '\0', sizeof (*r));
1049 return do_divide (r, op0, op1);
1051 case MIN_EXPR:
1052 if (op1->cl == rvc_nan)
1054 *r = *op1;
1055 /* Make resulting NaN value to be qNaN. The caller has the
1056 responsibility to avoid the operation if flag_signaling_nans
1057 is on. */
1058 r->signalling = 0;
1060 else if (do_compare (op0, op1, -1) < 0)
1061 *r = *op0;
1062 else
1063 *r = *op1;
1064 break;
1066 case MAX_EXPR:
1067 if (op1->cl == rvc_nan)
1069 *r = *op1;
1070 /* Make resulting NaN value to be qNaN. The caller has the
1071 responsibility to avoid the operation if flag_signaling_nans
1072 is on. */
1073 r->signalling = 0;
1075 else if (do_compare (op0, op1, 1) < 0)
1076 *r = *op1;
1077 else
1078 *r = *op0;
1079 break;
1081 case NEGATE_EXPR:
1082 *r = *op0;
1083 r->sign ^= 1;
1084 break;
1086 case ABS_EXPR:
1087 *r = *op0;
1088 r->sign = 0;
1089 break;
1091 case FIX_TRUNC_EXPR:
1092 do_fix_trunc (r, op0);
1093 break;
1095 default:
1096 gcc_unreachable ();
1098 return false;
1101 REAL_VALUE_TYPE
1102 real_value_negate (const REAL_VALUE_TYPE *op0)
1104 REAL_VALUE_TYPE r;
1105 real_arithmetic (&r, NEGATE_EXPR, op0, NULL);
1106 return r;
1109 REAL_VALUE_TYPE
1110 real_value_abs (const REAL_VALUE_TYPE *op0)
1112 REAL_VALUE_TYPE r;
1113 real_arithmetic (&r, ABS_EXPR, op0, NULL);
1114 return r;
1117 /* Return whether OP0 == OP1. */
1119 bool
1120 real_equal (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1)
1122 return do_compare (op0, op1, -1) == 0;
1125 /* Return whether OP0 < OP1. */
1127 bool
1128 real_less (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1)
1130 return do_compare (op0, op1, 1) < 0;
1133 bool
1134 real_compare (int icode, const REAL_VALUE_TYPE *op0,
1135 const REAL_VALUE_TYPE *op1)
1137 enum tree_code code = (enum tree_code) icode;
1139 switch (code)
1141 case LT_EXPR:
1142 return real_less (op0, op1);
1143 case LE_EXPR:
1144 return do_compare (op0, op1, 1) <= 0;
1145 case GT_EXPR:
1146 return do_compare (op0, op1, -1) > 0;
1147 case GE_EXPR:
1148 return do_compare (op0, op1, -1) >= 0;
1149 case EQ_EXPR:
1150 return real_equal (op0, op1);
1151 case NE_EXPR:
1152 return do_compare (op0, op1, -1) != 0;
1153 case UNORDERED_EXPR:
1154 return op0->cl == rvc_nan || op1->cl == rvc_nan;
1155 case ORDERED_EXPR:
1156 return op0->cl != rvc_nan && op1->cl != rvc_nan;
1157 case UNLT_EXPR:
1158 return do_compare (op0, op1, -1) < 0;
1159 case UNLE_EXPR:
1160 return do_compare (op0, op1, -1) <= 0;
1161 case UNGT_EXPR:
1162 return do_compare (op0, op1, 1) > 0;
1163 case UNGE_EXPR:
1164 return do_compare (op0, op1, 1) >= 0;
1165 case UNEQ_EXPR:
1166 return do_compare (op0, op1, 0) == 0;
1167 case LTGT_EXPR:
1168 return do_compare (op0, op1, 0) != 0;
1170 default:
1171 gcc_unreachable ();
1175 /* Return floor log2(R). */
1178 real_exponent (const REAL_VALUE_TYPE *r)
1180 switch (r->cl)
1182 case rvc_zero:
1183 return 0;
1184 case rvc_inf:
1185 case rvc_nan:
1186 return (unsigned int)-1 >> 1;
1187 case rvc_normal:
1188 return REAL_EXP (r);
1189 default:
1190 gcc_unreachable ();
1194 /* R = OP0 * 2**EXP. */
1196 void
1197 real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
1199 *r = *op0;
1200 switch (r->cl)
1202 case rvc_zero:
1203 case rvc_inf:
1204 case rvc_nan:
1205 /* Make resulting NaN value to be qNaN. The caller has the
1206 responsibility to avoid the operation if flag_signaling_nans
1207 is on. */
1208 r->signalling = 0;
1209 break;
1211 case rvc_normal:
1212 exp += REAL_EXP (op0);
1213 if (exp > MAX_EXP)
1214 get_inf (r, r->sign);
1215 else if (exp < -MAX_EXP)
1216 get_zero (r, r->sign);
1217 else
1218 SET_REAL_EXP (r, exp);
1219 break;
1221 default:
1222 gcc_unreachable ();
1226 /* Determine whether a floating-point value X is infinite. */
1228 bool
1229 real_isinf (const REAL_VALUE_TYPE *r)
1231 return (r->cl == rvc_inf);
1234 /* Determine whether a floating-point value X is a NaN. */
1236 bool
1237 real_isnan (const REAL_VALUE_TYPE *r)
1239 return (r->cl == rvc_nan);
1242 /* Determine whether a floating-point value X is a signaling NaN. */
1243 bool real_issignaling_nan (const REAL_VALUE_TYPE *r)
1245 return real_isnan (r) && r->signalling;
1248 /* Determine whether a floating-point value X is finite. */
1250 bool
1251 real_isfinite (const REAL_VALUE_TYPE *r)
1253 return (r->cl != rvc_nan) && (r->cl != rvc_inf);
1256 /* Determine whether a floating-point value X is negative. */
1258 bool
1259 real_isneg (const REAL_VALUE_TYPE *r)
1261 return r->sign;
1264 /* Determine whether a floating-point value X is minus zero. */
1266 bool
1267 real_isnegzero (const REAL_VALUE_TYPE *r)
1269 return r->sign && r->cl == rvc_zero;
1272 /* Compare two floating-point objects for bitwise identity. */
1274 bool
1275 real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
1277 int i;
1279 if (a->cl != b->cl)
1280 return false;
1281 if (a->sign != b->sign)
1282 return false;
1284 switch (a->cl)
1286 case rvc_zero:
1287 case rvc_inf:
1288 return true;
1290 case rvc_normal:
1291 if (a->decimal != b->decimal)
1292 return false;
1293 if (REAL_EXP (a) != REAL_EXP (b))
1294 return false;
1295 break;
1297 case rvc_nan:
1298 if (a->signalling != b->signalling)
1299 return false;
1300 /* The significand is ignored for canonical NaNs. */
1301 if (a->canonical || b->canonical)
1302 return a->canonical == b->canonical;
1303 break;
1305 default:
1306 gcc_unreachable ();
1309 for (i = 0; i < SIGSZ; ++i)
1310 if (a->sig[i] != b->sig[i])
1311 return false;
1313 return true;
1316 /* Try to change R into its exact multiplicative inverse in format FMT.
1317 Return true if successful. */
1319 bool
1320 exact_real_inverse (format_helper fmt, REAL_VALUE_TYPE *r)
1322 const REAL_VALUE_TYPE *one = real_digit (1);
1323 REAL_VALUE_TYPE u;
1324 int i;
1326 if (r->cl != rvc_normal)
1327 return false;
1329 /* Check for a power of two: all significand bits zero except the MSB. */
1330 for (i = 0; i < SIGSZ-1; ++i)
1331 if (r->sig[i] != 0)
1332 return false;
1333 if (r->sig[SIGSZ-1] != SIG_MSB)
1334 return false;
1336 /* Find the inverse and truncate to the required format. */
1337 do_divide (&u, one, r);
1338 real_convert (&u, fmt, &u);
1340 /* The rounding may have overflowed. */
1341 if (u.cl != rvc_normal)
1342 return false;
1343 for (i = 0; i < SIGSZ-1; ++i)
1344 if (u.sig[i] != 0)
1345 return false;
1346 if (u.sig[SIGSZ-1] != SIG_MSB)
1347 return false;
1349 *r = u;
1350 return true;
1353 /* Return true if arithmetic on values in IMODE that were promoted
1354 from values in TMODE is equivalent to direct arithmetic on values
1355 in TMODE. */
1357 bool
1358 real_can_shorten_arithmetic (machine_mode imode, machine_mode tmode)
1360 const struct real_format *tfmt, *ifmt;
1361 tfmt = REAL_MODE_FORMAT (tmode);
1362 ifmt = REAL_MODE_FORMAT (imode);
1363 /* These conditions are conservative rather than trying to catch the
1364 exact boundary conditions; the main case to allow is IEEE float
1365 and double. */
1366 return (ifmt->b == tfmt->b
1367 && ifmt->p > 2 * tfmt->p
1368 && ifmt->emin < 2 * tfmt->emin - tfmt->p - 2
1369 && ifmt->emin < tfmt->emin - tfmt->emax - tfmt->p - 2
1370 && ifmt->emax > 2 * tfmt->emax + 2
1371 && ifmt->emax > tfmt->emax - tfmt->emin + tfmt->p + 2
1372 && ifmt->round_towards_zero == tfmt->round_towards_zero
1373 && (ifmt->has_sign_dependent_rounding
1374 == tfmt->has_sign_dependent_rounding)
1375 && ifmt->has_nans >= tfmt->has_nans
1376 && ifmt->has_inf >= tfmt->has_inf
1377 && ifmt->has_signed_zero >= tfmt->has_signed_zero
1378 && !MODE_COMPOSITE_P (tmode)
1379 && !MODE_COMPOSITE_P (imode));
1382 /* Render R as an integer. */
1384 HOST_WIDE_INT
1385 real_to_integer (const REAL_VALUE_TYPE *r)
1387 unsigned HOST_WIDE_INT i;
1389 switch (r->cl)
1391 case rvc_zero:
1392 underflow:
1393 return 0;
1395 case rvc_inf:
1396 case rvc_nan:
1397 overflow:
1398 i = HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1);
1399 if (!r->sign)
1400 i--;
1401 return i;
1403 case rvc_normal:
1404 if (r->decimal)
1405 return decimal_real_to_integer (r);
1407 if (REAL_EXP (r) <= 0)
1408 goto underflow;
1409 /* Only force overflow for unsigned overflow. Signed overflow is
1410 undefined, so it doesn't matter what we return, and some callers
1411 expect to be able to use this routine for both signed and
1412 unsigned conversions. */
1413 if (REAL_EXP (r) > HOST_BITS_PER_WIDE_INT)
1414 goto overflow;
1416 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1417 i = r->sig[SIGSZ-1];
1418 else
1420 gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
1421 i = r->sig[SIGSZ-1];
1422 i = i << (HOST_BITS_PER_LONG - 1) << 1;
1423 i |= r->sig[SIGSZ-2];
1426 i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
1428 if (r->sign)
1429 i = -i;
1430 return i;
1432 default:
1433 gcc_unreachable ();
1437 /* Likewise, but producing a wide-int of PRECISION. If the value cannot
1438 be represented in precision, *FAIL is set to TRUE. */
1440 wide_int
1441 real_to_integer (const REAL_VALUE_TYPE *r, bool *fail, int precision)
1443 HOST_WIDE_INT val[2 * WIDE_INT_MAX_ELTS];
1444 int exp;
1445 int words, w;
1446 wide_int result;
1448 switch (r->cl)
1450 case rvc_zero:
1451 underflow:
1452 return wi::zero (precision);
1454 case rvc_inf:
1455 case rvc_nan:
1456 overflow:
1457 *fail = true;
1459 if (r->sign)
1460 return wi::set_bit_in_zero (precision - 1, precision);
1461 else
1462 return ~wi::set_bit_in_zero (precision - 1, precision);
1464 case rvc_normal:
1465 if (r->decimal)
1466 return decimal_real_to_integer (r, fail, precision);
1468 exp = REAL_EXP (r);
1469 if (exp <= 0)
1470 goto underflow;
1471 /* Only force overflow for unsigned overflow. Signed overflow is
1472 undefined, so it doesn't matter what we return, and some callers
1473 expect to be able to use this routine for both signed and
1474 unsigned conversions. */
1475 if (exp > precision)
1476 goto overflow;
1478 /* Put the significand into a wide_int that has precision W, which
1479 is the smallest HWI-multiple that has at least PRECISION bits.
1480 This ensures that the top bit of the significand is in the
1481 top bit of the wide_int. */
1482 words = (precision + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT;
1483 w = words * HOST_BITS_PER_WIDE_INT;
1485 #if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1486 for (int i = 0; i < words; i++)
1488 int j = SIGSZ - words + i;
1489 val[i] = (j < 0) ? 0 : r->sig[j];
1491 #else
1492 gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
1493 for (int i = 0; i < words; i++)
1495 int j = SIGSZ - (words * 2) + (i * 2);
1496 if (j < 0)
1497 val[i] = 0;
1498 else
1499 val[i] = r->sig[j];
1500 j += 1;
1501 if (j >= 0)
1502 val[i] |= (unsigned HOST_WIDE_INT) r->sig[j] << HOST_BITS_PER_LONG;
1504 #endif
1505 /* Shift the value into place and truncate to the desired precision. */
1506 result = wide_int::from_array (val, words, w);
1507 result = wi::lrshift (result, w - exp);
1508 result = wide_int::from (result, precision, UNSIGNED);
1510 if (r->sign)
1511 return -result;
1512 else
1513 return result;
1515 default:
1516 gcc_unreachable ();
1520 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1521 of NUM / DEN. Return the quotient and place the remainder in NUM.
1522 It is expected that NUM / DEN are close enough that the quotient is
1523 small. */
1525 static unsigned long
1526 rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den)
1528 unsigned long q, msb;
1529 int expn = REAL_EXP (num), expd = REAL_EXP (den);
1531 if (expn < expd)
1532 return 0;
1534 q = msb = 0;
1535 goto start;
1538 msb = num->sig[SIGSZ-1] & SIG_MSB;
1539 q <<= 1;
1540 lshift_significand_1 (num, num);
1541 start:
1542 if (msb || cmp_significands (num, den) >= 0)
1544 sub_significands (num, num, den, 0);
1545 q |= 1;
1548 while (--expn >= expd);
1550 SET_REAL_EXP (num, expd);
1551 normalize (num);
1553 return q;
1556 /* Render R as a decimal floating point constant. Emit DIGITS significant
1557 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1558 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1559 zeros. If MODE is VOIDmode, round to nearest value. Otherwise, round
1560 to a string that, when parsed back in mode MODE, yields the same value. */
1562 #define M_LOG10_2 0.30102999566398119521
1564 void
1565 real_to_decimal_for_mode (char *str, const REAL_VALUE_TYPE *r_orig,
1566 size_t buf_size, size_t digits,
1567 int crop_trailing_zeros, machine_mode mode)
1569 const struct real_format *fmt = NULL;
1570 const REAL_VALUE_TYPE *one, *ten;
1571 REAL_VALUE_TYPE r, pten, u, v;
1572 int dec_exp, cmp_one, digit;
1573 size_t max_digits;
1574 char *p, *first, *last;
1575 bool sign;
1576 bool round_up;
1578 if (mode != VOIDmode)
1580 fmt = REAL_MODE_FORMAT (mode);
1581 gcc_assert (fmt);
1584 r = *r_orig;
1585 switch (r.cl)
1587 case rvc_zero:
1588 strcpy (str, (r.sign ? "-0.0" : "0.0"));
1589 return;
1590 case rvc_normal:
1591 break;
1592 case rvc_inf:
1593 strcpy (str, (r.sign ? "-Inf" : "+Inf"));
1594 return;
1595 case rvc_nan:
1596 /* ??? Print the significand as well, if not canonical? */
1597 sprintf (str, "%c%cNaN", (r_orig->sign ? '-' : '+'),
1598 (r_orig->signalling ? 'S' : 'Q'));
1599 return;
1600 default:
1601 gcc_unreachable ();
1604 if (r.decimal)
1606 decimal_real_to_decimal (str, &r, buf_size, digits, crop_trailing_zeros);
1607 return;
1610 /* Bound the number of digits printed by the size of the representation. */
1611 max_digits = SIGNIFICAND_BITS * M_LOG10_2;
1612 if (digits == 0 || digits > max_digits)
1613 digits = max_digits;
1615 /* Estimate the decimal exponent, and compute the length of the string it
1616 will print as. Be conservative and add one to account for possible
1617 overflow or rounding error. */
1618 dec_exp = REAL_EXP (&r) * M_LOG10_2;
1619 for (max_digits = 1; dec_exp ; max_digits++)
1620 dec_exp /= 10;
1622 /* Bound the number of digits printed by the size of the output buffer. */
1623 max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
1624 gcc_assert (max_digits <= buf_size);
1625 if (digits > max_digits)
1626 digits = max_digits;
1628 one = real_digit (1);
1629 ten = ten_to_ptwo (0);
1631 sign = r.sign;
1632 r.sign = 0;
1634 dec_exp = 0;
1635 pten = *one;
1637 cmp_one = do_compare (&r, one, 0);
1638 if (cmp_one > 0)
1640 int m;
1642 /* Number is greater than one. Convert significand to an integer
1643 and strip trailing decimal zeros. */
1645 u = r;
1646 SET_REAL_EXP (&u, SIGNIFICAND_BITS - 1);
1648 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1649 m = floor_log2 (max_digits);
1651 /* Iterate over the bits of the possible powers of 10 that might
1652 be present in U and eliminate them. That is, if we find that
1653 10**2**M divides U evenly, keep the division and increase
1654 DEC_EXP by 2**M. */
1657 REAL_VALUE_TYPE t;
1659 do_divide (&t, &u, ten_to_ptwo (m));
1660 do_fix_trunc (&v, &t);
1661 if (cmp_significands (&v, &t) == 0)
1663 u = t;
1664 dec_exp += 1 << m;
1667 while (--m >= 0);
1669 /* Revert the scaling to integer that we performed earlier. */
1670 SET_REAL_EXP (&u, REAL_EXP (&u) + REAL_EXP (&r)
1671 - (SIGNIFICAND_BITS - 1));
1672 r = u;
1674 /* Find power of 10. Do this by dividing out 10**2**M when
1675 this is larger than the current remainder. Fill PTEN with
1676 the power of 10 that we compute. */
1677 if (REAL_EXP (&r) > 0)
1679 m = floor_log2 ((int)(REAL_EXP (&r) * M_LOG10_2)) + 1;
1682 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1683 if (do_compare (&u, ptentwo, 0) >= 0)
1685 do_divide (&u, &u, ptentwo);
1686 do_multiply (&pten, &pten, ptentwo);
1687 dec_exp += 1 << m;
1690 while (--m >= 0);
1692 else
1693 /* We managed to divide off enough tens in the above reduction
1694 loop that we've now got a negative exponent. Fall into the
1695 less-than-one code to compute the proper value for PTEN. */
1696 cmp_one = -1;
1698 if (cmp_one < 0)
1700 int m;
1702 /* Number is less than one. Pad significand with leading
1703 decimal zeros. */
1705 v = r;
1706 while (1)
1708 /* Stop if we'd shift bits off the bottom. */
1709 if (v.sig[0] & 7)
1710 break;
1712 do_multiply (&u, &v, ten);
1714 /* Stop if we're now >= 1. */
1715 if (REAL_EXP (&u) > 0)
1716 break;
1718 v = u;
1719 dec_exp -= 1;
1721 r = v;
1723 /* Find power of 10. Do this by multiplying in P=10**2**M when
1724 the current remainder is smaller than 1/P. Fill PTEN with the
1725 power of 10 that we compute. */
1726 m = floor_log2 ((int)(-REAL_EXP (&r) * M_LOG10_2)) + 1;
1729 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1730 const REAL_VALUE_TYPE *ptenmtwo = ten_to_mptwo (m);
1732 if (do_compare (&v, ptenmtwo, 0) <= 0)
1734 do_multiply (&v, &v, ptentwo);
1735 do_multiply (&pten, &pten, ptentwo);
1736 dec_exp -= 1 << m;
1739 while (--m >= 0);
1741 /* Invert the positive power of 10 that we've collected so far. */
1742 do_divide (&pten, one, &pten);
1745 p = str;
1746 if (sign)
1747 *p++ = '-';
1748 first = p++;
1750 /* At this point, PTEN should contain the nearest power of 10 smaller
1751 than R, such that this division produces the first digit.
1753 Using a divide-step primitive that returns the complete integral
1754 remainder avoids the rounding error that would be produced if
1755 we were to use do_divide here and then simply multiply by 10 for
1756 each subsequent digit. */
1758 digit = rtd_divmod (&r, &pten);
1760 /* Be prepared for error in that division via underflow ... */
1761 if (digit == 0 && cmp_significand_0 (&r))
1763 /* Multiply by 10 and try again. */
1764 do_multiply (&r, &r, ten);
1765 digit = rtd_divmod (&r, &pten);
1766 dec_exp -= 1;
1767 gcc_assert (digit != 0);
1770 /* ... or overflow. */
1771 if (digit == 10)
1773 *p++ = '1';
1774 if (--digits > 0)
1775 *p++ = '0';
1776 dec_exp += 1;
1778 else
1780 gcc_assert (digit <= 10);
1781 *p++ = digit + '0';
1784 /* Generate subsequent digits. */
1785 while (--digits > 0)
1787 do_multiply (&r, &r, ten);
1788 digit = rtd_divmod (&r, &pten);
1789 *p++ = digit + '0';
1791 last = p;
1793 /* Generate one more digit with which to do rounding. */
1794 do_multiply (&r, &r, ten);
1795 digit = rtd_divmod (&r, &pten);
1797 /* Round the result. */
1798 if (fmt && fmt->round_towards_zero)
1800 /* If the format uses round towards zero when parsing the string
1801 back in, we need to always round away from zero here. */
1802 if (cmp_significand_0 (&r))
1803 digit++;
1804 round_up = digit > 0;
1806 else
1808 if (digit == 5)
1810 /* Round to nearest. If R is nonzero there are additional
1811 nonzero digits to be extracted. */
1812 if (cmp_significand_0 (&r))
1813 digit++;
1814 /* Round to even. */
1815 else if ((p[-1] - '0') & 1)
1816 digit++;
1819 round_up = digit > 5;
1822 if (round_up)
1824 while (p > first)
1826 digit = *--p;
1827 if (digit == '9')
1828 *p = '0';
1829 else
1831 *p = digit + 1;
1832 break;
1836 /* Carry out of the first digit. This means we had all 9's and
1837 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1838 if (p == first)
1840 first[1] = '1';
1841 dec_exp++;
1845 /* Insert the decimal point. */
1846 first[0] = first[1];
1847 first[1] = '.';
1849 /* If requested, drop trailing zeros. Never crop past "1.0". */
1850 if (crop_trailing_zeros)
1851 while (last > first + 3 && last[-1] == '0')
1852 last--;
1854 /* Append the exponent. */
1855 sprintf (last, "e%+d", dec_exp);
1857 /* Verify that we can read the original value back in. */
1858 if (flag_checking && mode != VOIDmode)
1860 real_from_string (&r, str);
1861 real_convert (&r, mode, &r);
1862 gcc_assert (real_identical (&r, r_orig));
1866 /* Likewise, except always uses round-to-nearest. */
1868 void
1869 real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
1870 size_t digits, int crop_trailing_zeros)
1872 real_to_decimal_for_mode (str, r_orig, buf_size,
1873 digits, crop_trailing_zeros, VOIDmode);
1876 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1877 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1878 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1879 strip trailing zeros. */
1881 void
1882 real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
1883 size_t digits, int crop_trailing_zeros)
1885 int i, j, exp = REAL_EXP (r);
1886 char *p, *first;
1887 char exp_buf[16];
1888 size_t max_digits;
1890 switch (r->cl)
1892 case rvc_zero:
1893 exp = 0;
1894 break;
1895 case rvc_normal:
1896 break;
1897 case rvc_inf:
1898 strcpy (str, (r->sign ? "-Inf" : "+Inf"));
1899 return;
1900 case rvc_nan:
1901 /* ??? Print the significand as well, if not canonical? */
1902 sprintf (str, "%c%cNaN", (r->sign ? '-' : '+'),
1903 (r->signalling ? 'S' : 'Q'));
1904 return;
1905 default:
1906 gcc_unreachable ();
1909 if (r->decimal)
1911 /* Hexadecimal format for decimal floats is not interesting. */
1912 strcpy (str, "N/A");
1913 return;
1916 if (digits == 0)
1917 digits = SIGNIFICAND_BITS / 4;
1919 /* Bound the number of digits printed by the size of the output buffer. */
1921 sprintf (exp_buf, "p%+d", exp);
1922 max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1;
1923 gcc_assert (max_digits <= buf_size);
1924 if (digits > max_digits)
1925 digits = max_digits;
1927 p = str;
1928 if (r->sign)
1929 *p++ = '-';
1930 *p++ = '0';
1931 *p++ = 'x';
1932 *p++ = '0';
1933 *p++ = '.';
1934 first = p;
1936 for (i = SIGSZ - 1; i >= 0; --i)
1937 for (j = HOST_BITS_PER_LONG - 4; j >= 0; j -= 4)
1939 *p++ = "0123456789abcdef"[(r->sig[i] >> j) & 15];
1940 if (--digits == 0)
1941 goto out;
1944 out:
1945 if (crop_trailing_zeros)
1946 while (p > first + 1 && p[-1] == '0')
1947 p--;
1949 sprintf (p, "p%+d", exp);
1952 /* Initialize R from a decimal or hexadecimal string. The string is
1953 assumed to have been syntax checked already. Return -1 if the
1954 value underflows, +1 if overflows, and 0 otherwise. */
1957 real_from_string (REAL_VALUE_TYPE *r, const char *str)
1959 int exp = 0;
1960 bool sign = false;
1962 get_zero (r, 0);
1964 if (*str == '-')
1966 sign = true;
1967 str++;
1969 else if (*str == '+')
1970 str++;
1972 if (!strncmp (str, "QNaN", 4))
1974 get_canonical_qnan (r, sign);
1975 return 0;
1977 else if (!strncmp (str, "SNaN", 4))
1979 get_canonical_snan (r, sign);
1980 return 0;
1982 else if (!strncmp (str, "Inf", 3))
1984 get_inf (r, sign);
1985 return 0;
1988 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
1990 /* Hexadecimal floating point. */
1991 int pos = SIGNIFICAND_BITS - 4, d;
1993 str += 2;
1995 while (*str == '0')
1996 str++;
1997 while (1)
1999 d = hex_value (*str);
2000 if (d == _hex_bad)
2001 break;
2002 if (pos >= 0)
2004 r->sig[pos / HOST_BITS_PER_LONG]
2005 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
2006 pos -= 4;
2008 else if (d)
2009 /* Ensure correct rounding by setting last bit if there is
2010 a subsequent nonzero digit. */
2011 r->sig[0] |= 1;
2012 exp += 4;
2013 str++;
2015 if (*str == '.')
2017 str++;
2018 if (pos == SIGNIFICAND_BITS - 4)
2020 while (*str == '0')
2021 str++, exp -= 4;
2023 while (1)
2025 d = hex_value (*str);
2026 if (d == _hex_bad)
2027 break;
2028 if (pos >= 0)
2030 r->sig[pos / HOST_BITS_PER_LONG]
2031 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
2032 pos -= 4;
2034 else if (d)
2035 /* Ensure correct rounding by setting last bit if there is
2036 a subsequent nonzero digit. */
2037 r->sig[0] |= 1;
2038 str++;
2042 /* If the mantissa is zero, ignore the exponent. */
2043 if (!cmp_significand_0 (r))
2044 goto is_a_zero;
2046 if (*str == 'p' || *str == 'P')
2048 bool exp_neg = false;
2050 str++;
2051 if (*str == '-')
2053 exp_neg = true;
2054 str++;
2056 else if (*str == '+')
2057 str++;
2059 d = 0;
2060 while (ISDIGIT (*str))
2062 d *= 10;
2063 d += *str - '0';
2064 if (d > MAX_EXP)
2066 /* Overflowed the exponent. */
2067 if (exp_neg)
2068 goto underflow;
2069 else
2070 goto overflow;
2072 str++;
2074 if (exp_neg)
2075 d = -d;
2077 exp += d;
2080 r->cl = rvc_normal;
2081 SET_REAL_EXP (r, exp);
2083 normalize (r);
2085 else
2087 /* Decimal floating point. */
2088 const char *cstr = str;
2089 mpfr_t m;
2090 bool inexact;
2092 while (*cstr == '0')
2093 cstr++;
2094 if (*cstr == '.')
2096 cstr++;
2097 while (*cstr == '0')
2098 cstr++;
2101 /* If the mantissa is zero, ignore the exponent. */
2102 if (!ISDIGIT (*cstr))
2103 goto is_a_zero;
2105 /* Nonzero value, possibly overflowing or underflowing. */
2106 mpfr_init2 (m, SIGNIFICAND_BITS);
2107 inexact = mpfr_strtofr (m, str, NULL, 10, GMP_RNDZ);
2108 /* The result should never be a NaN, and because the rounding is
2109 toward zero should never be an infinity. */
2110 gcc_assert (!mpfr_nan_p (m) && !mpfr_inf_p (m));
2111 if (mpfr_zero_p (m) || mpfr_get_exp (m) < -MAX_EXP + 4)
2113 mpfr_clear (m);
2114 goto underflow;
2116 else if (mpfr_get_exp (m) > MAX_EXP - 4)
2118 mpfr_clear (m);
2119 goto overflow;
2121 else
2123 real_from_mpfr (r, m, NULL_TREE, GMP_RNDZ);
2124 /* 1 to 3 bits may have been shifted off (with a sticky bit)
2125 because the hex digits used in real_from_mpfr did not
2126 start with a digit 8 to f, but the exponent bounds above
2127 should have avoided underflow or overflow. */
2128 gcc_assert (r->cl == rvc_normal);
2129 /* Set a sticky bit if mpfr_strtofr was inexact. */
2130 r->sig[0] |= inexact;
2131 mpfr_clear (m);
2135 r->sign = sign;
2136 return 0;
2138 is_a_zero:
2139 get_zero (r, sign);
2140 return 0;
2142 underflow:
2143 get_zero (r, sign);
2144 return -1;
2146 overflow:
2147 get_inf (r, sign);
2148 return 1;
2151 /* Legacy. Similar, but return the result directly. */
2153 REAL_VALUE_TYPE
2154 real_from_string2 (const char *s, format_helper fmt)
2156 REAL_VALUE_TYPE r;
2158 real_from_string (&r, s);
2159 if (fmt)
2160 real_convert (&r, fmt, &r);
2162 return r;
2165 /* Initialize R from string S and desired format FMT. */
2167 void
2168 real_from_string3 (REAL_VALUE_TYPE *r, const char *s, format_helper fmt)
2170 if (fmt.decimal_p ())
2171 decimal_real_from_string (r, s);
2172 else
2173 real_from_string (r, s);
2175 if (fmt)
2176 real_convert (r, fmt, r);
2179 /* Initialize R from the wide_int VAL_IN. Round it to format FMT if
2180 FMT is nonnull. */
2182 void
2183 real_from_integer (REAL_VALUE_TYPE *r, format_helper fmt,
2184 const wide_int_ref &val_in, signop sgn)
2186 if (val_in == 0)
2187 get_zero (r, 0);
2188 else
2190 unsigned int len = val_in.get_precision ();
2191 int i, j, e = 0;
2192 int maxbitlen = MAX_BITSIZE_MODE_ANY_INT + HOST_BITS_PER_WIDE_INT;
2193 const unsigned int realmax = (SIGNIFICAND_BITS / HOST_BITS_PER_WIDE_INT
2194 * HOST_BITS_PER_WIDE_INT);
2196 memset (r, 0, sizeof (*r));
2197 r->cl = rvc_normal;
2198 r->sign = wi::neg_p (val_in, sgn);
2200 /* We have to ensure we can negate the largest negative number. */
2201 wide_int val = wide_int::from (val_in, maxbitlen, sgn);
2203 if (r->sign)
2204 val = -val;
2206 /* Ensure a multiple of HOST_BITS_PER_WIDE_INT, ceiling, as elt
2207 won't work with precisions that are not a multiple of
2208 HOST_BITS_PER_WIDE_INT. */
2209 len += HOST_BITS_PER_WIDE_INT - 1;
2211 /* Ensure we can represent the largest negative number. */
2212 len += 1;
2214 len = len/HOST_BITS_PER_WIDE_INT * HOST_BITS_PER_WIDE_INT;
2216 /* Cap the size to the size allowed by real.h. */
2217 if (len > realmax)
2219 HOST_WIDE_INT cnt_l_z;
2220 cnt_l_z = wi::clz (val);
2222 if (maxbitlen - cnt_l_z > realmax)
2224 e = maxbitlen - cnt_l_z - realmax;
2226 /* This value is too large, we must shift it right to
2227 preserve all the bits we can, and then bump the
2228 exponent up by that amount. */
2229 val = wi::lrshift (val, e);
2231 len = realmax;
2234 /* Clear out top bits so elt will work with precisions that aren't
2235 a multiple of HOST_BITS_PER_WIDE_INT. */
2236 val = wide_int::from (val, len, sgn);
2237 len = len / HOST_BITS_PER_WIDE_INT;
2239 SET_REAL_EXP (r, len * HOST_BITS_PER_WIDE_INT + e);
2241 j = SIGSZ - 1;
2242 if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT)
2243 for (i = len - 1; i >= 0; i--)
2245 r->sig[j--] = val.elt (i);
2246 if (j < 0)
2247 break;
2249 else
2251 gcc_assert (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT);
2252 for (i = len - 1; i >= 0; i--)
2254 HOST_WIDE_INT e = val.elt (i);
2255 r->sig[j--] = e >> (HOST_BITS_PER_LONG - 1) >> 1;
2256 if (j < 0)
2257 break;
2258 r->sig[j--] = e;
2259 if (j < 0)
2260 break;
2264 normalize (r);
2267 if (fmt.decimal_p ())
2268 decimal_from_integer (r);
2269 if (fmt)
2270 real_convert (r, fmt, r);
2273 /* Render R, an integral value, as a floating point constant with no
2274 specified exponent. */
2276 static void
2277 decimal_integer_string (char *str, const REAL_VALUE_TYPE *r_orig,
2278 size_t buf_size)
2280 int dec_exp, digit, digits;
2281 REAL_VALUE_TYPE r, pten;
2282 char *p;
2283 bool sign;
2285 r = *r_orig;
2287 if (r.cl == rvc_zero)
2289 strcpy (str, "0.");
2290 return;
2293 sign = r.sign;
2294 r.sign = 0;
2296 dec_exp = REAL_EXP (&r) * M_LOG10_2;
2297 digits = dec_exp + 1;
2298 gcc_assert ((digits + 2) < (int)buf_size);
2300 pten = *real_digit (1);
2301 times_pten (&pten, dec_exp);
2303 p = str;
2304 if (sign)
2305 *p++ = '-';
2307 digit = rtd_divmod (&r, &pten);
2308 gcc_assert (digit >= 0 && digit <= 9);
2309 *p++ = digit + '0';
2310 while (--digits > 0)
2312 times_pten (&r, 1);
2313 digit = rtd_divmod (&r, &pten);
2314 *p++ = digit + '0';
2316 *p++ = '.';
2317 *p++ = '\0';
2320 /* Convert a real with an integral value to decimal float. */
2322 static void
2323 decimal_from_integer (REAL_VALUE_TYPE *r)
2325 char str[256];
2327 decimal_integer_string (str, r, sizeof (str) - 1);
2328 decimal_real_from_string (r, str);
2331 /* Returns 10**2**N. */
2333 static const REAL_VALUE_TYPE *
2334 ten_to_ptwo (int n)
2336 static REAL_VALUE_TYPE tens[EXP_BITS];
2338 gcc_assert (n >= 0);
2339 gcc_assert (n < EXP_BITS);
2341 if (tens[n].cl == rvc_zero)
2343 if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
2345 HOST_WIDE_INT t = 10;
2346 int i;
2348 for (i = 0; i < n; ++i)
2349 t *= t;
2351 real_from_integer (&tens[n], VOIDmode, t, UNSIGNED);
2353 else
2355 const REAL_VALUE_TYPE *t = ten_to_ptwo (n - 1);
2356 do_multiply (&tens[n], t, t);
2360 return &tens[n];
2363 /* Returns 10**(-2**N). */
2365 static const REAL_VALUE_TYPE *
2366 ten_to_mptwo (int n)
2368 static REAL_VALUE_TYPE tens[EXP_BITS];
2370 gcc_assert (n >= 0);
2371 gcc_assert (n < EXP_BITS);
2373 if (tens[n].cl == rvc_zero)
2374 do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
2376 return &tens[n];
2379 /* Returns N. */
2381 static const REAL_VALUE_TYPE *
2382 real_digit (int n)
2384 static REAL_VALUE_TYPE num[10];
2386 gcc_assert (n >= 0);
2387 gcc_assert (n <= 9);
2389 if (n > 0 && num[n].cl == rvc_zero)
2390 real_from_integer (&num[n], VOIDmode, n, UNSIGNED);
2392 return &num[n];
2395 /* Multiply R by 10**EXP. */
2397 static void
2398 times_pten (REAL_VALUE_TYPE *r, int exp)
2400 REAL_VALUE_TYPE pten, *rr;
2401 bool negative = (exp < 0);
2402 int i;
2404 if (negative)
2406 exp = -exp;
2407 pten = *real_digit (1);
2408 rr = &pten;
2410 else
2411 rr = r;
2413 for (i = 0; exp > 0; ++i, exp >>= 1)
2414 if (exp & 1)
2415 do_multiply (rr, rr, ten_to_ptwo (i));
2417 if (negative)
2418 do_divide (r, r, &pten);
2421 /* Returns the special REAL_VALUE_TYPE corresponding to 'e'. */
2423 const REAL_VALUE_TYPE *
2424 dconst_e_ptr (void)
2426 static REAL_VALUE_TYPE value;
2428 /* Initialize mathematical constants for constant folding builtins.
2429 These constants need to be given to at least 160 bits precision. */
2430 if (value.cl == rvc_zero)
2432 mpfr_t m;
2433 mpfr_init2 (m, SIGNIFICAND_BITS);
2434 mpfr_set_ui (m, 1, GMP_RNDN);
2435 mpfr_exp (m, m, GMP_RNDN);
2436 real_from_mpfr (&value, m, NULL_TREE, GMP_RNDN);
2437 mpfr_clear (m);
2440 return &value;
2443 /* Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n. */
2445 #define CACHED_FRACTION(NAME, N) \
2446 const REAL_VALUE_TYPE * \
2447 NAME (void) \
2449 static REAL_VALUE_TYPE value; \
2451 /* Initialize mathematical constants for constant folding builtins. \
2452 These constants need to be given to at least 160 bits \
2453 precision. */ \
2454 if (value.cl == rvc_zero) \
2455 real_arithmetic (&value, RDIV_EXPR, &dconst1, real_digit (N)); \
2456 return &value; \
2459 CACHED_FRACTION (dconst_third_ptr, 3)
2460 CACHED_FRACTION (dconst_quarter_ptr, 4)
2461 CACHED_FRACTION (dconst_sixth_ptr, 6)
2462 CACHED_FRACTION (dconst_ninth_ptr, 9)
2464 /* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2). */
2466 const REAL_VALUE_TYPE *
2467 dconst_sqrt2_ptr (void)
2469 static REAL_VALUE_TYPE value;
2471 /* Initialize mathematical constants for constant folding builtins.
2472 These constants need to be given to at least 160 bits precision. */
2473 if (value.cl == rvc_zero)
2475 mpfr_t m;
2476 mpfr_init2 (m, SIGNIFICAND_BITS);
2477 mpfr_sqrt_ui (m, 2, GMP_RNDN);
2478 real_from_mpfr (&value, m, NULL_TREE, GMP_RNDN);
2479 mpfr_clear (m);
2481 return &value;
2484 /* Fills R with +Inf. */
2486 void
2487 real_inf (REAL_VALUE_TYPE *r)
2489 get_inf (r, 0);
2492 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2493 we force a QNaN, else we force an SNaN. The string, if not empty,
2494 is parsed as a number and placed in the significand. Return true
2495 if the string was successfully parsed. */
2497 bool
2498 real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
2499 format_helper fmt)
2501 if (*str == 0)
2503 if (quiet)
2504 get_canonical_qnan (r, 0);
2505 else
2506 get_canonical_snan (r, 0);
2508 else
2510 int base = 10, d;
2512 memset (r, 0, sizeof (*r));
2513 r->cl = rvc_nan;
2515 /* Parse akin to strtol into the significand of R. */
2517 while (ISSPACE (*str))
2518 str++;
2519 if (*str == '-')
2520 str++;
2521 else if (*str == '+')
2522 str++;
2523 if (*str == '0')
2525 str++;
2526 if (*str == 'x' || *str == 'X')
2528 base = 16;
2529 str++;
2531 else
2532 base = 8;
2535 while ((d = hex_value (*str)) < base)
2537 REAL_VALUE_TYPE u;
2539 switch (base)
2541 case 8:
2542 lshift_significand (r, r, 3);
2543 break;
2544 case 16:
2545 lshift_significand (r, r, 4);
2546 break;
2547 case 10:
2548 lshift_significand_1 (&u, r);
2549 lshift_significand (r, r, 3);
2550 add_significands (r, r, &u);
2551 break;
2552 default:
2553 gcc_unreachable ();
2556 get_zero (&u, 0);
2557 u.sig[0] = d;
2558 add_significands (r, r, &u);
2560 str++;
2563 /* Must have consumed the entire string for success. */
2564 if (*str != 0)
2565 return false;
2567 /* Shift the significand into place such that the bits
2568 are in the most significant bits for the format. */
2569 lshift_significand (r, r, SIGNIFICAND_BITS - fmt->pnan);
2571 /* Our MSB is always unset for NaNs. */
2572 r->sig[SIGSZ-1] &= ~SIG_MSB;
2574 /* Force quiet or signaling NaN. */
2575 r->signalling = !quiet;
2578 return true;
2581 /* Fills R with the largest finite value representable in mode MODE.
2582 If SIGN is nonzero, R is set to the most negative finite value. */
2584 void
2585 real_maxval (REAL_VALUE_TYPE *r, int sign, machine_mode mode)
2587 const struct real_format *fmt;
2588 int np2;
2590 fmt = REAL_MODE_FORMAT (mode);
2591 gcc_assert (fmt);
2592 memset (r, 0, sizeof (*r));
2594 if (fmt->b == 10)
2595 decimal_real_maxval (r, sign, mode);
2596 else
2598 r->cl = rvc_normal;
2599 r->sign = sign;
2600 SET_REAL_EXP (r, fmt->emax);
2602 np2 = SIGNIFICAND_BITS - fmt->p;
2603 memset (r->sig, -1, SIGSZ * sizeof (unsigned long));
2604 clear_significand_below (r, np2);
2606 if (fmt->pnan < fmt->p)
2607 /* This is an IBM extended double format made up of two IEEE
2608 doubles. The value of the long double is the sum of the
2609 values of the two parts. The most significant part is
2610 required to be the value of the long double rounded to the
2611 nearest double. Rounding means we need a slightly smaller
2612 value for LDBL_MAX. */
2613 clear_significand_bit (r, SIGNIFICAND_BITS - fmt->pnan - 1);
2617 /* Fills R with 2**N. */
2619 void
2620 real_2expN (REAL_VALUE_TYPE *r, int n, format_helper fmt)
2622 memset (r, 0, sizeof (*r));
2624 n++;
2625 if (n > MAX_EXP)
2626 r->cl = rvc_inf;
2627 else if (n < -MAX_EXP)
2629 else
2631 r->cl = rvc_normal;
2632 SET_REAL_EXP (r, n);
2633 r->sig[SIGSZ-1] = SIG_MSB;
2635 if (fmt.decimal_p ())
2636 decimal_real_convert (r, fmt, r);
2640 static void
2641 round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
2643 int p2, np2, i, w;
2644 int emin2m1, emax2;
2645 bool round_up = false;
2647 if (r->decimal)
2649 if (fmt->b == 10)
2651 decimal_round_for_format (fmt, r);
2652 return;
2654 /* FIXME. We can come here via fp_easy_constant
2655 (e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
2656 investigated whether this convert needs to be here, or
2657 something else is missing. */
2658 decimal_real_convert (r, REAL_MODE_FORMAT (DFmode), r);
2661 p2 = fmt->p;
2662 emin2m1 = fmt->emin - 1;
2663 emax2 = fmt->emax;
2665 np2 = SIGNIFICAND_BITS - p2;
2666 switch (r->cl)
2668 underflow:
2669 get_zero (r, r->sign);
2670 /* FALLTHRU */
2671 case rvc_zero:
2672 if (!fmt->has_signed_zero)
2673 r->sign = 0;
2674 return;
2676 overflow:
2677 get_inf (r, r->sign);
2678 case rvc_inf:
2679 return;
2681 case rvc_nan:
2682 clear_significand_below (r, np2);
2683 return;
2685 case rvc_normal:
2686 break;
2688 default:
2689 gcc_unreachable ();
2692 /* Check the range of the exponent. If we're out of range,
2693 either underflow or overflow. */
2694 if (REAL_EXP (r) > emax2)
2695 goto overflow;
2696 else if (REAL_EXP (r) <= emin2m1)
2698 int diff;
2700 if (!fmt->has_denorm)
2702 /* Don't underflow completely until we've had a chance to round. */
2703 if (REAL_EXP (r) < emin2m1)
2704 goto underflow;
2706 else
2708 diff = emin2m1 - REAL_EXP (r) + 1;
2709 if (diff > p2)
2710 goto underflow;
2712 /* De-normalize the significand. */
2713 r->sig[0] |= sticky_rshift_significand (r, r, diff);
2714 SET_REAL_EXP (r, REAL_EXP (r) + diff);
2718 if (!fmt->round_towards_zero)
2720 /* There are P2 true significand bits, followed by one guard bit,
2721 followed by one sticky bit, followed by stuff. Fold nonzero
2722 stuff into the sticky bit. */
2723 unsigned long sticky;
2724 bool guard, lsb;
2726 sticky = 0;
2727 for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
2728 sticky |= r->sig[i];
2729 sticky |= r->sig[w]
2730 & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
2732 guard = test_significand_bit (r, np2 - 1);
2733 lsb = test_significand_bit (r, np2);
2735 /* Round to even. */
2736 round_up = guard && (sticky || lsb);
2739 if (round_up)
2741 REAL_VALUE_TYPE u;
2742 get_zero (&u, 0);
2743 set_significand_bit (&u, np2);
2745 if (add_significands (r, r, &u))
2747 /* Overflow. Means the significand had been all ones, and
2748 is now all zeros. Need to increase the exponent, and
2749 possibly re-normalize it. */
2750 SET_REAL_EXP (r, REAL_EXP (r) + 1);
2751 if (REAL_EXP (r) > emax2)
2752 goto overflow;
2753 r->sig[SIGSZ-1] = SIG_MSB;
2757 /* Catch underflow that we deferred until after rounding. */
2758 if (REAL_EXP (r) <= emin2m1)
2759 goto underflow;
2761 /* Clear out trailing garbage. */
2762 clear_significand_below (r, np2);
2765 /* Extend or truncate to a new format. */
2767 void
2768 real_convert (REAL_VALUE_TYPE *r, format_helper fmt,
2769 const REAL_VALUE_TYPE *a)
2771 *r = *a;
2773 if (a->decimal || fmt->b == 10)
2774 decimal_real_convert (r, fmt, a);
2776 round_for_format (fmt, r);
2778 /* Make resulting NaN value to be qNaN. The caller has the
2779 responsibility to avoid the operation if flag_signaling_nans
2780 is on. */
2781 if (r->cl == rvc_nan)
2782 r->signalling = 0;
2784 /* round_for_format de-normalizes denormals. Undo just that part. */
2785 if (r->cl == rvc_normal)
2786 normalize (r);
2789 /* Legacy. Likewise, except return the struct directly. */
2791 REAL_VALUE_TYPE
2792 real_value_truncate (format_helper fmt, REAL_VALUE_TYPE a)
2794 REAL_VALUE_TYPE r;
2795 real_convert (&r, fmt, &a);
2796 return r;
2799 /* Return true if truncating to FMT is exact. */
2801 bool
2802 exact_real_truncate (format_helper fmt, const REAL_VALUE_TYPE *a)
2804 REAL_VALUE_TYPE t;
2805 int emin2m1;
2807 /* Don't allow conversion to denormals. */
2808 emin2m1 = fmt->emin - 1;
2809 if (REAL_EXP (a) <= emin2m1)
2810 return false;
2812 /* After conversion to the new format, the value must be identical. */
2813 real_convert (&t, fmt, a);
2814 return real_identical (&t, a);
2817 /* Write R to the given target format. Place the words of the result
2818 in target word order in BUF. There are always 32 bits in each
2819 long, no matter the size of the host long.
2821 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2823 long
2824 real_to_target (long *buf, const REAL_VALUE_TYPE *r_orig,
2825 format_helper fmt)
2827 REAL_VALUE_TYPE r;
2828 long buf1;
2830 r = *r_orig;
2831 round_for_format (fmt, &r);
2833 if (!buf)
2834 buf = &buf1;
2835 (*fmt->encode) (fmt, buf, &r);
2837 return *buf;
2840 /* Read R from the given target format. Read the words of the result
2841 in target word order in BUF. There are always 32 bits in each
2842 long, no matter the size of the host long. */
2844 void
2845 real_from_target (REAL_VALUE_TYPE *r, const long *buf, format_helper fmt)
2847 (*fmt->decode) (fmt, r, buf);
2850 /* Return the number of bits of the largest binary value that the
2851 significand of FMT will hold. */
2852 /* ??? Legacy. Should get access to real_format directly. */
2855 significand_size (format_helper fmt)
2857 if (fmt == NULL)
2858 return 0;
2860 if (fmt->b == 10)
2862 /* Return the size in bits of the largest binary value that can be
2863 held by the decimal coefficient for this format. This is one more
2864 than the number of bits required to hold the largest coefficient
2865 of this format. */
2866 double log2_10 = 3.3219281;
2867 return fmt->p * log2_10;
2869 return fmt->p;
2872 /* Return a hash value for the given real value. */
2873 /* ??? The "unsigned int" return value is intended to be hashval_t,
2874 but I didn't want to pull hashtab.h into real.h. */
2876 unsigned int
2877 real_hash (const REAL_VALUE_TYPE *r)
2879 unsigned int h;
2880 size_t i;
2882 h = r->cl | (r->sign << 2);
2883 switch (r->cl)
2885 case rvc_zero:
2886 case rvc_inf:
2887 return h;
2889 case rvc_normal:
2890 h |= (unsigned int)REAL_EXP (r) << 3;
2891 break;
2893 case rvc_nan:
2894 if (r->signalling)
2895 h ^= (unsigned int)-1;
2896 if (r->canonical)
2897 return h;
2898 break;
2900 default:
2901 gcc_unreachable ();
2904 if (sizeof (unsigned long) > sizeof (unsigned int))
2905 for (i = 0; i < SIGSZ; ++i)
2907 unsigned long s = r->sig[i];
2908 h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2));
2910 else
2911 for (i = 0; i < SIGSZ; ++i)
2912 h ^= r->sig[i];
2914 return h;
2917 /* IEEE single-precision format. */
2919 static void encode_ieee_single (const struct real_format *fmt,
2920 long *, const REAL_VALUE_TYPE *);
2921 static void decode_ieee_single (const struct real_format *,
2922 REAL_VALUE_TYPE *, const long *);
2924 static void
2925 encode_ieee_single (const struct real_format *fmt, long *buf,
2926 const REAL_VALUE_TYPE *r)
2928 unsigned long image, sig, exp;
2929 unsigned long sign = r->sign;
2930 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2932 image = sign << 31;
2933 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
2935 switch (r->cl)
2937 case rvc_zero:
2938 break;
2940 case rvc_inf:
2941 if (fmt->has_inf)
2942 image |= 255 << 23;
2943 else
2944 image |= 0x7fffffff;
2945 break;
2947 case rvc_nan:
2948 if (fmt->has_nans)
2950 if (r->canonical)
2951 sig = (fmt->canonical_nan_lsbs_set ? (1 << 22) - 1 : 0);
2952 if (r->signalling == fmt->qnan_msb_set)
2953 sig &= ~(1 << 22);
2954 else
2955 sig |= 1 << 22;
2956 if (sig == 0)
2957 sig = 1 << 21;
2959 image |= 255 << 23;
2960 image |= sig;
2962 else
2963 image |= 0x7fffffff;
2964 break;
2966 case rvc_normal:
2967 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2968 whereas the intermediate representation is 0.F x 2**exp.
2969 Which means we're off by one. */
2970 if (denormal)
2971 exp = 0;
2972 else
2973 exp = REAL_EXP (r) + 127 - 1;
2974 image |= exp << 23;
2975 image |= sig;
2976 break;
2978 default:
2979 gcc_unreachable ();
2982 buf[0] = image;
2985 static void
2986 decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
2987 const long *buf)
2989 unsigned long image = buf[0] & 0xffffffff;
2990 bool sign = (image >> 31) & 1;
2991 int exp = (image >> 23) & 0xff;
2993 memset (r, 0, sizeof (*r));
2994 image <<= HOST_BITS_PER_LONG - 24;
2995 image &= ~SIG_MSB;
2997 if (exp == 0)
2999 if (image && fmt->has_denorm)
3001 r->cl = rvc_normal;
3002 r->sign = sign;
3003 SET_REAL_EXP (r, -126);
3004 r->sig[SIGSZ-1] = image << 1;
3005 normalize (r);
3007 else if (fmt->has_signed_zero)
3008 r->sign = sign;
3010 else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
3012 if (image)
3014 r->cl = rvc_nan;
3015 r->sign = sign;
3016 r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
3017 ^ fmt->qnan_msb_set);
3018 r->sig[SIGSZ-1] = image;
3020 else
3022 r->cl = rvc_inf;
3023 r->sign = sign;
3026 else
3028 r->cl = rvc_normal;
3029 r->sign = sign;
3030 SET_REAL_EXP (r, exp - 127 + 1);
3031 r->sig[SIGSZ-1] = image | SIG_MSB;
3035 const struct real_format ieee_single_format =
3037 encode_ieee_single,
3038 decode_ieee_single,
3042 -125,
3043 128,
3047 false,
3048 true,
3049 true,
3050 true,
3051 true,
3052 true,
3053 true,
3054 false,
3055 "ieee_single"
3058 const struct real_format mips_single_format =
3060 encode_ieee_single,
3061 decode_ieee_single,
3065 -125,
3066 128,
3070 false,
3071 true,
3072 true,
3073 true,
3074 true,
3075 true,
3076 false,
3077 true,
3078 "mips_single"
3081 const struct real_format motorola_single_format =
3083 encode_ieee_single,
3084 decode_ieee_single,
3088 -125,
3089 128,
3093 false,
3094 true,
3095 true,
3096 true,
3097 true,
3098 true,
3099 true,
3100 true,
3101 "motorola_single"
3104 /* SPU Single Precision (Extended-Range Mode) format is the same as IEEE
3105 single precision with the following differences:
3106 - Infinities are not supported. Instead MAX_FLOAT or MIN_FLOAT
3107 are generated.
3108 - NaNs are not supported.
3109 - The range of non-zero numbers in binary is
3110 (001)[1.]000...000 to (255)[1.]111...111.
3111 - Denormals can be represented, but are treated as +0.0 when
3112 used as an operand and are never generated as a result.
3113 - -0.0 can be represented, but a zero result is always +0.0.
3114 - the only supported rounding mode is trunction (towards zero). */
3115 const struct real_format spu_single_format =
3117 encode_ieee_single,
3118 decode_ieee_single,
3122 -125,
3123 129,
3127 true,
3128 false,
3129 false,
3130 false,
3131 true,
3132 true,
3133 false,
3134 false,
3135 "spu_single"
3138 /* IEEE double-precision format. */
3140 static void encode_ieee_double (const struct real_format *fmt,
3141 long *, const REAL_VALUE_TYPE *);
3142 static void decode_ieee_double (const struct real_format *,
3143 REAL_VALUE_TYPE *, const long *);
3145 static void
3146 encode_ieee_double (const struct real_format *fmt, long *buf,
3147 const REAL_VALUE_TYPE *r)
3149 unsigned long image_lo, image_hi, sig_lo, sig_hi, exp;
3150 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
3152 image_hi = r->sign << 31;
3153 image_lo = 0;
3155 if (HOST_BITS_PER_LONG == 64)
3157 sig_hi = r->sig[SIGSZ-1];
3158 sig_lo = (sig_hi >> (64 - 53)) & 0xffffffff;
3159 sig_hi = (sig_hi >> (64 - 53 + 1) >> 31) & 0xfffff;
3161 else
3163 sig_hi = r->sig[SIGSZ-1];
3164 sig_lo = r->sig[SIGSZ-2];
3165 sig_lo = (sig_hi << 21) | (sig_lo >> 11);
3166 sig_hi = (sig_hi >> 11) & 0xfffff;
3169 switch (r->cl)
3171 case rvc_zero:
3172 break;
3174 case rvc_inf:
3175 if (fmt->has_inf)
3176 image_hi |= 2047 << 20;
3177 else
3179 image_hi |= 0x7fffffff;
3180 image_lo = 0xffffffff;
3182 break;
3184 case rvc_nan:
3185 if (fmt->has_nans)
3187 if (r->canonical)
3189 if (fmt->canonical_nan_lsbs_set)
3191 sig_hi = (1 << 19) - 1;
3192 sig_lo = 0xffffffff;
3194 else
3196 sig_hi = 0;
3197 sig_lo = 0;
3200 if (r->signalling == fmt->qnan_msb_set)
3201 sig_hi &= ~(1 << 19);
3202 else
3203 sig_hi |= 1 << 19;
3204 if (sig_hi == 0 && sig_lo == 0)
3205 sig_hi = 1 << 18;
3207 image_hi |= 2047 << 20;
3208 image_hi |= sig_hi;
3209 image_lo = sig_lo;
3211 else
3213 image_hi |= 0x7fffffff;
3214 image_lo = 0xffffffff;
3216 break;
3218 case rvc_normal:
3219 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3220 whereas the intermediate representation is 0.F x 2**exp.
3221 Which means we're off by one. */
3222 if (denormal)
3223 exp = 0;
3224 else
3225 exp = REAL_EXP (r) + 1023 - 1;
3226 image_hi |= exp << 20;
3227 image_hi |= sig_hi;
3228 image_lo = sig_lo;
3229 break;
3231 default:
3232 gcc_unreachable ();
3235 if (FLOAT_WORDS_BIG_ENDIAN)
3236 buf[0] = image_hi, buf[1] = image_lo;
3237 else
3238 buf[0] = image_lo, buf[1] = image_hi;
3241 static void
3242 decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3243 const long *buf)
3245 unsigned long image_hi, image_lo;
3246 bool sign;
3247 int exp;
3249 if (FLOAT_WORDS_BIG_ENDIAN)
3250 image_hi = buf[0], image_lo = buf[1];
3251 else
3252 image_lo = buf[0], image_hi = buf[1];
3253 image_lo &= 0xffffffff;
3254 image_hi &= 0xffffffff;
3256 sign = (image_hi >> 31) & 1;
3257 exp = (image_hi >> 20) & 0x7ff;
3259 memset (r, 0, sizeof (*r));
3261 image_hi <<= 32 - 21;
3262 image_hi |= image_lo >> 21;
3263 image_hi &= 0x7fffffff;
3264 image_lo <<= 32 - 21;
3266 if (exp == 0)
3268 if ((image_hi || image_lo) && fmt->has_denorm)
3270 r->cl = rvc_normal;
3271 r->sign = sign;
3272 SET_REAL_EXP (r, -1022);
3273 if (HOST_BITS_PER_LONG == 32)
3275 image_hi = (image_hi << 1) | (image_lo >> 31);
3276 image_lo <<= 1;
3277 r->sig[SIGSZ-1] = image_hi;
3278 r->sig[SIGSZ-2] = image_lo;
3280 else
3282 image_hi = (image_hi << 31 << 2) | (image_lo << 1);
3283 r->sig[SIGSZ-1] = image_hi;
3285 normalize (r);
3287 else if (fmt->has_signed_zero)
3288 r->sign = sign;
3290 else if (exp == 2047 && (fmt->has_nans || fmt->has_inf))
3292 if (image_hi || image_lo)
3294 r->cl = rvc_nan;
3295 r->sign = sign;
3296 r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set;
3297 if (HOST_BITS_PER_LONG == 32)
3299 r->sig[SIGSZ-1] = image_hi;
3300 r->sig[SIGSZ-2] = image_lo;
3302 else
3303 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo;
3305 else
3307 r->cl = rvc_inf;
3308 r->sign = sign;
3311 else
3313 r->cl = rvc_normal;
3314 r->sign = sign;
3315 SET_REAL_EXP (r, exp - 1023 + 1);
3316 if (HOST_BITS_PER_LONG == 32)
3318 r->sig[SIGSZ-1] = image_hi | SIG_MSB;
3319 r->sig[SIGSZ-2] = image_lo;
3321 else
3322 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo | SIG_MSB;
3326 const struct real_format ieee_double_format =
3328 encode_ieee_double,
3329 decode_ieee_double,
3333 -1021,
3334 1024,
3338 false,
3339 true,
3340 true,
3341 true,
3342 true,
3343 true,
3344 true,
3345 false,
3346 "ieee_double"
3349 const struct real_format mips_double_format =
3351 encode_ieee_double,
3352 decode_ieee_double,
3356 -1021,
3357 1024,
3361 false,
3362 true,
3363 true,
3364 true,
3365 true,
3366 true,
3367 false,
3368 true,
3369 "mips_double"
3372 const struct real_format motorola_double_format =
3374 encode_ieee_double,
3375 decode_ieee_double,
3379 -1021,
3380 1024,
3384 false,
3385 true,
3386 true,
3387 true,
3388 true,
3389 true,
3390 true,
3391 true,
3392 "motorola_double"
3395 /* IEEE extended real format. This comes in three flavors: Intel's as
3396 a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
3397 12- and 16-byte images may be big- or little endian; Motorola's is
3398 always big endian. */
3400 /* Helper subroutine which converts from the internal format to the
3401 12-byte little-endian Intel format. Functions below adjust this
3402 for the other possible formats. */
3403 static void
3404 encode_ieee_extended (const struct real_format *fmt, long *buf,
3405 const REAL_VALUE_TYPE *r)
3407 unsigned long image_hi, sig_hi, sig_lo;
3408 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
3410 image_hi = r->sign << 15;
3411 sig_hi = sig_lo = 0;
3413 switch (r->cl)
3415 case rvc_zero:
3416 break;
3418 case rvc_inf:
3419 if (fmt->has_inf)
3421 image_hi |= 32767;
3423 /* Intel requires the explicit integer bit to be set, otherwise
3424 it considers the value a "pseudo-infinity". Motorola docs
3425 say it doesn't care. */
3426 sig_hi = 0x80000000;
3428 else
3430 image_hi |= 32767;
3431 sig_lo = sig_hi = 0xffffffff;
3433 break;
3435 case rvc_nan:
3436 if (fmt->has_nans)
3438 image_hi |= 32767;
3439 if (r->canonical)
3441 if (fmt->canonical_nan_lsbs_set)
3443 sig_hi = (1 << 30) - 1;
3444 sig_lo = 0xffffffff;
3447 else if (HOST_BITS_PER_LONG == 32)
3449 sig_hi = r->sig[SIGSZ-1];
3450 sig_lo = r->sig[SIGSZ-2];
3452 else
3454 sig_lo = r->sig[SIGSZ-1];
3455 sig_hi = sig_lo >> 31 >> 1;
3456 sig_lo &= 0xffffffff;
3458 if (r->signalling == fmt->qnan_msb_set)
3459 sig_hi &= ~(1 << 30);
3460 else
3461 sig_hi |= 1 << 30;
3462 if ((sig_hi & 0x7fffffff) == 0 && sig_lo == 0)
3463 sig_hi = 1 << 29;
3465 /* Intel requires the explicit integer bit to be set, otherwise
3466 it considers the value a "pseudo-nan". Motorola docs say it
3467 doesn't care. */
3468 sig_hi |= 0x80000000;
3470 else
3472 image_hi |= 32767;
3473 sig_lo = sig_hi = 0xffffffff;
3475 break;
3477 case rvc_normal:
3479 int exp = REAL_EXP (r);
3481 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3482 whereas the intermediate representation is 0.F x 2**exp.
3483 Which means we're off by one.
3485 Except for Motorola, which consider exp=0 and explicit
3486 integer bit set to continue to be normalized. In theory
3487 this discrepancy has been taken care of by the difference
3488 in fmt->emin in round_for_format. */
3490 if (denormal)
3491 exp = 0;
3492 else
3494 exp += 16383 - 1;
3495 gcc_assert (exp >= 0);
3497 image_hi |= exp;
3499 if (HOST_BITS_PER_LONG == 32)
3501 sig_hi = r->sig[SIGSZ-1];
3502 sig_lo = r->sig[SIGSZ-2];
3504 else
3506 sig_lo = r->sig[SIGSZ-1];
3507 sig_hi = sig_lo >> 31 >> 1;
3508 sig_lo &= 0xffffffff;
3511 break;
3513 default:
3514 gcc_unreachable ();
3517 buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
3520 /* Convert from the internal format to the 12-byte Motorola format
3521 for an IEEE extended real. */
3522 static void
3523 encode_ieee_extended_motorola (const struct real_format *fmt, long *buf,
3524 const REAL_VALUE_TYPE *r)
3526 long intermed[3];
3527 encode_ieee_extended (fmt, intermed, r);
3529 if (r->cl == rvc_inf)
3530 /* For infinity clear the explicit integer bit again, so that the
3531 format matches the canonical infinity generated by the FPU. */
3532 intermed[1] = 0;
3534 /* Motorola chips are assumed always to be big-endian. Also, the
3535 padding in a Motorola extended real goes between the exponent and
3536 the mantissa. At this point the mantissa is entirely within
3537 elements 0 and 1 of intermed, and the exponent entirely within
3538 element 2, so all we have to do is swap the order around, and
3539 shift element 2 left 16 bits. */
3540 buf[0] = intermed[2] << 16;
3541 buf[1] = intermed[1];
3542 buf[2] = intermed[0];
3545 /* Convert from the internal format to the 12-byte Intel format for
3546 an IEEE extended real. */
3547 static void
3548 encode_ieee_extended_intel_96 (const struct real_format *fmt, long *buf,
3549 const REAL_VALUE_TYPE *r)
3551 if (FLOAT_WORDS_BIG_ENDIAN)
3553 /* All the padding in an Intel-format extended real goes at the high
3554 end, which in this case is after the mantissa, not the exponent.
3555 Therefore we must shift everything down 16 bits. */
3556 long intermed[3];
3557 encode_ieee_extended (fmt, intermed, r);
3558 buf[0] = ((intermed[2] << 16) | ((unsigned long)(intermed[1] & 0xFFFF0000) >> 16));
3559 buf[1] = ((intermed[1] << 16) | ((unsigned long)(intermed[0] & 0xFFFF0000) >> 16));
3560 buf[2] = (intermed[0] << 16);
3562 else
3563 /* encode_ieee_extended produces what we want directly. */
3564 encode_ieee_extended (fmt, buf, r);
3567 /* Convert from the internal format to the 16-byte Intel format for
3568 an IEEE extended real. */
3569 static void
3570 encode_ieee_extended_intel_128 (const struct real_format *fmt, long *buf,
3571 const REAL_VALUE_TYPE *r)
3573 /* All the padding in an Intel-format extended real goes at the high end. */
3574 encode_ieee_extended_intel_96 (fmt, buf, r);
3575 buf[3] = 0;
3578 /* As above, we have a helper function which converts from 12-byte
3579 little-endian Intel format to internal format. Functions below
3580 adjust for the other possible formats. */
3581 static void
3582 decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3583 const long *buf)
3585 unsigned long image_hi, sig_hi, sig_lo;
3586 bool sign;
3587 int exp;
3589 sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
3590 sig_lo &= 0xffffffff;
3591 sig_hi &= 0xffffffff;
3592 image_hi &= 0xffffffff;
3594 sign = (image_hi >> 15) & 1;
3595 exp = image_hi & 0x7fff;
3597 memset (r, 0, sizeof (*r));
3599 if (exp == 0)
3601 if ((sig_hi || sig_lo) && fmt->has_denorm)
3603 r->cl = rvc_normal;
3604 r->sign = sign;
3606 /* When the IEEE format contains a hidden bit, we know that
3607 it's zero at this point, and so shift up the significand
3608 and decrease the exponent to match. In this case, Motorola
3609 defines the explicit integer bit to be valid, so we don't
3610 know whether the msb is set or not. */
3611 SET_REAL_EXP (r, fmt->emin);
3612 if (HOST_BITS_PER_LONG == 32)
3614 r->sig[SIGSZ-1] = sig_hi;
3615 r->sig[SIGSZ-2] = sig_lo;
3617 else
3618 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3620 normalize (r);
3622 else if (fmt->has_signed_zero)
3623 r->sign = sign;
3625 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3627 /* See above re "pseudo-infinities" and "pseudo-nans".
3628 Short summary is that the MSB will likely always be
3629 set, and that we don't care about it. */
3630 sig_hi &= 0x7fffffff;
3632 if (sig_hi || sig_lo)
3634 r->cl = rvc_nan;
3635 r->sign = sign;
3636 r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set;
3637 if (HOST_BITS_PER_LONG == 32)
3639 r->sig[SIGSZ-1] = sig_hi;
3640 r->sig[SIGSZ-2] = sig_lo;
3642 else
3643 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3645 else
3647 r->cl = rvc_inf;
3648 r->sign = sign;
3651 else
3653 r->cl = rvc_normal;
3654 r->sign = sign;
3655 SET_REAL_EXP (r, exp - 16383 + 1);
3656 if (HOST_BITS_PER_LONG == 32)
3658 r->sig[SIGSZ-1] = sig_hi;
3659 r->sig[SIGSZ-2] = sig_lo;
3661 else
3662 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3666 /* Convert from the internal format to the 12-byte Motorola format
3667 for an IEEE extended real. */
3668 static void
3669 decode_ieee_extended_motorola (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3670 const long *buf)
3672 long intermed[3];
3674 /* Motorola chips are assumed always to be big-endian. Also, the
3675 padding in a Motorola extended real goes between the exponent and
3676 the mantissa; remove it. */
3677 intermed[0] = buf[2];
3678 intermed[1] = buf[1];
3679 intermed[2] = (unsigned long)buf[0] >> 16;
3681 decode_ieee_extended (fmt, r, intermed);
3684 /* Convert from the internal format to the 12-byte Intel format for
3685 an IEEE extended real. */
3686 static void
3687 decode_ieee_extended_intel_96 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3688 const long *buf)
3690 if (FLOAT_WORDS_BIG_ENDIAN)
3692 /* All the padding in an Intel-format extended real goes at the high
3693 end, which in this case is after the mantissa, not the exponent.
3694 Therefore we must shift everything up 16 bits. */
3695 long intermed[3];
3697 intermed[0] = (((unsigned long)buf[2] >> 16) | (buf[1] << 16));
3698 intermed[1] = (((unsigned long)buf[1] >> 16) | (buf[0] << 16));
3699 intermed[2] = ((unsigned long)buf[0] >> 16);
3701 decode_ieee_extended (fmt, r, intermed);
3703 else
3704 /* decode_ieee_extended produces what we want directly. */
3705 decode_ieee_extended (fmt, r, buf);
3708 /* Convert from the internal format to the 16-byte Intel format for
3709 an IEEE extended real. */
3710 static void
3711 decode_ieee_extended_intel_128 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3712 const long *buf)
3714 /* All the padding in an Intel-format extended real goes at the high end. */
3715 decode_ieee_extended_intel_96 (fmt, r, buf);
3718 const struct real_format ieee_extended_motorola_format =
3720 encode_ieee_extended_motorola,
3721 decode_ieee_extended_motorola,
3725 -16382,
3726 16384,
3730 false,
3731 true,
3732 true,
3733 true,
3734 true,
3735 true,
3736 true,
3737 true,
3738 "ieee_extended_motorola"
3741 const struct real_format ieee_extended_intel_96_format =
3743 encode_ieee_extended_intel_96,
3744 decode_ieee_extended_intel_96,
3748 -16381,
3749 16384,
3753 false,
3754 true,
3755 true,
3756 true,
3757 true,
3758 true,
3759 true,
3760 false,
3761 "ieee_extended_intel_96"
3764 const struct real_format ieee_extended_intel_128_format =
3766 encode_ieee_extended_intel_128,
3767 decode_ieee_extended_intel_128,
3771 -16381,
3772 16384,
3776 false,
3777 true,
3778 true,
3779 true,
3780 true,
3781 true,
3782 true,
3783 false,
3784 "ieee_extended_intel_128"
3787 /* The following caters to i386 systems that set the rounding precision
3788 to 53 bits instead of 64, e.g. FreeBSD. */
3789 const struct real_format ieee_extended_intel_96_round_53_format =
3791 encode_ieee_extended_intel_96,
3792 decode_ieee_extended_intel_96,
3796 -16381,
3797 16384,
3801 false,
3802 true,
3803 true,
3804 true,
3805 true,
3806 true,
3807 true,
3808 false,
3809 "ieee_extended_intel_96_round_53"
3812 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3813 numbers whose sum is equal to the extended precision value. The number
3814 with greater magnitude is first. This format has the same magnitude
3815 range as an IEEE double precision value, but effectively 106 bits of
3816 significand precision. Infinity and NaN are represented by their IEEE
3817 double precision value stored in the first number, the second number is
3818 +0.0 or -0.0 for Infinity and don't-care for NaN. */
3820 static void encode_ibm_extended (const struct real_format *fmt,
3821 long *, const REAL_VALUE_TYPE *);
3822 static void decode_ibm_extended (const struct real_format *,
3823 REAL_VALUE_TYPE *, const long *);
3825 static void
3826 encode_ibm_extended (const struct real_format *fmt, long *buf,
3827 const REAL_VALUE_TYPE *r)
3829 REAL_VALUE_TYPE u, normr, v;
3830 const struct real_format *base_fmt;
3832 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3834 /* Renormalize R before doing any arithmetic on it. */
3835 normr = *r;
3836 if (normr.cl == rvc_normal)
3837 normalize (&normr);
3839 /* u = IEEE double precision portion of significand. */
3840 u = normr;
3841 round_for_format (base_fmt, &u);
3842 encode_ieee_double (base_fmt, &buf[0], &u);
3844 if (u.cl == rvc_normal)
3846 do_add (&v, &normr, &u, 1);
3847 /* Call round_for_format since we might need to denormalize. */
3848 round_for_format (base_fmt, &v);
3849 encode_ieee_double (base_fmt, &buf[2], &v);
3851 else
3853 /* Inf, NaN, 0 are all representable as doubles, so the
3854 least-significant part can be 0.0. */
3855 buf[2] = 0;
3856 buf[3] = 0;
3860 static void
3861 decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_TYPE *r,
3862 const long *buf)
3864 REAL_VALUE_TYPE u, v;
3865 const struct real_format *base_fmt;
3867 base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3868 decode_ieee_double (base_fmt, &u, &buf[0]);
3870 if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan)
3872 decode_ieee_double (base_fmt, &v, &buf[2]);
3873 do_add (r, &u, &v, 0);
3875 else
3876 *r = u;
3879 const struct real_format ibm_extended_format =
3881 encode_ibm_extended,
3882 decode_ibm_extended,
3884 53 + 53,
3886 -1021 + 53,
3887 1024,
3888 127,
3891 false,
3892 true,
3893 true,
3894 true,
3895 true,
3896 true,
3897 true,
3898 false,
3899 "ibm_extended"
3902 const struct real_format mips_extended_format =
3904 encode_ibm_extended,
3905 decode_ibm_extended,
3907 53 + 53,
3909 -1021 + 53,
3910 1024,
3911 127,
3914 false,
3915 true,
3916 true,
3917 true,
3918 true,
3919 true,
3920 false,
3921 true,
3922 "mips_extended"
3926 /* IEEE quad precision format. */
3928 static void encode_ieee_quad (const struct real_format *fmt,
3929 long *, const REAL_VALUE_TYPE *);
3930 static void decode_ieee_quad (const struct real_format *,
3931 REAL_VALUE_TYPE *, const long *);
3933 static void
3934 encode_ieee_quad (const struct real_format *fmt, long *buf,
3935 const REAL_VALUE_TYPE *r)
3937 unsigned long image3, image2, image1, image0, exp;
3938 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
3939 REAL_VALUE_TYPE u;
3941 image3 = r->sign << 31;
3942 image2 = 0;
3943 image1 = 0;
3944 image0 = 0;
3946 rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
3948 switch (r->cl)
3950 case rvc_zero:
3951 break;
3953 case rvc_inf:
3954 if (fmt->has_inf)
3955 image3 |= 32767 << 16;
3956 else
3958 image3 |= 0x7fffffff;
3959 image2 = 0xffffffff;
3960 image1 = 0xffffffff;
3961 image0 = 0xffffffff;
3963 break;
3965 case rvc_nan:
3966 if (fmt->has_nans)
3968 image3 |= 32767 << 16;
3970 if (r->canonical)
3972 if (fmt->canonical_nan_lsbs_set)
3974 image3 |= 0x7fff;
3975 image2 = image1 = image0 = 0xffffffff;
3978 else if (HOST_BITS_PER_LONG == 32)
3980 image0 = u.sig[0];
3981 image1 = u.sig[1];
3982 image2 = u.sig[2];
3983 image3 |= u.sig[3] & 0xffff;
3985 else
3987 image0 = u.sig[0];
3988 image1 = image0 >> 31 >> 1;
3989 image2 = u.sig[1];
3990 image3 |= (image2 >> 31 >> 1) & 0xffff;
3991 image0 &= 0xffffffff;
3992 image2 &= 0xffffffff;
3994 if (r->signalling == fmt->qnan_msb_set)
3995 image3 &= ~0x8000;
3996 else
3997 image3 |= 0x8000;
3998 if (((image3 & 0xffff) | image2 | image1 | image0) == 0)
3999 image3 |= 0x4000;
4001 else
4003 image3 |= 0x7fffffff;
4004 image2 = 0xffffffff;
4005 image1 = 0xffffffff;
4006 image0 = 0xffffffff;
4008 break;
4010 case rvc_normal:
4011 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
4012 whereas the intermediate representation is 0.F x 2**exp.
4013 Which means we're off by one. */
4014 if (denormal)
4015 exp = 0;
4016 else
4017 exp = REAL_EXP (r) + 16383 - 1;
4018 image3 |= exp << 16;
4020 if (HOST_BITS_PER_LONG == 32)
4022 image0 = u.sig[0];
4023 image1 = u.sig[1];
4024 image2 = u.sig[2];
4025 image3 |= u.sig[3] & 0xffff;
4027 else
4029 image0 = u.sig[0];
4030 image1 = image0 >> 31 >> 1;
4031 image2 = u.sig[1];
4032 image3 |= (image2 >> 31 >> 1) & 0xffff;
4033 image0 &= 0xffffffff;
4034 image2 &= 0xffffffff;
4036 break;
4038 default:
4039 gcc_unreachable ();
4042 if (FLOAT_WORDS_BIG_ENDIAN)
4044 buf[0] = image3;
4045 buf[1] = image2;
4046 buf[2] = image1;
4047 buf[3] = image0;
4049 else
4051 buf[0] = image0;
4052 buf[1] = image1;
4053 buf[2] = image2;
4054 buf[3] = image3;
4058 static void
4059 decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
4060 const long *buf)
4062 unsigned long image3, image2, image1, image0;
4063 bool sign;
4064 int exp;
4066 if (FLOAT_WORDS_BIG_ENDIAN)
4068 image3 = buf[0];
4069 image2 = buf[1];
4070 image1 = buf[2];
4071 image0 = buf[3];
4073 else
4075 image0 = buf[0];
4076 image1 = buf[1];
4077 image2 = buf[2];
4078 image3 = buf[3];
4080 image0 &= 0xffffffff;
4081 image1 &= 0xffffffff;
4082 image2 &= 0xffffffff;
4084 sign = (image3 >> 31) & 1;
4085 exp = (image3 >> 16) & 0x7fff;
4086 image3 &= 0xffff;
4088 memset (r, 0, sizeof (*r));
4090 if (exp == 0)
4092 if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
4094 r->cl = rvc_normal;
4095 r->sign = sign;
4097 SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
4098 if (HOST_BITS_PER_LONG == 32)
4100 r->sig[0] = image0;
4101 r->sig[1] = image1;
4102 r->sig[2] = image2;
4103 r->sig[3] = image3;
4105 else
4107 r->sig[0] = (image1 << 31 << 1) | image0;
4108 r->sig[1] = (image3 << 31 << 1) | image2;
4111 normalize (r);
4113 else if (fmt->has_signed_zero)
4114 r->sign = sign;
4116 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
4118 if (image3 | image2 | image1 | image0)
4120 r->cl = rvc_nan;
4121 r->sign = sign;
4122 r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set;
4124 if (HOST_BITS_PER_LONG == 32)
4126 r->sig[0] = image0;
4127 r->sig[1] = image1;
4128 r->sig[2] = image2;
4129 r->sig[3] = image3;
4131 else
4133 r->sig[0] = (image1 << 31 << 1) | image0;
4134 r->sig[1] = (image3 << 31 << 1) | image2;
4136 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
4138 else
4140 r->cl = rvc_inf;
4141 r->sign = sign;
4144 else
4146 r->cl = rvc_normal;
4147 r->sign = sign;
4148 SET_REAL_EXP (r, exp - 16383 + 1);
4150 if (HOST_BITS_PER_LONG == 32)
4152 r->sig[0] = image0;
4153 r->sig[1] = image1;
4154 r->sig[2] = image2;
4155 r->sig[3] = image3;
4157 else
4159 r->sig[0] = (image1 << 31 << 1) | image0;
4160 r->sig[1] = (image3 << 31 << 1) | image2;
4162 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
4163 r->sig[SIGSZ-1] |= SIG_MSB;
4167 const struct real_format ieee_quad_format =
4169 encode_ieee_quad,
4170 decode_ieee_quad,
4172 113,
4173 113,
4174 -16381,
4175 16384,
4176 127,
4177 127,
4178 128,
4179 false,
4180 true,
4181 true,
4182 true,
4183 true,
4184 true,
4185 true,
4186 false,
4187 "ieee_quad"
4190 const struct real_format mips_quad_format =
4192 encode_ieee_quad,
4193 decode_ieee_quad,
4195 113,
4196 113,
4197 -16381,
4198 16384,
4199 127,
4200 127,
4201 128,
4202 false,
4203 true,
4204 true,
4205 true,
4206 true,
4207 true,
4208 false,
4209 true,
4210 "mips_quad"
4213 /* Descriptions of VAX floating point formats can be found beginning at
4215 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
4217 The thing to remember is that they're almost IEEE, except for word
4218 order, exponent bias, and the lack of infinities, nans, and denormals.
4220 We don't implement the H_floating format here, simply because neither
4221 the VAX or Alpha ports use it. */
4223 static void encode_vax_f (const struct real_format *fmt,
4224 long *, const REAL_VALUE_TYPE *);
4225 static void decode_vax_f (const struct real_format *,
4226 REAL_VALUE_TYPE *, const long *);
4227 static void encode_vax_d (const struct real_format *fmt,
4228 long *, const REAL_VALUE_TYPE *);
4229 static void decode_vax_d (const struct real_format *,
4230 REAL_VALUE_TYPE *, const long *);
4231 static void encode_vax_g (const struct real_format *fmt,
4232 long *, const REAL_VALUE_TYPE *);
4233 static void decode_vax_g (const struct real_format *,
4234 REAL_VALUE_TYPE *, const long *);
4236 static void
4237 encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4238 const REAL_VALUE_TYPE *r)
4240 unsigned long sign, exp, sig, image;
4242 sign = r->sign << 15;
4244 switch (r->cl)
4246 case rvc_zero:
4247 image = 0;
4248 break;
4250 case rvc_inf:
4251 case rvc_nan:
4252 image = 0xffff7fff | sign;
4253 break;
4255 case rvc_normal:
4256 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
4257 exp = REAL_EXP (r) + 128;
4259 image = (sig << 16) & 0xffff0000;
4260 image |= sign;
4261 image |= exp << 7;
4262 image |= sig >> 16;
4263 break;
4265 default:
4266 gcc_unreachable ();
4269 buf[0] = image;
4272 static void
4273 decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED,
4274 REAL_VALUE_TYPE *r, const long *buf)
4276 unsigned long image = buf[0] & 0xffffffff;
4277 int exp = (image >> 7) & 0xff;
4279 memset (r, 0, sizeof (*r));
4281 if (exp != 0)
4283 r->cl = rvc_normal;
4284 r->sign = (image >> 15) & 1;
4285 SET_REAL_EXP (r, exp - 128);
4287 image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff);
4288 r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
4292 static void
4293 encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4294 const REAL_VALUE_TYPE *r)
4296 unsigned long image0, image1, sign = r->sign << 15;
4298 switch (r->cl)
4300 case rvc_zero:
4301 image0 = image1 = 0;
4302 break;
4304 case rvc_inf:
4305 case rvc_nan:
4306 image0 = 0xffff7fff | sign;
4307 image1 = 0xffffffff;
4308 break;
4310 case rvc_normal:
4311 /* Extract the significand into straight hi:lo. */
4312 if (HOST_BITS_PER_LONG == 64)
4314 image0 = r->sig[SIGSZ-1];
4315 image1 = (image0 >> (64 - 56)) & 0xffffffff;
4316 image0 = (image0 >> (64 - 56 + 1) >> 31) & 0x7fffff;
4318 else
4320 image0 = r->sig[SIGSZ-1];
4321 image1 = r->sig[SIGSZ-2];
4322 image1 = (image0 << 24) | (image1 >> 8);
4323 image0 = (image0 >> 8) & 0xffffff;
4326 /* Rearrange the half-words of the significand to match the
4327 external format. */
4328 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff007f;
4329 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
4331 /* Add the sign and exponent. */
4332 image0 |= sign;
4333 image0 |= (REAL_EXP (r) + 128) << 7;
4334 break;
4336 default:
4337 gcc_unreachable ();
4340 if (FLOAT_WORDS_BIG_ENDIAN)
4341 buf[0] = image1, buf[1] = image0;
4342 else
4343 buf[0] = image0, buf[1] = image1;
4346 static void
4347 decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED,
4348 REAL_VALUE_TYPE *r, const long *buf)
4350 unsigned long image0, image1;
4351 int exp;
4353 if (FLOAT_WORDS_BIG_ENDIAN)
4354 image1 = buf[0], image0 = buf[1];
4355 else
4356 image0 = buf[0], image1 = buf[1];
4357 image0 &= 0xffffffff;
4358 image1 &= 0xffffffff;
4360 exp = (image0 >> 7) & 0xff;
4362 memset (r, 0, sizeof (*r));
4364 if (exp != 0)
4366 r->cl = rvc_normal;
4367 r->sign = (image0 >> 15) & 1;
4368 SET_REAL_EXP (r, exp - 128);
4370 /* Rearrange the half-words of the external format into
4371 proper ascending order. */
4372 image0 = ((image0 & 0x7f) << 16) | ((image0 >> 16) & 0xffff);
4373 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
4375 if (HOST_BITS_PER_LONG == 64)
4377 image0 = (image0 << 31 << 1) | image1;
4378 image0 <<= 64 - 56;
4379 image0 |= SIG_MSB;
4380 r->sig[SIGSZ-1] = image0;
4382 else
4384 r->sig[SIGSZ-1] = image0;
4385 r->sig[SIGSZ-2] = image1;
4386 lshift_significand (r, r, 2*HOST_BITS_PER_LONG - 56);
4387 r->sig[SIGSZ-1] |= SIG_MSB;
4392 static void
4393 encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4394 const REAL_VALUE_TYPE *r)
4396 unsigned long image0, image1, sign = r->sign << 15;
4398 switch (r->cl)
4400 case rvc_zero:
4401 image0 = image1 = 0;
4402 break;
4404 case rvc_inf:
4405 case rvc_nan:
4406 image0 = 0xffff7fff | sign;
4407 image1 = 0xffffffff;
4408 break;
4410 case rvc_normal:
4411 /* Extract the significand into straight hi:lo. */
4412 if (HOST_BITS_PER_LONG == 64)
4414 image0 = r->sig[SIGSZ-1];
4415 image1 = (image0 >> (64 - 53)) & 0xffffffff;
4416 image0 = (image0 >> (64 - 53 + 1) >> 31) & 0xfffff;
4418 else
4420 image0 = r->sig[SIGSZ-1];
4421 image1 = r->sig[SIGSZ-2];
4422 image1 = (image0 << 21) | (image1 >> 11);
4423 image0 = (image0 >> 11) & 0xfffff;
4426 /* Rearrange the half-words of the significand to match the
4427 external format. */
4428 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff000f;
4429 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
4431 /* Add the sign and exponent. */
4432 image0 |= sign;
4433 image0 |= (REAL_EXP (r) + 1024) << 4;
4434 break;
4436 default:
4437 gcc_unreachable ();
4440 if (FLOAT_WORDS_BIG_ENDIAN)
4441 buf[0] = image1, buf[1] = image0;
4442 else
4443 buf[0] = image0, buf[1] = image1;
4446 static void
4447 decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED,
4448 REAL_VALUE_TYPE *r, const long *buf)
4450 unsigned long image0, image1;
4451 int exp;
4453 if (FLOAT_WORDS_BIG_ENDIAN)
4454 image1 = buf[0], image0 = buf[1];
4455 else
4456 image0 = buf[0], image1 = buf[1];
4457 image0 &= 0xffffffff;
4458 image1 &= 0xffffffff;
4460 exp = (image0 >> 4) & 0x7ff;
4462 memset (r, 0, sizeof (*r));
4464 if (exp != 0)
4466 r->cl = rvc_normal;
4467 r->sign = (image0 >> 15) & 1;
4468 SET_REAL_EXP (r, exp - 1024);
4470 /* Rearrange the half-words of the external format into
4471 proper ascending order. */
4472 image0 = ((image0 & 0xf) << 16) | ((image0 >> 16) & 0xffff);
4473 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
4475 if (HOST_BITS_PER_LONG == 64)
4477 image0 = (image0 << 31 << 1) | image1;
4478 image0 <<= 64 - 53;
4479 image0 |= SIG_MSB;
4480 r->sig[SIGSZ-1] = image0;
4482 else
4484 r->sig[SIGSZ-1] = image0;
4485 r->sig[SIGSZ-2] = image1;
4486 lshift_significand (r, r, 64 - 53);
4487 r->sig[SIGSZ-1] |= SIG_MSB;
4492 const struct real_format vax_f_format =
4494 encode_vax_f,
4495 decode_vax_f,
4499 -127,
4500 127,
4504 false,
4505 false,
4506 false,
4507 false,
4508 false,
4509 false,
4510 false,
4511 false,
4512 "vax_f"
4515 const struct real_format vax_d_format =
4517 encode_vax_d,
4518 decode_vax_d,
4522 -127,
4523 127,
4527 false,
4528 false,
4529 false,
4530 false,
4531 false,
4532 false,
4533 false,
4534 false,
4535 "vax_d"
4538 const struct real_format vax_g_format =
4540 encode_vax_g,
4541 decode_vax_g,
4545 -1023,
4546 1023,
4550 false,
4551 false,
4552 false,
4553 false,
4554 false,
4555 false,
4556 false,
4557 false,
4558 "vax_g"
4561 /* Encode real R into a single precision DFP value in BUF. */
4562 static void
4563 encode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4564 long *buf ATTRIBUTE_UNUSED,
4565 const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
4567 encode_decimal32 (fmt, buf, r);
4570 /* Decode a single precision DFP value in BUF into a real R. */
4571 static void
4572 decode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4573 REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
4574 const long *buf ATTRIBUTE_UNUSED)
4576 decode_decimal32 (fmt, r, buf);
4579 /* Encode real R into a double precision DFP value in BUF. */
4580 static void
4581 encode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4582 long *buf ATTRIBUTE_UNUSED,
4583 const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
4585 encode_decimal64 (fmt, buf, r);
4588 /* Decode a double precision DFP value in BUF into a real R. */
4589 static void
4590 decode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4591 REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
4592 const long *buf ATTRIBUTE_UNUSED)
4594 decode_decimal64 (fmt, r, buf);
4597 /* Encode real R into a quad precision DFP value in BUF. */
4598 static void
4599 encode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
4600 long *buf ATTRIBUTE_UNUSED,
4601 const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
4603 encode_decimal128 (fmt, buf, r);
4606 /* Decode a quad precision DFP value in BUF into a real R. */
4607 static void
4608 decode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
4609 REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
4610 const long *buf ATTRIBUTE_UNUSED)
4612 decode_decimal128 (fmt, r, buf);
4615 /* Single precision decimal floating point (IEEE 754). */
4616 const struct real_format decimal_single_format =
4618 encode_decimal_single,
4619 decode_decimal_single,
4623 -94,
4628 false,
4629 true,
4630 true,
4631 true,
4632 true,
4633 true,
4634 true,
4635 false,
4636 "decimal_single"
4639 /* Double precision decimal floating point (IEEE 754). */
4640 const struct real_format decimal_double_format =
4642 encode_decimal_double,
4643 decode_decimal_double,
4647 -382,
4648 385,
4652 false,
4653 true,
4654 true,
4655 true,
4656 true,
4657 true,
4658 true,
4659 false,
4660 "decimal_double"
4663 /* Quad precision decimal floating point (IEEE 754). */
4664 const struct real_format decimal_quad_format =
4666 encode_decimal_quad,
4667 decode_decimal_quad,
4671 -6142,
4672 6145,
4673 127,
4674 127,
4675 128,
4676 false,
4677 true,
4678 true,
4679 true,
4680 true,
4681 true,
4682 true,
4683 false,
4684 "decimal_quad"
4687 /* Encode half-precision floats. This routine is used both for the IEEE
4688 ARM alternative encodings. */
4689 static void
4690 encode_ieee_half (const struct real_format *fmt, long *buf,
4691 const REAL_VALUE_TYPE *r)
4693 unsigned long image, sig, exp;
4694 unsigned long sign = r->sign;
4695 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
4697 image = sign << 15;
4698 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 11)) & 0x3ff;
4700 switch (r->cl)
4702 case rvc_zero:
4703 break;
4705 case rvc_inf:
4706 if (fmt->has_inf)
4707 image |= 31 << 10;
4708 else
4709 image |= 0x7fff;
4710 break;
4712 case rvc_nan:
4713 if (fmt->has_nans)
4715 if (r->canonical)
4716 sig = (fmt->canonical_nan_lsbs_set ? (1 << 9) - 1 : 0);
4717 if (r->signalling == fmt->qnan_msb_set)
4718 sig &= ~(1 << 9);
4719 else
4720 sig |= 1 << 9;
4721 if (sig == 0)
4722 sig = 1 << 8;
4724 image |= 31 << 10;
4725 image |= sig;
4727 else
4728 image |= 0x3ff;
4729 break;
4731 case rvc_normal:
4732 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
4733 whereas the intermediate representation is 0.F x 2**exp.
4734 Which means we're off by one. */
4735 if (denormal)
4736 exp = 0;
4737 else
4738 exp = REAL_EXP (r) + 15 - 1;
4739 image |= exp << 10;
4740 image |= sig;
4741 break;
4743 default:
4744 gcc_unreachable ();
4747 buf[0] = image;
4750 /* Decode half-precision floats. This routine is used both for the IEEE
4751 ARM alternative encodings. */
4752 static void
4753 decode_ieee_half (const struct real_format *fmt, REAL_VALUE_TYPE *r,
4754 const long *buf)
4756 unsigned long image = buf[0] & 0xffff;
4757 bool sign = (image >> 15) & 1;
4758 int exp = (image >> 10) & 0x1f;
4760 memset (r, 0, sizeof (*r));
4761 image <<= HOST_BITS_PER_LONG - 11;
4762 image &= ~SIG_MSB;
4764 if (exp == 0)
4766 if (image && fmt->has_denorm)
4768 r->cl = rvc_normal;
4769 r->sign = sign;
4770 SET_REAL_EXP (r, -14);
4771 r->sig[SIGSZ-1] = image << 1;
4772 normalize (r);
4774 else if (fmt->has_signed_zero)
4775 r->sign = sign;
4777 else if (exp == 31 && (fmt->has_nans || fmt->has_inf))
4779 if (image)
4781 r->cl = rvc_nan;
4782 r->sign = sign;
4783 r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
4784 ^ fmt->qnan_msb_set);
4785 r->sig[SIGSZ-1] = image;
4787 else
4789 r->cl = rvc_inf;
4790 r->sign = sign;
4793 else
4795 r->cl = rvc_normal;
4796 r->sign = sign;
4797 SET_REAL_EXP (r, exp - 15 + 1);
4798 r->sig[SIGSZ-1] = image | SIG_MSB;
4802 /* Half-precision format, as specified in IEEE 754R. */
4803 const struct real_format ieee_half_format =
4805 encode_ieee_half,
4806 decode_ieee_half,
4810 -13,
4815 false,
4816 true,
4817 true,
4818 true,
4819 true,
4820 true,
4821 true,
4822 false,
4823 "ieee_half"
4826 /* ARM's alternative half-precision format, similar to IEEE but with
4827 no reserved exponent value for NaNs and infinities; rather, it just
4828 extends the range of exponents by one. */
4829 const struct real_format arm_half_format =
4831 encode_ieee_half,
4832 decode_ieee_half,
4836 -13,
4841 false,
4842 true,
4843 false,
4844 false,
4845 true,
4846 true,
4847 false,
4848 false,
4849 "arm_half"
4852 /* A synthetic "format" for internal arithmetic. It's the size of the
4853 internal significand minus the two bits needed for proper rounding.
4854 The encode and decode routines exist only to satisfy our paranoia
4855 harness. */
4857 static void encode_internal (const struct real_format *fmt,
4858 long *, const REAL_VALUE_TYPE *);
4859 static void decode_internal (const struct real_format *,
4860 REAL_VALUE_TYPE *, const long *);
4862 static void
4863 encode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4864 const REAL_VALUE_TYPE *r)
4866 memcpy (buf, r, sizeof (*r));
4869 static void
4870 decode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED,
4871 REAL_VALUE_TYPE *r, const long *buf)
4873 memcpy (r, buf, sizeof (*r));
4876 const struct real_format real_internal_format =
4878 encode_internal,
4879 decode_internal,
4881 SIGNIFICAND_BITS - 2,
4882 SIGNIFICAND_BITS - 2,
4883 -MAX_EXP,
4884 MAX_EXP,
4888 false,
4889 false,
4890 true,
4891 true,
4892 false,
4893 true,
4894 true,
4895 false,
4896 "real_internal"
4899 /* Calculate X raised to the integer exponent N in format FMT and store
4900 the result in R. Return true if the result may be inexact due to
4901 loss of precision. The algorithm is the classic "left-to-right binary
4902 method" described in section 4.6.3 of Donald Knuth's "Seminumerical
4903 Algorithms", "The Art of Computer Programming", Volume 2. */
4905 bool
4906 real_powi (REAL_VALUE_TYPE *r, format_helper fmt,
4907 const REAL_VALUE_TYPE *x, HOST_WIDE_INT n)
4909 unsigned HOST_WIDE_INT bit;
4910 REAL_VALUE_TYPE t;
4911 bool inexact = false;
4912 bool init = false;
4913 bool neg;
4914 int i;
4916 if (n == 0)
4918 *r = dconst1;
4919 return false;
4921 else if (n < 0)
4923 /* Don't worry about overflow, from now on n is unsigned. */
4924 neg = true;
4925 n = -n;
4927 else
4928 neg = false;
4930 t = *x;
4931 bit = HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1);
4932 for (i = 0; i < HOST_BITS_PER_WIDE_INT; i++)
4934 if (init)
4936 inexact |= do_multiply (&t, &t, &t);
4937 if (n & bit)
4938 inexact |= do_multiply (&t, &t, x);
4940 else if (n & bit)
4941 init = true;
4942 bit >>= 1;
4945 if (neg)
4946 inexact |= do_divide (&t, &dconst1, &t);
4948 real_convert (r, fmt, &t);
4949 return inexact;
4952 /* Round X to the nearest integer not larger in absolute value, i.e.
4953 towards zero, placing the result in R in format FMT. */
4955 void
4956 real_trunc (REAL_VALUE_TYPE *r, format_helper fmt,
4957 const REAL_VALUE_TYPE *x)
4959 do_fix_trunc (r, x);
4960 if (fmt)
4961 real_convert (r, fmt, r);
4964 /* Round X to the largest integer not greater in value, i.e. round
4965 down, placing the result in R in format FMT. */
4967 void
4968 real_floor (REAL_VALUE_TYPE *r, format_helper fmt,
4969 const REAL_VALUE_TYPE *x)
4971 REAL_VALUE_TYPE t;
4973 do_fix_trunc (&t, x);
4974 if (! real_identical (&t, x) && x->sign)
4975 do_add (&t, &t, &dconstm1, 0);
4976 if (fmt)
4977 real_convert (r, fmt, &t);
4978 else
4979 *r = t;
4982 /* Round X to the smallest integer not less then argument, i.e. round
4983 up, placing the result in R in format FMT. */
4985 void
4986 real_ceil (REAL_VALUE_TYPE *r, format_helper fmt,
4987 const REAL_VALUE_TYPE *x)
4989 REAL_VALUE_TYPE t;
4991 do_fix_trunc (&t, x);
4992 if (! real_identical (&t, x) && ! x->sign)
4993 do_add (&t, &t, &dconst1, 0);
4994 if (fmt)
4995 real_convert (r, fmt, &t);
4996 else
4997 *r = t;
5000 /* Round X to the nearest integer, but round halfway cases away from
5001 zero. */
5003 void
5004 real_round (REAL_VALUE_TYPE *r, format_helper fmt,
5005 const REAL_VALUE_TYPE *x)
5007 do_add (r, x, &dconsthalf, x->sign);
5008 do_fix_trunc (r, r);
5009 if (fmt)
5010 real_convert (r, fmt, r);
5013 /* Set the sign of R to the sign of X. */
5015 void
5016 real_copysign (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *x)
5018 r->sign = x->sign;
5021 /* Check whether the real constant value given is an integer.
5022 Returns false for signaling NaN. */
5024 bool
5025 real_isinteger (const REAL_VALUE_TYPE *c, format_helper fmt)
5027 REAL_VALUE_TYPE cint;
5029 real_trunc (&cint, fmt, c);
5030 return real_identical (c, &cint);
5033 /* Check whether C is an integer that fits in a HOST_WIDE_INT,
5034 storing it in *INT_OUT if so. */
5036 bool
5037 real_isinteger (const REAL_VALUE_TYPE *c, HOST_WIDE_INT *int_out)
5039 REAL_VALUE_TYPE cint;
5041 HOST_WIDE_INT n = real_to_integer (c);
5042 real_from_integer (&cint, VOIDmode, n, SIGNED);
5043 if (real_identical (c, &cint))
5045 *int_out = n;
5046 return true;
5048 return false;
5051 /* Write into BUF the maximum representable finite floating-point
5052 number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
5053 float string. LEN is the size of BUF, and the buffer must be large
5054 enough to contain the resulting string. */
5056 void
5057 get_max_float (const struct real_format *fmt, char *buf, size_t len)
5059 int i, n;
5060 char *p;
5062 strcpy (buf, "0x0.");
5063 n = fmt->p;
5064 for (i = 0, p = buf + 4; i + 3 < n; i += 4)
5065 *p++ = 'f';
5066 if (i < n)
5067 *p++ = "08ce"[n - i];
5068 sprintf (p, "p%d", fmt->emax);
5069 if (fmt->pnan < fmt->p)
5071 /* This is an IBM extended double format made up of two IEEE
5072 doubles. The value of the long double is the sum of the
5073 values of the two parts. The most significant part is
5074 required to be the value of the long double rounded to the
5075 nearest double. Rounding means we need a slightly smaller
5076 value for LDBL_MAX. */
5077 buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
5080 gcc_assert (strlen (buf) < len);
5083 /* True if mode M has a NaN representation and
5084 the treatment of NaN operands is important. */
5086 bool
5087 HONOR_NANS (machine_mode m)
5089 return MODE_HAS_NANS (m) && !flag_finite_math_only;
5092 bool
5093 HONOR_NANS (const_tree t)
5095 return HONOR_NANS (element_mode (t));
5098 bool
5099 HONOR_NANS (const_rtx x)
5101 return HONOR_NANS (GET_MODE (x));
5104 /* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs). */
5106 bool
5107 HONOR_SNANS (machine_mode m)
5109 return flag_signaling_nans && HONOR_NANS (m);
5112 bool
5113 HONOR_SNANS (const_tree t)
5115 return HONOR_SNANS (element_mode (t));
5118 bool
5119 HONOR_SNANS (const_rtx x)
5121 return HONOR_SNANS (GET_MODE (x));
5124 /* As for HONOR_NANS, but true if the mode can represent infinity and
5125 the treatment of infinite values is important. */
5127 bool
5128 HONOR_INFINITIES (machine_mode m)
5130 return MODE_HAS_INFINITIES (m) && !flag_finite_math_only;
5133 bool
5134 HONOR_INFINITIES (const_tree t)
5136 return HONOR_INFINITIES (element_mode (t));
5139 bool
5140 HONOR_INFINITIES (const_rtx x)
5142 return HONOR_INFINITIES (GET_MODE (x));
5145 /* Like HONOR_NANS, but true if the given mode distinguishes between
5146 positive and negative zero, and the sign of zero is important. */
5148 bool
5149 HONOR_SIGNED_ZEROS (machine_mode m)
5151 return MODE_HAS_SIGNED_ZEROS (m) && flag_signed_zeros;
5154 bool
5155 HONOR_SIGNED_ZEROS (const_tree t)
5157 return HONOR_SIGNED_ZEROS (element_mode (t));
5160 bool
5161 HONOR_SIGNED_ZEROS (const_rtx x)
5163 return HONOR_SIGNED_ZEROS (GET_MODE (x));
5166 /* Like HONOR_NANS, but true if given mode supports sign-dependent rounding,
5167 and the rounding mode is important. */
5169 bool
5170 HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode m)
5172 return MODE_HAS_SIGN_DEPENDENT_ROUNDING (m) && flag_rounding_math;
5175 bool
5176 HONOR_SIGN_DEPENDENT_ROUNDING (const_tree t)
5178 return HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (t));
5181 bool
5182 HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx x)
5184 return HONOR_SIGN_DEPENDENT_ROUNDING (GET_MODE (x));