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 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   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 }