1 /* Floating point routines for GDB, the GNU debugger. 2 3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 4 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008, 2009 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 /* Support for converting target fp numbers into host DOUBLEST format. */ 23 24 /* XXX - This code should really be in libiberty/floatformat.c, 25 however configuration issues with libiberty made this very 26 difficult to do in the available time. */ 27 28 #include "defs.h" 29 #include "doublest.h" 30 #include "floatformat.h" 31 #include "gdb_assert.h" 32 #include "gdb_string.h" 33 #include "gdbtypes.h" 34 #include <math.h> /* ldexp */ 35 36 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not 37 going to bother with trying to muck around with whether it is defined in 38 a system header, what we do if not, etc. */ 39 #define FLOATFORMAT_CHAR_BIT 8 40 41 /* The number of bytes that the largest floating-point type that we 42 can convert to doublest will need. */ 43 #define FLOATFORMAT_LARGEST_BYTES 16 44 45 /* Extract a field which starts at START and is LEN bytes long. DATA and 46 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ 47 static unsigned long 48 get_field (const bfd_byte *data, enum floatformat_byteorders order, 49 unsigned int total_len, unsigned int start, unsigned int len) 50 { 51 unsigned long result; 52 unsigned int cur_byte; 53 int cur_bitshift; 54 55 /* Caller must byte-swap words before calling this routine. */ 56 gdb_assert (order == floatformat_little || order == floatformat_big); 57 58 /* Start at the least significant part of the field. */ 59 if (order == floatformat_little) 60 { 61 /* We start counting from the other end (i.e, from the high bytes 62 rather than the low bytes). As such, we need to be concerned 63 with what happens if bit 0 doesn't start on a byte boundary. 64 I.e, we need to properly handle the case where total_len is 65 not evenly divisible by 8. So we compute ``excess'' which 66 represents the number of bits from the end of our starting 67 byte needed to get to bit 0. */ 68 int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT); 69 cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) 70 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT); 71 cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT) 72 - FLOATFORMAT_CHAR_BIT; 73 } 74 else 75 { 76 cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT; 77 cur_bitshift = 78 ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT; 79 } 80 if (cur_bitshift > -FLOATFORMAT_CHAR_BIT) 81 result = *(data + cur_byte) >> (-cur_bitshift); 82 else 83 result = 0; 84 cur_bitshift += FLOATFORMAT_CHAR_BIT; 85 if (order == floatformat_little) 86 ++cur_byte; 87 else 88 --cur_byte; 89 90 /* Move towards the most significant part of the field. */ 91 while (cur_bitshift < len) 92 { 93 result |= (unsigned long)*(data + cur_byte) << cur_bitshift; 94 cur_bitshift += FLOATFORMAT_CHAR_BIT; 95 switch (order) 96 { 97 case floatformat_little: 98 ++cur_byte; 99 break; 100 case floatformat_big: 101 --cur_byte; 102 break; 103 } 104 } 105 if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT) 106 /* Mask out bits which are not part of the field */ 107 result &= ((1UL << len) - 1); 108 return result; 109 } 110 111 /* Normalize the byte order of FROM into TO. If no normalization is 112 needed then FMT->byteorder is returned and TO is not changed; 113 otherwise the format of the normalized form in TO is returned. */ 114 115 static enum floatformat_byteorders 116 floatformat_normalize_byteorder (const struct floatformat *fmt, 117 const void *from, void *to) 118 { 119 const unsigned char *swapin; 120 unsigned char *swapout; 121 int words; 122 123 if (fmt->byteorder == floatformat_little 124 || fmt->byteorder == floatformat_big) 125 return fmt->byteorder; 126 127 words = fmt->totalsize / FLOATFORMAT_CHAR_BIT; 128 words >>= 2; 129 130 swapout = (unsigned char *)to; 131 swapin = (const unsigned char *)from; 132 133 if (fmt->byteorder == floatformat_vax) 134 { 135 while (words-- > 0) 136 { 137 *swapout++ = swapin[1]; 138 *swapout++ = swapin[0]; 139 *swapout++ = swapin[3]; 140 *swapout++ = swapin[2]; 141 swapin += 4; 142 } 143 /* This may look weird, since VAX is little-endian, but it is 144 easier to translate to big-endian than to little-endian. */ 145 return floatformat_big; 146 } 147 else 148 { 149 gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword); 150 151 while (words-- > 0) 152 { 153 *swapout++ = swapin[3]; 154 *swapout++ = swapin[2]; 155 *swapout++ = swapin[1]; 156 *swapout++ = swapin[0]; 157 swapin += 4; 158 } 159 return floatformat_big; 160 } 161 } 162 163 /* Convert from FMT to a DOUBLEST. 164 FROM is the address of the extended float. 165 Store the DOUBLEST in *TO. */ 166 167 static void 168 convert_floatformat_to_doublest (const struct floatformat *fmt, 169 const void *from, 170 DOUBLEST *to) 171 { 172 unsigned char *ufrom = (unsigned char *) from; 173 DOUBLEST dto; 174 long exponent; 175 unsigned long mant; 176 unsigned int mant_bits, mant_off; 177 int mant_bits_left; 178 int special_exponent; /* It's a NaN, denorm or zero */ 179 enum floatformat_byteorders order; 180 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES]; 181 enum float_kind kind; 182 183 gdb_assert (fmt->totalsize 184 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT); 185 186 /* For non-numbers, reuse libiberty's logic to find the correct 187 format. We do not lose any precision in this case by passing 188 through a double. */ 189 kind = floatformat_classify (fmt, from); 190 if (kind == float_infinite || kind == float_nan) 191 { 192 double dto; 193 floatformat_to_double (fmt, from, &dto); 194 *to = (DOUBLEST) dto; 195 return; 196 } 197 198 order = floatformat_normalize_byteorder (fmt, ufrom, newfrom); 199 200 if (order != fmt->byteorder) 201 ufrom = newfrom; 202 203 if (fmt->split_half) 204 { 205 DOUBLEST dtop, dbot; 206 floatformat_to_doublest (fmt->split_half, ufrom, &dtop); 207 /* Preserve the sign of 0, which is the sign of the top 208 half. */ 209 if (dtop == 0.0) 210 { 211 *to = dtop; 212 return; 213 } 214 floatformat_to_doublest (fmt->split_half, 215 ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2, 216 &dbot); 217 *to = dtop + dbot; 218 return; 219 } 220 221 exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start, 222 fmt->exp_len); 223 /* Note that if exponent indicates a NaN, we can't really do anything useful 224 (not knowing if the host has NaN's, or how to build one). So it will 225 end up as an infinity or something close; that is OK. */ 226 227 mant_bits_left = fmt->man_len; 228 mant_off = fmt->man_start; 229 dto = 0.0; 230 231 special_exponent = exponent == 0 || exponent == fmt->exp_nan; 232 233 /* Don't bias NaNs. Use minimum exponent for denorms. For simplicity, 234 we don't check for zero as the exponent doesn't matter. Note the cast 235 to int; exp_bias is unsigned, so it's important to make sure the 236 operation is done in signed arithmetic. */ 237 if (!special_exponent) 238 exponent -= fmt->exp_bias; 239 else if (exponent == 0) 240 exponent = 1 - fmt->exp_bias; 241 242 /* Build the result algebraically. Might go infinite, underflow, etc; 243 who cares. */ 244 245 /* If this format uses a hidden bit, explicitly add it in now. Otherwise, 246 increment the exponent by one to account for the integer bit. */ 247 248 if (!special_exponent) 249 { 250 if (fmt->intbit == floatformat_intbit_no) 251 dto = ldexp (1.0, exponent); 252 else 253 exponent++; 254 } 255 256 while (mant_bits_left > 0) 257 { 258 mant_bits = min (mant_bits_left, 32); 259 260 mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits); 261 262 dto += ldexp ((double) mant, exponent - mant_bits); 263 exponent -= mant_bits; 264 mant_off += mant_bits; 265 mant_bits_left -= mant_bits; 266 } 267 268 /* Negate it if negative. */ 269 if (get_field (ufrom, order, fmt->totalsize, fmt->sign_start, 1)) 270 dto = -dto; 271 *to = dto; 272 } 273 274 static void put_field (unsigned char *, enum floatformat_byteorders, 275 unsigned int, 276 unsigned int, unsigned int, unsigned long); 277 278 /* Set a field which starts at START and is LEN bytes long. DATA and 279 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ 280 static void 281 put_field (unsigned char *data, enum floatformat_byteorders order, 282 unsigned int total_len, unsigned int start, unsigned int len, 283 unsigned long stuff_to_put) 284 { 285 unsigned int cur_byte; 286 int cur_bitshift; 287 288 /* Caller must byte-swap words before calling this routine. */ 289 gdb_assert (order == floatformat_little || order == floatformat_big); 290 291 /* Start at the least significant part of the field. */ 292 if (order == floatformat_little) 293 { 294 int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT); 295 cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) 296 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT); 297 cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT) 298 - FLOATFORMAT_CHAR_BIT; 299 } 300 else 301 { 302 cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT; 303 cur_bitshift = 304 ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT; 305 } 306 if (cur_bitshift > -FLOATFORMAT_CHAR_BIT) 307 { 308 *(data + cur_byte) &= 309 ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) 310 << (-cur_bitshift)); 311 *(data + cur_byte) |= 312 (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift); 313 } 314 cur_bitshift += FLOATFORMAT_CHAR_BIT; 315 if (order == floatformat_little) 316 ++cur_byte; 317 else 318 --cur_byte; 319 320 /* Move towards the most significant part of the field. */ 321 while (cur_bitshift < len) 322 { 323 if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT) 324 { 325 /* This is the last byte. */ 326 *(data + cur_byte) &= 327 ~((1 << (len - cur_bitshift)) - 1); 328 *(data + cur_byte) |= (stuff_to_put >> cur_bitshift); 329 } 330 else 331 *(data + cur_byte) = ((stuff_to_put >> cur_bitshift) 332 & ((1 << FLOATFORMAT_CHAR_BIT) - 1)); 333 cur_bitshift += FLOATFORMAT_CHAR_BIT; 334 if (order == floatformat_little) 335 ++cur_byte; 336 else 337 --cur_byte; 338 } 339 } 340 341 #ifdef HAVE_LONG_DOUBLE 342 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR. 343 The range of the returned value is >= 0.5 and < 1.0. This is equivalent to 344 frexp, but operates on the long double data type. */ 345 346 static long double ldfrexp (long double value, int *eptr); 347 348 static long double 349 ldfrexp (long double value, int *eptr) 350 { 351 long double tmp; 352 int exp; 353 354 /* Unfortunately, there are no portable functions for extracting the exponent 355 of a long double, so we have to do it iteratively by multiplying or dividing 356 by two until the fraction is between 0.5 and 1.0. */ 357 358 if (value < 0.0l) 359 value = -value; 360 361 tmp = 1.0l; 362 exp = 0; 363 364 if (value >= tmp) /* Value >= 1.0 */ 365 while (value >= tmp) 366 { 367 tmp *= 2.0l; 368 exp++; 369 } 370 else if (value != 0.0l) /* Value < 1.0 and > 0.0 */ 371 { 372 while (value < tmp) 373 { 374 tmp /= 2.0l; 375 exp--; 376 } 377 tmp *= 2.0l; 378 exp++; 379 } 380 381 *eptr = exp; 382 return value / tmp; 383 } 384 #endif /* HAVE_LONG_DOUBLE */ 385 386 387 /* The converse: convert the DOUBLEST *FROM to an extended float and 388 store where TO points. Neither FROM nor TO have any alignment 389 restrictions. */ 390 391 static void 392 convert_doublest_to_floatformat (CONST struct floatformat *fmt, 393 const DOUBLEST *from, void *to) 394 { 395 DOUBLEST dfrom; 396 int exponent; 397 DOUBLEST mant; 398 unsigned int mant_bits, mant_off; 399 int mant_bits_left; 400 unsigned char *uto = (unsigned char *) to; 401 enum floatformat_byteorders order = fmt->byteorder; 402 unsigned char newto[FLOATFORMAT_LARGEST_BYTES]; 403 404 if (order != floatformat_little) 405 order = floatformat_big; 406 407 if (order != fmt->byteorder) 408 uto = newto; 409 410 memcpy (&dfrom, from, sizeof (dfrom)); 411 memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1) 412 / FLOATFORMAT_CHAR_BIT); 413 414 if (fmt->split_half) 415 { 416 /* Use static volatile to ensure that any excess precision is 417 removed via storing in memory, and so the top half really is 418 the result of converting to double. */ 419 static volatile double dtop, dbot; 420 DOUBLEST dtopnv, dbotnv; 421 dtop = (double) dfrom; 422 /* If the rounded top half is Inf, the bottom must be 0 not NaN 423 or Inf. */ 424 if (dtop + dtop == dtop && dtop != 0.0) 425 dbot = 0.0; 426 else 427 dbot = (double) (dfrom - (DOUBLEST) dtop); 428 dtopnv = dtop; 429 dbotnv = dbot; 430 floatformat_from_doublest (fmt->split_half, &dtopnv, uto); 431 floatformat_from_doublest (fmt->split_half, &dbotnv, 432 (uto 433 + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2)); 434 return; 435 } 436 437 if (dfrom == 0) 438 return; /* Result is zero */ 439 if (dfrom != dfrom) /* Result is NaN */ 440 { 441 /* From is NaN */ 442 put_field (uto, order, fmt->totalsize, fmt->exp_start, 443 fmt->exp_len, fmt->exp_nan); 444 /* Be sure it's not infinity, but NaN value is irrel */ 445 put_field (uto, order, fmt->totalsize, fmt->man_start, 446 32, 1); 447 goto finalize_byteorder; 448 } 449 450 /* If negative, set the sign bit. */ 451 if (dfrom < 0) 452 { 453 put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1); 454 dfrom = -dfrom; 455 } 456 457 if (dfrom + dfrom == dfrom && dfrom != 0.0) /* Result is Infinity */ 458 { 459 /* Infinity exponent is same as NaN's. */ 460 put_field (uto, order, fmt->totalsize, fmt->exp_start, 461 fmt->exp_len, fmt->exp_nan); 462 /* Infinity mantissa is all zeroes. */ 463 put_field (uto, order, fmt->totalsize, fmt->man_start, 464 fmt->man_len, 0); 465 goto finalize_byteorder; 466 } 467 468 #ifdef HAVE_LONG_DOUBLE 469 mant = ldfrexp (dfrom, &exponent); 470 #else 471 mant = frexp (dfrom, &exponent); 472 #endif 473 474 put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len, 475 exponent + fmt->exp_bias - 1); 476 477 mant_bits_left = fmt->man_len; 478 mant_off = fmt->man_start; 479 while (mant_bits_left > 0) 480 { 481 unsigned long mant_long; 482 mant_bits = mant_bits_left < 32 ? mant_bits_left : 32; 483 484 mant *= 4294967296.0; 485 mant_long = ((unsigned long) mant) & 0xffffffffL; 486 mant -= mant_long; 487 488 /* If the integer bit is implicit, then we need to discard it. 489 If we are discarding a zero, we should be (but are not) creating 490 a denormalized number which means adjusting the exponent 491 (I think). */ 492 if (mant_bits_left == fmt->man_len 493 && fmt->intbit == floatformat_intbit_no) 494 { 495 mant_long <<= 1; 496 mant_long &= 0xffffffffL; 497 /* If we are processing the top 32 mantissa bits of a doublest 498 so as to convert to a float value with implied integer bit, 499 we will only be putting 31 of those 32 bits into the 500 final value due to the discarding of the top bit. In the 501 case of a small float value where the number of mantissa 502 bits is less than 32, discarding the top bit does not alter 503 the number of bits we will be adding to the result. */ 504 if (mant_bits == 32) 505 mant_bits -= 1; 506 } 507 508 if (mant_bits < 32) 509 { 510 /* The bits we want are in the most significant MANT_BITS bits of 511 mant_long. Move them to the least significant. */ 512 mant_long >>= 32 - mant_bits; 513 } 514 515 put_field (uto, order, fmt->totalsize, 516 mant_off, mant_bits, mant_long); 517 mant_off += mant_bits; 518 mant_bits_left -= mant_bits; 519 } 520 521 finalize_byteorder: 522 /* Do we need to byte-swap the words in the result? */ 523 if (order != fmt->byteorder) 524 floatformat_normalize_byteorder (fmt, newto, to); 525 } 526 527 /* Check if VAL (which is assumed to be a floating point number whose 528 format is described by FMT) is negative. */ 529 530 int 531 floatformat_is_negative (const struct floatformat *fmt, 532 const bfd_byte *uval) 533 { 534 enum floatformat_byteorders order; 535 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES]; 536 537 gdb_assert (fmt != NULL); 538 gdb_assert (fmt->totalsize 539 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT); 540 541 order = floatformat_normalize_byteorder (fmt, uval, newfrom); 542 543 if (order != fmt->byteorder) 544 uval = newfrom; 545 546 return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1); 547 } 548 549 /* Check if VAL is "not a number" (NaN) for FMT. */ 550 551 enum float_kind 552 floatformat_classify (const struct floatformat *fmt, 553 const bfd_byte *uval) 554 { 555 long exponent; 556 unsigned long mant; 557 unsigned int mant_bits, mant_off; 558 int mant_bits_left; 559 enum floatformat_byteorders order; 560 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES]; 561 int mant_zero; 562 563 gdb_assert (fmt != NULL); 564 gdb_assert (fmt->totalsize 565 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT); 566 567 order = floatformat_normalize_byteorder (fmt, uval, newfrom); 568 569 if (order != fmt->byteorder) 570 uval = newfrom; 571 572 exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start, 573 fmt->exp_len); 574 575 mant_bits_left = fmt->man_len; 576 mant_off = fmt->man_start; 577 578 mant_zero = 1; 579 while (mant_bits_left > 0) 580 { 581 mant_bits = min (mant_bits_left, 32); 582 583 mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits); 584 585 /* If there is an explicit integer bit, mask it off. */ 586 if (mant_off == fmt->man_start 587 && fmt->intbit == floatformat_intbit_yes) 588 mant &= ~(1 << (mant_bits - 1)); 589 590 if (mant) 591 { 592 mant_zero = 0; 593 break; 594 } 595 596 mant_off += mant_bits; 597 mant_bits_left -= mant_bits; 598 } 599 600 /* If exp_nan is not set, assume that inf, NaN, and subnormals are not 601 supported. */ 602 if (! fmt->exp_nan) 603 { 604 if (mant_zero) 605 return float_zero; 606 else 607 return float_normal; 608 } 609 610 if (exponent == 0 && !mant_zero) 611 return float_subnormal; 612 613 if (exponent == fmt->exp_nan) 614 { 615 if (mant_zero) 616 return float_infinite; 617 else 618 return float_nan; 619 } 620 621 if (mant_zero) 622 return float_zero; 623 624 return float_normal; 625 } 626 627 /* Convert the mantissa of VAL (which is assumed to be a floating 628 point number whose format is described by FMT) into a hexadecimal 629 and store it in a static string. Return a pointer to that string. */ 630 631 const char * 632 floatformat_mantissa (const struct floatformat *fmt, 633 const bfd_byte *val) 634 { 635 unsigned char *uval = (unsigned char *) val; 636 unsigned long mant; 637 unsigned int mant_bits, mant_off; 638 int mant_bits_left; 639 static char res[50]; 640 char buf[9]; 641 int len; 642 enum floatformat_byteorders order; 643 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES]; 644 645 gdb_assert (fmt != NULL); 646 gdb_assert (fmt->totalsize 647 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT); 648 649 order = floatformat_normalize_byteorder (fmt, uval, newfrom); 650 651 if (order != fmt->byteorder) 652 uval = newfrom; 653 654 if (! fmt->exp_nan) 655 return 0; 656 657 /* Make sure we have enough room to store the mantissa. */ 658 gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2); 659 660 mant_off = fmt->man_start; 661 mant_bits_left = fmt->man_len; 662 mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32; 663 664 mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits); 665 666 len = xsnprintf (res, sizeof res, "%lx", mant); 667 668 mant_off += mant_bits; 669 mant_bits_left -= mant_bits; 670 671 while (mant_bits_left > 0) 672 { 673 mant = get_field (uval, order, fmt->totalsize, mant_off, 32); 674 675 xsnprintf (buf, sizeof buf, "%08lx", mant); 676 gdb_assert (len + strlen (buf) <= sizeof res); 677 strcat (res, buf); 678 679 mant_off += 32; 680 mant_bits_left -= 32; 681 } 682 683 return res; 684 } 685 686 687 /* Convert TO/FROM target to the hosts DOUBLEST floating-point format. 688 689 If the host and target formats agree, we just copy the raw data 690 into the appropriate type of variable and return, letting the host 691 increase precision as necessary. Otherwise, we call the conversion 692 routine and let it do the dirty work. */ 693 694 static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT; 695 static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT; 696 static const struct floatformat *host_long_double_format = GDB_HOST_LONG_DOUBLE_FORMAT; 697 698 void 699 floatformat_to_doublest (const struct floatformat *fmt, 700 const void *in, DOUBLEST *out) 701 { 702 gdb_assert (fmt != NULL); 703 if (fmt == host_float_format) 704 { 705 float val; 706 memcpy (&val, in, sizeof (val)); 707 *out = val; 708 } 709 else if (fmt == host_double_format) 710 { 711 double val; 712 memcpy (&val, in, sizeof (val)); 713 *out = val; 714 } 715 else if (fmt == host_long_double_format) 716 { 717 long double val; 718 memcpy (&val, in, sizeof (val)); 719 *out = val; 720 } 721 else 722 convert_floatformat_to_doublest (fmt, in, out); 723 } 724 725 void 726 floatformat_from_doublest (const struct floatformat *fmt, 727 const DOUBLEST *in, void *out) 728 { 729 gdb_assert (fmt != NULL); 730 if (fmt == host_float_format) 731 { 732 float val = *in; 733 memcpy (out, &val, sizeof (val)); 734 } 735 else if (fmt == host_double_format) 736 { 737 double val = *in; 738 memcpy (out, &val, sizeof (val)); 739 } 740 else if (fmt == host_long_double_format) 741 { 742 long double val = *in; 743 memcpy (out, &val, sizeof (val)); 744 } 745 else 746 convert_doublest_to_floatformat (fmt, in, out); 747 } 748 749 750 /* Return a floating-point format for a floating-point variable of 751 length LEN. If no suitable floating-point format is found, an 752 error is thrown. 753 754 We need this functionality since information about the 755 floating-point format of a type is not always available to GDB; the 756 debug information typically only tells us the size of a 757 floating-point type. 758 759 FIXME: kettenis/2001-10-28: In many places, particularly in 760 target-dependent code, the format of floating-point types is known, 761 but not passed on by GDB. This should be fixed. */ 762 763 static const struct floatformat * 764 floatformat_from_length (struct gdbarch *gdbarch, int len) 765 { 766 const struct floatformat *format; 767 if (len * TARGET_CHAR_BIT == gdbarch_float_bit (gdbarch)) 768 format = gdbarch_float_format (gdbarch) 769 [gdbarch_byte_order (gdbarch)]; 770 else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (gdbarch)) 771 format = gdbarch_double_format (gdbarch) 772 [gdbarch_byte_order (gdbarch)]; 773 else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (gdbarch)) 774 format = gdbarch_long_double_format (gdbarch) 775 [gdbarch_byte_order (gdbarch)]; 776 /* On i386 the 'long double' type takes 96 bits, 777 while the real number of used bits is only 80, 778 both in processor and in memory. 779 The code below accepts the real bit size. */ 780 else if ((gdbarch_long_double_format (gdbarch) != NULL) 781 && (len * TARGET_CHAR_BIT == 782 gdbarch_long_double_format (gdbarch)[0]->totalsize)) 783 format = gdbarch_long_double_format (gdbarch) 784 [gdbarch_byte_order (gdbarch)]; 785 else 786 format = NULL; 787 if (format == NULL) 788 error (_("Unrecognized %d-bit floating-point type."), 789 len * TARGET_CHAR_BIT); 790 return format; 791 } 792 793 const struct floatformat * 794 floatformat_from_type (const struct type *type) 795 { 796 struct gdbarch *gdbarch = get_type_arch (type); 797 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT); 798 if (TYPE_FLOATFORMAT (type) != NULL) 799 return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (gdbarch)]; 800 else 801 return floatformat_from_length (gdbarch, TYPE_LENGTH (type)); 802 } 803 804 /* Extract a floating-point number of type TYPE from a target-order 805 byte-stream at ADDR. Returns the value as type DOUBLEST. */ 806 807 DOUBLEST 808 extract_typed_floating (const void *addr, const struct type *type) 809 { 810 const struct floatformat *fmt = floatformat_from_type (type); 811 DOUBLEST retval; 812 813 floatformat_to_doublest (fmt, addr, &retval); 814 return retval; 815 } 816 817 /* Store VAL as a floating-point number of type TYPE to a target-order 818 byte-stream at ADDR. */ 819 820 void 821 store_typed_floating (void *addr, const struct type *type, DOUBLEST val) 822 { 823 const struct floatformat *fmt = floatformat_from_type (type); 824 825 /* FIXME: kettenis/2001-10-28: It is debatable whether we should 826 zero out any remaining bytes in the target buffer when TYPE is 827 longer than the actual underlying floating-point format. Perhaps 828 we should store a fixed bitpattern in those remaining bytes, 829 instead of zero, or perhaps we shouldn't touch those remaining 830 bytes at all. 831 832 NOTE: cagney/2001-10-28: With the way things currently work, it 833 isn't a good idea to leave the end bits undefined. This is 834 because GDB writes out the entire sizeof(<floating>) bits of the 835 floating-point type even though the value might only be stored 836 in, and the target processor may only refer to, the first N < 837 TYPE_LENGTH (type) bits. If the end of the buffer wasn't 838 initialized, GDB would write undefined data to the target. An 839 errant program, refering to that undefined data, would then 840 become non-deterministic. 841 842 See also the function convert_typed_floating below. */ 843 memset (addr, 0, TYPE_LENGTH (type)); 844 845 floatformat_from_doublest (fmt, &val, addr); 846 } 847 848 /* Convert a floating-point number of type FROM_TYPE from a 849 target-order byte-stream at FROM to a floating-point number of type 850 TO_TYPE, and store it to a target-order byte-stream at TO. */ 851 852 void 853 convert_typed_floating (const void *from, const struct type *from_type, 854 void *to, const struct type *to_type) 855 { 856 const struct floatformat *from_fmt = floatformat_from_type (from_type); 857 const struct floatformat *to_fmt = floatformat_from_type (to_type); 858 859 if (from_fmt == NULL || to_fmt == NULL) 860 { 861 /* If we don't know the floating-point format of FROM_TYPE or 862 TO_TYPE, there's not much we can do. We might make the 863 assumption that if the length of FROM_TYPE and TO_TYPE match, 864 their floating-point format would match too, but that 865 assumption might be wrong on targets that support 866 floating-point types that only differ in endianness for 867 example. So we warn instead, and zero out the target buffer. */ 868 warning (_("Can't convert floating-point number to desired type.")); 869 memset (to, 0, TYPE_LENGTH (to_type)); 870 } 871 else if (from_fmt == to_fmt) 872 { 873 /* We're in business. The floating-point format of FROM_TYPE 874 and TO_TYPE match. However, even though the floating-point 875 format matches, the length of the type might still be 876 different. Make sure we don't overrun any buffers. See 877 comment in store_typed_floating for a discussion about 878 zeroing out remaining bytes in the target buffer. */ 879 memset (to, 0, TYPE_LENGTH (to_type)); 880 memcpy (to, from, min (TYPE_LENGTH (from_type), TYPE_LENGTH (to_type))); 881 } 882 else 883 { 884 /* The floating-point types don't match. The best we can do 885 (apart from simulating the target FPU) is converting to the 886 widest floating-point type supported by the host, and then 887 again to the desired type. */ 888 DOUBLEST d; 889 890 floatformat_to_doublest (from_fmt, from, &d); 891 floatformat_from_doublest (to_fmt, &d, to); 892 } 893 } 894 895 const struct floatformat *floatformat_ieee_single[BFD_ENDIAN_UNKNOWN]; 896 const struct floatformat *floatformat_ieee_double[BFD_ENDIAN_UNKNOWN]; 897 const struct floatformat *floatformat_ieee_quad[BFD_ENDIAN_UNKNOWN]; 898 const struct floatformat *floatformat_arm_ext[BFD_ENDIAN_UNKNOWN]; 899 const struct floatformat *floatformat_ia64_spill[BFD_ENDIAN_UNKNOWN]; 900 901 extern void _initialize_doublest (void); 902 903 extern void 904 _initialize_doublest (void) 905 { 906 floatformat_ieee_single[BFD_ENDIAN_LITTLE] = &floatformat_ieee_single_little; 907 floatformat_ieee_single[BFD_ENDIAN_BIG] = &floatformat_ieee_single_big; 908 floatformat_ieee_double[BFD_ENDIAN_LITTLE] = &floatformat_ieee_double_little; 909 floatformat_ieee_double[BFD_ENDIAN_BIG] = &floatformat_ieee_double_big; 910 floatformat_arm_ext[BFD_ENDIAN_LITTLE] = &floatformat_arm_ext_littlebyte_bigword; 911 floatformat_arm_ext[BFD_ENDIAN_BIG] = &floatformat_arm_ext_big; 912 floatformat_ia64_spill[BFD_ENDIAN_LITTLE] = &floatformat_ia64_spill_little; 913 floatformat_ia64_spill[BFD_ENDIAN_BIG] = &floatformat_ia64_spill_big; 914 floatformat_ieee_quad[BFD_ENDIAN_LITTLE] = &floatformat_ia64_quad_little; 915 floatformat_ieee_quad[BFD_ENDIAN_BIG] = &floatformat_ia64_quad_big; 916 } 917