1 /* atof_ieee.c - turn a Flonum into an IEEE floating point number
2 Copyright (C) 1987-2023 Free Software Foundation, Inc.
3
4 This file is part of GAS, the GNU Assembler.
5
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)
9 any later version.
10
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.
15
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
19 02110-1301, USA. */
20
21 #include "as.h"
22 #include "safe-ctype.h"
23
24 /* Flonums returned here. */
25 extern FLONUM_TYPE generic_floating_point_number;
26
27 /* Precision in LittleNums. */
28 /* Don't count the gap in the m68k extended precision format. */
29 #define MAX_PRECISION 5
30 #define H_PRECISION 1
31 #define B_PRECISION 1 /* Not strictly IEEE, but handled here anyway. */
32 #define F_PRECISION 2
33 #define D_PRECISION 4
34 #define X_PRECISION 5
35 #ifndef X_PRECISION_PAD
36 #define X_PRECISION_PAD 0
37 #endif
38 #define P_PRECISION 5
39 #ifndef P_PRECISION_PAD
40 #define P_PRECISION_PAD X_PRECISION_PAD
41 #endif
42
43 /* Length in LittleNums of guard bits. */
44 #define GUARD 2
45
46 #ifndef TC_LARGEST_EXPONENT_IS_NORMAL
47 #define TC_LARGEST_EXPONENT_IS_NORMAL(PRECISION) 0
48 #endif
49
50 static const unsigned long mask[] =
51 {
52 0x00000000,
53 0x00000001,
54 0x00000003,
55 0x00000007,
56 0x0000000f,
57 0x0000001f,
58 0x0000003f,
59 0x0000007f,
60 0x000000ff,
61 0x000001ff,
62 0x000003ff,
63 0x000007ff,
64 0x00000fff,
65 0x00001fff,
66 0x00003fff,
67 0x00007fff,
68 0x0000ffff,
69 0x0001ffff,
70 0x0003ffff,
71 0x0007ffff,
72 0x000fffff,
73 0x001fffff,
74 0x003fffff,
75 0x007fffff,
76 0x00ffffff,
77 0x01ffffff,
78 0x03ffffff,
79 0x07ffffff,
80 0x0fffffff,
81 0x1fffffff,
82 0x3fffffff,
83 0x7fffffff,
84 0xffffffff,
85 };
86
87 static int bits_left_in_littlenum;
88 static int littlenums_left;
89 static LITTLENUM_TYPE *littlenum_pointer;
90
91 static int
92 next_bits (int number_of_bits)
93 {
94 int return_value;
95
96 if (!littlenums_left)
97 return 0;
98
99 if (number_of_bits >= bits_left_in_littlenum)
100 {
101 return_value = mask[bits_left_in_littlenum] & *littlenum_pointer;
102 number_of_bits -= bits_left_in_littlenum;
103 return_value <<= number_of_bits;
104
105 if (--littlenums_left)
106 {
107 bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
108 --littlenum_pointer;
109 return_value |=
110 (*littlenum_pointer >> bits_left_in_littlenum)
111 & mask[number_of_bits];
112 }
113 }
114 else
115 {
116 bits_left_in_littlenum -= number_of_bits;
117 return_value =
118 mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum);
119 }
120 return return_value;
121 }
122
123 /* Num had better be less than LITTLENUM_NUMBER_OF_BITS. */
124
125 static void
126 unget_bits (int num)
127 {
128 if (!littlenums_left)
129 {
130 ++littlenum_pointer;
131 ++littlenums_left;
132 bits_left_in_littlenum = num;
133 }
134 else if (bits_left_in_littlenum + num > LITTLENUM_NUMBER_OF_BITS)
135 {
136 bits_left_in_littlenum =
137 num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum);
138 ++littlenum_pointer;
139 ++littlenums_left;
140 }
141 else
142 bits_left_in_littlenum += num;
143 }
144
145 static void
146 make_invalid_floating_point_number (LITTLENUM_TYPE *words)
147 {
148 as_bad (_("cannot create floating-point number"));
149 /* Zero the leftmost bit. */
150 words[0] = (LITTLENUM_TYPE) ((unsigned) -1) >> 1;
151 words[1] = (LITTLENUM_TYPE) -1;
152 words[2] = (LITTLENUM_TYPE) -1;
153 words[3] = (LITTLENUM_TYPE) -1;
154 words[4] = (LITTLENUM_TYPE) -1;
155 words[5] = (LITTLENUM_TYPE) -1;
156 }
157
158 /* Build a floating point constant at str into a IEEE floating
159 point number. This function does the same thing as atof_ieee
160 however it allows more control over the exact format, i.e.
161 explicitly specifying the precision and number of exponent bits
162 instead of relying on this infomation being deduced from a given type.
163
164 If generic_float_info is not NULL then it will be set to contain generic
165 infomation about the parsed floating point number.
166
167 Returns pointer past text consumed. */
168 char *
169 atof_ieee_detail (char * str,
170 int precision,
171 int exponent_bits,
172 LITTLENUM_TYPE * words,
173 FLONUM_TYPE * generic_float_info)
174 {
175 /* Extra bits for zeroed low-order bits.
176 The 1st MAX_PRECISION are zeroed, the last contain flonum bits. */
177 static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
178 char *return_value;
179
180 /* Number of 16-bit words in the format. */
181 FLONUM_TYPE save_gen_flonum;
182
183 /* We have to save the generic_floating_point_number because it
184 contains storage allocation about the array of LITTLENUMs where
185 the value is actually stored. We will allocate our own array of
186 littlenums below, but have to restore the global one on exit. */
187 save_gen_flonum = generic_floating_point_number;
188
189 return_value = str;
190 generic_floating_point_number.low = bits + MAX_PRECISION;
191 generic_floating_point_number.high = NULL;
192 generic_floating_point_number.leader = NULL;
193 generic_floating_point_number.exponent = 0;
194 generic_floating_point_number.sign = '\0';
195
196 /* Use more LittleNums than seems necessary: the highest flonum may
197 have 15 leading 0 bits, so could be useless. */
198
199 memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION);
200
201 generic_floating_point_number.high
202 = generic_floating_point_number.low + precision - 1 + GUARD;
203
204 if (atof_generic (&return_value, ".", EXP_CHARS,
205 &generic_floating_point_number))
206 {
207 make_invalid_floating_point_number (words);
208 return NULL;
209 }
210
211 if (generic_float_info)
212 *generic_float_info = generic_floating_point_number;
213
214 gen_to_words (words, precision, exponent_bits);
215
216 /* Restore the generic_floating_point_number's storage alloc (and
217 everything else). */
218 generic_floating_point_number = save_gen_flonum;
219
220 return return_value;
221 }
222
223 /* Warning: This returns 16-bit LITTLENUMs. It is up to the caller to
224 figure out any alignment problems and to conspire for the
225 bytes/word to be emitted in the right order. Bigendians beware! */
226
227 /* Note that atof-ieee always has X and P precisions enabled. it is up
228 to md_atof to filter them out if the target machine does not support
229 them. */
230
231 /* Returns pointer past text consumed. */
232 char *
233 atof_ieee (char *str, /* Text to convert to binary. */
234 int what_kind, /* 'd', 'f', 'x', 'p'. */
235 LITTLENUM_TYPE *words) /* Build the binary here. */
236 {
237 int precision;
238 long exponent_bits;
239
240 switch (what_kind)
241 {
242 case 'h':
243 case 'H':
244 precision = H_PRECISION;
245 exponent_bits = 5;
246 break;
247
248 case 'b':
249 case 'B':
250 precision = B_PRECISION;
251 exponent_bits = 8;
252 break;
253
254 case 'f':
255 case 'F':
256 case 's':
257 case 'S':
258 precision = F_PRECISION;
259 exponent_bits = 8;
260 break;
261
262 case 'd':
263 case 'D':
264 case 'r':
265 case 'R':
266 precision = D_PRECISION;
267 exponent_bits = 11;
268 break;
269
270 case 'x':
271 case 'X':
272 case 'e':
273 case 'E':
274 precision = X_PRECISION;
275 exponent_bits = 15;
276 break;
277
278 case 'p':
279 case 'P':
280 precision = P_PRECISION;
281 exponent_bits = -1;
282 break;
283
284 default:
285 make_invalid_floating_point_number (words);
286 return (NULL);
287 }
288
289 return atof_ieee_detail (str, precision, exponent_bits, words, NULL);
290 }
291
292 /* Turn generic_floating_point_number into a real float/double/extended. */
293
294 int
295 gen_to_words (LITTLENUM_TYPE *words, int precision, long exponent_bits)
296 {
297 int return_value = 0;
298
299 long exponent_1;
300 long exponent_2;
301 long exponent_3;
302 long exponent_4;
303 int exponent_skippage;
304 LITTLENUM_TYPE word1;
305 LITTLENUM_TYPE *lp;
306 LITTLENUM_TYPE *words_end;
307
308 words_end = words + precision;
309 #ifdef TC_M68K
310 if (precision == X_PRECISION)
311 /* On the m68k the extended precision format has a gap of 16 bits
312 between the exponent and the mantissa. */
313 words_end++;
314 #endif
315
316 if (generic_floating_point_number.low > generic_floating_point_number.leader)
317 {
318 /* 0.0e0 seen. */
319 if (generic_floating_point_number.sign == '+')
320 words[0] = 0x0000;
321 else
322 words[0] = 0x8000;
323 memset (&words[1], '\0',
324 (words_end - words - 1) * sizeof (LITTLENUM_TYPE));
325 return return_value;
326 }
327
328 switch (generic_floating_point_number.sign)
329 {
330 /* NaN: Do the right thing. */
331 case 0:
332 case 'Q': case 'q':
333 case 'S': case 's':
334 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
335 as_warn (_("NaNs are not supported by this target"));
336
337 if (precision == H_PRECISION)
338 {
339 if (TOUPPER (generic_floating_point_number.sign) != 'S')
340 words[0] = 0x7fff;
341 else
342 words[0] = exponent_bits == 5 ? 0x7dff : 0x7fbf;
343 }
344 else if (precision == F_PRECISION)
345 {
346 words[0] = TOUPPER (generic_floating_point_number.sign) == 'S'
347 ? 0x7fbf : 0x7fff;
348 words[1] = 0xffff;
349 }
350 else if (precision == X_PRECISION)
351 {
352 #ifdef TC_M68K
353 if (generic_floating_point_number.sign)
354 as_warn (_("NaN flavors are not supported by this target"));
355
356 words[0] = 0x7fff;
357 words[1] = 0;
358 words[2] = 0xffff;
359 words[3] = 0xffff;
360 words[4] = 0xffff;
361 words[5] = 0xffff;
362 #else /* ! TC_M68K */
363 #ifdef TC_I386
364 words[0] = 0x7fff;
365 words[1] = TOUPPER (generic_floating_point_number.sign) == 'S'
366 ? 0xbfff : 0xffff;
367 words[2] = 0xffff;
368 words[3] = 0xffff;
369 words[4] = 0xffff;
370 #else /* ! TC_I386 */
371 abort ();
372 #endif /* ! TC_I386 */
373 #endif /* ! TC_M68K */
374 }
375 else
376 {
377 words[0] = TOUPPER (generic_floating_point_number.sign) == 'S'
378 ? 0x7ff7 : 0x7fff;
379 words[1] = 0xffff;
380 words[2] = 0xffff;
381 words[3] = 0xffff;
382 }
383
384 if (ISLOWER (generic_floating_point_number.sign))
385 words[0] |= 0x8000;
386
387 return return_value;
388
389 case 'P':
390 case 'N':
391 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
392 as_warn (_("Infinities are not supported by this target"));
393
394 /* +INF: Do the right thing. */
395 if (precision == H_PRECISION /* also B_PRECISION */)
396 {
397 words[0] = exponent_bits == 5 ? 0x7c00 : 0x7f80;
398 }
399 else if (precision == F_PRECISION)
400 {
401 words[0] = 0x7f80;
402 words[1] = 0;
403 }
404 else if (precision == X_PRECISION)
405 {
406 #ifdef TC_M68K
407 words[0] = 0x7fff;
408 words[1] = 0;
409 words[2] = 0;
410 words[3] = 0;
411 words[4] = 0;
412 words[5] = 0;
413 #else /* ! TC_M68K */
414 #ifdef TC_I386
415 words[0] = 0x7fff;
416 words[1] = 0x8000;
417 words[2] = 0;
418 words[3] = 0;
419 words[4] = 0;
420 #else /* ! TC_I386 */
421 abort ();
422 #endif /* ! TC_I386 */
423 #endif /* ! TC_M68K */
424 }
425 else
426 {
427 words[0] = 0x7ff0;
428 words[1] = 0;
429 words[2] = 0;
430 words[3] = 0;
431 }
432
433 if (generic_floating_point_number.sign == 'N')
434 words[0] |= 0x8000;
435
436 return return_value;
437 }
438
439 /* The floating point formats we support have:
440 Bit 15 is sign bit.
441 Bits 14:n are excess-whatever exponent.
442 Bits n-1:0 (if any) are most significant bits of fraction.
443 Bits 15:0 of the next word(s) are the next most significant bits.
444
445 So we need: number of bits of exponent, number of bits of
446 mantissa. */
447 bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
448 littlenum_pointer = generic_floating_point_number.leader;
449 littlenums_left = (1
450 + generic_floating_point_number.leader
451 - generic_floating_point_number.low);
452
453 /* Seek (and forget) 1st significant bit. */
454 for (exponent_skippage = 0; !next_bits (1); ++exponent_skippage);
455 exponent_1 = (generic_floating_point_number.exponent
456 + generic_floating_point_number.leader
457 + 1
458 - generic_floating_point_number.low);
459
460 /* Radix LITTLENUM_RADIX, point just higher than
461 generic_floating_point_number.leader. */
462 exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
463
464 /* Radix 2. */
465 exponent_3 = exponent_2 - exponent_skippage;
466
467 /* Forget leading zeros, forget 1st bit. */
468 exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);
469
470 /* Offset exponent. */
471 lp = words;
472
473 /* Word 1. Sign, exponent and perhaps high bits. */
474 word1 = ((generic_floating_point_number.sign == '+')
475 ? 0
476 : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
477
478 /* Assume 2's complement integers. */
479 if (exponent_4 <= 0)
480 {
481 int prec_bits;
482 int num_bits;
483
484 unget_bits (1);
485 num_bits = -exponent_4;
486 prec_bits =
487 LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits);
488 #ifdef TC_I386
489 if (precision == X_PRECISION && exponent_bits == 15)
490 {
491 /* On the i386 a denormalized extended precision float is
492 shifted down by one, effectively decreasing the exponent
493 bias by one. */
494 prec_bits -= 1;
495 num_bits += 1;
496 }
497 #endif
498
499 if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits)
500 {
501 /* Bigger than one littlenum. */
502 num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits;
503 *lp++ = word1;
504 if (num_bits + exponent_bits + 1
505 > precision * LITTLENUM_NUMBER_OF_BITS)
506 {
507 /* Exponent overflow. */
508 make_invalid_floating_point_number (words);
509 return return_value;
510 }
511 #ifdef TC_M68K
512 if (precision == X_PRECISION && exponent_bits == 15)
513 *lp++ = 0;
514 #endif
515 while (num_bits >= LITTLENUM_NUMBER_OF_BITS)
516 {
517 num_bits -= LITTLENUM_NUMBER_OF_BITS;
518 *lp++ = 0;
519 }
520 if (num_bits)
521 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - (num_bits));
522 }
523 else
524 {
525 if (precision == X_PRECISION && exponent_bits == 15)
526 {
527 *lp++ = word1;
528 #ifdef TC_M68K
529 *lp++ = 0;
530 #endif
531 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - num_bits);
532 }
533 else
534 {
535 word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1)
536 - (exponent_bits + num_bits));
537 *lp++ = word1;
538 }
539 }
540 while (lp < words_end)
541 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
542
543 /* Round the mantissa up, but don't change the number. */
544 if (next_bits (1))
545 {
546 --lp;
547 if (prec_bits >= LITTLENUM_NUMBER_OF_BITS)
548 {
549 int n = 0;
550 int tmp_bits;
551
552 n = 0;
553 tmp_bits = prec_bits;
554 while (tmp_bits > LITTLENUM_NUMBER_OF_BITS)
555 {
556 if (lp[n] != (LITTLENUM_TYPE) - 1)
557 break;
558 --n;
559 tmp_bits -= LITTLENUM_NUMBER_OF_BITS;
560 }
561 if (tmp_bits > LITTLENUM_NUMBER_OF_BITS
562 || (lp[n] & mask[tmp_bits]) != mask[tmp_bits]
563 || (prec_bits != (precision * LITTLENUM_NUMBER_OF_BITS
564 - exponent_bits - 1)
565 #ifdef TC_I386
566 /* An extended precision float with only the integer
567 bit set would be invalid. That must be converted
568 to the smallest normalized number. */
569 && !(precision == X_PRECISION
570 && prec_bits == (precision * LITTLENUM_NUMBER_OF_BITS
571 - exponent_bits - 2))
572 #endif
573 ))
574 {
575 unsigned long carry;
576
577 for (carry = 1; carry && (lp >= words); lp--)
578 {
579 carry = *lp + carry;
580 *lp = carry;
581 carry >>= LITTLENUM_NUMBER_OF_BITS;
582 }
583 }
584 else
585 {
586 /* This is an overflow of the denormal numbers. We
587 need to forget what we have produced, and instead
588 generate the smallest normalized number. */
589 lp = words;
590 word1 = ((generic_floating_point_number.sign == '+')
591 ? 0
592 : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
593 word1 |= (1
594 << ((LITTLENUM_NUMBER_OF_BITS - 1)
595 - exponent_bits));
596 *lp++ = word1;
597 #ifdef TC_I386
598 /* Set the integer bit in the extended precision format.
599 This cannot happen on the m68k where the mantissa
600 just overflows into the integer bit above. */
601 if (precision == X_PRECISION)
602 *lp++ = 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
603 #endif
604 while (lp < words_end)
605 *lp++ = 0;
606 }
607 }
608 else
609 *lp += 1;
610 }
611
612 return return_value;
613 }
614 else if ((unsigned long) exponent_4 > mask[exponent_bits]
615 || (! TC_LARGEST_EXPONENT_IS_NORMAL (precision)
616 && (unsigned long) exponent_4 == mask[exponent_bits]))
617 {
618 /* Exponent overflow. Lose immediately. */
619
620 /* We leave return_value alone: admit we read the
621 number, but return a floating exception
622 because we can't encode the number. */
623 make_invalid_floating_point_number (words);
624 return return_value;
625 }
626 else
627 {
628 word1 |= (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits))
629 | next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits);
630 }
631
632 *lp++ = word1;
633
634 /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the
635 middle. Either way, it is then followed by a 1 bit. */
636 if (exponent_bits == 15 && precision == X_PRECISION)
637 {
638 #ifdef TC_M68K
639 *lp++ = 0;
640 #endif
641 *lp++ = (1 << (LITTLENUM_NUMBER_OF_BITS - 1)
642 | next_bits (LITTLENUM_NUMBER_OF_BITS - 1));
643 }
644
645 /* The rest of the words are just mantissa bits. */
646 while (lp < words_end)
647 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
648
649 if (next_bits (1))
650 {
651 unsigned long carry;
652 /* Since the NEXT bit is a 1, round UP the mantissa.
653 The cunning design of these hidden-1 floats permits
654 us to let the mantissa overflow into the exponent, and
655 it 'does the right thing'. However, we lose if the
656 highest-order bit of the lowest-order word flips.
657 Is that clear? */
658
659 /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
660 Please allow at least 1 more bit in carry than is in a LITTLENUM.
661 We need that extra bit to hold a carry during a LITTLENUM carry
662 propagation. Another extra bit (kept 0) will assure us that we
663 don't get a sticky sign bit after shifting right, and that
664 permits us to propagate the carry without any masking of bits.
665 #endif */
666 for (carry = 1, lp--; carry; lp--)
667 {
668 carry = *lp + carry;
669 *lp = carry;
670 carry >>= LITTLENUM_NUMBER_OF_BITS;
671 if (lp == words)
672 break;
673 }
674 if (precision == X_PRECISION && exponent_bits == 15)
675 {
676 /* Extended precision numbers have an explicit integer bit
677 that we may have to restore. */
678 if (lp == words)
679 {
680 #ifdef TC_M68K
681 /* On the m68k there is a gap of 16 bits. We must
682 explicitly propagate the carry into the exponent. */
683 words[0] += words[1];
684 words[1] = 0;
685 lp++;
686 #endif
687 /* Put back the integer bit. */
688 lp[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
689 }
690 }
691 if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)))
692 {
693 /* We leave return_value alone: admit we read the number,
694 but return a floating exception because we can't encode
695 the number. */
696 *words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1));
697 }
698 }
699 return return_value;
700 }
701
702 #ifdef TEST
703 char *
704 print_gen (gen)
705 FLONUM_TYPE *gen;
706 {
707 FLONUM_TYPE f;
708 LITTLENUM_TYPE arr[10];
709 double dv;
710 float fv;
711 static char sbuf[40];
712
713 if (gen)
714 {
715 f = generic_floating_point_number;
716 generic_floating_point_number = *gen;
717 }
718 gen_to_words (&arr[0], 4, 11);
719 memcpy (&dv, &arr[0], sizeof (double));
720 sprintf (sbuf, "%x %x %x %x %.14G ", arr[0], arr[1], arr[2], arr[3], dv);
721 gen_to_words (&arr[0], 2, 8);
722 memcpy (&fv, &arr[0], sizeof (float));
723 sprintf (sbuf + strlen (sbuf), "%x %x %.12g\n", arr[0], arr[1], fv);
724
725 if (gen)
726 generic_floating_point_number = f;
727
728 return (sbuf);
729 }
730 #endif
731
732 /* This is a utility function called from various tc-*.c files. It
733 is here in order to reduce code duplication.
734
735 Turn a string at input_line_pointer into a floating point constant
736 of type TYPE (a character found in the FLT_CHARS macro), and store
737 it as LITTLENUMS in the bytes buffer LITP. The number of chars
738 emitted is stored in *SIZEP. BIG_WORDIAN is TRUE if the littlenums
739 should be emitted most significant littlenum first.
740
741 An error message is returned, or a NULL pointer if everything went OK. */
742
743 const char *
744 ieee_md_atof (int type,
745 char *litP,
746 int *sizeP,
747 bool big_wordian)
748 {
749 LITTLENUM_TYPE words[MAX_LITTLENUMS];
750 LITTLENUM_TYPE *wordP;
751 char *t;
752 int prec = 0, pad = 0;
753
754 if (strchr (FLT_CHARS, type) != NULL)
755 {
756 switch (type)
757 {
758 case 'H':
759 case 'h':
760 prec = H_PRECISION;
761 break;
762
763 case 'B':
764 case 'b':
765 prec = B_PRECISION;
766 break;
767
768 case 'f':
769 case 'F':
770 case 's':
771 case 'S':
772 prec = F_PRECISION;
773 break;
774
775 case 'd':
776 case 'D':
777 case 'r':
778 case 'R':
779 prec = D_PRECISION;
780 break;
781
782 case 't':
783 case 'T':
784 prec = X_PRECISION;
785 pad = X_PRECISION_PAD;
786 type = 'x'; /* This is what atof_ieee() understands. */
787 break;
788
789 case 'x':
790 case 'X':
791 case 'p':
792 case 'P':
793 #ifdef TC_M68K
794 /* Note: on the m68k there is a gap of 16 bits (one littlenum)
795 between the exponent and mantissa. Hence the precision is
796 6 and not 5. */
797 prec = P_PRECISION + 1;
798 #else
799 prec = P_PRECISION;
800 #endif
801 pad = P_PRECISION_PAD;
802 break;
803
804 default:
805 break;
806 }
807 }
808 /* The 'f' and 'd' types are always recognised, even if the target has
809 not put them into the FLT_CHARS macro. This is because the 'f' type
810 can come from the .dc.s, .dcb.s, .float or .single pseudo-ops and the
811 'd' type from the .dc.d, .dbc.d or .double pseudo-ops.
812
813 The 'x' type is not implicitly recognised however, even though it can
814 be generated by the .dc.x and .dbc.x pseudo-ops because not all targets
815 can support floating point values that big. ie the target has to
816 explicitly allow them by putting them into FLT_CHARS. */
817 else if (type == 'f')
818 prec = F_PRECISION;
819 else if (type == 'd')
820 prec = D_PRECISION;
821
822 if (prec == 0)
823 {
824 *sizeP = 0;
825 return _("Unrecognized or unsupported floating point constant");
826 }
827
828 gas_assert (prec <= MAX_LITTLENUMS);
829
830 t = atof_ieee (input_line_pointer, type, words);
831 if (t)
832 input_line_pointer = t;
833
834 *sizeP = (prec + pad) * sizeof (LITTLENUM_TYPE);
835
836 if (big_wordian)
837 {
838 for (wordP = words; prec --;)
839 {
840 md_number_to_chars (litP, (valueT) (* wordP ++), sizeof (LITTLENUM_TYPE));
841 litP += sizeof (LITTLENUM_TYPE);
842 }
843 }
844 else
845 {
846 for (wordP = words + prec; prec --;)
847 {
848 md_number_to_chars (litP, (valueT) (* -- wordP), sizeof (LITTLENUM_TYPE));
849 litP += sizeof (LITTLENUM_TYPE);
850 }
851 }
852
853 memset (litP, 0, pad * sizeof (LITTLENUM_TYPE));
854 litP += pad * sizeof (LITTLENUM_TYPE);
855
856 return NULL;
857 }