GCC 4.2.0 release.

1 files changed, 539 insertions, 255 deletions

diff --git a/contrib/gcc/real.c b/contrib/gcc/real.c
index 843725e..420a045 100644
--- a/contrib/gcc/real.c
+++ b/contrib/gcc/real.c
@@ -1,6 +1,6 @@
 /* real.c - software floating point emulation.
    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2002, 2003, 2004 Free Software Foundation, Inc.
+   2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
    Contributed by Stephen L. Moshier (moshier@world.std.com).
    Re-written by Richard Henderson <rth@redhat.com>
 
@@ -18,8 +18,8 @@
 
    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, 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.  */
+   Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
 #include "config.h"
 #include "system.h"
@@ -29,6 +29,7 @@
 #include "toplev.h"
 #include "real.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,
@@ -138,7 +139,7 @@ static inline void
 get_canonical_qnan (REAL_VALUE_TYPE *r, int sign)
 {
   memset (r, 0, sizeof (*r));
-  r->class = rvc_nan;
+  r->cl = rvc_nan;
   r->sign = sign;
   r->canonical = 1;
 }
@@ -147,7 +148,7 @@ static inline void
 get_canonical_snan (REAL_VALUE_TYPE *r, int sign)
 {
   memset (r, 0, sizeof (*r));
-  r->class = rvc_nan;
+  r->cl = rvc_nan;
   r->sign = sign;
   r->signalling = 1;
   r->canonical = 1;
@@ -157,7 +158,7 @@ static inline void
 get_inf (REAL_VALUE_TYPE *r, int sign)
 {
   memset (r, 0, sizeof (*r));
-  r->class = rvc_inf;
+  r->cl = rvc_inf;
   r->sign = sign;
 }
 
@@ -480,6 +481,9 @@ normalize (REAL_VALUE_TYPE *r)
   int shift = 0, exp;
   int i, j;
 
+  if (r->decimal)
+    return;
+
   /* Find the first word that is nonzero.  */
   for (i = SIGSZ - 1; i >= 0; i--)
     if (r->sig[i] == 0)
@@ -490,8 +494,8 @@ normalize (REAL_VALUE_TYPE *r)
   /* Zero significand flushes to zero.  */
   if (i < 0)
     {
-      r->class = rvc_zero;
-      r->exp = 0;
+      r->cl = rvc_zero;
+      SET_REAL_EXP (r, 0);
       return;
     }
 
@@ -503,14 +507,14 @@ normalize (REAL_VALUE_TYPE *r)
 
   if (shift > 0)
     {
-      exp = r->exp - shift;
+      exp = REAL_EXP (r) - shift;
       if (exp > MAX_EXP)
 	get_inf (r, r->sign);
       else if (exp < -MAX_EXP)
 	get_zero (r, r->sign);
       else
 	{
-	  r->exp = exp;
+	  SET_REAL_EXP (r, exp);
 	  lshift_significand (r, r, shift);
 	}
     }
@@ -531,7 +535,7 @@ do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
   sign = a->sign;
   subtract_p = (sign ^ b->sign) ^ subtract_p;
 
-  switch (CLASS2 (a->class, b->class))
+  switch (CLASS2 (a->cl, b->cl))
     {
     case CLASS2 (rvc_zero, rvc_zero):
       /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0.  */
@@ -577,11 +581,11 @@ do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   /* Swap the arguments such that A has the larger exponent.  */
-  dexp = a->exp - b->exp;
+  dexp = REAL_EXP (a) - REAL_EXP (b);
   if (dexp < 0)
     {
       const REAL_VALUE_TYPE *t;
@@ -589,7 +593,7 @@ do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
       dexp = -dexp;
       sign ^= subtract_p;
     }
-  exp = a->exp;
+  exp = REAL_EXP (a);
 
   /* If the exponents are not identical, we need to shift the
      significand of B down.  */
@@ -637,19 +641,20 @@ do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
 	}
     }
 
-  r->class = rvc_normal;
+  r->cl = rvc_normal;
   r->sign = sign;
-  r->exp = exp;
+  SET_REAL_EXP (r, exp);
   /* Zero out the remaining fields.  */
   r->signalling = 0;
   r->canonical = 0;
+  r->decimal = 0;
 
   /* Re-normalize the result.  */
   normalize (r);
 
   /* Special case: if the subtraction results in zero, the result
      is positive.  */
-  if (r->class == rvc_zero)
+  if (r->cl == rvc_zero)
     r->sign = 0;
   else
     r->sig[0] |= inexact;
@@ -668,7 +673,7 @@ do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
   int sign = a->sign ^ b->sign;
   bool inexact = false;
 
-  switch (CLASS2 (a->class, b->class))
+  switch (CLASS2 (a->cl, b->cl))
     {
     case CLASS2 (rvc_zero, rvc_zero):
     case CLASS2 (rvc_zero, rvc_normal):
@@ -711,7 +716,7 @@ do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   if (r == a || r == b)
@@ -751,8 +756,8 @@ do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
 
       for (j = 0; j < 2; ++j)
 	{
-	  int exp = (a->exp - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2)
-		     + (b->exp - (1-j)*(HOST_BITS_PER_LONG/2)));
+	  int exp = (REAL_EXP (a) - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2)
+		     + (REAL_EXP (b) - (1-j)*(HOST_BITS_PER_LONG/2)));
 
 	  if (exp > MAX_EXP)
 	    {
@@ -767,8 +772,8 @@ do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
 	    }
 
 	  memset (&u, 0, sizeof (u));
