libiberty/floatformat.c

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