CbC/CbC_gcc: gcc/real.c comparison

comparison gcc/real.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* real.c - software floating point emulation.
-Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
+Copyright (C) 1993-2017 Free Software Foundation, Inc.
-2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
-Free Software Foundation, Inc.
 Contributed by Stephen L. Moshier (moshier@world.std.com).
 Re-written by Richard Henderson <rth@redhat.com>
 This file is part of GCC.
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
+#include "rtl.h"
 #include "tree.h"
-#include "diagnostic-core.h"
-#include "real.h"
 #include "realmpfr.h"
-#include "tm_p.h"
 #include "dfp.h"
 /* The floating point model used internally is not exactly IEEE 754
 compliant, and close to the description in the ISO C99 standard,
 section 5.2.4.2.2 Characteristics of floating types.
 E must be large enough to hold the smallest supported denormal number
 in a normalized form.
 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 26.
+denormal number fits in 17 exponent bits; we store 26.  */
-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.  */
 /* Used to classify two numbers simultaneously.  */
 #define CLASS2(A, B)  ((A) << 2 | (B))
 case CLASS2 (rvc_nan, rvc_nan):
 /* ANY + NaN = NaN.  */
 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_normal, rvc_zero):
 case CLASS2 (rvc_inf, rvc_zero):
 case CLASS2 (rvc_nan, rvc_inf):
 /* NaN + ANY = NaN.  */
 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):
 if (subtract_p)
 	/* Inf - Inf = NaN.  */
 case CLASS2 (rvc_normal, rvc_nan):
 case CLASS2 (rvc_inf, rvc_nan):
 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_zero):
 case CLASS2 (rvc_nan, rvc_normal):
 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_zero, rvc_inf):
 case CLASS2 (rvc_inf, rvc_zero):
 case CLASS2 (rvc_normal, rvc_nan):
 case CLASS2 (rvc_inf, rvc_nan):
 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_zero):
 case CLASS2 (rvc_nan, rvc_normal):
 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_inf, rvc_normal):
 /* Inf / R = Inf.  */
 default:
 gcc_unreachable ();
 }
+if (a->decimal || b->decimal)
+return decimal_do_compare (a, b, nan_result);
 if (a->sign != b->sign)
 return -a->sign - -b->sign;
-if (a->decimal || b->decimal)
-return decimal_do_compare (a, b, nan_result);
 if (REAL_EXP (a) > REAL_EXP (b))
 ret = 1;
 else if (REAL_EXP (a) < REAL_EXP (b))
 ret = -1;
 switch (r->cl)
 {
 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:
 if (r->decimal)
 	{
 	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
 	*r = *op1;
 break;
 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
 	*r = *op0;
 break;
 REAL_VALUE_TYPE r;
 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 = (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:
 return do_compare (op0, op1, -1) > 0;
 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:
 return op0->cl == rvc_nan || op1->cl == rvc_nan;
 case ORDERED_EXPR:
 switch (r->cl)
 {
 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:
 exp += REAL_EXP (op0);
 if (exp > MAX_EXP)
 real_isnan (const REAL_VALUE_TYPE *r)
 {
 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 false;
 return true;
 }
-/* Try to change R into its exact multiplicative inverse in machine
+/* Try to change R into its exact multiplicative inverse in format FMT.
-mode MODE.  Return true if successful.  */
+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;
 int i;
 if (r->sig[i] != 0)
 return false;
 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)
 return false;
 for (i = 0; i < SIGSZ-1; ++i)
 /* 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 (enum machine_mode imode, enum machine_mode tmode)
+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
 return 0;
 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;
 case rvc_normal:
 default:
 gcc_unreachable ();
 }
 }
-/* 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,
+wide_int
-		  const REAL_VALUE_TYPE *r)
+real_to_integer (const REAL_VALUE_TYPE *r, bool *fail, int precision)
 {
-REAL_VALUE_TYPE t;
+HOST_WIDE_INT val[2 * WIDE_INT_MAX_ELTS];
-HOST_WIDE_INT low, high;
 int exp;
+int words, w;
+wide_int result;
 switch (r->cl)
 {
 case rvc_zero:
 underflow:
-low = high = 0;
+return wi::zero (precision);
-break;
 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
-	{
+	return ~wi::set_bit_in_zero (precision - 1, precision);
-	  high--;
-	  low = -1;
-	}
-break;
 case rvc_normal:
 if (r->decimal)
-	{
+	return decimal_real_to_integer (r, fail, precision);
-	  decimal_real_to_integer2 (plow, phigh, r);
-	  return;
-	}
 exp = REAL_EXP (r);
 if (exp <= 0)
 	goto underflow;
 /* Only force overflow for unsigned overflow.  Signed overflow is
 	 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);
+/* Put the significand into a wide_int that has precision W, which
-if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
+	 is the smallest HWI-multiple that has at least PRECISION bits.
-	{
+	 This ensures that the top bit of the significand is in the
-	  high = t.sig[SIGSZ-1];
+	 top bit of the wide_int.  */
-	  low = t.sig[SIGSZ-2];
+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++)
+	{
+	  int j = SIGSZ - words + i;
+	  val[i] = (j < 0) ? 0 : r->sig[j];
+	}
+#else
+gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
+for (int i = 0; i < words; i++)
+	{
+	  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)
+	return -result;
 else
-	{
+	return result;
-	  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];
-	}
-if (r->sign)
-	{
-	  if (low == 0)
-	    high = -high;
-	  else
-	    low = -low, high = ~high;
-	}
-break;
 default:
 gcc_unreachable ();
 }
