gcc/dfp.c

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