libiberty/floatformat.c

   1 /* IEEE floating point support routines, for GDB, the GNU Debugger.
   2    Copyright (C) 1991, 1994, 1999, 2000, 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "ansidecl.h"
  21 #include "floatformat.h"
  22 #include <math.h>               /* ldexp */
  23 #ifdef ANSI_PROTOTYPES
  24 #include <stddef.h>
  25 extern void *memcpy (void *s1, const void *s2, size_t n);
  26 extern void *memset (void *s, int c, size_t n);
  27 #else
  28 extern char *memcpy ();
  29 extern char *memset ();
  30 #endif
  31
  32 static unsigned long get_field PARAMS ((const unsigned char *,
  33                                         enum floatformat_byteorders,
  34                                         unsigned int,
  35                                         unsigned int,
  36                                         unsigned int));
  37 static int floatformat_always_valid PARAMS ((const struct floatformat *fmt,
  38                                              const char *from));
  39
  40 static int
  41 floatformat_always_valid (fmt, from)
  42      const struct floatformat *fmt;
  43      const char *from;
  44 {
  45   return 1;
  46 }
  47
  48 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
  49    going to bother with trying to muck around with whether it is defined in
  50    a system header, what we do if not, etc.  */
  51 #define FLOATFORMAT_CHAR_BIT 8
  52
  53 /* floatformats for IEEE single and double, big and little endian.  */
  54 const struct floatformat floatformat_ieee_single_big =
  55 {
  56   floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23,
  57   floatformat_intbit_no,
  58   "floatformat_ieee_single_big",
  59   floatformat_always_valid
  60 };
  61 const struct floatformat floatformat_ieee_single_little =
  62 {
  63   floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23,
  64   floatformat_intbit_no,
  65   "floatformat_ieee_single_little",
  66   floatformat_always_valid
  67 };
  68 const struct floatformat floatformat_ieee_double_big =
  69 {
  70   floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52,
  71   floatformat_intbit_no,
  72   "floatformat_ieee_double_big",
  73   floatformat_always_valid
  74 };
  75 const struct floatformat floatformat_ieee_double_little =
  76 {
  77   floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52,
  78   floatformat_intbit_no,
  79   "floatformat_ieee_double_little",
  80   floatformat_always_valid
  81 };
  82
  83 /* floatformat for IEEE double, little endian byte order, with big endian word
  84    ordering, as on the ARM.  */
  85
  86 const struct floatformat floatformat_ieee_double_littlebyte_bigword =
  87 {
  88   floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52,
  89   floatformat_intbit_no,
  90   "floatformat_ieee_double_littlebyte_bigword",
  91   floatformat_always_valid
  92 };
  93
  94 static int floatformat_i387_ext_is_valid PARAMS ((const struct floatformat *fmt, const char *from));
  95
  96 static int
  97 floatformat_i387_ext_is_valid (fmt, from)
  98      const struct floatformat *fmt;
  99      const char *from;
 100 {
 101   /* In the i387 double-extended format, if the exponent is all ones,
 102      then the integer bit must be set.  If the exponent is neither 0
 103      nor ~0, the intbit must also be set.  Only if the exponent is
 104      zero can it be zero, and then it must be zero.  */
 105   unsigned long exponent, int_bit;
 106   const unsigned char *ufrom = (const unsigned char *) from;
 107
 108   exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
 109                         fmt->exp_start, fmt->exp_len);
 110   int_bit = get_field (ufrom, fmt->byteorder, fmt->totalsize,
 111                        fmt->man_start, 1);
 112
 113   if ((exponent == 0) != (int_bit == 0))
 114     return 0;
 115   else
 116     return 1;
 117 }
 118
 119 const struct floatformat floatformat_i387_ext =
 120 {
 121   floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
 122   floatformat_intbit_yes,
 123   "floatformat_i387_ext",
 124   floatformat_i387_ext_is_valid
 125 };
 126 const struct floatformat floatformat_m68881_ext =
 127 {
 128   /* Note that the bits from 16 to 31 are unused.  */
 129   floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64,
 130   floatformat_intbit_yes,
 131   "floatformat_m68881_ext",
 132   floatformat_always_valid
 133 };
 134 const struct floatformat floatformat_i960_ext =
 135 {
 136   /* Note that the bits from 0 to 15 are unused.  */
 137   floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64,
 138   floatformat_intbit_yes,
 139   "floatformat_i960_ext",
 140   floatformat_always_valid
 141 };
 142 const struct floatformat floatformat_m88110_ext =
 143 {
 144   floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
 145   floatformat_intbit_yes,
 146   "floatformat_m88110_ext",
 147   floatformat_always_valid
 148 };
 149 const struct floatformat floatformat_m88110_harris_ext =
 150 {
 151   /* Harris uses raw format 128 bytes long, but the number is just an ieee
 152      double, and the last 64 bits are wasted. */
 153   floatformat_big,128, 0, 1, 11,  0x3ff,  0x7ff, 12, 52,
 154   floatformat_intbit_no,
 155   "floatformat_m88110_ext_harris",
 156   floatformat_always_valid
 157 };
 158 const struct floatformat floatformat_arm_ext_big =
 159 {
 160   /* Bits 1 to 16 are unused.  */
 161   floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
 162   floatformat_intbit_yes,
 163   "floatformat_arm_ext_big",
 164   floatformat_always_valid
 165 };
 166 const struct floatformat floatformat_arm_ext_littlebyte_bigword =
 167 {
 168   /* Bits 1 to 16 are unused.  */
 169   floatformat_littlebyte_bigword, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
 170   floatformat_intbit_yes,
 171   "floatformat_arm_ext_littlebyte_bigword",
 172   floatformat_always_valid
 173 };
 174 const struct floatformat floatformat_ia64_spill_big =
 175 {
 176   floatformat_big, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
 177   floatformat_intbit_yes,
 178   "floatformat_ia64_spill_big",
 179   floatformat_always_valid
 180 };
 181 const struct floatformat floatformat_ia64_spill_little =
 182 {
 183   floatformat_little, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
 184   floatformat_intbit_yes,
 185   "floatformat_ia64_spill_little",
 186   floatformat_always_valid
 187 };
 188 const struct floatformat floatformat_ia64_quad_big =
 189 {
 190   floatformat_big, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
 191   floatformat_intbit_no,
 192   "floatformat_ia64_quad_big",
 193   floatformat_always_valid
 194 };
 195 const struct floatformat floatformat_ia64_quad_little =
 196 {
 197   floatformat_little, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
 198   floatformat_intbit_no,
 199   "floatformat_ia64_quad_little",
 200   floatformat_always_valid
 201 };
 202 \f
 203 /* Extract a field which starts at START and is LEN bits long.  DATA and
 204    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
 205 static unsigned long
 206 get_field (data, order, total_len, start, len)
 207      const unsigned char *data;
 208      enum floatformat_byteorders order;
 209      unsigned int total_len;
 210      unsigned int start;
 211      unsigned int len;
 212 {
 213   unsigned long result;
 214   unsigned int cur_byte;
 215   int cur_bitshift;
 216
 217   /* Start at the least significant part of the field.  */
 218   cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
 219   if (order == floatformat_little)
 220     cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
 221   cur_bitshift =
 222     ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
 223   result = *(data + cur_byte) >> (-cur_bitshift);
 224   cur_bitshift += FLOATFORMAT_CHAR_BIT;
 225   if (order == floatformat_little)
 226     ++cur_byte;
 227   else
 228     --cur_byte;
 229
 230   /* Move towards the most significant part of the field.  */
 231   while ((unsigned int) cur_bitshift < len)
 232     {
 233       if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
 234         /* This is the last byte; zero out the bits which are not part of
 235            this field.  */
 236         result |=
 237           (*(data + cur_byte) & ((1 << (len - cur_bitshift)) - 1))
 238             << cur_bitshift;
 239       else
 240         result |= *(data + cur_byte) << cur_bitshift;
 241       cur_bitshift += FLOATFORMAT_CHAR_BIT;
 242       if (order == floatformat_little)
 243         ++cur_byte;
 244       else
 245         --cur_byte;
 246     }
 247   return result;
 248 }
 249
 250 #ifndef min
 251 #define min(a, b) ((a) < (b) ? (a) : (b))
 252 #endif
 253
 254 /* Convert from FMT to a double.
 255    FROM is the address of the extended float.
 256    Store the double in *TO.  */
 257
 258 void
 259 floatformat_to_double (fmt, from, to)
 260      const struct floatformat *fmt;
 261      const char *from;
 262      double *to;
 263 {
 264   const unsigned char *ufrom = (const unsigned char *)from;
 265   double dto;
 266   long exponent;
 267   unsigned long mant;
 268   unsigned int mant_bits, mant_off;
 269   int mant_bits_left;
 270   int special_exponent;         /* It's a NaN, denorm or zero */
 271
 272   exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
 273                         fmt->exp_start, fmt->exp_len);
 274   /* Note that if exponent indicates a NaN, we can't really do anything useful
 275      (not knowing if the host has NaN's, or how to build one).  So it will
 276      end up as an infinity or something close; that is OK.  */
 277
 278   mant_bits_left = fmt->man_len;
 279   mant_off = fmt->man_start;
 280   dto = 0.0;
 281
 282   special_exponent = exponent == 0 || (unsigned long) exponent == fmt->exp_nan;
 283
 284   /* Don't bias zero's, denorms or NaNs.  */
 285   if (!special_exponent)
 286     exponent -= fmt->exp_bias;
 287
 288   /* Build the result algebraically.  Might go infinite, underflow, etc;
 289      who cares. */
 290
 291   /* If this format uses a hidden bit, explicitly add it in now.  Otherwise,
 292      increment the exponent by one to account for the integer bit.  */
 293
 294   if (!special_exponent)
 295     {
 296       if (fmt->intbit == floatformat_intbit_no)
 297         dto = ldexp (1.0, exponent);
 298       else
 299         exponent++;
 300     }
 301
 302   while (mant_bits_left > 0)
 303     {
 304       mant_bits = min (mant_bits_left, 32);
 305
 306       mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
 307                          mant_off, mant_bits);
 308
 309       dto += ldexp ((double)mant, exponent - mant_bits);
 310       exponent -= mant_bits;
 311       mant_off += mant_bits;
 312       mant_bits_left -= mant_bits;
 313     }
 314
 315   /* Negate it if negative.  */
 316   if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
 317     dto = -dto;
 318   *to = dto;
 319 }
 320 \f
 321 static void put_field PARAMS ((unsigned char *, enum floatformat_byteorders,
 322                                unsigned int,
 323                                unsigned int,
 324                                unsigned int,
 325                                unsigned long));
 326
 327 /* Set a field which starts at START and is LEN bits long.  DATA and
 328    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
 329 static void
 330 put_field (data, order, total_len, start, len, stuff_to_put)
 331      unsigned char *data;
 332      enum floatformat_byteorders order;
 333      unsigned int total_len;
 334      unsigned int start;
 335      unsigned int len;
 336      unsigned long stuff_to_put;
 337 {
 338   unsigned int cur_byte;
 339   int cur_bitshift;
 340
 341   /* Start at the least significant part of the field.  */
 342   cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
 343   if (order == floatformat_little)
 344     cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
 345   cur_bitshift =
 346     ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
 347   *(data + cur_byte) &=
 348     ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift));
 349   *(data + cur_byte) |=
 350     (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
 351   cur_bitshift += FLOATFORMAT_CHAR_BIT;
 352   if (order == floatformat_little)
 353     ++cur_byte;
 354   else
 355     --cur_byte;
 356
 357   /* Move towards the most significant part of the field.  */
 358   while ((unsigned int) cur_bitshift < len)
 359     {
 360       if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
 361         {
 362           /* This is the last byte.  */
 363           *(data + cur_byte) &=
 364             ~((1 << (len - cur_bitshift)) - 1);
 365           *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
 366         }
 367       else
 368         *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
 369                               & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
 370       cur_bitshift += FLOATFORMAT_CHAR_BIT;
 371       if (order == floatformat_little)
 372         ++cur_byte;
 373       else
 374         --cur_byte;
 375     }
 376 }
 377
 378 /* The converse: convert the double *FROM to an extended float
 379    and store where TO points.  Neither FROM nor TO have any alignment
 380    restrictions.  */
 381
 382 void
 383 floatformat_from_double (fmt, from, to)
 384      const struct floatformat *fmt;
 385      const double *from;
 386      char *to;
 387 {
 388   double dfrom;
 389   int exponent;
 390   double mant;
 391   unsigned int mant_bits, mant_off;
 392   int mant_bits_left;
 393   unsigned char *uto = (unsigned char *)to;
 394
 395   memcpy (&dfrom, from, sizeof (dfrom));
 396   memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
 397   if (dfrom == 0)
 398     return;                     /* Result is zero */
 399   if (dfrom != dfrom)
 400     {
 401       /* From is NaN */
 402       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
 403                  fmt->exp_len, fmt->exp_nan);
 404       /* Be sure it's not infinity, but NaN value is irrel */
 405       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
 406                  32, 1);
 407       return;
 408     }
 409
 410   /* If negative, set the sign bit.  */
 411   if (dfrom < 0)
 412     {
 413       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
 414       dfrom = -dfrom;
 415     }
 416
 417   /* How to tell an infinity from an ordinary number?  FIXME-someday */
 418
 419   mant = frexp (dfrom, &exponent);
 420   put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len,
 421              exponent + fmt->exp_bias - 1);
 422
 423   mant_bits_left = fmt->man_len;
 424   mant_off = fmt->man_start;
 425   while (mant_bits_left > 0)
 426     {
 427       unsigned long mant_long;
 428       mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
 429
 430       mant *= 4294967296.0;
 431       mant_long = (unsigned long)mant;
 432       mant -= mant_long;
 433
 434       /* If the integer bit is implicit, then we need to discard it.
 435          If we are discarding a zero, we should be (but are not) creating
 436          a denormalized number which means adjusting the exponent
 437          (I think).  */
 438       if ((unsigned int) mant_bits_left == fmt->man_len
 439           && fmt->intbit == floatformat_intbit_no)
 440         {
 441           mant_long &= 0x7fffffff;
 442           mant_bits -= 1;
 443         }
 444       else if (mant_bits < 32)
 445         {
 446           /* The bits we want are in the most significant MANT_BITS bits of
 447              mant_long.  Move them to the least significant.  */
 448           mant_long >>= 32 - mant_bits;
 449         }
 450
 451       put_field (uto, fmt->byteorder, fmt->totalsize,
 452                  mant_off, mant_bits, mant_long);
 453       mant_off += mant_bits;
 454       mant_bits_left -= mant_bits;
 455     }
 456 }
 457
 458 /* Return non-zero iff the data at FROM is a valid number in format FMT.  */
 459
 460 int
 461 floatformat_is_valid (fmt, from)
 462      const struct floatformat *fmt;
 463      const char *from;
 464 {
 465   return fmt->is_valid (fmt, from);
 466 }
 467
 468
 469 #ifdef IEEE_DEBUG
 470
 471 /* This is to be run on a host which uses IEEE floating point.  */
 472
 473 void
 474 ieee_test (n)
 475      double n;
 476 {
 477   double result;
 478   char exten[16];
 479
 480   floatformat_to_double (&floatformat_ieee_double_big, &n, &result);
 481   if (n != result)
 482     printf ("Differ(to): %.20g -> %.20g\n", n, result);
 483   floatformat_from_double (&floatformat_ieee_double_big, &n, &result);
 484   if (n != result)
 485     printf ("Differ(from): %.20g -> %.20g\n", n, result);
 486
 487   floatformat_from_double (&floatformat_m68881_ext, &n, exten);
 488   floatformat_to_double (&floatformat_m68881_ext, exten, &result);
 489   if (n != result)
 490     printf ("Differ(to+from): %.20g -> %.20g\n", n, result);
 491
 492 #if IEEE_DEBUG > 1
 493   /* This is to be run on a host which uses 68881 format.  */
 494   {
 495     long double ex = *(long double *)exten;
 496     if (ex != n)
 497       printf ("Differ(from vs. extended): %.20g\n", n);
 498   }
 499 #endif
 500 }
 501
 502 int
 503 main ()
 504 {
 505   ieee_test (0.5);
 506   ieee_test (256.0);
 507   ieee_test (0.12345);
 508   ieee_test (234235.78907234);
 509   ieee_test (-512.0);
 510   ieee_test (-0.004321);
 511   return 0;
 512 }
 513 #endif