-*plow = low;
-*phigh = high;
 }
 /* A subroutine of real_to_decimal.  Compute the quotient and remainder
 of NUM / DEN.  Return the quotient and place the remainder in NUM.
 It is expected that NUM / DEN are close enough that the quotient is
 #define M_LOG10_2	0.30102999566398119521
 void
 real_to_decimal_for_mode (char *str, const REAL_VALUE_TYPE *r_orig,
 			  size_t buf_size, size_t digits,
-			  int crop_trailing_zeros, enum machine_mode mode)
+			  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;
 last--;
 /* Append the exponent.  */
 sprintf (last, "e%+d", dec_exp);
-#ifdef ENABLE_CHECKING
 /* Verify that we can read the original value back in.  */
-if (mode != VOIDmode)
+if (flag_checking && mode != VOIDmode)
 {
 real_from_string (&r, str);
 real_convert (&r, mode, &r);
 gcc_assert (real_identical (&r, r_orig));
 }
-#endif
 }
 /* Likewise, except always uses round-to-nearest.  */
 void
 normalize (r);
 }
 else
 {
 /* Decimal floating point.  */
-const REAL_VALUE_TYPE *ten = ten_to_ptwo (0);
+const char *cstr = str;
-int d;
+mpfr_t m;
+bool inexact;
-while (*str == '0')
-	str++;
+while (*cstr == '0')
-while (ISDIGIT (*str))
+	cstr++;
-	{
+if (*cstr == '.')
-	  d = *str++ - '0';
+	{
-	  do_multiply (r, r, ten);
+	  cstr++;
-	  if (d)
+	  while (*cstr == '0')
-	    do_add (r, r, real_digit (d), 0);
+	    cstr++;
-	}
-if (*str == '.')
-	{
-	  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--;
-	    }
 	}
 /* If the mantissa is zero, ignore the exponent.  */
-if (r->cl == rvc_zero)
+if (!ISDIGIT (*cstr))
 	goto is_a_zero;
-if (*str == 'e' || *str == 'E')
+/* Nonzero value, possibly overflowing or underflowing.  */
-	{
+mpfr_init2 (m, SIGNIFICAND_BITS);
-	  bool exp_neg = false;
+inexact = mpfr_strtofr (m, str, NULL, 10, GMP_RNDZ);
+/* The result should never be a NaN, and because the rounding is
-	  str++;
+	 toward zero should never be an infinity.  */
-	  if (*str == '-')
+gcc_assert (!mpfr_nan_p (m) && !mpfr_inf_p (m));
-	    {
+if (mpfr_zero_p (m) || mpfr_get_exp (m) < -MAX_EXP + 4)
-	      exp_neg = true;
+	{
-	      str++;
+	  mpfr_clear (m);
-	    }
+	  goto underflow;
-	  else if (*str == '+')
+	}
-	    str++;
+else if (mpfr_get_exp (m) > MAX_EXP - 4)
+	{
-	  d = 0;
+	  mpfr_clear (m);
-	  while (ISDIGIT (*str))
+	  goto overflow;
-	    {
+	}
-	      d *= 10;
+else
-	      d += *str - '0';
+	{
-	      if (d > MAX_EXP)
+	  real_from_mpfr (r, m, NULL_TREE, GMP_RNDZ);
-		{
+	  /* 1 to 3 bits may have been shifted off (with a sticky bit)
-		  /* Overflowed the exponent.  */
+	     because the hex digits used in real_from_mpfr did not
-		  if (exp_neg)
+	     start with a digit 8 to f, but the exponent bounds above
-		    goto underflow;
+	     should have avoided underflow or overflow.  */
-		  else
+	  gcc_assert (r->cl == rvc_normal);
-		    goto overflow;
+	  /* Set a sticky bit if mpfr_strtofr was inexact.  */
-		}
+	  r->sig[0] |= inexact;
-	      str++;
+	  mpfr_clear (m);
-	    }
+	}
-	  if (exp_neg)
-	    d = -d;
-	  exp += d;
-	}
-if (exp)
-	times_pten (r, exp);
 }
 r->sign = sign;
 return 0;
 }
 /* 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)
+if (fmt)
-real_convert (&r, mode, &r);
+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)
+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)
+if (fmt)
-real_convert (r, mode, r);
+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,
+real_from_integer (REAL_VALUE_TYPE *r, format_helper fmt,
-		   unsigned HOST_WIDE_INT low, HOST_WIDE_INT high,
+		   const wide_int_ref &val_in, signop sgn)
-		   int unsigned_p)
+{
-{
+if (val_in == 0)
-if (low == 0 && high == 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;
+r->sign = wi::neg_p (val_in, sgn);
-SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT);
+/* 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;
-	  high = ~high;
-	  if (low == 0)
+/* Ensure a multiple of HOST_BITS_PER_WIDE_INT, ceiling, as elt
-	    high += 1;
+	 won't work with precisions that are not a multiple of
-	  else
+	 HOST_BITS_PER_WIDE_INT.  */
-	    low = -low;
+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)
+	{
+	  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)
-	{
+	for (i = len - 1; i >= 0; i--)
-	  r->sig[SIGSZ-1] = high;
+	  {
-	  r->sig[SIGSZ-2] = low;
+	    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;
+	  for (i = len - 1; i >= 0; i--)
-	  r->sig[SIGSZ-2] = high;
+	    {
-	  r->sig[SIGSZ-3] = low >> (HOST_BITS_PER_LONG - 1) >> 1;
+	      HOST_WIDE_INT e = val.elt (i);
-	  r->sig[SIGSZ-4] = low;
+	      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 (DECIMAL_FLOAT_MODE_P (mode))
+if (fmt.decimal_p ())
 decimal_from_integer (r);
-else if (mode != VOIDmode)
+if (fmt)
-real_convert (r, mode, r);
+real_convert (r, fmt, r);
 }
 /* Render R, an integral value, as a floating point constant with no
 specified exponent.  */
 	  int i;
 	  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
 	{
 	  const REAL_VALUE_TYPE *t = ten_to_ptwo (n - 1);
 	  do_multiply (&tens[n], t, t);
 gcc_assert (n >= 0);
 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];
 }
 /* Multiply R by 10**EXP.  */
 }
 return &value;
 }
