1 /* Decimal floating point support.
2 Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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/>. */
22 #include "coretypes.h"
30 /* The order of the following headers is important for making sure
31 decNumber structure is large enough to hold decimal128 digits. */
33 #include "decimal128.h"
34 #include "decimal64.h"
35 #include "decimal32.h"
36 #include "decNumber.h"
39 dfp_byte_swap (uint32_t in)
42 unsigned char *p = (unsigned char *) &out;
57 /* Initialize R (a real with the decimal flag set) from DN. Can
58 utilize status passed in via CONTEXT, if a previous operation had
59 interesting status. */
62 decimal_from_decnumber (REAL_VALUE_TYPE *r, decNumber *dn, decContext *context)
64 memset (r, 0, sizeof (REAL_VALUE_TYPE));
67 if (decNumberIsZero (dn))
69 if (decNumberIsNaN (dn))
71 if (decNumberIsInfinite (dn))
73 if (context->status & DEC_Overflow)
75 if (decNumberIsNegative (dn))
79 if (r->cl != rvc_normal)
82 decContextDefault (context, DEC_INIT_DECIMAL128);
85 decimal128FromNumber ((decimal128 *) r->sig, dn, context);
88 /* Create decimal encoded R from string S. */
91 decimal_real_from_string (REAL_VALUE_TYPE *r, const char *s)
95 decContextDefault (&set, DEC_INIT_DECIMAL128);
98 decNumberFromString (&dn, s, &set);
100 /* It would be more efficient to store directly in decNumber format,
101 but that is impractical from current data structure size.
102 Encoding as a decimal128 is much more compact. */
103 decimal_from_decnumber (r, &dn, &set);
106 /* Initialize a decNumber from a REAL_VALUE_TYPE. */
109 decimal_to_decnumber (const REAL_VALUE_TYPE *r, decNumber *dn)
112 decContextDefault (&set, DEC_INIT_DECIMAL128);
121 decNumberFromString (dn, "Infinity", &set);
125 decNumberFromString (dn, "snan", &set);
127 decNumberFromString (dn, "nan", &set);
130 gcc_assert (r->decimal);
131 decimal128ToNumber ((const decimal128 *) r->sig, dn);
137 /* Fix up sign bit. */
138 if (r->sign != decNumberIsNegative (dn))
142 /* Encode a real into an IEEE 754R decimal32 type. */
145 encode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
146 long *buf, const REAL_VALUE_TYPE *r)
152 decContextDefault (&set, DEC_INIT_DECIMAL128);
155 decimal_to_decnumber (r, &dn);
156 decimal32FromNumber (&d32, &dn, &set);
158 if (FLOAT_WORDS_BIG_ENDIAN)
159 buf[0] = *(uint32_t *) d32.bytes;
161 buf[0] = dfp_byte_swap (*(uint32_t *) d32.bytes);
164 /* Decode an IEEE 754R decimal32 type into a real. */
167 decode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
168 REAL_VALUE_TYPE *r, const long *buf)
174 decContextDefault (&set, DEC_INIT_DECIMAL128);
177 if (FLOAT_WORDS_BIG_ENDIAN)
178 *((uint32_t *) d32.bytes) = (uint32_t) buf[0];
180 *((uint32_t *) d32.bytes) = dfp_byte_swap ((uint32_t) buf[0]);
182 decimal32ToNumber (&d32, &dn);
183 decimal_from_decnumber (r, &dn, &set);
186 /* Encode a real into an IEEE 754R decimal64 type. */
189 encode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
190 long *buf, const REAL_VALUE_TYPE *r)
196 decContextDefault (&set, DEC_INIT_DECIMAL128);
199 decimal_to_decnumber (r, &dn);
200 decimal64FromNumber (&d64, &dn, &set);
202 if (FLOAT_WORDS_BIG_ENDIAN)
204 buf[0] = *(uint32_t *) &d64.bytes[0];
205 buf[1] = *(uint32_t *) &d64.bytes[4];
209 buf[1] = dfp_byte_swap (*(uint32_t *) &d64.bytes[0]);
210 buf[0] = dfp_byte_swap (*(uint32_t *) &d64.bytes[4]);
214 /* Decode an IEEE 754R decimal64 type into a real. */
217 decode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
218 REAL_VALUE_TYPE *r, const long *buf)
224 decContextDefault (&set, DEC_INIT_DECIMAL128);
227 if (FLOAT_WORDS_BIG_ENDIAN)
229 *((uint32_t *) &d64.bytes[0]) = (uint32_t) buf[0];
230 *((uint32_t *) &d64.bytes[4]) = (uint32_t) buf[1];
234 *((uint32_t *) &d64.bytes[0]) = dfp_byte_swap ((uint32_t) buf[1]);
235 *((uint32_t *) &d64.bytes[4]) = dfp_byte_swap ((uint32_t) buf[0]);
238 decimal64ToNumber (&d64, &dn);
239 decimal_from_decnumber (r, &dn, &set);
242 /* Encode a real into an IEEE 754R decimal128 type. */
245 encode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
246 long *buf, const REAL_VALUE_TYPE *r)
252 decContextDefault (&set, DEC_INIT_DECIMAL128);
255 decimal_to_decnumber (r, &dn);
256 decimal128FromNumber (&d128, &dn, &set);
258 if (FLOAT_WORDS_BIG_ENDIAN)
260 buf[0] = *(uint32_t *) &d128.bytes[0];
261 buf[1] = *(uint32_t *) &d128.bytes[4];
262 buf[2] = *(uint32_t *) &d128.bytes[8];
263 buf[3] = *(uint32_t *) &d128.bytes[12];
267 buf[0] = dfp_byte_swap (*(uint32_t *) &d128.bytes[12]);
268 buf[1] = dfp_byte_swap (*(uint32_t *) &d128.bytes[8]);
269 buf[2] = dfp_byte_swap (*(uint32_t *) &d128.bytes[4]);
270 buf[3] = dfp_byte_swap (*(uint32_t *) &d128.bytes[0]);
274 /* Decode an IEEE 754R decimal128 type into a real. */
277 decode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
278 REAL_VALUE_TYPE *r, const long *buf)
284 decContextDefault (&set, DEC_INIT_DECIMAL128);
287 if (FLOAT_WORDS_BIG_ENDIAN)
289 *((uint32_t *) &d128.bytes[0]) = (uint32_t) buf[0];
290 *((uint32_t *) &d128.bytes[4]) = (uint32_t) buf[1];
291 *((uint32_t *) &d128.bytes[8]) = (uint32_t) buf[2];
292 *((uint32_t *) &d128.bytes[12]) = (uint32_t) buf[3];
296 *((uint32_t *) &d128.bytes[0]) = dfp_byte_swap ((uint32_t) buf[3]);
297 *((uint32_t *) &d128.bytes[4]) = dfp_byte_swap ((uint32_t) buf[2]);
298 *((uint32_t *) &d128.bytes[8]) = dfp_byte_swap ((uint32_t) buf[1]);
299 *((uint32_t *) &d128.bytes[12]) = dfp_byte_swap ((uint32_t) buf[0]);
302 decimal128ToNumber (&d128, &dn);
303 decimal_from_decnumber (r, &dn, &set);
306 /* Helper function to convert from a binary real internal
310 decimal_to_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from,
311 enum machine_mode mode)
314 const decimal128 *const d128 = (const decimal128 *) from->sig;
316 decimal128ToString (d128, string);
317 real_from_string3 (to, string, mode);
321 /* Helper function to convert from a binary real internal
325 decimal_from_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from)
329 /* We convert to string, then to decNumber then to decimal128. */
330 real_to_decimal (string, from, sizeof (string), 0, 1);
331 decimal_real_from_string (to, string);
334 /* Helper function to real.c:do_compare() to handle decimal internal
335 representation including when one of the operands is still in the
336 binary internal representation. */
339 decimal_do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
343 decNumber dn, dn2, dn3;
344 REAL_VALUE_TYPE a1, b1;
346 /* If either operand is non-decimal, create temporary versions. */
349 decimal_from_binary (&a1, a);
354 decimal_from_binary (&b1, b);
358 /* Convert into decNumber form for comparison operation. */
359 decContextDefault (&set, DEC_INIT_DECIMAL128);
361 decimal128ToNumber ((const decimal128 *) a->sig, &dn2);
362 decimal128ToNumber ((const decimal128 *) b->sig, &dn3);
364 /* Finally, do the comparison. */
365 decNumberCompare (&dn, &dn2, &dn3, &set);
367 /* Return the comparison result. */
368 if (decNumberIsNaN (&dn))
370 else if (decNumberIsZero (&dn))
372 else if (decNumberIsNegative (&dn))
378 /* Helper to round_for_format, handling decimal float types. */
381 decimal_round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
386 /* Real encoding occurs later. */
387 if (r->cl != rvc_normal)
390 decContextDefault (&set, DEC_INIT_DECIMAL128);
392 decimal128ToNumber ((decimal128 *) r->sig, &dn);
394 if (fmt == &decimal_quad_format)
396 /* The internal format is already in this format. */
399 else if (fmt == &decimal_single_format)
402 decContextDefault (&set, DEC_INIT_DECIMAL32);
405 decimal32FromNumber (&d32, &dn, &set);
406 decimal32ToNumber (&d32, &dn);
408 else if (fmt == &decimal_double_format)
411 decContextDefault (&set, DEC_INIT_DECIMAL64);
414 decimal64FromNumber (&d64, &dn, &set);
415 decimal64ToNumber (&d64, &dn);
420 decimal_from_decnumber (r, &dn, &set);
423 /* Extend or truncate to a new mode. Handles conversions between
424 binary and decimal types. */
427 decimal_real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
428 const REAL_VALUE_TYPE *a)
430 const struct real_format *fmt = REAL_MODE_FORMAT (mode);
432 if (a->decimal && fmt->b == 10)
435 decimal_to_binary (r, a, mode);
437 decimal_from_binary (r, a);
440 /* Render R_ORIG as a decimal floating point constant. Emit DIGITS
441 significant digits in the result, bounded by BUF_SIZE. If DIGITS
442 is 0, choose the maximum for the representation. If
443 CROP_TRAILING_ZEROS, strip trailing zeros. Currently, not honoring
444 DIGITS or CROP_TRAILING_ZEROS. */
447 decimal_real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig,
449 size_t digits ATTRIBUTE_UNUSED,
450 int crop_trailing_zeros ATTRIBUTE_UNUSED)
452 const decimal128 *const d128 = (const decimal128*) r_orig->sig;
454 /* decimal128ToString requires space for at least 24 characters;
455 Require two more for suffix. */
456 gcc_assert (buf_size >= 24);
457 decimal128ToString (d128, str);
461 decimal_do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
462 const REAL_VALUE_TYPE *op1, int subtract_p)
468 decimal_to_decnumber (op0, &dn2);
469 decimal_to_decnumber (op1, &dn3);
471 decContextDefault (&set, DEC_INIT_DECIMAL128);
475 decNumberSubtract (&dn, &dn2, &dn3, &set);
477 decNumberAdd (&dn, &dn2, &dn3, &set);
479 decimal_from_decnumber (r, &dn, &set);
481 /* Return true, if inexact. */
482 return (set.status & DEC_Inexact);
485 /* Compute R = OP0 * OP1. */
488 decimal_do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
489 const REAL_VALUE_TYPE *op1)
492 decNumber dn, dn2, dn3;
494 decimal_to_decnumber (op0, &dn2);
495 decimal_to_decnumber (op1, &dn3);
497 decContextDefault (&set, DEC_INIT_DECIMAL128);
500 decNumberMultiply (&dn, &dn2, &dn3, &set);
501 decimal_from_decnumber (r, &dn, &set);
503 /* Return true, if inexact. */
504 return (set.status & DEC_Inexact);
507 /* Compute R = OP0 / OP1. */
510 decimal_do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
511 const REAL_VALUE_TYPE *op1)
514 decNumber dn, dn2, dn3;
516 decimal_to_decnumber (op0, &dn2);
517 decimal_to_decnumber (op1, &dn3);
519 decContextDefault (&set, DEC_INIT_DECIMAL128);
522 decNumberDivide (&dn, &dn2, &dn3, &set);
523 decimal_from_decnumber (r, &dn, &set);
525 /* Return true, if inexact. */
526 return (set.status & DEC_Inexact);
529 /* Set R to A truncated to an integral value toward zero (decimal
533 decimal_do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
538 decContextDefault (&set, DEC_INIT_DECIMAL128);
540 set.round = DEC_ROUND_DOWN;
541 decimal128ToNumber ((const decimal128 *) a->sig, &dn2);
543 decNumberToIntegralValue (&dn, &dn2, &set);
544 decimal_from_decnumber (r, &dn, &set);
547 /* Render decimal float value R as an integer. */
550 decimal_real_to_integer (const REAL_VALUE_TYPE *r)
553 decNumber dn, dn2, dn3;
557 decContextDefault (&set, DEC_INIT_DECIMAL128);
559 set.round = DEC_ROUND_DOWN;
560 decimal128ToNumber ((const decimal128 *) r->sig, &dn);
562 decNumberToIntegralValue (&dn2, &dn, &set);
563 decNumberZero (&dn3);
564 decNumberRescale (&dn, &dn2, &dn3, &set);
566 /* Convert to REAL_VALUE_TYPE and call appropriate conversion
568 decNumberToString (&dn, string);
569 real_from_string (&to, string);
570 return real_to_integer (&to);
573 /* Likewise, but to an integer pair, HI+LOW. */
576 decimal_real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
577 const REAL_VALUE_TYPE *r)
580 decNumber dn, dn2, dn3;
584 decContextDefault (&set, DEC_INIT_DECIMAL128);
586 set.round = DEC_ROUND_DOWN;
587 decimal128ToNumber ((const decimal128 *) r->sig, &dn);
589 decNumberToIntegralValue (&dn2, &dn, &set);
590 decNumberZero (&dn3);
591 decNumberRescale (&dn, &dn2, &dn3, &set);
593 /* Conver to REAL_VALUE_TYPE and call appropriate conversion
595 decNumberToString (&dn, string);
596 real_from_string (&to, string);
597 real_to_integer2 (plow, phigh, &to);
600 /* Perform the decimal floating point operation described by CODE.
601 For a unary operation, OP1 will be NULL. This function returns
602 true if the result may be inexact due to loss of precision. */
605 decimal_real_arithmetic (REAL_VALUE_TYPE *r, enum tree_code code,
606 const REAL_VALUE_TYPE *op0,
607 const REAL_VALUE_TYPE *op1)
609 REAL_VALUE_TYPE a, b;
611 /* If either operand is non-decimal, create temporaries. */
614 decimal_from_binary (&a, op0);
617 if (op1 && !op1->decimal)
619 decimal_from_binary (&b, op1);
626 return decimal_do_add (r, op0, op1, 0);
629 return decimal_do_add (r, op0, op1, 1);
632 return decimal_do_multiply (r, op0, op1);
635 return decimal_do_divide (r, op0, op1);
638 if (op1->cl == rvc_nan)
640 else if (real_compare (UNLT_EXPR, op0, op1))
647 if (op1->cl == rvc_nan)
649 else if (real_compare (LT_EXPR, op0, op1))
659 decimal128FlipSign ((decimal128 *) r->sig);
660 /* Keep sign field in sync. */
668 /* Clear sign bit. */
669 decimal128ClearSign ((decimal128 *) r->sig);
670 /* Keep sign field in sync. */
676 decimal_do_fix_trunc (r, op0);
684 /* Fills R with the largest finite value representable in mode MODE.
685 If SIGN is nonzero, R is set to the most negative finite value. */
688 decimal_real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
698 max = "9.999999999999999E384";
701 max = "9.999999999999999999999999999999999E6144";
707 decimal_real_from_string (r, max);
709 decimal128SetSign ((decimal128 *) r->sig, 1);