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