gcc/dfp.c

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