gcc/dfp.c

   1 /* Decimal floating point support.
   2    Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tm.h"
  24 #include "tree.h"
  25 #include "toplev.h"
  26 #include "real.h"
  27 #include "tm_p.h"
  28 #include "dfp.h"
  29
  30 /* The order of the following headers is important for making sure
  31    decNumber structure is large enough to hold decimal128 digits.  */
  32
  33 #include "decimal128.h"
  34 #include "decimal128Local.h"
  35 #include "decimal64.h"
  36 #include "decimal32.h"
  37 #include "decNumber.h"
  38
  39 #ifndef WORDS_BIGENDIAN
  40 #define WORDS_BIGENDIAN 0
  41 #endif
  42
  43 /* Initialize R (a real with the decimal flag set) from DN.  Can
  44    utilize status passed in via CONTEXT, if a previous operation had
  45    interesting status.  */
  46
  47 static void
  48 decimal_from_decnumber (REAL_VALUE_TYPE *r, decNumber *dn, decContext *context)
  49 {
  50   memset (r, 0, sizeof (REAL_VALUE_TYPE));
  51
  52   r->cl = rvc_normal;
  53   if (decNumberIsNaN (dn))
  54     r->cl = rvc_nan;
  55   if (decNumberIsInfinite (dn))
  56     r->cl = rvc_inf;
  57   if (context->status & DEC_Overflow)
  58     r->cl = rvc_inf;
  59   if (decNumberIsNegative (dn))
  60     r->sign = 1;
  61   r->decimal = 1;
  62
  63   if (r->cl != rvc_normal)
  64     return;
  65
  66   decContextDefault (context, DEC_INIT_DECIMAL128);
  67   context->traps = 0;
  68
  69   decimal128FromNumber ((decimal128 *) r->sig, dn, context);
  70 }
  71
  72 /* Create decimal encoded R from string S.  */
  73
  74 void
  75 decimal_real_from_string (REAL_VALUE_TYPE *r, const char *s)
  76 {
  77   decNumber dn;
  78   decContext set;
  79   decContextDefault (&set, DEC_INIT_DECIMAL128);
  80   set.traps = 0;
  81
  82   decNumberFromString (&dn, s, &set);
  83
  84   /* It would be more efficient to store directly in decNumber format,
  85      but that is impractical from current data structure size.
  86      Encoding as a decimal128 is much more compact.  */
  87   decimal_from_decnumber (r, &dn, &set);
  88 }
  89
  90 /* Initialize a decNumber from a REAL_VALUE_TYPE.  */
  91
  92 static void
  93 decimal_to_decnumber (const REAL_VALUE_TYPE *r, decNumber *dn)
  94 {
  95   decContext set;
  96   decContextDefault (&set, DEC_INIT_DECIMAL128);
  97   set.traps = 0;
  98
  99   switch (r->cl)
 100     {
 101     case rvc_zero:
 102       decNumberZero (dn);
 103       break;
 104     case rvc_inf:
 105       decNumberFromString (dn, "Infinity", &set);
 106       break;
 107     case rvc_nan:
 108       if (r->signalling)
 109         decNumberFromString (dn, "snan", &set);
 110       else
 111         decNumberFromString (dn, "nan", &set);
 112       break;
 113     case rvc_normal:
 114       gcc_assert (r->decimal);
 115       decimal128ToNumber ((const decimal128 *) r->sig, dn);
 116       break;
 117     default:
 118       gcc_unreachable ();
 119     }
 120
 121   /* Fix up sign bit.  */
 122   if (r->sign != decNumberIsNegative (dn))
 123     dn->bits ^= DECNEG;
 124 }
 125
 126 /* Encode a real into an IEEE 754 decimal32 type.  */
 127
 128 void
 129 encode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
 130                   long *buf, const REAL_VALUE_TYPE *r)
 131 {
 132   decNumber dn;
 133   decimal32 d32;
 134   decContext set;
 135
 136   decContextDefault (&set, DEC_INIT_DECIMAL128);
 137   set.traps = 0;
 138
 139   decimal_to_decnumber (r, &dn);
 140   decimal32FromNumber (&d32, &dn, &set);
 141
 142   buf[0] = *(uint32_t *) d32.bytes;
 143 }
 144
 145 /* Decode an IEEE 754 decimal32 type into a real.  */
 146
 147 void
 148 decode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
 149                   REAL_VALUE_TYPE *r, const long *buf)
 150 {
 151   decNumber dn;
 152   decimal32 d32;
 153   decContext set;
 154
 155   decContextDefault (&set, DEC_INIT_DECIMAL128);
 156   set.traps = 0;
 157
 158   *((uint32_t *) d32.bytes) = (uint32_t) buf[0];
 159
 160   decimal32ToNumber (&d32, &dn);
 161   decimal_from_decnumber (r, &dn, &set);
 162 }
 163
 164 /* Encode a real into an IEEE 754 decimal64 type.  */
 165
 166 void
 167 encode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
 168                   long *buf, const REAL_VALUE_TYPE *r)
 169 {
 170   decNumber dn;
 171   decimal64 d64;
 172   decContext set;
 173
 174   decContextDefault (&set, DEC_INIT_DECIMAL128);
 175   set.traps = 0;
 176
 177   decimal_to_decnumber (r, &dn);
 178   decimal64FromNumber (&d64, &dn, &set);
 179
 180   if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
 181     {
 182       buf[0] = *(uint32_t *) &d64.bytes[0];
 183       buf[1] = *(uint32_t *) &d64.bytes[4];
 184     }
 185   else
 186     {
 187       buf[0] = *(uint32_t *) &d64.bytes[4];
 188       buf[1] = *(uint32_t *) &d64.bytes[0];
 189     }
 190 }
 191
 192 /* Decode an IEEE 754 decimal64 type into a real.  */
 193
 194 void
 195 decode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
 196                   REAL_VALUE_TYPE *r, const long *buf)
 197 {
 198   decNumber dn;
 199   decimal64 d64;
 200   decContext set;
 201
 202   decContextDefault (&set, DEC_INIT_DECIMAL128);
 203   set.traps = 0;
 204
 205   if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
 206     {
 207       *((uint32_t *) &d64.bytes[0]) = (uint32_t) buf[0];
 208       *((uint32_t *) &d64.bytes[4]) = (uint32_t) buf[1];
 209     }
 210   else
 211     {
 212       *((uint32_t *) &d64.bytes[0]) = (uint32_t) buf[1];
 213       *((uint32_t *) &d64.bytes[4]) = (uint32_t) buf[0];
 214     }
 215
 216   decimal64ToNumber (&d64, &dn);
 217   decimal_from_decnumber (r, &dn, &set);
 218 }
 219
 220 /* Encode a real into an IEEE 754 decimal128 type.  */
 221
 222 void
 223 encode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
 224                    long *buf, const REAL_VALUE_TYPE *r)
 225 {
 226   decNumber dn;
 227   decContext set;
 228   decimal128 d128;
 229
 230   decContextDefault (&set, DEC_INIT_DECIMAL128);
 231   set.traps = 0;
 232
 233   decimal_to_decnumber (r, &dn);
 234   decimal128FromNumber (&d128, &dn, &set);
 235
 236   if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
 237     {
 238       buf[0] = *(uint32_t *) &d128.bytes[0];
 239       buf[1] = *(uint32_t *) &d128.bytes[4];
 240       buf[2] = *(uint32_t *) &d128.bytes[8];
 241       buf[3] = *(uint32_t *) &d128.bytes[12];
 242     }
 243   else
 244     {
 245       buf[0] = *(uint32_t *) &d128.bytes[12];
 246       buf[1] = *(uint32_t *) &d128.bytes[8];
 247       buf[2] = *(uint32_t *) &d128.bytes[4];
 248       buf[3] = *(uint32_t *) &d128.bytes[0];
 249     }
 250 }
 251
 252 /* Decode an IEEE 754 decimal128 type into a real.  */
 253
 254 void
 255 decode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
 256                    REAL_VALUE_TYPE *r, const long *buf)
 257 {
 258   decNumber dn;
 259   decimal128 d128;
 260   decContext set;
 261
 262   decContextDefault (&set, DEC_INIT_DECIMAL128);
 263   set.traps = 0;
 264
 265   if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
 266     {
 267       *((uint32_t *) &d128.bytes[0])  = (uint32_t) buf[0];
 268       *((uint32_t *) &d128.bytes[4])  = (uint32_t) buf[1];
 269       *((uint32_t *) &d128.bytes[8])  = (uint32_t) buf[2];
 270       *((uint32_t *) &d128.bytes[12]) = (uint32_t) buf[3];
 271     }
 272   else
 273     {
 274       *((uint32_t *) &d128.bytes[0])  = (uint32_t) buf[3];
 275       *((uint32_t *) &d128.bytes[4])  = (uint32_t) buf[2];
 276       *((uint32_t *) &d128.bytes[8])  = (uint32_t) buf[1];
 277       *((uint32_t *) &d128.bytes[12]) = (uint32_t) buf[0];
 278     }
 279
 280   decimal128ToNumber (&d128, &dn);
 281   decimal_from_decnumber (r, &dn, &set);
 282 }
 283
 284 /* Helper function to convert from a binary real internal
 285    representation.  */
 286
 287 static void
 288 decimal_to_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from,
 289                    enum machine_mode mode)
 290 {
 291   char string[256];
 292   const decimal128 *const d128 = (const decimal128 *) from->sig;
 293
 294   decimal128ToString (d128, string);
 295   real_from_string3 (to, string, mode);
 296 }
 297
 298
 299 /* Helper function to convert from a binary real internal
 300    representation.  */
 301
 302 static void
 303 decimal_from_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from)
 304 {
 305   char string[256];
 306
 307   /* We convert to string, then to decNumber then to decimal128.  */
 308   real_to_decimal (string, from, sizeof (string), 0, 1);
 309   decimal_real_from_string (to, string);
 310 }
 311
 312 /* Helper function to real.c:do_compare() to handle decimal internal
 313    representation including when one of the operands is still in the
 314    binary internal representation.  */
 315
 316 int
 317 decimal_do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
 318                     int nan_result)
 319 {
 320   decContext set;
 321   decNumber dn, dn2, dn3;
 322   REAL_VALUE_TYPE a1, b1;
 323
 324   /* If either operand is non-decimal, create temporary versions.  */
 325   if (!a->decimal)
 326     {
 327       decimal_from_binary (&a1, a);
 328       a = &a1;
 329     }
 330   if (!b->decimal)
 331     {
 332       decimal_from_binary (&b1, b);
 333       b = &b1;
 334     }
 335
 336   /* Convert into decNumber form for comparison operation.  */
 337   decContextDefault (&set, DEC_INIT_DECIMAL128);
 338   set.traps = 0;
 339   decimal128ToNumber ((const decimal128 *) a->sig, &dn2);
 340   decimal128ToNumber ((const decimal128 *) b->sig, &dn3);
 341
 342   /* Finally, do the comparison.  */
 343   decNumberCompare (&dn, &dn2, &dn3, &set);
 344
 345   /* Return the comparison result.  */
 346   if (decNumberIsNaN (&dn))
 347     return nan_result;
 348   else if (decNumberIsZero (&dn))
 349     return 0;
 350   else if (decNumberIsNegative (&dn))
 351     return -1;
 352   else
 353     return 1;
 354 }
 355
 356 /* Helper to round_for_format, handling decimal float types.  */
 357
 358 void
 359 decimal_round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
 360 {
 361   decNumber dn;
 362   decContext set;
 363
 364   /* Real encoding occurs later.  */
 365   if (r->cl != rvc_normal)
 366     return;
 367
 368   decContextDefault (&set, DEC_INIT_DECIMAL128);
 369   set.traps = 0;
 370   decimal128ToNumber ((decimal128 *) r->sig, &dn);
 371
 372   if (fmt == &decimal_quad_format)
 373     {
 374       /* The internal format is already in this format.  */
 375       return;
 376     }
 377   else if (fmt == &decimal_single_format)
 378     {
 379       decimal32 d32;
 380       decContextDefault (&set, DEC_INIT_DECIMAL32);
 381       set.traps = 0;
 382
 383       decimal32FromNumber (&d32, &dn, &set);
 384       decimal32ToNumber (&d32, &dn);
 385     }
 386   else if (fmt == &decimal_double_format)
 387     {
 388       decimal64 d64;
 389       decContextDefault (&set, DEC_INIT_DECIMAL64);
 390       set.traps = 0;
 391
 392       decimal64FromNumber (&d64, &dn, &set);
 393       decimal64ToNumber (&d64, &dn);
 394     }
 395   else
 396     gcc_unreachable ();
 397
 398   decimal_from_decnumber (r, &dn, &set);
 399 }
 400
 401 /* Extend or truncate to a new mode.  Handles conversions between
 402    binary and decimal types.  */
 403
 404 void
 405 decimal_real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
 406                       const REAL_VALUE_TYPE *a)
 407 {
 408   const struct real_format *fmt = REAL_MODE_FORMAT (mode);
 409
 410   if (a->decimal && fmt->b == 10)
 411     return;
 412   if (a->decimal)
 413       decimal_to_binary (r, a, mode);
 414   else
 415       decimal_from_binary (r, a);
 416 }
 417
 418 /* Render R_ORIG as a decimal floating point constant.  Emit DIGITS
 419    significant digits in the result, bounded by BUF_SIZE.  If DIGITS
 420    is 0, choose the maximum for the representation.  If
 421    CROP_TRAILING_ZEROS, strip trailing zeros.  Currently, not honoring
 422    DIGITS or CROP_TRAILING_ZEROS.  */
 423
 424 void
 425 decimal_real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig,
 426                          size_t buf_size,
 427                          size_t digits ATTRIBUTE_UNUSED,
 428                          int crop_trailing_zeros ATTRIBUTE_UNUSED)
 429 {
 430   const decimal128 *const d128 = (const decimal128*) r_orig->sig;
 431
 432   /* decimal128ToString requires space for at least 24 characters;
 433      Require two more for suffix.  */
 434   gcc_assert (buf_size >= 24);
 435   decimal128ToString (d128, str);
 436 }
 437
 438 static bool
 439 decimal_do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
 440                 const REAL_VALUE_TYPE *op1, int subtract_p)
 441 {
 442   decNumber dn;
 443   decContext set;
 444   decNumber dn2, dn3;
 445
 446   decimal_to_decnumber (op0, &dn2);
 447   decimal_to_decnumber (op1, &dn3);
 448
 449   decContextDefault (&set, DEC_INIT_DECIMAL128);
 450   set.traps = 0;
 451
 452   if (subtract_p)
 453     decNumberSubtract (&dn, &dn2, &dn3, &set);
 454   else
 455     decNumberAdd (&dn, &dn2, &dn3, &set);
 456
 457   decimal_from_decnumber (r, &dn, &set);
 458
 459   /* Return true, if inexact.  */
 460   return (set.status & DEC_Inexact);
 461 }
 462
 463 /* Compute R = OP0 * OP1.  */
 464
 465 static bool
 466 decimal_do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
 467                      const REAL_VALUE_TYPE *op1)
 468 {
 469   decContext set;
 470   decNumber dn, dn2, dn3;
 471
 472   decimal_to_decnumber (op0, &dn2);
 473   decimal_to_decnumber (op1, &dn3);
 474
 475   decContextDefault (&set, DEC_INIT_DECIMAL128);
 476   set.traps = 0;
 477
 478   decNumberMultiply (&dn, &dn2, &dn3, &set);
 479   decimal_from_decnumber (r, &dn, &set);
 480
 481   /* Return true, if inexact.  */
 482   return (set.status & DEC_Inexact);
 483 }
 484
 485 /* Compute R = OP0 / OP1.  */
 486
 487 static bool
 488 decimal_do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
 489                    const REAL_VALUE_TYPE *op1)
 490 {
 491   decContext set;
 492   decNumber dn, dn2, dn3;
 493
 494   decimal_to_decnumber (op0, &dn2);
 495   decimal_to_decnumber (op1, &dn3);
 496
 497   decContextDefault (&set, DEC_INIT_DECIMAL128);
 498   set.traps = 0;
 499
 500   decNumberDivide (&dn, &dn2, &dn3, &set);
 501   decimal_from_decnumber (r, &dn, &set);
 502
 503   /* Return true, if inexact.  */
 504   return (set.status & DEC_Inexact);
 505 }
 506
 507 /* Set R to A truncated to an integral value toward zero (decimal
 508    floating point).  */
 509
 510 void
 511 decimal_do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
 512 {
 513   decNumber dn, dn2;
 514   decContext set;
 515
 516   decContextDefault (&set, DEC_INIT_DECIMAL128);
 517   set.traps = 0;
 518   set.round = DEC_ROUND_DOWN;
 519   decimal128ToNumber ((const decimal128 *) a->sig, &dn2);
 520
 521   decNumberToIntegralValue (&dn, &dn2, &set);
 522   decimal_from_decnumber (r, &dn, &set);
 523 }
 524
 525 /* Render decimal float value R as an integer.  */
 526
 527 HOST_WIDE_INT
 528 decimal_real_to_integer (const REAL_VALUE_TYPE *r)
 529 {
 530   decContext set;
 531   decNumber dn, dn2, dn3;
 532   REAL_VALUE_TYPE to;
 533   char string[256];
 534
 535   decContextDefault (&set, DEC_INIT_DECIMAL128);
 536   set.traps = 0;
 537   set.round = DEC_ROUND_DOWN;
 538   decimal128ToNumber ((const decimal128 *) r->sig, &dn);
 539
 540   decNumberToIntegralValue (&dn2, &dn, &set);
 541   decNumberZero (&dn3);
 542   decNumberRescale (&dn, &dn2, &dn3, &set);
 543
 544   /* Convert to REAL_VALUE_TYPE and call appropriate conversion
 545      function.  */
 546   decNumberToString (&dn, string);
 547   real_from_string (&to, string);
 548   return real_to_integer (&to);
 549 }
 550
 551 /* Likewise, but to an integer pair, HI+LOW.  */
 552
 553 void
 554 decimal_real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
 555                           const REAL_VALUE_TYPE *r)
 556 {
 557   decContext set;
 558   decNumber dn, dn2, dn3;
 559   REAL_VALUE_TYPE to;
 560   char string[256];
 561
 562   decContextDefault (&set, DEC_INIT_DECIMAL128);
 563   set.traps = 0;
 564   set.round = DEC_ROUND_DOWN;
 565   decimal128ToNumber ((const decimal128 *) r->sig, &dn);
 566
 567   decNumberToIntegralValue (&dn2, &dn, &set);
 568   decNumberZero (&dn3);
 569   decNumberRescale (&dn, &dn2, &dn3, &set);
 570
 571   /* Convert to REAL_VALUE_TYPE and call appropriate conversion
 572      function.  */
 573   decNumberToString (&dn, string);
 574   real_from_string (&to, string);
 575   real_to_integer2 (plow, phigh, &to);
 576 }
 577
 578 /* Perform the decimal floating point operation described by CODE.
 579    For a unary operation, OP1 will be NULL.  This function returns
 580    true if the result may be inexact due to loss of precision.  */
 581
 582 bool
 583 decimal_real_arithmetic (REAL_VALUE_TYPE *r, enum tree_code code,
 584                          const REAL_VALUE_TYPE *op0,
 585                          const REAL_VALUE_TYPE *op1)
 586 {
 587   REAL_VALUE_TYPE a, b;
 588
 589   /* If either operand is non-decimal, create temporaries.  */
 590   if (!op0->decimal)
 591     {
 592       decimal_from_binary (&a, op0);
 593       op0 = &a;
 594     }
 595   if (op1 && !op1->decimal)
 596     {
 597       decimal_from_binary (&b, op1);
 598       op1 = &b;
 599     }
 600
 601   switch (code)
 602     {
 603     case PLUS_EXPR:
 604       return decimal_do_add (r, op0, op1, 0);
 605
 606     case MINUS_EXPR:
 607       return decimal_do_add (r, op0, op1, 1);
 608
 609     case MULT_EXPR:
 610       return decimal_do_multiply (r, op0, op1);
 611
 612     case RDIV_EXPR:
 613       return decimal_do_divide (r, op0, op1);
 614
 615     case MIN_EXPR:
 616       if (op1->cl == rvc_nan)
 617         *r = *op1;
 618       else if (real_compare (UNLT_EXPR, op0, op1))
 619         *r = *op0;
 620       else
 621         *r = *op1;
 622       return false;
 623
 624     case MAX_EXPR:
 625       if (op1->cl == rvc_nan)
 626         *r = *op1;
 627       else if (real_compare (LT_EXPR, op0, op1))
 628         *r = *op1;
 629       else
 630         *r = *op0;
 631       return false;
 632
 633     case NEGATE_EXPR:
 634       {
 635         *r = *op0;
 636         /* Flip sign bit.  */
 637         decimal128FlipSign ((decimal128 *) r->sig);
 638         /* Keep sign field in sync.  */
 639         r->sign ^= 1;
 640       }
 641       return false;
 642
 643     case ABS_EXPR:
 644       {
 645         *r = *op0;
 646         /* Clear sign bit.  */
 647         decimal128ClearSign ((decimal128 *) r->sig);
 648         /* Keep sign field in sync.  */
 649         r->sign = 0;
 650       }
 651       return false;
 652
 653     case FIX_TRUNC_EXPR:
 654       decimal_do_fix_trunc (r, op0);
 655       return false;
 656
 657     default:
 658       gcc_unreachable ();
 659     }
 660 }
 661
 662 /* Fills R with the largest finite value representable in mode MODE.
 663    If SIGN is nonzero, R is set to the most negative finite value.  */
 664
 665 void
 666 decimal_real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
 667 {
 668   const char *max;
 669
 670   switch (mode)
 671     {
 672     case SDmode:
 673       max = "9.999999E96";
 674       break;
 675     case DDmode:
 676       max = "9.999999999999999E384";
 677       break;
 678     case TDmode:
 679       max = "9.999999999999999999999999999999999E6144";
 680       break;
 681     default:
 682       gcc_unreachable ();
 683     }
 684
 685   decimal_real_from_string (r, max);
 686   if (sign)
 687     decimal128SetSign ((decimal128 *) r->sig, 1);
 688 }