gdb/doublest.c

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