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