contrib/gdb-7/gdb/doublest.c

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