1 /* atof_ieee.c - turn a Flonum into an IEEE floating point number
2 Copyright (C) 1987-2019 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 /* Precision in LittleNums. */
27 /* Don't count the gap in the m68k extended precision format. */
28 #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
);
196 precision
= H_PRECISION
;
204 precision
= F_PRECISION
;
212 precision
= D_PRECISION
;
220 precision
= X_PRECISION
;
226 precision
= P_PRECISION
;
231 make_invalid_floating_point_number (words
);
235 generic_floating_point_number
.high
236 = generic_floating_point_number
.low
+ precision
- 1 + GUARD
;
238 if (atof_generic (&return_value
, ".", EXP_CHARS
,
239 &generic_floating_point_number
))
241 make_invalid_floating_point_number (words
);
244 gen_to_words (words
, precision
, exponent_bits
);
246 /* Restore the generic_floating_point_number's storage alloc (and
248 generic_floating_point_number
= save_gen_flonum
;
253 /* Turn generic_floating_point_number into a real float/double/extended. */
256 gen_to_words (LITTLENUM_TYPE
*words
, int precision
, long exponent_bits
)
258 int return_value
= 0;
264 int exponent_skippage
;
265 LITTLENUM_TYPE word1
;
267 LITTLENUM_TYPE
*words_end
;
269 words_end
= words
+ precision
;
271 if (precision
== X_PRECISION
)
272 /* On the m68k the extended precision format has a gap of 16 bits
273 between the exponent and the mantissa. */
277 if (generic_floating_point_number
.low
> generic_floating_point_number
.leader
)
280 if (generic_floating_point_number
.sign
== '+')
284 memset (&words
[1], '\0',
285 (words_end
- words
- 1) * sizeof (LITTLENUM_TYPE
));
289 /* NaN: Do the right thing. */
290 if (generic_floating_point_number
.sign
== 0)
292 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision
))
293 as_warn (_("NaNs are not supported by this target"));
295 if (precision
== H_PRECISION
)
299 else if (precision
== F_PRECISION
)
304 else if (precision
== X_PRECISION
)
313 #else /* ! TC_M68K */
320 #else /* ! TC_I386 */
322 #endif /* ! TC_I386 */
323 #endif /* ! TC_M68K */
334 else if (generic_floating_point_number
.sign
== 'P')
336 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision
))
337 as_warn (_("Infinities are not supported by this target"));
339 /* +INF: Do the right thing. */
340 if (precision
== H_PRECISION
)
344 else if (precision
== F_PRECISION
)
349 else if (precision
== X_PRECISION
)
358 #else /* ! TC_M68K */
365 #else /* ! TC_I386 */
367 #endif /* ! TC_I386 */
368 #endif /* ! TC_M68K */
379 else if (generic_floating_point_number
.sign
== 'N')
381 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision
))
382 as_warn (_("Infinities are not supported by this target"));
385 if (precision
== H_PRECISION
)
389 else if (precision
== F_PRECISION
)
394 else if (precision
== X_PRECISION
)
403 #else /* ! TC_M68K */
410 #else /* ! TC_I386 */
412 #endif /* ! TC_I386 */
413 #endif /* ! TC_M68K */
425 /* The floating point formats we support have:
427 Bits 14:n are excess-whatever exponent.
428 Bits n-1:0 (if any) are most significant bits of fraction.
429 Bits 15:0 of the next word(s) are the next most significant bits.
431 So we need: number of bits of exponent, number of bits of
433 bits_left_in_littlenum
= LITTLENUM_NUMBER_OF_BITS
;
434 littlenum_pointer
= generic_floating_point_number
.leader
;
436 + generic_floating_point_number
.leader
437 - generic_floating_point_number
.low
);
439 /* Seek (and forget) 1st significant bit. */
440 for (exponent_skippage
= 0; !next_bits (1); ++exponent_skippage
);
441 exponent_1
= (generic_floating_point_number
.exponent
442 + generic_floating_point_number
.leader
444 - generic_floating_point_number
.low
);
446 /* Radix LITTLENUM_RADIX, point just higher than
447 generic_floating_point_number.leader. */
448 exponent_2
= exponent_1
* LITTLENUM_NUMBER_OF_BITS
;
451 exponent_3
= exponent_2
- exponent_skippage
;
453 /* Forget leading zeros, forget 1st bit. */
454 exponent_4
= exponent_3
+ ((1 << (exponent_bits
- 1)) - 2);
456 /* Offset exponent. */
459 /* Word 1. Sign, exponent and perhaps high bits. */
460 word1
= ((generic_floating_point_number
.sign
== '+')
462 : (1 << (LITTLENUM_NUMBER_OF_BITS
- 1)));
464 /* Assume 2's complement integers. */
471 num_bits
= -exponent_4
;
473 LITTLENUM_NUMBER_OF_BITS
* precision
- (exponent_bits
+ 1 + num_bits
);
475 if (precision
== X_PRECISION
&& exponent_bits
== 15)
477 /* On the i386 a denormalized extended precision float is
478 shifted down by one, effectively decreasing the exponent
485 if (num_bits
>= LITTLENUM_NUMBER_OF_BITS
- exponent_bits
)
487 /* Bigger than one littlenum. */
488 num_bits
-= (LITTLENUM_NUMBER_OF_BITS
- 1) - exponent_bits
;
490 if (num_bits
+ exponent_bits
+ 1
491 > precision
* LITTLENUM_NUMBER_OF_BITS
)
493 /* Exponent overflow. */
494 make_invalid_floating_point_number (words
);
498 if (precision
== X_PRECISION
&& exponent_bits
== 15)
501 while (num_bits
>= LITTLENUM_NUMBER_OF_BITS
)
503 num_bits
-= LITTLENUM_NUMBER_OF_BITS
;
507 *lp
++ = next_bits (LITTLENUM_NUMBER_OF_BITS
- (num_bits
));
511 if (precision
== X_PRECISION
&& exponent_bits
== 15)
517 *lp
++ = next_bits (LITTLENUM_NUMBER_OF_BITS
- num_bits
);
521 word1
|= next_bits ((LITTLENUM_NUMBER_OF_BITS
- 1)
522 - (exponent_bits
+ num_bits
));
526 while (lp
< words_end
)
527 *lp
++ = next_bits (LITTLENUM_NUMBER_OF_BITS
);
529 /* Round the mantissa up, but don't change the number. */
533 if (prec_bits
>= LITTLENUM_NUMBER_OF_BITS
)
539 tmp_bits
= prec_bits
;
540 while (tmp_bits
> LITTLENUM_NUMBER_OF_BITS
)
542 if (lp
[n
] != (LITTLENUM_TYPE
) - 1)
545 tmp_bits
-= LITTLENUM_NUMBER_OF_BITS
;
547 if (tmp_bits
> LITTLENUM_NUMBER_OF_BITS
548 || (lp
[n
] & mask
[tmp_bits
]) != mask
[tmp_bits
]
549 || (prec_bits
!= (precision
* LITTLENUM_NUMBER_OF_BITS
552 /* An extended precision float with only the integer
553 bit set would be invalid. That must be converted
554 to the smallest normalized number. */
555 && !(precision
== X_PRECISION
556 && prec_bits
== (precision
* LITTLENUM_NUMBER_OF_BITS
557 - exponent_bits
- 2))
563 for (carry
= 1; carry
&& (lp
>= words
); lp
--)
567 carry
>>= LITTLENUM_NUMBER_OF_BITS
;
572 /* This is an overflow of the denormal numbers. We
573 need to forget what we have produced, and instead
574 generate the smallest normalized number. */
576 word1
= ((generic_floating_point_number
.sign
== '+')
578 : (1 << (LITTLENUM_NUMBER_OF_BITS
- 1)));
580 << ((LITTLENUM_NUMBER_OF_BITS
- 1)
584 /* Set the integer bit in the extended precision format.
585 This cannot happen on the m68k where the mantissa
586 just overflows into the integer bit above. */
587 if (precision
== X_PRECISION
)
588 *lp
++ = 1 << (LITTLENUM_NUMBER_OF_BITS
- 1);
590 while (lp
< words_end
)
600 else if ((unsigned long) exponent_4
> mask
[exponent_bits
]
601 || (! TC_LARGEST_EXPONENT_IS_NORMAL (precision
)
602 && (unsigned long) exponent_4
== mask
[exponent_bits
]))
604 /* Exponent overflow. Lose immediately. */
606 /* We leave return_value alone: admit we read the
607 number, but return a floating exception
608 because we can't encode the number. */
609 make_invalid_floating_point_number (words
);
614 word1
|= (exponent_4
<< ((LITTLENUM_NUMBER_OF_BITS
- 1) - exponent_bits
))
615 | next_bits ((LITTLENUM_NUMBER_OF_BITS
- 1) - exponent_bits
);
620 /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the
621 middle. Either way, it is then followed by a 1 bit. */
622 if (exponent_bits
== 15 && precision
== X_PRECISION
)
627 *lp
++ = (1 << (LITTLENUM_NUMBER_OF_BITS
- 1)
628 | next_bits (LITTLENUM_NUMBER_OF_BITS
- 1));
631 /* The rest of the words are just mantissa bits. */
632 while (lp
< words_end
)
633 *lp
++ = next_bits (LITTLENUM_NUMBER_OF_BITS
);
638 /* Since the NEXT bit is a 1, round UP the mantissa.
639 The cunning design of these hidden-1 floats permits
640 us to let the mantissa overflow into the exponent, and
641 it 'does the right thing'. However, we lose if the
642 highest-order bit of the lowest-order word flips.
645 /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
646 Please allow at least 1 more bit in carry than is in a LITTLENUM.
647 We need that extra bit to hold a carry during a LITTLENUM carry
648 propagation. Another extra bit (kept 0) will assure us that we
649 don't get a sticky sign bit after shifting right, and that
650 permits us to propagate the carry without any masking of bits.
652 for (carry
= 1, lp
--; carry
; lp
--)
656 carry
>>= LITTLENUM_NUMBER_OF_BITS
;
660 if (precision
== X_PRECISION
&& exponent_bits
== 15)
662 /* Extended precision numbers have an explicit integer bit
663 that we may have to restore. */
667 /* On the m68k there is a gap of 16 bits. We must
668 explicitly propagate the carry into the exponent. */
669 words
[0] += words
[1];
673 /* Put back the integer bit. */
674 lp
[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS
- 1);
677 if ((word1
^ *words
) & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1)))
679 /* We leave return_value alone: admit we read the number,
680 but return a floating exception because we can't encode
682 *words
&= ~(1 << (LITTLENUM_NUMBER_OF_BITS
- 1));
694 LITTLENUM_TYPE arr
[10];
697 static char sbuf
[40];
701 f
= generic_floating_point_number
;
702 generic_floating_point_number
= *gen
;
704 gen_to_words (&arr
[0], 4, 11);
705 memcpy (&dv
, &arr
[0], sizeof (double));
706 sprintf (sbuf
, "%x %x %x %x %.14G ", arr
[0], arr
[1], arr
[2], arr
[3], dv
);
707 gen_to_words (&arr
[0], 2, 8);
708 memcpy (&fv
, &arr
[0], sizeof (float));
709 sprintf (sbuf
+ strlen (sbuf
), "%x %x %.12g\n", arr
[0], arr
[1], fv
);
712 generic_floating_point_number
= f
;
718 /* This is a utility function called from various tc-*.c files. It
719 is here in order to reduce code duplication.
721 Turn a string at input_line_pointer into a floating point constant
722 of type TYPE (a character found in the FLT_CHARS macro), and store
723 it as LITTLENUMS in the bytes buffer LITP. The number of chars
724 emitted is stored in *SIZEP. BIG_WORDIAN is TRUE if the littlenums
725 should be emitted most significant littlenum first.
727 An error message is returned, or a NULL pointer if everything went OK. */
730 ieee_md_atof (int type
,
733 bfd_boolean big_wordian
)
735 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
736 LITTLENUM_TYPE
*wordP
;
740 if (strchr (FLT_CHARS
, type
) != NULL
)
766 type
= 'x'; /* This is what atof_ieee() understands. */
774 /* Note: on the m68k there is a gap of 16 bits (one littlenum)
775 between the exponent and mantissa. Hence the precision is
777 prec
= P_PRECISION
+ 1;
787 /* The 'f' and 'd' types are always recognised, even if the target has
788 not put them into the FLT_CHARS macro. This is because the 'f' type
789 can come from the .dc.s, .dcb.s, .float or .single pseudo-ops and the
790 'd' type from the .dc.d, .dbc.d or .double pseudo-ops.
792 The 'x' type is not implicitly recognised however, even though it can
793 be generated by the .dc.x and .dbc.x pseudo-ops because not all targets
794 can support floating point values that big. ie the target has to
795 explicitly allow them by putting them into FLT_CHARS. */
796 else if (type
== 'f')
798 else if (type
== 'd')
804 return _("Unrecognized or unsupported floating point constant");
807 gas_assert (prec
<= MAX_LITTLENUMS
);
809 t
= atof_ieee (input_line_pointer
, type
, words
);
811 input_line_pointer
= t
;
813 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
817 for (wordP
= words
; prec
--;)
819 md_number_to_chars (litP
, (valueT
) (* wordP
++), sizeof (LITTLENUM_TYPE
));
820 litP
+= sizeof (LITTLENUM_TYPE
);
825 for (wordP
= words
+ prec
; prec
--;)
827 md_number_to_chars (litP
, (valueT
) (* -- wordP
), sizeof (LITTLENUM_TYPE
));
828 litP
+= sizeof (LITTLENUM_TYPE
);