aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.2.1-5666.3/gcc/dfp.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.2.1-5666.3/gcc/dfp.c')
-rw-r--r--gcc-4.2.1-5666.3/gcc/dfp.c716
1 files changed, 716 insertions, 0 deletions
diff --git a/gcc-4.2.1-5666.3/gcc/dfp.c b/gcc-4.2.1-5666.3/gcc/dfp.c
new file mode 100644
index 000000000..b388f9343
--- /dev/null
+++ b/gcc-4.2.1-5666.3/gcc/dfp.c
@@ -0,0 +1,716 @@
+/* Decimal floating point support.
+ Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING. If not, write to the Free
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "tree.h"
+#include "toplev.h"
+#include "real.h"
+#include "tm_p.h"
+#include "dfp.h"
+
+/* The order of the following headers is important for making sure
+ decNumber structure is large enough to hold decimal128 digits. */
+
+#include "decimal128.h"
+#include "decimal64.h"
+#include "decimal32.h"
+#include "decNumber.h"
+
+static uint32_t
+dfp_byte_swap (uint32_t in)
+{
+ uint32_t out = 0;
+ unsigned char *p = (unsigned char *) &out;
+ union {
+ uint32_t i;
+ unsigned char b[4];
+ } u;
+
+ u.i = in;
+ p[0] = u.b[3];
+ p[1] = u.b[2];
+ p[2] = u.b[1];
+ p[3] = u.b[0];
+
+ return out;
+}
+
+/* Initialize R (a real with the decimal flag set) from DN. Can
+ utilize status passed in via CONTEXT, if a previous operation had
+ interesting status. */
+
+static void
+decimal_from_decnumber (REAL_VALUE_TYPE *r, decNumber *dn, decContext *context)
+{
+ memset (r, 0, sizeof (REAL_VALUE_TYPE));
+
+ r->cl = rvc_normal;
+ if (decNumberIsZero (dn))
+ r->cl = rvc_zero;
+ if (decNumberIsNaN (dn))
+ r->cl = rvc_nan;
+ if (decNumberIsInfinite (dn))
+ r->cl = rvc_inf;
+ if (context->status & DEC_Overflow)
+ r->cl = rvc_inf;
+ if (decNumberIsNegative (dn))
+ r->sign = 1;
+ r->decimal = 1;
+
+ if (r->cl != rvc_normal)
+ return;
+
+ decContextDefault (context, DEC_INIT_DECIMAL128);
+ context->traps = 0;
+
+ decimal128FromNumber ((decimal128 *) r->sig, dn, context);
+}
+
+/* Create decimal encoded R from string S. */
+
+void
+decimal_real_from_string (REAL_VALUE_TYPE *r, const char *s)
+{
+ decNumber dn;
+ decContext set;
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ decNumberFromString (&dn, (char *) s, &set);
+
+ /* It would be more efficient to store directly in decNumber format,
+ but that is impractical from current data structure size.
+ Encoding as a decimal128 is much more compact. */
+ decimal_from_decnumber (r, &dn, &set);
+}
+
+/* Initialize a decNumber from a REAL_VALUE_TYPE. */
+
+static void
+decimal_to_decnumber (const REAL_VALUE_TYPE *r, decNumber *dn)
+{
+ decContext set;
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ switch (r->cl)
+ {
+ case rvc_zero:
+ decNumberZero (dn);
+ break;
+ case rvc_inf:
+ decNumberFromString (dn, (char *)"Infinity", &set);
+ break;
+ case rvc_nan:
+ if (r->signalling)
+ decNumberFromString (dn, (char *)"snan", &set);
+ else
+ decNumberFromString (dn, (char *)"nan", &set);
+ break;
+ case rvc_normal:
+ gcc_assert (r->decimal);
+ decimal128ToNumber ((decimal128 *) r->sig, dn);
+ break;
+ default:
+ gcc_unreachable ();
+ }
+
+ /* Fix up sign bit. */
+ if (r->sign != decNumberIsNegative (dn))
+ dn->bits ^= DECNEG;
+}
+
+/* Encode a real into an IEEE 754R decimal32 type. */
+
+void
+encode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
+ long *buf, const REAL_VALUE_TYPE *r)
+{
+ decNumber dn;
+ decimal32 d32;
+ decContext set;
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ decimal_to_decnumber (r, &dn);
+ decimal32FromNumber (&d32, &dn, &set);
+
+ if (FLOAT_WORDS_BIG_ENDIAN)
+ buf[0] = *(uint32_t *) d32.bytes;
+ else
+ buf[0] = dfp_byte_swap (*(uint32_t *) d32.bytes);
+}
+
+/* Decode an IEEE 754R decimal32 type into a real. */
+
+void
+decode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
+ REAL_VALUE_TYPE *r, const long *buf)
+{
+ decNumber dn;
+ decimal32 d32;
+ decContext set;
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ if (FLOAT_WORDS_BIG_ENDIAN)
+ *((uint32_t *) d32.bytes) = (uint32_t) buf[0];
+ else
+ *((uint32_t *) d32.bytes) = dfp_byte_swap ((uint32_t) buf[0]);
+
+ decimal32ToNumber (&d32, &dn);
+ decimal_from_decnumber (r, &dn, &set);
+}
+
+/* Encode a real into an IEEE 754R decimal64 type. */
+
+void
+encode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
+ long *buf, const REAL_VALUE_TYPE *r)
+{
+ decNumber dn;
+ decimal64 d64;
+ decContext set;
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ decimal_to_decnumber (r, &dn);
+ decimal64FromNumber (&d64, &dn, &set);
+
+ if (FLOAT_WORDS_BIG_ENDIAN)
+ {
+ buf[0] = *(uint32_t *) &d64.bytes[0];
+ buf[1] = *(uint32_t *) &d64.bytes[4];
+ }
+ else
+ {
+ buf[1] = dfp_byte_swap (*(uint32_t *) &d64.bytes[0]);
+ buf[0] = dfp_byte_swap (*(uint32_t *) &d64.bytes[4]);
+ }
+}
+
+/* Decode an IEEE 754R decimal64 type into a real. */
+
+void
+decode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
+ REAL_VALUE_TYPE *r, const long *buf)
+{
+ decNumber dn;
+ decimal64 d64;
+ decContext set;
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ if (FLOAT_WORDS_BIG_ENDIAN)
+ {
+ *((uint32_t *) &d64.bytes[0]) = (uint32_t) buf[0];
+ *((uint32_t *) &d64.bytes[4]) = (uint32_t) buf[1];
+ }
+ else
+ {
+ *((uint32_t *) &d64.bytes[0]) = dfp_byte_swap ((uint32_t) buf[1]);
+ *((uint32_t *) &d64.bytes[4]) = dfp_byte_swap ((uint32_t) buf[0]);
+ }
+
+ decimal64ToNumber (&d64, &dn);
+ decimal_from_decnumber (r, &dn, &set);
+}
+
+/* Encode a real into an IEEE 754R decimal128 type. */
+
+void
+encode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
+ long *buf, const REAL_VALUE_TYPE *r)
+{
+ decNumber dn;
+ decContext set;
+ decimal128 d128;
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ decimal_to_decnumber (r, &dn);
+ decimal128FromNumber (&d128, &dn, &set);
+
+ if (FLOAT_WORDS_BIG_ENDIAN)
+ {
+ buf[0] = *(uint32_t *) &d128.bytes[0];
+ buf[1] = *(uint32_t *) &d128.bytes[4];
+ buf[2] = *(uint32_t *) &d128.bytes[8];
+ buf[3] = *(uint32_t *) &d128.bytes[12];
+ }
+ else
+ {
+ buf[0] = dfp_byte_swap (*(uint32_t *) &d128.bytes[12]);
+ buf[1] = dfp_byte_swap (*(uint32_t *) &d128.bytes[8]);
+ buf[2] = dfp_byte_swap (*(uint32_t *) &d128.bytes[4]);
+ buf[3] = dfp_byte_swap (*(uint32_t *) &d128.bytes[0]);
+ }
+}
+
+/* Decode an IEEE 754R decimal128 type into a real. */
+
+void
+decode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
+ REAL_VALUE_TYPE *r, const long *buf)
+{
+ decNumber dn;
+ decimal128 d128;
+ decContext set;
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ if (FLOAT_WORDS_BIG_ENDIAN)
+ {
+ *((uint32_t *) &d128.bytes[0]) = (uint32_t) buf[0];
+ *((uint32_t *) &d128.bytes[4]) = (uint32_t) buf[1];
+ *((uint32_t *) &d128.bytes[8]) = (uint32_t) buf[2];
+ *((uint32_t *) &d128.bytes[12]) = (uint32_t) buf[3];
+ }
+ else
+ {
+ *((uint32_t *) &d128.bytes[0]) = dfp_byte_swap ((uint32_t) buf[3]);
+ *((uint32_t *) &d128.bytes[4]) = dfp_byte_swap ((uint32_t) buf[2]);
+ *((uint32_t *) &d128.bytes[8]) = dfp_byte_swap ((uint32_t) buf[1]);
+ *((uint32_t *) &d128.bytes[12]) = dfp_byte_swap ((uint32_t) buf[0]);
+ }
+
+ decimal128ToNumber (&d128, &dn);
+ decimal_from_decnumber (r, &dn, &set);
+}
+
+/* Helper function to convert from a binary real internal
+ representation. */
+
+static void
+decimal_to_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from,
+ enum machine_mode mode)
+{
+ char string[256];
+ decimal128 *d128;
+ d128 = (decimal128 *) from->sig;
+
+ decimal128ToString (d128, string);
+ real_from_string3 (to, string, mode);
+}
+
+
+/* Helper function to convert from a binary real internal
+ representation. */
+
+static void
+decimal_from_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from)
+{
+ char string[256];
+
+ /* We convert to string, then to decNumber then to decimal128. */
+ real_to_decimal (string, from, sizeof (string), 0, 1);
+ decimal_real_from_string (to, string);
+}
+
+/* Helper function to real.c:do_compare() to handle decimal internal
+ representation including when one of the operands is still in the
+ binary internal representation. */
+
+int
+decimal_do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
+ int nan_result)
+{
+ decContext set;
+ decNumber dn, dn2, dn3;
+ REAL_VALUE_TYPE a1, b1;
+
+ /* If either operand is non-decimal, create temporary versions. */
+ if (!a->decimal)
+ {
+ decimal_from_binary (&a1, a);
+ a = &a1;
+ }
+ if (!b->decimal)
+ {
+ decimal_from_binary (&b1, b);
+ b = &b1;
+ }
+
+ /* Convert into decNumber form for comparison operation. */
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+ decimal128ToNumber ((decimal128 *) a->sig, &dn2);
+ decimal128ToNumber ((decimal128 *) b->sig, &dn3);
+
+ /* Finally, do the comparison. */
+ decNumberCompare (&dn, &dn2, &dn3, &set);
+
+ /* Return the comparison result. */
+ if (decNumberIsNaN (&dn))
+ return nan_result;
+ else if (decNumberIsZero (&dn))
+ return 0;
+ else if (decNumberIsNegative (&dn))
+ return -1;
+ else
+ return 1;
+}
+
+/* Helper to round_for_format, handling decimal float types. */
+
+void
+decimal_round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
+{
+ decNumber dn;
+ decContext set;
+
+ /* Real encoding occurs later. */
+ if (r->cl != rvc_normal)
+ return;
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+ decimal128ToNumber ((decimal128 *) r->sig, &dn);
+
+ if (fmt == &decimal_quad_format)
+ {
+ /* The internal format is already in this format. */
+ return;
+ }
+ else if (fmt == &decimal_single_format)
+ {
+ decimal32 d32;
+ decContextDefault (&set, DEC_INIT_DECIMAL32);
+ set.traps = 0;
+
+ decimal32FromNumber (&d32, &dn, &set);
+ decimal32ToNumber (&d32, &dn);
+ }
+ else if (fmt == &decimal_double_format)
+ {
+ decimal64 d64;
+ decContextDefault (&set, DEC_INIT_DECIMAL64);
+ set.traps = 0;
+
+ decimal64FromNumber (&d64, &dn, &set);
+ decimal64ToNumber (&d64, &dn);
+ }
+ else
+ gcc_unreachable ();
+
+ decimal_from_decnumber (r, &dn, &set);
+}
+
+/* Extend or truncate to a new mode. Handles conversions between
+ binary and decimal types. */
+
+void
+decimal_real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
+ const REAL_VALUE_TYPE *a)
+{
+ const struct real_format *fmt = REAL_MODE_FORMAT (mode);
+
+ if (a->decimal && fmt->b == 10)
+ return;
+ if (a->decimal)
+ decimal_to_binary (r, a, mode);
+ else
+ decimal_from_binary (r, a);
+}
+
+/* Render R_ORIG as a decimal floating point constant. Emit DIGITS
+ significant digits in the result, bounded by BUF_SIZE. If DIGITS
+ is 0, choose the maximum for the representation. If
+ CROP_TRAILING_ZEROS, strip trailing zeros. Currently, not honoring
+ DIGITS or CROP_TRAILING_ZEROS. */
+
+void
+decimal_real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig,
+ size_t buf_size,
+ size_t digits ATTRIBUTE_UNUSED,
+ int crop_trailing_zeros ATTRIBUTE_UNUSED)
+{
+ decimal128 *d128 = (decimal128*) r_orig->sig;
+
+ /* decimal128ToString requires space for at least 24 characters;
+ Require two more for suffix. */
+ gcc_assert (buf_size >= 24);
+ decimal128ToString (d128, str);
+}
+
+static bool
+decimal_do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
+ const REAL_VALUE_TYPE *op1, int subtract_p)
+{
+ decNumber dn;
+ decContext set;
+ decNumber dn2, dn3;
+
+ decimal_to_decnumber (op0, &dn2);
+ decimal_to_decnumber (op1, &dn3);
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ if (subtract_p)
+ decNumberSubtract (&dn, &dn2, &dn3, &set);
+ else
+ decNumberAdd (&dn, &dn2, &dn3, &set);
+
+ decimal_from_decnumber (r, &dn, &set);
+
+ /* Return true, if inexact. */
+ return (set.status & DEC_Inexact);
+}
+
+/* Compute R = OP0 * OP1. */
+
+static bool
+decimal_do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
+ const REAL_VALUE_TYPE *op1)
+{
+ decContext set;
+ decNumber dn, dn2, dn3;
+
+ decimal_to_decnumber (op0, &dn2);
+ decimal_to_decnumber (op1, &dn3);
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ decNumberMultiply (&dn, &dn2, &dn3, &set);
+ decimal_from_decnumber (r, &dn, &set);
+
+ /* Return true, if inexact. */
+ return (set.status & DEC_Inexact);
+}
+
+/* Compute R = OP0 / OP1. */
+
+static bool
+decimal_do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
+ const REAL_VALUE_TYPE *op1)
+{
+ decContext set;
+ decNumber dn, dn2, dn3;
+
+ decimal_to_decnumber (op0, &dn2);
+ decimal_to_decnumber (op1, &dn3);
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+
+ decNumberDivide (&dn, &dn2, &dn3, &set);
+ decimal_from_decnumber (r, &dn, &set);
+
+ /* Return true, if inexact. */
+ return (set.status & DEC_Inexact);
+}
+
+/* Set R to A truncated to an integral value toward zero (decimal
+ floating point). */
+
+void
+decimal_do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
+{
+ decNumber dn, dn2;
+ decContext set;
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+ set.round = DEC_ROUND_DOWN;
+ decimal128ToNumber ((decimal128 *) a->sig, &dn2);
+
+ decNumberToIntegralValue (&dn, &dn2, &set);
+ decimal_from_decnumber (r, &dn, &set);
+}
+
+/* Render decimal float value R as an integer. */
+
+HOST_WIDE_INT
+decimal_real_to_integer (const REAL_VALUE_TYPE *r)
+{
+ decContext set;
+ decNumber dn, dn2, dn3;
+ REAL_VALUE_TYPE to;
+ char string[256];
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+ set.round = DEC_ROUND_DOWN;
+ decimal128ToNumber ((decimal128 *) r->sig, &dn);
+
+ decNumberToIntegralValue (&dn2, &dn, &set);
+ decNumberZero (&dn3);
+ decNumberRescale (&dn, &dn2, &dn3, &set);
+
+ /* Convert to REAL_VALUE_TYPE and call appropriate conversion
+ function. */
+ decNumberToString (&dn, string);
+ real_from_string (&to, string);
+ return real_to_integer (&to);
+}
+
+/* Likewise, but to an integer pair, HI+LOW. */
+
+void
+decimal_real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
+ const REAL_VALUE_TYPE *r)
+{
+ decContext set;
+ decNumber dn, dn2, dn3;
+ REAL_VALUE_TYPE to;
+ char string[256];
+
+ decContextDefault (&set, DEC_INIT_DECIMAL128);
+ set.traps = 0;
+ set.round = DEC_ROUND_DOWN;
+ decimal128ToNumber ((decimal128 *) r->sig, &dn);
+
+ decNumberToIntegralValue (&dn2, &dn, &set);
+ decNumberZero (&dn3);
+ decNumberRescale (&dn, &dn2, &dn3, &set);
+
+ /* Conver to REAL_VALUE_TYPE and call appropriate conversion
+ function. */
+ decNumberToString (&dn, string);
+ real_from_string (&to, string);
+ real_to_integer2 (plow, phigh, &to);
+}
+
+/* Perform the decimal floating point operation described by CODE.
+ For a unary operation, OP1 will be NULL. This function returns
+ true if the result may be inexact due to loss of precision. */
+
+bool
+decimal_real_arithmetic (REAL_VALUE_TYPE *r, enum tree_code code,
+ const REAL_VALUE_TYPE *op0,
+ const REAL_VALUE_TYPE *op1)
+{
+ REAL_VALUE_TYPE a, b;
+
+ /* If either operand is non-decimal, create temporaries. */
+ if (!op0->decimal)
+ {
+ decimal_from_binary (&a, op0);
+ op0 = &a;
+ }
+ if (op1 && !op1->decimal)
+ {
+ decimal_from_binary (&b, op1);
+ op1 = &b;
+ }
+
+ switch (code)
+ {
+ case PLUS_EXPR:
+ return decimal_do_add (r, op0, op1, 0);
+
+ case MINUS_EXPR:
+ return decimal_do_add (r, op0, op1, 1);
+
+ case MULT_EXPR:
+ return decimal_do_multiply (r, op0, op1);
+
+ case RDIV_EXPR:
+ return decimal_do_divide (r, op0, op1);
+
+ case MIN_EXPR:
+ if (op1->cl == rvc_nan)
+ *r = *op1;
+ else if (real_compare (UNLT_EXPR, op0, op1))
+ *r = *op0;
+ else
+ *r = *op1;
+ return false;
+
+ case MAX_EXPR:
+ if (op1->cl == rvc_nan)
+ *r = *op1;
+ else if (real_compare (LT_EXPR, op0, op1))
+ *r = *op1;
+ else
+ *r = *op0;
+ return false;
+
+ case NEGATE_EXPR:
+ {
+ decimal128 *d128;
+ *r = *op0;
+ d128 = (decimal128 *) r->sig;
+ /* Flip high bit. */
+ d128->bytes[0] ^= 1 << 7;
+ /* Keep sign field in sync. */
+ r->sign ^= 1;
+ }
+ return false;
+
+ case ABS_EXPR:
+ {
+ decimal128 *d128;
+ *r = *op0;
+ d128 = (decimal128 *) r->sig;
+ /* Clear high bit. */
+ d128->bytes[0] &= 0x7f;
+ /* Keep sign field in sync. */
+ r->sign = 0;
+ }
+ return false;
+
+ case FIX_TRUNC_EXPR:
+ decimal_do_fix_trunc (r, op0);
+ return false;
+
+ default:
+ gcc_unreachable ();
+ }
+}
+
+/* Fills R with the largest finite value representable in mode MODE.
+ If SIGN is nonzero, R is set to the most negative finite value. */
+
+void
+decimal_real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
+{
+ char *max;
+
+ switch (mode)
+ {
+ case SDmode:
+ max = (char *) "9.999999E96";
+ break;
+ case DDmode:
+ max = (char *) "9.999999999999999E384";
+ break;
+ case TDmode:
+ max = (char *) "9.999999999999999999999999999999999E6144";
+ break;
+ default:
+ gcc_unreachable ();
+ }
+
+ decimal_real_from_string (r, max);
+ if (sign)
+ r->sig[0] |= 0x80000000;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-18 23:25:57 +0000