aboutsummaryrefslogtreecommitdiff
path: root/libgcc/config/libbid/bid64_next.c
diff options
context:
space:
mode:
Diffstat (limited to 'libgcc/config/libbid/bid64_next.c')
-rw-r--r--libgcc/config/libbid/bid64_next.c314
1 files changed, 177 insertions, 137 deletions
diff --git a/libgcc/config/libbid/bid64_next.c b/libgcc/config/libbid/bid64_next.c
index 62fd091f85f..158121e788a 100644
--- a/libgcc/config/libbid/bid64_next.c
+++ b/libgcc/config/libbid/bid64_next.c
@@ -34,13 +34,13 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
#if DECIMAL_CALL_BY_REFERENCE
void
-__bid64_nextup (UINT64 * pres,
+bid64_nextup (UINT64 * pres,
UINT64 *
px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
UINT64 x = *px;
#else
UINT64
-__bid64_nextup (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+bid64_nextup (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
_EXC_INFO_PARAM) {
#endif
@@ -50,107 +50,112 @@ __bid64_nextup (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
BID_UI64DOUBLE tmp1;
int x_nr_bits;
int q1, ind;
- UINT64 C1; // C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (UINT64)
+ UINT64 C1; // C1 represents x_signif (UINT64)
// check for NaNs and infinities
- if ((x & MASK_SNAN) == MASK_SNAN) { // check for SNaN
- // set invalid flag
- *pfpsf |= INVALID_EXCEPTION;
- // return quiet (SNaN)
- res = x & 0xfdffffffffffffffull;
- BID_RETURN (res);
- } else if ((x & MASK_NAN) == MASK_NAN) { // check for QNaN
- res = x;
+ if ((x & MASK_NAN) == MASK_NAN) { // check for NaN
+ if ((x & 0x0003ffffffffffffull) > 999999999999999ull)
+ x = x & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
+ else
+ x = x & 0xfe03ffffffffffffull; // clear G6-G12
+ if ((x & MASK_SNAN) == MASK_SNAN) { // SNaN
+ // set invalid flag
+ *pfpsf |= INVALID_EXCEPTION;
+ // return quiet (SNaN)
+ res = x & 0xfdffffffffffffffull;
+ } else { // QNaN
+ res = x;
+ }
BID_RETURN (res);
- } else if ((x & MASK_INF) == MASK_INF) { // check for Infinity
- if (!(x & 0x8000000000000000ull)) { // x is +inf
+ } else if ((x & MASK_INF) == MASK_INF) { // check for Infinity
+ if (!(x & 0x8000000000000000ull)) { // x is +inf
res = 0x7800000000000000ull;
- } else { // x is -inf
- res = 0xf7fb86f26fc0ffffull; // -MAXFP = -999...99 * 10^emax
+ } else { // x is -inf
+ res = 0xf7fb86f26fc0ffffull; // -MAXFP = -999...99 * 10^emax
}
BID_RETURN (res);
}
// unpack the argument
- x_sign = x & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
+ x_sign = x & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
// if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
- x_exp = (x & MASK_BINARY_EXPONENT2) >> 51; // biased
+ x_exp = (x & MASK_BINARY_EXPONENT2) >> 51; // biased
C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
- if (C1 > 9999999999999999ull) { // non-canonical
+ if (C1 > 9999999999999999ull) { // non-canonical
x_exp = 0;
C1 = 0;
}
} else {
- x_exp = (x & MASK_BINARY_EXPONENT1) >> 53; // biased
+ x_exp = (x & MASK_BINARY_EXPONENT1) >> 53; // biased
C1 = x & MASK_BINARY_SIG1;
}
// check for zeros (possibly from non-canonical values)
if (C1 == 0x0ull) {
// x is 0
- res = 0x0000000000000001ull; // MINFP = 1 * 10^emin
- } else { // x is not special and is not zero
+ res = 0x0000000000000001ull; // MINFP = 1 * 10^emin
+ } else { // x is not special and is not zero
if (x == 0x77fb86f26fc0ffffull) {
// x = +MAXFP = 999...99 * 10^emax
- res = 0x7800000000000000ull; // +inf
+ res = 0x7800000000000000ull; // +inf
} else if (x == 0x8000000000000001ull) {
// x = -MINFP = 1...99 * 10^emin
- res = 0x8000000000000000ull; // -0
- } else { // -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
+ res = 0x8000000000000000ull; // -0
+ } else { // -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
// can add/subtract 1 ulp to the significand
// Note: we could check here if x >= 10^16 to speed up the case q1 =16
// q1 = nr. of decimal digits in x (1 <= q1 <= 54)
// determine first the nr. of bits in x
- if (C1 >= MASK_BINARY_OR2) { // x >= 2^53
+ if (C1 >= MASK_BINARY_OR2) { // x >= 2^53
// split the 64-bit value in two 32-bit halves to avoid rounding errors
- if (C1 >= 0x0000000100000000ull) { // x >= 2^32
- tmp1.d = (double) (C1 >> 32); // exact conversion
+ if (C1 >= 0x0000000100000000ull) { // x >= 2^32
+ tmp1.d = (double) (C1 >> 32); // exact conversion
x_nr_bits =
33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
- } else { // x < 2^32
- tmp1.d = (double) C1; // exact conversion
+ } else { // x < 2^32
+ tmp1.d = (double) C1; // exact conversion
x_nr_bits =
1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
}
- } else { // if x < 2^53
- tmp1.d = (double) C1; // exact conversion
+ } else { // if x < 2^53
+ tmp1.d = (double) C1; // exact conversion
x_nr_bits =
1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
}
- q1 = __bid_nr_digits[x_nr_bits - 1].digits;
+ q1 = nr_digits[x_nr_bits - 1].digits;
if (q1 == 0) {
- q1 = __bid_nr_digits[x_nr_bits - 1].digits1;
- if (C1 >= __bid_nr_digits[x_nr_bits - 1].threshold_lo)
+ q1 = nr_digits[x_nr_bits - 1].digits1;
+ if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
q1++;
}
// if q1 < P16 then pad the significand with zeros
if (q1 < P16) {
- if ((SINT64)x_exp > P16 - q1) {
- ind = P16 - q1; // 1 <= ind <= P16 - 1
+ if (x_exp > (UINT64) (P16 - q1)) {
+ ind = P16 - q1; // 1 <= ind <= P16 - 1
// pad with P16 - q1 zeros, until exponent = emin
// C1 = C1 * 10^ind
- C1 = C1 * __bid_ten2k64[ind];
+ C1 = C1 * ten2k64[ind];
x_exp = x_exp - ind;
- } else { // pad with zeros until the exponent reaches emin
+ } else { // pad with zeros until the exponent reaches emin
ind = x_exp;
- C1 = C1 * __bid_ten2k64[ind];
+ C1 = C1 * ten2k64[ind];
x_exp = EXP_MIN;
}
}
- if (!x_sign) { // x > 0
+ if (!x_sign) { // x > 0
// add 1 ulp (add 1 to the significand)
C1++;
- if (C1 == 0x002386f26fc10000ull) { // if C1 = 10^16
- C1 = 0x00038d7ea4c68000ull; // C1 = 10^15
+ if (C1 == 0x002386f26fc10000ull) { // if C1 = 10^16
+ C1 = 0x00038d7ea4c68000ull; // C1 = 10^15
x_exp++;
}
// Ok, because MAXFP = 999...99 * 10^emax was caught already
- } else { // x < 0
+ } else { // x < 0
// subtract 1 ulp (subtract 1 from the significand)
C1--;
- if (C1 == 0x00038d7ea4c67fffull && x_exp != 0) { // if C1 = 10^15 - 1
- C1 = 0x002386f26fc0ffffull; // C1 = 10^16 - 1
+ if (C1 == 0x00038d7ea4c67fffull && x_exp != 0) { // if C1 = 10^15 - 1
+ C1 = 0x002386f26fc0ffffull; // C1 = 10^16 - 1
x_exp--;
}
}
@@ -160,11 +165,11 @@ __bid64_nextup (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
res =
x_sign | (x_exp << 51) | MASK_STEERING_BITS | (C1 &
MASK_BINARY_SIG2);
- } else { // significand fits in 53 bits
+ } else { // significand fits in 53 bits
res = x_sign | (x_exp << 53) | C1;
}
- } // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
- } // end x is not special and is not zero
+ } // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
+ } // end x is not special and is not zero
BID_RETURN (res);
}
@@ -174,13 +179,13 @@ __bid64_nextup (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
#if DECIMAL_CALL_BY_REFERENCE
void
-__bid64_nextdown (UINT64 * pres,
+bid64_nextdown (UINT64 * pres,
UINT64 *
px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
UINT64 x = *px;
#else
UINT64
-__bid64_nextdown (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+bid64_nextdown (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
_EXC_INFO_PARAM) {
#endif
@@ -190,108 +195,113 @@ __bid64_nextdown (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
BID_UI64DOUBLE tmp1;
int x_nr_bits;
int q1, ind;
- UINT64 C1; // C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (UINT64)
+ UINT64 C1; // C1 represents x_signif (UINT64)
// check for NaNs and infinities
- if ((x & MASK_SNAN) == MASK_SNAN) { // check for SNaN
- // set invalid flag
- *pfpsf |= INVALID_EXCEPTION;
- // return quiet (SNaN)
- res = x & 0xfdffffffffffffffull;
- BID_RETURN (res);
- } else if ((x & MASK_NAN) == MASK_NAN) { // check for QNaN
- res = x;
+ if ((x & MASK_NAN) == MASK_NAN) { // check for NaN
+ if ((x & 0x0003ffffffffffffull) > 999999999999999ull)
+ x = x & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
+ else
+ x = x & 0xfe03ffffffffffffull; // clear G6-G12
+ if ((x & MASK_SNAN) == MASK_SNAN) { // SNaN
+ // set invalid flag
+ *pfpsf |= INVALID_EXCEPTION;
+ // return quiet (SNaN)
+ res = x & 0xfdffffffffffffffull;
+ } else { // QNaN
+ res = x;
+ }
BID_RETURN (res);
- } else if ((x & MASK_INF) == MASK_INF) { // check for Infinity
- if (x & 0x8000000000000000ull) { // x is -inf
+ } else if ((x & MASK_INF) == MASK_INF) { // check for Infinity
+ if (x & 0x8000000000000000ull) { // x is -inf
res = 0xf800000000000000ull;
- } else { // x is +inf
- res = 0x77fb86f26fc0ffffull; // +MAXFP = +999...99 * 10^emax
+ } else { // x is +inf
+ res = 0x77fb86f26fc0ffffull; // +MAXFP = +999...99 * 10^emax
}
BID_RETURN (res);
}
// unpack the argument
- x_sign = x & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
+ x_sign = x & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
// if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
- x_exp = (x & MASK_BINARY_EXPONENT2) >> 51; // biased
+ x_exp = (x & MASK_BINARY_EXPONENT2) >> 51; // biased
C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
- if (C1 > 9999999999999999ull) { // non-canonical
+ if (C1 > 9999999999999999ull) { // non-canonical
x_exp = 0;
C1 = 0;
}
} else {
- x_exp = (x & MASK_BINARY_EXPONENT1) >> 53; // biased
+ x_exp = (x & MASK_BINARY_EXPONENT1) >> 53; // biased
C1 = x & MASK_BINARY_SIG1;
}
// check for zeros (possibly from non-canonical values)
if (C1 == 0x0ull) {
// x is 0
- res = 0x8000000000000001ull; // -MINFP = -1 * 10^emin
- } else { // x is not special and is not zero
+ res = 0x8000000000000001ull; // -MINFP = -1 * 10^emin
+ } else { // x is not special and is not zero
if (x == 0xf7fb86f26fc0ffffull) {
// x = -MAXFP = -999...99 * 10^emax
- res = 0xf800000000000000ull; // -inf
+ res = 0xf800000000000000ull; // -inf
} else if (x == 0x0000000000000001ull) {
// x = +MINFP = 1...99 * 10^emin
- res = 0x0000000000000000ull; // -0
- } else { // -MAXFP + 1ulp <= x <= -MINFP OR MINFP + 1 ulp <= x <= MAXFP
+ res = 0x0000000000000000ull; // -0
+ } else { // -MAXFP + 1ulp <= x <= -MINFP OR MINFP + 1 ulp <= x <= MAXFP
// can add/subtract 1 ulp to the significand
// Note: we could check here if x >= 10^16 to speed up the case q1 =16
// q1 = nr. of decimal digits in x (1 <= q1 <= 16)
// determine first the nr. of bits in x
- if (C1 >= 0x0020000000000000ull) { // x >= 2^53
+ if (C1 >= 0x0020000000000000ull) { // x >= 2^53
// split the 64-bit value in two 32-bit halves to avoid
// rounding errors
- if (C1 >= 0x0000000100000000ull) { // x >= 2^32
- tmp1.d = (double) (C1 >> 32); // exact conversion
+ if (C1 >= 0x0000000100000000ull) { // x >= 2^32
+ tmp1.d = (double) (C1 >> 32); // exact conversion
x_nr_bits =
33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
- } else { // x < 2^32
- tmp1.d = (double) C1; // exact conversion
+ } else { // x < 2^32
+ tmp1.d = (double) C1; // exact conversion
x_nr_bits =
1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
}
- } else { // if x < 2^53
- tmp1.d = (double) C1; // exact conversion
+ } else { // if x < 2^53
+ tmp1.d = (double) C1; // exact conversion
x_nr_bits =
1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
}
- q1 = __bid_nr_digits[x_nr_bits - 1].digits;
+ q1 = nr_digits[x_nr_bits - 1].digits;
if (q1 == 0) {
- q1 = __bid_nr_digits[x_nr_bits - 1].digits1;
- if (C1 >= __bid_nr_digits[x_nr_bits - 1].threshold_lo)
+ q1 = nr_digits[x_nr_bits - 1].digits1;
+ if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)
q1++;
}
// if q1 < P16 then pad the significand with zeros
if (q1 < P16) {
- if ((SINT64)x_exp > P16 - q1) {
- ind = P16 - q1; // 1 <= ind <= P16 - 1
+ if (x_exp > (UINT64) (P16 - q1)) {
+ ind = P16 - q1; // 1 <= ind <= P16 - 1
// pad with P16 - q1 zeros, until exponent = emin
// C1 = C1 * 10^ind
- C1 = C1 * __bid_ten2k64[ind];
+ C1 = C1 * ten2k64[ind];
x_exp = x_exp - ind;
- } else { // pad with zeros until the exponent reaches emin
+ } else { // pad with zeros until the exponent reaches emin
ind = x_exp;
- C1 = C1 * __bid_ten2k64[ind];
+ C1 = C1 * ten2k64[ind];
x_exp = EXP_MIN;
}
}
- if (x_sign) { // x < 0
+ if (x_sign) { // x < 0
// add 1 ulp (add 1 to the significand)
C1++;
- if (C1 == 0x002386f26fc10000ull) { // if C1 = 10^16
- C1 = 0x00038d7ea4c68000ull; // C1 = 10^15
+ if (C1 == 0x002386f26fc10000ull) { // if C1 = 10^16
+ C1 = 0x00038d7ea4c68000ull; // C1 = 10^15
x_exp++;
// Ok, because -MAXFP = -999...99 * 10^emax was caught already
}
- } else { // x > 0
+ } else { // x > 0
// subtract 1 ulp (subtract 1 from the significand)
C1--;
- if (C1 == 0x00038d7ea4c67fffull && x_exp != 0) { // if C1 = 10^15 - 1
- C1 = 0x002386f26fc0ffffull; // C1 = 10^16 - 1
+ if (C1 == 0x00038d7ea4c67fffull && x_exp != 0) { // if C1 = 10^15 - 1
+ C1 = 0x002386f26fc0ffffull; // C1 = 10^16 - 1
x_exp--;
}
}
@@ -301,11 +311,11 @@ __bid64_nextdown (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
res =
x_sign | (x_exp << 51) | MASK_STEERING_BITS | (C1 &
MASK_BINARY_SIG2);
- } else { // significand fits in 53 bits
+ } else { // significand fits in 53 bits
res = x_sign | (x_exp << 53) | C1;
}
- } // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
- } // end x is not special and is not zero
+ } // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
+ } // end x is not special and is not zero
BID_RETURN (res);
}
@@ -315,37 +325,40 @@ __bid64_nextdown (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
#if DECIMAL_CALL_BY_REFERENCE
void
-__bid64_nextafter (UINT64 * pres, UINT64 * px,
+bid64_nextafter (UINT64 * pres, UINT64 * px,
UINT64 *
py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
UINT64 x = *px;
UINT64 y = *py;
#else
UINT64
-__bid64_nextafter (UINT64 x,
+bid64_nextafter (UINT64 x,
UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
_EXC_INFO_PARAM) {
#endif
UINT64 res;
UINT64 tmp1, tmp2;
- FPSC tmp_fpsf = 0; // dummy fpsf for calls to comparison functions
+ FPSC tmp_fpsf = 0; // dummy fpsf for calls to comparison functions
int res1, res2;
+ // check for NaNs or infinities
+ if (((x & MASK_SPECIAL) == MASK_SPECIAL) ||
+ ((y & MASK_SPECIAL) == MASK_SPECIAL)) {
+ // x is NaN or infinity or y is NaN or infinity
- // check for NaNs
- if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
- // x is NaN or y is NaN
-
- if ((x & MASK_NAN) == MASK_NAN) { // x is NAN
- if ((x & MASK_SNAN) == MASK_SNAN) { // x is SNAN
+ if ((x & MASK_NAN) == MASK_NAN) { // x is NAN
+ if ((x & 0x0003ffffffffffffull) > 999999999999999ull)
+ x = x & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
+ else
+ x = x & 0xfe03ffffffffffffull; // clear G6-G12
+ if ((x & MASK_SNAN) == MASK_SNAN) { // x is SNAN
// set invalid flag
*pfpsf |= INVALID_EXCEPTION;
// return quiet (x)
res = x & 0xfdffffffffffffffull;
- res = x;
- } else { // x is QNaN
- if ((y & MASK_SNAN) == MASK_SNAN) { // y is SNAN
+ } else { // x is QNaN
+ if ((y & MASK_SNAN) == MASK_SNAN) { // y is SNAN
// set invalid flag
*pfpsf |= INVALID_EXCEPTION;
}
@@ -353,54 +366,81 @@ __bid64_nextafter (UINT64 x,
res = x;
}
BID_RETURN (res);
- } else if ((y & MASK_NAN) == MASK_NAN) { // y is NAN
- if ((y & MASK_SNAN) == MASK_SNAN) { // y is SNAN
+ } else if ((y & MASK_NAN) == MASK_NAN) { // y is NAN
+ if ((y & 0x0003ffffffffffffull) > 999999999999999ull)
+ y = y & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
+ else
+ y = y & 0xfe03ffffffffffffull; // clear G6-G12
+ if ((y & MASK_SNAN) == MASK_SNAN) { // y is SNAN
// set invalid flag
*pfpsf |= INVALID_EXCEPTION;
// return quiet (y)
res = y & 0xfdffffffffffffffull;
- res = y;
- } else { // y is QNaN
+ } else { // y is QNaN
// return y
res = y;
}
BID_RETURN (res);
- } else {
- ; // let infinities fall through
+ } else { // at least one is infinity
+ if ((x & MASK_ANY_INF) == MASK_INF) { // x = inf
+ x = x & (MASK_SIGN | MASK_INF);
+ }
+ if ((y & MASK_ANY_INF) == MASK_INF) { // y = inf
+ y = y & (MASK_SIGN | MASK_INF);
+ }
}
}
// neither x nor y is NaN
- tmp_fpsf = *pfpsf; // save fpsf
+
+ // if not infinity, check for non-canonical values x (treated as zero)
+ if ((x & MASK_ANY_INF) != MASK_INF) { // x != inf
+ // unpack x
+ if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
+ // if the steering bits are 11 (condition will be 0), then
+ // the exponent is G[0:w+1]
+ if (((x & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >
+ 9999999999999999ull) {
+ // non-canonical
+ x = (x & MASK_SIGN) | ((x & MASK_BINARY_EXPONENT2) << 2);
+ }
+ } else { // if ((x & MASK_STEERING_BITS) != MASK_STEERING_BITS) x is unch.
+ ; // canonical
+ }
+ }
+ // no need to check for non-canonical y
+
+ // neither x nor y is NaN
+ tmp_fpsf = *pfpsf; // save fpsf
#if DECIMAL_CALL_BY_REFERENCE
- __bid64_quiet_equal (&res1, px,
+ bid64_quiet_equal (&res1, px,
py _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
- __bid64_quiet_greater (&res2, px,
+ bid64_quiet_greater (&res2, px,
py _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
#else
res1 =
- __bid64_quiet_equal (x,
+ bid64_quiet_equal (x,
y _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
res2 =
- __bid64_quiet_greater (x,
+ bid64_quiet_greater (x,
y _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
#endif
- *pfpsf = tmp_fpsf; // restore fpsf
- if (res1) { // x = y
+ *pfpsf = tmp_fpsf; // restore fpsf
+ if (res1) { // x = y
// return x with the sign of y
- res = (x & 0x7fffffffffffffffull) | (y & 0x8000000000000000ull);
- } else if (res2) { // x > y
+ res = (y & 0x8000000000000000ull) | (x & 0x7fffffffffffffffull);
+ } else if (res2) { // x > y
#if DECIMAL_CALL_BY_REFERENCE
- __bid64_nextdown (&res,
+ bid64_nextdown (&res,
px _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
#else
res =
- __bid64_nextdown (x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ bid64_nextdown (x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
#endif
- } else { // x < y
+ } else { // x < y
#if DECIMAL_CALL_BY_REFERENCE
- __bid64_nextup (&res, px _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ bid64_nextup (&res, px _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
#else
- res = __bid64_nextup (x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ res = bid64_nextup (x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
#endif
}
// if the operand x is finite but the result is infinite, signal
@@ -413,30 +453,30 @@ __bid64_nextafter (UINT64 x,
}
// if the result is in (-10^emin, 10^emin), and is different from the
// operand x, signal underflow and inexact
- tmp1 = 0x00038d7ea4c68000ull; // +100...0[16] * 10^emin
+ tmp1 = 0x00038d7ea4c68000ull; // +100...0[16] * 10^emin
tmp2 = res & 0x7fffffffffffffffull;
- tmp_fpsf = *pfpsf; // save fpsf
+ tmp_fpsf = *pfpsf; // save fpsf
#if DECIMAL_CALL_BY_REFERENCE
- __bid64_quiet_greater (&res1, &tmp1,
+ bid64_quiet_greater (&res1, &tmp1,
&tmp2 _EXC_FLAGS_ARG _EXC_MASKS_ARG
_EXC_INFO_ARG);
- __bid64_quiet_not_equal (&res2, &x,
+ bid64_quiet_not_equal (&res2, &x,
&res _EXC_FLAGS_ARG _EXC_MASKS_ARG
_EXC_INFO_ARG);
#else
res1 =
- __bid64_quiet_greater (tmp1,
+ bid64_quiet_greater (tmp1,
tmp2 _EXC_FLAGS_ARG _EXC_MASKS_ARG
_EXC_INFO_ARG);
res2 =
- __bid64_quiet_not_equal (x,
+ bid64_quiet_not_equal (x,
res _EXC_FLAGS_ARG _EXC_MASKS_ARG
_EXC_INFO_ARG);
#endif
- *pfpsf = tmp_fpsf; // restore fpsf
+ *pfpsf = tmp_fpsf; // restore fpsf
if (res1 && res2) {
- // if (__bid64_quiet_greater (tmp1, tmp2, &tmp_fpsf) &&
- // __bid64_quiet_not_equal (x, res, &tmp_fpsf)) {
+ // if (bid64_quiet_greater (tmp1, tmp2, &tmp_fpsf) &&
+ // bid64_quiet_not_equal (x, res, &tmp_fpsf)) {
// set the inexact flag
*pfpsf |= INEXACT_EXCEPTION;
// set the underflow flag
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-19 13:32:55 +0000