mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-24 11:29:10 +00:00
946 lines
17 KiB
C
946 lines
17 KiB
C
/*
|
|
** libgcc support for software floating point.
|
|
** Copyright (C) 1991 by Pipeline Associates, Inc. All rights reserved.
|
|
** Permission is granted to do *anything* you want with this file,
|
|
** commercial or otherwise, provided this message remains intact. So there!
|
|
** I would appreciate receiving any updates/patches/changes that anyone
|
|
** makes, and am willing to be the repository for said changes (am I
|
|
** making a big mistake?).
|
|
|
|
Warning! Only single-precision is actually implemented. This file
|
|
won't really be much use until double-precision is supported.
|
|
|
|
However, once that is done, this file might eventually become a
|
|
replacement for libgcc1.c. It might also make possible
|
|
cross-compilation for an IEEE target machine from a non-IEEE
|
|
host such as a VAX.
|
|
|
|
If you'd like to work on completing this, please talk to rms@gnu.ai.mit.edu.
|
|
|
|
--> Double precision floating support added by James Carlson on 20 April 1998.
|
|
|
|
**
|
|
** Pat Wood
|
|
** Pipeline Associates, Inc.
|
|
** pipeline!phw@motown.com or
|
|
** sun!pipeline!phw or
|
|
** uunet!motown!pipeline!phw
|
|
**
|
|
** 05/01/91 -- V1.0 -- first release to gcc mailing lists
|
|
** 05/04/91 -- V1.1 -- added float and double prototypes and return values
|
|
** -- fixed problems with adding and subtracting zero
|
|
** -- fixed rounding in truncdfsf2
|
|
** -- fixed SWAP define and tested on 386
|
|
*/
|
|
|
|
/*
|
|
** The following are routines that replace the libgcc soft floating point
|
|
** routines that are called automatically when -msoft-float is selected.
|
|
** The support single and double precision IEEE format, with provisions
|
|
** for byte-swapped machines (tested on 386). Some of the double-precision
|
|
** routines work at full precision, but most of the hard ones simply punt
|
|
** and call the single precision routines, producing a loss of accuracy.
|
|
** long long support is not assumed or included.
|
|
** Overall accuracy is close to IEEE (actually 68882) for single-precision
|
|
** arithmetic. I think there may still be a 1 in 1000 chance of a bit
|
|
** being rounded the wrong way during a multiply. I'm not fussy enough to
|
|
** bother with it, but if anyone is, knock yourself out.
|
|
**
|
|
** Efficiency has only been addressed where it was obvious that something
|
|
** would make a big difference. Anyone who wants to do this right for
|
|
** best speed should go in and rewrite in assembler.
|
|
**
|
|
** I have tested this only on a 68030 workstation and 386/ix integrated
|
|
** in with -msoft-float.
|
|
*/
|
|
|
|
/* the following deal with IEEE single-precision numbers */
|
|
#define EXCESS 126
|
|
#define SIGNBIT 0x80000000
|
|
#define HIDDEN (1 << 23)
|
|
#define SIGN(fp) ((fp) & SIGNBIT)
|
|
#define EXP(fp) (((fp) >> 23) & 0xFF)
|
|
#define MANT(fp) (((fp) & 0x7FFFFF) | HIDDEN)
|
|
#define PACK(s,e,m) ((s) | ((e) << 23) | (m))
|
|
|
|
/* the following deal with IEEE double-precision numbers */
|
|
#define EXCESSD 1022
|
|
#define HIDDEND (1 << 20)
|
|
#define EXPD(fp) (((fp.l.upper) >> 20) & 0x7FF)
|
|
#define SIGND(fp) ((fp.l.upper) & SIGNBIT)
|
|
#define MANTD(fp) (((((fp.l.upper) & 0xFFFFF) | HIDDEND) << 10) | \
|
|
(fp.l.lower >> 22))
|
|
#define HIDDEND_LL ((long long)1 << 52)
|
|
#define MANTD_LL(fp) ((fp.ll & (HIDDEND_LL-1)) | HIDDEND_LL)
|
|
#define PACKD_LL(s,e,m) (((long long)((s)+((e)<<20))<<32)|(m))
|
|
|
|
/* define SWAP for 386/960 reverse-byte-order brain-damaged CPUs */
|
|
union double_long {
|
|
double d;
|
|
#ifdef SWAP
|
|
struct {
|
|
unsigned long lower;
|
|
long upper;
|
|
} l;
|
|
#else
|
|
struct {
|
|
long upper;
|
|
unsigned long lower;
|
|
} l;
|
|
#endif
|
|
long long ll;
|
|
};
|
|
|
|
union float_long
|
|
{
|
|
float f;
|
|
long l;
|
|
};
|
|
|
|
/* add two floats */
|
|
float
|
|
__addsf3 (float a1, float a2)
|
|
{
|
|
register long mant1, mant2;
|
|
register union float_long fl1, fl2;
|
|
register int exp1, exp2;
|
|
int sign = 0;
|
|
|
|
fl1.f = a1;
|
|
fl2.f = a2;
|
|
|
|
/* check for zero args */
|
|
if (!fl1.l) {
|
|
fl1.f = fl2.f;
|
|
goto test_done;
|
|
}
|
|
if (!fl2.l)
|
|
goto test_done;
|
|
|
|
exp1 = EXP (fl1.l);
|
|
exp2 = EXP (fl2.l);
|
|
|
|
if (exp1 > exp2 + 25)
|
|
goto test_done;
|
|
if (exp2 > exp1 + 25) {
|
|
fl1.f = fl2.f;
|
|
goto test_done;
|
|
}
|
|
|
|
/* do everything in excess precision so's we can round later */
|
|
mant1 = MANT (fl1.l) << 6;
|
|
mant2 = MANT (fl2.l) << 6;
|
|
|
|
if (SIGN (fl1.l))
|
|
mant1 = -mant1;
|
|
if (SIGN (fl2.l))
|
|
mant2 = -mant2;
|
|
|
|
if (exp1 > exp2)
|
|
{
|
|
mant2 >>= exp1 - exp2;
|
|
}
|
|
else
|
|
{
|
|
mant1 >>= exp2 - exp1;
|
|
exp1 = exp2;
|
|
}
|
|
mant1 += mant2;
|
|
|
|
if (mant1 < 0)
|
|
{
|
|
mant1 = -mant1;
|
|
sign = SIGNBIT;
|
|
}
|
|
else if (!mant1) {
|
|
fl1.f = 0;
|
|
goto test_done;
|
|
}
|
|
|
|
/* normalize up */
|
|
while (!(mant1 & 0xE0000000))
|
|
{
|
|
mant1 <<= 1;
|
|
exp1--;
|
|
}
|
|
|
|
/* normalize down? */
|
|
if (mant1 & (1 << 30))
|
|
{
|
|
mant1 >>= 1;
|
|
exp1++;
|
|
}
|
|
|
|
/* round to even */
|
|
mant1 += (mant1 & 0x40) ? 0x20 : 0x1F;
|
|
|
|
/* normalize down? */
|
|
if (mant1 & (1 << 30))
|
|
{
|
|
mant1 >>= 1;
|
|
exp1++;
|
|
}
|
|
|
|
/* lose extra precision */
|
|
mant1 >>= 6;
|
|
|
|
/* turn off hidden bit */
|
|
mant1 &= ~HIDDEN;
|
|
|
|
/* pack up and go home */
|
|
fl1.l = PACK (sign, exp1, mant1);
|
|
test_done:
|
|
return (fl1.f);
|
|
}
|
|
|
|
/* subtract two floats */
|
|
float
|
|
__subsf3 (float a1, float a2)
|
|
{
|
|
register union float_long fl1, fl2;
|
|
|
|
fl1.f = a1;
|
|
fl2.f = a2;
|
|
|
|
/* check for zero args */
|
|
if (!fl2.l)
|
|
return (fl1.f);
|
|
if (!fl1.l)
|
|
return (-fl2.f);
|
|
|
|
/* twiddle sign bit and add */
|
|
fl2.l ^= SIGNBIT;
|
|
return __addsf3 (a1, fl2.f);
|
|
}
|
|
|
|
/* compare two floats */
|
|
long
|
|
__cmpsf2 (float a1, float a2)
|
|
{
|
|
register union float_long fl1, fl2;
|
|
|
|
fl1.f = a1;
|
|
fl2.f = a2;
|
|
|
|
if (SIGN (fl1.l) && SIGN (fl2.l))
|
|
{
|
|
fl1.l ^= SIGNBIT;
|
|
fl2.l ^= SIGNBIT;
|
|
}
|
|
if (fl1.l < fl2.l)
|
|
return (-1);
|
|
if (fl1.l > fl2.l)
|
|
return (1);
|
|
return (0);
|
|
}
|
|
|
|
/* multiply two floats */
|
|
float
|
|
__mulsf3 (float a1, float a2)
|
|
{
|
|
register union float_long fl1, fl2;
|
|
register unsigned long result;
|
|
register int exp;
|
|
int sign;
|
|
|
|
fl1.f = a1;
|
|
fl2.f = a2;
|
|
|
|
if (!fl1.l || !fl2.l) {
|
|
fl1.f = 0;
|
|
goto test_done;
|
|
}
|
|
|
|
/* compute sign and exponent */
|
|
sign = SIGN (fl1.l) ^ SIGN (fl2.l);
|
|
exp = EXP (fl1.l) - EXCESS;
|
|
exp += EXP (fl2.l);
|
|
|
|
fl1.l = MANT (fl1.l);
|
|
fl2.l = MANT (fl2.l);
|
|
|
|
/* the multiply is done as one 16x16 multiply and two 16x8 multiples */
|
|
result = (fl1.l >> 8) * (fl2.l >> 8);
|
|
result += ((fl1.l & 0xFF) * (fl2.l >> 8)) >> 8;
|
|
result += ((fl2.l & 0xFF) * (fl1.l >> 8)) >> 8;
|
|
|
|
result >>= 2;
|
|
if (result & 0x20000000)
|
|
{
|
|
/* round */
|
|
result += 0x20;
|
|
result >>= 6;
|
|
}
|
|
else
|
|
{
|
|
/* round */
|
|
result += 0x10;
|
|
result >>= 5;
|
|
exp--;
|
|
}
|
|
if (result & (HIDDEN<<1)) {
|
|
result >>= 1;
|
|
exp++;
|
|
}
|
|
|
|
result &= ~HIDDEN;
|
|
|
|
/* pack up and go home */
|
|
fl1.l = PACK (sign, exp, result);
|
|
test_done:
|
|
return (fl1.f);
|
|
}
|
|
|
|
/* divide two floats */
|
|
float
|
|
__divsf3 (float a1, float a2)
|
|
{
|
|
register union float_long fl1, fl2;
|
|
register int result;
|
|
register int mask;
|
|
register int exp, sign;
|
|
|
|
fl1.f = a1;
|
|
fl2.f = a2;
|
|
|
|
/* subtract exponents */
|
|
exp = EXP (fl1.l) - EXP (fl2.l) + EXCESS;
|
|
|
|
/* compute sign */
|
|
sign = SIGN (fl1.l) ^ SIGN (fl2.l);
|
|
|
|
/* divide by zero??? */
|
|
if (!fl2.l)
|
|
/* return NaN or -NaN */
|
|
return (sign ? 0xFFFFFFFF : 0x7FFFFFFF);
|
|
|
|
/* numerator zero??? */
|
|
if (!fl1.l)
|
|
return (0);
|
|
|
|
/* now get mantissas */
|
|
fl1.l = MANT (fl1.l);
|
|
fl2.l = MANT (fl2.l);
|
|
|
|
/* this assures we have 25 bits of precision in the end */
|
|
if (fl1.l < fl2.l)
|
|
{
|
|
fl1.l <<= 1;
|
|
exp--;
|
|
}
|
|
|
|
/* now we perform repeated subtraction of fl2.l from fl1.l */
|
|
mask = 0x1000000;
|
|
result = 0;
|
|
while (mask)
|
|
{
|
|
if (fl1.l >= fl2.l)
|
|
{
|
|
result |= mask;
|
|
fl1.l -= fl2.l;
|
|
}
|
|
fl1.l <<= 1;
|
|
mask >>= 1;
|
|
}
|
|
|
|
/* round */
|
|
result += 1;
|
|
|
|
/* normalize down */
|
|
exp++;
|
|
result >>= 1;
|
|
|
|
result &= ~HIDDEN;
|
|
|
|
/* pack up and go home */
|
|
fl1.l = PACK (sign, exp, result);
|
|
return (fl1.f);
|
|
}
|
|
|
|
/* convert int to double */
|
|
double
|
|
__floatsidf (register long a1)
|
|
{
|
|
register int sign = 0, exp = 31 + EXCESSD;
|
|
union double_long dl;
|
|
|
|
if (!a1)
|
|
{
|
|
dl.l.upper = dl.l.lower = 0;
|
|
return (dl.d);
|
|
}
|
|
|
|
if (a1 < 0)
|
|
{
|
|
sign = SIGNBIT;
|
|
a1 = -a1;
|
|
}
|
|
|
|
while (a1 < 0x1000000)
|
|
{
|
|
a1 <<= 4;
|
|
exp -= 4;
|
|
}
|
|
|
|
while (a1 < 0x40000000)
|
|
{
|
|
a1 <<= 1;
|
|
exp--;
|
|
}
|
|
|
|
/* pack up and go home */
|
|
dl.l.upper = sign;
|
|
dl.l.upper |= exp << 20;
|
|
dl.l.upper |= (a1 >> 10) & ~HIDDEND;
|
|
dl.l.lower = a1 << 22;
|
|
|
|
return (dl.d);
|
|
}
|
|
|
|
double
|
|
__floatdidf (register long long a1)
|
|
{
|
|
register int exp = 63 + EXCESSD;
|
|
union double_long dl;
|
|
|
|
dl.l.upper = dl.l.lower = 0;
|
|
if (a1 == 0)
|
|
return (dl.d);
|
|
|
|
if (a1 < 0) {
|
|
dl.l.upper = SIGNBIT;
|
|
a1 = -a1;
|
|
}
|
|
|
|
while (a1 < (long long)1<<54) {
|
|
a1 <<= 8;
|
|
exp -= 8;
|
|
}
|
|
while (a1 < (long long)1<<62) {
|
|
a1 <<= 1;
|
|
exp -= 1;
|
|
}
|
|
|
|
/* pack up and go home */
|
|
dl.ll |= (a1 >> 10) & ~HIDDEND_LL;
|
|
dl.l.upper |= exp << 20;
|
|
|
|
return (dl.d);
|
|
}
|
|
|
|
float
|
|
__floatsisf (register long a1)
|
|
{
|
|
(float)__floatsidf(a1);
|
|
}
|
|
|
|
float
|
|
__floatdisf (register long long a1)
|
|
{
|
|
(float)__floatdidf(a1);
|
|
}
|
|
|
|
/* negate a float */
|
|
float
|
|
__negsf2 (float a1)
|
|
{
|
|
register union float_long fl1;
|
|
|
|
fl1.f = a1;
|
|
if (!fl1.l)
|
|
return (0);
|
|
|
|
fl1.l ^= SIGNBIT;
|
|
return (fl1.f);
|
|
}
|
|
|
|
/* negate a double */
|
|
double
|
|
__negdf2 (double a1)
|
|
{
|
|
register union double_long dl1;
|
|
|
|
dl1.d = a1;
|
|
|
|
if (!dl1.l.upper && !dl1.l.lower)
|
|
return (dl1.d);
|
|
|
|
dl1.l.upper ^= SIGNBIT;
|
|
return (dl1.d);
|
|
}
|
|
|
|
/* convert float to double */
|
|
double
|
|
__extendsfdf2 (float a1)
|
|
{
|
|
register union float_long fl1;
|
|
register union double_long dl;
|
|
register int exp;
|
|
|
|
fl1.f = a1;
|
|
|
|
if (!fl1.l)
|
|
{
|
|
dl.l.upper = dl.l.lower = 0;
|
|
return (dl.d);
|
|
}
|
|
|
|
dl.l.upper = SIGN (fl1.l);
|
|
exp = EXP (fl1.l) - EXCESS + EXCESSD;
|
|
dl.l.upper |= exp << 20;
|
|
dl.l.upper |= (MANT (fl1.l) & ~HIDDEN) >> 3;
|
|
dl.l.lower = MANT (fl1.l) << 29;
|
|
|
|
return (dl.d);
|
|
}
|
|
|
|
/* convert double to float */
|
|
float
|
|
__truncdfsf2 (double a1)
|
|
{
|
|
register int exp;
|
|
register long mant;
|
|
register union float_long fl;
|
|
register union double_long dl1;
|
|
|
|
dl1.d = a1;
|
|
|
|
if (!dl1.l.upper && !dl1.l.lower)
|
|
return (float)(0);
|
|
|
|
exp = EXPD (dl1) - EXCESSD + EXCESS;
|
|
|
|
/* shift double mantissa 6 bits so we can round */
|
|
mant = MANTD (dl1) >> 6;
|
|
|
|
/* now round and shift down */
|
|
mant += 1;
|
|
mant >>= 1;
|
|
|
|
/* did the round overflow? */
|
|
if (mant & 0xFE000000)
|
|
{
|
|
mant >>= 1;
|
|
exp++;
|
|
}
|
|
|
|
mant &= ~HIDDEN;
|
|
|
|
/* pack up and go home */
|
|
fl.l = PACK (SIGND (dl1), exp, mant);
|
|
return (fl.f);
|
|
}
|
|
|
|
/* compare two doubles */
|
|
long
|
|
__cmpdf2 (double a1, double a2)
|
|
{
|
|
register union double_long dl1, dl2;
|
|
|
|
dl1.d = a1;
|
|
dl2.d = a2;
|
|
|
|
if (SIGND (dl1) && SIGND (dl2))
|
|
{
|
|
dl1.l.upper ^= SIGNBIT;
|
|
dl2.l.upper ^= SIGNBIT;
|
|
}
|
|
if (dl1.l.upper < dl2.l.upper)
|
|
return (-1);
|
|
if (dl1.l.upper > dl2.l.upper)
|
|
return (1);
|
|
if (dl1.l.lower < dl2.l.lower)
|
|
return (-1);
|
|
if (dl1.l.lower > dl2.l.lower)
|
|
return (1);
|
|
return (0);
|
|
}
|
|
|
|
/* convert double to int */
|
|
long
|
|
__fixdfsi (double a1)
|
|
{
|
|
register union double_long dl1;
|
|
register int exp;
|
|
register long l;
|
|
|
|
dl1.d = a1;
|
|
|
|
if (!dl1.l.upper && !dl1.l.lower)
|
|
return (0);
|
|
|
|
exp = EXPD (dl1) - EXCESSD - 31;
|
|
l = MANTD (dl1);
|
|
|
|
if (exp > 0)
|
|
return SIGND(dl1) ? (1<<31) : ((1ul<<31)-1);
|
|
|
|
/* shift down until exp = 0 or l = 0 */
|
|
if (exp < 0 && exp > -32 && l)
|
|
l >>= -exp;
|
|
else
|
|
return (0);
|
|
|
|
return (SIGND (dl1) ? -l : l);
|
|
}
|
|
|
|
/* convert double to int */
|
|
long long
|
|
__fixdfdi (double a1)
|
|
{
|
|
register union double_long dl1;
|
|
register int exp;
|
|
register long long l;
|
|
|
|
dl1.d = a1;
|
|
|
|
if (!dl1.l.upper && !dl1.l.lower)
|
|
return (0);
|
|
|
|
exp = EXPD (dl1) - EXCESSD - 64;
|
|
l = MANTD_LL(dl1);
|
|
|
|
if (exp > 0) {
|
|
l = (long long)1<<63;
|
|
if (!SIGND(dl1))
|
|
l--;
|
|
return l;
|
|
}
|
|
|
|
/* shift down until exp = 0 or l = 0 */
|
|
if (exp < 0 && exp > -64 && l)
|
|
l >>= -exp;
|
|
else
|
|
return (0);
|
|
|
|
return (SIGND (dl1) ? -l : l);
|
|
}
|
|
|
|
/* convert double to unsigned int */
|
|
unsigned long
|
|
__fixunsdfsi (double a1)
|
|
{
|
|
register union double_long dl1;
|
|
register int exp;
|
|
register unsigned long l;
|
|
|
|
dl1.d = a1;
|
|
|
|
if (!dl1.l.upper && !dl1.l.lower)
|
|
return (0);
|
|
|
|
exp = EXPD (dl1) - EXCESSD - 32;
|
|
l = (((((dl1.l.upper) & 0xFFFFF) | HIDDEND) << 11) | (dl1.l.lower >> 21));
|
|
|
|
if (exp > 0)
|
|
return (0xFFFFFFFFul); /* largest integer */
|
|
|
|
/* shift down until exp = 0 or l = 0 */
|
|
if (exp < 0 && exp > -32 && l)
|
|
l >>= -exp;
|
|
else
|
|
return (0);
|
|
|
|
return (l);
|
|
}
|
|
|
|
/* convert double to unsigned int */
|
|
unsigned long long
|
|
__fixunsdfdi (double a1)
|
|
{
|
|
register union double_long dl1;
|
|
register int exp;
|
|
register unsigned long long l;
|
|
|
|
dl1.d = a1;
|
|
|
|
if (dl1.ll == 0)
|
|
return (0);
|
|
|
|
exp = EXPD (dl1) - EXCESSD - 64;
|
|
|
|
l = dl1.ll;
|
|
|
|
if (exp > 0)
|
|
return (unsigned long long)-1;
|
|
|
|
/* shift down until exp = 0 or l = 0 */
|
|
if (exp < 0 && exp > -64 && l)
|
|
l >>= -exp;
|
|
else
|
|
return (0);
|
|
|
|
return (l);
|
|
}
|
|
|
|
/* addtwo doubles */
|
|
double
|
|
__adddf3 (double a1, double a2)
|
|
{
|
|
register long long mant1, mant2;
|
|
register union double_long fl1, fl2;
|
|
register int exp1, exp2;
|
|
int sign = 0;
|
|
|
|
fl1.d = a1;
|
|
fl2.d = a2;
|
|
|
|
/* check for zero args */
|
|
if (!fl2.ll)
|
|
goto test_done;
|
|
if (!fl1.ll) {
|
|
fl1.d = fl2.d;
|
|
goto test_done;
|
|
}
|
|
|
|
exp1 = EXPD(fl1);
|
|
exp2 = EXPD(fl2);
|
|
|
|
if (exp1 > exp2 + 54)
|
|
goto test_done;
|
|
if (exp2 > exp1 + 54) {
|
|
fl1.d = fl2.d;
|
|
goto test_done;
|
|
}
|
|
|
|
/* do everything in excess precision so's we can round later */
|
|
mant1 = MANTD_LL(fl1) << 9;
|
|
mant2 = MANTD_LL(fl2) << 9;
|
|
|
|
if (SIGND(fl1))
|
|
mant1 = -mant1;
|
|
if (SIGND(fl2))
|
|
mant2 = -mant2;
|
|
|
|
if (exp1 > exp2)
|
|
mant2 >>= exp1 - exp2;
|
|
else {
|
|
mant1 >>= exp2 - exp1;
|
|
exp1 = exp2;
|
|
}
|
|
mant1 += mant2;
|
|
|
|
if (mant1 < 0) {
|
|
mant1 = -mant1;
|
|
sign = SIGNBIT;
|
|
} else if (!mant1) {
|
|
fl1.d = 0;
|
|
goto test_done;
|
|
}
|
|
|
|
/* normalize up */
|
|
while (!(mant1 & ((long long)7<<61))) {
|
|
mant1 <<= 1;
|
|
exp1--;
|
|
}
|
|
|
|
/* normalize down? */
|
|
if (mant1 & ((long long)3<<62)) {
|
|
mant1 >>= 1;
|
|
exp1++;
|
|
}
|
|
|
|
/* round to even */
|
|
mant1 += (mant1 & (1<<9)) ? (1<<8) : ((1<<8)-1);
|
|
|
|
/* normalize down? */
|
|
if (mant1 & ((long long)3<<62)) {
|
|
mant1 >>= 1;
|
|
exp1++;
|
|
}
|
|
|
|
/* lose extra precision */
|
|
mant1 >>= 9;
|
|
|
|
/* turn off hidden bit */
|
|
mant1 &= ~HIDDEND_LL;
|
|
|
|
/* pack up and go home */
|
|
fl1.ll = PACKD_LL(sign,exp1,mant1);
|
|
|
|
test_done:
|
|
return (fl1.d);
|
|
}
|
|
|
|
/* subtract two doubles */
|
|
double
|
|
__subdf3 (double a1, double a2)
|
|
{
|
|
register union double_long fl1, fl2;
|
|
|
|
fl1.d = a1;
|
|
fl2.d = a2;
|
|
|
|
/* check for zero args */
|
|
if (!fl2.ll)
|
|
return (fl1.d);
|
|
/* twiddle sign bit and add */
|
|
fl2.l.upper ^= SIGNBIT;
|
|
if (!fl1.ll)
|
|
return (fl2.d);
|
|
return __adddf3 (a1, fl2.d);
|
|
}
|
|
|
|
/* multiply two doubles */
|
|
double
|
|
__muldf3 (double a1, double a2)
|
|
{
|
|
register union double_long fl1, fl2;
|
|
register unsigned long long result;
|
|
register int exp;
|
|
int sign;
|
|
|
|
fl1.d = a1;
|
|
fl2.d = a2;
|
|
|
|
if (!fl1.ll || !fl2.ll) {
|
|
fl1.d = 0;
|
|
goto test_done;
|
|
}
|
|
|
|
/* compute sign and exponent */
|
|
sign = SIGND(fl1) ^ SIGND(fl2);
|
|
exp = EXPD(fl1) - EXCESSD;
|
|
exp += EXPD(fl2);
|
|
|
|
fl1.ll = MANTD_LL(fl1);
|
|
fl2.ll = MANTD_LL(fl2);
|
|
|
|
/* the multiply is done as one 31x31 multiply and two 31x21 multiples */
|
|
result = (fl1.ll >> 21) * (fl2.ll >> 21);
|
|
result += ((fl1.ll & 0x1FFFFF) * (fl2.ll >> 21)) >> 21;
|
|
result += ((fl2.ll & 0x1FFFFF) * (fl1.ll >> 21)) >> 21;
|
|
|
|
result >>= 2;
|
|
if (result & ((long long)1<<61)) {
|
|
/* round */
|
|
result += 1<<8;
|
|
result >>= 9;
|
|
} else {
|
|
/* round */
|
|
result += 1<<7;
|
|
result >>= 8;
|
|
exp--;
|
|
}
|
|
if (result & (HIDDEND_LL<<1)) {
|
|
result >>= 1;
|
|
exp++;
|
|
}
|
|
|
|
result &= ~HIDDEND_LL;
|
|
|
|
/* pack up and go home */
|
|
fl1.ll = PACKD_LL(sign,exp,result);
|
|
test_done:
|
|
return (fl1.d);
|
|
}
|
|
|
|
/* divide two doubles */
|
|
double
|
|
__divdf3 (double a1, double a2)
|
|
{
|
|
register union double_long fl1, fl2;
|
|
register long long mask,result;
|
|
register int exp, sign;
|
|
|
|
fl1.d = a1;
|
|
fl2.d = a2;
|
|
|
|
/* subtract exponents */
|
|
exp = EXPD(fl1) - EXPD(fl2) + EXCESSD;
|
|
|
|
/* compute sign */
|
|
sign = SIGND(fl1) ^ SIGND(fl2);
|
|
|
|
/* numerator zero??? */
|
|
if (fl1.ll == 0) {
|
|
/* divide by zero??? */
|
|
if (fl2.ll == 0)
|
|
fl1.ll = ((unsigned long long)1<<63)-1; /* NaN */
|
|
else
|
|
fl1.ll = 0;
|
|
goto test_done;
|
|
}
|
|
|
|
/* return +Inf or -Inf */
|
|
if (fl2.ll == 0) {
|
|
fl1.ll = PACKD_LL(SIGND(fl1),2047,0);
|
|
goto test_done;
|
|
}
|
|
|
|
|
|
/* now get mantissas */
|
|
fl1.ll = MANTD_LL(fl1);
|
|
fl2.ll = MANTD_LL(fl2);
|
|
|
|
/* this assures we have 54 bits of precision in the end */
|
|
if (fl1.ll < fl2.ll) {
|
|
fl1.ll <<= 1;
|
|
exp--;
|
|
}
|
|
|
|
/* now we perform repeated subtraction of fl2.ll from fl1.ll */
|
|
mask = (long long)1<<53;
|
|
result = 0;
|
|
while (mask) {
|
|
if (fl1.ll >= fl2.ll)
|
|
{
|
|
result |= mask;
|
|
fl1.ll -= fl2.ll;
|
|
}
|
|
fl1.ll <<= 1;
|
|
mask >>= 1;
|
|
}
|
|
|
|
/* round */
|
|
result += 1;
|
|
|
|
/* normalize down */
|
|
exp++;
|
|
result >>= 1;
|
|
|
|
result &= ~HIDDEND_LL;
|
|
|
|
/* pack up and go home */
|
|
fl1.ll = PACKD_LL(sign, exp, result);
|
|
|
|
test_done:
|
|
return (fl1.d);
|
|
}
|
|
|
|
int
|
|
__gtdf2 (double a1, double a2)
|
|
{
|
|
return __cmpdf2 ((float) a1, (float) a2) > 0;
|
|
}
|
|
|
|
int
|
|
__gedf2 (double a1, double a2)
|
|
{
|
|
return (__cmpdf2 ((float) a1, (float) a2) >= 0) - 1;
|
|
}
|
|
|
|
int
|
|
__ltdf2 (double a1, double a2)
|
|
{
|
|
return - (__cmpdf2 ((float) a1, (float) a2) < 0);
|
|
}
|
|
|
|
int
|
|
__ledf2 (double a1, double a2)
|
|
{
|
|
return __cmpdf2 ((float) a1, (float) a2) > 0;
|
|
}
|
|
|
|
int
|
|
__eqdf2 (double a1, double a2)
|
|
{
|
|
return *(long long *) &a1 == *(long long *) &a2;
|
|
}
|
|
|
|
int
|
|
__nedf2 (double a1, double a2)
|
|
{
|
|
return *(long long *) &a1 != *(long long *) &a2;
|
|
}
|