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