1 /* atof_ieee.c - turn a Flonum into an IEEE floating point number
2 Copyright 1987, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001, 2005
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
24 /* Flonums returned here. */
25 extern FLONUM_TYPE generic_floating_point_number;
27 extern const char EXP_CHARS[];
28 /* Precision in LittleNums. */
29 /* Don't count the gap in the m68k extended precision format. */
30 #define MAX_PRECISION 5
36 /* Length in LittleNums of guard bits. */
39 #ifndef TC_LARGEST_EXPONENT_IS_NORMAL
40 #define TC_LARGEST_EXPONENT_IS_NORMAL(PRECISION) 0
43 static const unsigned long mask[] =
80 static int bits_left_in_littlenum;
81 static int littlenums_left;
82 static LITTLENUM_TYPE *littlenum_pointer;
85 next_bits (int number_of_bits)
92 if (number_of_bits >= bits_left_in_littlenum)
94 return_value = mask[bits_left_in_littlenum] & *littlenum_pointer;
95 number_of_bits -= bits_left_in_littlenum;
96 return_value <<= number_of_bits;
98 if (--littlenums_left)
100 bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
103 (*littlenum_pointer >> bits_left_in_littlenum)
104 & mask[number_of_bits];
109 bits_left_in_littlenum -= number_of_bits;
111 mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum);
116 /* Num had better be less than LITTLENUM_NUMBER_OF_BITS. */
121 if (!littlenums_left)
125 bits_left_in_littlenum = num;
127 else if (bits_left_in_littlenum + num > LITTLENUM_NUMBER_OF_BITS)
129 bits_left_in_littlenum =
130 num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum);
135 bits_left_in_littlenum += num;
139 make_invalid_floating_point_number (LITTLENUM_TYPE *words)
141 as_bad (_("cannot create floating-point number"));
142 /* Zero the leftmost bit. */
143 words[0] = (LITTLENUM_TYPE) ((unsigned) -1) >> 1;
144 words[1] = (LITTLENUM_TYPE) -1;
145 words[2] = (LITTLENUM_TYPE) -1;
146 words[3] = (LITTLENUM_TYPE) -1;
147 words[4] = (LITTLENUM_TYPE) -1;
148 words[5] = (LITTLENUM_TYPE) -1;
151 /* Warning: This returns 16-bit LITTLENUMs. It is up to the caller to
152 figure out any alignment problems and to conspire for the
153 bytes/word to be emitted in the right order. Bigendians beware! */
155 /* Note that atof-ieee always has X and P precisions enabled. it is up
156 to md_atof to filter them out if the target machine does not support
159 /* Returns pointer past text consumed. */
162 atof_ieee (char *str, /* Text to convert to binary. */
163 int what_kind, /* 'd', 'f', 'g', 'h'. */
164 LITTLENUM_TYPE *words) /* Build the binary here. */
166 /* Extra bits for zeroed low-order bits.
167 The 1st MAX_PRECISION are zeroed, the last contain flonum bits. */
168 static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
170 /* Number of 16-bit words in the format. */
173 FLONUM_TYPE save_gen_flonum;
175 /* We have to save the generic_floating_point_number because it
176 contains storage allocation about the array of LITTLENUMs where
177 the value is actually stored. We will allocate our own array of
178 littlenums below, but have to restore the global one on exit. */
179 save_gen_flonum = generic_floating_point_number;
182 generic_floating_point_number.low = bits + MAX_PRECISION;
183 generic_floating_point_number.high = NULL;
184 generic_floating_point_number.leader = NULL;
185 generic_floating_point_number.exponent = 0;
186 generic_floating_point_number.sign = '\0';
188 /* Use more LittleNums than seems necessary: the highest flonum may
189 have 15 leading 0 bits, so could be useless. */
191 memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION);
199 precision = F_PRECISION;
207 precision = D_PRECISION;
215 precision = X_PRECISION;
222 precision = P_PRECISION;
227 make_invalid_floating_point_number (words);
231 generic_floating_point_number.high
232 = generic_floating_point_number.low + precision - 1 + GUARD;
234 if (atof_generic (&return_value, ".", EXP_CHARS,
235 &generic_floating_point_number))
237 make_invalid_floating_point_number (words);
240 gen_to_words (words, precision, exponent_bits);
242 /* Restore the generic_floating_point_number's storage alloc (and
244 generic_floating_point_number = save_gen_flonum;
249 /* Turn generic_floating_point_number into a real float/double/extended. */
252 gen_to_words (LITTLENUM_TYPE *words, int precision, long exponent_bits)
254 int return_value = 0;
260 int exponent_skippage;
261 LITTLENUM_TYPE word1;
263 LITTLENUM_TYPE *words_end;
265 words_end = words + precision;
267 if (precision == X_PRECISION)
268 /* On the m68k the extended precision format has a gap of 16 bits
269 between the exponent and the mantissa. */
273 if (generic_floating_point_number.low > generic_floating_point_number.leader)
276 if (generic_floating_point_number.sign == '+')
280 memset (&words[1], '\0',
281 (words_end - words - 1) * sizeof (LITTLENUM_TYPE));
285 /* NaN: Do the right thing. */
286 if (generic_floating_point_number.sign == 0)
288 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
289 as_warn ("NaNs are not supported by this target\n");
290 if (precision == F_PRECISION)
295 else if (precision == X_PRECISION)
304 #else /* ! TC_M68K */
311 #else /* ! TC_I386 */
313 #endif /* ! TC_I386 */
314 #endif /* ! TC_M68K */
325 else if (generic_floating_point_number.sign == 'P')
327 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
328 as_warn ("Infinities are not supported by this target\n");
330 /* +INF: Do the right thing. */
331 if (precision == F_PRECISION)
336 else if (precision == X_PRECISION)
345 #else /* ! TC_M68K */
352 #else /* ! TC_I386 */
354 #endif /* ! TC_I386 */
355 #endif /* ! TC_M68K */
366 else if (generic_floating_point_number.sign == 'N')
368 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
369 as_warn ("Infinities are not supported by this target\n");
372 if (precision == F_PRECISION)
377 else if (precision == X_PRECISION)
386 #else /* ! TC_M68K */
393 #else /* ! TC_I386 */
395 #endif /* ! TC_I386 */
396 #endif /* ! TC_M68K */
408 /* The floating point formats we support have:
410 Bits 14:n are excess-whatever exponent.
411 Bits n-1:0 (if any) are most significant bits of fraction.
412 Bits 15:0 of the next word(s) are the next most significant bits.
414 So we need: number of bits of exponent, number of bits of
416 bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
417 littlenum_pointer = generic_floating_point_number.leader;
419 + generic_floating_point_number.leader
420 - generic_floating_point_number.low);
422 /* Seek (and forget) 1st significant bit. */
423 for (exponent_skippage = 0; !next_bits (1); ++exponent_skippage)
425 exponent_1 = (generic_floating_point_number.exponent
426 + generic_floating_point_number.leader
428 - generic_floating_point_number.low);
430 /* Radix LITTLENUM_RADIX, point just higher than
431 generic_floating_point_number.leader. */
432 exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
435 exponent_3 = exponent_2 - exponent_skippage;
437 /* Forget leading zeros, forget 1st bit. */
438 exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);
440 /* Offset exponent. */
443 /* Word 1. Sign, exponent and perhaps high bits. */
444 word1 = ((generic_floating_point_number.sign == '+')
446 : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
448 /* Assume 2's complement integers. */
455 num_bits = -exponent_4;
457 LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits);
459 if (precision == X_PRECISION && exponent_bits == 15)
461 /* On the i386 a denormalized extended precision float is
462 shifted down by one, effectively decreasing the exponent
469 if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits)
471 /* Bigger than one littlenum. */
472 num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits;
474 if (num_bits + exponent_bits + 1
475 > precision * LITTLENUM_NUMBER_OF_BITS)
477 /* Exponent overflow. */
478 make_invalid_floating_point_number (words);
482 if (precision == X_PRECISION && exponent_bits == 15)
485 while (num_bits >= LITTLENUM_NUMBER_OF_BITS)
487 num_bits -= LITTLENUM_NUMBER_OF_BITS;
491 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - (num_bits));
495 if (precision == X_PRECISION && exponent_bits == 15)
501 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - num_bits);
505 word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1)
506 - (exponent_bits + num_bits));
510 while (lp < words_end)
511 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
513 /* Round the mantissa up, but don't change the number. */
517 if (prec_bits >= LITTLENUM_NUMBER_OF_BITS)
523 tmp_bits = prec_bits;
524 while (tmp_bits > LITTLENUM_NUMBER_OF_BITS)
526 if (lp[n] != (LITTLENUM_TYPE) - 1)
529 tmp_bits -= LITTLENUM_NUMBER_OF_BITS;
531 if (tmp_bits > LITTLENUM_NUMBER_OF_BITS
532 || (lp[n] & mask[tmp_bits]) != mask[tmp_bits]
533 || (prec_bits != (precision * LITTLENUM_NUMBER_OF_BITS
536 /* An extended precision float with only the integer
537 bit set would be invalid. That must be converted
538 to the smallest normalized number. */
539 && !(precision == X_PRECISION
540 && prec_bits == (precision * LITTLENUM_NUMBER_OF_BITS
541 - exponent_bits - 2))
547 for (carry = 1; carry && (lp >= words); lp--)
551 carry >>= LITTLENUM_NUMBER_OF_BITS;
556 /* This is an overflow of the denormal numbers. We
557 need to forget what we have produced, and instead
558 generate the smallest normalized number. */
560 word1 = ((generic_floating_point_number.sign == '+')
562 : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
564 << ((LITTLENUM_NUMBER_OF_BITS - 1)
568 /* Set the integer bit in the extended precision format.
569 This cannot happen on the m68k where the mantissa
570 just overflows into the integer bit above. */
571 if (precision == X_PRECISION)
572 *lp++ = 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
574 while (lp < words_end)
584 else if ((unsigned long) exponent_4 > mask[exponent_bits]
585 || (! TC_LARGEST_EXPONENT_IS_NORMAL (precision)
586 && (unsigned long) exponent_4 == mask[exponent_bits]))
588 /* Exponent overflow. Lose immediately. */
590 /* We leave return_value alone: admit we read the
591 number, but return a floating exception
592 because we can't encode the number. */
593 make_invalid_floating_point_number (words);
598 word1 |= (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits))
599 | next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits);
604 /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the
605 middle. Either way, it is then followed by a 1 bit. */
606 if (exponent_bits == 15 && precision == X_PRECISION)
611 *lp++ = (1 << (LITTLENUM_NUMBER_OF_BITS - 1)
612 | next_bits (LITTLENUM_NUMBER_OF_BITS - 1));
615 /* The rest of the words are just mantissa bits. */
616 while (lp < words_end)
617 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
622 /* Since the NEXT bit is a 1, round UP the mantissa.
623 The cunning design of these hidden-1 floats permits
624 us to let the mantissa overflow into the exponent, and
625 it 'does the right thing'. However, we lose if the
626 highest-order bit of the lowest-order word flips.
629 /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
630 Please allow at least 1 more bit in carry than is in a LITTLENUM.
631 We need that extra bit to hold a carry during a LITTLENUM carry
632 propagation. Another extra bit (kept 0) will assure us that we
633 don't get a sticky sign bit after shifting right, and that
634 permits us to propagate the carry without any masking of bits.
636 for (carry = 1, lp--; carry; lp--)
640 carry >>= LITTLENUM_NUMBER_OF_BITS;
644 if (precision == X_PRECISION && exponent_bits == 15)
646 /* Extended precision numbers have an explicit integer bit
647 that we may have to restore. */
651 /* On the m68k there is a gap of 16 bits. We must
652 explicitly propagate the carry into the exponent. */
653 words[0] += words[1];
657 /* Put back the integer bit. */
658 lp[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
661 if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)))
663 /* We leave return_value alone: admit we read the number,
664 but return a floating exception because we can't encode
666 *words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1));
678 LITTLENUM_TYPE arr[10];
681 static char sbuf[40];
685 f = generic_floating_point_number;
686 generic_floating_point_number = *gen;
688 gen_to_words (&arr[0], 4, 11);
689 memcpy (&dv, &arr[0], sizeof (double));
690 sprintf (sbuf, "%x %x %x %x %.14G ", arr[0], arr[1], arr[2], arr[3], dv);
691 gen_to_words (&arr[0], 2, 8);
692 memcpy (&fv, &arr[0], sizeof (float));
693 sprintf (sbuf + strlen (sbuf), "%x %x %.12g\n", arr[0], arr[1], fv);
696 generic_floating_point_number = f;