/* real.c - software floating point emulation.
- Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 1993-2020 Free Software Foundation, Inc.
Contributed by Stephen L. Moshier (moshier@world.std.com).
Re-written by Richard Henderson <rth@redhat.com>
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
+ 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
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. */
+ 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 "rtl.h"
#include "tree.h"
-#include "toplev.h"
-#include "real.h"
-#include "tm_p.h"
+#include "realmpfr.h"
#include "dfp.h"
/* The floating point model used internally is not exactly IEEE 754
Both of these requirements are easily satisfied. The largest target
significand is 113 bits; we store at least 160. The smallest
- denormal number fits in 17 exponent bits; we store 27.
-
- Note that the decimal string conversion routines are sensitive to
- rounding errors. Since the raw arithmetic routines do not themselves
- have guard digits or rounding, the computation of 10**exp can
- accumulate more than a few digits of error. The previous incarnation
- of real.c successfully used a 144-bit fraction; given the current
- layout of REAL_VALUE_TYPE we're forced to expand to at least 160 bits.
-
- Target floating point models that use base 16 instead of base 2
- (i.e. IBM 370), are handled during round_for_format, in which we
- canonicalize the exponent to be a multiple of 4 (log2(16)), and
- adjust the significand to match. */
+ denormal number fits in 17 exponent bits; we store 26. */
/* Used to classify two numbers simultaneously. */
static void do_fix_trunc (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
static unsigned long rtd_divmod (REAL_VALUE_TYPE *, REAL_VALUE_TYPE *);
+static void decimal_from_integer (REAL_VALUE_TYPE *);
+static void decimal_integer_string (char *, const REAL_VALUE_TYPE *,
+ size_t);
static const REAL_VALUE_TYPE * ten_to_ptwo (int);
static const REAL_VALUE_TYPE * ten_to_mptwo (int);
case CLASS2 (rvc_normal, rvc_inf):
/* R + Inf = Inf. */
*r = *b;
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ r->signalling = 0;
r->sign = sign ^ subtract_p;
return false;
case CLASS2 (rvc_inf, rvc_normal):
/* Inf + R = Inf. */
*r = *a;
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ r->signalling = 0;
return false;
case CLASS2 (rvc_inf, rvc_inf):
case CLASS2 (rvc_nan, rvc_nan):
/* ANY * NaN = NaN. */
*r = *b;
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ r->signalling = 0;
r->sign = sign;
return false;
case CLASS2 (rvc_nan, rvc_inf):
/* NaN * ANY = NaN. */
*r = *a;
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ r->signalling = 0;
r->sign = sign;
return false;
case CLASS2 (rvc_nan, rvc_nan):
/* ANY / NaN = NaN. */
*r = *b;
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ r->signalling = 0;
r->sign = sign;
return false;
case CLASS2 (rvc_nan, rvc_inf):
/* NaN / ANY = NaN. */
*r = *a;
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ r->signalling = 0;
r->sign = sign;
return false;
/* Sign of zero doesn't matter for compares. */
return 0;
+ case CLASS2 (rvc_normal, rvc_zero):
+ /* Decimal float zero is special and uses rvc_normal, not rvc_zero. */
+ if (a->decimal)
+ return decimal_do_compare (a, b, nan_result);
+ /* Fall through. */
case CLASS2 (rvc_inf, rvc_zero):
case CLASS2 (rvc_inf, rvc_normal):
- case CLASS2 (rvc_normal, rvc_zero):
return (a->sign ? -1 : 1);
case CLASS2 (rvc_inf, rvc_inf):
return -a->sign - -b->sign;
case CLASS2 (rvc_zero, rvc_normal):
+ /* Decimal float zero is special and uses rvc_normal, not rvc_zero. */
+ if (b->decimal)
+ return decimal_do_compare (a, b, nan_result);
+ /* Fall through. */
case CLASS2 (rvc_zero, rvc_inf):
case CLASS2 (rvc_normal, rvc_inf):
return (b->sign ? 1 : -1);
gcc_unreachable ();
}
- if (a->sign != b->sign)
- return -a->sign - -b->sign;
-
if (a->decimal || b->decimal)
return decimal_do_compare (a, b, nan_result);
+ if (a->sign != b->sign)
+ return -a->sign - -b->sign;
+
if (REAL_EXP (a) > REAL_EXP (b))
ret = 1;
else if (REAL_EXP (a) < REAL_EXP (b))
case rvc_zero:
case rvc_inf:
case rvc_nan:
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ r->signalling = 0;
break;
case rvc_normal:
real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
const REAL_VALUE_TYPE *op1)
{
- enum tree_code code = icode;
+ enum tree_code code = (enum tree_code) icode;
if (op0->decimal || (op1 && op1->decimal))
- return decimal_real_arithmetic (r, icode, op0, op1);
+ return decimal_real_arithmetic (r, code, op0, op1);
switch (code)
{
case PLUS_EXPR:
+ /* Clear any padding areas in *r if it isn't equal to one of the
+ operands so that we can later do bitwise comparisons later on. */
+ if (r != op0 && r != op1)
+ memset (r, '\0', sizeof (*r));
return do_add (r, op0, op1, 0);
case MINUS_EXPR:
+ if (r != op0 && r != op1)
+ memset (r, '\0', sizeof (*r));
return do_add (r, op0, op1, 1);
case MULT_EXPR:
+ if (r != op0 && r != op1)
+ memset (r, '\0', sizeof (*r));
return do_multiply (r, op0, op1);
case RDIV_EXPR:
+ if (r != op0 && r != op1)
+ memset (r, '\0', sizeof (*r));
return do_divide (r, op0, op1);
case MIN_EXPR:
if (op1->cl == rvc_nan)
+ {
*r = *op1;
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ r->signalling = 0;
+ }
else if (do_compare (op0, op1, -1) < 0)
*r = *op0;
else
case MAX_EXPR:
if (op1->cl == rvc_nan)
+ {
*r = *op1;
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ r->signalling = 0;
+ }
else if (do_compare (op0, op1, 1) < 0)
*r = *op1;
else
return false;
}
-/* Legacy. Similar, but return the result directly. */
+REAL_VALUE_TYPE
+real_value_negate (const REAL_VALUE_TYPE *op0)
+{
+ REAL_VALUE_TYPE r;
+ real_arithmetic (&r, NEGATE_EXPR, op0, NULL);
+ return r;
+}
REAL_VALUE_TYPE
-real_arithmetic2 (int icode, const REAL_VALUE_TYPE *op0,
- const REAL_VALUE_TYPE *op1)
+real_value_abs (const REAL_VALUE_TYPE *op0)
{
REAL_VALUE_TYPE r;
- real_arithmetic (&r, icode, op0, op1);
+ real_arithmetic (&r, ABS_EXPR, op0, NULL);
return r;
}
+/* Return whether OP0 == OP1. */
+
+bool
+real_equal (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1)
+{
+ return do_compare (op0, op1, -1) == 0;
+}
+
+/* Return whether OP0 < OP1. */
+
+bool
+real_less (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1)
+{
+ return do_compare (op0, op1, 1) < 0;
+}
+
bool
real_compare (int icode, const REAL_VALUE_TYPE *op0,
const REAL_VALUE_TYPE *op1)
{
- enum tree_code code = icode;
+ enum tree_code code = (enum tree_code) icode;
switch (code)
{
case LT_EXPR:
- return do_compare (op0, op1, 1) < 0;
+ return real_less (op0, op1);
case LE_EXPR:
return do_compare (op0, op1, 1) <= 0;
case GT_EXPR:
case GE_EXPR:
return do_compare (op0, op1, -1) >= 0;
case EQ_EXPR:
- return do_compare (op0, op1, -1) == 0;
+ return real_equal (op0, op1);
case NE_EXPR:
return do_compare (op0, op1, -1) != 0;
case UNORDERED_EXPR:
case rvc_zero:
case rvc_inf:
case rvc_nan:
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ r->signalling = 0;
break;
case rvc_normal:
return (r->cl == rvc_nan);
}
+/* Determine whether a floating-point value X is a signaling NaN. */
+bool real_issignaling_nan (const REAL_VALUE_TYPE *r)
+{
+ return real_isnan (r) && r->signalling;
+}
+
+/* Determine whether a floating-point value X is finite. */
+
+bool
+real_isfinite (const REAL_VALUE_TYPE *r)
+{
+ return (r->cl != rvc_nan) && (r->cl != rvc_inf);
+}
+
/* Determine whether a floating-point value X is negative. */
bool
return true;
}
-/* Try to change R into its exact multiplicative inverse in machine
- mode MODE. Return true if successful. */
+/* Try to change R into its exact multiplicative inverse in format FMT.
+ Return true if successful. */
bool
-exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
+exact_real_inverse (format_helper fmt, REAL_VALUE_TYPE *r)
{
const REAL_VALUE_TYPE *one = real_digit (1);
REAL_VALUE_TYPE u;
if (r->sig[SIGSZ-1] != SIG_MSB)
return false;
- /* Find the inverse and truncate to the required mode. */
+ /* Find the inverse and truncate to the required format. */
do_divide (&u, one, r);
- real_convert (&u, mode, &u);
+ real_convert (&u, fmt, &u);
/* The rounding may have overflowed. */
if (u.cl != rvc_normal)
*r = u;
return true;
}
+
+/* Return true if arithmetic on values in IMODE that were promoted
+ from values in TMODE is equivalent to direct arithmetic on values
+ in TMODE. */
+
+bool
+real_can_shorten_arithmetic (machine_mode imode, machine_mode tmode)
+{
+ const struct real_format *tfmt, *ifmt;
+ tfmt = REAL_MODE_FORMAT (tmode);
+ ifmt = REAL_MODE_FORMAT (imode);
+ /* These conditions are conservative rather than trying to catch the
+ exact boundary conditions; the main case to allow is IEEE float
+ and double. */
+ return (ifmt->b == tfmt->b
+ && ifmt->p > 2 * tfmt->p
+ && ifmt->emin < 2 * tfmt->emin - tfmt->p - 2
+ && ifmt->emin < tfmt->emin - tfmt->emax - tfmt->p - 2
+ && ifmt->emax > 2 * tfmt->emax + 2
+ && ifmt->emax > tfmt->emax - tfmt->emin + tfmt->p + 2
+ && ifmt->round_towards_zero == tfmt->round_towards_zero
+ && (ifmt->has_sign_dependent_rounding
+ == tfmt->has_sign_dependent_rounding)
+ && ifmt->has_nans >= tfmt->has_nans
+ && ifmt->has_inf >= tfmt->has_inf
+ && ifmt->has_signed_zero >= tfmt->has_signed_zero
+ && !MODE_COMPOSITE_P (tmode)
+ && !MODE_COMPOSITE_P (imode));
+}
\f
/* Render R as an integer. */
case rvc_inf:
case rvc_nan:
overflow:
- i = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
+ i = HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1);
if (!r->sign)
i--;
return i;
if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
i = r->sig[SIGSZ-1];
- else
+ else
{
gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
i = r->sig[SIGSZ-1];
}
}
-/* Likewise, but to an integer pair, HI+LOW. */
+/* Likewise, but producing a wide-int of PRECISION. If the value cannot
+ be represented in precision, *FAIL is set to TRUE. */
-void
-real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
- const REAL_VALUE_TYPE *r)
+wide_int
+real_to_integer (const REAL_VALUE_TYPE *r, bool *fail, int precision)
{
- REAL_VALUE_TYPE t;
- HOST_WIDE_INT low, high;
+ HOST_WIDE_INT val[2 * WIDE_INT_MAX_ELTS];
int exp;
+ int words, w;
+ wide_int result;
switch (r->cl)
{
case rvc_zero:
underflow:
- low = high = 0;
- break;
+ return wi::zero (precision);
case rvc_inf:
case rvc_nan:
overflow:
- high = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
+ *fail = true;
+
if (r->sign)
- low = 0;
+ return wi::set_bit_in_zero (precision - 1, precision);
else
- {
- high--;
- low = -1;
- }
- break;
+ return ~wi::set_bit_in_zero (precision - 1, precision);
case rvc_normal:
if (r->decimal)
- {
- decimal_real_to_integer2 (plow, phigh, r);
- return;
- }
-
+ return decimal_real_to_integer (r, fail, precision);
+
exp = REAL_EXP (r);
if (exp <= 0)
goto underflow;
undefined, so it doesn't matter what we return, and some callers
expect to be able to use this routine for both signed and
unsigned conversions. */
- if (exp > 2*HOST_BITS_PER_WIDE_INT)
+ if (exp > precision)
goto overflow;
- rshift_significand (&t, r, 2*HOST_BITS_PER_WIDE_INT - exp);
- if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
+ /* Put the significand into a wide_int that has precision W, which
+ is the smallest HWI-multiple that has at least PRECISION bits.
+ This ensures that the top bit of the significand is in the
+ top bit of the wide_int. */
+ words = (precision + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT;
+ w = words * HOST_BITS_PER_WIDE_INT;
+
+#if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
+ for (int i = 0; i < words; i++)
{
- high = t.sig[SIGSZ-1];
- low = t.sig[SIGSZ-2];
+ int j = SIGSZ - words + i;
+ val[i] = (j < 0) ? 0 : r->sig[j];
}
- else
+#else
+ gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
+ for (int i = 0; i < words; i++)
{
- gcc_assert (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG);
- high = t.sig[SIGSZ-1];
- high = high << (HOST_BITS_PER_LONG - 1) << 1;
- high |= t.sig[SIGSZ-2];
-
- low = t.sig[SIGSZ-3];
- low = low << (HOST_BITS_PER_LONG - 1) << 1;
- low |= t.sig[SIGSZ-4];
+ int j = SIGSZ - (words * 2) + (i * 2);
+ if (j < 0)
+ val[i] = 0;
+ else
+ val[i] = r->sig[j];
+ j += 1;
+ if (j >= 0)
+ val[i] |= (unsigned HOST_WIDE_INT) r->sig[j] << HOST_BITS_PER_LONG;
}
+#endif
+ /* Shift the value into place and truncate to the desired precision. */
+ result = wide_int::from_array (val, words, w);
+ result = wi::lrshift (result, w - exp);
+ result = wide_int::from (result, precision, UNSIGNED);
if (r->sign)
- {
- if (low == 0)
- high = -high;
- else
- low = -low, high = ~high;
- }
- break;
+ return -result;
+ else
+ return result;
default:
gcc_unreachable ();
}
-
- *plow = low;
- *phigh = high;
}
/* A subroutine of real_to_decimal. Compute the quotient and remainder
/* Render R 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. */
+ zeros. If MODE is VOIDmode, round to nearest value. Otherwise, round
+ to a string that, when parsed back in mode MODE, yields the same value. */
#define M_LOG10_2 0.30102999566398119521
void
-real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
- size_t digits, int crop_trailing_zeros)
+real_to_decimal_for_mode (char *str, const REAL_VALUE_TYPE *r_orig,
+ size_t buf_size, size_t digits,
+ int crop_trailing_zeros, machine_mode mode)
{
+ const struct real_format *fmt = NULL;
const REAL_VALUE_TYPE *one, *ten;
REAL_VALUE_TYPE r, pten, u, v;
int dec_exp, cmp_one, digit;
size_t max_digits;
char *p, *first, *last;
bool sign;
+ bool round_up;
+
+ if (mode != VOIDmode)
+ {
+ fmt = REAL_MODE_FORMAT (mode);
+ gcc_assert (fmt);
+ }
r = *r_orig;
switch (r.cl)
return;
case rvc_nan:
/* ??? Print the significand as well, if not canonical? */
- strcpy (str, (r.sign ? "-NaN" : "+NaN"));
+ sprintf (str, "%c%cNaN", (r_orig->sign ? '-' : '+'),
+ (r_orig->signalling ? 'S' : 'Q'));
return;
default:
gcc_unreachable ();
digit = rtd_divmod (&r, &pten);
/* Round the result. */
- if (digit == 5)
+ if (fmt && fmt->round_towards_zero)
{
- /* Round to nearest. If R is nonzero there are additional
- nonzero digits to be extracted. */
+ /* If the format uses round towards zero when parsing the string
+ back in, we need to always round away from zero here. */
if (cmp_significand_0 (&r))
digit++;
- /* Round to even. */
- else if ((p[-1] - '0') & 1)
- digit++;
+ round_up = digit > 0;
+ }
+ else
+ {
+ if (digit == 5)
+ {
+ /* Round to nearest. If R is nonzero there are additional
+ nonzero digits to be extracted. */
+ if (cmp_significand_0 (&r))
+ digit++;
+ /* Round to even. */
+ else if ((p[-1] - '0') & 1)
+ digit++;
+ }
+
+ round_up = digit > 5;
}
- if (digit > 5)
+
+ if (round_up)
{
while (p > first)
{
/* Append the exponent. */
sprintf (last, "e%+d", dec_exp);
+
+ /* Verify that we can read the original value back in. */
+ if (flag_checking && mode != VOIDmode)
+ {
+ real_from_string (&r, str);
+ real_convert (&r, mode, &r);
+ gcc_assert (real_identical (&r, r_orig));
+ }
+}
+
+/* Likewise, except always uses round-to-nearest. */
+
+void
+real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
+ size_t digits, int crop_trailing_zeros)
+{
+ real_to_decimal_for_mode (str, r_orig, buf_size,
+ digits, crop_trailing_zeros, VOIDmode);
}
/* Render R as a hexadecimal floating point constant. Emit DIGITS
return;
case rvc_nan:
/* ??? Print the significand as well, if not canonical? */
- strcpy (str, (r->sign ? "-NaN" : "+NaN"));
+ sprintf (str, "%c%cNaN", (r->sign ? '-' : '+'),
+ (r->signalling ? 'S' : 'Q'));
return;
default:
gcc_unreachable ();
}
/* Initialize R from a decimal or hexadecimal string. The string is
- assumed to have been syntax checked already. */
+ assumed to have been syntax checked already. Return -1 if the
+ value underflows, +1 if overflows, and 0 otherwise. */
-void
+int
real_from_string (REAL_VALUE_TYPE *r, const char *str)
{
int exp = 0;
else if (*str == '+')
str++;
+ if (!strncmp (str, "QNaN", 4))
+ {
+ get_canonical_qnan (r, sign);
+ return 0;
+ }
+ else if (!strncmp (str, "SNaN", 4))
+ {
+ get_canonical_snan (r, sign);
+ return 0;
+ }
+ else if (!strncmp (str, "Inf", 3))
+ {
+ get_inf (r, sign);
+ return 0;
+ }
+
if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
{
/* Hexadecimal floating point. */
/* If the mantissa is zero, ignore the exponent. */
if (!cmp_significand_0 (r))
- goto underflow;
+ goto is_a_zero;
if (*str == 'p' || *str == 'P')
{
else
{
/* Decimal floating point. */
- const REAL_VALUE_TYPE *ten = ten_to_ptwo (0);
- int d;
+ const char *cstr = str;
+ mpfr_t m;
+ bool inexact;
- while (*str == '0')
- str++;
- while (ISDIGIT (*str))
- {
- d = *str++ - '0';
- do_multiply (r, r, ten);
- if (d)
- do_add (r, r, real_digit (d), 0);
- }
- if (*str == '.')
+ while (*cstr == '0')
+ cstr++;
+ if (*cstr == '.')
{
- str++;
- if (r->cl == rvc_zero)
- {
- while (*str == '0')
- str++, exp--;
- }
- while (ISDIGIT (*str))
- {
- d = *str++ - '0';
- do_multiply (r, r, ten);
- if (d)
- do_add (r, r, real_digit (d), 0);
- exp--;
- }
+ cstr++;
+ while (*cstr == '0')
+ cstr++;
}
/* If the mantissa is zero, ignore the exponent. */
- if (r->cl == rvc_zero)
- goto underflow;
-
- if (*str == 'e' || *str == 'E')
+ if (!ISDIGIT (*cstr))
+ goto is_a_zero;
+
+ /* Nonzero value, possibly overflowing or underflowing. */
+ mpfr_init2 (m, SIGNIFICAND_BITS);
+ inexact = mpfr_strtofr (m, str, NULL, 10, MPFR_RNDZ);
+ /* The result should never be a NaN, and because the rounding is
+ toward zero should never be an infinity. */
+ gcc_assert (!mpfr_nan_p (m) && !mpfr_inf_p (m));
+ if (mpfr_zero_p (m) || mpfr_get_exp (m) < -MAX_EXP + 4)
{
- bool exp_neg = false;
-
- str++;
- if (*str == '-')
- {
- exp_neg = true;
- str++;
- }
- else if (*str == '+')
- str++;
-
- d = 0;
- while (ISDIGIT (*str))
- {
- d *= 10;
- d += *str - '0';
- if (d > MAX_EXP)
- {
- /* Overflowed the exponent. */
- if (exp_neg)
- goto underflow;
- else
- goto overflow;
- }
- str++;
- }
- if (exp_neg)
- d = -d;
- exp += d;
+ mpfr_clear (m);
+ goto underflow;
+ }
+ else if (mpfr_get_exp (m) > MAX_EXP - 4)
+ {
+ mpfr_clear (m);
+ goto overflow;
+ }
+ else
+ {
+ real_from_mpfr (r, m, NULL_TREE, MPFR_RNDZ);
+ /* 1 to 3 bits may have been shifted off (with a sticky bit)
+ because the hex digits used in real_from_mpfr did not
+ start with a digit 8 to f, but the exponent bounds above
+ should have avoided underflow or overflow. */
+ gcc_assert (r->cl == rvc_normal);
+ /* Set a sticky bit if mpfr_strtofr was inexact. */
+ r->sig[0] |= inexact;
+ mpfr_clear (m);
}
-
- if (exp)
- times_pten (r, exp);
}
r->sign = sign;
- return;
+ return 0;
+
+ is_a_zero:
+ get_zero (r, sign);
+ return 0;
underflow:
get_zero (r, sign);
- return;
+ return -1;
overflow:
get_inf (r, sign);
- return;
+ return 1;
}
/* Legacy. Similar, but return the result directly. */
REAL_VALUE_TYPE
-real_from_string2 (const char *s, enum machine_mode mode)
+real_from_string2 (const char *s, format_helper fmt)
{
REAL_VALUE_TYPE r;
real_from_string (&r, s);
- if (mode != VOIDmode)
- real_convert (&r, mode, &r);
+ if (fmt)
+ real_convert (&r, fmt, &r);
return r;
}
-/* Initialize R from string S and desired MODE. */
+/* Initialize R from string S and desired format FMT. */
-void
-real_from_string3 (REAL_VALUE_TYPE *r, const char *s, enum machine_mode mode)
+void
+real_from_string3 (REAL_VALUE_TYPE *r, const char *s, format_helper fmt)
{
- if (DECIMAL_FLOAT_MODE_P (mode))
+ if (fmt.decimal_p ())
decimal_real_from_string (r, s);
else
real_from_string (r, s);
- if (mode != VOIDmode)
- real_convert (r, mode, r);
-}
+ if (fmt)
+ real_convert (r, fmt, r);
+}
-/* Initialize R from the integer pair HIGH+LOW. */
+/* Initialize R from the wide_int VAL_IN. Round it to format FMT if
+ FMT is nonnull. */
void
-real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
- unsigned HOST_WIDE_INT low, HOST_WIDE_INT high,
- int unsigned_p)
+real_from_integer (REAL_VALUE_TYPE *r, format_helper fmt,
+ const wide_int_ref &val_in, signop sgn)
{
- if (low == 0 && high == 0)
+ if (val_in == 0)
get_zero (r, 0);
else
{
+ unsigned int len = val_in.get_precision ();
+ int i, j, e = 0;
+ int maxbitlen = MAX_BITSIZE_MODE_ANY_INT + HOST_BITS_PER_WIDE_INT;
+ const unsigned int realmax = (SIGNIFICAND_BITS / HOST_BITS_PER_WIDE_INT
+ * HOST_BITS_PER_WIDE_INT);
+
memset (r, 0, sizeof (*r));
r->cl = rvc_normal;
- r->sign = high < 0 && !unsigned_p;
- SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT);
+ r->sign = wi::neg_p (val_in, sgn);
+
+ /* We have to ensure we can negate the largest negative number. */
+ wide_int val = wide_int::from (val_in, maxbitlen, sgn);
if (r->sign)
+ val = -val;
+
+ /* Ensure a multiple of HOST_BITS_PER_WIDE_INT, ceiling, as elt
+ won't work with precisions that are not a multiple of
+ HOST_BITS_PER_WIDE_INT. */
+ len += HOST_BITS_PER_WIDE_INT - 1;
+
+ /* Ensure we can represent the largest negative number. */
+ len += 1;
+
+ len = len/HOST_BITS_PER_WIDE_INT * HOST_BITS_PER_WIDE_INT;
+
+ /* Cap the size to the size allowed by real.h. */
+ if (len > realmax)
{
- high = ~high;
- if (low == 0)
- high += 1;
- else
- low = -low;
+ HOST_WIDE_INT cnt_l_z;
+ cnt_l_z = wi::clz (val);
+
+ if (maxbitlen - cnt_l_z > realmax)
+ {
+ e = maxbitlen - cnt_l_z - realmax;
+
+ /* This value is too large, we must shift it right to
+ preserve all the bits we can, and then bump the
+ exponent up by that amount. */
+ val = wi::lrshift (val, e);
+ }
+ len = realmax;
}
+ /* Clear out top bits so elt will work with precisions that aren't
+ a multiple of HOST_BITS_PER_WIDE_INT. */
+ val = wide_int::from (val, len, sgn);
+ len = len / HOST_BITS_PER_WIDE_INT;
+
+ SET_REAL_EXP (r, len * HOST_BITS_PER_WIDE_INT + e);
+
+ j = SIGSZ - 1;
if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT)
- {
- r->sig[SIGSZ-1] = high;
- r->sig[SIGSZ-2] = low;
- }
+ for (i = len - 1; i >= 0; i--)
+ {
+ r->sig[j--] = val.elt (i);
+ if (j < 0)
+ break;
+ }
else
{
gcc_assert (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT);
- r->sig[SIGSZ-1] = high >> (HOST_BITS_PER_LONG - 1) >> 1;
- r->sig[SIGSZ-2] = high;
- r->sig[SIGSZ-3] = low >> (HOST_BITS_PER_LONG - 1) >> 1;
- r->sig[SIGSZ-4] = low;
+ for (i = len - 1; i >= 0; i--)
+ {
+ HOST_WIDE_INT e = val.elt (i);
+ r->sig[j--] = e >> (HOST_BITS_PER_LONG - 1) >> 1;
+ if (j < 0)
+ break;
+ r->sig[j--] = e;
+ if (j < 0)
+ break;
+ }
}
normalize (r);
}
- if (mode != VOIDmode)
- real_convert (r, mode, r);
+ if (fmt.decimal_p ())
+ decimal_from_integer (r);
+ if (fmt)
+ real_convert (r, fmt, r);
+}
+
+/* Render R, an integral value, as a floating point constant with no
+ specified exponent. */
+
+static void
+decimal_integer_string (char *str, const REAL_VALUE_TYPE *r_orig,
+ size_t buf_size)
+{
+ int dec_exp, digit, digits;
+ REAL_VALUE_TYPE r, pten;
+ char *p;
+ bool sign;
+
+ r = *r_orig;
+
+ if (r.cl == rvc_zero)
+ {
+ strcpy (str, "0.");
+ return;
+ }
+
+ sign = r.sign;
+ r.sign = 0;
+
+ dec_exp = REAL_EXP (&r) * M_LOG10_2;
+ digits = dec_exp + 1;
+ gcc_assert ((digits + 2) < (int)buf_size);
+
+ pten = *real_digit (1);
+ times_pten (&pten, dec_exp);
+
+ p = str;
+ if (sign)
+ *p++ = '-';
+
+ digit = rtd_divmod (&r, &pten);
+ gcc_assert (digit >= 0 && digit <= 9);
+ *p++ = digit + '0';
+ while (--digits > 0)
+ {
+ times_pten (&r, 1);
+ digit = rtd_divmod (&r, &pten);
+ *p++ = digit + '0';
+ }
+ *p++ = '.';
+ *p++ = '\0';
+}
+
+/* Convert a real with an integral value to decimal float. */
+
+static void
+decimal_from_integer (REAL_VALUE_TYPE *r)
+{
+ char str[256];
+
+ decimal_integer_string (str, r, sizeof (str) - 1);
+ decimal_real_from_string (r, str);
}
/* Returns 10**2**N. */
for (i = 0; i < n; ++i)
t *= t;
- real_from_integer (&tens[n], VOIDmode, t, 0, 1);
+ real_from_integer (&tens[n], VOIDmode, t, UNSIGNED);
}
else
{
gcc_assert (n <= 9);
if (n > 0 && num[n].cl == rvc_zero)
- real_from_integer (&num[n], VOIDmode, n, 0, 1);
+ real_from_integer (&num[n], VOIDmode, n, UNSIGNED);
return &num[n];
}
do_divide (r, r, &pten);
}
+/* Returns the special REAL_VALUE_TYPE corresponding to 'e'. */
+
+const REAL_VALUE_TYPE *
+dconst_e_ptr (void)
+{
+ static REAL_VALUE_TYPE value;
+
+ /* Initialize mathematical constants for constant folding builtins.
+ These constants need to be given to at least 160 bits precision. */
+ if (value.cl == rvc_zero)
+ {
+ mpfr_t m;
+ mpfr_init2 (m, SIGNIFICAND_BITS);
+ mpfr_set_ui (m, 1, MPFR_RNDN);
+ mpfr_exp (m, m, MPFR_RNDN);
+ real_from_mpfr (&value, m, NULL_TREE, MPFR_RNDN);
+ mpfr_clear (m);
+
+ }
+ return &value;
+}
+
+/* Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n. */
+
+#define CACHED_FRACTION(NAME, N) \
+ const REAL_VALUE_TYPE * \
+ NAME (void) \
+ { \
+ static REAL_VALUE_TYPE value; \
+ \
+ /* Initialize mathematical constants for constant folding builtins. \
+ These constants need to be given to at least 160 bits \
+ precision. */ \
+ if (value.cl == rvc_zero) \
+ real_arithmetic (&value, RDIV_EXPR, &dconst1, real_digit (N)); \
+ return &value; \
+ }
+
+CACHED_FRACTION (dconst_third_ptr, 3)
+CACHED_FRACTION (dconst_quarter_ptr, 4)
+CACHED_FRACTION (dconst_sixth_ptr, 6)
+CACHED_FRACTION (dconst_ninth_ptr, 9)
+
+/* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2). */
+
+const REAL_VALUE_TYPE *
+dconst_sqrt2_ptr (void)
+{
+ static REAL_VALUE_TYPE value;
+
+ /* Initialize mathematical constants for constant folding builtins.
+ These constants need to be given to at least 160 bits precision. */
+ if (value.cl == rvc_zero)
+ {
+ mpfr_t m;
+ mpfr_init2 (m, SIGNIFICAND_BITS);
+ mpfr_sqrt_ui (m, 2, MPFR_RNDN);
+ real_from_mpfr (&value, m, NULL_TREE, MPFR_RNDN);
+ mpfr_clear (m);
+ }
+ return &value;
+}
+
/* Fills R with +Inf. */
void
bool
real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
- enum machine_mode mode)
+ format_helper fmt)
{
- const struct real_format *fmt;
-
- fmt = REAL_MODE_FORMAT (mode);
- gcc_assert (fmt);
-
if (*str == 0)
{
if (quiet)
/* Our MSB is always unset for NaNs. */
r->sig[SIGSZ-1] &= ~SIG_MSB;
- /* Force quiet or signalling NaN. */
+ /* Force quiet or signaling NaN. */
r->signalling = !quiet;
}
If SIGN is nonzero, R is set to the most negative finite value. */
void
-real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
+real_maxval (REAL_VALUE_TYPE *r, int sign, machine_mode mode)
{
const struct real_format *fmt;
int np2;
fmt = REAL_MODE_FORMAT (mode);
gcc_assert (fmt);
memset (r, 0, sizeof (*r));
-
+
if (fmt->b == 10)
decimal_real_maxval (r, sign, mode);
else
{
r->cl = rvc_normal;
r->sign = sign;
- SET_REAL_EXP (r, fmt->emax * fmt->log2_b);
+ SET_REAL_EXP (r, fmt->emax);
- np2 = SIGNIFICAND_BITS - fmt->p * fmt->log2_b;
+ np2 = SIGNIFICAND_BITS - fmt->p;
memset (r->sig, -1, SIGSZ * sizeof (unsigned long));
clear_significand_below (r, np2);
required to be the value of the long double rounded to the
nearest double. Rounding means we need a slightly smaller
value for LDBL_MAX. */
- clear_significand_bit (r, SIGNIFICAND_BITS - fmt->pnan);
+ clear_significand_bit (r, SIGNIFICAND_BITS - fmt->pnan - 1);
}
}
/* Fills R with 2**N. */
void
-real_2expN (REAL_VALUE_TYPE *r, int n)
+real_2expN (REAL_VALUE_TYPE *r, int n, format_helper fmt)
{
memset (r, 0, sizeof (*r));
SET_REAL_EXP (r, n);
r->sig[SIGSZ-1] = SIG_MSB;
}
+ if (fmt.decimal_p ())
+ decimal_real_convert (r, fmt, r);
}
\f
round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
{
int p2, np2, i, w;
- unsigned long sticky;
- bool guard, lsb;
int emin2m1, emax2;
+ bool round_up = false;
if (r->decimal)
{
(e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
investigated whether this convert needs to be here, or
something else is missing. */
- decimal_real_convert (r, DFmode, r);
+ decimal_real_convert (r, REAL_MODE_FORMAT (DFmode), r);
}
- p2 = fmt->p * fmt->log2_b;
- emin2m1 = (fmt->emin - 1) * fmt->log2_b;
- emax2 = fmt->emax * fmt->log2_b;
+ p2 = fmt->p;
+ emin2m1 = fmt->emin - 1;
+ emax2 = fmt->emax;
np2 = SIGNIFICAND_BITS - p2;
switch (r->cl)
{
underflow:
get_zero (r, r->sign);
+ /* FALLTHRU */
case rvc_zero:
if (!fmt->has_signed_zero)
r->sign = 0;
gcc_unreachable ();
}
- /* If we're not base2, normalize the exponent to a multiple of
- the true base. */
- if (fmt->log2_b != 1)
- {
- int shift;
-
- gcc_assert (fmt->b != 10);
- shift = REAL_EXP (r) & (fmt->log2_b - 1);
- if (shift)
- {
- shift = fmt->log2_b - shift;
- r->sig[0] |= sticky_rshift_significand (r, r, shift);
- SET_REAL_EXP (r, REAL_EXP (r) + shift);
- }
- }
-
/* Check the range of the exponent. If we're out of range,
either underflow or overflow. */
if (REAL_EXP (r) > emax2)
}
}
- /* There are P2 true significand bits, followed by one guard bit,
- followed by one sticky bit, followed by stuff. Fold nonzero
- stuff into the sticky bit. */
+ if (!fmt->round_towards_zero)
+ {
+ /* There are P2 true significand bits, followed by one guard bit,
+ followed by one sticky bit, followed by stuff. Fold nonzero
+ stuff into the sticky bit. */
+ unsigned long sticky;
+ bool guard, lsb;
+
+ sticky = 0;
+ for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
+ sticky |= r->sig[i];
+ sticky |= r->sig[w]
+ & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
- sticky = 0;
- for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
- sticky |= r->sig[i];
- sticky |=
- r->sig[w] & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
+ guard = test_significand_bit (r, np2 - 1);
+ lsb = test_significand_bit (r, np2);
- guard = test_significand_bit (r, np2 - 1);
- lsb = test_significand_bit (r, np2);
+ /* Round to even. */
+ round_up = guard && (sticky || lsb);
+ }
- /* Round to even. */
- if (guard && (sticky || lsb))
+ if (round_up)
{
REAL_VALUE_TYPE u;
get_zero (&u, 0);
if (REAL_EXP (r) > emax2)
goto overflow;
r->sig[SIGSZ-1] = SIG_MSB;
-
- if (fmt->log2_b != 1)
- {
- int shift = REAL_EXP (r) & (fmt->log2_b - 1);
- if (shift)
- {
- shift = fmt->log2_b - shift;
- rshift_significand (r, r, shift);
- SET_REAL_EXP (r, REAL_EXP (r) + shift);
- if (REAL_EXP (r) > emax2)
- goto overflow;
- }
- }
}
}
clear_significand_below (r, np2);
}
-/* Extend or truncate to a new mode. */
+/* Extend or truncate to a new format. */
void
-real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
+real_convert (REAL_VALUE_TYPE *r, format_helper fmt,
const REAL_VALUE_TYPE *a)
{
- const struct real_format *fmt;
-
- fmt = REAL_MODE_FORMAT (mode);
- gcc_assert (fmt);
-
*r = *a;
if (a->decimal || fmt->b == 10)
- decimal_real_convert (r, mode, a);
+ decimal_real_convert (r, fmt, a);
round_for_format (fmt, r);
+ /* Make resulting NaN value to be qNaN. The caller has the
+ responsibility to avoid the operation if flag_signaling_nans
+ is on. */
+ if (r->cl == rvc_nan)
+ r->signalling = 0;
+
/* round_for_format de-normalizes denormals. Undo just that part. */
if (r->cl == rvc_normal)
normalize (r);
/* Legacy. Likewise, except return the struct directly. */
REAL_VALUE_TYPE
-real_value_truncate (enum machine_mode mode, REAL_VALUE_TYPE a)
+real_value_truncate (format_helper fmt, REAL_VALUE_TYPE a)
{
REAL_VALUE_TYPE r;
- real_convert (&r, mode, &a);
+ real_convert (&r, fmt, &a);
return r;
}
-/* Return true if truncating to MODE is exact. */
+/* Return true if truncating to FMT is exact. */
bool
-exact_real_truncate (enum machine_mode mode, const REAL_VALUE_TYPE *a)
+exact_real_truncate (format_helper fmt, const REAL_VALUE_TYPE *a)
{
- const struct real_format *fmt;
REAL_VALUE_TYPE t;
int emin2m1;
- fmt = REAL_MODE_FORMAT (mode);
- gcc_assert (fmt);
-
/* Don't allow conversion to denormals. */
- emin2m1 = (fmt->emin - 1) * fmt->log2_b;
+ emin2m1 = fmt->emin - 1;
if (REAL_EXP (a) <= emin2m1)
return false;
- /* After conversion to the new mode, the value must be identical. */
- real_convert (&t, mode, a);
+ /* After conversion to the new format, the value must be identical. */
+ real_convert (&t, fmt, a);
return real_identical (&t, a);
}
Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
long
-real_to_target_fmt (long *buf, const REAL_VALUE_TYPE *r_orig,
- const struct real_format *fmt)
+real_to_target (long *buf, const REAL_VALUE_TYPE *r_orig,
+ format_helper fmt)
{
REAL_VALUE_TYPE r;
long buf1;
return *buf;
}
-/* Similar, but look up the format from MODE. */
-
-long
-real_to_target (long *buf, const REAL_VALUE_TYPE *r, enum machine_mode mode)
-{
- const struct real_format *fmt;
-
- fmt = REAL_MODE_FORMAT (mode);
- gcc_assert (fmt);
-
- return real_to_target_fmt (buf, r, fmt);
-}
-
/* Read R from the given target format. Read the words of the result
in target word order in BUF. There are always 32 bits in each
long, no matter the size of the host long. */
void
-real_from_target_fmt (REAL_VALUE_TYPE *r, const long *buf,
- const struct real_format *fmt)
-{
- (*fmt->decode) (fmt, r, buf);
-}
-
-/* Similar, but look up the format from MODE. */
-
-void
-real_from_target (REAL_VALUE_TYPE *r, const long *buf, enum machine_mode mode)
+real_from_target (REAL_VALUE_TYPE *r, const long *buf, format_helper fmt)
{
- const struct real_format *fmt;
-
- fmt = REAL_MODE_FORMAT (mode);
- gcc_assert (fmt);
-
(*fmt->decode) (fmt, r, buf);
}
/* Return the number of bits of the largest binary value that the
- significand of MODE will hold. */
+ significand of FMT will hold. */
/* ??? Legacy. Should get access to real_format directly. */
int
-significand_size (enum machine_mode mode)
+significand_size (format_helper fmt)
{
- const struct real_format *fmt;
-
- fmt = REAL_MODE_FORMAT (mode);
if (fmt == NULL)
return 0;
if (fmt->b == 10)
{
/* Return the size in bits of the largest binary value that can be
- held by the decimal coefficient for this mode. This is one more
+ held by the decimal coefficient for this format. This is one more
than the number of bits required to hold the largest coefficient
- of this mode. */
+ of this format. */
double log2_10 = 3.3219281;
return fmt->p * log2_10;
}
- return fmt->p * fmt->log2_b;
+ return fmt->p;
}
/* Return a hash value for the given real value. */
return h;
case rvc_normal:
- h |= REAL_EXP (r) << 3;
+ h |= (unsigned int)REAL_EXP (r) << 3;
break;
case rvc_nan:
gcc_unreachable ();
}
- if (sizeof(unsigned long) > sizeof(unsigned int))
+ if (sizeof (unsigned long) > sizeof (unsigned int))
for (i = 0; i < SIGSZ; ++i)
{
unsigned long s = r->sig[i];
encode_ieee_single,
decode_ieee_single,
2,
- 1,
24,
24,
-125,
128,
31,
31,
+ 32,
+ false,
true,
true,
true,
true,
true,
- false
+ true,
+ false,
+ "ieee_single"
};
const struct real_format mips_single_format =
encode_ieee_single,
decode_ieee_single,
2,
- 1,
24,
24,
-125,
128,
31,
31,
+ 32,
+ false,
+ true,
true,
true,
true,
true,
false,
- true
+ true,
+ "mips_single"
};
-const struct real_format coldfire_single_format =
+const struct real_format motorola_single_format =
{
encode_ieee_single,
decode_ieee_single,
2,
- 1,
24,
24,
-125,
128,
31,
31,
+ 32,
+ false,
+ true,
+ true,
+ true,
+ true,
true,
true,
true,
+ "motorola_single"
+ };
+
+/* SPU Single Precision (Extended-Range Mode) format is the same as IEEE
+ single precision with the following differences:
+ - Infinities are not supported. Instead MAX_FLOAT or MIN_FLOAT
+ are generated.
+ - NaNs are not supported.
+ - The range of non-zero numbers in binary is
+ (001)[1.]000...000 to (255)[1.]111...111.
+ - Denormals can be represented, but are treated as +0.0 when
+ used as an operand and are never generated as a result.
+ - -0.0 can be represented, but a zero result is always +0.0.
+ - the only supported rounding mode is trunction (towards zero). */
+const struct real_format spu_single_format =
+ {
+ encode_ieee_single,
+ decode_ieee_single,
+ 2,
+ 24,
+ 24,
+ -125,
+ 129,
+ 31,
+ 31,
+ 0,
+ true,
+ false,
+ false,
+ false,
true,
true,
- true
+ false,
+ false,
+ "spu_single"
};
\f
/* IEEE double-precision format. */
encode_ieee_double,
decode_ieee_double,
2,
- 1,
53,
53,
-1021,
1024,
63,
63,
+ 64,
+ false,
+ true,
true,
true,
true,
true,
true,
- false
+ false,
+ "ieee_double"
};
const struct real_format mips_double_format =
encode_ieee_double,
decode_ieee_double,
2,
- 1,
53,
53,
-1021,
1024,
63,
63,
+ 64,
+ false,
+ true,
true,
true,
true,
true,
false,
- true
+ true,
+ "mips_double"
};
-const struct real_format coldfire_double_format =
+const struct real_format motorola_double_format =
{
encode_ieee_double,
decode_ieee_double,
2,
- 1,
53,
53,
-1021,
1024,
63,
63,
+ 64,
+ false,
+ true,
true,
true,
true,
true,
true,
- true
+ true,
+ "motorola_double"
};
\f
/* IEEE extended real format. This comes in three flavors: Intel's as
if (fmt->has_nans)
{
image_hi |= 32767;
- if (HOST_BITS_PER_LONG == 32)
+ if (r->canonical)
+ {
+ if (fmt->canonical_nan_lsbs_set)
+ {
+ sig_hi = (1 << 30) - 1;
+ sig_lo = 0xffffffff;
+ }
+ }
+ else if (HOST_BITS_PER_LONG == 32)
{
sig_hi = r->sig[SIGSZ-1];
sig_lo = r->sig[SIGSZ-2];
long intermed[3];
encode_ieee_extended (fmt, intermed, r);
+ if (r->cl == rvc_inf)
+ /* For infinity clear the explicit integer bit again, so that the
+ format matches the canonical infinity generated by the FPU. */
+ intermed[1] = 0;
+
/* Motorola chips are assumed always to be big-endian. Also, the
padding in a Motorola extended real goes between the exponent and
the mantissa. At this point the mantissa is entirely within
encode_ieee_extended_motorola,
decode_ieee_extended_motorola,
2,
- 1,
64,
64,
-16382,
16384,
95,
95,
+ 0,
+ false,
true,
true,
true,
true,
true,
- false
+ true,
+ true,
+ "ieee_extended_motorola"
};
const struct real_format ieee_extended_intel_96_format =
encode_ieee_extended_intel_96,
decode_ieee_extended_intel_96,
2,
- 1,
64,
64,
-16381,
16384,
79,
79,
+ 65,
+ false,
+ true,
true,
true,
true,
true,
true,
- false
+ false,
+ "ieee_extended_intel_96"
};
const struct real_format ieee_extended_intel_128_format =
encode_ieee_extended_intel_128,
decode_ieee_extended_intel_128,
2,
- 1,
64,
64,
-16381,
16384,
79,
79,
+ 65,
+ false,
true,
true,
true,
true,
true,
- false
+ true,
+ false,
+ "ieee_extended_intel_128"
};
/* The following caters to i386 systems that set the rounding precision
encode_ieee_extended_intel_96,
decode_ieee_extended_intel_96,
2,
- 1,
53,
53,
-16381,
16384,
79,
79,
+ 33,
+ false,
+ true,
true,
true,
true,
true,
true,
- false
+ false,
+ "ieee_extended_intel_96_round_53"
};
\f
/* IBM 128-bit extended precision format: a pair of IEEE double precision
base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
- /* Renormlize R before doing any arithmetic on it. */
+ /* Renormalize R before doing any arithmetic on it. */
normr = *r;
if (normr.cl == rvc_normal)
normalize (&normr);
encode_ibm_extended,
decode_ibm_extended,
2,
- 1,
53 + 53,
53,
-1021 + 53,
1024,
127,
-1,
+ 0,
+ false,
true,
true,
true,
true,
true,
- false
+ true,
+ false,
+ "ibm_extended"
};
const struct real_format mips_extended_format =
encode_ibm_extended,
decode_ibm_extended,
2,
- 1,
53 + 53,
53,
-1021 + 53,
1024,
127,
-1,
+ 0,
+ false,
+ true,
true,
true,
true,
true,
false,
- true
+ true,
+ "mips_extended"
};
\f
encode_ieee_quad,
decode_ieee_quad,
2,
- 1,
113,
113,
-16381,
16384,
127,
127,
+ 128,
+ false,
+ true,
true,
true,
true,
true,
true,
- false
+ false,
+ "ieee_quad"
};
const struct real_format mips_quad_format =
encode_ieee_quad,
decode_ieee_quad,
2,
- 1,
113,
113,
-16381,
16384,
127,
127,
+ 128,
+ false,
+ true,
true,
true,
true,
true,
false,
- true
+ true,
+ "mips_quad"
};
\f
/* Descriptions of VAX floating point formats can be found beginning at
encode_vax_f,
decode_vax_f,
2,
- 1,
24,
24,
-127,
127,
15,
15,
+ 0,
+ false,
+ false,
+ false,
false,
false,
false,
false,
false,
- false
+ "vax_f"
};
const struct real_format vax_d_format =
encode_vax_d,
decode_vax_d,
2,
- 1,
56,
56,
-127,
127,
15,
15,
+ 0,
false,
false,
false,
false,
false,
- false
+ false,
+ false,
+ false,
+ "vax_d"
};
const struct real_format vax_g_format =
encode_vax_g,
decode_vax_g,
2,
- 1,
53,
53,
-1023,
1023,
15,
15,
+ 0,
false,
false,
false,
false,
false,
- false
- };
-\f
-/* A good reference for these can be found in chapter 9 of
- "ESA/390 Principles of Operation", IBM document number SA22-7201-01.
- An on-line version can be found here:
-
- http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/DZ9AR001/9.1?DT=19930923083613
-*/
-
-static void encode_i370_single (const struct real_format *fmt,
- long *, const REAL_VALUE_TYPE *);
-static void decode_i370_single (const struct real_format *,
- REAL_VALUE_TYPE *, const long *);
-static void encode_i370_double (const struct real_format *fmt,
- long *, const REAL_VALUE_TYPE *);
-static void decode_i370_double (const struct real_format *,
- REAL_VALUE_TYPE *, const long *);
-
-static void
-encode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
- long *buf, const REAL_VALUE_TYPE *r)
-{
- unsigned long sign, exp, sig, image;
-
- sign = r->sign << 31;
-
- switch (r->cl)
- {
- case rvc_zero:
- image = 0;
- break;
-
- case rvc_inf:
- case rvc_nan:
- image = 0x7fffffff | sign;
- break;
-
- case rvc_normal:
- sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0xffffff;
- exp = ((REAL_EXP (r) / 4) + 64) << 24;
- image = sign | exp | sig;
- break;
-
- default:
- gcc_unreachable ();
- }
-
- buf[0] = image;
-}
-
-static void
-decode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
- REAL_VALUE_TYPE *r, const long *buf)
-{
- unsigned long sign, sig, image = buf[0];
- int exp;
-
- sign = (image >> 31) & 1;
- exp = (image >> 24) & 0x7f;
- sig = image & 0xffffff;
-
- memset (r, 0, sizeof (*r));
-
- if (exp || sig)
- {
- r->cl = rvc_normal;
- r->sign = sign;
- SET_REAL_EXP (r, (exp - 64) * 4);
- r->sig[SIGSZ-1] = sig << (HOST_BITS_PER_LONG - 24);
- normalize (r);
- }
-}
-
-static void
-encode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
- long *buf, const REAL_VALUE_TYPE *r)
-{
- unsigned long sign, exp, image_hi, image_lo;
-
- sign = r->sign << 31;
-
- switch (r->cl)
- {
- case rvc_zero:
- image_hi = image_lo = 0;
- break;
-
- case rvc_inf:
- case rvc_nan:
- image_hi = 0x7fffffff | sign;
- image_lo = 0xffffffff;
- break;
-
- case rvc_normal:
- if (HOST_BITS_PER_LONG == 64)
- {
- image_hi = r->sig[SIGSZ-1];
- image_lo = (image_hi >> (64 - 56)) & 0xffffffff;
- image_hi = (image_hi >> (64 - 56 + 1) >> 31) & 0xffffff;
- }
- else
- {
- image_hi = r->sig[SIGSZ-1];
- image_lo = r->sig[SIGSZ-2];
- image_lo = (image_lo >> 8) | (image_hi << 24);
- image_hi >>= 8;
- }
-
- exp = ((REAL_EXP (r) / 4) + 64) << 24;
- image_hi |= sign | exp;
- break;
-
- default:
- gcc_unreachable ();
- }
-
- if (FLOAT_WORDS_BIG_ENDIAN)
- buf[0] = image_hi, buf[1] = image_lo;
- else
- buf[0] = image_lo, buf[1] = image_hi;
-}
-
-static void
-decode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
- REAL_VALUE_TYPE *r, const long *buf)
-{
- unsigned long sign, image_hi, image_lo;
- int exp;
-
- if (FLOAT_WORDS_BIG_ENDIAN)
- image_hi = buf[0], image_lo = buf[1];
- else
- image_lo = buf[0], image_hi = buf[1];
-
- sign = (image_hi >> 31) & 1;
- exp = (image_hi >> 24) & 0x7f;
- image_hi &= 0xffffff;
- image_lo &= 0xffffffff;
-
- memset (r, 0, sizeof (*r));
-
- if (exp || image_hi || image_lo)
- {
- r->cl = rvc_normal;
- r->sign = sign;
- SET_REAL_EXP (r, (exp - 64) * 4 + (SIGNIFICAND_BITS - 56));
-
- if (HOST_BITS_PER_LONG == 32)
- {
- r->sig[0] = image_lo;
- r->sig[1] = image_hi;
- }
- else
- r->sig[0] = image_lo | (image_hi << 31 << 1);
-
- normalize (r);
- }
-}
-
-const struct real_format i370_single_format =
- {
- encode_i370_single,
- decode_i370_single,
- 16,
- 4,
- 6,
- 6,
- -64,
- 63,
- 31,
- 31,
- false,
- false,
- false, /* ??? The encoding does allow for "unnormals". */
- false, /* ??? The encoding does allow for "unnormals". */
- false,
- false
- };
-
-const struct real_format i370_double_format =
- {
- encode_i370_double,
- decode_i370_double,
- 16,
- 4,
- 14,
- 14,
- -64,
- 63,
- 63,
- 63,
false,
false,
- false, /* ??? The encoding does allow for "unnormals". */
- false, /* ??? The encoding does allow for "unnormals". */
false,
- false
+ "vax_g"
};
\f
/* Encode real R into a single precision DFP value in BUF. */
static void
encode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
- long *buf ATTRIBUTE_UNUSED,
+ long *buf ATTRIBUTE_UNUSED,
const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
{
encode_decimal32 (fmt, buf, r);
}
/* Decode a single precision DFP value in BUF into a real R. */
-static void
+static void
decode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
- REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
+ REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
const long *buf ATTRIBUTE_UNUSED)
{
decode_decimal32 (fmt, r, buf);
}
/* Encode real R into a double precision DFP value in BUF. */
-static void
+static void
encode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
- long *buf ATTRIBUTE_UNUSED,
+ long *buf ATTRIBUTE_UNUSED,
const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
{
encode_decimal64 (fmt, buf, r);
}
/* Decode a double precision DFP value in BUF into a real R. */
-static void
+static void
decode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
- REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
+ REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
const long *buf ATTRIBUTE_UNUSED)
{
decode_decimal64 (fmt, r, buf);
}
/* Encode real R into a quad precision DFP value in BUF. */
-static void
+static void
encode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
long *buf ATTRIBUTE_UNUSED,
const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
}
/* Decode a quad precision DFP value in BUF into a real R. */
-static void
+static void
decode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
const long *buf ATTRIBUTE_UNUSED)
decode_decimal128 (fmt, r, buf);
}
-/* Single precision decimal floating point (IEEE 754R). */
+/* Single precision decimal floating point (IEEE 754). */
const struct real_format decimal_single_format =
{
encode_decimal_single,
decode_decimal_single,
- 10,
- 1, /* log10 */
+ 10,
7,
7,
- -95,
- 96,
+ -94,
+ 97,
31,
31,
+ 32,
+ false,
+ true,
+ true,
true,
true,
true,
- true,
true,
- false
+ false,
+ "decimal_single"
};
-/* Double precision decimal floating point (IEEE 754R). */
+/* Double precision decimal floating point (IEEE 754). */
const struct real_format decimal_double_format =
{
encode_decimal_double,
decode_decimal_double,
10,
- 1, /* log10 */
16,
16,
- -383,
- 384,
+ -382,
+ 385,
63,
63,
+ 64,
+ false,
true,
true,
true,
true,
true,
- false
- };
+ true,
+ false,
+ "decimal_double"
+ };
-/* Quad precision decimal floating point (IEEE 754R). */
+/* Quad precision decimal floating point (IEEE 754). */
const struct real_format decimal_quad_format =
{
encode_decimal_quad,
decode_decimal_quad,
10,
- 1, /* log10 */
34,
34,
- -6143,
- 6144,
+ -6142,
+ 6145,
127,
127,
+ 128,
+ false,
+ true,
+ true,
true,
true,
- true,
- true,
true,
- false
+ true,
+ false,
+ "decimal_quad"
};
\f
-/* The "twos-complement" c4x format is officially defined as
-
- x = s(~s).f * 2**e
-
- This is rather misleading. One must remember that F is signed.
- A better description would be
-
- x = -1**s * ((s + 1 + .f) * 2**e
-
- So if we have a (4 bit) fraction of .1000 with a sign bit of 1,
- that's -1 * (1+1+(-.5)) == -1.5. I think.
-
- The constructions here are taken from Tables 5-1 and 5-2 of the
- TMS320C4x User's Guide wherein step-by-step instructions for
- conversion from IEEE are presented. That's close enough to our
- internal representation so as to make things easy.
-
- See http://www-s.ti.com/sc/psheets/spru063c/spru063c.pdf */
-
-static void encode_c4x_single (const struct real_format *fmt,
- long *, const REAL_VALUE_TYPE *);
-static void decode_c4x_single (const struct real_format *,
- REAL_VALUE_TYPE *, const long *);
-static void encode_c4x_extended (const struct real_format *fmt,
- long *, const REAL_VALUE_TYPE *);
-static void decode_c4x_extended (const struct real_format *,
- REAL_VALUE_TYPE *, const long *);
-
+/* Encode half-precision floats. This routine is used both for the IEEE
+ ARM alternative encodings. */
static void
-encode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
- long *buf, const REAL_VALUE_TYPE *r)
+encode_ieee_half (const struct real_format *fmt, long *buf,
+ const REAL_VALUE_TYPE *r)
{
- unsigned long image, exp, sig;
+ unsigned long image, sig, exp;
+ unsigned long sign = r->sign;
+ bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
+
+ image = sign << 15;
+ sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 11)) & 0x3ff;
switch (r->cl)
{
case rvc_zero:
- exp = -128;
- sig = 0;
break;
case rvc_inf:
- case rvc_nan:
- exp = 127;
- sig = 0x800000 - r->sign;
+ if (fmt->has_inf)
+ image |= 31 << 10;
+ else
+ image |= 0x7fff;
break;
- case rvc_normal:
- exp = REAL_EXP (r) - 1;
- sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
- if (r->sign)
+ case rvc_nan:
+ if (fmt->has_nans)
{
- if (sig)
- sig = -sig;
+ if (r->canonical)
+ sig = (fmt->canonical_nan_lsbs_set ? (1 << 9) - 1 : 0);
+ if (r->signalling == fmt->qnan_msb_set)
+ sig &= ~(1 << 9);
else
- exp--;
- sig |= 0x800000;
+ sig |= 1 << 9;
+ if (sig == 0)
+ sig = 1 << 8;
+
+ image |= 31 << 10;
+ image |= sig;
}
+ else
+ image |= 0x3ff;
+ break;
+
+ case rvc_normal:
+ /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
+ whereas the intermediate representation is 0.F x 2**exp.
+ Which means we're off by one. */
+ if (denormal)
+ exp = 0;
+ else
+ exp = REAL_EXP (r) + 15 - 1;
+ image |= exp << 10;
+ image |= sig;
break;
default:
gcc_unreachable ();
}
- image = ((exp & 0xff) << 24) | (sig & 0xffffff);
buf[0] = image;
}
+/* Decode half-precision floats. This routine is used both for the IEEE
+ ARM alternative encodings. */
static void
-decode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
- REAL_VALUE_TYPE *r, const long *buf)
+decode_ieee_half (const struct real_format *fmt, REAL_VALUE_TYPE *r,
+ const long *buf)
{
- unsigned long image = buf[0];
- unsigned long sig;
- int exp, sf;
-
- exp = (((image >> 24) & 0xff) ^ 0x80) - 0x80;
- sf = ((image & 0xffffff) ^ 0x800000) - 0x800000;
+ unsigned long image = buf[0] & 0xffff;
+ bool sign = (image >> 15) & 1;
+ int exp = (image >> 10) & 0x1f;
memset (r, 0, sizeof (*r));
+ image <<= HOST_BITS_PER_LONG - 11;
+ image &= ~SIG_MSB;
- if (exp != -128)
+ if (exp == 0)
{
- r->cl = rvc_normal;
-
- sig = sf & 0x7fffff;
- if (sf < 0)
+ if (image && fmt->has_denorm)
{
- r->sign = 1;
- if (sig)
- sig = -sig;
- else
- exp++;
+ r->cl = rvc_normal;
+ r->sign = sign;
+ SET_REAL_EXP (r, -14);
+ r->sig[SIGSZ-1] = image << 1;
+ normalize (r);
}
- sig = (sig << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
-
- SET_REAL_EXP (r, exp + 1);
- r->sig[SIGSZ-1] = sig;
+ else if (fmt->has_signed_zero)
+ r->sign = sign;
+ }
+ else if (exp == 31 && (fmt->has_nans || fmt->has_inf))
+ {
+ if (image)
+ {
+ r->cl = rvc_nan;
+ r->sign = sign;
+ r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
+ ^ fmt->qnan_msb_set);
+ r->sig[SIGSZ-1] = image;
+ }
+ else
+ {
+ r->cl = rvc_inf;
+ r->sign = sign;
+ }
+ }
+ else
+ {
+ r->cl = rvc_normal;
+ r->sign = sign;
+ SET_REAL_EXP (r, exp - 15 + 1);
+ r->sig[SIGSZ-1] = image | SIG_MSB;
}
}
+/* Encode arm_bfloat types. */
static void
-encode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
- long *buf, const REAL_VALUE_TYPE *r)
+encode_arm_bfloat_half (const struct real_format *fmt, long *buf,
+ const REAL_VALUE_TYPE *r)
{
- unsigned long exp, sig;
+ unsigned long image, sig, exp;
+ unsigned long sign = r->sign;
+ bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
+
+ image = sign << 15;
+ sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 8)) & 0x7f;
switch (r->cl)
{
case rvc_zero:
- exp = -128;
- sig = 0;
break;
case rvc_inf:
- case rvc_nan:
- exp = 127;
- sig = 0x80000000 - r->sign;
+ if (fmt->has_inf)
+ image |= 255 << 7;
+ else
+ image |= 0x7fff;
break;
- case rvc_normal:
- exp = REAL_EXP (r) - 1;
-
- sig = r->sig[SIGSZ-1];
- if (HOST_BITS_PER_LONG == 64)
- sig = sig >> 1 >> 31;
- sig &= 0x7fffffff;
-
- if (r->sign)
+ case rvc_nan:
+ if (fmt->has_nans)
{
- if (sig)
- sig = -sig;
+ if (r->canonical)
+ sig = (fmt->canonical_nan_lsbs_set ? (1 << 6) - 1 : 0);
+ if (r->signalling == fmt->qnan_msb_set)
+ sig &= ~(1 << 6);
else
- exp--;
- sig |= 0x80000000;
+ sig |= 1 << 6;
+ if (sig == 0)
+ sig = 1 << 5;
+
+ image |= 255 << 7;
+ image |= sig;
}
+ else
+ image |= 0x7fff;
+ break;
+
+ case rvc_normal:
+ if (denormal)
+ exp = 0;
+ else
+ exp = REAL_EXP (r) + 127 - 1;
+ image |= exp << 7;
+ image |= sig;
break;
default:
gcc_unreachable ();
}
- exp = (exp & 0xff) << 24;
- sig &= 0xffffffff;
-
- if (FLOAT_WORDS_BIG_ENDIAN)
- buf[0] = exp, buf[1] = sig;
- else
- buf[0] = sig, buf[0] = exp;
+ buf[0] = image;
}
+/* Decode arm_bfloat types. */
static void
-decode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
- REAL_VALUE_TYPE *r, const long *buf)
+decode_arm_bfloat_half (const struct real_format *fmt, REAL_VALUE_TYPE *r,
+ const long *buf)
{
- unsigned long sig;
- int exp, sf;
-
- if (FLOAT_WORDS_BIG_ENDIAN)
- exp = buf[0], sf = buf[1];
- else
- sf = buf[0], exp = buf[1];
-
- exp = (((exp >> 24) & 0xff) & 0x80) - 0x80;
- sf = ((sf & 0xffffffff) ^ 0x80000000) - 0x80000000;
+ unsigned long image = buf[0] & 0xffff;
+ bool sign = (image >> 15) & 1;
+ int exp = (image >> 7) & 0xff;
memset (r, 0, sizeof (*r));
+ image <<= HOST_BITS_PER_LONG - 8;
+ image &= ~SIG_MSB;
- if (exp != -128)
+ if (exp == 0)
{
- r->cl = rvc_normal;
-
- sig = sf & 0x7fffffff;
- if (sf < 0)
+ if (image && fmt->has_denorm)
{
- r->sign = 1;
- if (sig)
- sig = -sig;
- else
- exp++;
+ r->cl = rvc_normal;
+ r->sign = sign;
+ SET_REAL_EXP (r, -126);
+ r->sig[SIGSZ-1] = image << 1;
+ normalize (r);
}
- if (HOST_BITS_PER_LONG == 64)
- sig = sig << 1 << 31;
- sig |= SIG_MSB;
-
- SET_REAL_EXP (r, exp + 1);
- r->sig[SIGSZ-1] = sig;
+ else if (fmt->has_signed_zero)
+ r->sign = sign;
+ }
+ else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
+ {
+ if (image)
+ {
+ r->cl = rvc_nan;
+ r->sign = sign;
+ r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
+ ^ fmt->qnan_msb_set);
+ r->sig[SIGSZ-1] = image;
+ }
+ else
+ {
+ r->cl = rvc_inf;
+ r->sign = sign;
+ }
+ }
+ else
+ {
+ r->cl = rvc_normal;
+ r->sign = sign;
+ SET_REAL_EXP (r, exp - 127 + 1);
+ r->sig[SIGSZ-1] = image | SIG_MSB;
}
}
-const struct real_format c4x_single_format =
+/* Half-precision format, as specified in IEEE 754R. */
+const struct real_format ieee_half_format =
{
- encode_c4x_single,
- decode_c4x_single,
+ encode_ieee_half,
+ decode_ieee_half,
2,
- 1,
- 24,
- 24,
- -126,
- 128,
- 23,
- -1,
+ 11,
+ 11,
+ -13,
+ 16,
+ 15,
+ 15,
+ 16,
false,
+ true,
+ true,
+ true,
+ true,
+ true,
+ true,
false,
+ "ieee_half"
+ };
+
+/* ARM's alternative half-precision format, similar to IEEE but with
+ no reserved exponent value for NaNs and infinities; rather, it just
+ extends the range of exponents by one. */
+const struct real_format arm_half_format =
+ {
+ encode_ieee_half,
+ decode_ieee_half,
+ 2,
+ 11,
+ 11,
+ -13,
+ 17,
+ 15,
+ 15,
+ 0,
false,
+ true,
false,
false,
- false
+ true,
+ true,
+ false,
+ false,
+ "arm_half"
};
-const struct real_format c4x_extended_format =
+/* ARM Bfloat half-precision format. This format resembles a truncated
+ (16-bit) version of the 32-bit IEEE 754 single-precision floating-point
+ format. */
+const struct real_format arm_bfloat_half_format =
{
- encode_c4x_extended,
- decode_c4x_extended,
+ encode_arm_bfloat_half,
+ decode_arm_bfloat_half,
2,
- 1,
- 32,
- 32,
- -126,
+ 8,
+ 8,
+ -125,
128,
- 31,
- -1,
- false,
- false,
- false,
+ 15,
+ 15,
+ 0,
false,
+ true,
+ true,
+ true,
+ true,
+ true,
+ true,
false,
- false
+ "arm_bfloat_half"
};
\f
encode_internal,
decode_internal,
2,
- 1,
SIGNIFICAND_BITS - 2,
SIGNIFICAND_BITS - 2,
-MAX_EXP,
MAX_EXP,
-1,
-1,
+ 0,
+ false,
+ false,
true,
true,
false,
true,
true,
- false
+ false,
+ "real_internal"
};
\f
-/* Calculate the square root of X in mode MODE, and store the result
- in R. Return TRUE if the operation does not raise an exception.
- For details see "High Precision Division and Square Root",
- Alan H. Karp and Peter Markstein, HP Lab Report 93-93-42, June
- 1993. http://www.hpl.hp.com/techreports/93/HPL-93-42.pdf. */
-
-bool
-real_sqrt (REAL_VALUE_TYPE *r, enum machine_mode mode,
- const REAL_VALUE_TYPE *x)
-{
- static REAL_VALUE_TYPE halfthree;
- static bool init = false;
- REAL_VALUE_TYPE h, t, i;
- int iter, exp;
-
- /* sqrt(-0.0) is -0.0. */
- if (real_isnegzero (x))
- {
- *r = *x;
- return false;
- }
-
- /* Negative arguments return NaN. */
- if (real_isneg (x))
- {
- get_canonical_qnan (r, 0);
- return false;
- }
-
- /* Infinity and NaN return themselves. */
- if (real_isinf (x) || real_isnan (x))
- {
- *r = *x;
- return false;
- }
-
- if (!init)
- {
- do_add (&halfthree, &dconst1, &dconsthalf, 0);
- init = true;
- }
-
- /* Initial guess for reciprocal sqrt, i. */
- exp = real_exponent (x);
- real_ldexp (&i, &dconst1, -exp/2);
-
- /* Newton's iteration for reciprocal sqrt, i. */
- for (iter = 0; iter < 16; iter++)
- {
- /* i(n+1) = i(n) * (1.5 - 0.5*i(n)*i(n)*x). */
- do_multiply (&t, x, &i);
- do_multiply (&h, &t, &i);
- do_multiply (&t, &h, &dconsthalf);
- do_add (&h, &halfthree, &t, 1);
- do_multiply (&t, &i, &h);
-
- /* Check for early convergence. */
- if (iter >= 6 && real_identical (&i, &t))
- break;
-
- /* ??? Unroll loop to avoid copying. */
- i = t;
- }
-
- /* Final iteration: r = i*x + 0.5*i*x*(1.0 - i*(i*x)). */
- do_multiply (&t, x, &i);
- do_multiply (&h, &t, &i);
- do_add (&i, &dconst1, &h, 1);
- do_multiply (&h, &t, &i);
- do_multiply (&i, &dconsthalf, &h);
- do_add (&h, &t, &i, 0);
-
- /* ??? We need a Tuckerman test to get the last bit. */
-
- real_convert (r, mode, &h);
- return true;
-}
-
-/* Calculate X raised to the integer exponent N in mode MODE and store
+/* Calculate X raised to the integer exponent N in format FMT and store
the result in R. Return true if the result may be inexact due to
loss of precision. The algorithm is the classic "left-to-right binary
method" described in section 4.6.3 of Donald Knuth's "Seminumerical
Algorithms", "The Art of Computer Programming", Volume 2. */
bool
-real_powi (REAL_VALUE_TYPE *r, enum machine_mode mode,
+real_powi (REAL_VALUE_TYPE *r, format_helper fmt,
const REAL_VALUE_TYPE *x, HOST_WIDE_INT n)
{
unsigned HOST_WIDE_INT bit;
neg = false;
t = *x;
- bit = (unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1);
+ bit = HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1);
for (i = 0; i < HOST_BITS_PER_WIDE_INT; i++)
{
if (init)
if (neg)
inexact |= do_divide (&t, &dconst1, &t);
- real_convert (r, mode, &t);
+ real_convert (r, fmt, &t);
return inexact;
}
/* Round X to the nearest integer not larger in absolute value, i.e.
- towards zero, placing the result in R in mode MODE. */
+ towards zero, placing the result in R in format FMT. */
void
-real_trunc (REAL_VALUE_TYPE *r, enum machine_mode mode,
+real_trunc (REAL_VALUE_TYPE *r, format_helper fmt,
const REAL_VALUE_TYPE *x)
{
do_fix_trunc (r, x);
- if (mode != VOIDmode)
- real_convert (r, mode, r);
+ if (fmt)
+ real_convert (r, fmt, r);
}
/* Round X to the largest integer not greater in value, i.e. round
- down, placing the result in R in mode MODE. */
+ down, placing the result in R in format FMT. */
void
-real_floor (REAL_VALUE_TYPE *r, enum machine_mode mode,
+real_floor (REAL_VALUE_TYPE *r, format_helper fmt,
const REAL_VALUE_TYPE *x)
{
REAL_VALUE_TYPE t;
do_fix_trunc (&t, x);
if (! real_identical (&t, x) && x->sign)
do_add (&t, &t, &dconstm1, 0);
- if (mode != VOIDmode)
- real_convert (r, mode, &t);
+ if (fmt)
+ real_convert (r, fmt, &t);
else
*r = t;
}
/* Round X to the smallest integer not less then argument, i.e. round
- up, placing the result in R in mode MODE. */
+ up, placing the result in R in format FMT. */
void
-real_ceil (REAL_VALUE_TYPE *r, enum machine_mode mode,
+real_ceil (REAL_VALUE_TYPE *r, format_helper fmt,
const REAL_VALUE_TYPE *x)
{
REAL_VALUE_TYPE t;
do_fix_trunc (&t, x);
if (! real_identical (&t, x) && ! x->sign)
do_add (&t, &t, &dconst1, 0);
- if (mode != VOIDmode)
- real_convert (r, mode, &t);
+ if (fmt)
+ real_convert (r, fmt, &t);
else
*r = t;
}
zero. */
void
-real_round (REAL_VALUE_TYPE *r, enum machine_mode mode,
+real_round (REAL_VALUE_TYPE *r, format_helper fmt,
const REAL_VALUE_TYPE *x)
{
do_add (r, x, &dconsthalf, x->sign);
do_fix_trunc (r, r);
- if (mode != VOIDmode)
- real_convert (r, mode, r);
+ if (fmt)
+ real_convert (r, fmt, r);
+}
+
+/* Return true including 0 if integer part of R is even, else return
+ false. The function is not valid for rvc_inf and rvc_nan classes. */
+
+bool
+is_even (REAL_VALUE_TYPE *r)
+{
+ gcc_assert (r->cl != rvc_inf);
+ gcc_assert (r->cl != rvc_nan);
+
+ if (r->cl == rvc_zero)
+ return true;
+
+ /* For (-1,1), number is even. */
+ if (REAL_EXP (r) <= 0)
+ return true;
+
+ /* Check lowest bit, if not set, return true. */
+ else if (REAL_EXP (r) <= SIGNIFICAND_BITS)
+ {
+ unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r);
+ int w = n / HOST_BITS_PER_LONG;
+
+ unsigned long num = ((unsigned long)1 << (n % HOST_BITS_PER_LONG));
+
+ if ((r->sig[w] & num) == 0)
+ return true;
+ }
+ else
+ return true;
+
+ return false;
+}
+
+/* Return true if R is halfway between two integers, else return
+ false. The function is not valid for rvc_inf and rvc_nan classes. */
+
+bool
+is_halfway_below (const REAL_VALUE_TYPE *r)
+{
+ gcc_assert (r->cl != rvc_inf);
+ gcc_assert (r->cl != rvc_nan);
+ int i;
+
+ if (r->cl == rvc_zero)
+ return false;
+
+ /* For numbers (-0.5,0) and (0,0.5). */
+ if (REAL_EXP (r) < 0)
+ return false;
+
+ else if (REAL_EXP (r) < SIGNIFICAND_BITS)
+ {
+ unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r) - 1;
+ int w = n / HOST_BITS_PER_LONG;
+
+ for (i = 0; i < w; ++i)
+ if (r->sig[i] != 0)
+ return false;
+
+ unsigned long num = ((unsigned long)1 << (n % HOST_BITS_PER_LONG));
+
+ if (((r->sig[w] & num) != 0) && ((r->sig[w] & (num-1)) == 0))
+ return true;
+ }
+ return false;
+}
+
+/* Round X to nearest integer, rounding halfway cases towards even. */
+
+void
+real_roundeven (REAL_VALUE_TYPE *r, format_helper fmt,
+ const REAL_VALUE_TYPE *x)
+{
+ if (is_halfway_below (x))
+ {
+ /* Special case as -0.5 rounds to -0.0 and
+ similarly +0.5 rounds to +0.0. */
+ if (REAL_EXP (x) == 0)
+ {
+ *r = *x;
+ clear_significand_below (r, SIGNIFICAND_BITS);
+ }
+ else
+ {
+ do_add (r, x, &dconsthalf, x->sign);
+ if (!is_even (r))
+ do_add (r, r, &dconstm1, x->sign);
+ }
+ if (fmt)
+ real_convert (r, fmt, r);
+ }
+ else
+ real_round (r, fmt, x);
}
/* Set the sign of R to the sign of X. */
r->sign = x->sign;
}
-/* Convert from REAL_VALUE_TYPE to MPFR. The caller is responsible
- for initializing and clearing the MPFR parameter. */
+/* Check whether the real constant value given is an integer.
+ Returns false for signaling NaN. */
-void
-mpfr_from_real (mpfr_ptr m, const REAL_VALUE_TYPE *r)
+bool
+real_isinteger (const REAL_VALUE_TYPE *c, format_helper fmt)
{
- /* We use a string as an intermediate type. */
- char buf[128];
- int ret;
+ REAL_VALUE_TYPE cint;
- real_to_hexadecimal (buf, r, sizeof (buf), 0, 1);
- /* mpfr_set_str() parses hexadecimal floats from strings in the same
- format that GCC will output them. Nothing extra is needed. */
- ret = mpfr_set_str (m, buf, 16, GMP_RNDN);
- gcc_assert (ret == 0);
+ real_trunc (&cint, fmt, c);
+ return real_identical (c, &cint);
}
-/* Convert from MPFR to REAL_VALUE_TYPE. */
+/* Check whether C is an integer that fits in a HOST_WIDE_INT,
+ storing it in *INT_OUT if so. */
-void
-real_from_mpfr (REAL_VALUE_TYPE *r, mpfr_srcptr m)
+bool
+real_isinteger (const REAL_VALUE_TYPE *c, HOST_WIDE_INT *int_out)
+{
+ REAL_VALUE_TYPE cint;
+
+ HOST_WIDE_INT n = real_to_integer (c);
+ real_from_integer (&cint, VOIDmode, n, SIGNED);
+ if (real_identical (c, &cint))
+ {
+ *int_out = n;
+ return true;
+ }
+ return false;
+}
+
+/* Calculate nextafter (X, Y) or nexttoward (X, Y). Return true if
+ underflow or overflow needs to be raised. */
+
+bool
+real_nextafter (REAL_VALUE_TYPE *r, format_helper fmt,
+ const REAL_VALUE_TYPE *x, const REAL_VALUE_TYPE *y)
{
- /* We use a string as an intermediate type. */
- char buf[128], *rstr;
- mp_exp_t exp;
+ int cmp = do_compare (x, y, 2);
+ /* If either operand is NaN, return qNaN. */
+ if (cmp == 2)
+ {
+ get_canonical_qnan (r, 0);
+ return false;
+ }
+ /* If x == y, return y cast to target type. */
+ if (cmp == 0)
+ {
+ real_convert (r, fmt, y);
+ return false;
+ }
- rstr = mpfr_get_str (NULL, &exp, 16, 0, m, GMP_RNDN);
+ if (x->cl == rvc_zero)
+ {
+ get_zero (r, y->sign);
+ r->cl = rvc_normal;
+ SET_REAL_EXP (r, fmt->emin - fmt->p + 1);
+ r->sig[SIGSZ - 1] = SIG_MSB;
+ return false;
+ }
- /* The additional 12 chars add space for the sprintf below. This
- leaves 6 digits for the exponent which is supposedly enough. */
- gcc_assert (rstr != NULL && strlen (rstr) < sizeof (buf) - 12);
+ int np2 = SIGNIFICAND_BITS - fmt->p;
+ /* For denormals adjust np2 correspondingly. */
+ if (x->cl == rvc_normal && REAL_EXP (x) < fmt->emin)
+ np2 += fmt->emin - REAL_EXP (x);
- /* REAL_VALUE_ATOF expects the exponent for mantissa * 2**exp,
- mpfr_get_str returns the exponent for mantissa * 16**exp, adjust
- for that. */
- exp *= 4;
+ REAL_VALUE_TYPE u;
+ get_zero (r, x->sign);
+ get_zero (&u, 0);
+ set_significand_bit (&u, np2);
+ r->cl = rvc_normal;
+ SET_REAL_EXP (r, REAL_EXP (x));
- if (rstr[0] == '-')
- sprintf (buf, "-0x.%sp%d", &rstr[1], (int) exp);
+ if (x->cl == rvc_inf)
+ {
+ bool borrow = sub_significands (r, r, &u, 0);
+ gcc_assert (borrow);
+ SET_REAL_EXP (r, fmt->emax);
+ }
+ else if (cmp == (x->sign ? 1 : -1))
+ {
+ if (add_significands (r, x, &u))
+ {
+ /* Overflow. Means the significand had been all ones, and
+ is now all zeros. Need to increase the exponent, and
+ possibly re-normalize it. */
+ SET_REAL_EXP (r, REAL_EXP (r) + 1);
+ if (REAL_EXP (r) > fmt->emax)
+ {
+ get_inf (r, x->sign);
+ return true;
+ }
+ r->sig[SIGSZ - 1] = SIG_MSB;
+ }
+ }
else
- sprintf (buf, "0x.%sp%d", rstr, (int) exp);
+ {
+ if (REAL_EXP (x) > fmt->emin && x->sig[SIGSZ - 1] == SIG_MSB)
+ {
+ int i;
+ for (i = SIGSZ - 2; i >= 0; i--)
+ if (x->sig[i])
+ break;
+ if (i < 0)
+ {
+ /* When mantissa is 1.0, we need to subtract only
+ half of u: nextafter (1.0, 0.0) is 1.0 - __DBL_EPSILON__ / 2
+ rather than 1.0 - __DBL_EPSILON__. */
+ clear_significand_bit (&u, np2);
+ np2--;
+ set_significand_bit (&u, np2);
+ }
+ }
+ sub_significands (r, x, &u, 0);
+ }
- mpfr_free_str (rstr);
-
- real_from_string (r, buf);
+ /* Clear out trailing garbage. */
+ clear_significand_below (r, np2);
+ normalize (r);
+ if (REAL_EXP (r) <= fmt->emin - fmt->p)
+ {
+ get_zero (r, x->sign);
+ return true;
+ }
+ return r->cl == rvc_zero || REAL_EXP (r) < fmt->emin;
+}
+
+/* Write into BUF the maximum representable finite floating-point
+ number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
+ float string. LEN is the size of BUF, and the buffer must be large
+ enough to contain the resulting string. If NORM_MAX, instead write
+ the maximum representable finite normalized floating-point number,
+ defined to be such that all choices of digits for that exponent are
+ representable in the format (this only makes a difference for IBM
+ long double). */
+
+void
+get_max_float (const struct real_format *fmt, char *buf, size_t len,
+ bool norm_max)
+{
+ int i, n;
+ char *p;
+ bool is_ibm_extended = fmt->pnan < fmt->p;
+
+ strcpy (buf, "0x0.");
+ n = fmt->p;
+ for (i = 0, p = buf + 4; i + 3 < n; i += 4)
+ *p++ = 'f';
+ if (i < n)
+ *p++ = "08ce"[n - i];
+ sprintf (p, "p%d",
+ (is_ibm_extended && norm_max) ? fmt->emax - 1 : fmt->emax);
+ if (is_ibm_extended && !norm_max)
+ {
+ /* This is an IBM extended double format made up of two IEEE
+ doubles. The value of the long double is the sum of the
+ values of the two parts. The most significant part is
+ required to be the value of the long double rounded to the
+ nearest double. Rounding means we need a slightly smaller
+ value for LDBL_MAX. */
+ buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
+ }
+
+ gcc_assert (strlen (buf) < len);
+}
+
+/* True if all values of integral type can be represented
+ by this floating-point type exactly. */
+
+bool format_helper::can_represent_integral_type_p (tree type) const
+{
+ gcc_assert (! decimal_p () && INTEGRAL_TYPE_P (type));
+
+ /* INT?_MIN is power-of-two so it takes
+ only one mantissa bit. */
+ bool signed_p = TYPE_SIGN (type) == SIGNED;
+ return TYPE_PRECISION (type) - signed_p <= significand_size (*this);
}
-/* Check whether the real constant value given is an integer. */
+/* True if mode M has a NaN representation and
+ the treatment of NaN operands is important. */
bool
-real_isinteger (const REAL_VALUE_TYPE *c, enum machine_mode mode)
+HONOR_NANS (machine_mode m)
{
- REAL_VALUE_TYPE cint;
+ return MODE_HAS_NANS (m) && !flag_finite_math_only;
+}
- real_trunc (&cint, mode, c);
- return real_identical (c, &cint);
+bool
+HONOR_NANS (const_tree t)
+{
+ return HONOR_NANS (element_mode (t));
+}
+
+bool
+HONOR_NANS (const_rtx x)
+{
+ return HONOR_NANS (GET_MODE (x));
+}
+
+/* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs). */
+
+bool
+HONOR_SNANS (machine_mode m)
+{
+ return flag_signaling_nans && HONOR_NANS (m);
+}
+
+bool
+HONOR_SNANS (const_tree t)
+{
+ return HONOR_SNANS (element_mode (t));
+}
+
+bool
+HONOR_SNANS (const_rtx x)
+{
+ return HONOR_SNANS (GET_MODE (x));
+}
+
+/* As for HONOR_NANS, but true if the mode can represent infinity and
+ the treatment of infinite values is important. */
+
+bool
+HONOR_INFINITIES (machine_mode m)
+{
+ return MODE_HAS_INFINITIES (m) && !flag_finite_math_only;
+}
+
+bool
+HONOR_INFINITIES (const_tree t)
+{
+ return HONOR_INFINITIES (element_mode (t));
+}
+
+bool
+HONOR_INFINITIES (const_rtx x)
+{
+ return HONOR_INFINITIES (GET_MODE (x));
+}
+
+/* Like HONOR_NANS, but true if the given mode distinguishes between
+ positive and negative zero, and the sign of zero is important. */
+
+bool
+HONOR_SIGNED_ZEROS (machine_mode m)
+{
+ return MODE_HAS_SIGNED_ZEROS (m) && flag_signed_zeros;
+}
+
+bool
+HONOR_SIGNED_ZEROS (const_tree t)
+{
+ return HONOR_SIGNED_ZEROS (element_mode (t));
+}
+
+bool
+HONOR_SIGNED_ZEROS (const_rtx x)
+{
+ return HONOR_SIGNED_ZEROS (GET_MODE (x));
+}
+
+/* Like HONOR_NANS, but true if given mode supports sign-dependent rounding,
+ and the rounding mode is important. */
+
+bool
+HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode m)
+{
+ return MODE_HAS_SIGN_DEPENDENT_ROUNDING (m) && flag_rounding_math;
+}
+
+bool
+HONOR_SIGN_DEPENDENT_ROUNDING (const_tree t)
+{
+ return HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (t));
+}
+
+bool
+HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx x)
+{
+ return HONOR_SIGN_DEPENDENT_ROUNDING (GET_MODE (x));
+}
+
+/* Fills r with the largest value such that 1 + r*r won't overflow.
+ This is used in both sin (atan (x)) and cos (atan(x)) optimizations. */
+
+void
+build_sinatan_real (REAL_VALUE_TYPE * r, tree type)
+{
+ REAL_VALUE_TYPE maxval;
+ mpfr_t mpfr_const1, mpfr_c, mpfr_maxval;
+ machine_mode mode = TYPE_MODE (type);
+ const struct real_format * fmt = REAL_MODE_FORMAT (mode);
+
+ real_maxval (&maxval, 0, mode);
+
+ mpfr_inits (mpfr_const1, mpfr_c, mpfr_maxval, NULL);
+
+ mpfr_from_real (mpfr_const1, &dconst1, MPFR_RNDN);
+ mpfr_from_real (mpfr_maxval, &maxval, MPFR_RNDN);
+
+ mpfr_sub (mpfr_c, mpfr_maxval, mpfr_const1, MPFR_RNDN);
+ mpfr_sqrt (mpfr_c, mpfr_c, MPFR_RNDZ);
+
+ real_from_mpfr (r, mpfr_c, fmt, MPFR_RNDZ);
+
+ mpfr_clears (mpfr_const1, mpfr_c, mpfr_maxval, NULL);
}