-/* Returns the special REAL_VALUE_TYPE corresponding to 1/3.  */
+/* Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n.  */
-const REAL_VALUE_TYPE *
+#define CACHED_FRACTION(NAME, N)					\
-dconst_third_ptr (void)
+const REAL_VALUE_TYPE *						\
-{
+NAME (void)								\
-static REAL_VALUE_TYPE value;
+{									\
+static REAL_VALUE_TYPE value;					\
-/* Initialize mathematical constants for constant folding builtins.
+									\
-These constants need to be given to at least 160 bits precision.  */
+/* Initialize mathematical constants for constant folding builtins.	\
-if (value.cl == rvc_zero)
+These constants need to be given to at least 160 bits		\
-{
+precision.  */							\
-real_arithmetic (&value, RDIV_EXPR, &dconst1, real_digit (3));
+if (value.cl == rvc_zero)						\
-}
+real_arithmetic (&value, RDIV_EXPR, &dconst1, real_digit (N));	\
-return &value;
+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)
 is parsed as a number and placed in the significand.  Return true
 if the string was successfully parsed.  */
 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)
 	get_canonical_qnan (r, 0);
 else
 lshift_significand (r, r, SIGNIFICAND_BITS - fmt->pnan);
 /* 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;
 }
 return true;
 }
 /* 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
-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);
 }
 /* Fills R with 2**N.  */
 void
