#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "sreal.h"
static inline void copy (sreal *, sreal *);
static inline void shift_right (sreal *, int);
static void normalize (sreal *);
void
dump_sreal (FILE *file, sreal *x)
{
#if SREAL_PART_BITS < 32
fprintf (file, "((" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^16 + "
HOST_WIDE_INT_PRINT_UNSIGNED ") * 2^%d)",
x->sig_hi, x->sig_lo, x->exp);
#else
fprintf (file, "(" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^%d)", x->sig, x->exp);
#endif
}
static inline void
copy (sreal *r, sreal *a)
{
#if SREAL_PART_BITS < 32
r->sig_lo = a->sig_lo;
r->sig_hi = a->sig_hi;
#else
r->sig = a->sig;
#endif
r->exp = a->exp;
}
static inline void
shift_right (sreal *x, int s)
{
gcc_assert (s > 0);
gcc_assert (s <= SREAL_BITS);
gcc_assert (x->exp + s <= SREAL_MAX_EXP);
x->exp += s;
#if SREAL_PART_BITS < 32
if (s > SREAL_PART_BITS)
{
s -= SREAL_PART_BITS;
x->sig_hi += (uhwi) 1 << (s - 1);
x->sig_lo = x->sig_hi >> s;
x->sig_hi = 0;
}
else
{
x->sig_lo += (uhwi) 1 << (s - 1);
if (x->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
{
x->sig_hi++;
x->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
}
x->sig_lo >>= s;
x->sig_lo |= (x->sig_hi & (((uhwi) 1 << s) - 1)) << (SREAL_PART_BITS - s);
x->sig_hi >>= s;
}
#else
x->sig += (uhwi) 1 << (s - 1);
x->sig >>= s;
#endif
}
static void
normalize (sreal *x)
{
#if SREAL_PART_BITS < 32
int shift;
HOST_WIDE_INT mask;
if (x->sig_lo == 0 && x->sig_hi == 0)
{
x->exp = -SREAL_MAX_EXP;
}
else if (x->sig_hi < SREAL_MIN_SIG)
{
if (x->sig_hi == 0)
{
x->sig_hi = x->sig_lo;
x->sig_lo = 0;
x->exp -= SREAL_PART_BITS;
}
shift = 0;
while (x->sig_hi < SREAL_MIN_SIG)
{
x->sig_hi <<= 1;
x->exp--;
shift++;
}
if (x->exp < -SREAL_MAX_EXP)
{
x->exp = -SREAL_MAX_EXP;
x->sig_hi = 0;
x->sig_lo = 0;
}
else if (shift)
{
mask = (1 << SREAL_PART_BITS) - (1 << (SREAL_PART_BITS - shift));
x->sig_hi |= (x->sig_lo & mask) >> (SREAL_PART_BITS - shift);
x->sig_lo = (x->sig_lo << shift) & (((uhwi) 1 << SREAL_PART_BITS) - 1);
}
}
else if (x->sig_hi > SREAL_MAX_SIG)
{
unsigned HOST_WIDE_INT tmp = x->sig_hi;
shift = 0;
do
{
tmp >>= 1;
shift++;
}
while (tmp > SREAL_MAX_SIG);
x->sig_lo += (uhwi) 1 << (shift - 1);
x->sig_lo >>= shift;
x->sig_lo += ((x->sig_hi & (((uhwi) 1 << shift) - 1))
<< (SREAL_PART_BITS - shift));
x->sig_hi >>= shift;
x->exp += shift;
if (x->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
{
x->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
x->sig_hi++;
if (x->sig_hi > SREAL_MAX_SIG)
{
x->sig_hi >>= 1;
x->sig_lo >>= 1;
x->exp++;
}
}
if (x->exp > SREAL_MAX_EXP)
{
x->exp = SREAL_MAX_EXP;
x->sig_hi = SREAL_MAX_SIG;
x->sig_lo = SREAL_MAX_SIG;
}
}
#else
if (x->sig == 0)
{
x->exp = -SREAL_MAX_EXP;
}
else if (x->sig < SREAL_MIN_SIG)
{
do
{
x->sig <<= 1;
x->exp--;
}
while (x->sig < SREAL_MIN_SIG);
if (x->exp < -SREAL_MAX_EXP)
{
x->exp = -SREAL_MAX_EXP;
x->sig = 0;
}
}
else if (x->sig > SREAL_MAX_SIG)
{
int last_bit;
do
{
last_bit = x->sig & 1;
x->sig >>= 1;
x->exp++;
}
while (x->sig > SREAL_MAX_SIG);
x->sig += last_bit;
if (x->sig > SREAL_MAX_SIG)
{
x->sig >>= 1;
x->exp++;
}
if (x->exp > SREAL_MAX_EXP)
{
x->exp = SREAL_MAX_EXP;
x->sig = SREAL_MAX_SIG;
}
}
#endif
}
sreal *
sreal_init (sreal *r, unsigned HOST_WIDE_INT sig, signed int exp)
{
#if SREAL_PART_BITS < 32
r->sig_lo = 0;
r->sig_hi = sig;
r->exp = exp - 16;
#else
r->sig = sig;
r->exp = exp;
#endif
normalize (r);
return r;
}
HOST_WIDE_INT
sreal_to_int (sreal *r)
{
#if SREAL_PART_BITS < 32
if (r->exp <= -SREAL_BITS)
return 0;
if (r->exp >= 0)
return MAX_HOST_WIDE_INT;
return ((r->sig_hi << SREAL_PART_BITS) + r->sig_lo) >> -r->exp;
#else
if (r->exp <= -SREAL_BITS)
return 0;
if (r->exp >= SREAL_PART_BITS)
return MAX_HOST_WIDE_INT;
if (r->exp > 0)
return r->sig << r->exp;
if (r->exp < 0)
return r->sig >> -r->exp;
return r->sig;
#endif
}
int
sreal_compare (sreal *a, sreal *b)
{
if (a->exp > b->exp)
return 1;
if (a->exp < b->exp)
return -1;
#if SREAL_PART_BITS < 32
if (a->sig_hi > b->sig_hi)
return 1;
if (a->sig_hi < b->sig_hi)
return -1;
if (a->sig_lo > b->sig_lo)
return 1;
if (a->sig_lo < b->sig_lo)
return -1;
#else
if (a->sig > b->sig)
return 1;
if (a->sig < b->sig)
return -1;
#endif
return 0;
}
sreal *
sreal_add (sreal *r, sreal *a, sreal *b)
{
int dexp;
sreal tmp;
sreal *bb;
if (sreal_compare (a, b) < 0)
{
sreal *swap;
swap = a;
a = b;
b = swap;
}
dexp = a->exp - b->exp;
r->exp = a->exp;
if (dexp > SREAL_BITS)
{
#if SREAL_PART_BITS < 32
r->sig_hi = a->sig_hi;
r->sig_lo = a->sig_lo;
#else
r->sig = a->sig;
#endif
return r;
}
if (dexp == 0)
bb = b;
else
{
copy (&tmp, b);
shift_right (&tmp, dexp);
bb = &tmp;
}
#if SREAL_PART_BITS < 32
r->sig_hi = a->sig_hi + bb->sig_hi;
r->sig_lo = a->sig_lo + bb->sig_lo;
if (r->sig_lo & ((uhwi) 1 << SREAL_PART_BITS))
{
r->sig_hi++;
r->sig_lo -= (uhwi) 1 << SREAL_PART_BITS;
}
#else
r->sig = a->sig + bb->sig;
#endif
normalize (r);
return r;
}
sreal *
sreal_sub (sreal *r, sreal *a, sreal *b)
{
int dexp;
sreal tmp;
sreal *bb;
gcc_assert (sreal_compare (a, b) >= 0);
dexp = a->exp - b->exp;
r->exp = a->exp;
if (dexp > SREAL_BITS)
{
#if SREAL_PART_BITS < 32
r->sig_hi = a->sig_hi;
r->sig_lo = a->sig_lo;
#else
r->sig = a->sig;
#endif
return r;
}
if (dexp == 0)
bb = b;
else
{
copy (&tmp, b);
shift_right (&tmp, dexp);
bb = &tmp;
}
#if SREAL_PART_BITS < 32
if (a->sig_lo < bb->sig_lo)
{
r->sig_hi = a->sig_hi - bb->sig_hi - 1;
r->sig_lo = a->sig_lo + ((uhwi) 1 << SREAL_PART_BITS) - bb->sig_lo;
}
else
{
r->sig_hi = a->sig_hi - bb->sig_hi;
r->sig_lo = a->sig_lo - bb->sig_lo;
}
#else
r->sig = a->sig - bb->sig;
#endif
normalize (r);
return r;
}
sreal *
sreal_mul (sreal *r, sreal *a, sreal *b)
{
#if SREAL_PART_BITS < 32
if (a->sig_hi < SREAL_MIN_SIG || b->sig_hi < SREAL_MIN_SIG)
{
r->sig_lo = 0;
r->sig_hi = 0;
r->exp = -SREAL_MAX_EXP;
}
else
{
unsigned HOST_WIDE_INT tmp1, tmp2, tmp3;
if (sreal_compare (a, b) < 0)
{
sreal *swap;
swap = a;
a = b;
b = swap;
}
r->exp = a->exp + b->exp + SREAL_PART_BITS;
tmp1 = a->sig_lo * b->sig_lo;
tmp2 = a->sig_lo * b->sig_hi;
tmp3 = a->sig_hi * b->sig_lo + (tmp1 >> SREAL_PART_BITS);
r->sig_hi = a->sig_hi * b->sig_hi;
r->sig_hi += (tmp2 >> SREAL_PART_BITS) + (tmp3 >> SREAL_PART_BITS);
tmp2 &= ((uhwi) 1 << SREAL_PART_BITS) - 1;
tmp3 &= ((uhwi) 1 << SREAL_PART_BITS) - 1;
tmp1 = tmp2 + tmp3;
r->sig_lo = tmp1 & (((uhwi) 1 << SREAL_PART_BITS) - 1);
r->sig_hi += tmp1 >> SREAL_PART_BITS;
normalize (r);
}
#else
if (a->sig < SREAL_MIN_SIG || b->sig < SREAL_MIN_SIG)
{
r->sig = 0;
r->exp = -SREAL_MAX_EXP;
}
else
{
r->sig = a->sig * b->sig;
r->exp = a->exp + b->exp;
normalize (r);
}
#endif
return r;
}
sreal *
sreal_div (sreal *r, sreal *a, sreal *b)
{
#if SREAL_PART_BITS < 32
unsigned HOST_WIDE_INT tmp, tmp1, tmp2;
gcc_assert (b->sig_hi >= SREAL_MIN_SIG);
if (a->sig_hi < SREAL_MIN_SIG)
{
r->sig_hi = 0;
r->sig_lo = 0;
r->exp = -SREAL_MAX_EXP;
}
else
{
tmp1 = (a->sig_hi << SREAL_PART_BITS) + a->sig_lo;
tmp2 = ((b->sig_hi << (SREAL_PART_BITS / 2))
+ (b->sig_lo >> (SREAL_PART_BITS / 2)));
if (b->sig_lo & ((uhwi) 1 << ((SREAL_PART_BITS / 2) - 1)))
tmp2++;
r->sig_lo = 0;
tmp = tmp1 / tmp2;
tmp1 = (tmp1 % tmp2) << (SREAL_PART_BITS / 2);
r->sig_hi = tmp << SREAL_PART_BITS;
tmp = tmp1 / tmp2;
tmp1 = (tmp1 % tmp2) << (SREAL_PART_BITS / 2);
r->sig_hi += tmp << (SREAL_PART_BITS / 2);
tmp = tmp1 / tmp2;
r->sig_hi += tmp;
r->exp = a->exp - b->exp - SREAL_BITS - SREAL_PART_BITS / 2;
normalize (r);
}
#else
gcc_assert (b->sig != 0);
r->sig = (a->sig << SREAL_PART_BITS) / b->sig;
r->exp = a->exp - b->exp - SREAL_PART_BITS;
normalize (r);
#endif
return r;
}