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