-real_2expN (REAL_VALUE_TYPE *r, int n, enum machine_mode fmode)
+real_2expN (REAL_VALUE_TYPE *r, int n, format_helper fmt)
 {
 memset (r, 0, sizeof (*r));
 n++;
 if (n > MAX_EXP)
 {
 r->cl = rvc_normal;
 SET_REAL_EXP (r, n);
 r->sig[SIGSZ-1] = SIG_MSB;
 }
-if (DECIMAL_FLOAT_MODE_P (fmode))
+if (fmt.decimal_p ())
-decimal_real_convert (r, fmode, r);
+decimal_real_convert (r, fmt, r);
 }
 static void
 round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
 	}
 /* FIXME. We can come here via fp_easy_constant
 	 (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;
 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;
 return;
 /* Clear out trailing garbage.  */
 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;
 if (REAL_EXP (a) <= emin2m1)
 return false;
-/* After conversion to the new mode, the value must be identical.  */
+/* After conversion to the new format, the value must be identical.  */
-real_convert (&t, mode, a);
+real_convert (&t, fmt, a);
 return real_identical (&t, a);
 }
 /* Write R to the given target format.  Place 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.
 Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE.  */
 long
-real_to_target_fmt (long *buf, const REAL_VALUE_TYPE *r_orig,
+real_to_target (long *buf, const REAL_VALUE_TYPE *r_orig,
-		    const struct real_format *fmt)
+		format_helper fmt)
 {
 REAL_VALUE_TYPE r;
 long buf1;
 r = *r_orig;
 (*fmt->encode) (fmt, buf, &r);
 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,
+real_from_target (REAL_VALUE_TYPE *r, const long *buf, format_helper fmt)
-		      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)
-{
-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;
 }
 case rvc_zero:
 case rvc_inf:
 return h;
 case rvc_normal:
-h |= REAL_EXP (r) << 3;
+h |= (unsigned int)REAL_EXP (r) << 3;
 break;
 case rvc_nan:
 if (r->signalling)
 	h ^= (unsigned int)-1;
 default:
 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];
 	h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2));
 }
 24,
 -125,
 128,
 31,
 31,
