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 394 396 #ifndef min 397 #define min(a, b) ((a) < (b) ? (a) : (b)) 398 #endif 399 400 /* Return 1 if any bits are explicitly set in the mantissa of UFROM, 401 format FMT, 0 otherwise. */ 402 static int 403 mant_bits_set (const struct floatformat *fmt, const unsigned char *ufrom) 404 { 405 unsigned int mant_bits, mant_off; 406 int mant_bits_left; 407 408 mant_off = fmt->man_start; 409 mant_bits_left = fmt->man_len; 410 while (mant_bits_left > 0) 411 { 412 mant_bits = min (mant_bits_left, 32); 413 414 if (get_field (ufrom, fmt->byteorder, fmt->totalsize, 415 mant_off, mant_bits) != 0) 416 return 1; 417 418 mant_off += mant_bits; 419 mant_bits_left -= mant_bits; 420 } 421 return 0; 422 } 423 424 /* Extract a field which starts at START and is LEN bits long. DATA and 425 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ 426 static unsigned long 427 get_field (const unsigned char *data, enum floatformat_byteorders order, 428 unsigned int total_len, unsigned int start, unsigned int len) 429 { 430 unsigned long result = 0; 431 unsigned int cur_byte; 432 int lo_bit, hi_bit, cur_bitshift = 0; 433 int nextbyte = (order == floatformat_little) ? 1 : -1; 434 435 /* Start is in big-endian bit order! Fix that first. */ 436 start = total_len - (start + len); 437 438 /* Start at the least significant part of the field. */ 439 if (order == floatformat_little) 440 cur_byte = start / FLOATFORMAT_CHAR_BIT; 441 else 442 cur_byte = (total_len - start - 1) / FLOATFORMAT_CHAR_BIT; 443 444 lo_bit = start % FLOATFORMAT_CHAR_BIT; 445 hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT); 446 447 do 448 { 449 unsigned int shifted = *(data + cur_byte) >> lo_bit; 450 unsigned int bits = hi_bit - lo_bit; 451 unsigned int mask = (1 << bits) - 1; 452 result |= (shifted & mask) << cur_bitshift; 453 len -= bits; 454 cur_bitshift += bits; 455 cur_byte += nextbyte; 456 lo_bit = 0; 457 hi_bit = min (len, FLOATFORMAT_CHAR_BIT); 458 } 459 while (len != 0); 460 461 return result; 462 } 463 464 /* Convert from FMT to a double. 465 FROM is the address of the extended float. 466 Store the double in *TO. */ 467 468 void 469 floatformat_to_double (const struct floatformat *fmt, 470 const void *from, double *to) 471 { 472 const unsigned char *ufrom = (const unsigned char *) from; 473 double dto; 474 long exponent; 475 unsigned long mant; 476 unsigned int mant_bits, mant_off; 477 int mant_bits_left; 478 479 /* Split values are not handled specially, since the top half has 480 the correctly rounded double value (in the only supported case of 481 split values). */ 482 483 exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize, 484 fmt->exp_start, fmt->exp_len); 485 486 /* If the exponent indicates a NaN, we don't have information to 487 decide what to do. So we handle it like IEEE, except that we 488 don't try to preserve the type of NaN. FIXME. */ 489 if ((unsigned long) exponent == fmt->exp_nan) 490 { 491 int nan = mant_bits_set (fmt, ufrom); 492 493 /* On certain systems (such as GNU/Linux), the use of the 494 INFINITY macro below may generate a warning that can not be 495 silenced due to a bug in GCC (PR preprocessor/11931). The 496 preprocessor fails to recognise the __extension__ keyword in 497 conjunction with the GNU/C99 extension for hexadecimal 498 floating point constants and will issue a warning when 499 compiling with -pedantic. */ 500 if (nan) 501 dto = NAN; 502 else 503 dto = INFINITY; 504 505 if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1)) 506 dto = -dto; 507 508 *to = dto; 509 510 return; 511 } 512 513 mant_bits_left = fmt->man_len; 514 mant_off = fmt->man_start; 515 dto = 0.0; 516 517 /* Build the result algebraically. Might go infinite, underflow, etc; 518 who cares. */ 519 520 /* For denorms use minimum exponent. */ 521 if (exponent == 0) 522 exponent = 1 - fmt->exp_bias; 523 else 524 { 525 exponent -= fmt->exp_bias; 526 527 /* If this format uses a hidden bit, explicitly add it in now. 528 Otherwise, increment the exponent by one to account for the 529 integer bit. */ 530 531 if (fmt->intbit == floatformat_intbit_no) 532 dto = ldexp (1.0, exponent); 533 else 534 exponent++; 535 } 536 537 while (mant_bits_left > 0) 538 { 539 mant_bits = min (mant_bits_left, 32); 540 541 mant = get_field (ufrom, fmt->byteorder, fmt->totalsize, 542 mant_off, mant_bits); 543 544 dto += ldexp ((double) mant, exponent - mant_bits); 545 exponent -= mant_bits; 546 mant_off += mant_bits; 547 mant_bits_left -= mant_bits; 548 } 549 550 /* Negate it if negative. */ 551 if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1)) 552 dto = -dto; 553 *to = dto; 554 } 555 556 static void put_field (unsigned char *, enum floatformat_byteorders, 558 unsigned int, 559 unsigned int, 560 unsigned int, 561 unsigned long); 562 563 /* Set a field which starts at START and is LEN bits long. DATA and 564 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ 565 static void 566 put_field (unsigned char *data, enum floatformat_byteorders order, 567 unsigned int total_len, unsigned int start, unsigned int len, 568 unsigned long stuff_to_put) 569 { 570 unsigned int cur_byte; 571 int lo_bit, hi_bit; 572 int nextbyte = (order == floatformat_little) ? 1 : -1; 573 574 /* Start is in big-endian bit order! Fix that first. */ 575 start = total_len - (start + len); 576 577 /* Start at the least significant part of the field. */ 578 if (order == floatformat_little) 579 cur_byte = start / FLOATFORMAT_CHAR_BIT; 580 else 581 cur_byte = (total_len - start - 1) / FLOATFORMAT_CHAR_BIT; 582 583 lo_bit = start % FLOATFORMAT_CHAR_BIT; 584 hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT); 585 586 do 587 { 588 unsigned char *byte_ptr = data + cur_byte; 589 unsigned int bits = hi_bit - lo_bit; 590 unsigned int mask = ((1 << bits) - 1) << lo_bit; 591 *byte_ptr = (*byte_ptr & ~mask) | ((stuff_to_put << lo_bit) & mask); 592 stuff_to_put >>= bits; 593 len -= bits; 594 cur_byte += nextbyte; 595 lo_bit = 0; 596 hi_bit = min (len, FLOATFORMAT_CHAR_BIT); 597 } 598 while (len != 0); 599 } 600 601 /* The converse: convert the double *FROM to an extended float 602 and store where TO points. Neither FROM nor TO have any alignment 603 restrictions. */ 604 605 void 606 floatformat_from_double (const struct floatformat *fmt, 607 const double *from, void *to) 608 { 609 double dfrom; 610 int exponent; 611 double mant; 612 unsigned int mant_bits, mant_off; 613 int mant_bits_left; 614 unsigned char *uto = (unsigned char *) to; 615 616 dfrom = *from; 617 memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT); 618 619 /* Split values are not handled specially, since a bottom half of 620 zero is correct for any value representable as double (in the 621 only supported case of split values). */ 622 623 /* If negative, set the sign bit. */ 624 if (dfrom < 0) 625 { 626 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1); 627 dfrom = -dfrom; 628 } 629 630 if (dfrom == 0) 631 { 632 /* 0.0. */ 633 return; 634 } 635 636 if (dfrom != dfrom) 637 { 638 /* NaN. */ 639 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, 640 fmt->exp_len, fmt->exp_nan); 641 /* Be sure it's not infinity, but NaN value is irrelevant. */ 642 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start, 643 32, 1); 644 return; 645 } 646 647 if (dfrom + dfrom == dfrom) 648 { 649 /* This can only happen for an infinite value (or zero, which we 650 already handled above). */ 651 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, 652 fmt->exp_len, fmt->exp_nan); 653 return; 654 } 655 656 mant = frexp (dfrom, &exponent); 657 if (exponent + fmt->exp_bias - 1 > 0) 658 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, 659 fmt->exp_len, exponent + fmt->exp_bias - 1); 660 else 661 { 662 /* Handle a denormalized number. FIXME: What should we do for 663 non-IEEE formats? */ 664 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, 665 fmt->exp_len, 0); 666 mant = ldexp (mant, exponent + fmt->exp_bias - 1); 667 } 668 669 mant_bits_left = fmt->man_len; 670 mant_off = fmt->man_start; 671 while (mant_bits_left > 0) 672 { 673 unsigned long mant_long; 674 mant_bits = mant_bits_left < 32 ? mant_bits_left : 32; 675 676 mant *= 4294967296.0; 677 mant_long = (unsigned long)mant; 678 mant -= mant_long; 679 680 /* If the integer bit is implicit, and we are not creating a 681 denormalized number, then we need to discard it. */ 682 if ((unsigned int) mant_bits_left == fmt->man_len 683 && fmt->intbit == floatformat_intbit_no 684 && exponent + fmt->exp_bias - 1 > 0) 685 { 686 mant_long &= 0x7fffffff; 687 mant_bits -= 1; 688 } 689 else if (mant_bits < 32) 690 { 691 /* The bits we want are in the most significant MANT_BITS bits of 692 mant_long. Move them to the least significant. */ 693 mant_long >>= 32 - mant_bits; 694 } 695 696 put_field (uto, fmt->byteorder, fmt->totalsize, 697 mant_off, mant_bits, mant_long); 698 mant_off += mant_bits; 699 mant_bits_left -= mant_bits; 700 } 701 } 702 703 /* Return non-zero iff the data at FROM is a valid number in format FMT. */ 704 705 int 706 floatformat_is_valid (const struct floatformat *fmt, const void *from) 707 { 708 return fmt->is_valid (fmt, from); 709 } 710 711 712 #ifdef IEEE_DEBUG 713 714 #include <stdio.h> 715 716 /* This is to be run on a host which uses IEEE floating point. */ 717 718 void 719 ieee_test (double n) 720 { 721 double result; 722 723 floatformat_to_double (&floatformat_ieee_double_little, &n, &result); 724 if ((n != result && (! isnan (n) || ! isnan (result))) 725 || (n < 0 && result >= 0) 726 || (n >= 0 && result < 0)) 727 printf ("Differ(to): %.20g -> %.20g\n", n, result); 728 729 floatformat_from_double (&floatformat_ieee_double_little, &n, &result); 730 if ((n != result && (! isnan (n) || ! isnan (result))) 731 || (n < 0 && result >= 0) 732 || (n >= 0 && result < 0)) 733 printf ("Differ(from): %.20g -> %.20g\n", n, result); 734 735 #if 0 736 { 737 char exten[16]; 738 739 floatformat_from_double (&floatformat_m68881_ext, &n, exten); 740 floatformat_to_double (&floatformat_m68881_ext, exten, &result); 741 if (n != result) 742 printf ("Differ(to+from): %.20g -> %.20g\n", n, result); 743 } 744 #endif 745 746 #if IEEE_DEBUG > 1 747 /* This is to be run on a host which uses 68881 format. */ 748 { 749 long double ex = *(long double *)exten; 750 if (ex != n) 751 printf ("Differ(from vs. extended): %.20g\n", n); 752 } 753 #endif 754 } 755 756 int 757 main (void) 758 { 759 ieee_test (0.0); 760 ieee_test (0.5); 761 ieee_test (1.1); 762 ieee_test (256.0); 763 ieee_test (0.12345); 764 ieee_test (234235.78907234); 765 ieee_test (-512.0); 766 ieee_test (-0.004321); 767 ieee_test (1.2E-70); 768 ieee_test (1.2E-316); 769 ieee_test (4.9406564584124654E-324); 770 ieee_test (- 4.9406564584124654E-324); 771 ieee_test (- 0.0); 772 ieee_test (- INFINITY); 773 ieee_test (- NAN); 774 ieee_test (INFINITY); 775 ieee_test (NAN); 776 return 0; 777 } 778 #endif 779
