gas/config/atof-ieee.c

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