/* real.c - software floating point emulation.
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2002, 2003 Free Software Foundation, Inc.
+ 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
Contributed by Stephen L. Moshier (moshier@world.std.com).
Re-written by Richard Henderson <rth@redhat.com>
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 29.
+ denormal number fits in 17 exponent bits; we store 27.
Note that the decimal string conversion routines are sensitive to
rounding errors. Since the raw arithmetic routines do not themselves
if (i < 0)
{
r->class = rvc_zero;
- r->exp = 0;
+ SET_REAL_EXP (r, 0);
return;
}
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);
}
}
}
/* 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;
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. */
r->class = rvc_normal;
r->sign = sign;
- r->exp = exp;
+ SET_REAL_EXP (r, exp);
/* Re-normalize the result. */
normalize (r);
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)
{
memset (&u, 0, sizeof (u));
u.class = rvc_normal;
- u.exp = exp;
+ SET_REAL_EXP (&u, exp);
for (k = j; k < SIGSZ * 2; k += 2)
{
else
rr = r;
+ /* Make sure all fields in the result are initialized. */
+ get_zero (rr, 0);
rr->class = 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);
get_zero (r, sign);
return true;
}
- rr->exp = exp;
+ SET_REAL_EXP (rr, exp);
inexact = div_significands (rr, a, b);
if (a->sign != b->sign)
return -a->sign - -b->sign;
- if (a->exp > b->exp)
+ 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);
break;
case rvc_normal:
- if (r->exp <= 0)
+ 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:
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 ();
case rvc_nan:
return (unsigned int)-1 >> 1;
case rvc_normal:
- return r->exp;
+ return REAL_EXP (r);
default:
abort ();
}
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:
return true;
case rvc_normal:
- if (a->exp != b->exp)
+ if (REAL_EXP (a) != REAL_EXP (b))
return false;
break;
return i;
case rvc_normal:
- if (r->exp <= 0)
+ 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)
else
abort ();
- i >>= HOST_BITS_PER_WIDE_INT - r->exp;
+ i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
if (r->sign)
i = -i;
break;
case rvc_normal:
- exp = r->exp;
+ exp = REAL_EXP (r);
if (exp <= 0)
goto underflow;
/* Only force overflow for unsigned overflow. Signed overflow is
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;
}
while (--expn >= expd);
- num->exp = expd;
+ SET_REAL_EXP (num, expd);
normalize (num);
return q;
/* 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;
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);
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);
do_multiply (&u, &v, ten);
/* Stop if we're now >= 1. */
- if (u.exp > 0)
+ if (REAL_EXP (&u) > 0)
break;
v = u;
/* 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);
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;
else if (*str == '+')
str++;
- if (str[0] == '0' && str[1] == 'x')
+ if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
{
/* Hexadecimal floating point. */
int pos = SIGNIFICAND_BITS - 4, d;
}
r->class = rvc_normal;
- r->exp = exp;
+ SET_REAL_EXP (r, exp);
normalize (r);
}
{
r->class = 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)
{
{
const struct real_format *fmt;
- fmt = real_format_for_mode[mode - QFmode];
+ fmt = REAL_MODE_FORMAT (mode);
if (fmt == NULL)
abort ();
const struct real_format *fmt;
int np2;
- fmt = real_format_for_mode[mode - QFmode];
+ fmt = REAL_MODE_FORMAT (mode);
if (fmt == NULL)
abort ();
r->sign = sign;
r->signalling = 0;
r->canonical = 0;
- r->exp = fmt->emax * fmt->log2_b;
+ SET_REAL_EXP (r, fmt->emax * fmt->log2_b);
np2 = SIGNIFICAND_BITS - fmt->p * fmt->log2_b;
memset (r->sig, -1, SIGSZ * sizeof (unsigned long));
else
{
r->class = rvc_normal;
- r->exp = n;
+ SET_REAL_EXP (r, n);
r->sig[SIGSZ-1] = SIG_MSB;
}
}
the true base. */
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;
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);
}
}
/* 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;
}
}
}
/* Catch underflow that we deferred until after rounding. */
- if (r->exp <= emin2m1)
+ if (REAL_EXP (r) <= emin2m1)
goto underflow;
/* Clear out trailing garbage. */
{
const struct real_format *fmt;
- fmt = real_format_for_mode[mode - QFmode];
+ fmt = REAL_MODE_FORMAT (mode);
if (fmt == NULL)
abort ();
{
const struct real_format *fmt;
- fmt = real_format_for_mode[mode - QFmode];
+ fmt = REAL_MODE_FORMAT (mode);
if (fmt == NULL)
abort ();
{
const struct real_format *fmt;
- fmt = real_format_for_mode[mode - QFmode];
+ fmt = REAL_MODE_FORMAT (mode);
if (fmt == NULL)
abort ();
{
const struct real_format *fmt;
- fmt = real_format_for_mode[mode - QFmode];
+ fmt = REAL_MODE_FORMAT (mode);
if (fmt == NULL)
return 0;
return h;
case rvc_normal:
- h |= r->exp << 3;
+ h |= REAL_EXP (r) << 3;
break;
case rvc_nan:
const REAL_VALUE_TYPE *r)
{
unsigned long image, sig, exp;
+ unsigned long sign = r->sign;
bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
- image = r->sign << 31;
+ image = sign << 31;
sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
switch (r->class)
if (denormal)
exp = 0;
else
- exp = r->exp + 127 - 1;
+ exp = REAL_EXP (r) + 127 - 1;
image |= exp << 23;
image |= sig;
break;
{
r->class = rvc_normal;
r->sign = sign;
- r->exp = -126;
+ SET_REAL_EXP (r, -126);
r->sig[SIGSZ-1] = image << 1;
normalize (r);
}
{
r->class = rvc_normal;
r->sign = sign;
- r->exp = exp - 127 + 1;
+ SET_REAL_EXP (r, exp - 127 + 1);
r->sig[SIGSZ-1] = image | SIG_MSB;
}
}
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;
{
r->class = 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);
{
r->class = 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;
};
\f
-/* IEEE extended double precision format. This comes in three
- flavors: Intel's as a 12 byte image, Intel's as a 16 byte image,
- and Motorola's. */
-
-static void encode_ieee_extended (const struct real_format *fmt,
- long *, const REAL_VALUE_TYPE *);
-static void decode_ieee_extended (const struct real_format *,
- REAL_VALUE_TYPE *, const long *);
-
-static void encode_ieee_extended_128 (const struct real_format *fmt,
- long *, const REAL_VALUE_TYPE *);
-static void decode_ieee_extended_128 (const struct real_format *,
- REAL_VALUE_TYPE *, const long *);
-
+/* 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
+ always big endian. */
+
+/* Helper subroutine which converts from the internal format to the
+ 12-byte little-endian Intel format. Functions below adjust this
+ for the other possible formats. */
static void
encode_ieee_extended (const struct real_format *fmt, long *buf,
const REAL_VALUE_TYPE *r)
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.
abort ();
}
+ buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
+}
+
+/* Convert from the internal format to the 12-byte Motorola format
+ for an IEEE extended real. */
+static void
+encode_ieee_extended_motorola (const struct real_format *fmt, long *buf,
+ const REAL_VALUE_TYPE *r)
+{
+ long intermed[3];
+ encode_ieee_extended (fmt, intermed, r);
+
+ /* 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
+ shift element 2 left 16 bits. */
+ buf[0] = intermed[2] << 16;
+ buf[1] = intermed[1];
+ buf[2] = intermed[0];
+}
+
+/* Convert from the internal format to the 12-byte Intel format for
+ an IEEE extended real. */
+static void
+encode_ieee_extended_intel_96 (const struct real_format *fmt, long *buf,
+ const REAL_VALUE_TYPE *r)
+{
if (FLOAT_WORDS_BIG_ENDIAN)
- buf[0] = image_hi << 16, buf[1] = sig_hi, buf[2] = sig_lo;
+ {
+ /* All the padding in an Intel-format extended real goes at the high
+ end, which in this case is after the mantissa, not the exponent.
+ Therefore we must shift everything down 16 bits. */
+ long intermed[3];
+ encode_ieee_extended (fmt, intermed, r);
+ buf[0] = ((intermed[2] << 16) | ((unsigned long)(intermed[1] & 0xFFFF0000) >> 16));
+ buf[1] = ((intermed[1] << 16) | ((unsigned long)(intermed[0] & 0xFFFF0000) >> 16));
+ buf[2] = (intermed[0] << 16);
+ }
else
- buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
+ /* encode_ieee_extended produces what we want directly. */
+ encode_ieee_extended (fmt, buf, r);
}
+/* Convert from the internal format to the 16-byte Intel format for
+ an IEEE extended real. */
static void
-encode_ieee_extended_128 (const struct real_format *fmt, long *buf,
- const REAL_VALUE_TYPE *r)
+encode_ieee_extended_intel_128 (const struct real_format *fmt, long *buf,
+ const REAL_VALUE_TYPE *r)
{
- buf[3 * !FLOAT_WORDS_BIG_ENDIAN] = 0;
- encode_ieee_extended (fmt, buf+!!FLOAT_WORDS_BIG_ENDIAN, r);
+ /* All the padding in an Intel-format extended real goes at the high end. */
+ encode_ieee_extended_intel_96 (fmt, buf, r);
+ buf[3] = 0;
}
+/* As above, we have a helper function which converts from 12-byte
+ little-endian Intel format to internal format. Functions below
+ adjust for the other possible formats. */
static void
decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
const long *buf)
bool sign;
int exp;
- if (FLOAT_WORDS_BIG_ENDIAN)
- image_hi = buf[0] >> 16, sig_hi = buf[1], sig_lo = buf[2];
- else
- sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
+ sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
sig_lo &= 0xffffffff;
sig_hi &= 0xffffffff;
image_hi &= 0xffffffff;
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;
{
r->class = 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;
}
}
+/* Convert from the internal format to the 12-byte Motorola format
+ for an IEEE extended real. */
static void
-decode_ieee_extended_128 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
- const long *buf)
+decode_ieee_extended_motorola (const struct real_format *fmt, REAL_VALUE_TYPE *r,
+ const long *buf)
{
- decode_ieee_extended (fmt, r, buf+!!FLOAT_WORDS_BIG_ENDIAN);
+ long intermed[3];
+
+ /* Motorola chips are assumed always to be big-endian. Also, the
+ padding in a Motorola extended real goes between the exponent and
+ the mantissa; remove it. */
+ intermed[0] = buf[2];
+ intermed[1] = buf[1];
+ intermed[2] = (unsigned long)buf[0] >> 16;
+
+ decode_ieee_extended (fmt, r, intermed);
+}
+
+/* Convert from the internal format to the 12-byte Intel format for
+ an IEEE extended real. */
+static void
+decode_ieee_extended_intel_96 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
+ const long *buf)
+{
+ if (FLOAT_WORDS_BIG_ENDIAN)
+ {
+ /* All the padding in an Intel-format extended real goes at the high
+ end, which in this case is after the mantissa, not the exponent.
+ Therefore we must shift everything up 16 bits. */
+ long intermed[3];
+
+ intermed[0] = (((unsigned long)buf[2] >> 16) | (buf[1] << 16));
+ intermed[1] = (((unsigned long)buf[1] >> 16) | (buf[0] << 16));
+ intermed[2] = ((unsigned long)buf[0] >> 16);
+
+ decode_ieee_extended (fmt, r, intermed);
+ }
+ else
+ /* decode_ieee_extended produces what we want directly. */
+ decode_ieee_extended (fmt, r, buf);
+}
+
+/* Convert from the internal format to the 16-byte Intel format for
+ an IEEE extended real. */
+static void
+decode_ieee_extended_intel_128 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
+ const long *buf)
+{
+ /* All the padding in an Intel-format extended real goes at the high end. */
+ decode_ieee_extended_intel_96 (fmt, r, buf);
}
const struct real_format ieee_extended_motorola_format =
{
- encode_ieee_extended,
- decode_ieee_extended,
+ encode_ieee_extended_motorola,
+ decode_ieee_extended_motorola,
2,
1,
64,
const struct real_format ieee_extended_intel_96_format =
{
- encode_ieee_extended,
- decode_ieee_extended,
+ encode_ieee_extended_intel_96,
+ decode_ieee_extended_intel_96,
2,
1,
64,
const struct real_format ieee_extended_intel_128_format =
{
- encode_ieee_extended_128,
- decode_ieee_extended_128,
+ encode_ieee_extended_intel_128,
+ decode_ieee_extended_intel_128,
2,
1,
64,
to 53 bits instead of 64, e.g. FreeBSD. */
const struct real_format ieee_extended_intel_96_round_53_format =
{
- encode_ieee_extended,
- decode_ieee_extended,
+ encode_ieee_extended_intel_96,
+ decode_ieee_extended_intel_96,
2,
1,
53,
encode_ibm_extended (const struct real_format *fmt, long *buf,
const REAL_VALUE_TYPE *r)
{
- REAL_VALUE_TYPE u, v;
+ REAL_VALUE_TYPE u, normr, v;
const struct real_format *base_fmt;
base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
- switch (r->class)
- {
- case rvc_zero:
- /* Both doubles have sign bit set. */
- buf[0] = FLOAT_WORDS_BIG_ENDIAN ? r->sign << 31 : 0;
- buf[1] = FLOAT_WORDS_BIG_ENDIAN ? 0 : r->sign << 31;
- buf[2] = buf[0];
- buf[3] = buf[1];
- break;
-
- case rvc_inf:
- case rvc_nan:
- /* Both doubles set to Inf / NaN. */
- encode_ieee_double (base_fmt, &buf[0], r);
- buf[2] = buf[0];
- buf[3] = buf[1];
- return;
-
- case rvc_normal:
- /* u = IEEE double precision portion of significand. */
- u = *r;
- clear_significand_below (&u, SIGNIFICAND_BITS - 53);
-
- normalize (&u);
- /* If the upper double is zero, we have a denormal double, so
- move it to the first double and leave the second as zero. */
- if (u.class == rvc_zero)
- {
- v = u;
- u = *r;
- normalize (&u);
- }
- else
- {
- /* v = remainder containing additional 53 bits of significand. */
- do_add (&v, r, &u, 1);
- round_for_format (base_fmt, &v);
- }
+ /* Renormlize R before doing any arithmetic on it. */
+ normr = *r;
+ if (normr.class == rvc_normal)
+ normalize (&normr);
- round_for_format (base_fmt, &u);
+ /* u = IEEE double precision portion of significand. */
+ u = normr;
+ round_for_format (base_fmt, &u);
+ encode_ieee_double (base_fmt, &buf[0], &u);
- encode_ieee_double (base_fmt, &buf[0], &u);
+ if (u.class == rvc_normal)
+ {
+ do_add (&v, &normr, &u, 1);
+ /* Call round_for_format since we might need to denormalize. */
+ round_for_format (base_fmt, &v);
encode_ieee_double (base_fmt, &buf[2], &v);
- break;
-
- default:
- abort ();
+ }
+ else
+ {
+ /* Inf, NaN, 0 are all representable as doubles, so the
+ least-significant part can be 0.0. */
+ buf[2] = 0;
+ buf[3] = 0;
}
}
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)
r->class = 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;
{
r->class = rvc_normal;
r->sign = sign;
- r->exp = exp - 16383 + 1;
+ SET_REAL_EXP (r, exp - 16383 + 1);
if (HOST_BITS_PER_LONG == 32)
{
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;
{
r->class = 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;
/* Add the sign and exponent. */
image0 |= sign;
- image0 |= (r->exp + 128) << 7;
+ image0 |= (REAL_EXP (r) + 128) << 7;
break;
default:
{
r->class = 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. */
/* Add the sign and exponent. */
image0 |= sign;
- image0 |= (r->exp + 1024) << 4;
+ image0 |= (REAL_EXP (r) + 1024) << 4;
break;
default:
{
r->class = 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. */
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;
{
r->class = 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);
}
image_hi >>= 8;
}
- exp = ((r->exp / 4) + 64) << 24;
+ exp = ((REAL_EXP (r) / 4) + 64) << 24;
image_hi |= sign | exp;
break;
{
r->class = 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)
{
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)
{
}
sig = (sig << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
- r->exp = exp + 1;
+ SET_REAL_EXP (r, exp + 1);
r->sig[SIGSZ-1] = sig;
}
}
break;
case rvc_normal:
- exp = r->exp - 1;
+ exp = REAL_EXP (r) - 1;
sig = r->sig[SIGSZ-1];
if (HOST_BITS_PER_LONG == 64)
sig = sig << 1 << 31;
sig |= SIG_MSB;
- r->exp = exp + 1;
+ SET_REAL_EXP (r, exp + 1);
r->sig[SIGSZ-1] = sig;
}
}
true
};
\f
-/* Set up default mode to format mapping for IEEE. Everyone else has
- to set these values in OVERRIDE_OPTIONS. */
-
-const struct real_format *real_format_for_mode[TFmode - QFmode + 1] =
-{
- NULL, /* QFmode */
- NULL, /* HFmode */
- NULL, /* TQFmode */
- &ieee_single_format, /* SFmode */
- &ieee_double_format, /* DFmode */
-
- /* We explicitly don't handle XFmode. There are two formats,
- pretty much equally common. Choose one in OVERRIDE_OPTIONS. */
- NULL, /* XFmode */
- &ieee_quad_format /* TFmode */
-};
-
-\f
/* Calculate the square root of X in mode MODE, and store the result
in R. Return TRUE if the operation does not raise an exception.
For details see "High Precision Division and Square Root",
/* Negative arguments return NaN. */
if (real_isneg (x))
{
- /* Mode is ignored for canonical NaN. */
- real_nan (r, "", 1, SFmode);
+ get_canonical_qnan (r, 0);
return false;
}
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);
}
/* Round X to the smallest integer not less then argument, i.e. round
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);
+}
+
+/* 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;
+}
+
OSDN Git Service
