Index: ChangeLog
[gcc.git] / gcc / real.c
1 /* real.c - software floating point emulation.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2002 Free Software Foundation, Inc.
4 Contributed by Stephen L. Moshier (moshier@world.std.com).
5 Re-written by Richard Henderson <rth@redhat.com>
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 2, or (at your option) any later
12 version.
13
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to the Free
21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 02111-1307, USA. */
23
24 #include "config.h"
25 #include "system.h"
26 #include "tree.h"
27 #include "toplev.h"
28 #include "real.h"
29 #include "tm_p.h"
30
31 /* The floating point model used internally is not exactly IEEE 754
32 compliant, and close to the description in the ISO C standard,
33 section 5.2.4.2.2 Characteristics of floating types.
34
35 Specifically
36
37 x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
38
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.
45
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).
49
50 A requirement of the model is that P be larger than than the
51 largest supported target floating-point type by at least 2 bits.
52 This gives us proper rounding when we truncate to the target type.
53 In addition, E must be large enough to hold the smallest supported
54 denormal number in a normalized form.
55
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 29.
59
60 Note that the decimal string conversion routines are sensitive to
61 rounding error. Since the raw arithmetic routines do not themselves
62 have guard digits or rounding, the computation of 10**exp can
63 accumulate more than a few digits of error. The previous incarnation
64 of real.c successfully used a 144 bit fraction; given the current
65 layout of REAL_VALUE_TYPE we're forced to expand to at least 160 bits.
66
67 Target floating point models that use base 16 instead of base 2
68 (i.e. IBM 370), are handled during round_for_format, in which we
69 canonicalize the exponent to be a multiple of 4 (log2(16)), and
70 adjust the significand to match. */
71
72
73 /* Used to classify two numbers simultaneously. */
74 #define CLASS2(A, B) ((A) << 2 | (B))
75
76 #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
77 #error "Some constant folding done by hand to avoid shift count warnings"
78 #endif
79
80 static void get_zero PARAMS ((REAL_VALUE_TYPE *, int));
81 static void get_canonical_qnan PARAMS ((REAL_VALUE_TYPE *, int));
82 static void get_canonical_snan PARAMS ((REAL_VALUE_TYPE *, int));
83 static void get_inf PARAMS ((REAL_VALUE_TYPE *, int));
84 static bool sticky_rshift_significand PARAMS ((REAL_VALUE_TYPE *,
85 const REAL_VALUE_TYPE *,
86 unsigned int));
87 static void rshift_significand PARAMS ((REAL_VALUE_TYPE *,
88 const REAL_VALUE_TYPE *,
89 unsigned int));
90 static void lshift_significand PARAMS ((REAL_VALUE_TYPE *,
91 const REAL_VALUE_TYPE *,
92 unsigned int));
93 static void lshift_significand_1 PARAMS ((REAL_VALUE_TYPE *,
94 const REAL_VALUE_TYPE *));
95 static bool add_significands PARAMS ((REAL_VALUE_TYPE *r,
96 const REAL_VALUE_TYPE *,
97 const REAL_VALUE_TYPE *));
98 static bool sub_significands PARAMS ((REAL_VALUE_TYPE *,
99 const REAL_VALUE_TYPE *,
100 const REAL_VALUE_TYPE *, int));
101 static void neg_significand PARAMS ((REAL_VALUE_TYPE *,
102 const REAL_VALUE_TYPE *));
103 static int cmp_significands PARAMS ((const REAL_VALUE_TYPE *,
104 const REAL_VALUE_TYPE *));
105 static int cmp_significand_0 PARAMS ((const REAL_VALUE_TYPE *));
106 static void set_significand_bit PARAMS ((REAL_VALUE_TYPE *, unsigned int));
107 static void clear_significand_bit PARAMS ((REAL_VALUE_TYPE *, unsigned int));
108 static bool test_significand_bit PARAMS ((REAL_VALUE_TYPE *, unsigned int));
109 static void clear_significand_below PARAMS ((REAL_VALUE_TYPE *,
110 unsigned int));
111 static bool div_significands PARAMS ((REAL_VALUE_TYPE *,
112 const REAL_VALUE_TYPE *,
113 const REAL_VALUE_TYPE *));
114 static void normalize PARAMS ((REAL_VALUE_TYPE *));
115
116 static void do_add PARAMS ((REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
117 const REAL_VALUE_TYPE *, int));
118 static void do_multiply PARAMS ((REAL_VALUE_TYPE *,
119 const REAL_VALUE_TYPE *,
120 const REAL_VALUE_TYPE *));
121 static void do_divide PARAMS ((REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
122 const REAL_VALUE_TYPE *));
123 static int do_compare PARAMS ((const REAL_VALUE_TYPE *,
124 const REAL_VALUE_TYPE *, int));
125 static void do_fix_trunc PARAMS ((REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *));
126
127 static unsigned long rtd_divmod PARAMS ((REAL_VALUE_TYPE *,
128 REAL_VALUE_TYPE *));
129
130 static const REAL_VALUE_TYPE * ten_to_ptwo PARAMS ((int));
131 static const REAL_VALUE_TYPE * ten_to_mptwo PARAMS ((int));
132 static const REAL_VALUE_TYPE * real_digit PARAMS ((int));
133 static void times_pten PARAMS ((REAL_VALUE_TYPE *, int));
134
135 static void round_for_format PARAMS ((const struct real_format *,
136 REAL_VALUE_TYPE *));
137 \f
138 /* Initialize R with a positive zero. */
139
140 static inline void
141 get_zero (r, sign)
142 REAL_VALUE_TYPE *r;
143 int sign;
144 {
145 memset (r, 0, sizeof (*r));
146 r->sign = sign;
147 }
148
149 /* Initialize R with the canonical quiet NaN. */
150
151 static inline void
152 get_canonical_qnan (r, sign)
153 REAL_VALUE_TYPE *r;
154 int sign;
155 {
156 memset (r, 0, sizeof (*r));
157 r->class = rvc_nan;
158 r->sign = sign;
159 r->sig[SIGSZ-1] = SIG_MSB >> 1;
160 }
161
162 static inline void
163 get_canonical_snan (r, sign)
164 REAL_VALUE_TYPE *r;
165 int sign;
166 {
167 memset (r, 0, sizeof (*r));
168 r->class = rvc_nan;
169 r->sign = sign;
170 r->sig[SIGSZ-1] = SIG_MSB >> 2;
171 }
172
173 static inline void
174 get_inf (r, sign)
175 REAL_VALUE_TYPE *r;
176 int sign;
177 {
178 memset (r, 0, sizeof (*r));
179 r->class = rvc_inf;
180 r->sign = sign;
181 }
182
183 \f
184 /* Right-shift the significand of A by N bits; put the result in the
185 significand of R. If any one bits are shifted out, return true. */
186
187 static bool
188 sticky_rshift_significand (r, a, n)
189 REAL_VALUE_TYPE *r;
190 const REAL_VALUE_TYPE *a;
191 unsigned int n;
192 {
193 unsigned long sticky = 0;
194 unsigned int i, ofs = 0;
195
196 if (n >= HOST_BITS_PER_LONG)
197 {
198 for (i = 0, ofs = n / HOST_BITS_PER_LONG; i < ofs; ++i)
199 sticky |= a->sig[i];
200 n &= HOST_BITS_PER_LONG - 1;
201 }
202
203 if (n != 0)
204 {
205 sticky |= a->sig[ofs] & (((unsigned long)1 << n) - 1);
206 for (i = 0; i < SIGSZ; ++i)
207 {
208 r->sig[i]
209 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
210 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
211 << (HOST_BITS_PER_LONG - n)));
212 }
213 }
214 else
215 {
216 for (i = 0; ofs + i < SIGSZ; ++i)
217 r->sig[i] = a->sig[ofs + i];
218 for (; i < SIGSZ; ++i)
219 r->sig[i] = 0;
220 }
221
222 return sticky != 0;
223 }
224
225 /* Right-shift the significand of A by N bits; put the result in the
226 significand of R. */
227
228 static void
229 rshift_significand (r, a, n)
230 REAL_VALUE_TYPE *r;
231 const REAL_VALUE_TYPE *a;
232 unsigned int n;
233 {
234 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
235
236 n &= HOST_BITS_PER_LONG - 1;
237 if (n != 0)
238 {
239 for (i = 0; i < SIGSZ; ++i)
240 {
241 r->sig[i]
242 = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
243 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
244 << (HOST_BITS_PER_LONG - n)));
245 }
246 }
247 else
248 {
249 for (i = 0; ofs + i < SIGSZ; ++i)
250 r->sig[i] = a->sig[ofs + i];
251 for (; i < SIGSZ; ++i)
252 r->sig[i] = 0;
253 }
254 }
255
256 /* Left-shift the significand of A by N bits; put the result in the
257 significand of R. */
258
259 static void
260 lshift_significand (r, a, n)
261 REAL_VALUE_TYPE *r;
262 const REAL_VALUE_TYPE *a;
263 unsigned int n;
264 {
265 unsigned int i, ofs = n / HOST_BITS_PER_LONG;
266
267 n &= HOST_BITS_PER_LONG - 1;
268 if (n == 0)
269 {
270 for (i = 0; ofs + i < SIGSZ; ++i)
271 r->sig[SIGSZ-1-i] = a->sig[SIGSZ-1-i-ofs];
272 for (; i < SIGSZ; ++i)
273 r->sig[SIGSZ-1-i] = 0;
274 }
275 else
276 for (i = 0; i < SIGSZ; ++i)
277 {
278 r->sig[SIGSZ-1-i]
279 = (((ofs + i >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs]) << n)
280 | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs-1])
281 >> (HOST_BITS_PER_LONG - n)));
282 }
283 }
284
285 /* Likewise, but N is specialized to 1. */
286
287 static inline void
288 lshift_significand_1 (r, a)
289 REAL_VALUE_TYPE *r;
290 const REAL_VALUE_TYPE *a;
291 {
292 unsigned int i;
293
294 for (i = SIGSZ - 1; i > 0; --i)
295 r->sig[i] = (a->sig[i] << 1) | (a->sig[i-1] >> (HOST_BITS_PER_LONG - 1));
296 r->sig[0] = a->sig[0] << 1;
297 }
298
299 /* Add the significands of A and B, placing the result in R. Return
300 true if there was carry out of the most significant word. */
301
302 static inline bool
303 add_significands (r, a, b)
304 REAL_VALUE_TYPE *r;
305 const REAL_VALUE_TYPE *a, *b;
306 {
307 bool carry = false;
308 int i;
309
310 for (i = 0; i < SIGSZ; ++i)
311 {
312 unsigned long ai = a->sig[i];
313 unsigned long ri = ai + b->sig[i];
314
315 if (carry)
316 {
317 carry = ri < ai;
318 carry |= ++ri == 0;
319 }
320 else
321 carry = ri < ai;
322
323 r->sig[i] = ri;
324 }
325
326 return carry;
327 }
328
329 /* Subtract the significands of A and B, placing the result in R. CARRY is
330 true if there's a borrow incoming to the least significant word.
331 Return true if there was borrow out of the most significant word. */
332
333 static inline bool
334 sub_significands (r, a, b, carry)
335 REAL_VALUE_TYPE *r;
336 const REAL_VALUE_TYPE *a, *b;
337 int carry;
338 {
339 int i;
340
341 for (i = 0; i < SIGSZ; ++i)
342 {
343 unsigned long ai = a->sig[i];
344 unsigned long ri = ai - b->sig[i];
345
346 if (carry)
347 {
348 carry = ri > ai;
349 carry |= ~--ri == 0;
350 }
351 else
352 carry = ri > ai;
353
354 r->sig[i] = ri;
355 }
356
357 return carry;
358 }
359
360 /* Negate the significand A, placing the result in R. */
361
362 static inline void
363 neg_significand (r, a)
364 REAL_VALUE_TYPE *r;
365 const REAL_VALUE_TYPE *a;
366 {
367 bool carry = true;
368 int i;
369
370 for (i = 0; i < SIGSZ; ++i)
371 {
372 unsigned long ri, ai = a->sig[i];
373
374 if (carry)
375 {
376 if (ai)
377 {
378 ri = -ai;
379 carry = false;
380 }
381 else
382 ri = ai;
383 }
384 else
385 ri = ~ai;
386
387 r->sig[i] = ri;
388 }
389 }
390
391 /* Compare significands. Return tri-state vs zero. */
392
393 static inline int
394 cmp_significands (a, b)
395 const REAL_VALUE_TYPE *a, *b;
396 {
397 int i;
398
399 for (i = SIGSZ - 1; i >= 0; --i)
400 {
401 unsigned long ai = a->sig[i];
402 unsigned long bi = b->sig[i];
403
404 if (ai > bi)
405 return 1;
406 if (ai < bi)
407 return -1;
408 }
409
410 return 0;
411 }
412
413 /* Return true if A is non-zero. */
414
415 static inline int
416 cmp_significand_0 (a)
417 const REAL_VALUE_TYPE *a;
418 {
419 int i;
420
421 for (i = SIGSZ - 1; i >= 0; --i)
422 if (a->sig[i])
423 return 1;
424
425 return 0;
426 }
427
428 /* Set bit N of the significand of R. */
429
430 static inline void
431 set_significand_bit (r, n)
432 REAL_VALUE_TYPE *r;
433 unsigned int n;
434 {
435 r->sig[n / HOST_BITS_PER_LONG]
436 |= (unsigned long)1 << (n % HOST_BITS_PER_LONG);
437 }
438
439 /* Clear bit N of the significand of R. */
440
441 static inline void
442 clear_significand_bit (r, n)
443 REAL_VALUE_TYPE *r;
444 unsigned int n;
445 {
446 r->sig[n / HOST_BITS_PER_LONG]
447 &= ~((unsigned long)1 << (n % HOST_BITS_PER_LONG));
448 }
449
450 /* Test bit N of the significand of R. */
451
452 static inline bool
453 test_significand_bit (r, n)
454 REAL_VALUE_TYPE *r;
455 unsigned int n;
456 {
457 /* ??? Compiler bug here if we return this expression directly.
458 The conversion to bool strips the "&1" and we wind up testing
459 e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
460 int t = (r->sig[n / HOST_BITS_PER_LONG] >> (n % HOST_BITS_PER_LONG)) & 1;
461 return t;
462 }
463
464 /* Clear bits 0..N-1 of the significand of R. */
465
466 static void
467 clear_significand_below (r, n)
468 REAL_VALUE_TYPE *r;
469 unsigned int n;
470 {
471 int i, w = n / HOST_BITS_PER_LONG;
472
473 for (i = 0; i < w; ++i)
474 r->sig[i] = 0;
475
476 r->sig[w] &= ~(((unsigned long)1 << (n % HOST_BITS_PER_LONG)) - 1);
477 }
478
479 /* Divide the significands of A and B, placing the result in R. Return
480 true if the division was inexact. */
481
482 static inline bool
483 div_significands (r, a, b)
484 REAL_VALUE_TYPE *r;
485 const REAL_VALUE_TYPE *a, *b;
486 {
487 REAL_VALUE_TYPE u;
488 int i, bit = SIGNIFICAND_BITS - 1;
489 unsigned long msb, inexact;
490
491 u = *a;
492 memset (r->sig, 0, sizeof (r->sig));
493
494 msb = 0;
495 goto start;
496 do
497 {
498 msb = u.sig[SIGSZ-1] & SIG_MSB;
499 lshift_significand_1 (&u, &u);
500 start:
501 if (msb || cmp_significands (&u, b) >= 0)
502 {
503 sub_significands (&u, &u, b, 0);
504 set_significand_bit (r, bit);
505 }
506 }
507 while (--bit >= 0);
508
509 for (i = 0, inexact = 0; i < SIGSZ; i++)
510 inexact |= u.sig[i];
511
512 return inexact != 0;
513 }
514
515 /* Adjust the exponent and significand of R such that the most
516 significant bit is set. We underflow to zero and overflow to
517 infinity here, without denormals. (The intermediate representation
518 exponent is large enough to handle target denormals normalized.) */
519
520 static void
521 normalize (r)
522 REAL_VALUE_TYPE *r;
523 {
524 int shift = 0, exp;
525 int i, j;
526
527 /* Find the first word that is nonzero. */
528 for (i = SIGSZ - 1; i >= 0; i--)
529 if (r->sig[i] == 0)
530 shift += HOST_BITS_PER_LONG;
531 else
532 break;
533
534 /* Zero significand flushes to zero. */
535 if (i < 0)
536 {
537 r->class = rvc_zero;
538 r->exp = 0;
539 return;
540 }
541
542 /* Find the first bit that is nonzero. */
543 for (j = 0; ; j++)
544 if (r->sig[i] & ((unsigned long)1 << (HOST_BITS_PER_LONG - 1 - j)))
545 break;
546 shift += j;
547
548 if (shift > 0)
549 {
550 exp = r->exp - shift;
551 if (exp > MAX_EXP)
552 get_inf (r, r->sign);
553 else if (exp < -MAX_EXP)
554 get_zero (r, r->sign);
555 else
556 {
557 r->exp = exp;
558 lshift_significand (r, r, shift);
559 }
560 }
561 }
562 \f
563 /* Return R = A + (SUBTRACT_P ? -B : B). */
564
565 static void
566 do_add (r, a, b, subtract_p)
567 REAL_VALUE_TYPE *r;
568 const REAL_VALUE_TYPE *a, *b;
569 int subtract_p;
570 {
571 int dexp, sign, exp;
572 REAL_VALUE_TYPE t;
573 bool inexact = false;
574
575 /* Determine if we need to add or subtract. */
576 sign = a->sign;
577 subtract_p = (sign ^ b->sign) ^ subtract_p;
578
579 switch (CLASS2 (a->class, b->class))
580 {
581 case CLASS2 (rvc_zero, rvc_zero):
582 /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
583 get_zero (r, sign & !subtract_p);
584 return;
585
586 case CLASS2 (rvc_zero, rvc_normal):
587 case CLASS2 (rvc_zero, rvc_inf):
588 case CLASS2 (rvc_zero, rvc_nan):
589 /* 0 + ANY = ANY. */
590 case CLASS2 (rvc_normal, rvc_nan):
591 case CLASS2 (rvc_inf, rvc_nan):
592 case CLASS2 (rvc_nan, rvc_nan):
593 /* ANY + NaN = NaN. */
594 case CLASS2 (rvc_normal, rvc_inf):
595 /* R + Inf = Inf. */
596 *r = *b;
597 r->sign = sign ^ subtract_p;
598 return;
599
600 case CLASS2 (rvc_normal, rvc_zero):
601 case CLASS2 (rvc_inf, rvc_zero):
602 case CLASS2 (rvc_nan, rvc_zero):
603 /* ANY + 0 = ANY. */
604 case CLASS2 (rvc_nan, rvc_normal):
605 case CLASS2 (rvc_nan, rvc_inf):
606 /* NaN + ANY = NaN. */
607 case CLASS2 (rvc_inf, rvc_normal):
608 /* Inf + R = Inf. */
609 *r = *a;
610 return;
611
612 case CLASS2 (rvc_inf, rvc_inf):
613 if (subtract_p)
614 /* Inf - Inf = NaN. */
615 get_canonical_qnan (r, 0);
616 else
617 /* Inf + Inf = Inf. */
618 *r = *a;
619 return;
620
621 case CLASS2 (rvc_normal, rvc_normal):
622 break;
623
624 default:
625 abort ();
626 }
627
628 /* Swap the arguments such that A has the larger exponent. */
629 dexp = a->exp - b->exp;
630 if (dexp < 0)
631 {
632 const REAL_VALUE_TYPE *t;
633 t = a, a = b, b = t;
634 dexp = -dexp;
635 sign ^= subtract_p;
636 }
637 exp = a->exp;
638
639 /* If the exponents are not identical, we need to shift the
640 significand of B down. */
641 if (dexp > 0)
642 {
643 /* If the exponents are too far apart, the significands
644 do not overlap, which makes the subtraction a noop. */
645 if (dexp >= SIGNIFICAND_BITS)
646 {
647 *r = *a;
648 r->sign = sign;
649 return;
650 }
651
652 inexact |= sticky_rshift_significand (&t, b, dexp);
653 b = &t;
654 }
655
656 if (subtract_p)
657 {
658 if (sub_significands (r, a, b, inexact))
659 {
660 /* We got a borrow out of the subtraction. That means that
661 A and B had the same exponent, and B had the larger
662 significand. We need to swap the sign and negate the
663 significand. */
664 sign ^= 1;
665 neg_significand (r, r);
666 }
667 }
668 else
669 {
670 if (add_significands (r, a, b))
671 {
672 /* We got carry out of the addition. This means we need to
673 shift the significand back down one bit and increase the
674 exponent. */
675 inexact |= sticky_rshift_significand (r, r, 1);
676 r->sig[SIGSZ-1] |= SIG_MSB;
677 if (++exp > MAX_EXP)
678 {
679 get_inf (r, sign);
680 return;
681 }
682 }
683 }
684
685 r->class = rvc_normal;
686 r->sign = sign;
687 r->exp = exp;
688
689 /* Re-normalize the result. */
690 normalize (r);
691
692 /* Special case: if the subtraction results in zero, the result
693 is positive. */
694 if (r->class == rvc_zero)
695 r->sign = 0;
696 else
697 r->sig[0] |= inexact;
698 }
699
700 /* Return R = A * B. */
701
702 static void
703 do_multiply (r, a, b)
704 REAL_VALUE_TYPE *r;
705 const REAL_VALUE_TYPE *a, *b;
706 {
707 REAL_VALUE_TYPE u, t, *rr;
708 unsigned int i, j, k;
709 int sign = a->sign ^ b->sign;
710
711 switch (CLASS2 (a->class, b->class))
712 {
713 case CLASS2 (rvc_zero, rvc_zero):
714 case CLASS2 (rvc_zero, rvc_normal):
715 case CLASS2 (rvc_normal, rvc_zero):
716 /* +-0 * ANY = 0 with appropriate sign. */
717 get_zero (r, sign);
718 return;
719
720 case CLASS2 (rvc_zero, rvc_nan):
721 case CLASS2 (rvc_normal, rvc_nan):
722 case CLASS2 (rvc_inf, rvc_nan):
723 case CLASS2 (rvc_nan, rvc_nan):
724 /* ANY * NaN = NaN. */
725 *r = *b;
726 r->sign = sign;
727 return;
728
729 case CLASS2 (rvc_nan, rvc_zero):
730 case CLASS2 (rvc_nan, rvc_normal):
731 case CLASS2 (rvc_nan, rvc_inf):
732 /* NaN * ANY = NaN. */
733 *r = *a;
734 r->sign = sign;
735 return;
736
737 case CLASS2 (rvc_zero, rvc_inf):
738 case CLASS2 (rvc_inf, rvc_zero):
739 /* 0 * Inf = NaN */
740 get_canonical_qnan (r, sign);
741 return;
742
743 case CLASS2 (rvc_inf, rvc_inf):
744 case CLASS2 (rvc_normal, rvc_inf):
745 case CLASS2 (rvc_inf, rvc_normal):
746 /* Inf * Inf = Inf, R * Inf = Inf */
747 overflow:
748 get_inf (r, sign);
749 return;
750
751 case CLASS2 (rvc_normal, rvc_normal):
752 break;
753
754 default:
755 abort ();
756 }
757
758 if (r == a || r == b)
759 rr = &t;
760 else
761 rr = r;
762 get_zero (rr, 0);
763
764 /* Collect all the partial products. Since we don't have sure access
765 to a widening multiply, we split each long into two half-words.
766
767 Consider the long-hand form of a four half-word multiplication:
768
769 A B C D
770 * E F G H
771 --------------
772 DE DF DG DH
773 CE CF CG CH
774 BE BF BG BH
775 AE AF AG AH
776
777 We construct partial products of the widened half-word products
778 that are known to not overlap, e.g. DF+DH. Each such partial
779 product is given its proper exponent, which allows us to sum them
780 and obtain the finished product. */
781
782 for (i = 0; i < SIGSZ * 2; ++i)
783 {
784 unsigned long ai = a->sig[i / 2];
785 if (i & 1)
786 ai >>= HOST_BITS_PER_LONG / 2;
787 else
788 ai &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
789
790 if (ai == 0)
791 continue;
792
793 for (j = 0; j < 2; ++j)
794 {
795 int exp = (a->exp - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2)
796 + (b->exp - (1-j)*(HOST_BITS_PER_LONG/2)));
797
798 if (exp > MAX_EXP)
799 goto overflow;
800 if (exp < -MAX_EXP)
801 /* Would underflow to zero, which we shouldn't bother adding. */
802 continue;
803
804 u.class = rvc_normal;
805 u.sign = 0;
806 u.exp = exp;
807
808 for (k = j; k < SIGSZ * 2; k += 2)
809 {
810 unsigned long bi = b->sig[k / 2];
811 if (k & 1)
812 bi >>= HOST_BITS_PER_LONG / 2;
813 else
814 bi &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
815
816 u.sig[k / 2] = ai * bi;
817 }
818
819 normalize (&u);
820 do_add (rr, rr, &u, 0);
821 }
822 }
823
824 rr->sign = sign;
825 if (rr != r)
826 *r = t;
827 }
828
829 /* Return R = A / B. */
830
831 static void
832 do_divide (r, a, b)
833 REAL_VALUE_TYPE *r;
834 const REAL_VALUE_TYPE *a, *b;
835 {
836 int exp, sign = a->sign ^ b->sign;
837 REAL_VALUE_TYPE t, *rr;
838 bool inexact;
839
840 switch (CLASS2 (a->class, b->class))
841 {
842 case CLASS2 (rvc_zero, rvc_zero):
843 /* 0 / 0 = NaN. */
844 case CLASS2 (rvc_inf, rvc_inf):
845 /* Inf / Inf = NaN. */
846 get_canonical_qnan (r, sign);
847 return;
848
849 case CLASS2 (rvc_zero, rvc_normal):
850 case CLASS2 (rvc_zero, rvc_inf):
851 /* 0 / ANY = 0. */
852 case CLASS2 (rvc_normal, rvc_inf):
853 /* R / Inf = 0. */
854 underflow:
855 get_zero (r, sign);
856 return;
857
858 case CLASS2 (rvc_normal, rvc_zero):
859 /* R / 0 = Inf. */
860 case CLASS2 (rvc_inf, rvc_zero):
861 /* Inf / 0 = Inf. */
862 get_inf (r, sign);
863 return;
864
865 case CLASS2 (rvc_zero, rvc_nan):
866 case CLASS2 (rvc_normal, rvc_nan):
867 case CLASS2 (rvc_inf, rvc_nan):
868 case CLASS2 (rvc_nan, rvc_nan):
869 /* ANY / NaN = NaN. */
870 *r = *b;
871 r->sign = sign;
872 return;
873
874 case CLASS2 (rvc_nan, rvc_zero):
875 case CLASS2 (rvc_nan, rvc_normal):
876 case CLASS2 (rvc_nan, rvc_inf):
877 /* NaN / ANY = NaN. */
878 *r = *a;
879 r->sign = sign;
880 return;
881
882 case CLASS2 (rvc_inf, rvc_normal):
883 /* Inf / R = Inf. */
884 overflow:
885 get_inf (r, sign);
886 return;
887
888 case CLASS2 (rvc_normal, rvc_normal):
889 break;
890
891 default:
892 abort ();
893 }
894
895 if (r == a || r == b)
896 rr = &t;
897 else
898 rr = r;
899
900 rr->class = rvc_normal;
901 rr->sign = sign;
902
903 exp = a->exp - b->exp + 1;
904 if (exp > MAX_EXP)
905 goto overflow;
906 if (exp < -MAX_EXP)
907 goto underflow;
908 rr->exp = exp;
909
910 inexact = div_significands (rr, a, b);
911
912 /* Re-normalize the result. */
913 normalize (rr);
914 rr->sig[0] |= inexact;
915
916 if (rr != r)
917 *r = t;
918 }
919
920 /* Return a tri-state comparison of A vs B. Return NAN_RESULT if
921 one of the two operands is a NaN. */
922
923 static int
924 do_compare (a, b, nan_result)
925 const REAL_VALUE_TYPE *a, *b;
926 int nan_result;
927 {
928 int ret;
929
930 switch (CLASS2 (a->class, b->class))
931 {
932 case CLASS2 (rvc_zero, rvc_zero):
933 /* Sign of zero doesn't matter for compares. */
934 return 0;
935
936 case CLASS2 (rvc_inf, rvc_zero):
937 case CLASS2 (rvc_inf, rvc_normal):
938 case CLASS2 (rvc_normal, rvc_zero):
939 return (a->sign ? -1 : 1);
940
941 case CLASS2 (rvc_inf, rvc_inf):
942 return -a->sign - -b->sign;
943
944 case CLASS2 (rvc_zero, rvc_normal):
945 case CLASS2 (rvc_zero, rvc_inf):
946 case CLASS2 (rvc_normal, rvc_inf):
947 return (b->sign ? 1 : -1);
948
949 case CLASS2 (rvc_zero, rvc_nan):
950 case CLASS2 (rvc_normal, rvc_nan):
951 case CLASS2 (rvc_inf, rvc_nan):
952 case CLASS2 (rvc_nan, rvc_nan):
953 case CLASS2 (rvc_nan, rvc_zero):
954 case CLASS2 (rvc_nan, rvc_normal):
955 case CLASS2 (rvc_nan, rvc_inf):
956 return nan_result;
957
958 case CLASS2 (rvc_normal, rvc_normal):
959 break;
960
961 default:
962 abort ();
963 }
964
965 if (a->sign != b->sign)
966 return -a->sign - -b->sign;
967
968 if (a->exp > b->exp)
969 ret = 1;
970 else if (a->exp < b->exp)
971 ret = -1;
972 else
973 ret = cmp_significands (a, b);
974
975 return (a->sign ? -ret : ret);
976 }
977
978 /* Return A truncated to an integral value toward zero. */
979
980 static void
981 do_fix_trunc (r, a)
982 REAL_VALUE_TYPE *r;
983 const REAL_VALUE_TYPE *a;
984 {
985 *r = *a;
986
987 switch (r->class)
988 {
989 case rvc_zero:
990 case rvc_inf:
991 case rvc_nan:
992 break;
993
994 case rvc_normal:
995 if (r->exp <= 0)
996 get_zero (r, r->sign);
997 else if (r->exp < SIGNIFICAND_BITS)
998 clear_significand_below (r, SIGNIFICAND_BITS - r->exp);
999 break;
1000
1001 default:
1002 abort ();
1003 }
1004 }
1005
1006 /* Perform the binary or unary operation described by CODE.
1007 For a unary operation, leave OP1 NULL. */
1008
1009 void
1010 real_arithmetic (r, icode, op0, op1)
1011 REAL_VALUE_TYPE *r;
1012 int icode;
1013 const REAL_VALUE_TYPE *op0, *op1;
1014 {
1015 enum tree_code code = icode;
1016
1017 switch (code)
1018 {
1019 case PLUS_EXPR:
1020 do_add (r, op0, op1, 0);
1021 break;
1022
1023 case MINUS_EXPR:
1024 do_add (r, op0, op1, 1);
1025 break;
1026
1027 case MULT_EXPR:
1028 do_multiply (r, op0, op1);
1029 break;
1030
1031 case RDIV_EXPR:
1032 do_divide (r, op0, op1);
1033 break;
1034
1035 case MIN_EXPR:
1036 if (op1->class == rvc_nan)
1037 *r = *op1;
1038 else if (do_compare (op0, op1, -1) < 0)
1039 *r = *op0;
1040 else
1041 *r = *op1;
1042 break;
1043
1044 case MAX_EXPR:
1045 if (op1->class == rvc_nan)
1046 *r = *op1;
1047 else if (do_compare (op0, op1, 1) < 0)
1048 *r = *op1;
1049 else
1050 *r = *op0;
1051 break;
1052
1053 case NEGATE_EXPR:
1054 *r = *op0;
1055 r->sign ^= 1;
1056 break;
1057
1058 case ABS_EXPR:
1059 *r = *op0;
1060 r->sign = 0;
1061 break;
1062
1063 case FIX_TRUNC_EXPR:
1064 do_fix_trunc (r, op0);
1065 break;
1066
1067 default:
1068 abort ();
1069 }
1070 }
1071
1072 /* Legacy. Similar, but return the result directly. */
1073
1074 REAL_VALUE_TYPE
1075 real_arithmetic2 (icode, op0, op1)
1076 int icode;
1077 const REAL_VALUE_TYPE *op0, *op1;
1078 {
1079 REAL_VALUE_TYPE r;
1080 real_arithmetic (&r, icode, op0, op1);
1081 return r;
1082 }
1083
1084 bool
1085 real_compare (icode, op0, op1)
1086 int icode;
1087 const REAL_VALUE_TYPE *op0, *op1;
1088 {
1089 enum tree_code code = icode;
1090
1091 switch (code)
1092 {
1093 case LT_EXPR:
1094 return do_compare (op0, op1, 1) < 0;
1095 case LE_EXPR:
1096 return do_compare (op0, op1, 1) <= 0;
1097 case GT_EXPR:
1098 return do_compare (op0, op1, -1) > 0;
1099 case GE_EXPR:
1100 return do_compare (op0, op1, -1) >= 0;
1101 case EQ_EXPR:
1102 return do_compare (op0, op1, -1) == 0;
1103 case NE_EXPR:
1104 return do_compare (op0, op1, -1) != 0;
1105 case UNORDERED_EXPR:
1106 return op0->class == rvc_nan || op1->class == rvc_nan;
1107 case ORDERED_EXPR:
1108 return op0->class != rvc_nan && op1->class != rvc_nan;
1109 case UNLT_EXPR:
1110 return do_compare (op0, op1, -1) < 0;
1111 case UNLE_EXPR:
1112 return do_compare (op0, op1, -1) <= 0;
1113 case UNGT_EXPR:
1114 return do_compare (op0, op1, 1) > 0;
1115 case UNGE_EXPR:
1116 return do_compare (op0, op1, 1) >= 0;
1117 case UNEQ_EXPR:
1118 return do_compare (op0, op1, 0) == 0;
1119
1120 default:
1121 abort ();
1122 }
1123 }
1124
1125 /* Return floor log2(R). */
1126
1127 int
1128 real_exponent (r)
1129 const REAL_VALUE_TYPE *r;
1130 {
1131 switch (r->class)
1132 {
1133 case rvc_zero:
1134 return 0;
1135 case rvc_inf:
1136 case rvc_nan:
1137 return (unsigned int)-1 >> 1;
1138 case rvc_normal:
1139 return r->exp;
1140 default:
1141 abort ();
1142 }
1143 }
1144
1145 /* R = OP0 * 2**EXP. */
1146
1147 void
1148 real_ldexp (r, op0, exp)
1149 REAL_VALUE_TYPE *r;
1150 const REAL_VALUE_TYPE *op0;
1151 int exp;
1152 {
1153 *r = *op0;
1154 switch (r->class)
1155 {
1156 case rvc_zero:
1157 case rvc_inf:
1158 case rvc_nan:
1159 break;
1160
1161 case rvc_normal:
1162 exp += op0->exp;
1163 if (exp > MAX_EXP)
1164 get_inf (r, r->sign);
1165 else if (exp < -MAX_EXP)
1166 get_zero (r, r->sign);
1167 else
1168 r->exp = exp;
1169 break;
1170
1171 default:
1172 abort ();
1173 }
1174 }
1175
1176 /* Determine whether a floating-point value X is infinite. */
1177
1178 bool
1179 real_isinf (r)
1180 const REAL_VALUE_TYPE *r;
1181 {
1182 return (r->class == rvc_inf);
1183 }
1184
1185 /* Determine whether a floating-point value X is a NaN. */
1186
1187 bool
1188 real_isnan (r)
1189 const REAL_VALUE_TYPE *r;
1190 {
1191 return (r->class == rvc_nan);
1192 }
1193
1194 /* Determine whether a floating-point value X is negative. */
1195
1196 bool
1197 real_isneg (r)
1198 const REAL_VALUE_TYPE *r;
1199 {
1200 return r->sign;
1201 }
1202
1203 /* Determine whether a floating-point value X is minus zero. */
1204
1205 bool
1206 real_isnegzero (r)
1207 const REAL_VALUE_TYPE *r;
1208 {
1209 return r->sign && r->class == rvc_zero;
1210 }
1211
1212 /* Compare two floating-point objects for bitwise identity. */
1213
1214 extern bool
1215 real_identical (a, b)
1216 const REAL_VALUE_TYPE *a, *b;
1217 {
1218 int i;
1219
1220 if (a->class != b->class)
1221 return false;
1222 if (a->sign != b->sign)
1223 return false;
1224
1225 switch (a->class)
1226 {
1227 case rvc_zero:
1228 case rvc_inf:
1229 break;
1230
1231 case rvc_normal:
1232 if (a->exp != b->exp)
1233 return false;
1234 /* FALLTHRU */
1235 case rvc_nan:
1236 for (i = 0; i < SIGSZ; ++i)
1237 if (a->sig[i] != b->sig[i])
1238 return false;
1239 break;
1240
1241 default:
1242 abort ();
1243 }
1244
1245 return true;
1246 }
1247
1248 /* Try to change R into its exact multiplicative inverse in machine
1249 mode MODE. Return true if successful. */
1250
1251 bool
1252 exact_real_inverse (mode, r)
1253 enum machine_mode mode;
1254 REAL_VALUE_TYPE *r;
1255 {
1256 const REAL_VALUE_TYPE *one = real_digit (1);
1257 REAL_VALUE_TYPE u;
1258 int i;
1259
1260 if (r->class != rvc_normal)
1261 return false;
1262
1263 /* Check for a power of two: all significand bits zero except the MSB. */
1264 for (i = 0; i < SIGSZ-1; ++i)
1265 if (r->sig[i] != 0)
1266 return false;
1267 if (r->sig[SIGSZ-1] != SIG_MSB)
1268 return false;
1269
1270 /* Find the inverse and truncate to the required mode. */
1271 do_divide (&u, one, r);
1272 real_convert (&u, mode, &u);
1273
1274 /* The rounding may have overflowed. */
1275 if (u.class != rvc_normal)
1276 return false;
1277 for (i = 0; i < SIGSZ-1; ++i)
1278 if (u.sig[i] != 0)
1279 return false;
1280 if (u.sig[SIGSZ-1] != SIG_MSB)
1281 return false;
1282
1283 *r = u;
1284 return true;
1285 }
1286 \f
1287 /* Render R as an integer. */
1288
1289 HOST_WIDE_INT
1290 real_to_integer (r)
1291 const REAL_VALUE_TYPE *r;
1292 {
1293 unsigned HOST_WIDE_INT i;
1294
1295 switch (r->class)
1296 {
1297 case rvc_zero:
1298 underflow:
1299 return 0;
1300
1301 case rvc_inf:
1302 case rvc_nan:
1303 overflow:
1304 i = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1305 if (!r->sign)
1306 i--;
1307 return i;
1308
1309 case rvc_normal:
1310 if (r->exp <= 0)
1311 goto underflow;
1312 if (r->exp > HOST_BITS_PER_WIDE_INT)
1313 goto overflow;
1314
1315 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1316 i = r->sig[SIGSZ-1];
1317 else if (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG)
1318 {
1319 i = r->sig[SIGSZ-1];
1320 i = i << (HOST_BITS_PER_LONG - 1) << 1;
1321 i |= r->sig[SIGSZ-2];
1322 }
1323 else
1324 abort ();
1325
1326 i >>= HOST_BITS_PER_WIDE_INT - r->exp;
1327
1328 if (r->sign)
1329 i = -i;
1330 return i;
1331
1332 default:
1333 abort ();
1334 }
1335 }
1336
1337 /* Likewise, but to an integer pair, HI+LOW. */
1338
1339 void
1340 real_to_integer2 (plow, phigh, r)
1341 HOST_WIDE_INT *plow, *phigh;
1342 const REAL_VALUE_TYPE *r;
1343 {
1344 REAL_VALUE_TYPE t;
1345 HOST_WIDE_INT low, high;
1346 int exp;
1347
1348 switch (r->class)
1349 {
1350 case rvc_zero:
1351 underflow:
1352 low = high = 0;
1353 break;
1354
1355 case rvc_inf:
1356 case rvc_nan:
1357 overflow:
1358 high = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
1359 if (r->sign)
1360 low = 0;
1361 else
1362 {
1363 high--;
1364 low = -1;
1365 }
1366 break;
1367
1368 case rvc_normal:
1369 exp = r->exp;
1370 if (exp <= 0)
1371 goto underflow;
1372 if (exp >= 2*HOST_BITS_PER_WIDE_INT)
1373 goto overflow;
1374
1375 rshift_significand (&t, r, 2*HOST_BITS_PER_WIDE_INT - exp);
1376 if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1377 {
1378 high = t.sig[SIGSZ-1];
1379 low = t.sig[SIGSZ-2];
1380 }
1381 else if (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG)
1382 {
1383 high = t.sig[SIGSZ-1];
1384 high = high << (HOST_BITS_PER_LONG - 1) << 1;
1385 high |= t.sig[SIGSZ-2];
1386
1387 low = t.sig[SIGSZ-3];
1388 low = low << (HOST_BITS_PER_LONG - 1) << 1;
1389 low |= t.sig[SIGSZ-4];
1390 }
1391 else
1392 abort ();
1393
1394 if (r->sign)
1395 {
1396 if (low == 0)
1397 high = -high;
1398 else
1399 low = -low, high = ~high;
1400 }
1401 break;
1402
1403 default:
1404 abort ();
1405 }
1406
1407 *plow = low;
1408 *phigh = high;
1409 }
1410
1411 /* A subroutine of real_to_decimal. Compute the quotient and remainder
1412 of NUM / DEN. Return the quotient and place the remainder in NUM.
1413 It is expected that NUM / DEN are close enough that the quotient is
1414 small. */
1415
1416 static unsigned long
1417 rtd_divmod (num, den)
1418 REAL_VALUE_TYPE *num, *den;
1419 {
1420 unsigned long q, msb;
1421 int expn = num->exp, expd = den->exp;
1422
1423 if (expn < expd)
1424 return 0;
1425
1426 q = msb = 0;
1427 goto start;
1428 do
1429 {
1430 msb = num->sig[SIGSZ-1] & SIG_MSB;
1431 q <<= 1;
1432 lshift_significand_1 (num, num);
1433 start:
1434 if (msb || cmp_significands (num, den) >= 0)
1435 {
1436 sub_significands (num, num, den, 0);
1437 q |= 1;
1438 }
1439 }
1440 while (--expn >= expd);
1441
1442 num->exp = expd;
1443 normalize (num);
1444
1445 return q;
1446 }
1447
1448 /* Render R as a decimal floating point constant. Emit DIGITS significant
1449 digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1450 maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1451 zeros. */
1452
1453 #define M_LOG10_2 0.30102999566398119521
1454
1455 void
1456 real_to_decimal (str, r_orig, buf_size, digits, crop_trailing_zeros)
1457 char *str;
1458 const REAL_VALUE_TYPE *r_orig;
1459 size_t buf_size, digits;
1460 int crop_trailing_zeros;
1461 {
1462 const REAL_VALUE_TYPE *one, *ten;
1463 REAL_VALUE_TYPE r, pten, u, v;
1464 int dec_exp, cmp_one, digit;
1465 size_t max_digits;
1466 char *p, *first, *last;
1467 bool sign;
1468
1469 r = *r_orig;
1470 switch (r.class)
1471 {
1472 case rvc_zero:
1473 strcpy (str, (r.sign ? "-0.0" : "0.0"));
1474 return;
1475 case rvc_normal:
1476 break;
1477 case rvc_inf:
1478 strcpy (str, (r.sign ? "-Inf" : "+Inf"));
1479 return;
1480 case rvc_nan:
1481 /* ??? Print the significand as well, if not canonical? */
1482 strcpy (str, (r.sign ? "-NaN" : "+NaN"));
1483 return;
1484 default:
1485 abort ();
1486 }
1487
1488 /* Estimate the decimal exponent, and compute the length of the string it
1489 will print as. Be conservative and add one to account for possible
1490 overflow or rounding error. */
1491 dec_exp = r.exp * M_LOG10_2;
1492 for (max_digits = 1; dec_exp ; max_digits++)
1493 dec_exp /= 10;
1494
1495 /* Bound the number of digits printed by the size of the output buffer. */
1496 max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
1497 if (max_digits > buf_size)
1498 abort ();
1499 if (digits > max_digits)
1500 digits = max_digits;
1501
1502 /* Bound the number of digits printed by the size of the representation. */
1503 max_digits = SIGNIFICAND_BITS * M_LOG10_2;
1504 if (digits == 0 || digits > max_digits)
1505 digits = max_digits;
1506
1507 one = real_digit (1);
1508 ten = ten_to_ptwo (0);
1509
1510 sign = r.sign;
1511 r.sign = 0;
1512
1513 dec_exp = 0;
1514 pten = *one;
1515
1516 cmp_one = do_compare (&r, one, 0);
1517 if (cmp_one > 0)
1518 {
1519 int m;
1520
1521 /* Number is greater than one. Convert significand to an integer
1522 and strip trailing decimal zeros. */
1523
1524 u = r;
1525 u.exp = SIGNIFICAND_BITS - 1;
1526
1527 /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1528 m = floor_log2 (max_digits);
1529
1530 /* Iterate over the bits of the possible powers of 10 that might
1531 be present in U and eliminate them. That is, if we find that
1532 10**2**M divides U evenly, keep the division and increase
1533 DEC_EXP by 2**M. */
1534 do
1535 {
1536 REAL_VALUE_TYPE t;
1537
1538 do_divide (&t, &u, ten_to_ptwo (m));
1539 do_fix_trunc (&v, &t);
1540 if (cmp_significands (&v, &t) == 0)
1541 {
1542 u = t;
1543 dec_exp += 1 << m;
1544 }
1545 }
1546 while (--m >= 0);
1547
1548 /* Revert the scaling to integer that we performed earlier. */
1549 u.exp += r.exp - (SIGNIFICAND_BITS - 1);
1550 r = u;
1551
1552 /* Find power of 10. Do this by dividing out 10**2**M when
1553 this is larger than the current remainder. Fill PTEN with
1554 the power of 10 that we compute. */
1555 if (r.exp > 0)
1556 {
1557 m = floor_log2 ((int)(r.exp * M_LOG10_2)) + 1;
1558 do
1559 {
1560 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1561 if (do_compare (&u, ptentwo, 0) >= 0)
1562 {
1563 do_divide (&u, &u, ptentwo);
1564 do_multiply (&pten, &pten, ptentwo);
1565 dec_exp += 1 << m;
1566 }
1567 }
1568 while (--m >= 0);
1569 }
1570 else
1571 /* We managed to divide off enough tens in the above reduction
1572 loop that we've now got a negative exponent. Fall into the
1573 less-than-one code to compute the proper value for PTEN. */
1574 cmp_one = -1;
1575 }
1576 if (cmp_one < 0)
1577 {
1578 int m;
1579
1580 /* Number is less than one. Pad significand with leading
1581 decimal zeros. */
1582
1583 v = r;
1584 while (1)
1585 {
1586 /* Stop if we'd shift bits off the bottom. */
1587 if (v.sig[0] & 7)
1588 break;
1589
1590 do_multiply (&u, &v, ten);
1591
1592 /* Stop if we're now >= 1. */
1593 if (u.exp > 0)
1594 break;
1595
1596 v = u;
1597 dec_exp -= 1;
1598 }
1599 r = v;
1600
1601 /* Find power of 10. Do this by multiplying in P=10**2**M when
1602 the current remainder is smaller than 1/P. Fill PTEN with the
1603 power of 10 that we compute. */
1604 m = floor_log2 ((int)(-r.exp * M_LOG10_2)) + 1;
1605 do
1606 {
1607 const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1608 const REAL_VALUE_TYPE *ptenmtwo = ten_to_mptwo (m);
1609
1610 if (do_compare (&v, ptenmtwo, 0) <= 0)
1611 {
1612 do_multiply (&v, &v, ptentwo);
1613 do_multiply (&pten, &pten, ptentwo);
1614 dec_exp -= 1 << m;
1615 }
1616 }
1617 while (--m >= 0);
1618
1619 /* Invert the positive power of 10 that we've collected so far. */
1620 do_divide (&pten, one, &pten);
1621 }
1622
1623 p = str;
1624 if (sign)
1625 *p++ = '-';
1626 first = p++;
1627
1628 /* At this point, PTEN should contain the nearest power of 10 smaller
1629 than R, such that this division produces the first digit.
1630
1631 Using a divide-step primitive that returns the complete integral
1632 remainder avoids the rounding error that would be produced if
1633 we were to use do_divide here and then simply multiply by 10 for
1634 each subsequent digit. */
1635
1636 digit = rtd_divmod (&r, &pten);
1637
1638 /* Be prepared for error in that division via underflow ... */
1639 if (digit == 0 && cmp_significand_0 (&r))
1640 {
1641 /* Multiply by 10 and try again. */
1642 do_multiply (&r, &r, ten);
1643 digit = rtd_divmod (&r, &pten);
1644 dec_exp -= 1;
1645 if (digit == 0)
1646 abort ();
1647 }
1648
1649 /* ... or overflow. */
1650 if (digit == 10)
1651 {
1652 *p++ = '1';
1653 if (--digits > 0)
1654 *p++ = '0';
1655 dec_exp += 1;
1656 }
1657 else if (digit > 10)
1658 abort ();
1659 else
1660 *p++ = digit + '0';
1661
1662 /* Generate subsequent digits. */
1663 while (--digits > 0)
1664 {
1665 do_multiply (&r, &r, ten);
1666 digit = rtd_divmod (&r, &pten);
1667 *p++ = digit + '0';
1668 }
1669 last = p;
1670
1671 /* Generate one more digit with which to do rounding. */
1672 do_multiply (&r, &r, ten);
1673 digit = rtd_divmod (&r, &pten);
1674
1675 /* Round the result. */
1676 if (digit == 5)
1677 {
1678 /* Round to nearest. If R is non-zero there are additional
1679 non-zero digits to be extracted. */
1680 if (cmp_significand_0 (&r))
1681 digit++;
1682 /* Round to even. */
1683 else if ((p[-1] - '0') & 1)
1684 digit++;
1685 }
1686 if (digit > 5)
1687 {
1688 while (p > first)
1689 {
1690 digit = *--p;
1691 if (digit == '9')
1692 *p = '0';
1693 else
1694 {
1695 *p = digit + 1;
1696 break;
1697 }
1698 }
1699
1700 /* Carry out of the first digit. This means we had all 9's and
1701 now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1702 if (p == first)
1703 {
1704 first[1] = '1';
1705 dec_exp++;
1706 }
1707 }
1708
1709 /* Insert the decimal point. */
1710 first[0] = first[1];
1711 first[1] = '.';
1712
1713 /* If requested, drop trailing zeros. Never crop past "1.0". */
1714 if (crop_trailing_zeros)
1715 while (last > first + 3 && last[-1] == '0')
1716 last--;
1717
1718 /* Append the exponent. */
1719 sprintf (last, "e%+d", dec_exp);
1720 }
1721
1722 /* Render R as a hexadecimal floating point constant. Emit DIGITS
1723 significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1724 choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1725 strip trailing zeros. */
1726
1727 void
1728 real_to_hexadecimal (str, r, buf_size, digits, crop_trailing_zeros)
1729 char *str;
1730 const REAL_VALUE_TYPE *r;
1731 size_t buf_size, digits;
1732 int crop_trailing_zeros;
1733 {
1734 int i, j, exp = r->exp;
1735 char *p, *first;
1736 char exp_buf[16];
1737 size_t max_digits;
1738
1739 switch (r->class)
1740 {
1741 case rvc_zero:
1742 exp = 0;
1743 break;
1744 case rvc_normal:
1745 break;
1746 case rvc_inf:
1747 strcpy (str, (r->sign ? "-Inf" : "+Inf"));
1748 return;
1749 case rvc_nan:
1750 /* ??? Print the significand as well, if not canonical? */
1751 strcpy (str, (r->sign ? "-NaN" : "+NaN"));
1752 return;
1753 default:
1754 abort ();
1755 }
1756
1757 if (digits == 0)
1758 digits = SIGNIFICAND_BITS / 4;
1759
1760 /* Bound the number of digits printed by the size of the output buffer. */
1761
1762 sprintf (exp_buf, "p%+d", exp);
1763 max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1;
1764 if (max_digits > buf_size)
1765 abort ();
1766 if (digits > max_digits)
1767 digits = max_digits;
1768
1769 p = str;
1770 if (r->sign)
1771 *p++ = '-';
1772 *p++ = '0';
1773 *p++ = 'x';
1774 *p++ = '0';
1775 *p++ = '.';
1776 first = p;
1777
1778 for (i = SIGSZ - 1; i >= 0; --i)
1779 for (j = HOST_BITS_PER_LONG - 4; j >= 0; j -= 4)
1780 {
1781 *p++ = "0123456789abcdef"[(r->sig[i] >> j) & 15];
1782 if (--digits == 0)
1783 goto out;
1784 }
1785
1786 out:
1787 if (crop_trailing_zeros)
1788 while (p > first + 1 && p[-1] == '0')
1789 p--;
1790
1791 sprintf (p, "p%+d", exp);
1792 }
1793
1794 /* Initialize R from a decimal or hexadecimal string. The string is
1795 assumed to have been syntax checked already. */
1796
1797 void
1798 real_from_string (r, str)
1799 REAL_VALUE_TYPE *r;
1800 const char *str;
1801 {
1802 int exp = 0;
1803 bool sign = false;
1804
1805 get_zero (r, 0);
1806
1807 if (*str == '-')
1808 {
1809 sign = true;
1810 str++;
1811 }
1812 else if (*str == '+')
1813 str++;
1814
1815 if (str[0] == '0' && str[1] == 'x')
1816 {
1817 /* Hexadecimal floating point. */
1818 int pos = SIGNIFICAND_BITS - 4, d;
1819
1820 str += 2;
1821
1822 while (*str == '0')
1823 str++;
1824 while (1)
1825 {
1826 d = hex_value (*str);
1827 if (d == _hex_bad)
1828 break;
1829 if (pos >= 0)
1830 {
1831 r->sig[pos / HOST_BITS_PER_LONG]
1832 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1833 pos -= 4;
1834 }
1835 exp += 4;
1836 str++;
1837 }
1838 if (*str == '.')
1839 {
1840 str++;
1841 if (pos == SIGNIFICAND_BITS - 4)
1842 {
1843 while (*str == '0')
1844 str++, exp -= 4;
1845 }
1846 while (1)
1847 {
1848 d = hex_value (*str);
1849 if (d == _hex_bad)
1850 break;
1851 if (pos >= 0)
1852 {
1853 r->sig[pos / HOST_BITS_PER_LONG]
1854 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
1855 pos -= 4;
1856 }
1857 str++;
1858 }
1859 }
1860 if (*str == 'p' || *str == 'P')
1861 {
1862 bool exp_neg = false;
1863
1864 str++;
1865 if (*str == '-')
1866 {
1867 exp_neg = true;
1868 str++;
1869 }
1870 else if (*str == '+')
1871 str++;
1872
1873 d = 0;
1874 while (ISDIGIT (*str))
1875 {
1876 d *= 10;
1877 d += *str - '0';
1878 if (d > MAX_EXP)
1879 {
1880 /* Overflowed the exponent. */
1881 if (exp_neg)
1882 goto underflow;
1883 else
1884 goto overflow;
1885 }
1886 str++;
1887 }
1888 if (exp_neg)
1889 d = -d;
1890
1891 exp += d;
1892 }
1893
1894 r->class = rvc_normal;
1895 r->exp = exp;
1896
1897 normalize (r);
1898 }
1899 else
1900 {
1901 /* Decimal floating point. */
1902 const REAL_VALUE_TYPE *ten = ten_to_ptwo (0);
1903 int d;
1904
1905 while (*str == '0')
1906 str++;
1907 while (ISDIGIT (*str))
1908 {
1909 d = *str++ - '0';
1910 do_multiply (r, r, ten);
1911 if (d)
1912 do_add (r, r, real_digit (d), 0);
1913 }
1914 if (*str == '.')
1915 {
1916 str++;
1917 if (r->class == rvc_zero)
1918 {
1919 while (*str == '0')
1920 str++, exp--;
1921 }
1922 while (ISDIGIT (*str))
1923 {
1924 d = *str++ - '0';
1925 do_multiply (r, r, ten);
1926 if (d)
1927 do_add (r, r, real_digit (d), 0);
1928 exp--;
1929 }
1930 }
1931
1932 if (*str == 'e' || *str == 'E')
1933 {
1934 bool exp_neg = false;
1935
1936 str++;
1937 if (*str == '-')
1938 {
1939 exp_neg = true;
1940 str++;
1941 }
1942 else if (*str == '+')
1943 str++;
1944
1945 d = 0;
1946 while (ISDIGIT (*str))
1947 {
1948 d *= 10;
1949 d += *str - '0';
1950 if (d > MAX_EXP)
1951 {
1952 /* Overflowed the exponent. */
1953 if (exp_neg)
1954 goto underflow;
1955 else
1956 goto overflow;
1957 }
1958 str++;
1959 }
1960 if (exp_neg)
1961 d = -d;
1962 exp += d;
1963 }
1964
1965 if (exp)
1966 times_pten (r, exp);
1967 }
1968
1969 r->sign = sign;
1970 return;
1971
1972 underflow:
1973 get_zero (r, sign);
1974 return;
1975
1976 overflow:
1977 get_inf (r, sign);
1978 return;
1979 }
1980
1981 /* Legacy. Similar, but return the result directly. */
1982
1983 REAL_VALUE_TYPE
1984 real_from_string2 (s, mode)
1985 const char *s;
1986 enum machine_mode mode;
1987 {
1988 REAL_VALUE_TYPE r;
1989
1990 real_from_string (&r, s);
1991 if (mode != VOIDmode)
1992 real_convert (&r, mode, &r);
1993
1994 return r;
1995 }
1996
1997 /* Initialize R from the integer pair HIGH+LOW. */
1998
1999 void
2000 real_from_integer (r, mode, low, high, unsigned_p)
2001 REAL_VALUE_TYPE *r;
2002 enum machine_mode mode;
2003 unsigned HOST_WIDE_INT low;
2004 HOST_WIDE_INT high;
2005 int unsigned_p;
2006 {
2007 if (low == 0 && high == 0)
2008 get_zero (r, 0);
2009 else
2010 {
2011 r->class = rvc_normal;
2012 r->sign = high < 0 && !unsigned_p;
2013 r->exp = 2 * HOST_BITS_PER_WIDE_INT;
2014
2015 if (r->sign)
2016 {
2017 high = ~high;
2018 if (low == 0)
2019 high += 1;
2020 else
2021 low = -low;
2022 }
2023
2024 if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT)
2025 {
2026 r->sig[SIGSZ-1] = high;
2027 r->sig[SIGSZ-2] = low;
2028 memset (r->sig, 0, sizeof(long)*(SIGSZ-2));
2029 }
2030 else if (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT)
2031 {
2032 r->sig[SIGSZ-1] = high >> (HOST_BITS_PER_LONG - 1) >> 1;
2033 r->sig[SIGSZ-2] = high;
2034 r->sig[SIGSZ-3] = low >> (HOST_BITS_PER_LONG - 1) >> 1;
2035 r->sig[SIGSZ-4] = low;
2036 if (SIGSZ > 4)
2037 memset (r->sig, 0, sizeof(long)*(SIGSZ-4));
2038 }
2039 else
2040 abort ();
2041
2042 normalize (r);
2043 }
2044
2045 if (mode != VOIDmode)
2046 real_convert (r, mode, r);
2047 }
2048
2049 /* Returns 10**2**N. */
2050
2051 static const REAL_VALUE_TYPE *
2052 ten_to_ptwo (n)
2053 int n;
2054 {
2055 static REAL_VALUE_TYPE tens[EXP_BITS];
2056
2057 if (n < 0 || n >= EXP_BITS)
2058 abort ();
2059
2060 if (tens[n].class == rvc_zero)
2061 {
2062 if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
2063 {
2064 HOST_WIDE_INT t = 10;
2065 int i;
2066
2067 for (i = 0; i < n; ++i)
2068 t *= t;
2069
2070 real_from_integer (&tens[n], VOIDmode, t, 0, 1);
2071 }
2072 else
2073 {
2074 const REAL_VALUE_TYPE *t = ten_to_ptwo (n - 1);
2075 do_multiply (&tens[n], t, t);
2076 }
2077 }
2078
2079 return &tens[n];
2080 }
2081
2082 /* Returns 10**(-2**N). */
2083
2084 static const REAL_VALUE_TYPE *
2085 ten_to_mptwo (n)
2086 int n;
2087 {
2088 static REAL_VALUE_TYPE tens[EXP_BITS];
2089
2090 if (n < 0 || n >= EXP_BITS)
2091 abort ();
2092
2093 if (tens[n].class == rvc_zero)
2094 do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
2095
2096 return &tens[n];
2097 }
2098
2099 /* Returns N. */
2100
2101 static const REAL_VALUE_TYPE *
2102 real_digit (n)
2103 int n;
2104 {
2105 static REAL_VALUE_TYPE num[10];
2106
2107 if (n < 0 || n > 9)
2108 abort ();
2109
2110 if (n > 0 && num[n].class == rvc_zero)
2111 real_from_integer (&num[n], VOIDmode, n, 0, 1);
2112
2113 return &num[n];
2114 }
2115
2116 /* Multiply R by 10**EXP. */
2117
2118 static void
2119 times_pten (r, exp)
2120 REAL_VALUE_TYPE *r;
2121 int exp;
2122 {
2123 REAL_VALUE_TYPE pten, *rr;
2124 bool negative = (exp < 0);
2125 int i;
2126
2127 if (negative)
2128 {
2129 exp = -exp;
2130 pten = *real_digit (1);
2131 rr = &pten;
2132 }
2133 else
2134 rr = r;
2135
2136 for (i = 0; exp > 0; ++i, exp >>= 1)
2137 if (exp & 1)
2138 do_multiply (rr, rr, ten_to_ptwo (i));
2139
2140 if (negative)
2141 do_divide (r, r, &pten);
2142 }
2143
2144 /* Fills R with +Inf. */
2145
2146 void
2147 real_inf (r)
2148 REAL_VALUE_TYPE *r;
2149 {
2150 get_inf (r, 0);
2151 }
2152
2153 /* Fills R with a NaN whose significand is described by STR. If QUIET,
2154 we force a QNaN, else we force an SNaN. The string, if not empty,
2155 is parsed as a number and placed in the significand. Return true
2156 if the string was successfully parsed. */
2157
2158 bool
2159 real_nan (r, str, quiet, mode)
2160 REAL_VALUE_TYPE *r;
2161 const char *str;
2162 int quiet;
2163 enum machine_mode mode;
2164 {
2165 const struct real_format *fmt;
2166
2167 fmt = real_format_for_mode[mode - QFmode];
2168 if (fmt == NULL)
2169 abort ();
2170
2171 if (*str == 0)
2172 {
2173 if (quiet)
2174 get_canonical_qnan (r, 0);
2175 else
2176 get_canonical_snan (r, 0);
2177 }
2178 else
2179 {
2180 int base = 10, d;
2181 bool neg = false;
2182
2183 memset (r, 0, sizeof (*r));
2184 r->class = rvc_nan;
2185
2186 /* Parse akin to strtol into the significand of R. */
2187
2188 while (ISSPACE (*str))
2189 str++;
2190 if (*str == '-')
2191 str++, neg = true;
2192 else if (*str == '+')
2193 str++;
2194 if (*str == '0')
2195 {
2196 if (*++str == 'x')
2197 str++, base = 16;
2198 else
2199 base = 8;
2200 }
2201
2202 while ((d = hex_value (*str)) < base)
2203 {
2204 REAL_VALUE_TYPE u;
2205
2206 switch (base)
2207 {
2208 case 8:
2209 lshift_significand (r, r, 3);
2210 break;
2211 case 16:
2212 lshift_significand (r, r, 4);
2213 break;
2214 case 10:
2215 lshift_significand_1 (&u, r);
2216 lshift_significand (r, r, 3);
2217 add_significands (r, r, &u);
2218 break;
2219 default:
2220 abort ();
2221 }
2222
2223 get_zero (&u, 0);
2224 u.sig[0] = d;
2225 add_significands (r, r, &u);
2226
2227 str++;
2228 }
2229
2230 /* Must have consumed the entire string for success. */
2231 if (*str != 0)
2232 return false;
2233
2234 /* Shift the significand into place such that the bits
2235 are in the most significant bits for the format. */
2236 lshift_significand (r, r, SIGNIFICAND_BITS - fmt->p);
2237
2238 /* Our MSB is always unset for NaNs. */
2239 r->sig[SIGSZ-1] &= ~SIG_MSB;
2240
2241 /* Force quiet or signalling NaN. */
2242 if (quiet)
2243 r->sig[SIGSZ-1] |= SIG_MSB >> 1;
2244 else
2245 r->sig[SIGSZ-1] &= ~(SIG_MSB >> 1);
2246
2247 /* Force at least one bit of the significand set. */
2248 for (d = 0; d < SIGSZ; ++d)
2249 if (r->sig[d])
2250 break;
2251 if (d == SIGSZ)
2252 r->sig[SIGSZ-1] |= SIG_MSB >> 2;
2253
2254 /* Our intermediate format forces QNaNs to have MSB-1 set.
2255 If the target format has QNaNs with the top bit unset,
2256 mirror the output routines and invert the top two bits. */
2257 if (!fmt->qnan_msb_set)
2258 r->sig[SIGSZ-1] ^= (SIG_MSB >> 1) | (SIG_MSB >> 2);
2259 }
2260
2261 return true;
2262 }
2263
2264 /* Fills R with 2**N. */
2265
2266 void
2267 real_2expN (r, n)
2268 REAL_VALUE_TYPE *r;
2269 int n;
2270 {
2271 memset (r, 0, sizeof (*r));
2272
2273 n++;
2274 if (n > MAX_EXP)
2275 r->class = rvc_inf;
2276 else if (n < -MAX_EXP)
2277 ;
2278 else
2279 {
2280 r->class = rvc_normal;
2281 r->exp = n;
2282 r->sig[SIGSZ-1] = SIG_MSB;
2283 }
2284 }
2285
2286 \f
2287 static void
2288 round_for_format (fmt, r)
2289 const struct real_format *fmt;
2290 REAL_VALUE_TYPE *r;
2291 {
2292 int p2, np2, i, w;
2293 unsigned long sticky;
2294 bool guard, lsb;
2295 int emin2m1, emax2;
2296
2297 p2 = fmt->p * fmt->log2_b;
2298 emin2m1 = (fmt->emin - 1) * fmt->log2_b;
2299 emax2 = fmt->emax * fmt->log2_b;
2300
2301 np2 = SIGNIFICAND_BITS - p2;
2302 switch (r->class)
2303 {
2304 underflow:
2305 get_zero (r, r->sign);
2306 case rvc_zero:
2307 if (!fmt->has_signed_zero)
2308 r->sign = 0;
2309 return;
2310
2311 overflow:
2312 get_inf (r, r->sign);
2313 case rvc_inf:
2314 return;
2315
2316 case rvc_nan:
2317 clear_significand_below (r, np2);
2318
2319 /* If we've cleared the entire significand, we need one bit
2320 set for this to continue to be a NaN. */
2321 for (i = 0; i < SIGSZ; ++i)
2322 if (r->sig[i])
2323 break;
2324 if (i == SIGSZ)
2325 r->sig[SIGSZ-1] = SIG_MSB >> 2;
2326 return;
2327
2328 case rvc_normal:
2329 break;
2330
2331 default:
2332 abort ();
2333 }
2334
2335 /* If we're not base2, normalize the exponent to a multiple of
2336 the true base. */
2337 if (fmt->log2_b != 1)
2338 {
2339 int shift = r->exp & (fmt->log2_b - 1);
2340 if (shift)
2341 {
2342 shift = fmt->log2_b - shift;
2343 r->sig[0] |= sticky_rshift_significand (r, r, shift);
2344 r->exp += shift;
2345 }
2346 }
2347
2348 /* Check the range of the exponent. If we're out of range,
2349 either underflow or overflow. */
2350 if (r->exp > emax2)
2351 goto overflow;
2352 else if (r->exp <= emin2m1)
2353 {
2354 int diff;
2355
2356 if (!fmt->has_denorm)
2357 {
2358 /* Don't underflow completely until we've had a chance to round. */
2359 if (r->exp < emin2m1)
2360 goto underflow;
2361 }
2362 else
2363 {
2364 diff = emin2m1 - r->exp + 1;
2365 if (diff > p2)
2366 goto underflow;
2367
2368 /* De-normalize the significand. */
2369 r->sig[0] |= sticky_rshift_significand (r, r, diff);
2370 r->exp += diff;
2371 }
2372 }
2373
2374 /* There are P2 true significand bits, followed by one guard bit,
2375 followed by one sticky bit, followed by stuff. Fold nonzero
2376 stuff into the sticky bit. */
2377
2378 sticky = 0;
2379 for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
2380 sticky |= r->sig[i];
2381 sticky |=
2382 r->sig[w] & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
2383
2384 guard = test_significand_bit (r, np2 - 1);
2385 lsb = test_significand_bit (r, np2);
2386
2387 /* Round to even. */
2388 if (guard && (sticky || lsb))
2389 {
2390 REAL_VALUE_TYPE u;
2391 get_zero (&u, 0);
2392 set_significand_bit (&u, np2);
2393
2394 if (add_significands (r, r, &u))
2395 {
2396 /* Overflow. Means the significand had been all ones, and
2397 is now all zeros. Need to increase the exponent, and
2398 possibly re-normalize it. */
2399 if (++r->exp > emax2)
2400 goto overflow;
2401 r->sig[SIGSZ-1] = SIG_MSB;
2402
2403 if (fmt->log2_b != 1)
2404 {
2405 int shift = r->exp & (fmt->log2_b - 1);
2406 if (shift)
2407 {
2408 shift = fmt->log2_b - shift;
2409 rshift_significand (r, r, shift);
2410 r->exp += shift;
2411 if (r->exp > emax2)
2412 goto overflow;
2413 }
2414 }
2415 }
2416 }
2417
2418 /* Catch underflow that we deferred until after rounding. */
2419 if (r->exp <= emin2m1)
2420 goto underflow;
2421
2422 /* Clear out trailing garbage. */
2423 clear_significand_below (r, np2);
2424 }
2425
2426 /* Extend or truncate to a new mode. */
2427
2428 void
2429 real_convert (r, mode, a)
2430 REAL_VALUE_TYPE *r;
2431 enum machine_mode mode;
2432 const REAL_VALUE_TYPE *a;
2433 {
2434 const struct real_format *fmt;
2435
2436 fmt = real_format_for_mode[mode - QFmode];
2437 if (fmt == NULL)
2438 abort ();
2439
2440 *r = *a;
2441 round_for_format (fmt, r);
2442
2443 /* round_for_format de-normalizes denormals. Undo just that part. */
2444 if (r->class == rvc_normal)
2445 normalize (r);
2446 }
2447
2448 /* Legacy. Likewise, except return the struct directly. */
2449
2450 REAL_VALUE_TYPE
2451 real_value_truncate (mode, a)
2452 enum machine_mode mode;
2453 REAL_VALUE_TYPE a;
2454 {
2455 REAL_VALUE_TYPE r;
2456 real_convert (&r, mode, &a);
2457 return r;
2458 }
2459
2460 /* Return true if truncating to MODE is exact. */
2461
2462 bool
2463 exact_real_truncate (mode, a)
2464 enum machine_mode mode;
2465 const REAL_VALUE_TYPE *a;
2466 {
2467 REAL_VALUE_TYPE t;
2468 real_convert (&t, mode, a);
2469 return real_identical (&t, a);
2470 }
2471
2472 /* Write R to the given target format. Place the words of the result
2473 in target word order in BUF. There are always 32 bits in each
2474 long, no matter the size of the host long.
2475
2476 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2477
2478 long
2479 real_to_target_fmt (buf, r_orig, fmt)
2480 long *buf;
2481 const REAL_VALUE_TYPE *r_orig;
2482 const struct real_format *fmt;
2483 {
2484 REAL_VALUE_TYPE r;
2485 long buf1;
2486
2487 r = *r_orig;
2488 round_for_format (fmt, &r);
2489
2490 if (!buf)
2491 buf = &buf1;
2492 (*fmt->encode) (fmt, buf, &r);
2493
2494 return *buf;
2495 }
2496
2497 /* Similar, but look up the format from MODE. */
2498
2499 long
2500 real_to_target (buf, r, mode)
2501 long *buf;
2502 const REAL_VALUE_TYPE *r;
2503 enum machine_mode mode;
2504 {
2505 const struct real_format *fmt;
2506
2507 fmt = real_format_for_mode[mode - QFmode];
2508 if (fmt == NULL)
2509 abort ();
2510
2511 return real_to_target_fmt (buf, r, fmt);
2512 }
2513
2514 /* Read R from the given target format. Read the words of the result
2515 in target word order in BUF. There are always 32 bits in each
2516 long, no matter the size of the host long. */
2517
2518 void
2519 real_from_target_fmt (r, buf, fmt)
2520 REAL_VALUE_TYPE *r;
2521 const long *buf;
2522 const struct real_format *fmt;
2523 {
2524 (*fmt->decode) (fmt, r, buf);
2525 }
2526
2527 /* Similar, but look up the format from MODE. */
2528
2529 void
2530 real_from_target (r, buf, mode)
2531 REAL_VALUE_TYPE *r;
2532 const long *buf;
2533 enum machine_mode mode;
2534 {
2535 const struct real_format *fmt;
2536
2537 fmt = real_format_for_mode[mode - QFmode];
2538 if (fmt == NULL)
2539 abort ();
2540
2541 (*fmt->decode) (fmt, r, buf);
2542 }
2543
2544 /* Return the number of bits in the significand for MODE. */
2545 /* ??? Legacy. Should get access to real_format directly. */
2546
2547 int
2548 significand_size (mode)
2549 enum machine_mode mode;
2550 {
2551 const struct real_format *fmt;
2552
2553 fmt = real_format_for_mode[mode - QFmode];
2554 if (fmt == NULL)
2555 return 0;
2556
2557 return fmt->p * fmt->log2_b;
2558 }
2559
2560 /* Return a hash value for the given real value. */
2561 /* ??? The "unsigned int" return value is intended to be hashval_t,
2562 but I didn't want to pull hashtab.h into real.h. */
2563
2564 unsigned int
2565 real_hash (r)
2566 const REAL_VALUE_TYPE *r;
2567 {
2568 unsigned int h;
2569 size_t i;
2570
2571 h = r->class | (r->sign << 2);
2572 switch (r->class)
2573 {
2574 case rvc_zero:
2575 case rvc_inf:
2576 break;
2577
2578 case rvc_normal:
2579 h |= r->exp << 3;
2580 /* FALLTHRU */
2581
2582 case rvc_nan:
2583 if (sizeof(unsigned long) > sizeof(unsigned int))
2584 for (i = 0; i < SIGSZ; ++i)
2585 {
2586 unsigned long s = r->sig[i];
2587 h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2));
2588 }
2589 else
2590 for (i = 0; i < SIGSZ; ++i)
2591 h ^= r->sig[i];
2592 break;
2593
2594 default:
2595 abort ();
2596 }
2597
2598 return h;
2599 }
2600 \f
2601 /* IEEE single-precision format. */
2602
2603 static void encode_ieee_single PARAMS ((const struct real_format *fmt,
2604 long *, const REAL_VALUE_TYPE *));
2605 static void decode_ieee_single PARAMS ((const struct real_format *,
2606 REAL_VALUE_TYPE *, const long *));
2607
2608 static void
2609 encode_ieee_single (fmt, buf, r)
2610 const struct real_format *fmt;
2611 long *buf;
2612 const REAL_VALUE_TYPE *r;
2613 {
2614 unsigned long image, sig, exp;
2615 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2616
2617 image = r->sign << 31;
2618 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
2619
2620 switch (r->class)
2621 {
2622 case rvc_zero:
2623 break;
2624
2625 case rvc_inf:
2626 if (fmt->has_inf)
2627 image |= 255 << 23;
2628 else
2629 image |= 0x7fffffff;
2630 break;
2631
2632 case rvc_nan:
2633 if (fmt->has_nans)
2634 {
2635 image |= 255 << 23;
2636 image |= sig;
2637 if (!fmt->qnan_msb_set)
2638 image ^= 1 << 23 | 1 << 22;
2639 }
2640 else
2641 image |= 0x7fffffff;
2642 break;
2643
2644 case rvc_normal:
2645 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2646 whereas the intermediate representation is 0.F x 2**exp.
2647 Which means we're off by one. */
2648 if (denormal)
2649 exp = 0;
2650 else
2651 exp = r->exp + 127 - 1;
2652 image |= exp << 23;
2653 image |= sig;
2654 break;
2655
2656 default:
2657 abort ();
2658 }
2659
2660 buf[0] = image;
2661 }
2662
2663 static void
2664 decode_ieee_single (fmt, r, buf)
2665 const struct real_format *fmt;
2666 REAL_VALUE_TYPE *r;
2667 const long *buf;
2668 {
2669 unsigned long image = buf[0] & 0xffffffff;
2670 bool sign = (image >> 31) & 1;
2671 int exp = (image >> 23) & 0xff;
2672
2673 memset (r, 0, sizeof (*r));
2674 image <<= HOST_BITS_PER_LONG - 24;
2675 image &= ~SIG_MSB;
2676
2677 if (exp == 0)
2678 {
2679 if (image && fmt->has_denorm)
2680 {
2681 r->class = rvc_normal;
2682 r->sign = sign;
2683 r->exp = -126;
2684 r->sig[SIGSZ-1] = image << 1;
2685 normalize (r);
2686 }
2687 else if (fmt->has_signed_zero)
2688 r->sign = sign;
2689 }
2690 else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
2691 {
2692 if (image)
2693 {
2694 r->class = rvc_nan;
2695 r->sign = sign;
2696 if (!fmt->qnan_msb_set)
2697 image ^= (SIG_MSB >> 1 | SIG_MSB >> 2);
2698 r->sig[SIGSZ-1] = image;
2699 }
2700 else
2701 {
2702 r->class = rvc_inf;
2703 r->sign = sign;
2704 }
2705 }
2706 else
2707 {
2708 r->class = rvc_normal;
2709 r->sign = sign;
2710 r->exp = exp - 127 + 1;
2711 r->sig[SIGSZ-1] = image | SIG_MSB;
2712 }
2713 }
2714
2715 const struct real_format ieee_single_format =
2716 {
2717 encode_ieee_single,
2718 decode_ieee_single,
2719 2,
2720 1,
2721 24,
2722 -125,
2723 128,
2724 true,
2725 true,
2726 true,
2727 true,
2728 true
2729 };
2730
2731 \f
2732 /* IEEE double-precision format. */
2733
2734 static void encode_ieee_double PARAMS ((const struct real_format *fmt,
2735 long *, const REAL_VALUE_TYPE *));
2736 static void decode_ieee_double PARAMS ((const struct real_format *,
2737 REAL_VALUE_TYPE *, const long *));
2738
2739 static void
2740 encode_ieee_double (fmt, buf, r)
2741 const struct real_format *fmt;
2742 long *buf;
2743 const REAL_VALUE_TYPE *r;
2744 {
2745 unsigned long image_lo, image_hi, sig_lo, sig_hi, exp;
2746 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2747
2748 image_hi = r->sign << 31;
2749 image_lo = 0;
2750
2751 if (HOST_BITS_PER_LONG == 64)
2752 {
2753 sig_hi = r->sig[SIGSZ-1];
2754 sig_lo = (sig_hi >> (64 - 53)) & 0xffffffff;
2755 sig_hi = (sig_hi >> (64 - 53 + 1) >> 31) & 0xfffff;
2756 }
2757 else
2758 {
2759 sig_hi = r->sig[SIGSZ-1];
2760 sig_lo = r->sig[SIGSZ-2];
2761 sig_lo = (sig_hi << 21) | (sig_lo >> 11);
2762 sig_hi = (sig_hi >> 11) & 0xfffff;
2763 }
2764
2765 switch (r->class)
2766 {
2767 case rvc_zero:
2768 break;
2769
2770 case rvc_inf:
2771 if (fmt->has_inf)
2772 image_hi |= 2047 << 20;
2773 else
2774 {
2775 image_hi |= 0x7fffffff;
2776 image_lo = 0xffffffff;
2777 }
2778 break;
2779
2780 case rvc_nan:
2781 if (fmt->has_nans)
2782 {
2783 image_hi |= 2047 << 20;
2784 image_hi |= sig_hi;
2785 if (!fmt->qnan_msb_set)
2786 image_hi ^= 1 << 19 | 1 << 18;
2787 image_lo = sig_lo;
2788 }
2789 else
2790 {
2791 image_hi |= 0x7fffffff;
2792 image_lo = 0xffffffff;
2793 }
2794 break;
2795
2796 case rvc_normal:
2797 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
2798 whereas the intermediate representation is 0.F x 2**exp.
2799 Which means we're off by one. */
2800 if (denormal)
2801 exp = 0;
2802 else
2803 exp = r->exp + 1023 - 1;
2804 image_hi |= exp << 20;
2805 image_hi |= sig_hi;
2806 image_lo = sig_lo;
2807 break;
2808
2809 default:
2810 abort ();
2811 }
2812
2813 if (FLOAT_WORDS_BIG_ENDIAN)
2814 buf[0] = image_hi, buf[1] = image_lo;
2815 else
2816 buf[0] = image_lo, buf[1] = image_hi;
2817 }
2818
2819 static void
2820 decode_ieee_double (fmt, r, buf)
2821 const struct real_format *fmt;
2822 REAL_VALUE_TYPE *r;
2823 const long *buf;
2824 {
2825 unsigned long image_hi, image_lo;
2826 bool sign;
2827 int exp;
2828
2829 if (FLOAT_WORDS_BIG_ENDIAN)
2830 image_hi = buf[0], image_lo = buf[1];
2831 else
2832 image_lo = buf[0], image_hi = buf[1];
2833 image_lo &= 0xffffffff;
2834 image_hi &= 0xffffffff;
2835
2836 sign = (image_hi >> 31) & 1;
2837 exp = (image_hi >> 20) & 0x7ff;
2838
2839 memset (r, 0, sizeof (*r));
2840
2841 image_hi <<= 32 - 21;
2842 image_hi |= image_lo >> 21;
2843 image_hi &= 0x7fffffff;
2844 image_lo <<= 32 - 21;
2845
2846 if (exp == 0)
2847 {
2848 if ((image_hi || image_lo) && fmt->has_denorm)
2849 {
2850 r->class = rvc_normal;
2851 r->sign = sign;
2852 r->exp = -1022;
2853 if (HOST_BITS_PER_LONG == 32)
2854 {
2855 image_hi = (image_hi << 1) | (image_lo >> 31);
2856 image_lo <<= 1;
2857 r->sig[SIGSZ-1] = image_hi;
2858 r->sig[SIGSZ-2] = image_lo;
2859 }
2860 else
2861 {
2862 image_hi = (image_hi << 31 << 2) | (image_lo << 1);
2863 r->sig[SIGSZ-1] = image_hi;
2864 }
2865 normalize (r);
2866 }
2867 else if (fmt->has_signed_zero)
2868 r->sign = sign;
2869 }
2870 else if (exp == 2047 && (fmt->has_nans || fmt->has_inf))
2871 {
2872 if (image_hi || image_lo)
2873 {
2874 r->class = rvc_nan;
2875 r->sign = sign;
2876 if (HOST_BITS_PER_LONG == 32)
2877 {
2878 r->sig[SIGSZ-1] = image_hi;
2879 r->sig[SIGSZ-2] = image_lo;
2880 }
2881 else
2882 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo;
2883
2884 if (!fmt->qnan_msb_set)
2885 r->sig[SIGSZ-1] ^= (SIG_MSB >> 1 | SIG_MSB >> 2);
2886 }
2887 else
2888 {
2889 r->class = rvc_inf;
2890 r->sign = sign;
2891 }
2892 }
2893 else
2894 {
2895 r->class = rvc_normal;
2896 r->sign = sign;
2897 r->exp = exp - 1023 + 1;
2898 if (HOST_BITS_PER_LONG == 32)
2899 {
2900 r->sig[SIGSZ-1] = image_hi | SIG_MSB;
2901 r->sig[SIGSZ-2] = image_lo;
2902 }
2903 else
2904 r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo | SIG_MSB;
2905 }
2906 }
2907
2908 const struct real_format ieee_double_format =
2909 {
2910 encode_ieee_double,
2911 decode_ieee_double,
2912 2,
2913 1,
2914 53,
2915 -1021,
2916 1024,
2917 true,
2918 true,
2919 true,
2920 true,
2921 true
2922 };
2923
2924 \f
2925 /* IEEE extended double precision format. This comes in three
2926 flavours: Intel's as a 12 byte image, Intel's as a 16 byte image,
2927 and Motorola's. */
2928
2929 static void encode_ieee_extended PARAMS ((const struct real_format *fmt,
2930 long *, const REAL_VALUE_TYPE *));
2931 static void decode_ieee_extended PARAMS ((const struct real_format *,
2932 REAL_VALUE_TYPE *, const long *));
2933
2934 static void encode_ieee_extended_128 PARAMS ((const struct real_format *fmt,
2935 long *,
2936 const REAL_VALUE_TYPE *));
2937 static void decode_ieee_extended_128 PARAMS ((const struct real_format *,
2938 REAL_VALUE_TYPE *,
2939 const long *));
2940
2941 static void
2942 encode_ieee_extended (fmt, buf, r)
2943 const struct real_format *fmt;
2944 long *buf;
2945 const REAL_VALUE_TYPE *r;
2946 {
2947 unsigned long image_hi, sig_hi, sig_lo;
2948 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
2949
2950 image_hi = r->sign << 15;
2951 sig_hi = sig_lo = 0;
2952
2953 switch (r->class)
2954 {
2955 case rvc_zero:
2956 break;
2957
2958 case rvc_inf:
2959 if (fmt->has_inf)
2960 {
2961 image_hi |= 32767;
2962
2963 /* Intel requires the explicit integer bit to be set, otherwise
2964 it considers the value a "pseudo-infinity". Motorola docs
2965 say it doesn't care. */
2966 sig_hi = 0x80000000;
2967 }
2968 else
2969 {
2970 image_hi |= 32767;
2971 sig_lo = sig_hi = 0xffffffff;
2972 }
2973 break;
2974
2975 case rvc_nan:
2976 if (fmt->has_nans)
2977 {
2978 image_hi |= 32767;
2979 if (HOST_BITS_PER_LONG == 32)
2980 {
2981 sig_hi = r->sig[SIGSZ-1];
2982 sig_lo = r->sig[SIGSZ-2];
2983 }
2984 else
2985 {
2986 sig_lo = r->sig[SIGSZ-1];
2987 sig_hi = sig_lo >> 31 >> 1;
2988 sig_lo &= 0xffffffff;
2989 }
2990 if (!fmt->qnan_msb_set)
2991 sig_hi ^= 1 << 30 | 1 << 29;
2992
2993 /* Intel requires the explicit integer bit to be set, otherwise
2994 it considers the value a "pseudo-nan". Motorola docs say it
2995 doesn't care. */
2996 sig_hi |= 0x80000000;
2997 }
2998 else
2999 {
3000 image_hi |= 32767;
3001 sig_lo = sig_hi = 0xffffffff;
3002 }
3003 break;
3004
3005 case rvc_normal:
3006 {
3007 int exp = r->exp;
3008
3009 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3010 whereas the intermediate representation is 0.F x 2**exp.
3011 Which means we're off by one.
3012
3013 Except for Motorola, which consider exp=0 and explicit
3014 integer bit set to continue to be normalized. In theory
3015 this descrepency has been taken care of by the difference
3016 in fmt->emin in round_for_format. */
3017
3018 if (denormal)
3019 exp = 0;
3020 else
3021 {
3022 exp += 16383 - 1;
3023 if (exp < 0)
3024 abort ();
3025 }
3026 image_hi |= exp;
3027
3028 if (HOST_BITS_PER_LONG == 32)
3029 {
3030 sig_hi = r->sig[SIGSZ-1];
3031 sig_lo = r->sig[SIGSZ-2];
3032 }
3033 else
3034 {
3035 sig_lo = r->sig[SIGSZ-1];
3036 sig_hi = sig_lo >> 31 >> 1;
3037 sig_lo &= 0xffffffff;
3038 }
3039 }
3040 break;
3041
3042 default:
3043 abort ();
3044 }
3045
3046 if (FLOAT_WORDS_BIG_ENDIAN)
3047 buf[0] = image_hi << 16, buf[1] = sig_hi, buf[2] = sig_lo;
3048 else
3049 buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
3050 }
3051
3052 static void
3053 encode_ieee_extended_128 (fmt, buf, r)
3054 const struct real_format *fmt;
3055 long *buf;
3056 const REAL_VALUE_TYPE *r;
3057 {
3058 buf[3 * !FLOAT_WORDS_BIG_ENDIAN] = 0;
3059 encode_ieee_extended (fmt, buf+!!FLOAT_WORDS_BIG_ENDIAN, r);
3060 }
3061
3062 static void
3063 decode_ieee_extended (fmt, r, buf)
3064 const struct real_format *fmt;
3065 REAL_VALUE_TYPE *r;
3066 const long *buf;
3067 {
3068 unsigned long image_hi, sig_hi, sig_lo;
3069 bool sign;
3070 int exp;
3071
3072 if (FLOAT_WORDS_BIG_ENDIAN)
3073 image_hi = buf[0] >> 16, sig_hi = buf[1], sig_lo = buf[2];
3074 else
3075 sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
3076 sig_lo &= 0xffffffff;
3077 sig_hi &= 0xffffffff;
3078 image_hi &= 0xffffffff;
3079
3080 sign = (image_hi >> 15) & 1;
3081 exp = image_hi & 0x7fff;
3082
3083 memset (r, 0, sizeof (*r));
3084
3085 if (exp == 0)
3086 {
3087 if ((sig_hi || sig_lo) && fmt->has_denorm)
3088 {
3089 r->class = rvc_normal;
3090 r->sign = sign;
3091
3092 /* When the IEEE format contains a hidden bit, we know that
3093 it's zero at this point, and so shift up the significand
3094 and decrease the exponent to match. In this case, Motorola
3095 defines the explicit integer bit to be valid, so we don't
3096 know whether the msb is set or not. */
3097 r->exp = fmt->emin;
3098 if (HOST_BITS_PER_LONG == 32)
3099 {
3100 r->sig[SIGSZ-1] = sig_hi;
3101 r->sig[SIGSZ-2] = sig_lo;
3102 }
3103 else
3104 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3105
3106 normalize (r);
3107 }
3108 else if (fmt->has_signed_zero)
3109 r->sign = sign;
3110 }
3111 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3112 {
3113 /* See above re "pseudo-infinities" and "pseudo-nans".
3114 Short summary is that the MSB will likely always be
3115 set, and that we don't care about it. */
3116 sig_hi &= 0x7fffffff;
3117
3118 if (sig_hi || sig_lo)
3119 {
3120 r->class = rvc_nan;
3121 r->sign = sign;
3122 if (HOST_BITS_PER_LONG == 32)
3123 {
3124 r->sig[SIGSZ-1] = sig_hi;
3125 r->sig[SIGSZ-2] = sig_lo;
3126 }
3127 else
3128 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3129
3130 if (!fmt->qnan_msb_set)
3131 r->sig[SIGSZ-1] ^= (SIG_MSB >> 1 | SIG_MSB >> 2);
3132 }
3133 else
3134 {
3135 r->class = rvc_inf;
3136 r->sign = sign;
3137 }
3138 }
3139 else
3140 {
3141 r->class = rvc_normal;
3142 r->sign = sign;
3143 r->exp = exp - 16383 + 1;
3144 if (HOST_BITS_PER_LONG == 32)
3145 {
3146 r->sig[SIGSZ-1] = sig_hi;
3147 r->sig[SIGSZ-2] = sig_lo;
3148 }
3149 else
3150 r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3151 }
3152 }
3153
3154 static void
3155 decode_ieee_extended_128 (fmt, r, buf)
3156 const struct real_format *fmt;
3157 REAL_VALUE_TYPE *r;
3158 const long *buf;
3159 {
3160 decode_ieee_extended (fmt, r, buf+!!FLOAT_WORDS_BIG_ENDIAN);
3161 }
3162
3163 const struct real_format ieee_extended_motorola_format =
3164 {
3165 encode_ieee_extended,
3166 decode_ieee_extended,
3167 2,
3168 1,
3169 64,
3170 -16382,
3171 16384,
3172 true,
3173 true,
3174 true,
3175 true,
3176 true
3177 };
3178
3179 const struct real_format ieee_extended_intel_96_format =
3180 {
3181 encode_ieee_extended,
3182 decode_ieee_extended,
3183 2,
3184 1,
3185 64,
3186 -16381,
3187 16384,
3188 true,
3189 true,
3190 true,
3191 true,
3192 true
3193 };
3194
3195 const struct real_format ieee_extended_intel_128_format =
3196 {
3197 encode_ieee_extended_128,
3198 decode_ieee_extended_128,
3199 2,
3200 1,
3201 64,
3202 -16381,
3203 16384,
3204 true,
3205 true,
3206 true,
3207 true,
3208 true
3209 };
3210
3211 \f
3212 /* IBM 128-bit extended precision format: a pair of IEEE double precision
3213 numbers whose sum is equal to the extended precision value. The number
3214 with greater magnitude is first. This format has the same magnitude
3215 range as an IEEE double precision value, but effectively 106 bits of
3216 significand precision. Infinity and NaN are represented by their IEEE
3217 double precision value stored in the first number, the second number is
3218 ignored. Zeroes, Infinities, and NaNs are set in both doubles
3219 due to precedent. */
3220
3221 static void encode_ibm_extended PARAMS ((const struct real_format *fmt,
3222 long *, const REAL_VALUE_TYPE *));
3223 static void decode_ibm_extended PARAMS ((const struct real_format *,
3224 REAL_VALUE_TYPE *, const long *));
3225
3226 static void
3227 encode_ibm_extended (fmt, buf, r)
3228 const struct real_format *fmt ATTRIBUTE_UNUSED;
3229 long *buf;
3230 const REAL_VALUE_TYPE *r;
3231 {
3232 REAL_VALUE_TYPE u, v;
3233
3234 switch (r->class)
3235 {
3236 case rvc_zero:
3237 /* Both doubles have sign bit set. */
3238 buf[0] = FLOAT_WORDS_BIG_ENDIAN ? r->sign << 31 : 0;
3239 buf[1] = FLOAT_WORDS_BIG_ENDIAN ? 0 : r->sign << 31;
3240 buf[2] = buf[0];
3241 buf[3] = buf[1];
3242 break;
3243
3244 case rvc_inf:
3245 case rvc_nan:
3246 /* Both doubles set to Inf / NaN. */
3247 encode_ieee_double (&ieee_double_format, &buf[0], r);
3248 buf[2] = buf[0];
3249 buf[3] = buf[1];
3250 return;
3251
3252 case rvc_normal:
3253 /* u = IEEE double precision portion of significand. */
3254 u = *r;
3255 clear_significand_below (&u, SIGNIFICAND_BITS - 53);
3256
3257 /* v = remainder containing additional 53 bits of significand. */
3258 do_add (&v, r, &u, 1);
3259
3260 encode_ieee_double (&ieee_double_format, &buf[0], &u);
3261 encode_ieee_double (&ieee_double_format, &buf[2], &v);
3262 break;
3263
3264 default:
3265 abort ();
3266 }
3267 }
3268
3269 static void
3270 decode_ibm_extended (fmt, r, buf)
3271 const struct real_format *fmt ATTRIBUTE_UNUSED;
3272 REAL_VALUE_TYPE *r;
3273 const long *buf;
3274 {
3275 REAL_VALUE_TYPE u, v;
3276
3277 decode_ieee_double (&ieee_double_format, &u, &buf[0]);
3278
3279 if (u.class != rvc_zero && u.class != rvc_inf && u.class != rvc_nan)
3280 {
3281 decode_ieee_double (&ieee_double_format, &v, &buf[2]);
3282 do_add (r, &u, &v, 0);
3283 }
3284 else
3285 *r = u;
3286 }
3287
3288 const struct real_format ibm_extended_format =
3289 {
3290 encode_ibm_extended,
3291 decode_ibm_extended,
3292 2,
3293 1,
3294 53 + 53,
3295 -1021,
3296 1024,
3297 true,
3298 true,
3299 true,
3300 true,
3301 true
3302 };
3303
3304 \f
3305 /* IEEE quad precision format. */
3306
3307 static void encode_ieee_quad PARAMS ((const struct real_format *fmt,
3308 long *, const REAL_VALUE_TYPE *));
3309 static void decode_ieee_quad PARAMS ((const struct real_format *,
3310 REAL_VALUE_TYPE *, const long *));
3311
3312 static void
3313 encode_ieee_quad (fmt, buf, r)
3314 const struct real_format *fmt;
3315 long *buf;
3316 const REAL_VALUE_TYPE *r;
3317 {
3318 unsigned long image3, image2, image1, image0, exp;
3319 bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
3320 REAL_VALUE_TYPE u;
3321
3322 image3 = r->sign << 31;
3323 image2 = 0;
3324 image1 = 0;
3325 image0 = 0;
3326
3327 rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
3328
3329 switch (r->class)
3330 {
3331 case rvc_zero:
3332 break;
3333
3334 case rvc_inf:
3335 if (fmt->has_inf)
3336 image3 |= 32767 << 16;
3337 else
3338 {
3339 image3 |= 0x7fffffff;
3340 image2 = 0xffffffff;
3341 image1 = 0xffffffff;
3342 image0 = 0xffffffff;
3343 }
3344 break;
3345
3346 case rvc_nan:
3347 if (fmt->has_nans)
3348 {
3349 image3 |= 32767 << 16;
3350
3351 if (HOST_BITS_PER_LONG == 32)
3352 {
3353 image0 = u.sig[0];
3354 image1 = u.sig[1];
3355 image2 = u.sig[2];
3356 image3 |= u.sig[3] & 0xffff;
3357 }
3358 else
3359 {
3360 image0 = u.sig[0];
3361 image1 = image0 >> 31 >> 1;
3362 image2 = u.sig[1];
3363 image3 |= (image2 >> 31 >> 1) & 0xffff;
3364 image0 &= 0xffffffff;
3365 image2 &= 0xffffffff;
3366 }
3367
3368 if (!fmt->qnan_msb_set)
3369 image3 ^= 1 << 15 | 1 << 14;
3370 }
3371 else
3372 {
3373 image3 |= 0x7fffffff;
3374 image2 = 0xffffffff;
3375 image1 = 0xffffffff;
3376 image0 = 0xffffffff;
3377 }
3378 break;
3379
3380 case rvc_normal:
3381 /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3382 whereas the intermediate representation is 0.F x 2**exp.
3383 Which means we're off by one. */
3384 if (denormal)
3385 exp = 0;
3386 else
3387 exp = r->exp + 16383 - 1;
3388 image3 |= exp << 16;
3389
3390 if (HOST_BITS_PER_LONG == 32)
3391 {
3392 image0 = u.sig[0];
3393 image1 = u.sig[1];
3394 image2 = u.sig[2];
3395 image3 |= u.sig[3] & 0xffff;
3396 }
3397 else
3398 {
3399 image0 = u.sig[0];
3400 image1 = image0 >> 31 >> 1;
3401 image2 = u.sig[1];
3402 image3 |= (image2 >> 31 >> 1) & 0xffff;
3403 image0 &= 0xffffffff;
3404 image2 &= 0xffffffff;
3405 }
3406 break;
3407
3408 default:
3409 abort ();
3410 }
3411
3412 if (FLOAT_WORDS_BIG_ENDIAN)
3413 {
3414 buf[0] = image3;
3415 buf[1] = image2;
3416 buf[2] = image1;
3417 buf[3] = image0;
3418 }
3419 else
3420 {
3421 buf[0] = image0;
3422 buf[1] = image1;
3423 buf[2] = image2;
3424 buf[3] = image3;
3425 }
3426 }
3427
3428 static void
3429 decode_ieee_quad (fmt, r, buf)
3430 const struct real_format *fmt;
3431 REAL_VALUE_TYPE *r;
3432 const long *buf;
3433 {
3434 unsigned long image3, image2, image1, image0;
3435 bool sign;
3436 int exp;
3437
3438 if (FLOAT_WORDS_BIG_ENDIAN)
3439 {
3440 image3 = buf[0];
3441 image2 = buf[1];
3442 image1 = buf[2];
3443 image0 = buf[3];
3444 }
3445 else
3446 {
3447 image0 = buf[0];
3448 image1 = buf[1];
3449 image2 = buf[2];
3450 image3 = buf[3];
3451 }
3452 image0 &= 0xffffffff;
3453 image1 &= 0xffffffff;
3454 image2 &= 0xffffffff;
3455
3456 sign = (image3 >> 31) & 1;
3457 exp = (image3 >> 16) & 0x7fff;
3458 image3 &= 0xffff;
3459
3460 memset (r, 0, sizeof (*r));
3461
3462 if (exp == 0)
3463 {
3464 if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
3465 {
3466 r->class = rvc_normal;
3467 r->sign = sign;
3468
3469 r->exp = -16382 + (SIGNIFICAND_BITS - 112);
3470 if (HOST_BITS_PER_LONG == 32)
3471 {
3472 r->sig[0] = image0;
3473 r->sig[1] = image1;
3474 r->sig[2] = image2;
3475 r->sig[3] = image3;
3476 }
3477 else
3478 {
3479 r->sig[0] = (image1 << 31 << 1) | image0;
3480 r->sig[1] = (image3 << 31 << 1) | image2;
3481 }
3482
3483 normalize (r);
3484 }
3485 else if (fmt->has_signed_zero)
3486 r->sign = sign;
3487 }
3488 else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3489 {
3490 if (image3 | image2 | image1 | image0)
3491 {
3492 r->class = rvc_nan;
3493 r->sign = sign;
3494
3495 if (HOST_BITS_PER_LONG == 32)
3496 {
3497 r->sig[0] = image0;
3498 r->sig[1] = image1;
3499 r->sig[2] = image2;
3500 r->sig[3] = image3;
3501 }
3502 else
3503 {
3504 r->sig[0] = (image1 << 31 << 1) | image0;
3505 r->sig[1] = (image3 << 31 << 1) | image2;
3506 }
3507 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3508
3509 if (!fmt->qnan_msb_set)
3510 r->sig[SIGSZ-1] ^= (SIG_MSB >> 1 | SIG_MSB >> 2);
3511 }
3512 else
3513 {
3514 r->class = rvc_inf;
3515 r->sign = sign;
3516 }
3517 }
3518 else
3519 {
3520 r->class = rvc_normal;
3521 r->sign = sign;
3522 r->exp = exp - 16383 + 1;
3523
3524 if (HOST_BITS_PER_LONG == 32)
3525 {
3526 r->sig[0] = image0;
3527 r->sig[1] = image1;
3528 r->sig[2] = image2;
3529 r->sig[3] = image3;
3530 }
3531 else
3532 {
3533 r->sig[0] = (image1 << 31 << 1) | image0;
3534 r->sig[1] = (image3 << 31 << 1) | image2;
3535 }
3536 lshift_significand (r, r, SIGNIFICAND_BITS - 113);
3537 r->sig[SIGSZ-1] |= SIG_MSB;
3538 }
3539 }
3540
3541 const struct real_format ieee_quad_format =
3542 {
3543 encode_ieee_quad,
3544 decode_ieee_quad,
3545 2,
3546 1,
3547 113,
3548 -16381,
3549 16384,
3550 true,
3551 true,
3552 true,
3553 true,
3554 true
3555 };
3556 \f
3557 /* Descriptions of VAX floating point formats can be found beginning at
3558
3559 http://www.openvms.compaq.com:8000/73final/4515/4515pro_013.html#f_floating_point_format
3560
3561 The thing to remember is that they're almost IEEE, except for word
3562 order, exponent bias, and the lack of infinities, nans, and denormals.
3563
3564 We don't implement the H_floating format here, simply because neither
3565 the VAX or Alpha ports use it. */
3566
3567 static void encode_vax_f PARAMS ((const struct real_format *fmt,
3568 long *, const REAL_VALUE_TYPE *));
3569 static void decode_vax_f PARAMS ((const struct real_format *,
3570 REAL_VALUE_TYPE *, const long *));
3571 static void encode_vax_d PARAMS ((const struct real_format *fmt,
3572 long *, const REAL_VALUE_TYPE *));
3573 static void decode_vax_d PARAMS ((const struct real_format *,
3574 REAL_VALUE_TYPE *, const long *));
3575 static void encode_vax_g PARAMS ((const struct real_format *fmt,
3576 long *, const REAL_VALUE_TYPE *));
3577 static void decode_vax_g PARAMS ((const struct real_format *,
3578 REAL_VALUE_TYPE *, const long *));
3579
3580 static void
3581 encode_vax_f (fmt, buf, r)
3582 const struct real_format *fmt ATTRIBUTE_UNUSED;
3583 long *buf;
3584 const REAL_VALUE_TYPE *r;
3585 {
3586 unsigned long sign, exp, sig, image;
3587
3588 sign = r->sign << 15;
3589
3590 switch (r->class)
3591 {
3592 case rvc_zero:
3593 image = 0;
3594 break;
3595
3596 case rvc_inf:
3597 case rvc_nan:
3598 image = 0xffff7fff | sign;
3599 break;
3600
3601 case rvc_normal:
3602 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
3603 exp = r->exp + 128;
3604
3605 image = (sig << 16) & 0xffff0000;
3606 image |= sign;
3607 image |= exp << 7;
3608 image |= sig >> 16;
3609 break;
3610
3611 default:
3612 abort ();
3613 }
3614
3615 buf[0] = image;
3616 }
3617
3618 static void
3619 decode_vax_f (fmt, r, buf)
3620 const struct real_format *fmt ATTRIBUTE_UNUSED;
3621 REAL_VALUE_TYPE *r;
3622 const long *buf;
3623 {
3624 unsigned long image = buf[0] & 0xffffffff;
3625 int exp = (image >> 7) & 0xff;
3626
3627 memset (r, 0, sizeof (*r));
3628
3629 if (exp != 0)
3630 {
3631 r->class = rvc_normal;
3632 r->sign = (image >> 15) & 1;
3633 r->exp = exp - 128;
3634
3635 image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff);
3636 r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
3637 }
3638 }
3639
3640 static void
3641 encode_vax_d (fmt, buf, r)
3642 const struct real_format *fmt ATTRIBUTE_UNUSED;
3643 long *buf;
3644 const REAL_VALUE_TYPE *r;
3645 {
3646 unsigned long image0, image1, sign = r->sign << 15;
3647
3648 switch (r->class)
3649 {
3650 case rvc_zero:
3651 image0 = image1 = 0;
3652 break;
3653
3654 case rvc_inf:
3655 case rvc_nan:
3656 image0 = 0xffff7fff | sign;
3657 image1 = 0xffffffff;
3658 break;
3659
3660 case rvc_normal:
3661 /* Extract the significand into straight hi:lo. */
3662 if (HOST_BITS_PER_LONG == 64)
3663 {
3664 image0 = r->sig[SIGSZ-1];
3665 image1 = (image0 >> (64 - 56)) & 0xffffffff;
3666 image0 = (image0 >> (64 - 56 + 1) >> 31) & 0x7fffff;
3667 }
3668 else
3669 {
3670 image0 = r->sig[SIGSZ-1];
3671 image1 = r->sig[SIGSZ-2];
3672 image1 = (image0 << 24) | (image1 >> 8);
3673 image0 = (image0 >> 8) & 0xffffff;
3674 }
3675
3676 /* Rearrange the half-words of the significand to match the
3677 external format. */
3678 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff007f;
3679 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
3680
3681 /* Add the sign and exponent. */
3682 image0 |= sign;
3683 image0 |= (r->exp + 128) << 7;
3684 break;
3685
3686 default:
3687 abort ();
3688 }
3689
3690 if (FLOAT_WORDS_BIG_ENDIAN)
3691 buf[0] = image1, buf[1] = image0;
3692 else
3693 buf[0] = image0, buf[1] = image1;
3694 }
3695
3696 static void
3697 decode_vax_d (fmt, r, buf)
3698 const struct real_format *fmt ATTRIBUTE_UNUSED;
3699 REAL_VALUE_TYPE *r;
3700 const long *buf;
3701 {
3702 unsigned long image0, image1;
3703 int exp;
3704
3705 if (FLOAT_WORDS_BIG_ENDIAN)
3706 image1 = buf[0], image0 = buf[1];
3707 else
3708 image0 = buf[0], image1 = buf[1];
3709 image0 &= 0xffffffff;
3710 image1 &= 0xffffffff;
3711
3712 exp = (image0 >> 7) & 0x7f;
3713
3714 memset (r, 0, sizeof (*r));
3715
3716 if (exp != 0)
3717 {
3718 r->class = rvc_normal;
3719 r->sign = (image0 >> 15) & 1;
3720 r->exp = exp - 128;
3721
3722 /* Rearrange the half-words of the external format into
3723 proper ascending order. */
3724 image0 = ((image0 & 0x7f) << 16) | ((image0 >> 16) & 0xffff);
3725 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
3726
3727 if (HOST_BITS_PER_LONG == 64)
3728 {
3729 image0 = (image0 << 31 << 1) | image1;
3730 image0 <<= 64 - 56;
3731 image0 |= SIG_MSB;
3732 r->sig[SIGSZ-1] = image0;
3733 }
3734 else
3735 {
3736 r->sig[SIGSZ-1] = image0;
3737 r->sig[SIGSZ-2] = image1;
3738 lshift_significand (r, r, 2*HOST_BITS_PER_LONG - 56);
3739 r->sig[SIGSZ-1] |= SIG_MSB;
3740 }
3741 }
3742 }
3743
3744 static void
3745 encode_vax_g (fmt, buf, r)
3746 const struct real_format *fmt ATTRIBUTE_UNUSED;
3747 long *buf;
3748 const REAL_VALUE_TYPE *r;
3749 {
3750 unsigned long image0, image1, sign = r->sign << 15;
3751
3752 switch (r->class)
3753 {
3754 case rvc_zero:
3755 image0 = image1 = 0;
3756 break;
3757
3758 case rvc_inf:
3759 case rvc_nan:
3760 image0 = 0xffff7fff | sign;
3761 image1 = 0xffffffff;
3762 break;
3763
3764 case rvc_normal:
3765 /* Extract the significand into straight hi:lo. */
3766 if (HOST_BITS_PER_LONG == 64)
3767 {
3768 image0 = r->sig[SIGSZ-1];
3769 image1 = (image0 >> (64 - 53)) & 0xffffffff;
3770 image0 = (image0 >> (64 - 53 + 1) >> 31) & 0xfffff;
3771 }
3772 else
3773 {
3774 image0 = r->sig[SIGSZ-1];
3775 image1 = r->sig[SIGSZ-2];
3776 image1 = (image0 << 21) | (image1 >> 11);
3777 image0 = (image0 >> 11) & 0xfffff;
3778 }
3779
3780 /* Rearrange the half-words of the significand to match the
3781 external format. */
3782 image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff000f;
3783 image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
3784
3785 /* Add the sign and exponent. */
3786 image0 |= sign;
3787 image0 |= (r->exp + 1024) << 4;
3788 break;
3789
3790 default:
3791 abort ();
3792 }
3793
3794 if (FLOAT_WORDS_BIG_ENDIAN)
3795 buf[0] = image1, buf[1] = image0;
3796 else
3797 buf[0] = image0, buf[1] = image1;
3798 }
3799
3800 static void
3801 decode_vax_g (fmt, r, buf)
3802 const struct real_format *fmt ATTRIBUTE_UNUSED;
3803 REAL_VALUE_TYPE *r;
3804 const long *buf;
3805 {
3806 unsigned long image0, image1;
3807 int exp;
3808
3809 if (FLOAT_WORDS_BIG_ENDIAN)
3810 image1 = buf[0], image0 = buf[1];
3811 else
3812 image0 = buf[0], image1 = buf[1];
3813 image0 &= 0xffffffff;
3814 image1 &= 0xffffffff;
3815
3816 exp = (image0 >> 4) & 0x7ff;
3817
3818 memset (r, 0, sizeof (*r));
3819
3820 if (exp != 0)
3821 {
3822 r->class = rvc_normal;
3823 r->sign = (image0 >> 15) & 1;
3824 r->exp = exp - 1024;
3825
3826 /* Rearrange the half-words of the external format into
3827 proper ascending order. */
3828 image0 = ((image0 & 0xf) << 16) | ((image0 >> 16) & 0xffff);
3829 image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
3830
3831 if (HOST_BITS_PER_LONG == 64)
3832 {
3833 image0 = (image0 << 31 << 1) | image1;
3834 image0 <<= 64 - 53;
3835 image0 |= SIG_MSB;
3836 r->sig[SIGSZ-1] = image0;
3837 }
3838 else
3839 {
3840 r->sig[SIGSZ-1] = image0;
3841 r->sig[SIGSZ-2] = image1;
3842 lshift_significand (r, r, 64 - 53);
3843 r->sig[SIGSZ-1] |= SIG_MSB;
3844 }
3845 }
3846 }
3847
3848 const struct real_format vax_f_format =
3849 {
3850 encode_vax_f,
3851 decode_vax_f,
3852 2,
3853 1,
3854 24,
3855 -127,
3856 127,
3857 false,
3858 false,
3859 false,
3860 false,
3861 false
3862 };
3863
3864 const struct real_format vax_d_format =
3865 {
3866 encode_vax_d,
3867 decode_vax_d,
3868 2,
3869 1,
3870 56,
3871 -127,
3872 127,
3873 false,
3874 false,
3875 false,
3876 false,
3877 false
3878 };
3879
3880 const struct real_format vax_g_format =
3881 {
3882 encode_vax_g,
3883 decode_vax_g,
3884 2,
3885 1,
3886 53,
3887 -1023,
3888 1023,
3889 false,
3890 false,
3891 false,
3892 false,
3893 false
3894 };
3895 \f
3896 /* A good reference for these can be found in chapter 9 of
3897 "ESA/390 Principles of Operation", IBM document number SA22-7201-01.
3898 An on-line version can be found here:
3899
3900 http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/DZ9AR001/9.1?DT=19930923083613
3901 */
3902
3903 static void encode_i370_single PARAMS ((const struct real_format *fmt,
3904 long *, const REAL_VALUE_TYPE *));
3905 static void decode_i370_single PARAMS ((const struct real_format *,
3906 REAL_VALUE_TYPE *, const long *));
3907 static void encode_i370_double PARAMS ((const struct real_format *fmt,
3908 long *, const REAL_VALUE_TYPE *));
3909 static void decode_i370_double PARAMS ((const struct real_format *,
3910 REAL_VALUE_TYPE *, const long *));
3911
3912 static void
3913 encode_i370_single (fmt, buf, r)
3914 const struct real_format *fmt ATTRIBUTE_UNUSED;
3915 long *buf;
3916 const REAL_VALUE_TYPE *r;
3917 {
3918 unsigned long sign, exp, sig, image;
3919
3920 sign = r->sign << 31;
3921
3922 switch (r->class)
3923 {
3924 case rvc_zero:
3925 image = 0;
3926 break;
3927
3928 case rvc_inf:
3929 case rvc_nan:
3930 image = 0x7fffffff | sign;
3931 break;
3932
3933 case rvc_normal:
3934 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0xffffff;
3935 exp = ((r->exp / 4) + 64) << 24;
3936 image = sign | exp | sig;
3937 break;
3938
3939 default:
3940 abort ();
3941 }
3942
3943 buf[0] = image;
3944 }
3945
3946 static void
3947 decode_i370_single (fmt, r, buf)
3948 const struct real_format *fmt ATTRIBUTE_UNUSED;
3949 REAL_VALUE_TYPE *r;
3950 const long *buf;
3951 {
3952 unsigned long sign, sig, image = buf[0];
3953 int exp;
3954
3955 sign = (image >> 31) & 1;
3956 exp = (image >> 24) & 0x7f;
3957 sig = image & 0xffffff;
3958
3959 memset (r, 0, sizeof (*r));
3960
3961 if (exp || sig)
3962 {
3963 r->class = rvc_normal;
3964 r->sign = sign;
3965 r->exp = (exp - 64) * 4;
3966 r->sig[SIGSZ-1] = sig << (HOST_BITS_PER_LONG - 24);
3967 normalize (r);
3968 }
3969 }
3970
3971 static void
3972 encode_i370_double (fmt, buf, r)
3973 const struct real_format *fmt ATTRIBUTE_UNUSED;
3974 long *buf;
3975 const REAL_VALUE_TYPE *r;
3976 {
3977 unsigned long sign, exp, image_hi, image_lo;
3978
3979 sign = r->sign << 31;
3980
3981 switch (r->class)
3982 {
3983 case rvc_zero:
3984 image_hi = image_lo = 0;
3985 break;
3986
3987 case rvc_inf:
3988 case rvc_nan:
3989 image_hi = 0x7fffffff | sign;
3990 image_lo = 0xffffffff;
3991 break;
3992
3993 case rvc_normal:
3994 if (HOST_BITS_PER_LONG == 64)
3995 {
3996 image_hi = r->sig[SIGSZ-1];
3997 image_lo = (image_hi >> (64 - 56)) & 0xffffffff;
3998 image_hi = (image_hi >> (64 - 56 + 1) >> 31) & 0xffffff;
3999 }
4000 else
4001 {
4002 image_hi = r->sig[SIGSZ-1];
4003 image_lo = r->sig[SIGSZ-2];
4004 image_lo = (image_lo >> 8) | (image_hi << 24);
4005 image_hi >>= 8;
4006 }
4007
4008 exp = ((r->exp / 4) + 64) << 24;
4009 image_hi |= sign | exp;
4010 break;
4011
4012 default:
4013 abort ();
4014 }
4015
4016 if (FLOAT_WORDS_BIG_ENDIAN)
4017 buf[0] = image_hi, buf[1] = image_lo;
4018 else
4019 buf[0] = image_lo, buf[1] = image_hi;
4020 }
4021
4022 static void
4023 decode_i370_double (fmt, r, buf)
4024 const struct real_format *fmt ATTRIBUTE_UNUSED;
4025 REAL_VALUE_TYPE *r;
4026 const long *buf;
4027 {
4028 unsigned long sign, image_hi, image_lo;
4029 int exp;
4030
4031 if (FLOAT_WORDS_BIG_ENDIAN)
4032 image_hi = buf[0], image_lo = buf[1];
4033 else
4034 image_lo = buf[0], image_hi = buf[1];
4035
4036 sign = (image_hi >> 31) & 1;
4037 exp = (image_hi >> 24) & 0x7f;
4038 image_hi &= 0xffffff;
4039 image_lo &= 0xffffffff;
4040
4041 memset (r, 0, sizeof (*r));
4042
4043 if (exp || image_hi || image_lo)
4044 {
4045 r->class = rvc_normal;
4046 r->sign = sign;
4047 r->exp = (exp - 64) * 4 + (SIGNIFICAND_BITS - 56);
4048
4049 if (HOST_BITS_PER_LONG == 32)
4050 {
4051 r->sig[0] = image_lo;
4052 r->sig[1] = image_hi;
4053 }
4054 else
4055 r->sig[0] = image_lo | (image_hi << 31 << 1);
4056
4057 normalize (r);
4058 }
4059 }
4060
4061 const struct real_format i370_single_format =
4062 {
4063 encode_i370_single,
4064 decode_i370_single,
4065 16,
4066 4,
4067 6,
4068 -64,
4069 63,
4070 false,
4071 false,
4072 false, /* ??? The encoding does allow for "unnormals". */
4073 false, /* ??? The encoding does allow for "unnormals". */
4074 false
4075 };
4076
4077 const struct real_format i370_double_format =
4078 {
4079 encode_i370_double,
4080 decode_i370_double,
4081 16,
4082 4,
4083 14,
4084 -64,
4085 63,
4086 false,
4087 false,
4088 false, /* ??? The encoding does allow for "unnormals". */
4089 false, /* ??? The encoding does allow for "unnormals". */
4090 false
4091 };
4092 \f
4093 /* The "twos-complement" c4x format is officially defined as
4094
4095 x = s(~s).f * 2**e
4096
4097 This is rather misleading. One must remember that F is signed.
4098 A better description would be
4099
4100 x = -1**s * ((s + 1 + .f) * 2**e
4101
4102 So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
4103 that's -1 * (1+1+(-.5)) == -1.5. I think.
4104
4105 The constructions here are taken from Tables 5-1 and 5-2 of the
4106 TMS320C4x User's Guide wherein step-by-step instructions for
4107 conversion from IEEE are presented. That's close enough to our
4108 internal representation so as to make things easy.
4109
4110 See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
4111
4112 static void encode_c4x_single PARAMS ((const struct real_format *fmt,
4113 long *, const REAL_VALUE_TYPE *));
4114 static void decode_c4x_single PARAMS ((const struct real_format *,
4115 REAL_VALUE_TYPE *, const long *));
4116 static void encode_c4x_extended PARAMS ((const struct real_format *fmt,
4117 long *, const REAL_VALUE_TYPE *));
4118 static void decode_c4x_extended PARAMS ((const struct real_format *,
4119 REAL_VALUE_TYPE *, const long *));
4120
4121 static void
4122 encode_c4x_single (fmt, buf, r)
4123 const struct real_format *fmt ATTRIBUTE_UNUSED;
4124 long *buf;
4125 const REAL_VALUE_TYPE *r;
4126 {
4127 unsigned long image, exp, sig;
4128
4129 switch (r->class)
4130 {
4131 case rvc_zero:
4132 exp = -128;
4133 sig = 0;
4134 break;
4135
4136 case rvc_inf:
4137 case rvc_nan:
4138 exp = 127;
4139 sig = 0x800000 - r->sign;
4140 break;
4141
4142 case rvc_normal:
4143 exp = r->exp - 1;
4144 sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
4145 if (r->sign)
4146 {
4147 if (sig)
4148 sig = -sig;
4149 else
4150 exp--;
4151 sig |= 0x800000;
4152 }
4153 break;
4154
4155 default:
4156 abort ();
4157 }
4158
4159 image = ((exp & 0xff) << 24) | (sig & 0xffffff);
4160 buf[0] = image;
4161 }
4162
4163 static void
4164 decode_c4x_single (fmt, r, buf)
4165 const struct real_format *fmt ATTRIBUTE_UNUSED;
4166 REAL_VALUE_TYPE *r;
4167 const long *buf;
4168 {
4169 unsigned long image = buf[0];
4170 unsigned long sig;
4171 int exp, sf;
4172
4173 exp = (((image >> 24) & 0xff) ^ 0x80) - 0x80;
4174 sf = ((image & 0xffffff) ^ 0x800000) - 0x800000;
4175
4176 memset (r, 0, sizeof (*r));
4177
4178 if (exp != -128)
4179 {
4180 r->class = rvc_normal;
4181
4182 sig = sf & 0x7fffff;
4183 if (sf < 0)
4184 {
4185 r->sign = 1;
4186 if (sig)
4187 sig = -sig;
4188 else
4189 exp++;
4190 }
4191 sig = (sig << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
4192
4193 r->exp = exp + 1;
4194 r->sig[SIGSZ-1] = sig;
4195 }
4196 }
4197
4198 static void
4199 encode_c4x_extended (fmt, buf, r)
4200 const struct real_format *fmt ATTRIBUTE_UNUSED;
4201 long *buf;
4202 const REAL_VALUE_TYPE *r;
4203 {
4204 unsigned long exp, sig;
4205
4206 switch (r->class)
4207 {
4208 case rvc_zero:
4209 exp = -128;
4210 sig = 0;
4211 break;
4212
4213 case rvc_inf:
4214 case rvc_nan:
4215 exp = 127;
4216 sig = 0x80000000 - r->sign;
4217 break;
4218
4219 case rvc_normal:
4220 exp = r->exp - 1;
4221
4222 sig = r->sig[SIGSZ-1];
4223 if (HOST_BITS_PER_LONG == 64)
4224 sig = sig >> 1 >> 31;
4225 sig &= 0x7fffffff;
4226
4227 if (r->sign)
4228 {
4229 if (sig)
4230 sig = -sig;
4231 else
4232 exp--;
4233 sig |= 0x80000000;
4234 }
4235 break;
4236
4237 default:
4238 abort ();
4239 }
4240
4241 exp = (exp & 0xff) << 24;
4242 sig &= 0xffffffff;
4243
4244 if (FLOAT_WORDS_BIG_ENDIAN)
4245 buf[0] = exp, buf[1] = sig;
4246 else
4247 buf[0] = sig, buf[0] = exp;
4248 }
4249
4250 static void
4251 decode_c4x_extended (fmt, r, buf)
4252 const struct real_format *fmt ATTRIBUTE_UNUSED;
4253 REAL_VALUE_TYPE *r;
4254 const long *buf;
4255 {
4256 unsigned long sig;
4257 int exp, sf;
4258
4259 if (FLOAT_WORDS_BIG_ENDIAN)
4260 exp = buf[0], sf = buf[1];
4261 else
4262 sf = buf[0], exp = buf[1];
4263
4264 exp = (((exp >> 24) & 0xff) & 0x80) - 0x80;
4265 sf = ((sf & 0xffffffff) ^ 0x80000000) - 0x80000000;
4266
4267 memset (r, 0, sizeof (*r));
4268
4269 if (exp != -128)
4270 {
4271 r->class = rvc_normal;
4272
4273 sig = sf & 0x7fffffff;
4274 if (sf < 0)
4275 {
4276 r->sign = 1;
4277 if (sig)
4278 sig = -sig;
4279 else
4280 exp++;
4281 }
4282 if (HOST_BITS_PER_LONG == 64)
4283 sig = sig << 1 << 31;
4284 sig |= SIG_MSB;
4285
4286 r->exp = exp + 1;
4287 r->sig[SIGSZ-1] = sig;
4288 }
4289 }
4290
4291 const struct real_format c4x_single_format =
4292 {
4293 encode_c4x_single,
4294 decode_c4x_single,
4295 2,
4296 1,
4297 24,
4298 -126,
4299 128,
4300 false,
4301 false,
4302 false,
4303 false,
4304 false
4305 };
4306
4307 const struct real_format c4x_extended_format =
4308 {
4309 encode_c4x_extended,
4310 decode_c4x_extended,
4311 2,
4312 1,
4313 32,
4314 -126,
4315 128,
4316 false,
4317 false,
4318 false,
4319 false,
4320 false
4321 };
4322
4323 \f
4324 /* A synthetic "format" for internal arithmetic. It's the size of the
4325 internal significand minus the two bits needed for proper rounding.
4326 The encode and decode routines exist only to satisfy our paranoia
4327 harness. */
4328
4329 static void encode_internal PARAMS ((const struct real_format *fmt,
4330 long *, const REAL_VALUE_TYPE *));
4331 static void decode_internal PARAMS ((const struct real_format *,
4332 REAL_VALUE_TYPE *, const long *));
4333
4334 static void
4335 encode_internal (fmt, buf, r)
4336 const struct real_format *fmt ATTRIBUTE_UNUSED;
4337 long *buf;
4338 const REAL_VALUE_TYPE *r;
4339 {
4340 memcpy (buf, r, sizeof (*r));
4341 }
4342
4343 static void
4344 decode_internal (fmt, r, buf)
4345 const struct real_format *fmt ATTRIBUTE_UNUSED;
4346 REAL_VALUE_TYPE *r;
4347 const long *buf;
4348 {
4349 memcpy (r, buf, sizeof (*r));
4350 }
4351
4352 const struct real_format real_internal_format =
4353 {
4354 encode_internal,
4355 decode_internal,
4356 2,
4357 1,
4358 SIGNIFICAND_BITS - 2,
4359 -MAX_EXP,
4360 MAX_EXP,
4361 true,
4362 true,
4363 false,
4364 true,
4365 true
4366 };
4367 \f
4368 /* Set up default mode to format mapping for IEEE. Everyone else has
4369 to set these values in OVERRIDE_OPTIONS. */
4370
4371 const struct real_format *real_format_for_mode[TFmode - QFmode + 1] =
4372 {
4373 NULL, /* QFmode */
4374 NULL, /* HFmode */
4375 NULL, /* TQFmode */
4376 &ieee_single_format, /* SFmode */
4377 &ieee_double_format, /* DFmode */
4378
4379 /* We explicitly don't handle XFmode. There are two formats,
4380 pretty much equally common. Choose one in OVERRIDE_OPTIONS. */
4381 NULL, /* XFmode */
4382 &ieee_quad_format /* TFmode */
4383 };