URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [libbid/] [bid128_next.c] - Rev 749
Go to most recent revision | Compare with Previous | Blame | View Log
/* Copyright (C) 2007, 2009 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. */ #define BID_128RES #include "bid_internal.h" /***************************************************************************** * BID128 nextup ****************************************************************************/ #if DECIMAL_CALL_BY_REFERENCE void bid128_nextup (UINT128 * pres, UINT128 * px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) { UINT128 x = *px; #else UINT128 bid128_nextup (UINT128 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) { #endif UINT128 res; UINT64 x_sign; UINT64 x_exp; int exp; BID_UI64DOUBLE tmp1; int x_nr_bits; int q1, ind; UINT128 C1; // C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (UINT64) BID_SWAP128 (x); // unpack the argument x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative C1.w[1] = x.w[1] & MASK_COEFF; C1.w[0] = x.w[0]; // check for NaN or Infinity if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { // x is special if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN // if x = NaN, then res = Q (x) // check first for non-canonical NaN payload if (((x.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) || (((x.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) && (x.w[0] > 0x38c15b09ffffffffull))) { x.w[1] = x.w[1] & 0xffffc00000000000ull; x.w[0] = 0x0ull; } if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN // set invalid flag *pfpsf |= INVALID_EXCEPTION; // return quiet (x) res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out also G[6]-G[16] res.w[0] = x.w[0]; } else { // x is QNaN // return x res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out G[6]-G[16] res.w[0] = x.w[0]; } } else { // x is not NaN, so it must be infinity if (!x_sign) { // x is +inf res.w[1] = 0x7800000000000000ull; // +inf res.w[0] = 0x0000000000000000ull; } else { // x is -inf res.w[1] = 0xdfffed09bead87c0ull; // -MAXFP = -999...99 * 10^emax res.w[0] = 0x378d8e63ffffffffull; } } BID_RETURN (res); } // check for non-canonical values (treated as zero) if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11 // non-canonical x_exp = (x.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits C1.w[1] = 0; // significand high C1.w[0] = 0; // significand low } else { // G0_G1 != 11 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bits if (C1.w[1] > 0x0001ed09bead87c0ull || (C1.w[1] == 0x0001ed09bead87c0ull && C1.w[0] > 0x378d8e63ffffffffull)) { // x is non-canonical if coefficient is larger than 10^34 -1 C1.w[1] = 0; C1.w[0] = 0; } else { // canonical ; } } if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { // x is +/-0 res.w[1] = 0x0000000000000000ull; // +1 * 10^emin res.w[0] = 0x0000000000000001ull; } else { // x is not special and is not zero if (x.w[1] == 0x5fffed09bead87c0ull && x.w[0] == 0x378d8e63ffffffffull) { // x = +MAXFP = 999...99 * 10^emax res.w[1] = 0x7800000000000000ull; // +inf res.w[0] = 0x0000000000000000ull; } else if (x.w[1] == 0x8000000000000000ull && x.w[0] == 0x0000000000000001ull) { // x = -MINFP = 1...99 * 10^emin res.w[1] = 0x8000000000000000ull; // -0 res.w[0] = 0x0000000000000000ull; } 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^34 to speed up the case q1 = 34 // q1 = nr. of decimal digits in x // determine first the nr. of bits in x if (C1.w[1] == 0) { if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 // split the 64-bit value in two 32-bit halves to avoid rnd errors if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion x_nr_bits = 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); } else { // x < 2^32 tmp1.d = (double) (C1.w[0]); // exact conversion x_nr_bits = 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); } } else { // if x < 2^53 tmp1.d = (double) C1.w[0]; // exact conversion x_nr_bits = 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); } } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) tmp1.d = (double) C1.w[1]; // exact conversion x_nr_bits = 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); } q1 = nr_digits[x_nr_bits - 1].digits; if (q1 == 0) { q1 = nr_digits[x_nr_bits - 1].digits1; if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) q1++; } // if q1 < P34 then pad the significand with zeros if (q1 < P34) { exp = (x_exp >> 49) - 6176; if (exp + 6176 > P34 - q1) { ind = P34 - q1; // 1 <= ind <= P34 - 1 // pad with P34 - q1 zeros, until exponent = emin // C1 = C1 * 10^ind if (q1 <= 19) { // 64-bit C1 if (ind <= 19) { // 64-bit 10^ind and 64-bit C1 __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]); } else { // 128-bit 10^ind and 64-bit C1 __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]); } } else { // C1 is (most likely) 128-bit if (ind <= 14) { // 64-bit 10^ind and 128-bit C1 (most likely) __mul_128x64_to_128 (C1, ten2k64[ind], C1); } else if (ind <= 19) { // 64-bit 10^ind and 64-bit C1 (q1 <= 19) __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]); } else { // 128-bit 10^ind and 64-bit C1 (C1 must be 64-bit) __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]); } } x_exp = x_exp - ((UINT64) ind << 49); } else { // pad with zeros until the exponent reaches emin ind = exp + 6176; // C1 = C1 * 10^ind if (ind <= 19) { // 1 <= P34 - q1 <= 19 <=> 15 <= q1 <= 33 if (q1 <= 19) { // 64-bit C1, 64-bit 10^ind __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]); } else { // 20 <= q1 <= 33 => 128-bit C1, 64-bit 10^ind __mul_128x64_to_128 (C1, ten2k64[ind], C1); } } else { // if 20 <= P34 - q1 <= 33 <=> 1 <= q1 <= 14 => // 64-bit C1, 128-bit 10^ind __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]); } x_exp = EXP_MIN; } } if (!x_sign) { // x > 0 // add 1 ulp (add 1 to the significand) C1.w[0]++; if (C1.w[0] == 0) C1.w[1]++; if (C1.w[1] == 0x0001ed09bead87c0ull && C1.w[0] == 0x378d8e6400000000ull) { // if C1 = 10^34 C1.w[1] = 0x0000314dc6448d93ull; // C1 = 10^33 C1.w[0] = 0x38c15b0a00000000ull; x_exp = x_exp + EXP_P1; } } else { // x < 0 // subtract 1 ulp (subtract 1 from the significand) C1.w[0]--; if (C1.w[0] == 0xffffffffffffffffull) C1.w[1]--; if (x_exp != 0 && C1.w[1] == 0x0000314dc6448d93ull && C1.w[0] == 0x38c15b09ffffffffull) { // if C1 = 10^33 - 1 C1.w[1] = 0x0001ed09bead87c0ull; // C1 = 10^34 - 1 C1.w[0] = 0x378d8e63ffffffffull; x_exp = x_exp - EXP_P1; } } // assemble the result res.w[1] = x_sign | x_exp | C1.w[1]; res.w[0] = C1.w[0]; } // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp } // end x is not special and is not zero BID_RETURN (res); } /***************************************************************************** * BID128 nextdown ****************************************************************************/ #if DECIMAL_CALL_BY_REFERENCE void bid128_nextdown (UINT128 * pres, UINT128 * px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) { UINT128 x = *px; #else UINT128 bid128_nextdown (UINT128 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) { #endif UINT128 res; UINT64 x_sign; UINT64 x_exp; int exp; BID_UI64DOUBLE tmp1; int x_nr_bits; int q1, ind; UINT128 C1; // C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (UINT64) BID_SWAP128 (x); // unpack the argument x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative C1.w[1] = x.w[1] & MASK_COEFF; C1.w[0] = x.w[0]; // check for NaN or Infinity if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { // x is special if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN // if x = NaN, then res = Q (x) // check first for non-canonical NaN payload if (((x.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) || (((x.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) && (x.w[0] > 0x38c15b09ffffffffull))) { x.w[1] = x.w[1] & 0xffffc00000000000ull; x.w[0] = 0x0ull; } if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN // set invalid flag *pfpsf |= INVALID_EXCEPTION; // return quiet (x) res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out also G[6]-G[16] res.w[0] = x.w[0]; } else { // x is QNaN // return x res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out G[6]-G[16] res.w[0] = x.w[0]; } } else { // x is not NaN, so it must be infinity if (!x_sign) { // x is +inf res.w[1] = 0x5fffed09bead87c0ull; // +MAXFP = +999...99 * 10^emax res.w[0] = 0x378d8e63ffffffffull; } else { // x is -inf res.w[1] = 0xf800000000000000ull; // -inf res.w[0] = 0x0000000000000000ull; } } BID_RETURN (res); } // check for non-canonical values (treated as zero) if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11 // non-canonical x_exp = (x.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits C1.w[1] = 0; // significand high C1.w[0] = 0; // significand low } else { // G0_G1 != 11 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bits if (C1.w[1] > 0x0001ed09bead87c0ull || (C1.w[1] == 0x0001ed09bead87c0ull && C1.w[0] > 0x378d8e63ffffffffull)) { // x is non-canonical if coefficient is larger than 10^34 -1 C1.w[1] = 0; C1.w[0] = 0; } else { // canonical ; } } if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { // x is +/-0 res.w[1] = 0x8000000000000000ull; // -1 * 10^emin res.w[0] = 0x0000000000000001ull; } else { // x is not special and is not zero if (x.w[1] == 0xdfffed09bead87c0ull && x.w[0] == 0x378d8e63ffffffffull) { // x = -MAXFP = -999...99 * 10^emax res.w[1] = 0xf800000000000000ull; // -inf res.w[0] = 0x0000000000000000ull; } else if (x.w[1] == 0x0ull && x.w[0] == 0x0000000000000001ull) { // +MINFP res.w[1] = 0x0000000000000000ull; // +0 res.w[0] = 0x0000000000000000ull; } 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^34 to speed up the case q1 = 34 // q1 = nr. of decimal digits in x // determine first the nr. of bits in x if (C1.w[1] == 0) { if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 // split the 64-bit value in two 32-bit halves to avoid rnd errors if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion x_nr_bits = 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); } else { // x < 2^32 tmp1.d = (double) (C1.w[0]); // exact conversion x_nr_bits = 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); } } else { // if x < 2^53 tmp1.d = (double) C1.w[0]; // exact conversion x_nr_bits = 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); } } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) tmp1.d = (double) C1.w[1]; // exact conversion x_nr_bits = 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); } q1 = nr_digits[x_nr_bits - 1].digits; if (q1 == 0) { q1 = nr_digits[x_nr_bits - 1].digits1; if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) q1++; } // if q1 < P then pad the significand with zeros if (q1 < P34) { exp = (x_exp >> 49) - 6176; if (exp + 6176 > P34 - q1) { ind = P34 - q1; // 1 <= ind <= P34 - 1 // pad with P34 - q1 zeros, until exponent = emin // C1 = C1 * 10^ind if (q1 <= 19) { // 64-bit C1 if (ind <= 19) { // 64-bit 10^ind and 64-bit C1 __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]); } else { // 128-bit 10^ind and 64-bit C1 __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]); } } else { // C1 is (most likely) 128-bit if (ind <= 14) { // 64-bit 10^ind and 128-bit C1 (most likely) __mul_128x64_to_128 (C1, ten2k64[ind], C1); } else if (ind <= 19) { // 64-bit 10^ind and 64-bit C1 (q1 <= 19) __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]); } else { // 128-bit 10^ind and 64-bit C1 (C1 must be 64-bit) __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]); } } x_exp = x_exp - ((UINT64) ind << 49); } else { // pad with zeros until the exponent reaches emin ind = exp + 6176; // C1 = C1 * 10^ind if (ind <= 19) { // 1 <= P34 - q1 <= 19 <=> 15 <= q1 <= 33 if (q1 <= 19) { // 64-bit C1, 64-bit 10^ind __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]); } else { // 20 <= q1 <= 33 => 128-bit C1, 64-bit 10^ind __mul_128x64_to_128 (C1, ten2k64[ind], C1); } } else { // if 20 <= P34 - q1 <= 33 <=> 1 <= q1 <= 14 => // 64-bit C1, 128-bit 10^ind __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]); } x_exp = EXP_MIN; } } if (x_sign) { // x < 0 // add 1 ulp (add 1 to the significand) C1.w[0]++; if (C1.w[0] == 0) C1.w[1]++; if (C1.w[1] == 0x0001ed09bead87c0ull && C1.w[0] == 0x378d8e6400000000ull) { // if C1 = 10^34 C1.w[1] = 0x0000314dc6448d93ull; // C1 = 10^33 C1.w[0] = 0x38c15b0a00000000ull; x_exp = x_exp + EXP_P1; } } else { // x > 0 // subtract 1 ulp (subtract 1 from the significand) C1.w[0]--; if (C1.w[0] == 0xffffffffffffffffull) C1.w[1]--; if (x_exp != 0 && C1.w[1] == 0x0000314dc6448d93ull && C1.w[0] == 0x38c15b09ffffffffull) { // if C1 = 10^33 - 1 C1.w[1] = 0x0001ed09bead87c0ull; // C1 = 10^34 - 1 C1.w[0] = 0x378d8e63ffffffffull; x_exp = x_exp - EXP_P1; } } // assemble the result res.w[1] = x_sign | x_exp | C1.w[1]; res.w[0] = C1.w[0]; } // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp } // end x is not special and is not zero BID_RETURN (res); } /***************************************************************************** * BID128 nextafter ****************************************************************************/ #if DECIMAL_CALL_BY_REFERENCE void bid128_nextafter (UINT128 * pres, UINT128 * px, UINT128 * py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) { UINT128 x = *px; UINT128 y = *py; UINT128 xnswp = *px; UINT128 ynswp = *py; #else UINT128 bid128_nextafter (UINT128 x, UINT128 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) { UINT128 xnswp = x; UINT128 ynswp = y; #endif UINT128 res; UINT128 tmp1, tmp2, tmp3; FPSC tmp_fpsf = 0; // dummy fpsf for calls to comparison functions int res1, res2; UINT64 x_exp; BID_SWAP128 (x); BID_SWAP128 (y); // check for NaNs if (((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) || ((y.w[1] & MASK_SPECIAL) == MASK_SPECIAL)) { // x is special or y is special if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN // if x = NaN, then res = Q (x) // check first for non-canonical NaN payload if (((x.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) || (((x.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) && (x.w[0] > 0x38c15b09ffffffffull))) { x.w[1] = x.w[1] & 0xffffc00000000000ull; x.w[0] = 0x0ull; } if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN // set invalid flag *pfpsf |= INVALID_EXCEPTION; // return quiet (x) res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out also G[6]-G[16] res.w[0] = x.w[0]; } else { // x is QNaN // return x res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out G[6]-G[16] res.w[0] = x.w[0]; if ((y.w[1] & MASK_SNAN) == MASK_SNAN) { // y is SNAN // set invalid flag *pfpsf |= INVALID_EXCEPTION; } } BID_RETURN (res) } else if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NAN // if x = NaN, then res = Q (x) // check first for non-canonical NaN payload if (((y.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) || (((y.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) && (y.w[0] > 0x38c15b09ffffffffull))) { y.w[1] = y.w[1] & 0xffffc00000000000ull; y.w[0] = 0x0ull; } if ((y.w[1] & MASK_SNAN) == MASK_SNAN) { // y is SNAN // set invalid flag *pfpsf |= INVALID_EXCEPTION; // return quiet (x) res.w[1] = y.w[1] & 0xfc003fffffffffffull; // clear out also G[6]-G[16] res.w[0] = y.w[0]; } else { // x is QNaN // return x res.w[1] = y.w[1] & 0xfc003fffffffffffull; // clear out G[6]-G[16] res.w[0] = y.w[0]; } BID_RETURN (res) } else { // at least one is infinity if ((x.w[1] & MASK_ANY_INF) == MASK_INF) { // x = inf x.w[1] = x.w[1] & (MASK_SIGN | MASK_INF); x.w[0] = 0x0ull; } if ((y.w[1] & MASK_ANY_INF) == MASK_INF) { // y = inf y.w[1] = y.w[1] & (MASK_SIGN | MASK_INF); y.w[0] = 0x0ull; } } } // neither x nor y is NaN // if not infinity, check for non-canonical values x (treated as zero) if ((x.w[1] & MASK_ANY_INF) != MASK_INF) { // x != inf if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11 // non-canonical x_exp = (x.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits x.w[1] = (x.w[1] & MASK_SIGN) | x_exp; x.w[0] = 0x0ull; } else { // G0_G1 != 11 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bits if ((x.w[1] & MASK_COEFF) > 0x0001ed09bead87c0ull || ((x.w[1] & MASK_COEFF) == 0x0001ed09bead87c0ull && x.w[0] > 0x378d8e63ffffffffull)) { // x is non-canonical if coefficient is larger than 10^34 -1 x.w[1] = (x.w[1] & MASK_SIGN) | x_exp; x.w[0] = 0x0ull; } else { // 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 bid128_quiet_equal (&res1, &xnswp, &ynswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); bid128_quiet_greater (&res2, &xnswp, &ynswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); #else res1 = bid128_quiet_equal (xnswp, ynswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); res2 = bid128_quiet_greater (xnswp, ynswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); #endif *pfpsf = tmp_fpsf; // restore fpsf if (res1) { // x = y // return x with the sign of y res.w[1] = (x.w[1] & 0x7fffffffffffffffull) | (y. w[1] & 0x8000000000000000ull); res.w[0] = x.w[0]; } else if (res2) { // x > y #if DECIMAL_CALL_BY_REFERENCE bid128_nextdown (&res, &xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); #else res = bid128_nextdown (xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); #endif BID_SWAP128 (res); } else { // x < y #if DECIMAL_CALL_BY_REFERENCE bid128_nextup (&res, &xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); #else res = bid128_nextup (xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); #endif BID_SWAP128 (res); } // if the operand x is finite but the result is infinite, signal // overflow and inexact if (((x.w[1] & MASK_SPECIAL) != MASK_SPECIAL) && ((res.w[1] & MASK_SPECIAL) == MASK_SPECIAL)) { // set the inexact flag *pfpsf |= INEXACT_EXCEPTION; // set the overflow flag *pfpsf |= OVERFLOW_EXCEPTION; } // if the result is in (-10^emin, 10^emin), and is different from the // operand x, signal underflow and inexact tmp1.w[HIGH_128W] = 0x0000314dc6448d93ull; tmp1.w[LOW_128W] = 0x38c15b0a00000000ull; // +100...0[34] * 10^emin tmp2.w[HIGH_128W] = res.w[1] & 0x7fffffffffffffffull; tmp2.w[LOW_128W] = res.w[0]; tmp3.w[HIGH_128W] = res.w[1]; tmp3.w[LOW_128W] = res.w[0]; tmp_fpsf = *pfpsf; // save fpsf #if DECIMAL_CALL_BY_REFERENCE bid128_quiet_greater (&res1, &tmp1, &tmp2 _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); bid128_quiet_not_equal (&res2, &xnswp, &tmp3 _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); #else res1 = bid128_quiet_greater (tmp1, tmp2 _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); res2 = bid128_quiet_not_equal (xnswp, tmp3 _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG); #endif *pfpsf = tmp_fpsf; // restore fpsf if (res1 && res2) { // set the inexact flag *pfpsf |= INEXACT_EXCEPTION; // set the underflow flag *pfpsf |= UNDERFLOW_EXCEPTION; } BID_RETURN (res); }
Go to most recent revision | Compare with Previous | Blame | View Log