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