Merge branch 'vendor/GCC50'
[dragonfly.git] / contrib / binutils-2.25 / gas / config / atof-ieee.c
1 /* atof_ieee.c - turn a Flonum into an IEEE floating point number
2    Copyright (C) 1987-2014 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 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
30 #define F_PRECISION    2
31 #define D_PRECISION    4
32 #define X_PRECISION    5
33 #define P_PRECISION    5
34
35 /* Length in LittleNums of guard bits.  */
36 #define GUARD          2
37
38 #ifndef TC_LARGEST_EXPONENT_IS_NORMAL
39 #define TC_LARGEST_EXPONENT_IS_NORMAL(PRECISION) 0
40 #endif
41
42 static const unsigned long mask[] =
43 {
44   0x00000000,
45   0x00000001,
46   0x00000003,
47   0x00000007,
48   0x0000000f,
49   0x0000001f,
50   0x0000003f,
51   0x0000007f,
52   0x000000ff,
53   0x000001ff,
54   0x000003ff,
55   0x000007ff,
56   0x00000fff,
57   0x00001fff,
58   0x00003fff,
59   0x00007fff,
60   0x0000ffff,
61   0x0001ffff,
62   0x0003ffff,
63   0x0007ffff,
64   0x000fffff,
65   0x001fffff,
66   0x003fffff,
67   0x007fffff,
68   0x00ffffff,
69   0x01ffffff,
70   0x03ffffff,
71   0x07ffffff,
72   0x0fffffff,
73   0x1fffffff,
74   0x3fffffff,
75   0x7fffffff,
76   0xffffffff,
77 };
78 \f
79 static int bits_left_in_littlenum;
80 static int littlenums_left;
81 static LITTLENUM_TYPE *littlenum_pointer;
82
83 static int
84 next_bits (int number_of_bits)
85 {
86   int return_value;
87
88   if (!littlenums_left)
89     return 0;
90
91   if (number_of_bits >= bits_left_in_littlenum)
92     {
93       return_value = mask[bits_left_in_littlenum] & *littlenum_pointer;
94       number_of_bits -= bits_left_in_littlenum;
95       return_value <<= number_of_bits;
96
97       if (--littlenums_left)
98         {
99           bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
100           --littlenum_pointer;
101           return_value |=
102             (*littlenum_pointer >> bits_left_in_littlenum)
103             & mask[number_of_bits];
104         }
105     }
106   else
107     {
108       bits_left_in_littlenum -= number_of_bits;
109       return_value =
110         mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum);
111     }
112   return return_value;
113 }
114
115 /* Num had better be less than LITTLENUM_NUMBER_OF_BITS.  */
116
117 static void
118 unget_bits (int num)
119 {
120   if (!littlenums_left)
121     {
122       ++littlenum_pointer;
123       ++littlenums_left;
124       bits_left_in_littlenum = num;
125     }
126   else if (bits_left_in_littlenum + num > LITTLENUM_NUMBER_OF_BITS)
127     {
128       bits_left_in_littlenum =
129         num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum);
130       ++littlenum_pointer;
131       ++littlenums_left;
132     }
133   else
134     bits_left_in_littlenum += num;
135 }
136
137 static void
138 make_invalid_floating_point_number (LITTLENUM_TYPE *words)
139 {
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;
148 }
149 \f
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!  */
153
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
156    them.  */
157
158 /* Returns pointer past text consumed.  */
159
160 char *
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.  */
164 {
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];
168   char *return_value;
169   /* Number of 16-bit words in the format.  */
170   int precision;
171   long exponent_bits;
172   FLONUM_TYPE save_gen_flonum;
173
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;
179
180   return_value = str;
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';
186
187   /* Use more LittleNums than seems necessary: the highest flonum may
188      have 15 leading 0 bits, so could be useless.  */
189
190   memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION);
191
192   switch (what_kind)
193     {
194     case 'f':
195     case 'F':
196     case 's':
197     case 'S':
198       precision = F_PRECISION;
199       exponent_bits = 8;
200       break;
201
202     case 'd':
203     case 'D':
204     case 'r':
205     case 'R':
206       precision = D_PRECISION;
207       exponent_bits = 11;
208       break;
209
210     case 'x':
211     case 'X':
212     case 'e':
213     case 'E':
214       precision = X_PRECISION;
215       exponent_bits = 15;
216       break;
217
218     case 'p':
219     case 'P':
220       precision = P_PRECISION;
221       exponent_bits = -1;
222       break;
223
224     default:
225       make_invalid_floating_point_number (words);
226       return (NULL);
227     }
228
229   generic_floating_point_number.high
230     = generic_floating_point_number.low + precision - 1 + GUARD;
231
232   if (atof_generic (&return_value, ".", EXP_CHARS,
233                     &generic_floating_point_number))
234     {
235       make_invalid_floating_point_number (words);
236       return NULL;
237     }
238   gen_to_words (words, precision, exponent_bits);
239
240   /* Restore the generic_floating_point_number's storage alloc (and
241      everything else).  */
242   generic_floating_point_number = save_gen_flonum;
243
244   return return_value;
245 }
246
247 /* Turn generic_floating_point_number into a real float/double/extended.  */
248
249 int
250 gen_to_words (LITTLENUM_TYPE *words, int precision, long exponent_bits)
251 {
252   int return_value = 0;
253
254   long exponent_1;
255   long exponent_2;
256   long exponent_3;
257   long exponent_4;
258   int exponent_skippage;
259   LITTLENUM_TYPE word1;
260   LITTLENUM_TYPE *lp;
261   LITTLENUM_TYPE *words_end;
262
263   words_end = words + precision;
264 #ifdef TC_M68K
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.  */
268     words_end++;
269 #endif
270
271   if (generic_floating_point_number.low > generic_floating_point_number.leader)
272     {
273       /* 0.0e0 seen.  */
274       if (generic_floating_point_number.sign == '+')
275         words[0] = 0x0000;
276       else
277         words[0] = 0x8000;
278       memset (&words[1], '\0',
279               (words_end - words - 1) * sizeof (LITTLENUM_TYPE));
280       return return_value;
281     }
282
283   /* NaN:  Do the right thing.  */
284   if (generic_floating_point_number.sign == 0)
285     {
286       if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
287         as_warn (_("NaNs are not supported by this target\n"));
288       if (precision == F_PRECISION)
289         {
290           words[0] = 0x7fff;
291           words[1] = 0xffff;
292         }
293       else if (precision == X_PRECISION)
294         {
295 #ifdef TC_M68K
296           words[0] = 0x7fff;
297           words[1] = 0;
298           words[2] = 0xffff;
299           words[3] = 0xffff;
300           words[4] = 0xffff;
301           words[5] = 0xffff;
302 #else /* ! TC_M68K  */
303 #ifdef TC_I386
304           words[0] = 0xffff;
305           words[1] = 0xc000;
306           words[2] = 0;
307           words[3] = 0;
308           words[4] = 0;
309 #else /* ! TC_I386  */
310           abort ();
311 #endif /* ! TC_I386  */
312 #endif /* ! TC_M68K  */
313         }
314       else
315         {
316           words[0] = 0x7fff;
317           words[1] = 0xffff;
318           words[2] = 0xffff;
319           words[3] = 0xffff;
320         }
321       return return_value;
322     }
323   else if (generic_floating_point_number.sign == 'P')
324     {
325       if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
326         as_warn (_("Infinities are not supported by this target\n"));
327
328       /* +INF:  Do the right thing.  */
329       if (precision == F_PRECISION)
330         {
331           words[0] = 0x7f80;
332           words[1] = 0;
333         }
334       else if (precision == X_PRECISION)
335         {
336 #ifdef TC_M68K
337           words[0] = 0x7fff;
338           words[1] = 0;
339           words[2] = 0;
340           words[3] = 0;
341           words[4] = 0;
342           words[5] = 0;
343 #else /* ! TC_M68K  */
344 #ifdef TC_I386
345           words[0] = 0x7fff;
346           words[1] = 0x8000;
347           words[2] = 0;
348           words[3] = 0;
349           words[4] = 0;
350 #else /* ! TC_I386  */
351           abort ();
352 #endif /* ! TC_I386  */
353 #endif /* ! TC_M68K  */
354         }
355       else
356         {
357           words[0] = 0x7ff0;
358           words[1] = 0;
359           words[2] = 0;
360           words[3] = 0;
361         }
362       return return_value;
363     }
364   else if (generic_floating_point_number.sign == 'N')
365     {
366       if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
367         as_warn (_("Infinities are not supported by this target\n"));
368
369       /* Negative INF.  */
370       if (precision == F_PRECISION)
371         {
372           words[0] = 0xff80;
373           words[1] = 0x0;
374         }
375       else if (precision == X_PRECISION)
376         {
377 #ifdef TC_M68K
378           words[0] = 0xffff;
379           words[1] = 0;
380           words[2] = 0;
381           words[3] = 0;
382           words[4] = 0;
383           words[5] = 0;
384 #else /* ! TC_M68K  */
385 #ifdef TC_I386
386           words[0] = 0xffff;
387           words[1] = 0x8000;
388           words[2] = 0;
389           words[3] = 0;
390           words[4] = 0;
391 #else /* ! TC_I386  */
392           abort ();
393 #endif /* ! TC_I386  */
394 #endif /* ! TC_M68K  */
395         }
396       else
397         {
398           words[0] = 0xfff0;
399           words[1] = 0x0;
400           words[2] = 0x0;
401           words[3] = 0x0;
402         }
403       return return_value;
404     }
405
406   /* The floating point formats we support have:
407      Bit 15 is sign bit.
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.
411
412      So we need: number of bits of exponent, number of bits of
413      mantissa.  */
414   bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
415   littlenum_pointer = generic_floating_point_number.leader;
416   littlenums_left = (1
417                      + generic_floating_point_number.leader
418                      - generic_floating_point_number.low);
419
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
424                 + 1
425                 - generic_floating_point_number.low);
426
427   /* Radix LITTLENUM_RADIX, point just higher than
428      generic_floating_point_number.leader.  */
429   exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
430
431   /* Radix 2.  */
432   exponent_3 = exponent_2 - exponent_skippage;
433
434   /* Forget leading zeros, forget 1st bit.  */
435   exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);
436
437   /* Offset exponent.  */
438   lp = words;
439
440   /* Word 1.  Sign, exponent and perhaps high bits.  */
441   word1 = ((generic_floating_point_number.sign == '+')
442            ? 0
443            : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
444
445   /* Assume 2's complement integers.  */
446   if (exponent_4 <= 0)
447     {
448       int prec_bits;
449       int num_bits;
450
451       unget_bits (1);
452       num_bits = -exponent_4;
453       prec_bits =
454         LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits);
455 #ifdef TC_I386
456       if (precision == X_PRECISION && exponent_bits == 15)
457         {
458           /* On the i386 a denormalized extended precision float is
459              shifted down by one, effectively decreasing the exponent
460              bias by one.  */
461           prec_bits -= 1;
462           num_bits += 1;
463         }
464 #endif
465
466       if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits)
467         {
468           /* Bigger than one littlenum.  */
469           num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits;
470           *lp++ = word1;
471           if (num_bits + exponent_bits + 1
472               > precision * LITTLENUM_NUMBER_OF_BITS)
473             {
474               /* Exponent overflow.  */
475               make_invalid_floating_point_number (words);
476               return return_value;
477             }
478 #ifdef TC_M68K
479           if (precision == X_PRECISION && exponent_bits == 15)
480             *lp++ = 0;
481 #endif
482           while (num_bits >= LITTLENUM_NUMBER_OF_BITS)
483             {
484               num_bits -= LITTLENUM_NUMBER_OF_BITS;
485               *lp++ = 0;
486             }
487           if (num_bits)
488             *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - (num_bits));
489         }
490       else
491         {
492           if (precision == X_PRECISION && exponent_bits == 15)
493             {
494               *lp++ = word1;
495 #ifdef TC_M68K
496               *lp++ = 0;
497 #endif
498               *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - num_bits);
499             }
500           else
501             {
502               word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1)
503                                   - (exponent_bits + num_bits));
504               *lp++ = word1;
505             }
506         }
507       while (lp < words_end)
508         *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
509
510       /* Round the mantissa up, but don't change the number.  */
511       if (next_bits (1))
512         {
513           --lp;
514           if (prec_bits >= LITTLENUM_NUMBER_OF_BITS)
515             {
516               int n = 0;
517               int tmp_bits;
518
519               n = 0;
520               tmp_bits = prec_bits;
521               while (tmp_bits > LITTLENUM_NUMBER_OF_BITS)
522                 {
523                   if (lp[n] != (LITTLENUM_TYPE) - 1)
524                     break;
525                   --n;
526                   tmp_bits -= LITTLENUM_NUMBER_OF_BITS;
527                 }
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
531                                     - exponent_bits - 1)
532 #ifdef TC_I386
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))
539 #endif
540                       ))
541                 {
542                   unsigned long carry;
543
544                   for (carry = 1; carry && (lp >= words); lp--)
545                     {
546                       carry = *lp + carry;
547                       *lp = carry;
548                       carry >>= LITTLENUM_NUMBER_OF_BITS;
549                     }
550                 }
551               else
552                 {
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.  */
556                   lp = words;
557                   word1 = ((generic_floating_point_number.sign == '+')
558                            ? 0
559                            : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
560                   word1 |= (1
561                             << ((LITTLENUM_NUMBER_OF_BITS - 1)
562                                 - exponent_bits));
563                   *lp++ = word1;
564 #ifdef TC_I386
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);
570 #endif
571                   while (lp < words_end)
572                     *lp++ = 0;
573                 }
574             }
575           else
576             *lp += 1;
577         }
578
579       return return_value;
580     }
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]))
584     {
585       /* Exponent overflow.  Lose immediately.  */
586
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);
591       return return_value;
592     }
593   else
594     {
595       word1 |= (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits))
596         | next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits);
597     }
598
599   *lp++ = word1;
600
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)
604     {
605 #ifdef TC_M68K
606       *lp++ = 0;
607 #endif
608       *lp++ = (1 << (LITTLENUM_NUMBER_OF_BITS - 1)
609                | next_bits (LITTLENUM_NUMBER_OF_BITS - 1));
610     }
611
612   /* The rest of the words are just mantissa bits.  */
613   while (lp < words_end)
614     *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
615
616   if (next_bits (1))
617     {
618       unsigned long carry;
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.
624          Is that clear?  */
625
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.
632          #endif */
633       for (carry = 1, lp--; carry; lp--)
634         {
635           carry = *lp + carry;
636           *lp = carry;
637           carry >>= LITTLENUM_NUMBER_OF_BITS;
638           if (lp == words)
639             break;
640         }
641       if (precision == X_PRECISION && exponent_bits == 15)
642         {
643           /* Extended precision numbers have an explicit integer bit
644              that we may have to restore.  */
645           if (lp == words)
646             {
647 #ifdef TC_M68K
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];
651               words[1] = 0;
652               lp++;
653 #endif
654               /* Put back the integer bit.  */
655               lp[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
656             }
657         }
658       if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)))
659         {
660           /* We leave return_value alone: admit we read the number,
661              but return a floating exception because we can't encode
662              the number.  */
663           *words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1));
664         }
665     }
666   return return_value;
667 }
668
669 #ifdef TEST
670 char *
671 print_gen (gen)
672      FLONUM_TYPE *gen;
673 {
674   FLONUM_TYPE f;
675   LITTLENUM_TYPE arr[10];
676   double dv;
677   float fv;
678   static char sbuf[40];
679
680   if (gen)
681     {
682       f = generic_floating_point_number;
683       generic_floating_point_number = *gen;
684     }
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);
691
692   if (gen)
693     generic_floating_point_number = f;
694
695   return (sbuf);
696 }
697 #endif
698
699 extern const char FLT_CHARS[];
700 #define MAX_LITTLENUMS 6
701
702 /* This is a utility function called from various tc-*.c files.  It
703    is here in order to reduce code duplication.
704    
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.
710
711    An error message is returned, or a NULL pointer if everything went OK.  */
712
713 char *
714 ieee_md_atof (int type,
715               char *litP,
716               int *sizeP,
717               bfd_boolean big_wordian)
718 {
719   LITTLENUM_TYPE words[MAX_LITTLENUMS];
720   LITTLENUM_TYPE *wordP;
721   char *t;
722   int prec = 0;
723
724   if (strchr (FLT_CHARS, type) != NULL)
725     {
726       switch (type)
727         {
728         case 'f':
729         case 'F':
730         case 's':
731         case 'S':
732           prec = F_PRECISION;
733           break;
734
735         case 'd':
736         case 'D':
737         case 'r':
738         case 'R':
739           prec = D_PRECISION;
740           break;
741
742         case 't':
743         case 'T':
744           prec = X_PRECISION;
745           type = 'x';           /* This is what atof_ieee() understands.  */
746           break;
747
748         case 'x':
749         case 'X':
750         case 'p':
751         case 'P':
752 #ifdef TC_M68K
753           /* Note: on the m68k there is a gap of 16 bits (one littlenum)
754              between the exponent and mantissa.  Hence the precision is
755              6 and not 5.  */
756           prec = P_PRECISION + 1;
757 #else
758           prec = P_PRECISION;
759 #endif
760           break;
761
762         default:
763           break;
764         }
765     }
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.
770
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')
776     prec = F_PRECISION;
777   else if (type == 'd')
778     prec = D_PRECISION;
779
780   if (prec == 0)
781     {
782       *sizeP = 0;
783       return _("Unrecognized or unsupported floating point constant");
784     }
785
786   gas_assert (prec <= MAX_LITTLENUMS);
787
788   t = atof_ieee (input_line_pointer, type, words);
789   if (t)
790     input_line_pointer = t;
791
792   *sizeP = prec * sizeof (LITTLENUM_TYPE);
793
794   if (big_wordian)
795     {
796       for (wordP = words; prec --;)
797         {
798           md_number_to_chars (litP, (valueT) (* wordP ++), sizeof (LITTLENUM_TYPE));
799           litP += sizeof (LITTLENUM_TYPE);
800         }
801     }
802   else
803     {
804       for (wordP = words + prec; prec --;)
805         {
806           md_number_to_chars (litP, (valueT) (* -- wordP), sizeof (LITTLENUM_TYPE));
807           litP += sizeof (LITTLENUM_TYPE);
808         }
809     }
810
811   return NULL;
812 }