-false,
+32,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+true,
+false,
+"ieee_single"
 };
 const struct real_format mips_single_format =
 {
 encode_ieee_single,
 24,
 -125,
 128,
 31,
 31,
-false,
+32,
-true,
+false,
 true,
 true,
 true,
 true,
-false,
+true,
-true
+false,
+true,
+"mips_single"
 };
 const struct real_format motorola_single_format =
 {
 encode_ieee_single,
 24,
 -125,
 128,
 31,
 31,
-false,
+32,
-true,
+false,
 true,
 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
 24,
 -125,
 129,
 31,
 31,
-true,
+0,
-false,
+true,
 false,
 false,
-true,
+false,
 true,
-false,
+true,
-false
+false,
+false,
+"spu_single"
 };
 /* IEEE double-precision format.  */
 static void encode_ieee_double (const struct real_format *fmt,
 53,
 -1021,
 1024,
 63,
 63,
-false,
+64,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+true,
+false,
+"ieee_double"
 };
 const struct real_format mips_double_format =
 {
 encode_ieee_double,
 53,
 -1021,
 1024,
 63,
 63,
-false,
+64,
-true,
+false,
 true,
 true,
 true,
 true,
-false,
+true,
-true
+false,
+true,
+"mips_double"
 };
 const struct real_format motorola_double_format =
 {
 encode_ieee_double,
 53,
 -1021,
 1024,
 63,
 63,
-false,
+64,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-true
+true,
+true,
+"motorola_double"
 };
 /* IEEE extended real format.  This comes in three flavors: Intel's as
 a 12 byte image, Intel's as a 16 byte image, and Motorola's.  Intel
 12- and 16-byte images may be big- or little endian; Motorola's is
 			       const REAL_VALUE_TYPE *r)
 {
 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
 elements 0 and 1 of intermed, and the exponent entirely within
 element 2, so all we have to do is swap the order around, and
 64,
 -16382,
 16384,
 95,
 95,
-false,
+0,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-true
+true,
+true,
+"ieee_extended_motorola"
 };
 const struct real_format ieee_extended_intel_96_format =
 {
 encode_ieee_extended_intel_96,
 64,
 -16381,
 16384,
 79,
 79,
-false,
+65,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+true,
+false,
+"ieee_extended_intel_96"
 };
 const struct real_format ieee_extended_intel_128_format =
 {
 encode_ieee_extended_intel_128,
 64,
 -16381,
 16384,
 79,
 79,
-false,
+65,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+true,
+false,
+"ieee_extended_intel_128"
 };
 /* The following caters to i386 systems that set the rounding precision
 to 53 bits instead of 64, e.g. FreeBSD.  */
 const struct real_format ieee_extended_intel_96_round_53_format =
 53,
 -16381,
 16384,
 79,
 79,
-false,
+33,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+true,
+false,
+"ieee_extended_intel_96_round_53"
 };
 /* IBM 128-bit extended precision format: a pair of IEEE double precision
 numbers whose sum is equal to the extended precision value.  The number
 with greater magnitude is first.  This format has the same magnitude
 53,
 -1021 + 53,
 1024,
 127,
 -1,
-false,
+0,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+true,
+false,
+"ibm_extended"
 };
 const struct real_format mips_extended_format =
 {
 encode_ibm_extended,
 53,
 -1021 + 53,
 1024,
 127,
 -1,
-false,
+0,
-true,
+false,
 true,
 true,
 true,
 true,
-false,
+true,
-true
+false,
+true,
+"mips_extended"
 };
 /* IEEE quad precision format.  */
 113,
 -16381,
 16384,
 127,
 127,
-false,
+128,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+true,
+false,
+"ieee_quad"
 };
 const struct real_format mips_quad_format =
 {
 encode_ieee_quad,
 113,
 -16381,
 16384,
 127,
 127,
-false,
+128,
-true,
+false,
 true,
 true,
 true,
 true,
-false,
+true,
-true
+false,
+true,
+"mips_quad"
 };
 /* Descriptions of VAX floating point formats can be found beginning at
 http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
 24,
 -127,
 127,
 15,
 15,
-false,
+0,
 false,
 false,
 false,
 false,
 false,
 false,
-false
+false,
+false,
+"vax_f"
 };
 const struct real_format vax_d_format =
 {
 encode_vax_d,
 56,
 -127,
 127,
 15,
 15,
-false,
+0,
 false,
 false,
 false,
 false,
 false,
 false,
-false
+false,
+false,
+"vax_d"
 };
 const struct real_format vax_g_format =
 {
 encode_vax_g,
 53,
 -1023,
 1023,
 15,
 15,
-false,
+0,
 false,
 false,
 false,
 false,
 false,
 false,
-false
+false,
+false,
+"vax_g"
 };
 /* Encode real R into a single precision DFP value in BUF.  */
 static void
 encode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 7,
 -94,
 97,
 31,
 31,
