URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [dfp.c] - Rev 847
Go to most recent revision | Compare with Previous | Blame | View Log
/* Decimal floating point support. Copyright (C) 2005, 2006, 2007 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 3, 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 COPYING3. If not see <http://www.gnu.org/licenses/>. */ #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; }
Go to most recent revision | Compare with Previous | Blame | View Log