gcc/dfp.c

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