contrib/gdb-7/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, 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 \f
 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 \f
 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 \f
 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 }