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