-false,
+32,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+true,
+false,
+"decimal_single"
 };
 /* Double precision decimal floating point (IEEE 754). */
 const struct real_format decimal_double_format =
 {
 16,
 -382,
 385,
 63,
 63,
-false,
+64,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+true,
+false,
+"decimal_double"
 };
 /* Quad precision decimal floating point (IEEE 754). */
 const struct real_format decimal_quad_format =
 {
 34,
 -6142,
 6145,
 127,
 127,
-false,
+128,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+true,
+false,
+"decimal_quad"
 };
 /* Encode half-precision floats.  This routine is used both for the IEEE
 ARM alternative encodings.  */
 static void
 11,
 -13,
 16,
 15,
 15,
-false,
+16,
-true,
+false,
 true,
 true,
 true,
 true,
 true,
-false
+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.  */
 11,
 -13,
 17,
 15,
 15,
-false,
+0,
-true,
+false,
-false,
+true,
 false,
-true,
+false,
 true,
-false,
+true,
-false
+false,
+false,
+"arm_half"
 };
 /* A synthetic "format" for internal arithmetic.  It's the size of the
 internal significand minus the two bits needed for proper rounding.
 The encode and decode routines exist only to satisfy our paranoia
 SIGNIFICAND_BITS - 2,
 -MAX_EXP,
 MAX_EXP,
 -1,
 -1,
-false,
+0,
 false,
-true,
+false,
 true,
-false,
+true,
-true,
+false,
 true,
-false
+true,
+false,
+"real_internal"
 };
-/* Calculate the square root of X in mode MODE, and store the result
+/* Calculate X raised to the integer exponent N in format FMT and store
-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_isfinite (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
 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;
 REAL_VALUE_TYPE t;
 bool inexact = false;
 }
 else
 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)
 	{
 	  inexact |= do_multiply (&t, &t, &t);
 }
 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)
+if (fmt)
-real_convert (r, mode, r);
+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)
+if (fmt)
-real_convert (r, mode, &t);
+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)
+if (fmt)
-real_convert (r, mode, &t);
+real_convert (r, fmt, &t);
 else
 *r = t;
 }
 /* Round X to the nearest integer, but round halfway cases away from
 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)
+if (fmt)
-real_convert (r, mode, r);
+real_convert (r, fmt, r);
 }
 /* Set the sign of R to the sign of X.  */
 void
 real_copysign (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *x)
 {
 r->sign = x->sign;
 }
-/* Check whether the real constant value given is an integer.  */
+/* Check whether the real constant value given is an integer.
+Returns false for signaling NaN.  */
 bool
-real_isinteger (const REAL_VALUE_TYPE *c, enum machine_mode mode)
+real_isinteger (const REAL_VALUE_TYPE *c, format_helper fmt)
 {
 REAL_VALUE_TYPE cint;
-real_trunc (&cint, mode, c);
+real_trunc (&cint, fmt, c);
 return real_identical (c, &cint);
+}
+/* Check whether C is an integer that fits in a HOST_WIDE_INT,
+storing it in *INT_OUT if so.  */
+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;
 }
 /* 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
 buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
 }
 gcc_assert (strlen (buf) < len);
 }
+/* True if mode M has a NaN representation and
+the treatment of NaN operands is important.  */
+bool
+HONOR_NANS (machine_mode m)
+{
+return MODE_HAS_NANS (m) && !flag_finite_math_only;
+}
+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));
+}

Mercurial > hg > CbC > CbC_gcc

comparison gcc/real.c @ 111:04ced10e8804