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