libiberty/floatformat.c

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