-	  u.class = rvc_normal;
-	  u.exp = exp;
+	  u.cl = rvc_normal;
+	  SET_REAL_EXP (&u, exp);
 
 	  for (k = j; k < SIGSZ * 2; k += 2)
 	    {
@@ -803,7 +808,7 @@ do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
   REAL_VALUE_TYPE t, *rr;
   bool inexact;
 
-  switch (CLASS2 (a->class, b->class))
+  switch (CLASS2 (a->cl, b->cl))
     {
     case CLASS2 (rvc_zero, rvc_zero):
       /* 0 / 0 = NaN.  */
@@ -853,7 +858,7 @@ do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   if (r == a || r == b)
@@ -863,10 +868,10 @@ do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
 
   /* Make sure all fields in the result are initialized.  */
   get_zero (rr, 0);
-  rr->class = rvc_normal;
+  rr->cl = rvc_normal;
   rr->sign = sign;
 
-  exp = a->exp - b->exp + 1;
+  exp = REAL_EXP (a) - REAL_EXP (b) + 1;
   if (exp > MAX_EXP)
     {
       get_inf (r, sign);
@@ -877,7 +882,7 @@ do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
       get_zero (r, sign);
       return true;
     }
-  rr->exp = exp;
+  SET_REAL_EXP (rr, exp);
 
   inexact = div_significands (rr, a, b);
 
@@ -900,7 +905,7 @@ do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
 {
   int ret;
 
-  switch (CLASS2 (a->class, b->class))
+  switch (CLASS2 (a->cl, b->cl))
     {
     case CLASS2 (rvc_zero, rvc_zero):
       /* Sign of zero doesn't matter for compares.  */
@@ -932,15 +937,18 @@ do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   if (a->sign != b->sign)
     return -a->sign - -b->sign;
 
-  if (a->exp > b->exp)
+  if (a->decimal || b->decimal)
+    return decimal_do_compare (a, b, nan_result);
+
+  if (REAL_EXP (a) > REAL_EXP (b))
     ret = 1;
-  else if (a->exp < b->exp)
+  else if (REAL_EXP (a) < REAL_EXP (b))
     ret = -1;
   else
     ret = cmp_significands (a, b);
@@ -955,7 +963,7 @@ do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
 {
   *r = *a;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
     case rvc_inf:
@@ -963,46 +971,51 @@ do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
       break;
 
     case rvc_normal:
-      if (r->exp <= 0)
+      if (r->decimal)
+	{
+	  decimal_do_fix_trunc (r, a);
+	  return;
+	}
+      if (REAL_EXP (r) <= 0)
 	get_zero (r, r->sign);
-      else if (r->exp < SIGNIFICAND_BITS)
-	clear_significand_below (r, SIGNIFICAND_BITS - r->exp);
+      else if (REAL_EXP (r) < SIGNIFICAND_BITS)
+	clear_significand_below (r, SIGNIFICAND_BITS - REAL_EXP (r));
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
 /* Perform the binary or unary operation described by CODE.
-   For a unary operation, leave OP1 NULL.  */
+   For a unary operation, leave OP1 NULL.  This function returns
+   true if the result may be inexact due to loss of precision.  */
 
-void
+bool
 real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
 		 const REAL_VALUE_TYPE *op1)
 {
   enum tree_code code = icode;
 
+  if (op0->decimal || (op1 && op1->decimal))
+    return decimal_real_arithmetic (r, icode, op0, op1);
+
   switch (code)
     {
     case PLUS_EXPR:
-      do_add (r, op0, op1, 0);
-      break;
+      return do_add (r, op0, op1, 0);
 
     case MINUS_EXPR:
-      do_add (r, op0, op1, 1);
-      break;
+      return do_add (r, op0, op1, 1);
 
     case MULT_EXPR:
-      do_multiply (r, op0, op1);
-      break;
+      return do_multiply (r, op0, op1);
 
     case RDIV_EXPR:
-      do_divide (r, op0, op1);
-      break;
+      return do_divide (r, op0, op1);
 
     case MIN_EXPR:
-      if (op1->class == rvc_nan)
+      if (op1->cl == rvc_nan)
 	*r = *op1;
       else if (do_compare (op0, op1, -1) < 0)
 	*r = *op0;
@@ -1011,7 +1024,7 @@ real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
       break;
 
     case MAX_EXPR:
-      if (op1->class == rvc_nan)
+      if (op1->cl == rvc_nan)
 	*r = *op1;
       else if (do_compare (op0, op1, 1) < 0)
 	*r = *op1;
@@ -1034,8 +1047,9 @@ real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
+  return false;
 }
 
 /* Legacy.  Similar, but return the result directly.  */
@@ -1070,9 +1084,9 @@ real_compare (int icode, const REAL_VALUE_TYPE *op0,
     case NE_EXPR:
       return do_compare (op0, op1, -1) != 0;
     case UNORDERED_EXPR:
-      return op0->class == rvc_nan || op1->class == rvc_nan;
+      return op0->cl == rvc_nan || op1->cl == rvc_nan;
     case ORDERED_EXPR:
-      return op0->class != rvc_nan && op1->class != rvc_nan;
+      return op0->cl != rvc_nan && op1->cl != rvc_nan;
     case UNLT_EXPR:
       return do_compare (op0, op1, -1) < 0;
     case UNLE_EXPR:
@@ -1083,9 +1097,11 @@ real_compare (int icode, const REAL_VALUE_TYPE *op0,
       return do_compare (op0, op1, 1) >= 0;
     case UNEQ_EXPR:
       return do_compare (op0, op1, 0) == 0;
+    case LTGT_EXPR:
+      return do_compare (op0, op1, 0) != 0;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -1094,7 +1110,7 @@ real_compare (int icode, const REAL_VALUE_TYPE *op0,
 int
 real_exponent (const REAL_VALUE_TYPE *r)
 {
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       return 0;
@@ -1102,9 +1118,9 @@ real_exponent (const REAL_VALUE_TYPE *r)
     case rvc_nan:
       return (unsigned int)-1 >> 1;
     case rvc_normal:
-      return r->exp;
+      return REAL_EXP (r);
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -1114,7 +1130,7 @@ void
 real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
 {
   *r = *op0;
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
     case rvc_inf:
@@ -1122,17 +1138,17 @@ real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
       break;
 
     case rvc_normal:
-      exp += op0->exp;
+      exp += REAL_EXP (op0);
       if (exp > MAX_EXP)
 	get_inf (r, r->sign);
       else if (exp < -MAX_EXP)
 	get_zero (r, r->sign);
       else
-	r->exp = exp;
+	SET_REAL_EXP (r, exp);
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -1141,7 +1157,7 @@ real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
 bool
 real_isinf (const REAL_VALUE_TYPE *r)
 {
-  return (r->class == rvc_inf);
+  return (r->cl == rvc_inf);
 }
 
 /* Determine whether a floating-point value X is a NaN.  */
@@ -1149,7 +1165,7 @@ real_isinf (const REAL_VALUE_TYPE *r)
 bool
 real_isnan (const REAL_VALUE_TYPE *r)
 {
-  return (r->class == rvc_nan);
+  return (r->cl == rvc_nan);
 }
 
 /* Determine whether a floating-point value X is negative.  */
@@ -1165,7 +1181,7 @@ real_isneg (const REAL_VALUE_TYPE *r)
 bool
 real_isnegzero (const REAL_VALUE_TYPE *r)
 {
-  return r->sign && r->class == rvc_zero;
+  return r->sign && r->cl == rvc_zero;
 }
 
 /* Compare two floating-point objects for bitwise identity.  */
@@ -1175,19 +1191,21 @@ real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
 {
   int i;
 
-  if (a->class != b->class)
+  if (a->cl != b->cl)
     return false;
   if (a->sign != b->sign)
     return false;
 
-  switch (a->class)
+  switch (a->cl)
     {
     case rvc_zero:
     case rvc_inf:
       return true;
 
     case rvc_normal:
-      if (a->exp != b->exp)
+      if (a->decimal != b->decimal)
+        return false;
+      if (REAL_EXP (a) != REAL_EXP (b))
 	return false;
       break;
 
@@ -1200,7 +1218,7 @@ real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   for (i = 0; i < SIGSZ; ++i)
@@ -1220,7 +1238,7 @@ exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
   REAL_VALUE_TYPE u;
   int i;
 
-  if (r->class != rvc_normal)
+  if (r->cl != rvc_normal)
     return false;
 
   /* Check for a power of two: all significand bits zero except the MSB.  */
@@ -1235,7 +1253,7 @@ exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
   real_convert (&u, mode, &u);
 
   /* The rounding may have overflowed.  */
-  if (u.class != rvc_normal)
+  if (u.cl != rvc_normal)
     return false;
   for (i = 0; i < SIGSZ-1; ++i)
     if (u.sig[i] != 0)
@@ -1254,7 +1272,7 @@ real_to_integer (const REAL_VALUE_TYPE *r)
 {
   unsigned HOST_WIDE_INT i;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
     underflow:
@@ -1269,34 +1287,36 @@ real_to_integer (const REAL_VALUE_TYPE *r)
       return i;
 
     case rvc_normal:
-      if (r->exp <= 0)
+      if (r->decimal)
+	return decimal_real_to_integer (r);
+
+      if (REAL_EXP (r) <= 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 (r->exp > HOST_BITS_PER_WIDE_INT)
+      if (REAL_EXP (r) > HOST_BITS_PER_WIDE_INT)
 	goto overflow;
 
       if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
 	i = r->sig[SIGSZ-1];
-      else if (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG)
+      else 
 	{
+	  gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
 	  i = r->sig[SIGSZ-1];
 	  i = i << (HOST_BITS_PER_LONG - 1) << 1;
 	  i |= r->sig[SIGSZ-2];
 	}
-      else
-	abort ();
 
-      i >>= HOST_BITS_PER_WIDE_INT - r->exp;
+      i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
 
       if (r->sign)
 	i = -i;
       return i;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -1310,7 +1330,7 @@ real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
   HOST_WIDE_INT low, high;
   int exp;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
     underflow:
@@ -1331,7 +1351,13 @@ real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
       break;
 
     case rvc_normal:
-      exp = r->exp;
+      if (r->decimal)
+	{ 
+	  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
@@ -1347,8 +1373,9 @@ real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
 	  high = t.sig[SIGSZ-1];
 	  low = t.sig[SIGSZ-2];
 	}
-      else if (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG)
+      else 
 	{
+	  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];
@@ -1357,8 +1384,6 @@ real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
 	  low = low << (HOST_BITS_PER_LONG - 1) << 1;
 	  low |= t.sig[SIGSZ-4];
 	}
-      else
-	abort ();
 
       if (r->sign)
 	{
@@ -1370,7 +1395,7 @@ real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   *plow = low;
@@ -1386,7 +1411,7 @@ static unsigned long
 rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den)
 {
   unsigned long q, msb;
-  int expn = num->exp, expd = den->exp;
+  int expn = REAL_EXP (num), expd = REAL_EXP (den);
 
   if (expn < expd)
     return 0;
@@ -1407,7 +1432,7 @@ rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den)
     }
   while (--expn >= expd);
 
-  num->exp = expd;
+  SET_REAL_EXP (num, expd);
   normalize (num);
 
   return q;
@@ -1432,7 +1457,7 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
   bool sign;
 
   r = *r_orig;
-  switch (r.class)
+  switch (r.cl)
     {
     case rvc_zero:
       strcpy (str, (r.sign ? "-0.0" : "0.0"));
@@ -1447,7 +1472,13 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
       strcpy (str, (r.sign ? "-NaN" : "+NaN"));
       return;
     default:
-      abort ();
+      gcc_unreachable ();
+    }
+
+  if (r.decimal)
+    {
+      decimal_real_to_decimal (str, &r, buf_size, digits, crop_trailing_zeros);
+      return;
     }
 
   /* Bound the number of digits printed by the size of the representation.  */
@@ -1458,14 +1489,13 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
   /* Estimate the decimal exponent, and compute the length of the string it
      will print as.  Be conservative and add one to account for possible
      overflow or rounding error.  */
-  dec_exp = r.exp * M_LOG10_2;
+  dec_exp = REAL_EXP (&r) * M_LOG10_2;
   for (max_digits = 1; dec_exp ; max_digits++)
     dec_exp /= 10;
 
   /* Bound the number of digits printed by the size of the output buffer.  */
   max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
-  if (max_digits > buf_size)
-    abort ();
+  gcc_assert (max_digits <= buf_size);
   if (digits > max_digits)
     digits = max_digits;
 
@@ -1487,7 +1517,7 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
 	 and strip trailing decimal zeros.  */
 
       u = r;
-      u.exp = SIGNIFICAND_BITS - 1;
+      SET_REAL_EXP (&u, SIGNIFICAND_BITS - 1);
 
       /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS.  */
       m = floor_log2 (max_digits);
@@ -1511,15 +1541,16 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
       while (--m >= 0);
 
       /* Revert the scaling to integer that we performed earlier.  */
-      u.exp += r.exp - (SIGNIFICAND_BITS - 1);
+      SET_REAL_EXP (&u, REAL_EXP (&u) + REAL_EXP (&r)
+		    - (SIGNIFICAND_BITS - 1));
       r = u;
 
       /* Find power of 10.  Do this by dividing out 10**2**M when
 	 this is larger than the current remainder.  Fill PTEN with
 	 the power of 10 that we compute.  */
-      if (r.exp > 0)
+      if (REAL_EXP (&r) > 0)
 	{
-	  m = floor_log2 ((int)(r.exp * M_LOG10_2)) + 1;
+	  m = floor_log2 ((int)(REAL_EXP (&r) * M_LOG10_2)) + 1;
 	  do
 	    {
 	      const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
@@ -1555,7 +1586,7 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
 	  do_multiply (&u, &v, ten);
 
 	  /* Stop if we're now >= 1.  */
-	  if (u.exp > 0)
+	  if (REAL_EXP (&u) > 0)
 	    break;
 
 	  v = u;
@@ -1566,7 +1597,7 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
       /* Find power of 10.  Do this by multiplying in P=10**2**M when
 	 the current remainder is smaller than 1/P.  Fill PTEN with the
 	 power of 10 that we compute.  */
-      m = floor_log2 ((int)(-r.exp * M_LOG10_2)) + 1;
+      m = floor_log2 ((int)(-REAL_EXP (&r) * M_LOG10_2)) + 1;
       do
 	{
 	  const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
@@ -1607,8 +1638,7 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
       do_multiply (&r, &r, ten);
       digit = rtd_divmod (&r, &pten);
       dec_exp -= 1;
-      if (digit == 0)
-	abort ();
+      gcc_assert (digit != 0);
     }
 
   /* ... or overflow.  */
@@ -1619,10 +1649,11 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
 	*p++ = '0';
       dec_exp += 1;
     }
-  else if (digit > 10)
-    abort ();
   else
-    *p++ = digit + '0';
+    {
+      gcc_assert (digit <= 10);
+      *p++ = digit + '0';
+    }
 
   /* Generate subsequent digits.  */
   while (--digits > 0)
@@ -1693,12 +1724,12 @@ void
 real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
 		     size_t digits, int crop_trailing_zeros)
 {
-  int i, j, exp = r->exp;
+  int i, j, exp = REAL_EXP (r);
   char *p, *first;
   char exp_buf[16];
   size_t max_digits;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       exp = 0;
@@ -1713,7 +1744,14 @@ real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
       strcpy (str, (r->sign ? "-NaN" : "+NaN"));
       return;
     default:
-      abort ();
+      gcc_unreachable ();
+    }
+
+  if (r->decimal)
+    {
+      /* Hexadecimal format for decimal floats is not interesting. */
+      strcpy (str, "N/A");
+      return;
     }
 
   if (digits == 0)
@@ -1723,8 +1761,7 @@ real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
 
   sprintf (exp_buf, "p%+d", exp);
   max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1;
-  if (max_digits > buf_size)
-    abort ();
+  gcc_assert (max_digits <= buf_size);
   if (digits > max_digits)
     digits = max_digits;
 
@@ -1792,6 +1829,10 @@ real_from_string (REAL_VALUE_TYPE *r, const char *str)
 		|= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
 	      pos -= 4;
 	    }
+	  else if (d)
+	    /* Ensure correct rounding by setting last bit if there is
+	       a subsequent nonzero digit.  */
+	    r->sig[0] |= 1;
 	  exp += 4;
 	  str++;
 	}
@@ -1814,9 +1855,18 @@ real_from_string (REAL_VALUE_TYPE *r, const char *str)
 		    |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
 		  pos -= 4;
 		}
+	      else if (d)
+		/* Ensure correct rounding by setting last bit if there is
+		   a subsequent nonzero digit.  */
+		r->sig[0] |= 1;
 	      str++;
 	    }
 	}
+
+      /* If the mantissa is zero, ignore the exponent.  */
+      if (!cmp_significand_0 (r))
+	goto underflow;
+
       if (*str == 'p' || *str == 'P')
 	{
 	  bool exp_neg = false;
@@ -1851,8 +1901,8 @@ real_from_string (REAL_VALUE_TYPE *r, const char *str)
 	  exp += d;
 	}
 
-      r->class = rvc_normal;
-      r->exp = exp;
+      r->cl = rvc_normal;
+      SET_REAL_EXP (r, exp);
 
       normalize (r);
     }
@@ -1874,7 +1924,7 @@ real_from_string (REAL_VALUE_TYPE *r, const char *str)
       if (*str == '.')
 	{
 	  str++;
-	  if (r->class == rvc_zero)
+	  if (r->cl == rvc_zero)
 	    {
 	      while (*str == '0')
 		str++, exp--;
@@ -1889,6 +1939,10 @@ real_from_string (REAL_VALUE_TYPE *r, const char *str)
 	    }
 	}
 
+      /* If the mantissa is zero, ignore the exponent.  */
+      if (r->cl == rvc_zero)
+	goto underflow;
+
       if (*str == 'e' || *str == 'E')
 	{
 	  bool exp_neg = false;
@@ -1952,6 +2006,20 @@ real_from_string2 (const char *s, enum machine_mode mode)
   return r;
 }
 
+/* Initialize R from string S and desired MODE. */
+
+void 
+real_from_string3 (REAL_VALUE_TYPE *r, const char *s, enum machine_mode mode)
+{
+  if (DECIMAL_FLOAT_MODE_P (mode))
+    decimal_real_from_string (r, s);
+  else
+    real_from_string (r, s);
+
+  if (mode != VOIDmode)
+    real_convert (r, mode, r);  
+} 
+
 /* Initialize R from the integer pair HIGH+LOW.  */
 
 void
@@ -1964,9 +2032,9 @@ real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
   else
     {
       memset (r, 0, sizeof (*r));
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = high < 0 && !unsigned_p;
-      r->exp = 2 * HOST_BITS_PER_WIDE_INT;
+      SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT);
 
       if (r->sign)
 	{
@@ -1982,15 +2050,14 @@ real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
 	  r->sig[SIGSZ-1] = high;
 	  r->sig[SIGSZ-2] = low;
 	}
-      else if (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT)
+      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;
 	}
-      else
-	abort ();
 
       normalize (r);
     }
@@ -2006,10 +2073,10 @@ ten_to_ptwo (int n)
 {
   static REAL_VALUE_TYPE tens[EXP_BITS];
 
-  if (n < 0 || n >= EXP_BITS)
-    abort ();
+  gcc_assert (n >= 0);
+  gcc_assert (n < EXP_BITS);
 
-  if (tens[n].class == rvc_zero)
+  if (tens[n].cl == rvc_zero)
     {
       if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
 	{
@@ -2038,10 +2105,10 @@ ten_to_mptwo (int n)
 {
   static REAL_VALUE_TYPE tens[EXP_BITS];
 
-  if (n < 0 || n >= EXP_BITS)
-    abort ();
+  gcc_assert (n >= 0);
+  gcc_assert (n < EXP_BITS);
 
-  if (tens[n].class == rvc_zero)
+  if (tens[n].cl == rvc_zero)
     do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
 
   return &tens[n];
@@ -2054,10 +2121,10 @@ real_digit (int n)
 {
   static REAL_VALUE_TYPE num[10];
 
-  if (n < 0 || n > 9)
-    abort ();
+  gcc_assert (n >= 0);
+  gcc_assert (n <= 9);
 
-  if (n > 0 && num[n].class == rvc_zero)
+  if (n > 0 && num[n].cl == rvc_zero)
     real_from_integer (&num[n], VOIDmode, n, 0, 1);
 
   return &num[n];
@@ -2109,8 +2176,7 @@ real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
   const struct real_format *fmt;
 
   fmt = REAL_MODE_FORMAT (mode);
-  if (fmt == NULL)
-    abort ();
+  gcc_assert (fmt);
 
   if (*str == 0)
     {
@@ -2122,23 +2188,26 @@ real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
   else
     {
       int base = 10, d;
-      bool neg = false;
 
       memset (r, 0, sizeof (*r));
-      r->class = rvc_nan;
+      r->cl = rvc_nan;
 
       /* Parse akin to strtol into the significand of R.  */
 
       while (ISSPACE (*str))
 	str++;
       if (*str == '-')
-	str++, neg = true;
+	str++;
       else if (*str == '+')
 	str++;
       if (*str == '0')
 	{
-	  if (*++str == 'x')
-	    str++, base = 16;
+	  str++;
+	  if (*str == 'x' || *str == 'X')
+	    {
+	      base = 16;
+	      str++;
+	    }
 	  else
 	    base = 8;
 	}
@@ -2161,7 +2230,7 @@ real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
 	      add_significands (r, r, &u);
 	      break;
 	    default:
-	      abort ();
+	      gcc_unreachable ();
 	    }
 
 	  get_zero (&u, 0);
@@ -2199,18 +2268,30 @@ real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
   int np2;
 
   fmt = REAL_MODE_FORMAT (mode);
-  if (fmt == NULL)
-    abort ();
+  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);
 
-  r->class = rvc_normal;
-  r->sign = sign;
-  r->signalling = 0;
-  r->canonical = 0;
-  r->exp = fmt->emax * fmt->log2_b;
+      np2 = SIGNIFICAND_BITS - fmt->p * fmt->log2_b;
+      memset (r->sig, -1, SIGSZ * sizeof (unsigned long));
+      clear_significand_below (r, np2);
 
-  np2 = SIGNIFICAND_BITS - fmt->p * fmt->log2_b;
-  memset (r->sig, -1, SIGSZ * sizeof (unsigned long));
-  clear_significand_below (r, np2);
+      if (fmt->pnan < fmt->p)
+	/* 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.  */
+        clear_significand_bit (r, SIGNIFICAND_BITS - fmt->pnan);
+    }
 }
 
 /* Fills R with 2**N.  */
@@ -2222,13 +2303,13 @@ real_2expN (REAL_VALUE_TYPE *r, int n)
 
   n++;
   if (n > MAX_EXP)
-    r->class = rvc_inf;
+    r->cl = rvc_inf;
   else if (n < -MAX_EXP)
     ;
   else
     {
-      r->class = rvc_normal;
-      r->exp = n;
+      r->cl = rvc_normal;
+      SET_REAL_EXP (r, n);
       r->sig[SIGSZ-1] = SIG_MSB;
     }
 }
@@ -2242,12 +2323,26 @@ round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
   bool guard, lsb;
   int emin2m1, emax2;
 
+  if (r->decimal)
+    {
+      if (fmt->b == 10)
+	{
+	  decimal_round_for_format (fmt, r);
+	  return;
+	}
+      /* 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);
+    }
+
   p2 = fmt->p * fmt->log2_b;
   emin2m1 = (fmt->emin - 1) * fmt->log2_b;
   emax2 = fmt->emax * fmt->log2_b;
 
   np2 = SIGNIFICAND_BITS - p2;
-  switch (r->class)
+  switch (r->cl)
     {
     underflow:
       get_zero (r, r->sign);
@@ -2269,45 +2364,48 @@ round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   /* If we're not base2, normalize the exponent to a multiple of
      the true base.  */
   if (fmt->log2_b != 1)
     {
-      int shift = r->exp & (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);
-	  r->exp += 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 (r->exp > emax2)
+  if (REAL_EXP (r) > emax2)
     goto overflow;
-  else if (r->exp <= emin2m1)
+  else if (REAL_EXP (r) <= emin2m1)
     {
       int diff;
 
       if (!fmt->has_denorm)
 	{
 	  /* Don't underflow completely until we've had a chance to round.  */
-	  if (r->exp < emin2m1)
+	  if (REAL_EXP (r) < emin2m1)
 	    goto underflow;
 	}
       else
 	{
-	  diff = emin2m1 - r->exp + 1;
+	  diff = emin2m1 - REAL_EXP (r) + 1;
 	  if (diff > p2)
 	    goto underflow;
 
 	  /* De-normalize the significand.  */
 	  r->sig[0] |= sticky_rshift_significand (r, r, diff);
-	  r->exp += diff;
+	  SET_REAL_EXP (r, REAL_EXP (r) + diff);
 	}
     }
 
@@ -2336,19 +2434,20 @@ round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
 	  /* Overflow.  Means the significand had been all ones, and
 	     is now all zeros.  Need to increase the exponent, and
 	     possibly re-normalize it.  */
-	  if (++r->exp > emax2)
+	  SET_REAL_EXP (r, REAL_EXP (r) + 1);
+	  if (REAL_EXP (r) > emax2)
 	    goto overflow;
 	  r->sig[SIGSZ-1] = SIG_MSB;
 
 	  if (fmt->log2_b != 1)
 	    {
-	      int shift = r->exp & (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);
-		  r->exp += shift;
-		  if (r->exp > emax2)
+		  SET_REAL_EXP (r, REAL_EXP (r) + shift);
+		  if (REAL_EXP (r) > emax2)
 		    goto overflow;
 		}
 	    }
@@ -2356,7 +2455,7 @@ round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
     }
 
   /* Catch underflow that we deferred until after rounding.  */
-  if (r->exp <= emin2m1)
+  if (REAL_EXP (r) <= emin2m1)
     goto underflow;
 
   /* Clear out trailing garbage.  */
@@ -2372,14 +2471,17 @@ real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
   const struct real_format *fmt;
 
   fmt = REAL_MODE_FORMAT (mode);
-  if (fmt == NULL)
-    abort ();
+  gcc_assert (fmt);
 
   *r = *a;
+
+  if (a->decimal || fmt->b == 10)
+    decimal_real_convert (r, mode, a);
+
   round_for_format (fmt, r);
 
   /* round_for_format de-normalizes denormals.  Undo just that part.  */
-  if (r->class == rvc_normal)
+  if (r->cl == rvc_normal)
     normalize (r);
 }
 
@@ -2398,7 +2500,19 @@ real_value_truncate (enum machine_mode mode, REAL_VALUE_TYPE a)
 bool
 exact_real_truncate (enum machine_mode mode, 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;
+  if (REAL_EXP (a) <= emin2m1)
+    return false;
+
+  /* After conversion to the new mode, the value must be identical.  */
   real_convert (&t, mode, a);
   return real_identical (&t, a);
 }
@@ -2434,8 +2548,7 @@ real_to_target (long *buf, const REAL_VALUE_TYPE *r, enum machine_mode mode)
   const struct real_format *fmt;
 
   fmt = REAL_MODE_FORMAT (mode);
-  if (fmt == NULL)
-    abort ();
+  gcc_assert (fmt);
 
   return real_to_target_fmt (buf, r, fmt);
 }
@@ -2459,13 +2572,13 @@ real_from_target (REAL_VALUE_TYPE *r, const long *buf, enum machine_mode mode)
   const struct real_format *fmt;
 
   fmt = REAL_MODE_FORMAT (mode);
-  if (fmt == NULL)
-    abort ();
+  gcc_assert (fmt);
 
   (*fmt->decode) (fmt, r, buf);
 }
 
-/* Return the number of bits in the significand for MODE.  */
+/* Return the number of bits of the largest binary value that the
+   significand of MODE will hold.  */
 /* ??? Legacy.  Should get access to real_format directly.  */
 
 int
@@ -2477,6 +2590,15 @@ significand_size (enum machine_mode 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
+	 than the number of bits required to hold the largest coefficient
+	 of this mode.  */
+      double log2_10 = 3.3219281;
+      return fmt->p * log2_10;
+    }
   return fmt->p * fmt->log2_b;
 }
 
@@ -2490,15 +2612,15 @@ real_hash (const REAL_VALUE_TYPE *r)
   unsigned int h;
   size_t i;
 
-  h = r->class | (r->sign << 2);
-  switch (r->class)
+  h = r->cl | (r->sign << 2);
+  switch (r->cl)
     {
     case rvc_zero:
     case rvc_inf:
       return h;
 
     case rvc_normal:
-      h |= r->exp << 3;
+      h |= REAL_EXP (r) << 3;
       break;
 
     case rvc_nan:
@@ -2509,7 +2631,7 @@ real_hash (const REAL_VALUE_TYPE *r)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   if (sizeof(unsigned long) > sizeof(unsigned int))
@@ -2543,7 +2665,7 @@ encode_ieee_single (const struct real_format *fmt, long *buf,
   image = sign << 31;
   sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       break;
@@ -2587,13 +2709,13 @@ encode_ieee_single (const struct real_format *fmt, long *buf,
       if (denormal)
 	exp = 0;
       else
-      exp = r->exp + 127 - 1;
+      exp = REAL_EXP (r) + 127 - 1;
       image |= exp << 23;
       image |= sig;
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   buf[0] = image;
@@ -2615,9 +2737,9 @@ decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if (image && fmt->has_denorm)
 	{
-	  r->class = rvc_normal;
+	  r->cl = rvc_normal;
 	  r->sign = sign;
-	  r->exp = -126;
+	  SET_REAL_EXP (r, -126);
 	  r->sig[SIGSZ-1] = image << 1;
 	  normalize (r);
 	}
@@ -2628,7 +2750,7 @@ decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if (image)
 	{
-	  r->class = rvc_nan;
+	  r->cl = rvc_nan;
 	  r->sign = sign;
 	  r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
 			   ^ fmt->qnan_msb_set);
@@ -2636,15 +2758,15 @@ decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 	}
       else
 	{
-	  r->class = rvc_inf;
+	  r->cl = rvc_inf;
 	  r->sign = sign;
 	}
     }
   else
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
-      r->exp = exp - 127 + 1;
+      SET_REAL_EXP (r, exp - 127 + 1);
       r->sig[SIGSZ-1] = image | SIG_MSB;
     }
 }
@@ -2660,6 +2782,7 @@ const struct real_format ieee_single_format =
     -125,
     128,
     31,
+    31,
     true,
     true,
     true,
@@ -2678,6 +2801,7 @@ const struct real_format mips_single_format =
     -125,
     128,
     31,
+    31,
     true,
     true,
     true,
@@ -2717,7 +2841,7 @@ encode_ieee_double (const struct real_format *fmt, long *buf,
       sig_hi = (sig_hi >> 11) & 0xfffff;
     }
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       break;
@@ -2771,14 +2895,14 @@ encode_ieee_double (const struct real_format *fmt, long *buf,
       if (denormal)
 	exp = 0;
       else
-	exp = r->exp + 1023 - 1;
+	exp = REAL_EXP (r) + 1023 - 1;
       image_hi |= exp << 20;
       image_hi |= sig_hi;
       image_lo = sig_lo;
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   if (FLOAT_WORDS_BIG_ENDIAN)
@@ -2816,9 +2940,9 @@ decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if ((image_hi || image_lo) && fmt->has_denorm)
 	{
-	  r->class = rvc_normal;
+	  r->cl = rvc_normal;
 	  r->sign = sign;
-	  r->exp = -1022;
+	  SET_REAL_EXP (r, -1022);
 	  if (HOST_BITS_PER_LONG == 32)
 	    {
 	      image_hi = (image_hi << 1) | (image_lo >> 31);
@@ -2840,7 +2964,7 @@ decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if (image_hi || image_lo)
 	{
-	  r->class = rvc_nan;
+	  r->cl = rvc_nan;
 	  r->sign = sign;
 	  r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set;
 	  if (HOST_BITS_PER_LONG == 32)
@@ -2853,15 +2977,15 @@ decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 	}
       else
 	{
-	  r->class = rvc_inf;
+	  r->cl = rvc_inf;
 	  r->sign = sign;
 	}
     }
   else
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
-      r->exp = exp - 1023 + 1;
+      SET_REAL_EXP (r, exp - 1023 + 1);
       if (HOST_BITS_PER_LONG == 32)
 	{
 	  r->sig[SIGSZ-1] = image_hi | SIG_MSB;
@@ -2883,6 +3007,7 @@ const struct real_format ieee_double_format =
     -1021,
     1024,
     63,
+    63,
     true,
     true,
     true,
@@ -2901,6 +3026,7 @@ const struct real_format mips_double_format =
     -1021,
     1024,
     63,
+    63,
     true,
     true,
     true,
@@ -2927,7 +3053,7 @@ encode_ieee_extended (const struct real_format *fmt, long *buf,
   image_hi = r->sign << 15;
   sig_hi = sig_lo = 0;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       break;
@@ -2985,7 +3111,7 @@ encode_ieee_extended (const struct real_format *fmt, long *buf,
 
     case rvc_normal:
       {
-	int exp = r->exp;
+	int exp = REAL_EXP (r);
 
 	/* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
 	   whereas the intermediate representation is 0.F x 2**exp.
@@ -3001,8 +3127,7 @@ encode_ieee_extended (const struct real_format *fmt, long *buf,
 	else
 	  {
 	    exp += 16383 - 1;
-	    if (exp < 0)
-	      abort ();
+	    gcc_assert (exp >= 0);
 	  }
 	image_hi |= exp;
 
@@ -3021,7 +3146,7 @@ encode_ieee_extended (const struct real_format *fmt, long *buf,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
@@ -3105,7 +3230,7 @@ decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if ((sig_hi || sig_lo) && fmt->has_denorm)
 	{
-	  r->class = rvc_normal;
+	  r->cl = rvc_normal;
 	  r->sign = sign;
 
 	  /* When the IEEE format contains a hidden bit, we know that
@@ -3113,7 +3238,7 @@ decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 	     and decrease the exponent to match.  In this case, Motorola
 	     defines the explicit integer bit to be valid, so we don't
 	     know whether the msb is set or not.  */
-	  r->exp = fmt->emin;
+	  SET_REAL_EXP (r, fmt->emin);
 	  if (HOST_BITS_PER_LONG == 32)
 	    {
 	      r->sig[SIGSZ-1] = sig_hi;
@@ -3136,7 +3261,7 @@ decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 
       if (sig_hi || sig_lo)
 	{
-	  r->class = rvc_nan;
+	  r->cl = rvc_nan;
 	  r->sign = sign;
 	  r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set;
 	  if (HOST_BITS_PER_LONG == 32)
@@ -3149,15 +3274,15 @@ decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 	}
       else
 	{
-	  r->class = rvc_inf;
+	  r->cl = rvc_inf;
 	  r->sign = sign;
 	}
     }
   else
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
-      r->exp = exp - 16383 + 1;
+      SET_REAL_EXP (r, exp - 16383 + 1);
       if (HOST_BITS_PER_LONG == 32)
 	{
 	  r->sig[SIGSZ-1] = sig_hi;
@@ -3231,6 +3356,7 @@ const struct real_format ieee_extended_motorola_format =
     -16382,
     16384,
     95,
+    95,
     true,
     true,
     true,
@@ -3249,6 +3375,7 @@ const struct real_format ieee_extended_intel_96_format =
     -16381,
     16384,
     79,
+    79,
     true,
     true,
     true,
@@ -3267,6 +3394,7 @@ const struct real_format ieee_extended_intel_128_format =
     -16381,
     16384,
     79,
+    79,
     true,
     true,
     true,
@@ -3287,6 +3415,7 @@ const struct real_format ieee_extended_intel_96_round_53_format =
     -16381,
     16384,
     79,
+    79,
     true,
     true,
     true,
@@ -3300,8 +3429,7 @@ const struct real_format ieee_extended_intel_96_round_53_format =
    range as an IEEE double precision value, but effectively 106 bits of
    significand precision.  Infinity and NaN are represented by their IEEE
    double precision value stored in the first number, the second number is
-   ignored.  Zeroes, Infinities, and NaNs are set in both doubles
-   due to precedent.  */
+   +0.0 or -0.0 for Infinity and don't-care for NaN.  */
 
 static void encode_ibm_extended (const struct real_format *fmt,
 				 long *, const REAL_VALUE_TYPE *);
@@ -3319,7 +3447,7 @@ encode_ibm_extended (const struct real_format *fmt, long *buf,
 
   /* Renormlize R before doing any arithmetic on it.  */
   normr = *r;
-  if (normr.class == rvc_normal)
+  if (normr.cl == rvc_normal)
     normalize (&normr);
 
   /* u = IEEE double precision portion of significand.  */
@@ -3327,7 +3455,7 @@ encode_ibm_extended (const struct real_format *fmt, long *buf,
   round_for_format (base_fmt, &u);
   encode_ieee_double (base_fmt, &buf[0], &u);
 
-  if (u.class == rvc_normal)
+  if (u.cl == rvc_normal)
     {
       do_add (&v, &normr, &u, 1);
       /* Call round_for_format since we might need to denormalize.  */
@@ -3353,7 +3481,7 @@ decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_
   base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
   decode_ieee_double (base_fmt, &u, &buf[0]);
 
-  if (u.class != rvc_zero && u.class != rvc_inf && u.class != rvc_nan)
+  if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan)
     {
       decode_ieee_double (base_fmt, &v, &buf[2]);
       do_add (r, &u, &v, 0);
@@ -3372,6 +3500,7 @@ const struct real_format ibm_extended_format =
     53,
     -1021 + 53,
     1024,
+    127,
     -1,
     true,
     true,
@@ -3390,6 +3519,7 @@ const struct real_format mips_extended_format =
     53,
     -1021 + 53,
     1024,
+    127,
     -1,
     true,
     true,
@@ -3421,7 +3551,7 @@ encode_ieee_quad (const struct real_format *fmt, long *buf,
 
   rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       break;
@@ -3496,7 +3626,7 @@ encode_ieee_quad (const struct real_format *fmt, long *buf,
       if (denormal)
 	exp = 0;
       else
-	exp = r->exp + 16383 - 1;
+	exp = REAL_EXP (r) + 16383 - 1;
       image3 |= exp << 16;
 
       if (HOST_BITS_PER_LONG == 32)
@@ -3518,7 +3648,7 @@ encode_ieee_quad (const struct real_format *fmt, long *buf,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   if (FLOAT_WORDS_BIG_ENDIAN)
@@ -3573,10 +3703,10 @@ decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
 	{
-	  r->class = rvc_normal;
+	  r->cl = rvc_normal;
 	  r->sign = sign;
 
-	  r->exp = -16382 + (SIGNIFICAND_BITS - 112);
+	  SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
 	  if (HOST_BITS_PER_LONG == 32)
 	    {
 	      r->sig[0] = image0;
@@ -3599,7 +3729,7 @@ decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if (image3 | image2 | image1 | image0)
 	{
-	  r->class = rvc_nan;
+	  r->cl = rvc_nan;
 	  r->sign = sign;
 	  r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set;
 
@@ -3619,15 +3749,15 @@ decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 	}
       else
 	{
-	  r->class = rvc_inf;
+	  r->cl = rvc_inf;
 	  r->sign = sign;
 	}
     }
   else
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
-      r->exp = exp - 16383 + 1;
+      SET_REAL_EXP (r, exp - 16383 + 1);
 
       if (HOST_BITS_PER_LONG == 32)
 	{
@@ -3657,6 +3787,7 @@ const struct real_format ieee_quad_format =
     -16381,
     16384,
     127,
+    127,
     true,
     true,
     true,
@@ -3675,6 +3806,7 @@ const struct real_format mips_quad_format =
     -16381,
     16384,
     127,
+    127,
     true,
     true,
     true,
@@ -3713,7 +3845,7 @@ encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
 
   sign = r->sign << 15;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       image = 0;
@@ -3726,7 +3858,7 @@ encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
 
     case rvc_normal:
       sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
-      exp = r->exp + 128;
+      exp = REAL_EXP (r) + 128;
 
       image = (sig << 16) & 0xffff0000;
       image |= sign;
@@ -3735,7 +3867,7 @@ encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   buf[0] = image;
@@ -3752,9 +3884,9 @@ decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp != 0)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = (image >> 15) & 1;
-      r->exp = exp - 128;
+      SET_REAL_EXP (r, exp - 128);
 
       image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff);
       r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
@@ -3767,7 +3899,7 @@ encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
 {
   unsigned long image0, image1, sign = r->sign << 15;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       image0 = image1 = 0;
@@ -3802,11 +3934,11 @@ encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
 
       /* Add the sign and exponent.  */
       image0 |= sign;
-      image0 |= (r->exp + 128) << 7;
+      image0 |= (REAL_EXP (r) + 128) << 7;
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   if (FLOAT_WORDS_BIG_ENDIAN)
@@ -3835,9 +3967,9 @@ decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp != 0)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = (image0 >> 15) & 1;
-      r->exp = exp - 128;
+      SET_REAL_EXP (r, exp - 128);
 
       /* Rearrange the half-words of the external format into
 	 proper ascending order.  */
@@ -3867,7 +3999,7 @@ encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
 {
   unsigned long image0, image1, sign = r->sign << 15;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       image0 = image1 = 0;
@@ -3902,11 +4034,11 @@ encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
 
       /* Add the sign and exponent.  */
       image0 |= sign;
-      image0 |= (r->exp + 1024) << 4;
+      image0 |= (REAL_EXP (r) + 1024) << 4;
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   if (FLOAT_WORDS_BIG_ENDIAN)
@@ -3935,9 +4067,9 @@ decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp != 0)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = (image0 >> 15) & 1;
-      r->exp = exp - 1024;
+      SET_REAL_EXP (r, exp - 1024);
 
       /* Rearrange the half-words of the external format into
 	 proper ascending order.  */
@@ -3972,6 +4104,7 @@ const struct real_format vax_f_format =
     -127,
     127,
     15,
+    15,
     false,
     false,
     false,
@@ -3990,6 +4123,7 @@ const struct real_format vax_d_format =
     -127,
     127,
     15,
+    15,
     false,
     false,
     false,
@@ -4008,6 +4142,7 @@ const struct real_format vax_g_format =
     -1023,
     1023,
     15,
+    15,
     false,
     false,
     false,
@@ -4039,7 +4174,7 @@ encode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   sign = r->sign << 31;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       image = 0;
@@ -4052,12 +4187,12 @@ encode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
     case rvc_normal:
       sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0xffffff;
-      exp = ((r->exp / 4) + 64) << 24;
+      exp = ((REAL_EXP (r) / 4) + 64) << 24;
       image = sign | exp | sig;
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   buf[0] = image;
@@ -4078,9 +4213,9 @@ decode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp || sig)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
-      r->exp = (exp - 64) * 4;
+      SET_REAL_EXP (r, (exp - 64) * 4);
       r->sig[SIGSZ-1] = sig << (HOST_BITS_PER_LONG - 24);
       normalize (r);
     }
@@ -4094,7 +4229,7 @@ encode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   sign = r->sign << 31;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       image_hi = image_lo = 0;
@@ -4121,12 +4256,12 @@ encode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
 	  image_hi >>= 8;
 	}
 
-      exp = ((r->exp / 4) + 64) << 24;
+      exp = ((REAL_EXP (r) / 4) + 64) << 24;
       image_hi |= sign | exp;
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   if (FLOAT_WORDS_BIG_ENDIAN)
@@ -4156,9 +4291,9 @@ decode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp || image_hi || image_lo)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
-      r->exp = (exp - 64) * 4 + (SIGNIFICAND_BITS - 56);
+      SET_REAL_EXP (r, (exp - 64) * 4 + (SIGNIFICAND_BITS - 56));
 
       if (HOST_BITS_PER_LONG == 32)
 	{
@@ -4183,6 +4318,7 @@ const struct real_format i370_single_format =
     -64,
     63,
     31,
+    31,
     false,
     false,
     false, /* ??? The encoding does allow for "unnormals".  */
@@ -4201,6 +4337,7 @@ const struct real_format i370_double_format =
     -64,
     63,
     63,
+    63,
     false,
     false,
     false, /* ??? The encoding does allow for "unnormals".  */
@@ -4208,6 +4345,120 @@ const struct real_format i370_double_format =
     false
   };
 
+/* 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, 
+		       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 
+decode_decimal_single (const struct real_format *fmt 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 
+encode_decimal_double (const struct real_format *fmt 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 
+decode_decimal_double (const struct real_format *fmt 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 
+encode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
+		     long *buf ATTRIBUTE_UNUSED,
+		     const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
+{
+  encode_decimal128 (fmt, buf, r);
+}
+
+/* Decode a quad precision DFP value in BUF into a real R.  */
+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). */
+const struct real_format decimal_single_format =
+  {
+    encode_decimal_single,
+    decode_decimal_single,
+    10, 
+    1,  /* log10 */
+    7,
+    7,
+    -95,
+    96,
+    31,
+    31,
+    true,
+    true,
+    true,
+    true, 
+    true
+  };
+
+/* Double precision decimal floating point (IEEE 754R). */
+const struct real_format decimal_double_format =
+  {
+    encode_decimal_double,
+    decode_decimal_double,
+    10,
+    1,  /* log10 */
+    16,
+    16,
+    -383,
+    384,
+    63,
+    63,
+    true,
+    true,
+    true,
+    true,
+    true
+  };
+
+/* Quad precision decimal floating point (IEEE 754R). */
+const struct real_format decimal_quad_format =
+  {
+    encode_decimal_quad,
+    decode_decimal_quad,
+    10,
+    1,  /* log10 */
+    34,
+    34,
+    -6143,
+    6144,
+    127,
+    127,
+    true,
+    true,
+    true, 
+    true, 
+    true
+  };
+
 /* The "twos-complement" c4x format is officially defined as
 
 	x = s(~s).f * 2**e
@@ -4242,7 +4493,7 @@ encode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 {
   unsigned long image, exp, sig;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       exp = -128;
@@ -4256,7 +4507,7 @@ encode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
       break;
 
     case rvc_normal:
-      exp = r->exp - 1;
+      exp = REAL_EXP (r) - 1;
       sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
       if (r->sign)
 	{
@@ -4269,7 +4520,7 @@ encode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   image = ((exp & 0xff) << 24) | (sig & 0xffffff);
@@ -4291,7 +4542,7 @@ decode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp != -128)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
 
       sig = sf & 0x7fffff;
       if (sf < 0)
@@ -4304,7 +4555,7 @@ decode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 	}
       sig = (sig << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
 
-      r->exp = exp + 1;
+      SET_REAL_EXP (r, exp + 1);
       r->sig[SIGSZ-1] = sig;
     }
 }
@@ -4315,7 +4566,7 @@ encode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
 {
   unsigned long exp, sig;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       exp = -128;
@@ -4329,7 +4580,7 @@ encode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
       break;
 
     case rvc_normal:
-      exp = r->exp - 1;
+      exp = REAL_EXP (r) - 1;
 
       sig = r->sig[SIGSZ-1];
       if (HOST_BITS_PER_LONG == 64)
@@ -4347,7 +4598,7 @@ encode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   exp = (exp & 0xff) << 24;
@@ -4378,7 +4629,7 @@ decode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp != -128)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
 
       sig = sf & 0x7fffffff;
       if (sf < 0)
@@ -4393,7 +4644,7 @@ decode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
 	sig = sig << 1 << 31;
       sig |= SIG_MSB;
 
-      r->exp = exp + 1;
+      SET_REAL_EXP (r, exp + 1);
       r->sig[SIGSZ-1] = sig;
     }
 }
@@ -4408,6 +4659,7 @@ const struct real_format c4x_single_format =
     24,
     -126,
     128,
+    23,
     -1,
     false,
     false,
@@ -4426,6 +4678,7 @@ const struct real_format c4x_extended_format =
     32,
     -126,
     128,
+    31,
     -1,
     false,
     false,
@@ -4470,6 +4723,7 @@ const struct real_format real_internal_format =
     -MAX_EXP,
     MAX_EXP,
     -1,
+    -1,
     true,
     true,
     false,
@@ -4627,11 +4881,15 @@ void
 real_floor (REAL_VALUE_TYPE *r, enum machine_mode mode,
 	    const REAL_VALUE_TYPE *x)
 {
-  do_fix_trunc (r, x);
-  if (! real_identical (r, x) && r->sign)
-    do_add (r, r, &dconstm1, 0);
+  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, r);
+    real_convert (r, mode, &t);
+  else
+    *r = t;
 }
 
 /* Round X to the smallest integer not less then argument, i.e. round
@@ -4641,9 +4899,35 @@ void
 real_ceil (REAL_VALUE_TYPE *r, enum machine_mode mode,
 	   const REAL_VALUE_TYPE *x)
 {
-  do_fix_trunc (r, x);
-  if (! real_identical (r, x) && ! r->sign)
-    do_add (r, r, &dconst1, 0);
+  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);
+  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,
+	    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);
 }
+
+/* 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;
+}
+