gdb/doublest.c

   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
   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   exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start,
 204                         fmt->exp_len);
 205   /* Note that if exponent indicates a NaN, we can't really do anything useful
 206      (not knowing if the host has NaN's, or how to build one).  So it will
 207      end up as an infinity or something close; that is OK.  */
 208
 209   mant_bits_left = fmt->man_len;
 210   mant_off = fmt->man_start;
 211   dto = 0.0;
 212
 213   special_exponent = exponent == 0 || exponent == fmt->exp_nan;
 214
 215   /* Don't bias NaNs. Use minimum exponent for denorms. For simplicity,
 216      we don't check for zero as the exponent doesn't matter.  Note the cast
 217      to int; exp_bias is unsigned, so it's important to make sure the
 218      operation is done in signed arithmetic.  */
 219   if (!special_exponent)
 220     exponent -= fmt->exp_bias;
 221   else if (exponent == 0)
 222     exponent = 1 - fmt->exp_bias;
 223
 224   /* Build the result algebraically.  Might go infinite, underflow, etc;
 225      who cares. */
 226
 227 /* If this format uses a hidden bit, explicitly add it in now.  Otherwise,
 228    increment the exponent by one to account for the integer bit.  */
 229
 230   if (!special_exponent)
 231     {
 232       if (fmt->intbit == floatformat_intbit_no)
 233         dto = ldexp (1.0, exponent);
 234       else
 235         exponent++;
 236     }
 237
 238   while (mant_bits_left > 0)
 239     {
 240       mant_bits = min (mant_bits_left, 32);
 241
 242       mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits);
 243
 244       dto += ldexp ((double) mant, exponent - mant_bits);
 245       exponent -= mant_bits;
 246       mant_off += mant_bits;
 247       mant_bits_left -= mant_bits;
 248     }
 249
 250   /* Negate it if negative.  */
 251   if (get_field (ufrom, order, fmt->totalsize, fmt->sign_start, 1))
 252     dto = -dto;
 253   *to = dto;
 254 }
 255 \f
 256 static void put_field (unsigned char *, enum floatformat_byteorders,
 257                        unsigned int,
 258                        unsigned int, unsigned int, unsigned long);
 259
 260 /* Set a field which starts at START and is LEN bytes long.  DATA and
 261    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
 262 static void
 263 put_field (unsigned char *data, enum floatformat_byteorders order,
 264            unsigned int total_len, unsigned int start, unsigned int len,
 265            unsigned long stuff_to_put)
 266 {
 267   unsigned int cur_byte;
 268   int cur_bitshift;
 269
 270   /* Caller must byte-swap words before calling this routine.  */
 271   gdb_assert (order == floatformat_little || order == floatformat_big);
 272
 273   /* Start at the least significant part of the field.  */
 274   if (order == floatformat_little)
 275     {
 276       int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
 277       cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
 278                  - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
 279       cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
 280                      - FLOATFORMAT_CHAR_BIT;
 281     }
 282   else
 283     {
 284       cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
 285       cur_bitshift =
 286         ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
 287     }
 288   if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
 289     {
 290       *(data + cur_byte) &=
 291         ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1)
 292           << (-cur_bitshift));
 293       *(data + cur_byte) |=
 294         (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
 295     }
 296   cur_bitshift += FLOATFORMAT_CHAR_BIT;
 297   if (order == floatformat_little)
 298     ++cur_byte;
 299   else
 300     --cur_byte;
 301
 302   /* Move towards the most significant part of the field.  */
 303   while (cur_bitshift < len)
 304     {
 305       if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
 306         {
 307           /* This is the last byte.  */
 308           *(data + cur_byte) &=
 309             ~((1 << (len - cur_bitshift)) - 1);
 310           *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
 311         }
 312       else
 313         *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
 314                               & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
 315       cur_bitshift += FLOATFORMAT_CHAR_BIT;
 316       if (order == floatformat_little)
 317         ++cur_byte;
 318       else
 319         --cur_byte;
 320     }
 321 }
 322
 323 #ifdef HAVE_LONG_DOUBLE
 324 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
 325    The range of the returned value is >= 0.5 and < 1.0.  This is equivalent to
 326    frexp, but operates on the long double data type.  */
 327
 328 static long double ldfrexp (long double value, int *eptr);
 329
 330 static long double
 331 ldfrexp (long double value, int *eptr)
 332 {
 333   long double tmp;
 334   int exp;
 335
 336   /* Unfortunately, there are no portable functions for extracting the exponent
 337      of a long double, so we have to do it iteratively by multiplying or dividing
 338      by two until the fraction is between 0.5 and 1.0.  */
 339
 340   if (value < 0.0l)
 341     value = -value;
 342
 343   tmp = 1.0l;
 344   exp = 0;
 345
 346   if (value >= tmp)             /* Value >= 1.0 */
 347     while (value >= tmp)
 348       {
 349         tmp *= 2.0l;
 350         exp++;
 351       }
 352   else if (value != 0.0l)       /* Value < 1.0  and > 0.0 */
 353     {
 354       while (value < tmp)
 355         {
 356           tmp /= 2.0l;
 357           exp--;
 358         }
 359       tmp *= 2.0l;
 360       exp++;
 361     }
 362
 363   *eptr = exp;
 364   return value / tmp;
 365 }
 366 #endif /* HAVE_LONG_DOUBLE */
 367
 368
 369 /* The converse: convert the DOUBLEST *FROM to an extended float and
 370    store where TO points.  Neither FROM nor TO have any alignment
 371    restrictions.  */
 372
 373 static void
 374 convert_doublest_to_floatformat (CONST struct floatformat *fmt,
 375                                  const DOUBLEST *from, void *to)
 376 {
 377   DOUBLEST dfrom;
 378   int exponent;
 379   DOUBLEST mant;
 380   unsigned int mant_bits, mant_off;
 381   int mant_bits_left;
 382   unsigned char *uto = (unsigned char *) to;
 383   enum floatformat_byteorders order = fmt->byteorder;
 384   unsigned char newto[FLOATFORMAT_LARGEST_BYTES];
 385
 386   if (order != floatformat_little)
 387     order = floatformat_big;
 388
 389   if (order != fmt->byteorder)
 390     uto = newto;
 391
 392   memcpy (&dfrom, from, sizeof (dfrom));
 393   memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
 394                     / FLOATFORMAT_CHAR_BIT);
 395   if (dfrom == 0)
 396     return;                     /* Result is zero */
 397   if (dfrom != dfrom)           /* Result is NaN */
 398     {
 399       /* From is NaN */
 400       put_field (uto, order, fmt->totalsize, fmt->exp_start,
 401                  fmt->exp_len, fmt->exp_nan);
 402       /* Be sure it's not infinity, but NaN value is irrel */
 403       put_field (uto, order, fmt->totalsize, fmt->man_start,
 404                  32, 1);
 405       goto finalize_byteorder;
 406     }
 407
 408   /* If negative, set the sign bit.  */
 409   if (dfrom < 0)
 410     {
 411       put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1);
 412       dfrom = -dfrom;
 413     }
 414
 415   if (dfrom + dfrom == dfrom && dfrom != 0.0)   /* Result is Infinity */
 416     {
 417       /* Infinity exponent is same as NaN's.  */
 418       put_field (uto, order, fmt->totalsize, fmt->exp_start,
 419                  fmt->exp_len, fmt->exp_nan);
 420       /* Infinity mantissa is all zeroes.  */
 421       put_field (uto, order, fmt->totalsize, fmt->man_start,
 422                  fmt->man_len, 0);
 423       goto finalize_byteorder;
 424     }
 425
 426 #ifdef HAVE_LONG_DOUBLE
 427   mant = ldfrexp (dfrom, &exponent);
 428 #else
 429   mant = frexp (dfrom, &exponent);
 430 #endif
 431
 432   put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len,
 433              exponent + fmt->exp_bias - 1);
 434
 435   mant_bits_left = fmt->man_len;
 436   mant_off = fmt->man_start;
 437   while (mant_bits_left > 0)
 438     {
 439       unsigned long mant_long;
 440       mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
 441
 442       mant *= 4294967296.0;
 443       mant_long = ((unsigned long) mant) & 0xffffffffL;
 444       mant -= mant_long;
 445
 446       /* If the integer bit is implicit, then we need to discard it.
 447          If we are discarding a zero, we should be (but are not) creating
 448          a denormalized number which means adjusting the exponent
 449          (I think).  */
 450       if (mant_bits_left == fmt->man_len
 451           && fmt->intbit == floatformat_intbit_no)
 452         {
 453           mant_long <<= 1;
 454           mant_long &= 0xffffffffL;
 455           /* If we are processing the top 32 mantissa bits of a doublest
 456              so as to convert to a float value with implied integer bit,
 457              we will only be putting 31 of those 32 bits into the
 458              final value due to the discarding of the top bit.  In the
 459              case of a small float value where the number of mantissa
 460              bits is less than 32, discarding the top bit does not alter
 461              the number of bits we will be adding to the result.  */
 462           if (mant_bits == 32)
 463             mant_bits -= 1;
 464         }
 465
 466       if (mant_bits < 32)
 467         {
 468           /* The bits we want are in the most significant MANT_BITS bits of
 469              mant_long.  Move them to the least significant.  */
 470           mant_long >>= 32 - mant_bits;
 471         }
 472
 473       put_field (uto, order, fmt->totalsize,
 474                  mant_off, mant_bits, mant_long);
 475       mant_off += mant_bits;
 476       mant_bits_left -= mant_bits;
 477     }
 478
 479  finalize_byteorder:
 480   /* Do we need to byte-swap the words in the result?  */
 481   if (order != fmt->byteorder)
 482     floatformat_normalize_byteorder (fmt, newto, to);
 483 }
 484
 485 /* Check if VAL (which is assumed to be a floating point number whose
 486    format is described by FMT) is negative.  */
 487
 488 int
 489 floatformat_is_negative (const struct floatformat *fmt,
 490                          const bfd_byte *uval)
 491 {
 492   enum floatformat_byteorders order;
 493   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
 494
 495   gdb_assert (fmt != NULL);
 496   gdb_assert (fmt->totalsize
 497               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 498
 499   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 500
 501   if (order != fmt->byteorder)
 502     uval = newfrom;
 503
 504   return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1);
 505 }
 506
 507 /* Check if VAL is "not a number" (NaN) for FMT.  */
 508
 509 enum float_kind
 510 floatformat_classify (const struct floatformat *fmt,
 511                       const bfd_byte *uval)
 512 {
 513   long exponent;
 514   unsigned long mant;
 515   unsigned int mant_bits, mant_off;
 516   int mant_bits_left;
 517   enum floatformat_byteorders order;
 518   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
 519   int mant_zero;
 520
 521   gdb_assert (fmt != NULL);
 522   gdb_assert (fmt->totalsize
 523               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 524
 525   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 526
 527   if (order != fmt->byteorder)
 528     uval = newfrom;
 529
 530   exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
 531                         fmt->exp_len);
 532
 533   mant_bits_left = fmt->man_len;
 534   mant_off = fmt->man_start;
 535
 536   mant_zero = 1;
 537   while (mant_bits_left > 0)
 538     {
 539       mant_bits = min (mant_bits_left, 32);
 540
 541       mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
 542
 543       /* If there is an explicit integer bit, mask it off.  */
 544       if (mant_off == fmt->man_start
 545           && fmt->intbit == floatformat_intbit_yes)
 546         mant &= ~(1 << (mant_bits - 1));
 547
 548       if (mant)
 549         {
 550           mant_zero = 0;
 551           break;
 552         }
 553
 554       mant_off += mant_bits;
 555       mant_bits_left -= mant_bits;
 556     }
 557
 558   /* If exp_nan is not set, assume that inf, NaN, and subnormals are not
 559      supported.  */
 560   if (! fmt->exp_nan)
 561     {
 562       if (mant_zero)
 563         return float_zero;
 564       else
 565         return float_normal;
 566     }
 567
 568   if (exponent == 0 && !mant_zero)
 569     return float_subnormal;
 570
 571   if (exponent == fmt->exp_nan)
 572     {
 573       if (mant_zero)
 574         return float_infinite;
 575       else
 576         return float_nan;
 577     }
 578
 579   if (mant_zero)
 580     return float_zero;
 581
 582   return float_normal;
 583 }
 584
 585 /* Convert the mantissa of VAL (which is assumed to be a floating
 586    point number whose format is described by FMT) into a hexadecimal
 587    and store it in a static string.  Return a pointer to that string.  */
 588
 589 const char *
 590 floatformat_mantissa (const struct floatformat *fmt,
 591                       const bfd_byte *val)
 592 {
 593   unsigned char *uval = (unsigned char *) val;
 594   unsigned long mant;
 595   unsigned int mant_bits, mant_off;
 596   int mant_bits_left;
 597   static char res[50];
 598   char buf[9];
 599   int len;
 600   enum floatformat_byteorders order;
 601   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
 602
 603   gdb_assert (fmt != NULL);
 604   gdb_assert (fmt->totalsize
 605               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 606
 607   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 608
 609   if (order != fmt->byteorder)
 610     uval = newfrom;
 611
 612   if (! fmt->exp_nan)
 613     return 0;
 614
 615   /* Make sure we have enough room to store the mantissa.  */
 616   gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
 617
 618   mant_off = fmt->man_start;
 619   mant_bits_left = fmt->man_len;
 620   mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;
 621
 622   mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
 623
 624   len = xsnprintf (res, sizeof res, "%lx", mant);
 625
 626   mant_off += mant_bits;
 627   mant_bits_left -= mant_bits;
 628
 629   while (mant_bits_left > 0)
 630     {
 631       mant = get_field (uval, order, fmt->totalsize, mant_off, 32);
 632
 633       xsnprintf (buf, sizeof buf, "%08lx", mant);
 634       gdb_assert (len + strlen (buf) <= sizeof res);
 635       strcat (res, buf);
 636
 637       mant_off += 32;
 638       mant_bits_left -= 32;
 639     }
 640
 641   return res;
 642 }
 643
 644 \f
 645 /* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
 646
 647    If the host and target formats agree, we just copy the raw data
 648    into the appropriate type of variable and return, letting the host
 649    increase precision as necessary.  Otherwise, we call the conversion
 650    routine and let it do the dirty work.  */
 651
 652 static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT;
 653 static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;
 654 static const struct floatformat *host_long_double_format = GDB_HOST_LONG_DOUBLE_FORMAT;
 655
 656 void
 657 floatformat_to_doublest (const struct floatformat *fmt,
 658                          const void *in, DOUBLEST *out)
 659 {
 660   gdb_assert (fmt != NULL);
 661   if (fmt == host_float_format)
 662     {
 663       float val;
 664       memcpy (&val, in, sizeof (val));
 665       *out = val;
 666     }
 667   else if (fmt == host_double_format)
 668     {
 669       double val;
 670       memcpy (&val, in, sizeof (val));
 671       *out = val;
 672     }
 673   else if (fmt == host_long_double_format)
 674     {
 675       long double val;
 676       memcpy (&val, in, sizeof (val));
 677       *out = val;
 678     }
 679   else
 680     convert_floatformat_to_doublest (fmt, in, out);
 681 }
 682
 683 void
 684 floatformat_from_doublest (const struct floatformat *fmt,
 685                            const DOUBLEST *in, void *out)
 686 {
 687   gdb_assert (fmt != NULL);
 688   if (fmt == host_float_format)
 689     {
 690       float val = *in;
 691       memcpy (out, &val, sizeof (val));
 692     }
 693   else if (fmt == host_double_format)
 694     {
 695       double val = *in;
 696       memcpy (out, &val, sizeof (val));
 697     }
 698   else if (fmt == host_long_double_format)
 699     {
 700       long double val = *in;
 701       memcpy (out, &val, sizeof (val));
 702     }
 703   else
 704     convert_doublest_to_floatformat (fmt, in, out);
 705 }
 706
 707 \f
 708 /* Return a floating-point format for a floating-point variable of
 709    length LEN.  If no suitable floating-point format is found, an
 710    error is thrown.
 711
 712    We need this functionality since information about the
 713    floating-point format of a type is not always available to GDB; the
 714    debug information typically only tells us the size of a
 715    floating-point type.
 716
 717    FIXME: kettenis/2001-10-28: In many places, particularly in
 718    target-dependent code, the format of floating-point types is known,
 719    but not passed on by GDB.  This should be fixed.  */
 720
 721 static const struct floatformat *
 722 floatformat_from_length (int len)
 723 {
 724   const struct floatformat *format;
 725   if (len * TARGET_CHAR_BIT == gdbarch_float_bit (current_gdbarch))
 726     format = gdbarch_float_format (current_gdbarch)
 727                [gdbarch_byte_order (current_gdbarch)];
 728   else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (current_gdbarch))
 729     format = gdbarch_double_format (current_gdbarch)
 730                [gdbarch_byte_order (current_gdbarch)];
 731   else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (current_gdbarch))
 732     format = gdbarch_long_double_format (current_gdbarch)
 733                [gdbarch_byte_order (current_gdbarch)];
 734   /* On i386 the 'long double' type takes 96 bits,
 735      while the real number of used bits is only 80,
 736      both in processor and in memory.
 737      The code below accepts the real bit size.  */
 738   else if ((gdbarch_long_double_format (current_gdbarch) != NULL)
 739            && (len * TARGET_CHAR_BIT ==
 740                gdbarch_long_double_format (current_gdbarch)[0]->totalsize))
 741     format = gdbarch_long_double_format (current_gdbarch)
 742                [gdbarch_byte_order (current_gdbarch)];
 743   else
 744     format = NULL;
 745   if (format == NULL)
 746     error (_("Unrecognized %d-bit floating-point type."),
 747            len * TARGET_CHAR_BIT);
 748   return format;
 749 }
 750
 751 const struct floatformat *
 752 floatformat_from_type (const struct type *type)
 753 {
 754   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
 755   if (TYPE_FLOATFORMAT (type) != NULL)
 756     return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)];
 757   else
 758     return floatformat_from_length (TYPE_LENGTH (type));
 759 }
 760
 761 /* If the host doesn't define NAN, use zero instead.  */
 762 #ifndef NAN
 763 #define NAN 0.0
 764 #endif
 765
 766 /* Extract a floating-point number of length LEN from a target-order
 767    byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
 768
 769 static DOUBLEST
 770 extract_floating_by_length (const void *addr, int len)
 771 {
 772   const struct floatformat *fmt = floatformat_from_length (len);
 773   DOUBLEST val;
 774
 775   floatformat_to_doublest (fmt, addr, &val);
 776   return val;
 777 }
 778
 779 DOUBLEST
 780 deprecated_extract_floating (const void *addr, int len)
 781 {
 782   return extract_floating_by_length (addr, len);
 783 }
 784
 785 /* Store VAL as a floating-point number of length LEN to a
 786    target-order byte-stream at ADDR.  */
 787
 788 static void
 789 store_floating_by_length (void *addr, int len, DOUBLEST val)
 790 {
 791   const struct floatformat *fmt = floatformat_from_length (len);
 792
 793   floatformat_from_doublest (fmt, &val, addr);
 794 }
 795
 796 void
 797 deprecated_store_floating (void *addr, int len, DOUBLEST val)
 798 {
 799   store_floating_by_length (addr, len, val);
 800 }
 801
 802 /* Extract a floating-point number of type TYPE from a target-order
 803    byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
 804
 805 DOUBLEST
 806 extract_typed_floating (const void *addr, const struct type *type)
 807 {
 808   DOUBLEST retval;
 809
 810   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
 811
 812   if (TYPE_FLOATFORMAT (type) == NULL)
 813     /* Not all code remembers to set the FLOATFORMAT (language
 814        specific code? stabs?) so handle that here as a special case.  */
 815     return extract_floating_by_length (addr, TYPE_LENGTH (type));
 816
 817   floatformat_to_doublest
 818         (TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)],
 819                            addr, &retval);
 820   return retval;
 821 }
 822
 823 /* Store VAL as a floating-point number of type TYPE to a target-order
 824    byte-stream at ADDR.  */
 825
 826 void
 827 store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
 828 {
 829   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
 830
 831   /* FIXME: kettenis/2001-10-28: It is debatable whether we should
 832      zero out any remaining bytes in the target buffer when TYPE is
 833      longer than the actual underlying floating-point format.  Perhaps
 834      we should store a fixed bitpattern in those remaining bytes,
 835      instead of zero, or perhaps we shouldn't touch those remaining
 836      bytes at all.
 837
 838      NOTE: cagney/2001-10-28: With the way things currently work, it
 839      isn't a good idea to leave the end bits undefined.  This is
 840      because GDB writes out the entire sizeof(<floating>) bits of the
 841      floating-point type even though the value might only be stored
 842      in, and the target processor may only refer to, the first N <
 843      TYPE_LENGTH (type) bits.  If the end of the buffer wasn't
 844      initialized, GDB would write undefined data to the target.  An
 845      errant program, refering to that undefined data, would then
 846      become non-deterministic.
 847
 848      See also the function convert_typed_floating below.  */
 849   memset (addr, 0, TYPE_LENGTH (type));
 850
 851   if (TYPE_FLOATFORMAT (type) == NULL)
 852     /* Not all code remembers to set the FLOATFORMAT (language
 853        specific code? stabs?) so handle that here as a special case.  */
 854     store_floating_by_length (addr, TYPE_LENGTH (type), val);
 855   else
 856     floatformat_from_doublest
 857         (TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)],
 858         &val, addr);
 859 }
 860
 861 /* Convert a floating-point number of type FROM_TYPE from a
 862    target-order byte-stream at FROM to a floating-point number of type
 863    TO_TYPE, and store it to a target-order byte-stream at TO.  */
 864
 865 void
 866 convert_typed_floating (const void *from, const struct type *from_type,
 867                         void *to, const struct type *to_type)
 868 {
 869   const struct floatformat *from_fmt = floatformat_from_type (from_type);
 870   const struct floatformat *to_fmt = floatformat_from_type (to_type);
 871
 872   gdb_assert (TYPE_CODE (from_type) == TYPE_CODE_FLT);
 873   gdb_assert (TYPE_CODE (to_type) == TYPE_CODE_FLT);
 874
 875   if (from_fmt == NULL || to_fmt == NULL)
 876     {
 877       /* If we don't know the floating-point format of FROM_TYPE or
 878          TO_TYPE, there's not much we can do.  We might make the
 879          assumption that if the length of FROM_TYPE and TO_TYPE match,
 880          their floating-point format would match too, but that
 881          assumption might be wrong on targets that support
 882          floating-point types that only differ in endianness for
 883          example.  So we warn instead, and zero out the target buffer.  */
 884       warning (_("Can't convert floating-point number to desired type."));
 885       memset (to, 0, TYPE_LENGTH (to_type));
 886     }
 887   else if (from_fmt == to_fmt)
 888     {
 889       /* We're in business.  The floating-point format of FROM_TYPE
 890          and TO_TYPE match.  However, even though the floating-point
 891          format matches, the length of the type might still be
 892          different.  Make sure we don't overrun any buffers.  See
 893          comment in store_typed_floating for a discussion about
 894          zeroing out remaining bytes in the target buffer.  */
 895       memset (to, 0, TYPE_LENGTH (to_type));
 896       memcpy (to, from, min (TYPE_LENGTH (from_type), TYPE_LENGTH (to_type)));
 897     }
 898   else
 899     {
 900       /* The floating-point types don't match.  The best we can do
 901          (aport from simulating the target FPU) is converting to the
 902          widest floating-point type supported by the host, and then
 903          again to the desired type.  */
 904       DOUBLEST d;
 905
 906       floatformat_to_doublest (from_fmt, from, &d);
 907       floatformat_from_doublest (to_fmt, &d, to);
 908     }
 909 }
 910
 911 const struct floatformat *floatformat_ieee_single[BFD_ENDIAN_UNKNOWN];
 912 const struct floatformat *floatformat_ieee_double[BFD_ENDIAN_UNKNOWN];
 913 const struct floatformat *floatformat_ieee_quad[BFD_ENDIAN_UNKNOWN];
 914 const struct floatformat *floatformat_arm_ext[BFD_ENDIAN_UNKNOWN];
 915 const struct floatformat *floatformat_ia64_spill[BFD_ENDIAN_UNKNOWN];
 916
 917 extern void _initialize_doublest (void);
 918
 919 extern void
 920 _initialize_doublest (void)
 921 {
 922   floatformat_ieee_single[BFD_ENDIAN_LITTLE] = &floatformat_ieee_single_little;
 923   floatformat_ieee_single[BFD_ENDIAN_BIG] = &floatformat_ieee_single_big;
 924   floatformat_ieee_double[BFD_ENDIAN_LITTLE] = &floatformat_ieee_double_little;
 925   floatformat_ieee_double[BFD_ENDIAN_BIG] = &floatformat_ieee_double_big;
 926   floatformat_arm_ext[BFD_ENDIAN_LITTLE] = &floatformat_arm_ext_littlebyte_bigword;
 927   floatformat_arm_ext[BFD_ENDIAN_BIG] = &floatformat_arm_ext_big;
 928   floatformat_ia64_spill[BFD_ENDIAN_LITTLE] = &floatformat_ia64_spill_little;
 929   floatformat_ia64_spill[BFD_ENDIAN_BIG] = &floatformat_ia64_spill_big;
 930   floatformat_ieee_quad[BFD_ENDIAN_LITTLE] = &floatformat_ia64_quad_little;
 931   floatformat_ieee_quad[BFD_ENDIAN_BIG] = &floatformat_ia64_quad_big;
 932 }