From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libgcc/config/libbid/bid128_noncomp.c | 1200 +++++++++++++++++++++++++++++++++ 1 file changed, 1200 insertions(+) create mode 100644 libgcc/config/libbid/bid128_noncomp.c (limited to 'libgcc/config/libbid/bid128_noncomp.c') diff --git a/libgcc/config/libbid/bid128_noncomp.c b/libgcc/config/libbid/bid128_noncomp.c new file mode 100644 index 000000000..5fce7ea6f --- /dev/null +++ b/libgcc/config/libbid/bid128_noncomp.c @@ -0,0 +1,1200 @@ +/* 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 +. */ + +#include "bid_internal.h" + +/***************************************************************************** + * + * BID128 non-computational functions: + * - bid128_isSigned + * - bid128_isNormal + * - bid128_isSubnormal + * - bid128_isFinite + * - bid128_isZero + * - bid128_isInf + * - bid128_isSignaling + * - bid128_isCanonical + * - bid128_isNaN + * - bid128_copy + * - bid128_negate + * - bid128_abs + * - bid128_copySign + * - bid128_class + * - bid128_totalOrder + * - bid128_totalOrderMag + * - bid128_sameQuantum + * - bid128_radix + ****************************************************************************/ + +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_isSigned (int *pres, + UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_isSigned (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + + res = ((x.w[HIGH_128W] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +// return 1 iff x is not zero, nor NaN nor subnormal nor infinity +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_isNormal (int *pres, + UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_isNormal (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + UINT64 x_exp, C1_hi, C1_lo; + BID_UI64DOUBLE tmp1; + int exp, q, x_nr_bits; + + BID_SWAP128 (x); + // test for special values - infinity or NaN + if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { + // x is special + res = 0; + BID_RETURN (res); + } + // unpack x + x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions + C1_hi = x.w[1] & MASK_COEFF; + C1_lo = x.w[0]; + // test for zero + if (C1_hi == 0 && C1_lo == 0) { + res = 0; + BID_RETURN (res); + } + // test for non-canonical values of the argument x + if ((((C1_hi > 0x0001ed09bead87c0ull) + || ((C1_hi == 0x0001ed09bead87c0ull) + && (C1_lo > 0x378d8e63ffffffffull))) + && ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) + || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { + res = 0; + BID_RETURN (res); + } + // x is subnormal or normal + // determine the number of digits q in the significand + // q = nr. of decimal digits in x + // determine first the nr. of bits in x + if (C1_hi == 0) { + if (C1_lo >= 0x0020000000000000ull) { // x >= 2^53 + // split the 64-bit value in two 32-bit halves to avoid rounding errors + if (C1_lo >= 0x0000000100000000ull) { // x >= 2^32 + tmp1.d = (double) (C1_lo >> 32); // exact conversion + x_nr_bits = + 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); + } else { // x < 2^32 + tmp1.d = (double) (C1_lo); // exact conversion + x_nr_bits = + 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); + } + } else { // if x < 2^53 + tmp1.d = (double) C1_lo; // exact conversion + x_nr_bits = + 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); + } + } else { // C1_hi != 0 => nr. bits = 64 + nr_bits (C1_hi) + tmp1.d = (double) C1_hi; // exact conversion + x_nr_bits = + 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); + } + q = nr_digits[x_nr_bits - 1].digits; + if (q == 0) { + q = nr_digits[x_nr_bits - 1].digits1; + if (C1_hi > nr_digits[x_nr_bits - 1].threshold_hi || + (C1_hi == nr_digits[x_nr_bits - 1].threshold_hi && + C1_lo >= nr_digits[x_nr_bits - 1].threshold_lo)) + q++; + } + exp = (int) (x_exp >> 49) - 6176; + // test for subnormal values of x + if (exp + q <= -6143) { + res = 0; + BID_RETURN (res); + } else { + res = 1; + BID_RETURN (res); + } +} + +// return 1 iff x is not zero, nor NaN nor normal nor infinity +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_isSubnormal (int *pres, + UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_isSubnormal (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + UINT64 x_exp, C1_hi, C1_lo; + BID_UI64DOUBLE tmp1; + int exp, q, x_nr_bits; + + BID_SWAP128 (x); + // test for special values - infinity or NaN + if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { + // x is special + res = 0; + BID_RETURN (res); + } + // unpack x + x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions + C1_hi = x.w[1] & MASK_COEFF; + C1_lo = x.w[0]; + // test for zero + if (C1_hi == 0 && C1_lo == 0) { + res = 0; + BID_RETURN (res); + } + // test for non-canonical values of the argument x + if ((((C1_hi > 0x0001ed09bead87c0ull) + || ((C1_hi == 0x0001ed09bead87c0ull) + && (C1_lo > 0x378d8e63ffffffffull))) + && ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) + || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { + res = 0; + BID_RETURN (res); + } + // x is subnormal or normal + // determine the number of digits q in the significand + // q = nr. of decimal digits in x + // determine first the nr. of bits in x + if (C1_hi == 0) { + if (C1_lo >= 0x0020000000000000ull) { // x >= 2^53 + // split the 64-bit value in two 32-bit halves to avoid rounding errors + if (C1_lo >= 0x0000000100000000ull) { // x >= 2^32 + tmp1.d = (double) (C1_lo >> 32); // exact conversion + x_nr_bits = + 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); + } else { // x < 2^32 + tmp1.d = (double) (C1_lo); // exact conversion + x_nr_bits = + 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); + } + } else { // if x < 2^53 + tmp1.d = (double) C1_lo; // exact conversion + x_nr_bits = + 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); + } + } else { // C1_hi != 0 => nr. bits = 64 + nr_bits (C1_hi) + tmp1.d = (double) C1_hi; // exact conversion + x_nr_bits = + 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); + } + q = nr_digits[x_nr_bits - 1].digits; + if (q == 0) { + q = nr_digits[x_nr_bits - 1].digits1; + if (C1_hi > nr_digits[x_nr_bits - 1].threshold_hi || + (C1_hi == nr_digits[x_nr_bits - 1].threshold_hi && + C1_lo >= nr_digits[x_nr_bits - 1].threshold_lo)) + q++; + } + exp = (int) (x_exp >> 49) - 6176; + // test for subnormal values of x + if (exp + q <= -6143) { + res = 1; + } else { + res = 0; + } + BID_RETURN (res); +} + +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_isFinite (int *pres, + UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_isFinite (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + res = ((x.w[HIGH_128W] & MASK_INF) != MASK_INF); + BID_RETURN (res); +} + +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_isZero (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_isZero (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + UINT128 sig_x; + + BID_SWAP128 (x); + if ((x.w[1] & MASK_INF) == MASK_INF) { + res = 0; + BID_RETURN (res); + } + sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull; + sig_x.w[0] = x.w[0]; + if ((sig_x.w[1] > 0x0001ed09bead87c0ull) || // significand is non-canonical + ((sig_x.w[1] == 0x0001ed09bead87c0ull) && (sig_x.w[0] > 0x378d8e63ffffffffull)) || // significand is non-canonical + ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull && (x.w[1] & MASK_INF) != MASK_INF) || // significand is non-canonical + (sig_x.w[1] == 0 && sig_x.w[0] == 0)) { // significand is 0 + res = 1; + BID_RETURN (res); + } + res = 0; + BID_RETURN (res); +} + +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_isInf (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_isInf (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + res = ((x.w[HIGH_128W] & MASK_INF) == MASK_INF) + && ((x.w[HIGH_128W] & MASK_NAN) != MASK_NAN); + BID_RETURN (res); +} + +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_isSignaling (int *pres, + UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_isSignaling (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + + res = ((x.w[HIGH_128W] & MASK_SNAN) == MASK_SNAN); + BID_RETURN (res); +} + +// return 1 iff x is a canonical number ,infinity, or NaN. +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_isCanonical (int *pres, + UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_isCanonical (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + UINT128 sig_x; + + BID_SWAP128 (x); + if ((x.w[1] & MASK_NAN) == MASK_NAN) { // NaN + if (x.w[1] & 0x01ffc00000000000ull) { + res = 0; + BID_RETURN (res); + } + sig_x.w[1] = x.w[1] & 0x00003fffffffffffull; // 46 bits + sig_x.w[0] = x.w[0]; // 64 bits + // payload must be < 10^33 = 0x0000314dc6448d93_38c15b0a00000000 + if (sig_x.w[1] < 0x0000314dc6448d93ull + || (sig_x.w[1] == 0x0000314dc6448d93ull + && sig_x.w[0] < 0x38c15b0a00000000ull)) { + res = 1; + } else { + res = 0; + } + BID_RETURN (res); + } else if ((x.w[1] & MASK_INF) == MASK_INF) { // infinity + if ((x.w[1] & 0x03ffffffffffffffull) || x.w[0]) { + res = 0; + } else { + res = 1; + } + BID_RETURN (res); + } + // not NaN or infinity; extract significand to ensure it is canonical + sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull; + sig_x.w[0] = x.w[0]; + // a canonical number has a coefficient < 10^34 + // (0x0001ed09_bead87c0_378d8e64_00000000) + if ((sig_x.w[1] > 0x0001ed09bead87c0ull) || // significand is non-canonical + ((sig_x.w[1] == 0x0001ed09bead87c0ull) && (sig_x.w[0] > 0x378d8e63ffffffffull)) || // significand is non-canonical + ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { + res = 0; + } else { + res = 1; + } + BID_RETURN (res); +} + +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_isNaN (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_isNaN (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + + res = ((x.w[HIGH_128W] & MASK_NAN) == MASK_NAN); + BID_RETURN (res); +} + +// copies a floating-point operand x to destination y, with no change +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_copy (UINT128 * pres, + UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +UINT128 +bid128_copy (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + UINT128 res; + + res = x; + BID_RETURN (res); +} + +// copies a floating-point operand x to destination y, reversing the sign +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_negate (UINT128 * pres, + UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +UINT128 +bid128_negate (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + UINT128 res; + + x.w[HIGH_128W] ^= MASK_SIGN; + res = x; + BID_RETURN (res); +} + +// copies a floating-point operand x to destination y, changing the sign to positive +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_abs (UINT128 * pres, + UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +UINT128 +bid128_abs (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + UINT128 res; + + x.w[HIGH_128W] &= ~MASK_SIGN; + res = x; + BID_RETURN (res); +} + +// copies operand x to destination in the same format as x, but with the sign of y +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_copySign (UINT128 * pres, UINT128 * px, + UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; + UINT128 y = *py; +#else +UINT128 +bid128_copySign (UINT128 x, UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + UINT128 res; + + x.w[HIGH_128W] = + (x.w[HIGH_128W] & ~MASK_SIGN) | (y.w[HIGH_128W] & MASK_SIGN); + res = x; + BID_RETURN (res); +} + +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_class (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_class (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + UINT256 sig_x_prime256; + UINT192 sig_x_prime192; + UINT128 sig_x; + int exp_x; + + BID_SWAP128 (x); + if ((x.w[1] & MASK_NAN) == MASK_NAN) { + if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { + res = signalingNaN; + } else { + res = quietNaN; + } + BID_RETURN (res); + } + if ((x.w[1] & MASK_INF) == MASK_INF) { + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) { + res = negativeInfinity; + } else { + res = positiveInfinity; + } + BID_RETURN (res); + } + // decode number into exponent and significand + sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull; + sig_x.w[0] = x.w[0]; + // check for zero or non-canonical + if ((sig_x.w[1] > 0x0001ed09bead87c0ull) + || ((sig_x.w[1] == 0x0001ed09bead87c0ull) + && (sig_x.w[0] > 0x378d8e63ffffffffull)) + || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) + || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) { + res = negativeZero; + } else { + res = positiveZero; + } + BID_RETURN (res); + } + exp_x = (x.w[1] >> 49) & 0x000000000003fffull; + // if exponent is less than -6176, the number may be subnormal + // (less than the smallest normal value) + // the smallest normal value is 1 x 10^-6143 = 10^33 x 10^-6176 + // if (exp_x - 6176 < -6143) + if (exp_x < 33) { // sig_x * 10^exp_x + if (exp_x > 19) { + __mul_128x128_to_256 (sig_x_prime256, sig_x, + ten2k128[exp_x - 20]); + // 10^33 = 0x0000314dc6448d93_38c15b0a00000000 + if ((sig_x_prime256.w[3] == 0) && (sig_x_prime256.w[2] == 0) + && ((sig_x_prime256.w[1] < 0x0000314dc6448d93ull) + || ((sig_x_prime256.w[1] == 0x0000314dc6448d93ull) + && (sig_x_prime256.w[0] < 0x38c15b0a00000000ull)))) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? negativeSubnormal : + positiveSubnormal; + BID_RETURN (res); + } + } else { + __mul_64x128_to_192 (sig_x_prime192, ten2k64[exp_x], sig_x); + // 10^33 = 0x0000314dc6448d93_38c15b0a00000000 + if ((sig_x_prime192.w[2] == 0) + && ((sig_x_prime192.w[1] < 0x0000314dc6448d93ull) + || ((sig_x_prime192.w[1] == 0x0000314dc6448d93ull) + && (sig_x_prime192.w[0] < 0x38c15b0a00000000ull)))) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? negativeSubnormal : + positiveSubnormal; + BID_RETURN (res); + } + } + } + // otherwise, normal number, determine the sign + res = + ((x.w[1] & MASK_SIGN) == + MASK_SIGN) ? negativeNormal : positiveNormal; + BID_RETURN (res); +} + +// true if the exponents of x and y are the same, false otherwise. +// The special cases of sameQuantum(NaN, NaN) and sameQuantum(Inf, Inf) are true +// If exactly one operand is infinite or exactly one operand is NaN, then false +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_sameQuantum (int *pres, UINT128 * px, + UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; + UINT128 y = *py; +#else +int +bid128_sameQuantum (UINT128 x, + UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + UINT64 x_exp, y_exp; + + BID_SWAP128 (x); + BID_SWAP128 (y); + // if both operands are NaN, return true + if ((x.w[1] & MASK_NAN) == MASK_NAN + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { + res = ((x.w[1] & MASK_NAN) == MASK_NAN + && (y.w[1] & MASK_NAN) == MASK_NAN); + BID_RETURN (res); + } + // if both operands are INF, return true + if ((x.w[1] & MASK_INF) == MASK_INF + || (y.w[1] & MASK_INF) == MASK_INF) { + res = ((x.w[1] & MASK_INF) == MASK_INF) + && ((y.w[1] & MASK_INF) == MASK_INF); + BID_RETURN (res); + } + // decode exponents for both numbers, and return true if they match + if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11 + x_exp = (x.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits + } else { // G0_G1 != 11 + x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bits + } + if ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11 + y_exp = (y.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits + } else { // G0_G1 != 11 + y_exp = y.w[1] & MASK_EXP; // biased and shifted left 49 bits + } + res = (x_exp == y_exp); + BID_RETURN (res); +} + +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_totalOrder (int *pres, UINT128 * px, + UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; + UINT128 y = *py; +#else +int +bid128_totalOrder (UINT128 x, + UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + int exp_x, exp_y; + UINT128 sig_x, sig_y, pyld_y, pyld_x; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0; + + BID_SWAP128 (x); + BID_SWAP128 (y); + // NaN (CASE 1) + // if x and y are unordered numerically because either operand is NaN + // (1) totalOrder(-NaN, number) is true + // (2) totalOrder(number, +NaN) is true + // (3) if x and y are both NaN: + // i) negative sign bit < positive sign bit + // ii) signaling < quiet for +NaN, reverse for -NaN + // iii) lesser payload < greater payload for +NaN (reverse for -NaN) + // iv) else if bitwise identical (in canonical form), return 1 + if ((x.w[1] & MASK_NAN) == MASK_NAN) { + // if x is -NaN + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) { + // return true, unless y is -NaN also + if ((y.w[1] & MASK_NAN) != MASK_NAN + || (y.w[1] & MASK_SIGN) != MASK_SIGN) { + res = 1; // y is a number, return 1 + BID_RETURN (res); + } else { // if y and x are both -NaN + pyld_x.w[1] = x.w[1] & 0x00003fffffffffffull; + pyld_x.w[0] = x.w[0]; + pyld_y.w[1] = y.w[1] & 0x00003fffffffffffull; + pyld_y.w[0] = y.w[0]; + if ((pyld_x.w[1] > 0x0000314dc6448d93ull) + || ((pyld_x.w[1] == 0x0000314dc6448d93ull) + && (pyld_x.w[0] > 0x38c15b09ffffffffull))) { + pyld_x.w[1] = 0; + pyld_x.w[0] = 0; + } + if ((pyld_y.w[1] > 0x0000314dc6448d93ull) + || ((pyld_y.w[1] == 0x0000314dc6448d93ull) + && (pyld_y.w[0] > 0x38c15b09ffffffffull))) { + pyld_y.w[1] = 0; + pyld_y.w[0] = 0; + } + // if x and y are both -SNaN or both -QNaN, we have to compare payloads + // this statement evaluates to true if both are SNaN or QNaN + if (! + (((y.w[1] & MASK_SNAN) == MASK_SNAN) ^ + ((x.w[1] & MASK_SNAN) == MASK_SNAN))) { + // it comes down to the payload. we want to return true if x has a + // larger payload, or if the payloads are equal (canonical forms + // are bitwise identical) + if ((pyld_x.w[1] > pyld_y.w[1]) || + ((pyld_x.w[1] == pyld_y.w[1]) + && (pyld_x.w[0] >= pyld_y.w[0]))) + res = 1; + else + res = 0; + BID_RETURN (res); + } else { + // either x = -SNaN and y = -QNaN or x = -QNaN and y = -SNaN + res = ((y.w[1] & MASK_SNAN) == MASK_SNAN); + // totalOrder (-QNaN, -SNaN) == 1 + BID_RETURN (res); + } + } + } else { // x is +NaN + // return false, unless y is +NaN also + if ((y.w[1] & MASK_NAN) != MASK_NAN + || (y.w[1] & MASK_SIGN) == MASK_SIGN) { + res = 0; // y is a number, return 1 + BID_RETURN (res); + } else { + // x and y are both +NaN; + pyld_x.w[1] = x.w[1] & 0x00003fffffffffffull; + pyld_x.w[0] = x.w[0]; + pyld_y.w[1] = y.w[1] & 0x00003fffffffffffull; + pyld_y.w[0] = y.w[0]; + if ((pyld_x.w[1] > 0x0000314dc6448d93ull) + || ((pyld_x.w[1] == 0x0000314dc6448d93ull) + && (pyld_x.w[0] > 0x38c15b09ffffffffull))) { + pyld_x.w[1] = 0; + pyld_x.w[0] = 0; + } + if ((pyld_y.w[1] > 0x0000314dc6448d93ull) + || ((pyld_y.w[1] == 0x0000314dc6448d93ull) + && (pyld_y.w[0] > 0x38c15b09ffffffffull))) { + pyld_y.w[1] = 0; + pyld_y.w[0] = 0; + } + // if x and y are both +SNaN or both +QNaN, we have to compare payloads + // this statement evaluates to true if both are SNaN or QNaN + if (! + (((y.w[1] & MASK_SNAN) == MASK_SNAN) ^ + ((x.w[1] & MASK_SNAN) == MASK_SNAN))) { + // it comes down to the payload. we want to return true if x has a + // smaller payload, or if the payloads are equal (canonical forms + // are bitwise identical) + if ((pyld_x.w[1] < pyld_y.w[1]) || + ((pyld_x.w[1] == pyld_y.w[1]) + && (pyld_x.w[0] <= pyld_y.w[0]))) + res = 1; + else + res = 0; + BID_RETURN (res); + } else { + // either x = SNaN and y = QNaN or x = QNaN and y = SNaN + res = ((x.w[1] & MASK_SNAN) == MASK_SNAN); + // totalOrder (-QNaN, -SNaN) == 1 + BID_RETURN (res); + } + } + } + } else if ((y.w[1] & MASK_NAN) == MASK_NAN) { + // x is certainly not NAN in this case. + // return true if y is positive + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } + // SIMPLE (CASE 2) + // if all the bits are the same, the numbers are equal. + if ((x.w[1] == y.w[1]) && (x.w[0] == y.w[0])) { + res = 1; + BID_RETURN (res); + } + // OPPOSITE SIGNS (CASE 3) + // if signs are opposite, return 1 if x is negative + // (if x < y, totalOrder is true) + if (((x.w[1] & MASK_SIGN) == MASK_SIGN) ^ ((y.w[1] & MASK_SIGN) == + MASK_SIGN)) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } + // INFINITY (CASE 4) + if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x == neg_inf, return (y == neg_inf); + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) { + res = 1; + BID_RETURN (res); + } else { + // x is positive infinity, only return1 if y is positive infinity as well + res = ((y.w[1] & MASK_INF) == MASK_INF); + BID_RETURN (res); + // && (y & MASK_SIGN) != MASK_SIGN); (we know y has same sign as x) + } + } else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so: + // if y is +inf, xy + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } + // CONVERT x + sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull; + sig_x.w[0] = x.w[0]; + exp_x = (x.w[1] >> 49) & 0x000000000003fffull; + + // CHECK IF x IS CANONICAL + // 9999999999999999999999999999999999 (decimal) = + // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal) + // [0, 10^34) is the 754r supported canonical range. + // If the value exceeds that, it is interpreted as 0. + if ((((sig_x.w[1] > 0x0001ed09bead87c0ull) || + ((sig_x.w[1] == 0x0001ed09bead87c0ull) && + (sig_x.w[0] > 0x378d8e63ffffffffull))) && + ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) || + ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) || + ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; + // check for the case where the exponent is shifted right by 2 bits! + if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { + exp_x = (x.w[1] >> 47) & 0x000000000003fffull; + } + } + // CONVERT y + exp_y = (y.w[1] >> 49) & 0x0000000000003fffull; + sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull; + sig_y.w[0] = y.w[0]; + + // CHECK IF y IS CANONICAL + // 9999999999999999999999999999999999(decimal) = + // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal) + // [0, 10^34) is the 754r supported canonical range. + // If the value exceeds that, it is interpreted as 0. + if ((((sig_y.w[1] > 0x0001ed09bead87c0ull) || + ((sig_y.w[1] == 0x0001ed09bead87c0ull) && + (sig_y.w[0] > 0x378d8e63ffffffffull))) && + ((y.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) || + ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) || + ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; + // check for the case where the exponent is shifted right by 2 bits! + if ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { + exp_y = (y.w[1] >> 47) & 0x000000000003fffull; + } + } + // ZERO (CASE 5) + // if x and y represent the same entities, and both are negative + // return true iff exp_x <= exp_y + if (x_is_zero && y_is_zero) { + // we know that signs must be the same because we would have caught it + // in case3 if signs were different + // totalOrder(x,y) iff exp_x >= exp_y for negative numbers + // totalOrder(x,y) iff exp_x <= exp_y for positive numbers + if (exp_x == exp_y) { + res = 1; + BID_RETURN (res); + } + res = ((exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + // if x is zero and y isn't, clearly x has the smaller payload + if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } + // if y is zero, and x isn't, clearly y has the smaller payload + if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } + // REDUNDANT REPRESENTATIONS (CASE 6) + // if both components are either bigger or smaller + if (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0])) + && exp_x >= exp_y) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } + if (((sig_x.w[1] < sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0])) + && exp_x <= exp_y) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } + // if |exp_x - exp_y| < 33, it comes down to the compensated significand + if (exp_x > exp_y) { + // if exp_x is 33 greater than exp_y, it is definitely larger, + // so no need for compensation + if (exp_x - exp_y > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + // difference cannot be greater than 10^33 + } + // otherwise adjust the x significand upwards + if (exp_x - exp_y > 19) { + __mul_128x128_to_256 (sig_n_prime256, sig_x, + ten2k128[exp_x - exp_y - 20]); + // the compensated significands are equal (ie "x and y represent the same + // entities") return 1 if (negative && expx > expy) || + // (positive && expx < expy) + if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) + && (sig_n_prime256.w[1] == sig_y.w[1]) + && (sig_n_prime256.w[0] == sig_y.w[0])) { + // the case exp_x == exp_y cannot occur, because all bits must be + // the same - would have been caught if (x == y) + res = ((exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + // if positive, return 1 if adjusted x is smaller than y + res = (((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) + && ((sig_n_prime256.w[1] < sig_y.w[1]) + || (sig_n_prime256.w[1] == sig_y.w[1] + && sig_n_prime256.w[0] < + sig_y.w[0]))) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); + } + __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_x - exp_y], sig_x); + // if positive, return whichever significand is larger + // (converse if negative) + if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1] + && (sig_n_prime192.w[0] == sig_y.w[0])) { + res = ((exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + res = (((sig_n_prime192.w[2] == 0) + && ((sig_n_prime192.w[1] < sig_y.w[1]) + || (sig_n_prime192.w[1] == sig_y.w[1] + && sig_n_prime192.w[0] < + sig_y.w[0]))) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); + } + // if exp_x is 33 less than exp_y, it is definitely smaller, + // no need for compensation + if (exp_y - exp_x > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } + if (exp_y - exp_x > 19) { + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, + ten2k128[exp_y - exp_x - 20]); + // if x and y represent the same entities and both are negative + // return true iff exp_x <= exp_y + if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) + && (sig_n_prime256.w[1] == sig_x.w[1]) + && (sig_n_prime256.w[0] == sig_x.w[0])) { + res = (exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } + // values are not equal, for positive numbers return 1 if x is less than y + // and 0 otherwise + res = (((sig_n_prime256.w[3] != 0) || + // if upper128 bits of compensated y are non-zero, y is bigger + (sig_n_prime256.w[2] != 0) || + // if upper128 bits of compensated y are non-zero, y is bigger + (sig_n_prime256.w[1] > sig_x.w[1]) || + // if compensated y is bigger, y is bigger + (sig_n_prime256.w[1] == sig_x.w[1] + && sig_n_prime256.w[0] > + sig_x.w[0])) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_y - exp_x], sig_y); + if ((sig_n_prime192.w[2] == 0) && (sig_n_prime192.w[1] == sig_x.w[1]) + && (sig_n_prime192.w[0] == sig_x.w[0])) { + res = (exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } + res = (((sig_n_prime192.w[2] != 0) || + // if upper128 bits of compensated y are non-zero, y is bigger + (sig_n_prime192.w[1] > sig_x.w[1]) || + // if compensated y is bigger, y is bigger + (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0])) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); +} + +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_totalOrderMag (int *pres, UINT128 * px, + UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; + UINT128 y = *py; +#else +int +bid128_totalOrderMag (UINT128 x, + UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + int exp_x, exp_y; + UINT128 sig_x, sig_y, pyld_y, pyld_x; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0; + + BID_SWAP128 (x); + BID_SWAP128 (y); + x.w[1] = x.w[1] & 0x7fffffffffffffffull; + y.w[1] = y.w[1] & 0x7fffffffffffffffull; + + // NaN (CASE 1) + // if x and y are unordered numerically because either operand is NaN + // (1) totalOrder(number, +NaN) is true + // (2) if x and y are both NaN: + // i) signaling < quiet for +NaN + // ii) lesser payload < greater payload for +NaN + // iii) else if bitwise identical (in canonical form), return 1 + if ((x.w[1] & MASK_NAN) == MASK_NAN) { + // x is +NaN + // return false, unless y is +NaN also + if ((y.w[1] & MASK_NAN) != MASK_NAN) { + res = 0; // y is a number, return 0 + BID_RETURN (res); + } else { + // x and y are both +NaN; + pyld_x.w[1] = x.w[1] & 0x00003fffffffffffull; + pyld_x.w[0] = x.w[0]; + pyld_y.w[1] = y.w[1] & 0x00003fffffffffffull; + pyld_y.w[0] = y.w[0]; + if ((pyld_x.w[1] > 0x0000314dc6448d93ull) + || ((pyld_x.w[1] == 0x0000314dc6448d93ull) + && (pyld_x.w[0] > 0x38c15b09ffffffffull))) { + pyld_x.w[1] = 0; + pyld_x.w[0] = 0; + } + if ((pyld_y.w[1] > 0x0000314dc6448d93ull) + || ((pyld_y.w[1] == 0x0000314dc6448d93ull) + && (pyld_y.w[0] > 0x38c15b09ffffffffull))) { + pyld_y.w[1] = 0; + pyld_y.w[0] = 0; + } + // if x and y are both +SNaN or both +QNaN, we have to compare payloads + // this statement evaluates to true if both are SNaN or QNaN + if (! + (((y.w[1] & MASK_SNAN) == MASK_SNAN) ^ + ((x.w[1] & MASK_SNAN) == MASK_SNAN))) { + // it comes down to the payload. we want to return true if x has a + // smaller payload, or if the payloads are equal (canonical forms + // are bitwise identical) + if ((pyld_x.w[1] < pyld_y.w[1]) || + ((pyld_x.w[1] == pyld_y.w[1]) + && (pyld_x.w[0] <= pyld_y.w[0]))) { + res = 1; + } else { + res = 0; + } + BID_RETURN (res); + } else { + // either x = SNaN and y = QNaN or x = QNaN and y = SNaN + res = ((x.w[1] & MASK_SNAN) == MASK_SNAN); + // totalOrder (-QNaN, -SNaN) == 1 + BID_RETURN (res); + } + } + } else if ((y.w[1] & MASK_NAN) == MASK_NAN) { + // x is certainly not NAN in this case. + // return true because y is positive + res = 1; + BID_RETURN (res); + } + // SIMPLE (CASE 2) + // if all the bits are the same, the numbers are equal. + if ((x.w[1] == y.w[1]) && (x.w[0] == y.w[0])) { + res = 1; + BID_RETURN (res); + } + // INFINITY (CASE 3) + if ((x.w[1] & MASK_INF) == MASK_INF) { + // x is positive infinity, only return 1 if y is positive infinity as well + res = ((y.w[1] & MASK_INF) == MASK_INF); + BID_RETURN (res); + // (we know y has same sign as x) + } else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so: + // since y is +inf, x> 49) & 0x000000000003fffull; + + // CHECK IF x IS CANONICAL + // 9999999999999999999999999999999999 (decimal) = + // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal) + // [0, 10^34) is the 754r supported canonical range. + // If the value exceeds that, it is interpreted as 0. + if ((((sig_x.w[1] > 0x0001ed09bead87c0ull) || + ((sig_x.w[1] == 0x0001ed09bead87c0ull) && + (sig_x.w[0] > 0x378d8e63ffffffffull))) && + ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) || + ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) || + ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; + // check for the case where the exponent is shifted right by 2 bits! + if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { + exp_x = (x.w[1] >> 47) & 0x000000000003fffull; + } + } + // CONVERT y + exp_y = (y.w[1] >> 49) & 0x0000000000003fffull; + sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull; + sig_y.w[0] = y.w[0]; + + // CHECK IF y IS CANONICAL + // 9999999999999999999999999999999999(decimal) = + // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal) + // [0, 10^34) is the 754r supported canonical range. + // If the value exceeds that, it is interpreted as 0. + if ((((sig_y.w[1] > 0x0001ed09bead87c0ull) || + ((sig_y.w[1] == 0x0001ed09bead87c0ull) && + (sig_y.w[0] > 0x378d8e63ffffffffull))) && + ((y.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) || + ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) || + ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; + // check for the case where the exponent is shifted right by 2 bits! + if ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { + exp_y = (y.w[1] >> 47) & 0x000000000003fffull; + } + } + // ZERO (CASE 4) + if (x_is_zero && y_is_zero) { + // we know that signs must be the same because we would have caught it + // in case3 if signs were different + // totalOrder(x,y) iff exp_x <= exp_y for positive numbers + if (exp_x == exp_y) { + res = 1; + BID_RETURN (res); + } + res = (exp_x <= exp_y); + BID_RETURN (res); + } + // if x is zero and y isn't, clearly x has the smaller payload + if (x_is_zero) { + res = 1; + BID_RETURN (res); + } + // if y is zero, and x isn't, clearly y has the smaller payload + if (y_is_zero) { + res = 0; + BID_RETURN (res); + } + // REDUNDANT REPRESENTATIONS (CASE 5) + // if both components are either bigger or smaller + if (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0])) + && exp_x >= exp_y) { + res = 0; + BID_RETURN (res); + } + if (((sig_x.w[1] < sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0])) + && exp_x <= exp_y) { + res = 1; + BID_RETURN (res); + } + // if |exp_x - exp_y| < 33, it comes down to the compensated significand + if (exp_x > exp_y) { + // if exp_x is 33 greater than exp_y, it is definitely larger, + // so no need for compensation + if (exp_x - exp_y > 33) { + res = 0; // difference cannot be greater than 10^33 + BID_RETURN (res); + } + // otherwise adjust the x significand upwards + if (exp_x - exp_y > 19) { + __mul_128x128_to_256 (sig_n_prime256, sig_x, + ten2k128[exp_x - exp_y - 20]); + // the compensated significands are equal (ie "x and y represent the same + // entities") return 1 if (negative && expx > expy) || + // (positive && expx < expy) + if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) + && (sig_n_prime256.w[1] == sig_y.w[1]) + && (sig_n_prime256.w[0] == sig_y.w[0])) { + // the case (exp_x == exp_y) cannot occur, because all bits must be + // the same - would have been caught if (x == y) + res = (exp_x <= exp_y); + BID_RETURN (res); + } + // since positive, return 1 if adjusted x is smaller than y + res = ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) + && ((sig_n_prime256.w[1] < sig_y.w[1]) + || (sig_n_prime256.w[1] == sig_y.w[1] + && sig_n_prime256.w[0] < sig_y.w[0]))); + BID_RETURN (res); + } + __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_x - exp_y], sig_x); + // if positive, return whichever significand is larger + // (converse if negative) + if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1] + && (sig_n_prime192.w[0] == sig_y.w[0])) { + res = (exp_x <= exp_y); + BID_RETURN (res); + } + res = ((sig_n_prime192.w[2] == 0) + && ((sig_n_prime192.w[1] < sig_y.w[1]) + || (sig_n_prime192.w[1] == sig_y.w[1] + && sig_n_prime192.w[0] < sig_y.w[0]))); + BID_RETURN (res); + } + // if exp_x is 33 less than exp_y, it is definitely smaller, + // no need for compensation + if (exp_y - exp_x > 33) { + res = 1; + BID_RETURN (res); + } + if (exp_y - exp_x > 19) { + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, + ten2k128[exp_y - exp_x - 20]); + if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) + && (sig_n_prime256.w[1] == sig_x.w[1]) + && (sig_n_prime256.w[0] == sig_x.w[0])) { + res = (exp_x <= exp_y); + BID_RETURN (res); + } + // values are not equal, for positive numbers return 1 if x is less than y + // and 0 otherwise + res = ((sig_n_prime256.w[3] != 0) || + // if upper128 bits of compensated y are non-zero, y is bigger + (sig_n_prime256.w[2] != 0) || + // if upper128 bits of compensated y are non-zero, y is bigger + (sig_n_prime256.w[1] > sig_x.w[1]) || + // if compensated y is bigger, y is bigger + (sig_n_prime256.w[1] == sig_x.w[1] + && sig_n_prime256.w[0] > sig_x.w[0])); + BID_RETURN (res); + } + __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_y - exp_x], sig_y); + if ((sig_n_prime192.w[2] == 0) && (sig_n_prime192.w[1] == sig_x.w[1]) + && (sig_n_prime192.w[0] == sig_x.w[0])) { + res = (exp_x <= exp_y); + BID_RETURN (res); + } + res = ((sig_n_prime192.w[2] != 0) || + // if upper128 bits of compensated y are non-zero, y is bigger + (sig_n_prime192.w[1] > sig_x.w[1]) || + // if compensated y is bigger, y is bigger + (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > sig_x.w[0])); + BID_RETURN (res); +} + +#if DECIMAL_CALL_BY_REFERENCE +void +bid128_radix (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { + UINT128 x = *px; +#else +int +bid128_radix (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { +#endif + int res; + if (x.w[LOW_128W]) // dummy test + res = 10; + else + res = 10; + BID_RETURN (res); +} -- cgit v1.2.3