1 /* atof_ieee.c - turn a Flonum into an IEEE floating point number
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* Flonums returned here. */
24 extern FLONUM_TYPE generic_floating_point_number
;
26 extern const char EXP_CHARS
[];
27 /* Precision in LittleNums. */
28 /* Don't count the gap in the m68k extended precision format. */
29 #define MAX_PRECISION 5
35 /* Length in LittleNums of guard bits. */
38 #ifndef TC_LARGEST_EXPONENT_IS_NORMAL
39 #define TC_LARGEST_EXPONENT_IS_NORMAL(PRECISION) 0
42 static const unsigned long mask
[] =
79 static int bits_left_in_littlenum
;
80 static int littlenums_left
;
81 static LITTLENUM_TYPE
*littlenum_pointer
;
84 next_bits (int number_of_bits
)
91 if (number_of_bits
>= bits_left_in_littlenum
)
93 return_value
= mask
[bits_left_in_littlenum
] & *littlenum_pointer
;
94 number_of_bits
-= bits_left_in_littlenum
;
95 return_value
<<= number_of_bits
;
97 if (--littlenums_left
)
99 bits_left_in_littlenum
= LITTLENUM_NUMBER_OF_BITS
- number_of_bits
;
102 (*littlenum_pointer
>> bits_left_in_littlenum
)
103 & mask
[number_of_bits
];
108 bits_left_in_littlenum
-= number_of_bits
;
110 mask
[number_of_bits
] & (*littlenum_pointer
>> bits_left_in_littlenum
);
115 /* Num had better be less than LITTLENUM_NUMBER_OF_BITS. */
120 if (!littlenums_left
)
124 bits_left_in_littlenum
= num
;
126 else if (bits_left_in_littlenum
+ num
> LITTLENUM_NUMBER_OF_BITS
)
128 bits_left_in_littlenum
=
129 num
- (LITTLENUM_NUMBER_OF_BITS
- bits_left_in_littlenum
);
134 bits_left_in_littlenum
+= num
;
138 make_invalid_floating_point_number (LITTLENUM_TYPE
*words
)
140 as_bad (_("cannot create floating-point number"));
141 /* Zero the leftmost bit. */
142 words
[0] = (LITTLENUM_TYPE
) ((unsigned) -1) >> 1;
143 words
[1] = (LITTLENUM_TYPE
) -1;
144 words
[2] = (LITTLENUM_TYPE
) -1;
145 words
[3] = (LITTLENUM_TYPE
) -1;
146 words
[4] = (LITTLENUM_TYPE
) -1;
147 words
[5] = (LITTLENUM_TYPE
) -1;
150 /* Warning: This returns 16-bit LITTLENUMs. It is up to the caller to
151 figure out any alignment problems and to conspire for the
152 bytes/word to be emitted in the right order. Bigendians beware! */
154 /* Note that atof-ieee always has X and P precisions enabled. it is up
155 to md_atof to filter them out if the target machine does not support
158 /* Returns pointer past text consumed. */
161 atof_ieee (char *str
, /* Text to convert to binary. */
162 int what_kind
, /* 'd', 'f', 'x', 'p'. */
163 LITTLENUM_TYPE
*words
) /* Build the binary here. */
165 /* Extra bits for zeroed low-order bits.
166 The 1st MAX_PRECISION are zeroed, the last contain flonum bits. */
167 static LITTLENUM_TYPE bits
[MAX_PRECISION
+ MAX_PRECISION
+ GUARD
];
169 /* Number of 16-bit words in the format. */
172 FLONUM_TYPE save_gen_flonum
;
174 /* We have to save the generic_floating_point_number because it
175 contains storage allocation about the array of LITTLENUMs where
176 the value is actually stored. We will allocate our own array of
177 littlenums below, but have to restore the global one on exit. */
178 save_gen_flonum
= generic_floating_point_number
;
181 generic_floating_point_number
.low
= bits
+ MAX_PRECISION
;
182 generic_floating_point_number
.high
= NULL
;
183 generic_floating_point_number
.leader
= NULL
;
184 generic_floating_point_number
.exponent
= 0;
185 generic_floating_point_number
.sign
= '\0';
187 /* Use more LittleNums than seems necessary: the highest flonum may
188 have 15 leading 0 bits, so could be useless. */
190 memset (bits
, '\0', sizeof (LITTLENUM_TYPE
) * MAX_PRECISION
);
198 precision
= F_PRECISION
;
206 precision
= D_PRECISION
;
214 precision
= X_PRECISION
;
220 precision
= P_PRECISION
;
225 make_invalid_floating_point_number (words
);
229 generic_floating_point_number
.high
230 = generic_floating_point_number
.low
+ precision
- 1 + GUARD
;
232 if (atof_generic (&return_value
, ".", EXP_CHARS
,
233 &generic_floating_point_number
))
235 make_invalid_floating_point_number (words
);
238 gen_to_words (words
, precision
, exponent_bits
);
240 /* Restore the generic_floating_point_number's storage alloc (and
242 generic_floating_point_number
= save_gen_flonum
;
247 /* Turn generic_floating_point_number into a real float/double/extended. */
250 gen_to_words (LITTLENUM_TYPE
*words
, int precision
, long exponent_bits
)
252 int return_value
= 0;
258 int exponent_skippage
;
259 LITTLENUM_TYPE word1
;
261 LITTLENUM_TYPE
*words_end
;
263 words_end
= words
+ precision
;
265 if (precision
== X_PRECISION
)
266 /* On the m68k the extended precision format has a gap of 16 bits
267 between the exponent and the mantissa. */
271 if (generic_floating_point_number
.low
> generic_floating_point_number
.leader
)
274 if (generic_floating_point_number
.sign
== '+')
278 memset (&words
[1], '\0',
279 (words_end
- words
- 1) * sizeof (LITTLENUM_TYPE
));
283 /* NaN: Do the right thing. */
284 if (generic_floating_point_number
.sign
== 0)
286 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision
))
287 as_warn (_("NaNs are not supported by this target\n"));
288 if (precision
== F_PRECISION
)
293 else if (precision
== X_PRECISION
)
302 #else /* ! TC_M68K */
309 #else /* ! TC_I386 */
311 #endif /* ! TC_I386 */
312 #endif /* ! TC_M68K */
323 else if (generic_floating_point_number
.sign
== 'P')
325 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision
))
326 as_warn (_("Infinities are not supported by this target\n"));
328 /* +INF: Do the right thing. */
329 if (precision
== F_PRECISION
)
334 else if (precision
== X_PRECISION
)
343 #else /* ! TC_M68K */
350 #else /* ! TC_I386 */
352 #endif /* ! TC_I386 */
353 #endif /* ! TC_M68K */
364 else if (generic_floating_point_number
.sign
== 'N')
366 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision
))
367 as_warn (_("Infinities are not supported by this target\n"));
370 if (precision
== F_PRECISION
)
375 else if (precision
== X_PRECISION
)
384 #else /* ! TC_M68K */
391 #else /* ! TC_I386 */
393 #endif /* ! TC_I386 */
394 #endif /* ! TC_M68K */
406 /* The floating point formats we support have:
408 Bits 14:n are excess-whatever exponent.
409 Bits n-1:0 (if any) are most significant bits of fraction.
410 Bits 15:0 of the next word(s) are the next most significant bits.
412 So we need: number of bits of exponent, number of bits of
414 bits_left_in_littlenum
= LITTLENUM_NUMBER_OF_BITS
;
415 littlenum_pointer
= generic_floating_point_number
.leader
;
417 + generic_floating_point_number
.leader
418 - generic_floating_point_number
.low
);
420 /* Seek (and forget) 1st significant bit. */
421 for (exponent_skippage
= 0; !next_bits (1); ++exponent_skippage
);
422 exponent_1
= (generic_floating_point_number
.exponent
423 + generic_floating_point_number
.leader
425 - generic_floating_point_number
.low
);
427 /* Radix LITTLENUM_RADIX, point just higher than
428 generic_floating_point_number.leader. */
429 exponent_2
= exponent_1
* LITTLENUM_NUMBER_OF_BITS
;
432 exponent_3
= exponent_2
- exponent_skippage
;
434 /* Forget leading zeros, forget 1st bit. */
435 exponent_4
= exponent_3
+ ((1 << (exponent_bits
- 1)) - 2);
437 /* Offset exponent. */
440 /* Word 1. Sign, exponent and perhaps high bits. */
441 word1
= ((generic_floating_point_number
.sign
== '+')
443 : (1 << (LITTLENUM_NUMBER_OF_BITS
- 1)));
445 /* Assume 2's complement integers. */
452 num_bits
= -exponent_4
;
454 LITTLENUM_NUMBER_OF_BITS
* precision
- (exponent_bits
+ 1 + num_bits
);
456 if (precision
== X_PRECISION
&& exponent_bits
== 15)
458 /* On the i386 a denormalized extended precision float is
459 shifted down by one, effectively decreasing the exponent
466 if (num_bits
>= LITTLENUM_NUMBER_OF_BITS
- exponent_bits
)
468 /* Bigger than one littlenum. */
469 num_bits
-= (LITTLENUM_NUMBER_OF_BITS
- 1) - exponent_bits
;
471 if (num_bits
+ exponent_bits
+ 1
472 > precision
* LITTLENUM_NUMBER_OF_BITS
)
474 /* Exponent overflow. */
475 make_invalid_floating_point_number (words
);
479 if (precision
== X_PRECISION
&& exponent_bits
== 15)
482 while (num_bits
>= LITTLENUM_NUMBER_OF_BITS
)
484 num_bits
-= LITTLENUM_NUMBER_OF_BITS
;
488 *lp
++ = next_bits (LITTLENUM_NUMBER_OF_BITS
- (num_bits
));
492 if (precision
== X_PRECISION
&& exponent_bits
== 15)
498 *lp
++ = next_bits (LITTLENUM_NUMBER_OF_BITS
- num_bits
);
502 word1
|= next_bits ((LITTLENUM_NUMBER_OF_BITS
- 1)
503 - (exponent_bits
+ num_bits
));
507 while (lp
< words_end
)
508 *lp
++ = next_bits (LITTLENUM_NUMBER_OF_BITS
);
510 /* Round the mantissa up, but don't change the number. */
514 if (prec_bits
>= LITTLENUM_NUMBER_OF_BITS
)
520 tmp_bits
= prec_bits
;
521 while (tmp_bits
> LITTLENUM_NUMBER_OF_BITS
)
523 if (lp
[n
] != (LITTLENUM_TYPE
) - 1)
526 tmp_bits
-= LITTLENUM_NUMBER_OF_BITS
;
528 if (tmp_bits
> LITTLENUM_NUMBER_OF_BITS
529 || (lp
[n
] & mask
[tmp_bits
]) != mask
[tmp_bits
]
530 || (prec_bits
!= (precision
* LITTLENUM_NUMBER_OF_BITS
533 /* An extended precision float with only the integer
534 bit set would be invalid. That must be converted
535 to the smallest normalized number. */
536 && !(precision
== X_PRECISION
537 && prec_bits
== (precision
* LITTLENUM_NUMBER_OF_BITS
538 - exponent_bits
- 2))
544 for (carry
= 1; carry
&& (lp
>= words
); lp
--)
548 carry
>>= LITTLENUM_NUMBER_OF_BITS
;
553 /* This is an overflow of the denormal numbers. We
554 need to forget what we have produced, and instead
555 generate the smallest normalized number. */
557 word1
= ((generic_floating_point_number
.sign
== '+')
559 : (1 << (LITTLENUM_NUMBER_OF_BITS
- 1)));
561 << ((LITTLENUM_NUMBER_OF_BITS
- 1)
565 /* Set the integer bit in the extended precision format.
566 This cannot happen on the m68k where the mantissa
567 just overflows into the integer bit above. */
568 if (precision
== X_PRECISION
)
569 *lp
++ = 1 << (LITTLENUM_NUMBER_OF_BITS
- 1);
571 while (lp
< words_end
)
581 else if ((unsigned long) exponent_4
> mask
[exponent_bits
]
582 || (! TC_LARGEST_EXPONENT_IS_NORMAL (precision
)
583 && (unsigned long) exponent_4
== mask
[exponent_bits
]))
585 /* Exponent overflow. Lose immediately. */
587 /* We leave return_value alone: admit we read the
588 number, but return a floating exception
589 because we can't encode the number. */
590 make_invalid_floating_point_number (words
);
595 word1
|= (exponent_4
<< ((LITTLENUM_NUMBER_OF_BITS
- 1) - exponent_bits
))
596 | next_bits ((LITTLENUM_NUMBER_OF_BITS
- 1) - exponent_bits
);
601 /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the
602 middle. Either way, it is then followed by a 1 bit. */
603 if (exponent_bits
== 15 && precision
== X_PRECISION
)
608 *lp
++ = (1 << (LITTLENUM_NUMBER_OF_BITS
- 1)
609 | next_bits (LITTLENUM_NUMBER_OF_BITS
- 1));
612 /* The rest of the words are just mantissa bits. */
613 while (lp
< words_end
)
614 *lp
++ = next_bits (LITTLENUM_NUMBER_OF_BITS
);
619 /* Since the NEXT bit is a 1, round UP the mantissa.
620 The cunning design of these hidden-1 floats permits
621 us to let the mantissa overflow into the exponent, and
622 it 'does the right thing'. However, we lose if the
623 highest-order bit of the lowest-order word flips.
626 /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
627 Please allow at least 1 more bit in carry than is in a LITTLENUM.
628 We need that extra bit to hold a carry during a LITTLENUM carry
629 propagation. Another extra bit (kept 0) will assure us that we
630 don't get a sticky sign bit after shifting right, and that
631 permits us to propagate the carry without any masking of bits.
633 for (carry
= 1, lp
--; carry
; lp
--)
637 carry
>>= LITTLENUM_NUMBER_OF_BITS
;
641 if (precision
== X_PRECISION
&& exponent_bits
== 15)
643 /* Extended precision numbers have an explicit integer bit
644 that we may have to restore. */
648 /* On the m68k there is a gap of 16 bits. We must
649 explicitly propagate the carry into the exponent. */
650 words
[0] += words
[1];
654 /* Put back the integer bit. */
655 lp
[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS
- 1);
658 if ((word1
^ *words
) & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1)))
660 /* We leave return_value alone: admit we read the number,
661 but return a floating exception because we can't encode
663 *words
&= ~(1 << (LITTLENUM_NUMBER_OF_BITS
- 1));
675 LITTLENUM_TYPE arr
[10];
678 static char sbuf
[40];
682 f
= generic_floating_point_number
;
683 generic_floating_point_number
= *gen
;
685 gen_to_words (&arr
[0], 4, 11);
686 memcpy (&dv
, &arr
[0], sizeof (double));
687 sprintf (sbuf
, "%x %x %x %x %.14G ", arr
[0], arr
[1], arr
[2], arr
[3], dv
);
688 gen_to_words (&arr
[0], 2, 8);
689 memcpy (&fv
, &arr
[0], sizeof (float));
690 sprintf (sbuf
+ strlen (sbuf
), "%x %x %.12g\n", arr
[0], arr
[1], fv
);
693 generic_floating_point_number
= f
;
699 extern const char FLT_CHARS
[];
700 #define MAX_LITTLENUMS 6
702 /* This is a utility function called from various tc-*.c files. It
703 is here in order to reduce code duplication.
705 Turn a string at input_line_pointer into a floating point constant
706 of type TYPE (a character found in the FLT_CHARS macro), and store
707 it as LITTLENUMS in the bytes buffer LITP. The number of chars
708 emitted is stored in *SIZEP. BIG_WORDIAN is TRUE if the littlenums
709 should be emitted most significant littlenum first.
711 An error message is returned, or a NULL pointer if everything went OK. */
714 ieee_md_atof (int type
,
717 bfd_boolean big_wordian
)
719 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
720 LITTLENUM_TYPE
*wordP
;
724 if (strchr (FLT_CHARS
, type
) != NULL
)
745 type
= 'x'; /* This is what atof_ieee() understands. */
753 /* Note: on the m68k there is a gap of 16 bits (one littlenum)
754 between the exponent and mantissa. Hence the precision is
756 prec
= P_PRECISION
+ 1;
766 /* The 'f' and 'd' types are always recognised, even if the target has
767 not put them into the FLT_CHARS macro. This is because the 'f' type
768 can come from the .dc.s, .dcb.s, .float or .single pseudo-ops and the
769 'd' type from the .dc.d, .dbc.d or .double pseudo-ops.
771 The 'x' type is not implicitly recongised however, even though it can
772 be generated by the .dc.x and .dbc.x pseudo-ops because not all targets
773 can support floating point values that big. ie the target has to
774 explicitly allow them by putting them into FLT_CHARS. */
775 else if (type
== 'f')
777 else if (type
== 'd')
783 return _("Unrecognized or unsupported floating point constant");
786 gas_assert (prec
<= MAX_LITTLENUMS
);
788 t
= atof_ieee (input_line_pointer
, type
, words
);
790 input_line_pointer
= t
;
792 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
796 for (wordP
= words
; prec
--;)
798 md_number_to_chars (litP
, (valueT
) (* wordP
++), sizeof (LITTLENUM_TYPE
));
799 litP
+= sizeof (LITTLENUM_TYPE
);
804 for (wordP
= words
+ prec
; prec
--;)
806 md_number_to_chars (litP
, (valueT
) (* -- wordP
), sizeof (LITTLENUM_TYPE
));
807 litP
+= sizeof (LITTLENUM_TYPE
);