/* 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>
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"
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;
}
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;
get_inf (REAL_VALUE_TYPE *r, int sign)
{
memset (r, 0, sizeof (*r));
- r->class = rvc_inf;
+ r->cl = rvc_inf;
r->sign = sign;
}
/* Zero significand flushes to zero. */
if (i < 0)
{
- r->class = rvc_zero;
+ r->cl = rvc_zero;
SET_REAL_EXP (r, 0);
return;
}
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. */
break;
default:
- abort ();
+ gcc_unreachable ();
}
/* Swap the arguments such that A has the larger exponent. */
}
}
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp);
+ /* Zero out the remaining fields. */
+ r->signalling = 0;
+ r->canonical = 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;
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):
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (r == a || r == b)
}
memset (&u, 0, sizeof (u));
- u.class = rvc_normal;
+ u.cl = rvc_normal;
SET_REAL_EXP (&u, exp);
for (k = j; k < SIGSZ * 2; k += 2)
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. */
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (r == a || r == b)
/* 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 = REAL_EXP (a) - REAL_EXP (b) + 1;
{
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. */
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (a->sign != b->sign)
{
*r = *a;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
case rvc_inf:
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)
{
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;
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;
break;
default:
- abort ();
+ gcc_unreachable ();
}
+ return false;
}
/* Legacy. Similar, but return the result directly. */
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:
return do_compare (op0, op1, 0) != 0;
default:
- abort ();
+ gcc_unreachable ();
}
}
int
real_exponent (const REAL_VALUE_TYPE *r)
{
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
return 0;
case rvc_normal:
return REAL_EXP (r);
default:
- abort ();
+ gcc_unreachable ();
}
}
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:
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
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. */
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. */
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. */
{
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:
break;
default:
- abort ();
+ gcc_unreachable ();
}
for (i = 0; i < SIGSZ; ++i)
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. */
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)
{
unsigned HOST_WIDE_INT i;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
underflow:
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 - REAL_EXP (r);
return i;
default:
- abort ();
+ gcc_unreachable ();
}
}
HOST_WIDE_INT low, high;
int exp;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
underflow:
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];
low = low << (HOST_BITS_PER_LONG - 1) << 1;
low |= t.sig[SIGSZ-4];
}
- else
- abort ();
if (r->sign)
{
break;
default:
- abort ();
+ gcc_unreachable ();
}
*plow = low;
bool sign;
r = *r_orig;
- switch (r.class)
+ switch (r.cl)
{
case rvc_zero:
strcpy (str, (r.sign ? "-0.0" : "0.0"));
strcpy (str, (r.sign ? "-NaN" : "+NaN"));
return;
default:
- abort ();
+ gcc_unreachable ();
}
/* Bound the number of digits printed by the size of the representation. */
/* 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;
do_multiply (&r, &r, ten);
digit = rtd_divmod (&r, &pten);
dec_exp -= 1;
- if (digit == 0)
- abort ();
+ gcc_assert (digit != 0);
}
/* ... or overflow. */
*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)
char exp_buf[16];
size_t max_digits;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
exp = 0;
strcpy (str, (r->sign ? "-NaN" : "+NaN"));
return;
default:
- abort ();
+ gcc_unreachable ();
}
if (digits == 0)
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;
|= (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++;
}
|= (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++;
}
}
exp += d;
}
- r->class = rvc_normal;
+ r->cl = rvc_normal;
SET_REAL_EXP (r, exp);
normalize (r);
if (*str == '.')
{
str++;
- if (r->class == rvc_zero)
+ if (r->cl == rvc_zero)
{
while (*str == '0')
str++, exp--;
get_zero (r, 0);
else
{
- r->class = rvc_normal;
+ memset (r, 0, sizeof (*r));
+ r->cl = rvc_normal;
r->sign = high < 0 && !unsigned_p;
SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT);
{
r->sig[SIGSZ-1] = high;
r->sig[SIGSZ-2] = low;
- memset (r->sig, 0, sizeof(long)*(SIGSZ-2));
}
- 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;
- if (SIGSZ > 4)
- memset (r->sig, 0, sizeof(long)*(SIGSZ-4));
}
- else
- abort ();
normalize (r);
}
{
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))
{
{
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];
{
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];
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
- if (fmt == NULL)
- abort ();
+ gcc_assert (fmt);
if (*str == 0)
{
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')
add_significands (r, r, &u);
break;
default:
- abort ();
+ gcc_unreachable ();
}
get_zero (&u, 0);
int np2;
fmt = REAL_MODE_FORMAT (mode);
- if (fmt == NULL)
- abort ();
+ gcc_assert (fmt);
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
r->signalling = 0;
r->canonical = 0;
n++;
if (n > MAX_EXP)
- r->class = rvc_inf;
+ r->cl = rvc_inf;
else if (n < -MAX_EXP)
;
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
SET_REAL_EXP (r, n);
r->sig[SIGSZ-1] = SIG_MSB;
}
emax2 = fmt->emax * fmt->log2_b;
np2 = SIGNIFICAND_BITS - p2;
- switch (r->class)
+ switch (r->cl)
{
underflow:
get_zero (r, r->sign);
break;
default:
- abort ();
+ gcc_unreachable ();
}
/* If we're not base2, normalize the exponent to a multiple of
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
- if (fmt == NULL)
- abort ();
+ gcc_assert (fmt);
*r = *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);
}
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);
}
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);
}
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
- if (fmt == NULL)
- abort ();
+ gcc_assert (fmt);
(*fmt->decode) (fmt, r, buf);
}
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:
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (sizeof(unsigned long) > sizeof(unsigned int))
image = sign << 31;
sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
break;
break;
default:
- abort ();
+ gcc_unreachable ();
}
buf[0] = image;
{
if (image && fmt->has_denorm)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, -126);
r->sig[SIGSZ-1] = image << 1;
{
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);
}
else
{
- r->class = rvc_inf;
+ r->cl = rvc_inf;
r->sign = sign;
}
}
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp - 127 + 1);
r->sig[SIGSZ-1] = image | SIG_MSB;
-125,
128,
31,
+ 31,
true,
true,
true,
-125,
128,
31,
+ 31,
true,
true,
true,
sig_hi = (sig_hi >> 11) & 0xfffff;
}
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
break;
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
{
if ((image_hi || image_lo) && fmt->has_denorm)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, -1022);
if (HOST_BITS_PER_LONG == 32)
{
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)
}
else
{
- r->class = rvc_inf;
+ r->cl = rvc_inf;
r->sign = sign;
}
}
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp - 1023 + 1);
if (HOST_BITS_PER_LONG == 32)
-1021,
1024,
63,
+ 63,
true,
true,
true,
-1021,
1024,
63,
+ 63,
true,
true,
true,
image_hi = r->sign << 15;
sig_hi = sig_lo = 0;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
break;
else
{
exp += 16383 - 1;
- if (exp < 0)
- abort ();
+ gcc_assert (exp >= 0);
}
image_hi |= exp;
break;
default:
- abort ();
+ gcc_unreachable ();
}
buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
{
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
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)
}
else
{
- r->class = rvc_inf;
+ r->cl = rvc_inf;
r->sign = sign;
}
}
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp - 16383 + 1);
if (HOST_BITS_PER_LONG == 32)
-16382,
16384,
95,
+ 95,
true,
true,
true,
-16381,
16384,
79,
+ 79,
true,
true,
true,
-16381,
16384,
79,
+ 79,
true,
true,
true,
-16381,
16384,
79,
+ 79,
true,
true,
true,
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 *);
/* 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. */
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. */
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);
53,
-1021 + 53,
1024,
+ 127,
-1,
true,
true,
53,
-1021 + 53,
1024,
+ 127,
-1,
true,
true,
rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
break;
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
{
if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
{
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;
}
else
{
- r->class = rvc_inf;
+ r->cl = rvc_inf;
r->sign = sign;
}
}
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp - 16383 + 1);
-16381,
16384,
127,
+ 127,
true,
true,
true,
-16381,
16384,
127,
+ 127,
true,
true,
true,
sign = r->sign << 15;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
image = 0;
break;
default:
- abort ();
+ gcc_unreachable ();
}
buf[0] = image;
if (exp != 0)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = (image >> 15) & 1;
SET_REAL_EXP (r, exp - 128);
{
unsigned long image0, image1, sign = r->sign << 15;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
image0 = image1 = 0;
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
if (exp != 0)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = (image0 >> 15) & 1;
SET_REAL_EXP (r, exp - 128);
{
unsigned long image0, image1, sign = r->sign << 15;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
image0 = image1 = 0;
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
if (exp != 0)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = (image0 >> 15) & 1;
SET_REAL_EXP (r, exp - 1024);
-127,
127,
15,
+ 15,
false,
false,
false,
-127,
127,
15,
+ 15,
false,
false,
false,
-1023,
1023,
15,
+ 15,
false,
false,
false,
sign = r->sign << 31;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
image = 0;
break;
default:
- abort ();
+ gcc_unreachable ();
}
buf[0] = image;
if (exp || sig)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, (exp - 64) * 4);
r->sig[SIGSZ-1] = sig << (HOST_BITS_PER_LONG - 24);
sign = r->sign << 31;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
image_hi = image_lo = 0;
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
if (exp || image_hi || image_lo)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, (exp - 64) * 4 + (SIGNIFICAND_BITS - 56));
-64,
63,
31,
+ 31,
false,
false,
false, /* ??? The encoding does allow for "unnormals". */
-64,
63,
63,
+ 63,
false,
false,
false, /* ??? The encoding does allow for "unnormals". */
{
unsigned long image, exp, sig;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
exp = -128;
break;
default:
- abort ();
+ gcc_unreachable ();
}
image = ((exp & 0xff) << 24) | (sig & 0xffffff);
if (exp != -128)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
sig = sf & 0x7fffff;
if (sf < 0)
{
unsigned long exp, sig;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
exp = -128;
break;
default:
- abort ();
+ gcc_unreachable ();
}
exp = (exp & 0xff) << 24;
if (exp != -128)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
sig = sf & 0x7fffffff;
if (sf < 0)
24,
-126,
128,
+ 23,
-1,
false,
false,
32,
-126,
128,
+ 31,
-1,
false,
false,
-MAX_EXP,
MAX_EXP,
-1,
+ -1,
true,
true,
false,
do_add (&t, &t, &dconstm1, 0);
if (mode != VOIDmode)
real_convert (r, mode, &t);
+ else
+ *r = t;
}
/* Round X to the smallest integer not less then argument, i.e. round
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