libgcc/config/libbid/bid64_noncomp.c

   1 /* Copyright (C) 2007-2019 Free Software Foundation, Inc.
   2
   3 This file is part of GCC.
   4
   5 GCC is free software; you can redistribute it and/or modify it under
   6 the terms of the GNU General Public License as published by the Free
   7 Software Foundation; either version 3, or (at your option) any later
   8 version.
   9
  10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 for more details.
  14
  15 Under Section 7 of GPL version 3, you are granted additional
  16 permissions described in the GCC Runtime Library Exception, version
  17 3.1, as published by the Free Software Foundation.
  18
  19 You should have received a copy of the GNU General Public License and
  20 a copy of the GCC Runtime Library Exception along with this program;
  21 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24 #include "bid_internal.h"
  25
  26 static const UINT64 mult_factor[16] = {
  27   1ull, 10ull, 100ull, 1000ull,
  28   10000ull, 100000ull, 1000000ull, 10000000ull,
  29   100000000ull, 1000000000ull, 10000000000ull, 100000000000ull,
  30   1000000000000ull, 10000000000000ull,
  31   100000000000000ull, 1000000000000000ull
  32 };
  33
  34 /*****************************************************************************
  35  *    BID64 non-computational functions:
  36  *         - bid64_isSigned
  37  *         - bid64_isNormal
  38  *         - bid64_isSubnormal
  39  *         - bid64_isFinite
  40  *         - bid64_isZero
  41  *         - bid64_isInf
  42  *         - bid64_isSignaling
  43  *         - bid64_isCanonical
  44  *         - bid64_isNaN
  45  *         - bid64_copy
  46  *         - bid64_negate
  47  *         - bid64_abs
  48  *         - bid64_copySign
  49  *         - bid64_class
  50  *         - bid64_sameQuantum
  51  *         - bid64_totalOrder
  52  *         - bid64_totalOrderMag
  53  *         - bid64_radix
  54  ****************************************************************************/
  55
  56 #if DECIMAL_CALL_BY_REFERENCE
  57 void
  58 bid64_isSigned (int *pres, UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
  59   UINT64 x = *px;
  60 #else
  61 int
  62 bid64_isSigned (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
  63 #endif
  64   int res;
  65
  66   res = ((x & MASK_SIGN) == MASK_SIGN);
  67   BID_RETURN (res);
  68 }
  69
  70 // return 1 iff x is not zero, nor NaN nor subnormal nor infinity
  71 #if DECIMAL_CALL_BY_REFERENCE
  72 void
  73 bid64_isNormal (int *pres, UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
  74   UINT64 x = *px;
  75 #else
  76 int
  77 bid64_isNormal (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
  78 #endif
  79   int res;
  80   UINT128 sig_x_prime;
  81   UINT64 sig_x;
  82   unsigned int exp_x;
  83
  84   if ((x & MASK_INF) == MASK_INF) {     // x is either INF or NaN
  85     res = 0;
  86   } else {
  87     // decode number into exponent and significand
  88     if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  89       sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  90       // check for zero or non-canonical
  91       if (sig_x > 9999999999999999ull || sig_x == 0) {
  92         res = 0;        // zero or non-canonical
  93         BID_RETURN (res);
  94       }
  95       exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
  96     } else {
  97       sig_x = (x & MASK_BINARY_SIG1);
  98       if (sig_x == 0) {
  99         res = 0;        // zero
 100         BID_RETURN (res);
 101       }
 102       exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 103     }
 104     // if exponent is less than -383, the number may be subnormal
 105     // if (exp_x - 398 = -383) the number may be subnormal
 106     if (exp_x < 15) {
 107       __mul_64x64_to_128MACH (sig_x_prime, sig_x, mult_factor[exp_x]);
 108       if (sig_x_prime.w[1] == 0
 109           && sig_x_prime.w[0] < 1000000000000000ull) {
 110         res = 0;        // subnormal
 111       } else {
 112         res = 1;        // normal
 113       }
 114     } else {
 115       res = 1;  // normal
 116     }
 117   }
 118   BID_RETURN (res);
 119 }
 120
 121 // return 1 iff x is not zero, nor NaN nor normal nor infinity
 122 #if DECIMAL_CALL_BY_REFERENCE
 123 void
 124 bid64_isSubnormal (int *pres,
 125                    UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 126   UINT64 x = *px;
 127 #else
 128 int
 129 bid64_isSubnormal (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 130 #endif
 131   int res;
 132   UINT128 sig_x_prime;
 133   UINT64 sig_x;
 134   unsigned int exp_x;
 135
 136   if ((x & MASK_INF) == MASK_INF) {     // x is either INF or NaN
 137     res = 0;
 138   } else {
 139     // decode number into exponent and significand
 140     if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 141       sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 142       // check for zero or non-canonical
 143       if (sig_x > 9999999999999999ull || sig_x == 0) {
 144         res = 0;        // zero or non-canonical
 145         BID_RETURN (res);
 146       }
 147       exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
 148     } else {
 149       sig_x = (x & MASK_BINARY_SIG1);
 150       if (sig_x == 0) {
 151         res = 0;        // zero
 152         BID_RETURN (res);
 153       }
 154       exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 155     }
 156     // if exponent is less than -383, the number may be subnormal
 157     // if (exp_x - 398 = -383) the number may be subnormal
 158     if (exp_x < 15) {
 159       __mul_64x64_to_128MACH (sig_x_prime, sig_x, mult_factor[exp_x]);
 160       if (sig_x_prime.w[1] == 0
 161           && sig_x_prime.w[0] < 1000000000000000ull) {
 162         res = 1;        // subnormal
 163       } else {
 164         res = 0;        // normal
 165       }
 166     } else {
 167       res = 0;  // normal
 168     }
 169   }
 170   BID_RETURN (res);
 171 }
 172
 173 //iff x is zero, subnormal or normal (not infinity or NaN)
 174 #if DECIMAL_CALL_BY_REFERENCE
 175 void
 176 bid64_isFinite (int *pres, UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 177   UINT64 x = *px;
 178 #else
 179 int
 180 bid64_isFinite (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 181 #endif
 182   int res;
 183
 184   res = ((x & MASK_INF) != MASK_INF);
 185   BID_RETURN (res);
 186 }
 187
 188 #if DECIMAL_CALL_BY_REFERENCE
 189 void
 190 bid64_isZero (int *pres, UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 191   UINT64 x = *px;
 192 #else
 193 int
 194 bid64_isZero (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 195 #endif
 196   int res;
 197
 198   // if infinity or nan, return 0
 199   if ((x & MASK_INF) == MASK_INF) {
 200     res = 0;
 201   } else if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 202     // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1]
 203     // => sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 204     // if(sig_x > 9999999999999999ull) {return 1;}
 205     res =
 206       (((x & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >
 207        9999999999999999ull);
 208   } else {
 209     res = ((x & MASK_BINARY_SIG1) == 0);
 210   }
 211   BID_RETURN (res);
 212 }
 213
 214 #if DECIMAL_CALL_BY_REFERENCE
 215 void
 216 bid64_isInf (int *pres, UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 217   UINT64 x = *px;
 218 #else
 219 int
 220 bid64_isInf (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 221 #endif
 222   int res;
 223
 224   res = ((x & MASK_INF) == MASK_INF) && ((x & MASK_NAN) != MASK_NAN);
 225   BID_RETURN (res);
 226 }
 227
 228 #if DECIMAL_CALL_BY_REFERENCE
 229 void
 230 bid64_isSignaling (int *pres,
 231                    UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 232   UINT64 x = *px;
 233 #else
 234 int
 235 bid64_isSignaling (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 236 #endif
 237   int res;
 238
 239   res = ((x & MASK_SNAN) == MASK_SNAN);
 240   BID_RETURN (res);
 241 }
 242
 243 #if DECIMAL_CALL_BY_REFERENCE
 244 void
 245 bid64_isCanonical (int *pres,
 246                    UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 247   UINT64 x = *px;
 248 #else
 249 int
 250 bid64_isCanonical (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 251 #endif
 252   int res;
 253
 254   if ((x & MASK_NAN) == MASK_NAN) {     // NaN
 255     if (x & 0x01fc000000000000ull) {
 256       res = 0;
 257     } else if ((x & 0x0003ffffffffffffull) > 999999999999999ull) {      // payload
 258       res = 0;
 259     } else {
 260       res = 1;
 261     }
 262   } else if ((x & MASK_INF) == MASK_INF) {
 263     if (x & 0x03ffffffffffffffull) {
 264       res = 0;
 265     } else {
 266       res = 1;
 267     }
 268   } else if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {  // 54-bit coeff.
 269     res =
 270       (((x & MASK_BINARY_SIG2) | MASK_BINARY_OR2) <=
 271        9999999999999999ull);
 272   } else {      // 53-bit coeff.
 273     res = 1;
 274   }
 275   BID_RETURN (res);
 276 }
 277
 278 #if DECIMAL_CALL_BY_REFERENCE
 279 void
 280 bid64_isNaN (int *pres, UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 281   UINT64 x = *px;
 282 #else
 283 int
 284 bid64_isNaN (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 285 #endif
 286   int res;
 287
 288   res = ((x & MASK_NAN) == MASK_NAN);
 289   BID_RETURN (res);
 290 }
 291
 292 // copies a floating-point operand x to destination y, with no change
 293 #if DECIMAL_CALL_BY_REFERENCE
 294 void
 295 bid64_copy (UINT64 * pres, UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 296   UINT64 x = *px;
 297 #else
 298 UINT64
 299 bid64_copy (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 300 #endif
 301   UINT64 res;
 302
 303   res = x;
 304   BID_RETURN (res);
 305 }
 306
 307 // copies a floating-point operand x to destination y, reversing the sign
 308 #if DECIMAL_CALL_BY_REFERENCE
 309 void
 310 bid64_negate (UINT64 * pres,
 311               UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 312   UINT64 x = *px;
 313 #else
 314 UINT64
 315 bid64_negate (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 316 #endif
 317   UINT64 res;
 318
 319   res = x ^ MASK_SIGN;
 320   BID_RETURN (res);
 321 }
 322
 323 // copies a floating-point operand x to destination y, changing the sign to positive
 324 #if DECIMAL_CALL_BY_REFERENCE
 325 void
 326 bid64_abs (UINT64 * pres, UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 327   UINT64 x = *px;
 328 #else
 329 UINT64
 330 bid64_abs (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 331 #endif
 332   UINT64 res;
 333
 334   res = x & ~MASK_SIGN;
 335   BID_RETURN (res);
 336 }
 337
 338 // copies operand x to destination in the same format as x, but
 339 // with the sign of y
 340 #if DECIMAL_CALL_BY_REFERENCE
 341 void
 342 bid64_copySign (UINT64 * pres, UINT64 * px,
 343                 UINT64 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 344   UINT64 x = *px;
 345   UINT64 y = *py;
 346 #else
 347 UINT64
 348 bid64_copySign (UINT64 x, UINT64 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 349 #endif
 350   UINT64 res;
 351
 352   res = (x & ~MASK_SIGN) | (y & MASK_SIGN);
 353   BID_RETURN (res);
 354 }
 355
 356 #if DECIMAL_CALL_BY_REFERENCE
 357 void
 358 bid64_class (int *pres, UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 359   UINT64 x = *px;
 360 #else
 361 int
 362 bid64_class (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 363 #endif
 364   int res;
 365   UINT128 sig_x_prime;
 366   UINT64 sig_x;
 367   int exp_x;
 368
 369   if ((x & MASK_NAN) == MASK_NAN) {
 370     // is the NaN signaling?
 371     if ((x & MASK_SNAN) == MASK_SNAN) {
 372       res = signalingNaN;
 373       BID_RETURN (res);
 374     }
 375     // if NaN and not signaling, must be quietNaN
 376     res = quietNaN;
 377     BID_RETURN (res);
 378   } else if ((x & MASK_INF) == MASK_INF) {
 379     // is the Infinity negative?
 380     if ((x & MASK_SIGN) == MASK_SIGN) {
 381       res = negativeInfinity;
 382     } else {
 383       // otherwise, must be positive infinity
 384       res = positiveInfinity;
 385     }
 386     BID_RETURN (res);
 387   } else if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 388     // decode number into exponent and significand
 389     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 390     // check for zero or non-canonical
 391     if (sig_x > 9999999999999999ull || sig_x == 0) {
 392       if ((x & MASK_SIGN) == MASK_SIGN) {
 393         res = negativeZero;
 394       } else {
 395         res = positiveZero;
 396       }
 397       BID_RETURN (res);
 398     }
 399     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
 400   } else {
 401     sig_x = (x & MASK_BINARY_SIG1);
 402     if (sig_x == 0) {
 403       res =
 404         ((x & MASK_SIGN) == MASK_SIGN) ? negativeZero : positiveZero;
 405       BID_RETURN (res);
 406     }
 407     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 408   }
 409   // if exponent is less than -383, number may be subnormal
 410   //  if (exp_x - 398 < -383)
 411   if (exp_x < 15) {     // sig_x *10^exp_x
 412     __mul_64x64_to_128MACH (sig_x_prime, sig_x, mult_factor[exp_x]);
 413     if (sig_x_prime.w[1] == 0
 414         && (sig_x_prime.w[0] < 1000000000000000ull)) {
 415       res =
 416         ((x & MASK_SIGN) ==
 417          MASK_SIGN) ? negativeSubnormal : positiveSubnormal;
 418       BID_RETURN (res);
 419     }
 420   }
 421   // otherwise, normal number, determine the sign
 422   res =
 423     ((x & MASK_SIGN) == MASK_SIGN) ? negativeNormal : positiveNormal;
 424   BID_RETURN (res);
 425 }
 426
 427 // true if the exponents of x and y are the same, false otherwise.
 428 // The special cases of sameQuantum (NaN, NaN) and sameQuantum (Inf, Inf) are
 429 // true.
 430 // If exactly one operand is infinite or exactly one operand is NaN, then false
 431 #if DECIMAL_CALL_BY_REFERENCE
 432 void
 433 bid64_sameQuantum (int *pres, UINT64 * px,
 434                    UINT64 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 435   UINT64 x = *px;
 436   UINT64 y = *py;
 437 #else
 438 int
 439 bid64_sameQuantum (UINT64 x, UINT64 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 440 #endif
 441   int res;
 442   unsigned int exp_x, exp_y;
 443
 444   // if both operands are NaN, return true; if just one is NaN, return false
 445   if ((x & MASK_NAN) == MASK_NAN || ((y & MASK_NAN) == MASK_NAN)) {
 446     res = ((x & MASK_NAN) == MASK_NAN && (y & MASK_NAN) == MASK_NAN);
 447     BID_RETURN (res);
 448   }
 449   // if both operands are INF, return true; if just one is INF, return false
 450   if ((x & MASK_INF) == MASK_INF || (y & MASK_INF) == MASK_INF) {
 451     res = ((x & MASK_INF) == MASK_INF && (y & MASK_INF) == MASK_INF);
 452     BID_RETURN (res);
 453   }
 454   // decode exponents for both numbers, and return true if they match
 455   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 456     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
 457   } else {
 458     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 459   }
 460   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 461     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
 462   } else {
 463     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
 464   }
 465   res = (exp_x == exp_y);
 466   BID_RETURN (res);
 467 }
 468
 469 #if DECIMAL_CALL_BY_REFERENCE
 470 void
 471 bid64_totalOrder (int *pres, UINT64 * px,
 472                   UINT64 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 473   UINT64 x = *px;
 474   UINT64 y = *py;
 475 #else
 476 int
 477 bid64_totalOrder (UINT64 x, UINT64 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 478 #endif
 479   int res;
 480   int exp_x, exp_y;
 481   UINT64 sig_x, sig_y, pyld_y, pyld_x;
 482   UINT128 sig_n_prime;
 483   char x_is_zero = 0, y_is_zero = 0;
 484
 485   // NaN (CASE1)
 486   // if x and y are unordered numerically because either operand is NaN
 487   //    (1) totalOrder(-NaN, number) is true
 488   //    (2) totalOrder(number, +NaN) is true
 489   //    (3) if x and y are both NaN:
 490   //           i) negative sign bit < positive sign bit
 491   //           ii) signaling < quiet for +NaN, reverse for -NaN
 492   //           iii) lesser payload < greater payload for +NaN (reverse for -NaN)
 493   //           iv) else if bitwise identical (in canonical form), return 1
 494   if ((x & MASK_NAN) == MASK_NAN) {
 495     // if x is -NaN
 496     if ((x & MASK_SIGN) == MASK_SIGN) {
 497       // return true, unless y is -NaN also
 498       if ((y & MASK_NAN) != MASK_NAN || (y & MASK_SIGN) != MASK_SIGN) {
 499         res = 1;        // y is a number, return 1
 500         BID_RETURN (res);
 501       } else {  // if y and x are both -NaN
 502         // if x and y are both -sNaN or both -qNaN, we have to compare payloads
 503         // this xnor statement evaluates to true if both are sNaN or qNaN
 504         if (!
 505             (((y & MASK_SNAN) == MASK_SNAN) ^ ((x & MASK_SNAN) ==
 506                                                MASK_SNAN))) {
 507           // it comes down to the payload.  we want to return true if x has a
 508           // larger payload, or if the payloads are equal (canonical forms
 509           // are bitwise identical)
 510           pyld_y = y & 0x0003ffffffffffffull;
 511           pyld_x = x & 0x0003ffffffffffffull;
 512           if (pyld_y > 999999999999999ull || pyld_y == 0) {
 513             // if y is zero, x must be less than or numerically equal
 514             // y's payload is 0
 515             res = 1;
 516             BID_RETURN (res);
 517           }
 518           // if x is zero and y isn't, x has the smaller payload
 519           // definitely (since we know y isn't 0 at this point)
 520           if (pyld_x > 999999999999999ull || pyld_x == 0) {
 521             // x's payload is 0
 522             res = 0;
 523             BID_RETURN (res);
 524           }
 525           res = (pyld_x >= pyld_y);
 526           BID_RETURN (res);
 527         } else {
 528           // either x = -sNaN and y = -qNaN or x = -qNaN and y = -sNaN
 529           res = (y & MASK_SNAN) == MASK_SNAN;   // totalOrder(-qNaN, -sNaN) == 1
 530           BID_RETURN (res);
 531         }
 532       }
 533     } else {    // x is +NaN
 534       // return false, unless y is +NaN also
 535       if ((y & MASK_NAN) != MASK_NAN || (y & MASK_SIGN) == MASK_SIGN) {
 536         res = 0;        // y is a number, return 1
 537         BID_RETURN (res);
 538       } else {
 539         // x and y are both +NaN;
 540         // must investigate payload if both quiet or both signaling
 541         // this xnor statement will be true if both x and y are +qNaN or +sNaN
 542         if (!
 543             (((y & MASK_SNAN) == MASK_SNAN) ^ ((x & MASK_SNAN) ==
 544                                                MASK_SNAN))) {
 545           // it comes down to the payload.  we want to return true if x has a
 546           // smaller payload, or if the payloads are equal (canonical forms
 547           // are bitwise identical)
 548           pyld_y = y & 0x0003ffffffffffffull;
 549           pyld_x = x & 0x0003ffffffffffffull;
 550           // if x is zero and y isn't, x has the smaller
 551           // payload definitely (since we know y isn't 0 at this point)
 552           if (pyld_x > 999999999999999ull || pyld_x == 0) {
 553             res = 1;
 554             BID_RETURN (res);
 555           }
 556           if (pyld_y > 999999999999999ull || pyld_y == 0) {
 557             // if y is zero, x must be less than or numerically equal
 558             res = 0;
 559             BID_RETURN (res);
 560           }
 561           res = (pyld_x <= pyld_y);
 562           BID_RETURN (res);
 563         } else {
 564           // return true if y is +qNaN and x is +sNaN
 565           // (we know they're different bc of xor if_stmt above)
 566           res = ((x & MASK_SNAN) == MASK_SNAN);
 567           BID_RETURN (res);
 568         }
 569       }
 570     }
 571   } else if ((y & MASK_NAN) == MASK_NAN) {
 572     // x is certainly not NAN in this case.
 573     // return true if y is positive
 574     res = ((y & MASK_SIGN) != MASK_SIGN);
 575     BID_RETURN (res);
 576   }
 577   // SIMPLE (CASE2)
 578   // if all the bits are the same, these numbers are equal.
 579   if (x == y) {
 580     res = 1;
 581     BID_RETURN (res);
 582   }
 583   // OPPOSITE SIGNS (CASE 3)
 584   // if signs are opposite, return 1 if x is negative
 585   // (if x<y, totalOrder is true)
 586   if (((x & MASK_SIGN) == MASK_SIGN) ^ ((y & MASK_SIGN) == MASK_SIGN)) {
 587     res = (x & MASK_SIGN) == MASK_SIGN;
 588     BID_RETURN (res);
 589   }
 590   // INFINITY (CASE4)
 591   if ((x & MASK_INF) == MASK_INF) {
 592     // if x==neg_inf, return (y == neg_inf)?1:0;
 593     if ((x & MASK_SIGN) == MASK_SIGN) {
 594       res = 1;
 595       BID_RETURN (res);
 596     } else {
 597       // x is positive infinity, only return1 if y
 598       // is positive infinity as well
 599       // (we know y has same sign as x)
 600       res = ((y & MASK_INF) == MASK_INF);
 601       BID_RETURN (res);
 602     }
 603   } else if ((y & MASK_INF) == MASK_INF) {
 604     // x is finite, so:
 605     //    if y is +inf, x<y
 606     //    if y is -inf, x>y
 607     res = ((y & MASK_SIGN) != MASK_SIGN);
 608     BID_RETURN (res);
 609   }
 610   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 611   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 612     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
 613     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 614     if (sig_x > 9999999999999999ull || sig_x == 0) {
 615       x_is_zero = 1;
 616     }
 617   } else {
 618     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 619     sig_x = (x & MASK_BINARY_SIG1);
 620     if (sig_x == 0) {
 621       x_is_zero = 1;
 622     }
 623   }
 624
 625   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 626   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 627     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
 628     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 629     if (sig_y > 9999999999999999ull || sig_y == 0) {
 630       y_is_zero = 1;
 631     }
 632   } else {
 633     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
 634     sig_y = (y & MASK_BINARY_SIG1);
 635     if (sig_y == 0) {
 636       y_is_zero = 1;
 637     }
 638   }
 639
 640   // ZERO (CASE 5)
 641   // if x and y represent the same entities, and
 642   // both are negative , return true iff exp_x <= exp_y
 643   if (x_is_zero && y_is_zero) {
 644     if (!((x & MASK_SIGN) == MASK_SIGN) ^
 645         ((y & MASK_SIGN) == MASK_SIGN)) {
 646       // if signs are the same:
 647       // totalOrder(x,y) iff exp_x >= exp_y for negative numbers
 648       // totalOrder(x,y) iff exp_x <= exp_y for positive numbers
 649       if (exp_x == exp_y) {
 650         res = 1;
 651         BID_RETURN (res);
 652       }
 653       res = (exp_x <= exp_y) ^ ((x & MASK_SIGN) == MASK_SIGN);
 654       BID_RETURN (res);
 655     } else {
 656       // signs are different.
 657       // totalOrder(-0, +0) is true
 658       // totalOrder(+0, -0) is false
 659       res = ((x & MASK_SIGN) == MASK_SIGN);
 660       BID_RETURN (res);
 661     }
 662   }
 663   // if x is zero and y isn't, clearly x has the smaller payload.
 664   if (x_is_zero) {
 665     res = ((y & MASK_SIGN) != MASK_SIGN);
 666     BID_RETURN (res);
 667   }
 668   // if y is zero, and x isn't, clearly y has the smaller payload.
 669   if (y_is_zero) {
 670     res = ((x & MASK_SIGN) == MASK_SIGN);
 671     BID_RETURN (res);
 672   }
 673   // REDUNDANT REPRESENTATIONS (CASE6)
 674   // if both components are either bigger or smaller,
 675   // it is clear what needs to be done
 676   if (sig_x > sig_y && exp_x >= exp_y) {
 677     res = ((x & MASK_SIGN) == MASK_SIGN);
 678     BID_RETURN (res);
 679   }
 680   if (sig_x < sig_y && exp_x <= exp_y) {
 681     res = ((x & MASK_SIGN) != MASK_SIGN);
 682     BID_RETURN (res);
 683   }
 684   // if exp_x is 15 greater than exp_y, it is
 685   // definitely larger, so no need for compensation
 686   if (exp_x - exp_y > 15) {
 687     // difference cannot be greater than 10^15
 688     res = ((x & MASK_SIGN) == MASK_SIGN);
 689     BID_RETURN (res);
 690   }
 691   // if exp_x is 15 less than exp_y, it is
 692   // definitely smaller, no need for compensation
 693   if (exp_y - exp_x > 15) {
 694     res = ((x & MASK_SIGN) != MASK_SIGN);
 695     BID_RETURN (res);
 696   }
 697   // if |exp_x - exp_y| < 15, it comes down
 698   // to the compensated significand
 699   if (exp_x > exp_y) {
 700     // otherwise adjust the x significand upwards
 701     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
 702                             mult_factor[exp_x - exp_y]);
 703     // if x and y represent the same entities,
 704     // and both are negative, return true iff exp_x <= exp_y
 705     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
 706       // case cannot occure, because all bits must
 707       // be the same - would have been caught if (x==y)
 708       res = (exp_x <= exp_y) ^ ((x & MASK_SIGN) == MASK_SIGN);
 709       BID_RETURN (res);
 710     }
 711     // if positive, return 1 if adjusted x is smaller than y
 712     res = ((sig_n_prime.w[1] == 0)
 713            && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
 714                                            MASK_SIGN);
 715     BID_RETURN (res);
 716   }
 717   // adjust the y significand upwards
 718   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
 719                           mult_factor[exp_y - exp_x]);
 720
 721   // if x and y represent the same entities,
 722   // and both are negative, return true iff exp_x <= exp_y
 723   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
 724     // Cannot occur, because all bits must be the same.
 725     // Case would have been caught if (x==y)
 726     res = (exp_x <= exp_y) ^ ((x & MASK_SIGN) == MASK_SIGN);
 727     BID_RETURN (res);
 728   }
 729   // values are not equal, for positive numbers return 1
 730   // if x is less than y.  0 otherwise
 731   res = ((sig_n_prime.w[1] > 0)
 732          || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
 733                                            MASK_SIGN);
 734   BID_RETURN (res);
 735 }
 736
 737 // totalOrderMag is TotalOrder(abs(x), abs(y))
 738 #if DECIMAL_CALL_BY_REFERENCE
 739 void
 740 bid64_totalOrderMag (int *pres, UINT64 * px,
 741                      UINT64 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 742   UINT64 x = *px;
 743   UINT64 y = *py;
 744 #else
 745 int
 746 bid64_totalOrderMag (UINT64 x,
 747                      UINT64 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 748 #endif
 749   int res;
 750   int exp_x, exp_y;
 751   UINT64 sig_x, sig_y, pyld_y, pyld_x;
 752   UINT128 sig_n_prime;
 753   char x_is_zero = 0, y_is_zero = 0;
 754
 755   // NaN (CASE 1)
 756   // if x and y are unordered numerically because either operand is NaN
 757   //    (1) totalOrder(number, +NaN) is true
 758   //    (2) if x and y are both NaN:
 759   //       i) signaling < quiet for +NaN
 760   //       ii) lesser payload < greater payload for +NaN
 761   //       iii) else if bitwise identical (in canonical form), return 1
 762   if ((x & MASK_NAN) == MASK_NAN) {
 763     // x is +NaN
 764
 765     // return false, unless y is +NaN also
 766     if ((y & MASK_NAN) != MASK_NAN) {
 767       res = 0;  // y is a number, return 1
 768       BID_RETURN (res);
 769
 770     } else {
 771
 772       // x and y are both +NaN;
 773       // must investigate payload if both quiet or both signaling
 774       // this xnor statement will be true if both x and y are +qNaN or +sNaN
 775       if (!
 776           (((y & MASK_SNAN) == MASK_SNAN) ^ ((x & MASK_SNAN) ==
 777                                              MASK_SNAN))) {
 778         // it comes down to the payload.  we want to return true if x has a
 779         // smaller payload, or if the payloads are equal (canonical forms
 780         // are bitwise identical)
 781         pyld_y = y & 0x0003ffffffffffffull;
 782         pyld_x = x & 0x0003ffffffffffffull;
 783         // if x is zero and y isn't, x has the smaller
 784         // payload definitely (since we know y isn't 0 at this point)
 785         if (pyld_x > 999999999999999ull || pyld_x == 0) {
 786           res = 1;
 787           BID_RETURN (res);
 788         }
 789
 790         if (pyld_y > 999999999999999ull || pyld_y == 0) {
 791           // if y is zero, x must be less than or numerically equal
 792           res = 0;
 793           BID_RETURN (res);
 794         }
 795         res = (pyld_x <= pyld_y);
 796         BID_RETURN (res);
 797
 798       } else {
 799         // return true if y is +qNaN and x is +sNaN
 800         // (we know they're different bc of xor if_stmt above)
 801         res = ((x & MASK_SNAN) == MASK_SNAN);
 802         BID_RETURN (res);
 803       }
 804     }
 805
 806   } else if ((y & MASK_NAN) == MASK_NAN) {
 807     // x is certainly not NAN in this case.
 808     // return true if y is positive
 809     res = 1;
 810     BID_RETURN (res);
 811   }
 812   // SIMPLE (CASE2)
 813   // if all the bits (except sign bit) are the same,
 814   // these numbers are equal.
 815   if ((x & ~MASK_SIGN) == (y & ~MASK_SIGN)) {
 816     res = 1;
 817     BID_RETURN (res);
 818   }
 819   // INFINITY (CASE3)
 820   if ((x & MASK_INF) == MASK_INF) {
 821     // x is positive infinity, only return1
 822     // if y is positive infinity as well
 823     res = ((y & MASK_INF) == MASK_INF);
 824     BID_RETURN (res);
 825   } else if ((y & MASK_INF) == MASK_INF) {
 826     // x is finite, so:
 827     //    if y is +inf, x<y
 828     res = 1;
 829     BID_RETURN (res);
 830   }
 831   // if steering bits are 11 (condition will be 0),
 832   // then exponent is G[0:w+1] =>
 833   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 834     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
 835     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 836     if (sig_x > 9999999999999999ull || sig_x == 0) {
 837       x_is_zero = 1;
 838     }
 839   } else {
 840     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 841     sig_x = (x & MASK_BINARY_SIG1);
 842     if (sig_x == 0) {
 843       x_is_zero = 1;
 844     }
 845   }
 846
 847   // if steering bits are 11 (condition will be 0),
 848   // then exponent is G[0:w+1] =>
 849   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 850     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
 851     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 852     if (sig_y > 9999999999999999ull || sig_y == 0) {
 853       y_is_zero = 1;
 854     }
 855   } else {
 856     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
 857     sig_y = (y & MASK_BINARY_SIG1);
 858     if (sig_y == 0) {
 859       y_is_zero = 1;
 860     }
 861   }
 862
 863   // ZERO (CASE 5)
 864   // if x and y represent the same entities,
 865   // and both are negative , return true iff exp_x <= exp_y
 866   if (x_is_zero && y_is_zero) {
 867     // totalOrder(x,y) iff exp_x <= exp_y for positive numbers
 868     res = (exp_x <= exp_y);
 869     BID_RETURN (res);
 870   }
 871   // if x is zero and y isn't, clearly x has the smaller payload.
 872   if (x_is_zero) {
 873     res = 1;
 874     BID_RETURN (res);
 875   }
 876   // if y is zero, and x isn't, clearly y has the smaller payload.
 877   if (y_is_zero) {
 878     res = 0;
 879     BID_RETURN (res);
 880   }
 881   // REDUNDANT REPRESENTATIONS (CASE6)
 882   // if both components are either bigger or smaller
 883   if (sig_x > sig_y && exp_x >= exp_y) {
 884     res = 0;
 885     BID_RETURN (res);
 886   }
 887   if (sig_x < sig_y && exp_x <= exp_y) {
 888     res = 1;
 889     BID_RETURN (res);
 890   }
 891   // if exp_x is 15 greater than exp_y, it is definitely
 892   // larger, so no need for compensation
 893   if (exp_x - exp_y > 15) {
 894     res = 0;    // difference cannot be greater than 10^15
 895     BID_RETURN (res);
 896   }
 897   // if exp_x is 15 less than exp_y, it is definitely
 898   // smaller, no need for compensation
 899   if (exp_y - exp_x > 15) {
 900     res = 1;
 901     BID_RETURN (res);
 902   }
 903   // if |exp_x - exp_y| < 15, it comes down
 904   // to the compensated significand
 905   if (exp_x > exp_y) {
 906
 907     // otherwise adjust the x significand upwards
 908     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
 909                             mult_factor[exp_x - exp_y]);
 910
 911     // if x and y represent the same entities,
 912     // and both are negative, return true iff exp_x <= exp_y
 913     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
 914       // case cannot occur, because all bits
 915       // must be the same - would have been caught if (x==y)
 916       res = (exp_x <= exp_y);
 917       BID_RETURN (res);
 918     }
 919     // if positive, return 1 if adjusted x is smaller than y
 920     res = ((sig_n_prime.w[1] == 0) && sig_n_prime.w[0] < sig_y);
 921     BID_RETURN (res);
 922   }
 923   // adjust the y significand upwards
 924   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
 925                           mult_factor[exp_y - exp_x]);
 926
 927   // if x and y represent the same entities,
 928   // and both are negative, return true iff exp_x <= exp_y
 929   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
 930     res = (exp_x <= exp_y);
 931     BID_RETURN (res);
 932   }
 933   // values are not equal, for positive numbers
 934   // return 1 if x is less than y.  0 otherwise
 935   res = ((sig_n_prime.w[1] > 0) || (sig_x < sig_n_prime.w[0]));
 936   BID_RETURN (res);
 937
 938 }
 939
 940 #if DECIMAL_CALL_BY_REFERENCE
 941 void
 942 bid64_radix (int *pres, UINT64 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 943   UINT64 x = *px;
 944 #else
 945 int
 946 bid64_radix (UINT64 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 947 #endif
 948   int res;
 949   if (x)        // dummy test
 950     res = 10;
 951   else
 952     res = 10;
 953   BID_RETURN (res);
 954 }