libiberty/floatformat.c

   1 /* IEEE floating point support routines, for GDB, the GNU Debugger.
   2    Copyright 1991, 1994, 1999, 2000, 2003, 2005, 2006, 2010, 2012, 2015
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program 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 of the License, or
  10 (at your option) any later version.
  11
  12 This program 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 this program; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 /* This is needed to pick up the NAN macro on some systems.  */
  22 #ifndef _GNU_SOURCE
  23 #define _GNU_SOURCE
  24 #endif
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include <math.h>
  31
  32 #ifdef HAVE_STRING_H
  33 #include <string.h>
  34 #endif
  35
  36 /* On some platforms, <float.h> provides DBL_QNAN.  */
  37 #ifdef STDC_HEADERS
  38 #include <float.h>
  39 #endif
  40
  41 #include "ansidecl.h"
  42 #include "libiberty.h"
  43 #include "floatformat.h"
  44
  45 #ifndef INFINITY
  46 #ifdef HUGE_VAL
  47 #define INFINITY HUGE_VAL
  48 #else
  49 #define INFINITY (1.0 / 0.0)
  50 #endif
  51 #endif
  52
  53 #ifndef NAN
  54 #ifdef DBL_QNAN
  55 #define NAN DBL_QNAN
  56 #else
  57 #define NAN (0.0 / 0.0)
  58 #endif
  59 #endif
  60
  61 static int mant_bits_set (const struct floatformat *, const unsigned char *);
  62 static unsigned long get_field (const unsigned char *,
  63                                 enum floatformat_byteorders,
  64                                 unsigned int,
  65                                 unsigned int,
  66                                 unsigned int);
  67 static int floatformat_always_valid (const struct floatformat *fmt,
  68                                      const void *from);
  69
  70 static int
  71 floatformat_always_valid (const struct floatformat *fmt ATTRIBUTE_UNUSED,
  72                           const void *from ATTRIBUTE_UNUSED)
  73 {
  74   return 1;
  75 }
  76
  77 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
  78    going to bother with trying to muck around with whether it is defined in
  79    a system header, what we do if not, etc.  */
  80 #define FLOATFORMAT_CHAR_BIT 8
  81
  82 /* floatformats for IEEE half, single and double, big and little endian.  */
  83 const struct floatformat floatformat_ieee_half_big =
  84 {
  85   floatformat_big, 16, 0, 1, 5, 15, 31, 6, 10,
  86   floatformat_intbit_no,
  87   "floatformat_ieee_half_big",
  88   floatformat_always_valid,
  89   NULL
  90 };
  91 const struct floatformat floatformat_ieee_half_little =
  92 {
  93   floatformat_little, 16, 0, 1, 5, 15, 31, 6, 10,
  94   floatformat_intbit_no,
  95   "floatformat_ieee_half_little",
  96   floatformat_always_valid,
  97   NULL
  98 };
  99 const struct floatformat floatformat_ieee_single_big =
 100 {
 101   floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23,
 102   floatformat_intbit_no,
 103   "floatformat_ieee_single_big",
 104   floatformat_always_valid,
 105   NULL
 106 };
 107 const struct floatformat floatformat_ieee_single_little =
 108 {
 109   floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23,
 110   floatformat_intbit_no,
 111   "floatformat_ieee_single_little",
 112   floatformat_always_valid,
 113   NULL
 114 };
 115 const struct floatformat floatformat_ieee_double_big =
 116 {
 117   floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52,
 118   floatformat_intbit_no,
 119   "floatformat_ieee_double_big",
 120   floatformat_always_valid,
 121   NULL
 122 };
 123 const struct floatformat floatformat_ieee_double_little =
 124 {
 125   floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52,
 126   floatformat_intbit_no,
 127   "floatformat_ieee_double_little",
 128   floatformat_always_valid,
 129   NULL
 130 };
 131
 132 /* floatformat for IEEE double, little endian byte order, with big endian word
 133    ordering, as on the ARM.  */
 134
 135 const struct floatformat floatformat_ieee_double_littlebyte_bigword =
 136 {
 137   floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52,
 138   floatformat_intbit_no,
 139   "floatformat_ieee_double_littlebyte_bigword",
 140   floatformat_always_valid,
 141   NULL
 142 };
 143
 144 /* floatformat for VAX.  Not quite IEEE, but close enough.  */
 145
 146 const struct floatformat floatformat_vax_f =
 147 {
 148   floatformat_vax, 32, 0, 1, 8, 129, 0, 9, 23,
 149   floatformat_intbit_no,
 150   "floatformat_vax_f",
 151   floatformat_always_valid,
 152   NULL
 153 };
 154 const struct floatformat floatformat_vax_d =
 155 {
 156   floatformat_vax, 64, 0, 1, 8, 129, 0, 9, 55,
 157   floatformat_intbit_no,
 158   "floatformat_vax_d",
 159   floatformat_always_valid,
 160   NULL
 161 };
 162 const struct floatformat floatformat_vax_g =
 163 {
 164   floatformat_vax, 64, 0, 1, 11, 1025, 0, 12, 52,
 165   floatformat_intbit_no,
 166   "floatformat_vax_g",
 167   floatformat_always_valid,
 168   NULL
 169 };
 170
 171 static int floatformat_i387_ext_is_valid (const struct floatformat *fmt,
 172                                           const void *from);
 173
 174 static int
 175 floatformat_i387_ext_is_valid (const struct floatformat *fmt, const void *from)
 176 {
 177   /* In the i387 double-extended format, if the exponent is all ones,
 178      then the integer bit must be set.  If the exponent is neither 0
 179      nor ~0, the intbit must also be set.  Only if the exponent is
 180      zero can it be zero, and then it must be zero.  */
 181   unsigned long exponent, int_bit;
 182   const unsigned char *ufrom = (const unsigned char *) from;
 183
 184   exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
 185                         fmt->exp_start, fmt->exp_len);
 186   int_bit = get_field (ufrom, fmt->byteorder, fmt->totalsize,
 187                        fmt->man_start, 1);
 188
 189   if ((exponent == 0) != (int_bit == 0))
 190     return 0;
 191   else
 192     return 1;
 193 }
 194
 195 const struct floatformat floatformat_i387_ext =
 196 {
 197   floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
 198   floatformat_intbit_yes,
 199   "floatformat_i387_ext",
 200   floatformat_i387_ext_is_valid,
 201   NULL
 202 };
 203 const struct floatformat floatformat_m68881_ext =
 204 {
 205   /* Note that the bits from 16 to 31 are unused.  */
 206   floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64,
 207   floatformat_intbit_yes,
 208   "floatformat_m68881_ext",
 209   floatformat_always_valid,
 210   NULL
 211 };
 212 const struct floatformat floatformat_i960_ext =
 213 {
 214   /* Note that the bits from 0 to 15 are unused.  */
 215   floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64,
 216   floatformat_intbit_yes,
 217   "floatformat_i960_ext",
 218   floatformat_always_valid,
 219   NULL
 220 };
 221 const struct floatformat floatformat_m88110_ext =
 222 {
 223   floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
 224   floatformat_intbit_yes,
 225   "floatformat_m88110_ext",
 226   floatformat_always_valid,
 227   NULL
 228 };
 229 const struct floatformat floatformat_m88110_harris_ext =
 230 {
 231   /* Harris uses raw format 128 bytes long, but the number is just an ieee
 232      double, and the last 64 bits are wasted. */
 233   floatformat_big,128, 0, 1, 11,  0x3ff,  0x7ff, 12, 52,
 234   floatformat_intbit_no,
 235   "floatformat_m88110_ext_harris",
 236   floatformat_always_valid,
 237   NULL
 238 };
 239 const struct floatformat floatformat_arm_ext_big =
 240 {
 241   /* Bits 1 to 16 are unused.  */
 242   floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
 243   floatformat_intbit_yes,
 244   "floatformat_arm_ext_big",
 245   floatformat_always_valid,
 246   NULL
 247 };
 248 const struct floatformat floatformat_arm_ext_littlebyte_bigword =
 249 {
 250   /* Bits 1 to 16 are unused.  */
 251   floatformat_littlebyte_bigword, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
 252   floatformat_intbit_yes,
 253   "floatformat_arm_ext_littlebyte_bigword",
 254   floatformat_always_valid,
 255   NULL
 256 };
 257 const struct floatformat floatformat_ia64_spill_big =
 258 {
 259   floatformat_big, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
 260   floatformat_intbit_yes,
 261   "floatformat_ia64_spill_big",
 262   floatformat_always_valid,
 263   NULL
 264 };
 265 const struct floatformat floatformat_ia64_spill_little =
 266 {
 267   floatformat_little, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
 268   floatformat_intbit_yes,
 269   "floatformat_ia64_spill_little",
 270   floatformat_always_valid,
 271   NULL
 272 };
 273 const struct floatformat floatformat_ia64_quad_big =
 274 {
 275   floatformat_big, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
 276   floatformat_intbit_no,
 277   "floatformat_ia64_quad_big",
 278   floatformat_always_valid,
 279   NULL
 280 };
 281 const struct floatformat floatformat_ia64_quad_little =
 282 {
 283   floatformat_little, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
 284   floatformat_intbit_no,
 285   "floatformat_ia64_quad_little",
 286   floatformat_always_valid,
 287   NULL
 288 };
 289
 290 static int
 291 floatformat_ibm_long_double_is_valid (const struct floatformat *fmt,
 292                                       const void *from)
 293 {
 294   const unsigned char *ufrom = (const unsigned char *) from;
 295   const struct floatformat *hfmt = fmt->split_half;
 296   long top_exp, bot_exp;
 297   int top_nan = 0;
 298
 299   top_exp = get_field (ufrom, hfmt->byteorder, hfmt->totalsize,
 300                        hfmt->exp_start, hfmt->exp_len);
 301   bot_exp = get_field (ufrom + 8, hfmt->byteorder, hfmt->totalsize,
 302                        hfmt->exp_start, hfmt->exp_len);
 303
 304   if ((unsigned long) top_exp == hfmt->exp_nan)
 305     top_nan = mant_bits_set (hfmt, ufrom);
 306
 307   /* A NaN is valid with any low part.  */
 308   if (top_nan)
 309     return 1;
 310
 311   /* An infinity, zero or denormal requires low part 0 (positive or
 312      negative).  */
 313   if ((unsigned long) top_exp == hfmt->exp_nan || top_exp == 0)
 314     {
 315       if (bot_exp != 0)
 316         return 0;
 317
 318       return !mant_bits_set (hfmt, ufrom + 8);
 319     }
 320
 321   /* The top part is now a finite normal value.  The long double value
 322      is the sum of the two parts, and the top part must equal the
 323      result of rounding the long double value to nearest double.  Thus
 324      the bottom part must be <= 0.5ulp of the top part in absolute
 325      value, and if it is < 0.5ulp then the long double is definitely
 326      valid.  */
 327   if (bot_exp < top_exp - 53)
 328     return 1;
 329   if (bot_exp > top_exp - 53 && bot_exp != 0)
 330     return 0;
 331   if (bot_exp == 0)
 332     {
 333       /* The bottom part is 0 or denormal.  Determine which, and if
 334          denormal the first two set bits.  */
 335       int first_bit = -1, second_bit = -1, cur_bit;
 336       for (cur_bit = 0; (unsigned int) cur_bit < hfmt->man_len; cur_bit++)
 337         if (get_field (ufrom + 8, hfmt->byteorder, hfmt->totalsize,
 338                        hfmt->man_start + cur_bit, 1))
 339           {
 340             if (first_bit == -1)
 341               first_bit = cur_bit;
 342             else
 343               {
 344                 second_bit = cur_bit;
 345                 break;
 346               }
 347           }
 348       /* Bottom part 0 is OK.  */
 349       if (first_bit == -1)
 350         return 1;
 351       /* The real exponent of the bottom part is -first_bit.  */
 352       if (-first_bit < top_exp - 53)
 353         return 1;
 354       if (-first_bit > top_exp - 53)
 355         return 0;
 356       /* The bottom part is at least 0.5ulp of the top part.  For this
 357          to be OK, the bottom part must be exactly 0.5ulp (i.e. no
 358          more bits set) and the top part must have last bit 0.  */
 359       if (second_bit != -1)
 360         return 0;
 361       return !get_field (ufrom, hfmt->byteorder, hfmt->totalsize,
 362                          hfmt->man_start + hfmt->man_len - 1, 1);
 363     }
 364   else
 365     {
 366       /* The bottom part is at least 0.5ulp of the top part.  For this
 367          to be OK, it must be exactly 0.5ulp (i.e. no explicit bits
 368          set) and the top part must have last bit 0.  */
 369       if (get_field (ufrom, hfmt->byteorder, hfmt->totalsize,
 370                      hfmt->man_start + hfmt->man_len - 1, 1))
 371         return 0;
 372       return !mant_bits_set (hfmt, ufrom + 8);
 373     }
 374 }
 375
 376 const struct floatformat floatformat_ibm_long_double_big =
 377 {
 378   floatformat_big, 128, 0, 1, 11, 1023, 2047, 12, 52,
 379   floatformat_intbit_no,
 380   "floatformat_ibm_long_double_big",
 381   floatformat_ibm_long_double_is_valid,
 382   &floatformat_ieee_double_big
 383 };
 384
 385 const struct floatformat floatformat_ibm_long_double_little =
 386 {
 387   floatformat_little, 128, 0, 1, 11, 1023, 2047, 12, 52,
 388   floatformat_intbit_no,
 389   "floatformat_ibm_long_double_little",
 390   floatformat_ibm_long_double_is_valid,
 391   &floatformat_ieee_double_little
 392 };
 393 \f
 394
 395 #ifndef min
 396 #define min(a, b) ((a) < (b) ? (a) : (b))
 397 #endif
 398
 399 /* Return 1 if any bits are explicitly set in the mantissa of UFROM,
 400    format FMT, 0 otherwise.  */
 401 static int
 402 mant_bits_set (const struct floatformat *fmt, const unsigned char *ufrom)
 403 {
 404   unsigned int mant_bits, mant_off;
 405   int mant_bits_left;
 406
 407   mant_off = fmt->man_start;
 408   mant_bits_left = fmt->man_len;
 409   while (mant_bits_left > 0)
 410     {
 411       mant_bits = min (mant_bits_left, 32);
 412
 413       if (get_field (ufrom, fmt->byteorder, fmt->totalsize,
 414                      mant_off, mant_bits) != 0)
 415         return 1;
 416
 417       mant_off += mant_bits;
 418       mant_bits_left -= mant_bits;
 419     }
 420   return 0;
 421 }
 422
 423 /* Extract a field which starts at START and is LEN bits long.  DATA and
 424    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
 425 static unsigned long
 426 get_field (const unsigned char *data, enum floatformat_byteorders order,
 427            unsigned int total_len, unsigned int start, unsigned int len)
 428 {
 429   unsigned long result = 0;
 430   unsigned int cur_byte;
 431   int lo_bit, hi_bit, cur_bitshift = 0;
 432   int nextbyte = (order == floatformat_little) ? 1 : -1;
 433
 434   /* Start is in big-endian bit order!  Fix that first.  */
 435   start = total_len - (start + len);
 436
 437   /* Start at the least significant part of the field.  */
 438   if (order == floatformat_little)
 439     cur_byte = start / FLOATFORMAT_CHAR_BIT;
 440   else
 441     cur_byte = (total_len - start - 1) / FLOATFORMAT_CHAR_BIT;
 442
 443   lo_bit = start % FLOATFORMAT_CHAR_BIT;
 444   hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT);
 445
 446   do
 447     {
 448       unsigned int shifted = *(data + cur_byte) >> lo_bit;
 449       unsigned int bits = hi_bit - lo_bit;
 450       unsigned int mask = (1 << bits) - 1;
 451       result |= (shifted & mask) << cur_bitshift;
 452       len -= bits;
 453       cur_bitshift += bits;
 454       cur_byte += nextbyte;
 455       lo_bit = 0;
 456       hi_bit = min (len, FLOATFORMAT_CHAR_BIT);
 457     }
 458   while (len != 0);
 459
 460   return result;
 461 }
 462
 463 /* Convert from FMT to a double.
 464    FROM is the address of the extended float.
 465    Store the double in *TO.  */
 466
 467 void
 468 floatformat_to_double (const struct floatformat *fmt,
 469                        const void *from, double *to)
 470 {
 471   const unsigned char *ufrom = (const unsigned char *) from;
 472   double dto;
 473   long exponent;
 474   unsigned long mant;
 475   unsigned int mant_bits, mant_off;
 476   int mant_bits_left;
 477
 478   /* Split values are not handled specially, since the top half has
 479      the correctly rounded double value (in the only supported case of
 480      split values).  */
 481
 482   exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
 483                         fmt->exp_start, fmt->exp_len);
 484
 485   /* If the exponent indicates a NaN, we don't have information to
 486      decide what to do.  So we handle it like IEEE, except that we
 487      don't try to preserve the type of NaN.  FIXME.  */
 488   if ((unsigned long) exponent == fmt->exp_nan)
 489     {
 490       int nan = mant_bits_set (fmt, ufrom);
 491
 492       /* On certain systems (such as GNU/Linux), the use of the
 493          INFINITY macro below may generate a warning that can not be
 494          silenced due to a bug in GCC (PR preprocessor/11931).  The
 495          preprocessor fails to recognise the __extension__ keyword in
 496          conjunction with the GNU/C99 extension for hexadecimal
 497          floating point constants and will issue a warning when
 498          compiling with -pedantic.  */
 499       if (nan)
 500         dto = NAN;
 501       else
 502         dto = INFINITY;
 503
 504       if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
 505         dto = -dto;
 506
 507       *to = dto;
 508
 509       return;
 510     }
 511
 512   mant_bits_left = fmt->man_len;
 513   mant_off = fmt->man_start;
 514   dto = 0.0;
 515
 516   /* Build the result algebraically.  Might go infinite, underflow, etc;
 517      who cares. */
 518
 519   /* For denorms use minimum exponent.  */
 520   if (exponent == 0)
 521     exponent = 1 - fmt->exp_bias;
 522   else
 523     {
 524       exponent -= fmt->exp_bias;
 525
 526       /* If this format uses a hidden bit, explicitly add it in now.
 527          Otherwise, increment the exponent by one to account for the
 528          integer bit.  */
 529
 530       if (fmt->intbit == floatformat_intbit_no)
 531         dto = ldexp (1.0, exponent);
 532       else
 533         exponent++;
 534     }
 535
 536   while (mant_bits_left > 0)
 537     {
 538       mant_bits = min (mant_bits_left, 32);
 539
 540       mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
 541                          mant_off, mant_bits);
 542
 543       dto += ldexp ((double) mant, exponent - mant_bits);
 544       exponent -= mant_bits;
 545       mant_off += mant_bits;
 546       mant_bits_left -= mant_bits;
 547     }
 548
 549   /* Negate it if negative.  */
 550   if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
 551     dto = -dto;
 552   *to = dto;
 553 }
 554 \f
 555 static void put_field (unsigned char *, enum floatformat_byteorders,
 556                        unsigned int,
 557                        unsigned int,
 558                        unsigned int,
 559                        unsigned long);
 560
 561 /* Set a field which starts at START and is LEN bits long.  DATA and
 562    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
 563 static void
 564 put_field (unsigned char *data, enum floatformat_byteorders order,
 565            unsigned int total_len, unsigned int start, unsigned int len,
 566            unsigned long stuff_to_put)
 567 {
 568   unsigned int cur_byte;
 569   int lo_bit, hi_bit;
 570   int nextbyte = (order == floatformat_little) ? 1 : -1;
 571
 572   /* Start is in big-endian bit order!  Fix that first.  */
 573   start = total_len - (start + len);
 574
 575   /* Start at the least significant part of the field.  */
 576   if (order == floatformat_little)
 577     cur_byte = start / FLOATFORMAT_CHAR_BIT;
 578   else
 579     cur_byte = (total_len - start - 1) / FLOATFORMAT_CHAR_BIT;
 580
 581   lo_bit = start % FLOATFORMAT_CHAR_BIT;
 582   hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT);
 583
 584   do
 585     {
 586       unsigned char *byte_ptr = data + cur_byte;
 587       unsigned int bits = hi_bit - lo_bit;
 588       unsigned int mask = ((1 << bits) - 1) << lo_bit;
 589       *byte_ptr = (*byte_ptr & ~mask) | ((stuff_to_put << lo_bit) & mask);
 590       stuff_to_put >>= bits;
 591       len -= bits;
 592       cur_byte += nextbyte;
 593       lo_bit = 0;
 594       hi_bit = min (len, FLOATFORMAT_CHAR_BIT);
 595     }
 596   while (len != 0);
 597 }
 598
 599 /* The converse: convert the double *FROM to an extended float
 600    and store where TO points.  Neither FROM nor TO have any alignment
 601    restrictions.  */
 602
 603 void
 604 floatformat_from_double (const struct floatformat *fmt,
 605                          const double *from, void *to)
 606 {
 607   double dfrom;
 608   int exponent;
 609   double mant;
 610   unsigned int mant_bits, mant_off;
 611   int mant_bits_left;
 612   unsigned char *uto = (unsigned char *) to;
 613
 614   dfrom = *from;
 615   memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
 616
 617   /* Split values are not handled specially, since a bottom half of
 618      zero is correct for any value representable as double (in the
 619      only supported case of split values).  */
 620
 621   /* If negative, set the sign bit.  */
 622   if (dfrom < 0)
 623     {
 624       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
 625       dfrom = -dfrom;
 626     }
 627
 628   if (dfrom == 0)
 629     {
 630       /* 0.0.  */
 631       return;
 632     }
 633
 634   if (dfrom != dfrom)
 635     {
 636       /* NaN.  */
 637       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
 638                  fmt->exp_len, fmt->exp_nan);
 639       /* Be sure it's not infinity, but NaN value is irrelevant.  */
 640       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
 641                  32, 1);
 642       return;
 643     }
 644
 645   if (dfrom + dfrom == dfrom)
 646     {
 647       /* This can only happen for an infinite value (or zero, which we
 648          already handled above).  */
 649       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
 650                  fmt->exp_len, fmt->exp_nan);
 651       return;
 652     }
 653
 654   mant = frexp (dfrom, &exponent);
 655   if (exponent + fmt->exp_bias - 1 > 0)
 656     put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
 657                fmt->exp_len, exponent + fmt->exp_bias - 1);
 658   else
 659     {
 660       /* Handle a denormalized number.  FIXME: What should we do for
 661          non-IEEE formats?  */
 662       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
 663                  fmt->exp_len, 0);
 664       mant = ldexp (mant, exponent + fmt->exp_bias - 1);
 665     }
 666
 667   mant_bits_left = fmt->man_len;
 668   mant_off = fmt->man_start;
 669   while (mant_bits_left > 0)
 670     {
 671       unsigned long mant_long;
 672       mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
 673
 674       mant *= 4294967296.0;
 675       mant_long = (unsigned long)mant;
 676       mant -= mant_long;
 677
 678       /* If the integer bit is implicit, and we are not creating a
 679          denormalized number, then we need to discard it.  */
 680       if ((unsigned int) mant_bits_left == fmt->man_len
 681           && fmt->intbit == floatformat_intbit_no
 682           && exponent + fmt->exp_bias - 1 > 0)
 683         {
 684           mant_long &= 0x7fffffff;
 685           mant_bits -= 1;
 686         }
 687       else if (mant_bits < 32)
 688         {
 689           /* The bits we want are in the most significant MANT_BITS bits of
 690              mant_long.  Move them to the least significant.  */
 691           mant_long >>= 32 - mant_bits;
 692         }
 693
 694       put_field (uto, fmt->byteorder, fmt->totalsize,
 695                  mant_off, mant_bits, mant_long);
 696       mant_off += mant_bits;
 697       mant_bits_left -= mant_bits;
 698     }
 699 }
 700
 701 /* Return non-zero iff the data at FROM is a valid number in format FMT.  */
 702
 703 int
 704 floatformat_is_valid (const struct floatformat *fmt, const void *from)
 705 {
 706   return fmt->is_valid (fmt, from);
 707 }
 708
 709
 710 #ifdef IEEE_DEBUG
 711
 712 #include <stdio.h>
 713
 714 /* This is to be run on a host which uses IEEE floating point.  */
 715
 716 void
 717 ieee_test (double n)
 718 {
 719   double result;
 720
 721   floatformat_to_double (&floatformat_ieee_double_little, &n, &result);
 722   if ((n != result && (! isnan (n) || ! isnan (result)))
 723       || (n < 0 && result >= 0)
 724       || (n >= 0 && result < 0))
 725     printf ("Differ(to): %.20g -> %.20g\n", n, result);
 726
 727   floatformat_from_double (&floatformat_ieee_double_little, &n, &result);
 728   if ((n != result && (! isnan (n) || ! isnan (result)))
 729       || (n < 0 && result >= 0)
 730       || (n >= 0 && result < 0))
 731     printf ("Differ(from): %.20g -> %.20g\n", n, result);
 732
 733 #if 0
 734   {
 735     char exten[16];
 736
 737     floatformat_from_double (&floatformat_m68881_ext, &n, exten);
 738     floatformat_to_double (&floatformat_m68881_ext, exten, &result);
 739     if (n != result)
 740       printf ("Differ(to+from): %.20g -> %.20g\n", n, result);
 741   }
 742 #endif
 743
 744 #if IEEE_DEBUG > 1
 745   /* This is to be run on a host which uses 68881 format.  */
 746   {
 747     long double ex = *(long double *)exten;
 748     if (ex != n)
 749       printf ("Differ(from vs. extended): %.20g\n", n);
 750   }
 751 #endif
 752 }
 753
 754 int
 755 main (void)
 756 {
 757   ieee_test (0.0);
 758   ieee_test (0.5);
 759   ieee_test (1.1);
 760   ieee_test (256.0);
 761   ieee_test (0.12345);
 762   ieee_test (234235.78907234);
 763   ieee_test (-512.0);
 764   ieee_test (-0.004321);
 765   ieee_test (1.2E-70);
 766   ieee_test (1.2E-316);
 767   ieee_test (4.9406564584124654E-324);
 768   ieee_test (- 4.9406564584124654E-324);
 769   ieee_test (- 0.0);
 770   ieee_test (- INFINITY);
 771   ieee_test (- NAN);
 772   ieee_test (INFINITY);
 773   ieee_test (NAN);
 774   return 0;
 775 }
 776 #endif