gas/config/atof-ieee.c

   1 /* atof_ieee.c - turn a Flonum into an IEEE floating point number
   2    Copyright (C) 1987-2015 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 }