• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
79 static int bits_left_in_littlenum;
80 static int littlenums_left;
81 static LITTLENUM_TYPE *littlenum_pointer;
82 
83 static int
next_bits(int number_of_bits)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
unget_bits(int num)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
make_invalid_floating_point_number(LITTLENUM_TYPE * words)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 
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 *
atof_ieee(char * str,int what_kind,LITTLENUM_TYPE * words)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
gen_to_words(LITTLENUM_TYPE * words,int precision,long exponent_bits)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 *
print_gen(gen)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 *
ieee_md_atof(int type,char * litP,int * sizeP,bfd_boolean big_wordian)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 }
813