gcc/dfp.c

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