gas/config/atof-ieee.c

   1 /* atof_ieee.c - turn a Flonum into an IEEE floating point number
   2    Copyright (C) 1987, 92, 93, 94, 95, 96, 97, 1998
   3    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 2, 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, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 #include "as.h"
  23
  24 /* Flonums returned here.  */
  25 extern FLONUM_TYPE generic_floating_point_number;
  26
  27 static int next_bits PARAMS ((int));
  28 static void unget_bits PARAMS ((int));
  29 static void make_invalid_floating_point_number PARAMS ((LITTLENUM_TYPE *));
  30
  31 extern const char EXP_CHARS[];
  32 /* Precision in LittleNums. */
  33 /* Don't count the gap in the m68k extended precision format.  */
  34 #define MAX_PRECISION (5)
  35 #define F_PRECISION (2)
  36 #define D_PRECISION (4)
  37 #define X_PRECISION (5)
  38 #define P_PRECISION (5)
  39
  40 /* Length in LittleNums of guard bits. */
  41 #define GUARD (2)
  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
  81 static int bits_left_in_littlenum;
  82 static int littlenums_left;
  83 static LITTLENUM_TYPE *littlenum_pointer;
  84
  85 static int
  86 next_bits (number_of_bits)
  87      int number_of_bits;
  88 {
  89   int return_value;
  90
  91   if (!littlenums_left)
  92     return (0);
  93   if (number_of_bits >= bits_left_in_littlenum)
  94     {
  95       return_value = mask[bits_left_in_littlenum] & *littlenum_pointer;
  96       number_of_bits -= bits_left_in_littlenum;
  97       return_value <<= number_of_bits;
  98
  99       if (--littlenums_left)
 100         {
 101           bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
 102           --littlenum_pointer;
 103           return_value |= (*littlenum_pointer >> bits_left_in_littlenum) & mask[number_of_bits];
 104         }
 105     }
 106   else
 107     {
 108       bits_left_in_littlenum -= number_of_bits;
 109       return_value = mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum);
 110     }
 111   return (return_value);
 112 }
 113
 114 /* Num had better be less than LITTLENUM_NUMBER_OF_BITS */
 115 static void
 116 unget_bits (num)
 117      int num;
 118 {
 119   if (!littlenums_left)
 120     {
 121       ++littlenum_pointer;
 122       ++littlenums_left;
 123       bits_left_in_littlenum = num;
 124     }
 125   else if (bits_left_in_littlenum + num > LITTLENUM_NUMBER_OF_BITS)
 126     {
 127       bits_left_in_littlenum = num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum);
 128       ++littlenum_pointer;
 129       ++littlenums_left;
 130     }
 131   else
 132     bits_left_in_littlenum += num;
 133 }
 134
 135 static void
 136 make_invalid_floating_point_number (words)
 137      LITTLENUM_TYPE *words;
 138 {
 139   as_bad (_("cannot create floating-point number"));
 140   words[0] = (LITTLENUM_TYPE) ((unsigned) -1) >> 1; /* Zero the leftmost bit */
 141   words[1] = (LITTLENUM_TYPE) -1;
 142   words[2] = (LITTLENUM_TYPE) -1;
 143   words[3] = (LITTLENUM_TYPE) -1;
 144   words[4] = (LITTLENUM_TYPE) -1;
 145   words[5] = (LITTLENUM_TYPE) -1;
 146 }
 147 \f
 148 /************************************************************************\
 149  *      Warning: this returns 16-bit LITTLENUMs. It is up to the caller *
 150  *      to figure out any alignment problems and to conspire for the    *
 151  *      bytes/word to be emitted in the right order. Bigendians beware! *
 152  *                                                                      *
 153 \************************************************************************/
 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 char *
 161 atof_ieee (str, what_kind, words)
 162      char *str;                 /* Text to convert to binary. */
 163      char what_kind;            /* 'd', 'f', 'g', 'h' */
 164      LITTLENUM_TYPE *words;     /* Build the binary here. */
 165 {
 166   /* Extra bits for zeroed low-order bits.  The 1st MAX_PRECISION are
 167      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
 222       precision = P_PRECISION;
 223       exponent_bits = -1;
 224       break;
 225
 226     default:
 227       make_invalid_floating_point_number (words);
 228       return (NULL);
 229     }
 230
 231   generic_floating_point_number.high
 232     = generic_floating_point_number.low + precision - 1 + GUARD;
 233
 234   if (atof_generic (&return_value, ".", EXP_CHARS,
 235                     &generic_floating_point_number))
 236     {
 237       make_invalid_floating_point_number (words);
 238       return (NULL);
 239     }
 240   gen_to_words (words, precision, exponent_bits);
 241
 242   /* Restore the generic_floating_point_number's storage alloc (and
 243      everything else).  */
 244   generic_floating_point_number = save_gen_flonum;
 245
 246   return return_value;
 247 }
 248
 249 /* Turn generic_floating_point_number into a real float/double/extended.  */
 250 int
 251 gen_to_words (words, precision, exponent_bits)
 252      LITTLENUM_TYPE *words;
 253      int precision;
 254      long exponent_bits;
 255 {
 256   int return_value = 0;
 257
 258   long exponent_1;
 259   long exponent_2;
 260   long exponent_3;
 261   long exponent_4;
 262   int exponent_skippage;
 263   LITTLENUM_TYPE word1;
 264   LITTLENUM_TYPE *lp;
 265   LITTLENUM_TYPE *words_end;
 266
 267   words_end = words + precision;
 268 #ifdef TC_M68K
 269   if (precision == X_PRECISION)
 270     /* On the m68k the extended precision format has a gap of 16 bits
 271        between the exponent and the mantissa.  */
 272     words_end++;
 273 #endif
 274
 275   if (generic_floating_point_number.low > generic_floating_point_number.leader)
 276     {
 277       /* 0.0e0 seen. */
 278       if (generic_floating_point_number.sign == '+')
 279         words[0] = 0x0000;
 280       else
 281         words[0] = 0x8000;
 282       memset (&words[1], '\0',
 283               (words_end - words - 1) * sizeof (LITTLENUM_TYPE));
 284       return (return_value);
 285     }
 286
 287   /* NaN:  Do the right thing */
 288   if (generic_floating_point_number.sign == 0)
 289     {
 290       if (precision == F_PRECISION)
 291         {
 292           words[0] = 0x7fff;
 293           words[1] = 0xffff;
 294         }
 295       else if (precision == X_PRECISION)
 296         {
 297 #ifdef TC_M68K
 298           words[0] = 0x7fff;
 299           words[1] = 0;
 300           words[2] = 0xffff;
 301           words[3] = 0xffff;
 302           words[4] = 0xffff;
 303           words[5] = 0xffff;
 304 #else /* ! TC_M68K */
 305 #ifdef TC_I386
 306           words[0] = 0xffff;
 307           words[1] = 0xc000;
 308           words[2] = 0;
 309           words[3] = 0;
 310           words[4] = 0;
 311 #else /* ! TC_I386 */
 312           abort ();
 313 #endif /* ! TC_I386 */
 314 #endif /* ! TC_M68K */
 315         }
 316       else
 317         {
 318           words[0] = 0x7fff;
 319           words[1] = 0xffff;
 320           words[2] = 0xffff;
 321           words[3] = 0xffff;
 322         }
 323       return return_value;
 324     }
 325   else if (generic_floating_point_number.sign == 'P')
 326     {
 327       /* +INF:  Do the right thing */
 328       if (precision == F_PRECISION)
 329         {
 330           words[0] = 0x7f80;
 331           words[1] = 0;
 332         }
 333       else if (precision == X_PRECISION)
 334         {
 335 #ifdef TC_M68K
 336           words[0] = 0x7fff;
 337           words[1] = 0;
 338           words[2] = 0;
 339           words[3] = 0;
 340           words[4] = 0;
 341           words[5] = 0;
 342 #else /* ! TC_M68K */
 343 #ifdef TC_I386
 344           words[0] = 0x7fff;
 345           words[1] = 0x8000;
 346           words[2] = 0;
 347           words[3] = 0;
 348           words[4] = 0;
 349 #else /* ! TC_I386 */
 350           abort ();
 351 #endif /* ! TC_I386 */
 352 #endif /* ! TC_M68K */
 353         }
 354       else
 355         {
 356           words[0] = 0x7ff0;
 357           words[1] = 0;
 358           words[2] = 0;
 359           words[3] = 0;
 360         }
 361       return (return_value);
 362     }
 363   else if (generic_floating_point_number.sign == 'N')
 364     {
 365       /* Negative INF */
 366       if (precision == F_PRECISION)
 367         {
 368           words[0] = 0xff80;
 369           words[1] = 0x0;
 370         }
 371       else if (precision == X_PRECISION)
 372         {
 373 #ifdef TC_M68K
 374           words[0] = 0xffff;
 375           words[1] = 0;
 376           words[2] = 0;
 377           words[3] = 0;
 378           words[4] = 0;
 379           words[5] = 0;
 380 #else /* ! TC_M68K */
 381 #ifdef TC_I386
 382           words[0] = 0xffff;
 383           words[1] = 0x8000;
 384           words[2] = 0;
 385           words[3] = 0;
 386           words[4] = 0;
 387 #else /* ! TC_I386 */
 388           abort ();
 389 #endif /* ! TC_I386 */
 390 #endif /* ! TC_M68K */
 391         }
 392       else
 393         {
 394           words[0] = 0xfff0;
 395           words[1] = 0x0;
 396           words[2] = 0x0;
 397           words[3] = 0x0;
 398         }
 399       return (return_value);
 400     }
 401   /*
 402    * The floating point formats we support have:
 403    * Bit 15 is sign bit.
 404    * Bits 14:n are excess-whatever exponent.
 405    * Bits n-1:0 (if any) are most significant bits of fraction.
 406    * Bits 15:0 of the next word(s) are the next most significant bits.
 407    *
 408    * So we need: number of bits of exponent, number of bits of
 409    * mantissa.
 410    */
 411   bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
 412   littlenum_pointer = generic_floating_point_number.leader;
 413   littlenums_left = (1
 414                      + generic_floating_point_number.leader
 415                      - generic_floating_point_number.low);
 416   /* Seek (and forget) 1st significant bit */
 417   for (exponent_skippage = 0; !next_bits (1); ++exponent_skippage);;
 418   exponent_1 = (generic_floating_point_number.exponent
 419                 + generic_floating_point_number.leader
 420                 + 1
 421                 - generic_floating_point_number.low);
 422   /* Radix LITTLENUM_RADIX, point just higher than
 423      generic_floating_point_number.leader. */
 424   exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
 425   /* Radix 2. */
 426   exponent_3 = exponent_2 - exponent_skippage;
 427   /* Forget leading zeros, forget 1st bit. */
 428   exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);
 429   /* Offset exponent. */
 430
 431   lp = words;
 432
 433   /* Word 1. Sign, exponent and perhaps high bits. */
 434   word1 = ((generic_floating_point_number.sign == '+')
 435            ? 0
 436            : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
 437
 438   /* Assume 2's complement integers. */
 439   if (exponent_4 <= 0)
 440     {
 441       int prec_bits;
 442       int num_bits;
 443
 444       unget_bits (1);
 445       num_bits = -exponent_4;
 446       prec_bits = LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits);
 447 #ifdef TC_I386
 448       if (precision == X_PRECISION && exponent_bits == 15)
 449         {
 450           /* On the i386 a denormalized extended precision float is
 451              shifted down by one, effectively decreasing the exponent
 452              bias by one.  */
 453           prec_bits -= 1;
 454           num_bits += 1;
 455         }
 456 #endif
 457
 458       if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits)
 459         {
 460           /* Bigger than one littlenum */
 461           num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits;
 462           *lp++ = word1;
 463           if (num_bits + exponent_bits + 1 > precision * LITTLENUM_NUMBER_OF_BITS)
 464             {
 465               /* Exponent overflow */
 466               make_invalid_floating_point_number (words);
 467               return (return_value);
 468             }
 469 #ifdef TC_M68K
 470           if (precision == X_PRECISION && exponent_bits == 15)
 471             *lp++ = 0;
 472 #endif
 473           while (num_bits >= LITTLENUM_NUMBER_OF_BITS)
 474             {
 475               num_bits -= LITTLENUM_NUMBER_OF_BITS;
 476               *lp++ = 0;
 477             }
 478           if (num_bits)
 479             *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - (num_bits));
 480         }
 481       else
 482         {
 483           if (precision == X_PRECISION && exponent_bits == 15)
 484             {
 485               *lp++ = word1;
 486 #ifdef TC_M68K
 487               *lp++ = 0;
 488 #endif
 489               *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - num_bits);
 490             }
 491           else
 492             {
 493               word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - (exponent_bits + num_bits));
 494               *lp++ = word1;
 495             }
 496         }
 497       while (lp < words_end)
 498         *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
 499
 500       /* Round the mantissa up, but don't change the number */
 501       if (next_bits (1))
 502         {
 503           --lp;
 504           if (prec_bits >= LITTLENUM_NUMBER_OF_BITS)
 505             {
 506               int n = 0;
 507               int tmp_bits;
 508
 509               n = 0;
 510               tmp_bits = prec_bits;
 511               while (tmp_bits > LITTLENUM_NUMBER_OF_BITS)
 512                 {
 513                   if (lp[n] != (LITTLENUM_TYPE) - 1)
 514                     break;
 515                   --n;
 516                   tmp_bits -= LITTLENUM_NUMBER_OF_BITS;
 517                 }
 518               if (tmp_bits > LITTLENUM_NUMBER_OF_BITS
 519                   || (lp[n] & mask[tmp_bits]) != mask[tmp_bits]
 520                   || (prec_bits != (precision * LITTLENUM_NUMBER_OF_BITS
 521                                     - exponent_bits - 1)
 522 #ifdef TC_I386
 523                       /* An extended precision float with only the integer
 524                          bit set would be invalid.  That must be converted
 525                          to the smallest normalized number.  */
 526                       && !(precision == X_PRECISION
 527                            && prec_bits == (precision * LITTLENUM_NUMBER_OF_BITS
 528                                             - exponent_bits - 2))
 529 #endif
 530                       ))
 531                 {
 532                   unsigned long carry;
 533
 534                   for (carry = 1; carry && (lp >= words); lp--)
 535                     {
 536                       carry = *lp + carry;
 537                       *lp = carry;
 538                       carry >>= LITTLENUM_NUMBER_OF_BITS;
 539                     }
 540                 }
 541               else
 542                 {
 543                   /* This is an overflow of the denormal numbers.  We
 544                      need to forget what we have produced, and instead
 545                      generate the smallest normalized number.  */
 546                   lp = words;
 547                   word1 = ((generic_floating_point_number.sign == '+')
 548                            ? 0
 549                            : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
 550                   word1 |= (1
 551                             << ((LITTLENUM_NUMBER_OF_BITS - 1)
 552                                 - exponent_bits));
 553                   *lp++ = word1;
 554 #ifdef TC_I386
 555                   /* Set the integer bit in the extended precision format.
 556                      This cannot happen on the m68k where the mantissa
 557                      just overflows into the integer bit above.  */
 558                   if (precision == X_PRECISION)
 559                     *lp++ = 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
 560 #endif
 561                   while (lp < words_end)
 562                     *lp++ = 0;
 563                 }
 564             }
 565           else
 566             *lp += 1;
 567         }
 568
 569       return return_value;
 570     }
 571   else if ((unsigned long) exponent_4 >= mask[exponent_bits])
 572     {
 573       /*
 574        * Exponent overflow. Lose immediately.
 575        */
 576
 577       /*
 578        * We leave return_value alone: admit we read the
 579        * number, but return a floating exception
 580        * because we can't encode the number.
 581        */
 582       make_invalid_floating_point_number (words);
 583       return return_value;
 584     }
 585   else
 586     {
 587       word1 |= (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits))
 588         | next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits);
 589     }
 590
 591   *lp++ = word1;
 592
 593   /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the
 594      middle.  Either way, it is then followed by a 1 bit. */
 595   if (exponent_bits == 15 && precision == X_PRECISION)
 596     {
 597 #ifdef TC_M68K
 598       *lp++ = 0;
 599 #endif
 600       *lp++ = (1 << (LITTLENUM_NUMBER_OF_BITS - 1)
 601                | next_bits (LITTLENUM_NUMBER_OF_BITS - 1));
 602     }
 603
 604   /* The rest of the words are just mantissa bits. */
 605   while (lp < words_end)
 606     *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
 607
 608   if (next_bits (1))
 609     {
 610       unsigned long carry;
 611       /*
 612        * Since the NEXT bit is a 1, round UP the mantissa.
 613        * The cunning design of these hidden-1 floats permits
 614        * us to let the mantissa overflow into the exponent, and
 615        * it 'does the right thing'. However, we lose if the
 616        * highest-order bit of the lowest-order word flips.
 617        * Is that clear?
 618        */
 619
 620       /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
 621          Please allow at least 1 more bit in carry than is in a LITTLENUM.
 622          We need that extra bit to hold a carry during a LITTLENUM carry
 623          propagation. Another extra bit (kept 0) will assure us that we
 624          don't get a sticky sign bit after shifting right, and that
 625          permits us to propagate the carry without any masking of bits.
 626          #endif */
 627       for (carry = 1, lp--; carry && (lp >= words); lp--)
 628         {
 629           carry = *lp + carry;
 630           *lp = carry;
 631           carry >>= LITTLENUM_NUMBER_OF_BITS;
 632         }
 633       if (precision == X_PRECISION && exponent_bits == 15)
 634         {
 635           /* Extended precision numbers have an explicit integer bit
 636              that we may have to restore.  */
 637           if (lp == words)
 638             {
 639 #ifdef TC_M68K
 640               /* On the m68k there is a gap of 16 bits.  We must
 641                  explicitly propagate the carry into the exponent. */
 642               words[0] += words[1];
 643               words[1] = 0;
 644               lp++;
 645 #endif
 646               /* Put back the integer bit.  */
 647               lp[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
 648             }
 649         }
 650       if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)))
 651         {
 652           /* We leave return_value alone: admit we read the
 653            * number, but return a floating exception
 654            * because we can't encode the number.
 655            */
 656           *words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1));
 657           /* make_invalid_floating_point_number (words); */
 658           /* return return_value; */
 659         }
 660     }
 661   return (return_value);
 662 }
 663
 664 #if 0 /* unused */
 665 /* This routine is a real kludge.  Someone really should do it better,
 666    but I'm too lazy, and I don't understand this stuff all too well
 667    anyway. (JF)  */
 668 static void
 669 int_to_gen (x)
 670      long x;
 671 {
 672   char buf[20];
 673   char *bufp;
 674
 675   sprintf (buf, "%ld", x);
 676   bufp = &buf[0];
 677   if (atof_generic (&bufp, ".", EXP_CHARS, &generic_floating_point_number))
 678     as_bad (_("Error converting number to floating point (Exponent overflow?)"));
 679 }
 680 #endif
 681
 682 #ifdef TEST
 683 char *
 684 print_gen (gen)
 685      FLONUM_TYPE *gen;
 686 {
 687   FLONUM_TYPE f;
 688   LITTLENUM_TYPE arr[10];
 689   double dv;
 690   float fv;
 691   static char sbuf[40];
 692
 693   if (gen)
 694     {
 695       f = generic_floating_point_number;
 696       generic_floating_point_number = *gen;
 697     }
 698   gen_to_words (&arr[0], 4, 11);
 699   memcpy (&dv, &arr[0], sizeof (double));
 700   sprintf (sbuf, "%x %x %x %x %.14G   ", arr[0], arr[1], arr[2], arr[3], dv);
 701   gen_to_words (&arr[0], 2, 8);
 702   memcpy (&fv, &arr[0], sizeof (float));
 703   sprintf (sbuf + strlen (sbuf), "%x %x %.12g\n", arr[0], arr[1], fv);
 704
 705   if (gen)
 706     {
 707       generic_floating_point_number = f;
 708     }
 709
 710   return (sbuf);
 711 }
 712
 713 #endif
 714
 715 /* end of atof-ieee.c */