libgcc/config/libbid/bid64_compare.c

   1 /* Copyright (C) 2007  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 2, or (at your option) any later
   8 version.
   9
  10 In addition to the permissions in the GNU General Public License, the
  11 Free Software Foundation gives you unlimited permission to link the
  12 compiled version of this file into combinations with other programs,
  13 and to distribute those combinations without any restriction coming
  14 from the use of this file.  (The General Public License restrictions
  15 do apply in other respects; for example, they cover modification of
  16 the file, and distribution when not linked into a combine
  17 executable.)
  18
  19 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  20 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  21 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  22 for more details.
  23
  24 You should have received a copy of the GNU General Public License
  25 along with GCC; see the file COPYING.  If not, write to the Free
  26 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  27 02110-1301, USA.  */
  28
  29 #include "bid_internal.h"
  30
  31 static const UINT64 mult_factor[16] = {
  32   1ull, 10ull, 100ull, 1000ull,
  33   10000ull, 100000ull, 1000000ull, 10000000ull,
  34   100000000ull, 1000000000ull, 10000000000ull, 100000000000ull,
  35   1000000000000ull, 10000000000000ull,
  36   100000000000000ull, 1000000000000000ull
  37 };
  38
  39 #if DECIMAL_CALL_BY_REFERENCE
  40 void
  41 bid64_quiet_equal (int *pres, UINT64 * px,
  42                    UINT64 *
  43                    py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  44                    _EXC_INFO_PARAM) {
  45   UINT64 x = *px;
  46   UINT64 y = *py;
  47 #else
  48 int
  49 bid64_quiet_equal (UINT64 x,
  50                    UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
  51                    _EXC_INFO_PARAM) {
  52 #endif
  53   int res;
  54   int exp_x, exp_y, exp_t;
  55   UINT64 sig_x, sig_y, sig_t;
  56   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y, lcv;
  57
  58   // NaN (CASE1)
  59   // if either number is NAN, the comparison is unordered,
  60   // rather than equal : return 0
  61   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
  62     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
  63       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
  64     }
  65     res = 0;
  66     BID_RETURN (res);
  67   }
  68   // SIMPLE (CASE2)
  69   // if all the bits are the same, these numbers are equivalent.
  70   if (x == y) {
  71     res = 1;
  72     BID_RETURN (res);
  73   }
  74   // INFINITY (CASE3)
  75   if (((x & MASK_INF) == MASK_INF) && ((y & MASK_INF) == MASK_INF)) {
  76     res = (((x ^ y) & MASK_SIGN) != MASK_SIGN);
  77     BID_RETURN (res);
  78   }
  79   // ONE INFINITY (CASE3')
  80   if (((x & MASK_INF) == MASK_INF) || ((y & MASK_INF) == MASK_INF)) {
  81     res = 0;
  82     BID_RETURN (res);
  83   }
  84   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  85   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
  86     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
  87     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
  88     if (sig_x > 9999999999999999ull) {
  89       non_canon_x = 1;
  90     } else {
  91       non_canon_x = 0;
  92     }
  93   } else {
  94     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
  95     sig_x = (x & MASK_BINARY_SIG1);
  96     non_canon_x = 0;
  97   }
  98   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
  99   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 100     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
 101     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 102     if (sig_y > 9999999999999999ull) {
 103       non_canon_y = 1;
 104     } else {
 105       non_canon_y = 0;
 106     }
 107   } else {
 108     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
 109     sig_y = (y & MASK_BINARY_SIG1);
 110     non_canon_y = 0;
 111   }
 112   // ZERO (CASE4)
 113   // some properties:
 114   // (+ZERO==-ZERO) => therefore ignore the sign
 115   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
 116   //    therefore ignore the exponent field
 117   //    (Any non-canonical # is considered 0)
 118   if (non_canon_x || sig_x == 0) {
 119     x_is_zero = 1;
 120   }
 121   if (non_canon_y || sig_y == 0) {
 122     y_is_zero = 1;
 123   }
 124   if (x_is_zero && y_is_zero) {
 125     res = 1;
 126     BID_RETURN (res);
 127   } else if ((x_is_zero && !y_is_zero) || (!x_is_zero && y_is_zero)) {
 128     res = 0;
 129     BID_RETURN (res);
 130   }
 131   // OPPOSITE SIGN (CASE5)
 132   // now, if the sign bits differ => not equal : return 0
 133   if ((x ^ y) & MASK_SIGN) {
 134     res = 0;
 135     BID_RETURN (res);
 136   }
 137   // REDUNDANT REPRESENTATIONS (CASE6)
 138   if (exp_x > exp_y) {  // to simplify the loop below,
 139     SWAP (exp_x, exp_y, exp_t); // put the larger exp in y,
 140     SWAP (sig_x, sig_y, sig_t); // and the smaller exp in x
 141   }
 142   if (exp_y - exp_x > 15) {
 143     res = 0;    // difference cannot be greater than 10^15
 144     BID_RETURN (res);
 145   }
 146   for (lcv = 0; lcv < (exp_y - exp_x); lcv++) {
 147     // recalculate y's significand upwards
 148     sig_y = sig_y * 10;
 149     if (sig_y > 9999999999999999ull) {
 150       res = 0;
 151       BID_RETURN (res);
 152     }
 153   }
 154   res = (sig_y == sig_x);
 155   BID_RETURN (res);
 156 }
 157
 158 #if DECIMAL_CALL_BY_REFERENCE
 159 void
 160 bid64_quiet_greater (int *pres, UINT64 * px,
 161                      UINT64 *
 162                      py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
 163                      _EXC_INFO_PARAM) {
 164   UINT64 x = *px;
 165   UINT64 y = *py;
 166 #else
 167 int
 168 bid64_quiet_greater (UINT64 x,
 169                      UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
 170                      _EXC_INFO_PARAM) {
 171 #endif
 172   int res;
 173   int exp_x, exp_y;
 174   UINT64 sig_x, sig_y;
 175   UINT128 sig_n_prime;
 176   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
 177
 178   // NaN (CASE1)
 179   // if either number is NAN, the comparison is unordered, rather than equal :
 180   // return 0
 181   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
 182     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
 183       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
 184     }
 185     res = 0;
 186     BID_RETURN (res);
 187   }
 188   // SIMPLE (CASE2)
 189   // if all the bits are the same, these numbers are equal (not Greater).
 190   if (x == y) {
 191     res = 0;
 192     BID_RETURN (res);
 193   }
 194   // INFINITY (CASE3)
 195   if ((x & MASK_INF) == MASK_INF) {
 196     // if x is neg infinity, there is no way it is greater than y, return 0
 197     if (((x & MASK_SIGN) == MASK_SIGN)) {
 198       res = 0;
 199       BID_RETURN (res);
 200     } else {
 201       // x is pos infinity, it is greater, unless y is positive
 202       // infinity => return y!=pos_infinity
 203       res = (((y & MASK_INF) != MASK_INF)
 204              || ((y & MASK_SIGN) == MASK_SIGN));
 205       BID_RETURN (res);
 206     }
 207   } else if ((y & MASK_INF) == MASK_INF) {
 208     // x is finite, so if y is positive infinity, then x is less, return 0
 209     //                 if y is negative infinity, then x is greater, return 1
 210     res = ((y & MASK_SIGN) == MASK_SIGN);
 211     BID_RETURN (res);
 212   }
 213   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 214   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 215     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
 216     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 217     if (sig_x > 9999999999999999ull) {
 218       non_canon_x = 1;
 219     } else {
 220       non_canon_x = 0;
 221     }
 222   } else {
 223     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 224     sig_x = (x & MASK_BINARY_SIG1);
 225     non_canon_x = 0;
 226   }
 227   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 228   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 229     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
 230     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 231     if (sig_y > 9999999999999999ull) {
 232       non_canon_y = 1;
 233     } else {
 234       non_canon_y = 0;
 235     }
 236   } else {
 237     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
 238     sig_y = (y & MASK_BINARY_SIG1);
 239     non_canon_y = 0;
 240   }
 241   // ZERO (CASE4)
 242   // some properties:
 243   //(+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
 244   //(ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore ignore the
 245   // exponent field
 246   // (Any non-canonical # is considered 0)
 247   if (non_canon_x || sig_x == 0) {
 248     x_is_zero = 1;
 249   }
 250   if (non_canon_y || sig_y == 0) {
 251     y_is_zero = 1;
 252   }
 253   // if both numbers are zero, neither is greater => return NOTGREATERTHAN
 254   if (x_is_zero && y_is_zero) {
 255     res = 0;
 256     BID_RETURN (res);
 257   } else if (x_is_zero) {
 258     // is x is zero, it is greater if Y is negative
 259     res = ((y & MASK_SIGN) == MASK_SIGN);
 260     BID_RETURN (res);
 261   } else if (y_is_zero) {
 262     // is y is zero, X is greater if it is positive
 263     res = ((x & MASK_SIGN) != MASK_SIGN);
 264     BID_RETURN (res);
 265   }
 266   // OPPOSITE SIGN (CASE5)
 267   // now, if the sign bits differ, x is greater if y is negative
 268   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
 269     res = ((y & MASK_SIGN) == MASK_SIGN);
 270     BID_RETURN (res);
 271   }
 272   // REDUNDANT REPRESENTATIONS (CASE6)
 273   // if both components are either bigger or smaller,
 274   // it is clear what needs to be done
 275   if (sig_x > sig_y && exp_x > exp_y) {
 276     res = ((x & MASK_SIGN) != MASK_SIGN);
 277     BID_RETURN (res);
 278   }
 279   if (sig_x < sig_y && exp_x < exp_y) {
 280     res = ((x & MASK_SIGN) == MASK_SIGN);
 281     BID_RETURN (res);
 282   }
 283   // if exp_x is 15 greater than exp_y, no need for compensation
 284   if (exp_x - exp_y > 15) {     // difference cannot be greater than 10^15
 285     if (x & MASK_SIGN)  // if both are negative
 286       res = 0;
 287     else        // if both are positive
 288       res = 1;
 289     BID_RETURN (res);
 290   }
 291   // if exp_x is 15 less than exp_y, no need for compensation
 292   if (exp_y - exp_x > 15) {
 293     if (x & MASK_SIGN)  // if both are negative
 294       res = 1;
 295     else        // if both are positive
 296       res = 0;
 297     BID_RETURN (res);
 298   }
 299   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
 300   if (exp_x > exp_y) {  // to simplify the loop below,
 301     // otherwise adjust the x significand upwards
 302     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
 303                             mult_factor[exp_x - exp_y]);
 304     // if postitive, return whichever significand is larger (converse if neg.)
 305     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
 306       res = 0;
 307       BID_RETURN (res);
 308     }
 309     res = (((sig_n_prime.w[1] > 0)
 310             || sig_n_prime.w[0] > sig_y) ^ ((x & MASK_SIGN) ==
 311                                             MASK_SIGN));
 312     BID_RETURN (res);
 313   }
 314   // adjust the y significand upwards
 315   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
 316                           mult_factor[exp_y - exp_x]);
 317   // if postitive, return whichever significand is larger
 318   //     (converse if negative)
 319   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
 320     res = 0;
 321     BID_RETURN (res);
 322   }
 323   res = (((sig_n_prime.w[1] == 0)
 324           && (sig_x > sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
 325                                             MASK_SIGN));
 326   BID_RETURN (res);
 327 }
 328
 329 #if DECIMAL_CALL_BY_REFERENCE
 330 void
 331 bid64_quiet_greater_equal (int *pres, UINT64 * px,
 332                            UINT64 *
 333                            py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
 334                            _EXC_INFO_PARAM) {
 335   UINT64 x = *px;
 336   UINT64 y = *py;
 337 #else
 338 int
 339 bid64_quiet_greater_equal (UINT64 x,
 340                            UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
 341                            _EXC_INFO_PARAM) {
 342 #endif
 343   int res;
 344   int exp_x, exp_y;
 345   UINT64 sig_x, sig_y;
 346   UINT128 sig_n_prime;
 347   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
 348
 349   // NaN (CASE1)
 350   // if either number is NAN, the comparison is unordered : return 1
 351   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
 352     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
 353       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
 354     }
 355     res = 0;
 356     BID_RETURN (res);
 357   }
 358   // SIMPLE (CASE2)
 359   // if all the bits are the same, these numbers are equal.
 360   if (x == y) {
 361     res = 1;
 362     BID_RETURN (res);
 363   }
 364   // INFINITY (CASE3)
 365   if ((x & MASK_INF) == MASK_INF) {
 366     // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
 367     if ((x & MASK_SIGN) == MASK_SIGN) {
 368       // x is -inf, so it is less than y unless y is -inf
 369       res = (((y & MASK_INF) == MASK_INF)
 370              && (y & MASK_SIGN) == MASK_SIGN);
 371       BID_RETURN (res);
 372     } else {    // x is pos_inf, no way for it to be less than y
 373       res = 1;
 374       BID_RETURN (res);
 375     }
 376   } else if ((y & MASK_INF) == MASK_INF) {
 377     // x is finite, so:
 378     //    if y is +inf, x<y
 379     //    if y is -inf, x>y
 380     res = ((y & MASK_SIGN) == MASK_SIGN);
 381     BID_RETURN (res);
 382   }
 383   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 384   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 385     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
 386     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 387     if (sig_x > 9999999999999999ull) {
 388       non_canon_x = 1;
 389     } else {
 390       non_canon_x = 0;
 391     }
 392   } else {
 393     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 394     sig_x = (x & MASK_BINARY_SIG1);
 395     non_canon_x = 0;
 396   }
 397   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 398   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 399     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
 400     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 401     if (sig_y > 9999999999999999ull) {
 402       non_canon_y = 1;
 403     } else {
 404       non_canon_y = 0;
 405     }
 406   } else {
 407     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
 408     sig_y = (y & MASK_BINARY_SIG1);
 409     non_canon_y = 0;
 410   }
 411   // ZERO (CASE4)
 412   // some properties:
 413   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
 414   // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
 415   //   therefore ignore the exponent field
 416   //  (Any non-canonical # is considered 0)
 417   if (non_canon_x || sig_x == 0) {
 418     x_is_zero = 1;
 419   }
 420   if (non_canon_y || sig_y == 0) {
 421     y_is_zero = 1;
 422   }
 423   if (x_is_zero && y_is_zero) {
 424     // if both numbers are zero, they are equal
 425     res = 1;
 426     BID_RETURN (res);
 427   } else if (x_is_zero) {
 428     // if x is zero, it is lessthan if Y is positive
 429     res = ((y & MASK_SIGN) == MASK_SIGN);
 430     BID_RETURN (res);
 431   } else if (y_is_zero) {
 432     // if y is zero, X is less if it is negative
 433     res = ((x & MASK_SIGN) != MASK_SIGN);
 434     BID_RETURN (res);
 435   }
 436   // OPPOSITE SIGN (CASE5)
 437   // now, if the sign bits differ, x is less than if y is positive
 438   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
 439     res = ((y & MASK_SIGN) == MASK_SIGN);
 440     BID_RETURN (res);
 441   }
 442   // REDUNDANT REPRESENTATIONS (CASE6)
 443   // if both components are either bigger or smaller
 444   if (sig_x > sig_y && exp_x >= exp_y) {
 445     res = ((x & MASK_SIGN) != MASK_SIGN);
 446     BID_RETURN (res);
 447   }
 448   if (sig_x < sig_y && exp_x <= exp_y) {
 449     res = ((x & MASK_SIGN) == MASK_SIGN);
 450     BID_RETURN (res);
 451   }
 452   // if exp_x is 15 greater than exp_y, no need for compensation
 453   if (exp_x - exp_y > 15) {
 454     res = ((x & MASK_SIGN) != MASK_SIGN);
 455     // difference cannot be greater than 10^15
 456     BID_RETURN (res);
 457   }
 458   // if exp_x is 15 less than exp_y, no need for compensation
 459   if (exp_y - exp_x > 15) {
 460     res = ((x & MASK_SIGN) == MASK_SIGN);
 461     BID_RETURN (res);
 462   }
 463   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
 464   if (exp_x > exp_y) {  // to simplify the loop below,
 465     // otherwise adjust the x significand upwards
 466     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
 467                             mult_factor[exp_x - exp_y]);
 468     // return 1 if values are equal
 469     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
 470       res = 1;
 471       BID_RETURN (res);
 472     }
 473     // if postitive, return whichever significand abs is smaller
 474     // (converse if negative)
 475     res = (((sig_n_prime.w[1] == 0)
 476             && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) !=
 477                                             MASK_SIGN));
 478     BID_RETURN (res);
 479   }
 480   // adjust the y significand upwards
 481   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
 482                           mult_factor[exp_y - exp_x]);
 483   // return 0 if values are equal
 484   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
 485     res = 1;
 486     BID_RETURN (res);
 487   }
 488   // if positive, return whichever significand abs is smaller
 489   // (converse if negative)
 490   res = (((sig_n_prime.w[1] > 0)
 491           || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) !=
 492                                             MASK_SIGN));
 493   BID_RETURN (res);
 494 }
 495
 496 #if DECIMAL_CALL_BY_REFERENCE
 497 void
 498 bid64_quiet_greater_unordered (int *pres, UINT64 * px,
 499                                UINT64 *
 500                                py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
 501                                _EXC_INFO_PARAM) {
 502   UINT64 x = *px;
 503   UINT64 y = *py;
 504 #else
 505 int
 506 bid64_quiet_greater_unordered (UINT64 x,
 507                                UINT64 y _EXC_FLAGS_PARAM
 508                                _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 509 #endif
 510   int res;
 511   int exp_x, exp_y;
 512   UINT64 sig_x, sig_y;
 513   UINT128 sig_n_prime;
 514   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
 515
 516   // NaN (CASE1)
 517   // if either number is NAN, the comparison is unordered, rather than equal :
 518   // return 0
 519   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
 520     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
 521       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
 522     }
 523     res = 1;
 524     BID_RETURN (res);
 525   }
 526   // SIMPLE (CASE2)
 527   // if all the bits are the same, these numbers are equal (not Greater).
 528   if (x == y) {
 529     res = 0;
 530     BID_RETURN (res);
 531   }
 532   // INFINITY (CASE3)
 533   if ((x & MASK_INF) == MASK_INF) {
 534     // if x is neg infinity, there is no way it is greater than y, return 0
 535     if (((x & MASK_SIGN) == MASK_SIGN)) {
 536       res = 0;
 537       BID_RETURN (res);
 538     } else {
 539       // x is pos infinity, it is greater, unless y is positive infinity =>
 540       // return y!=pos_infinity
 541       res = (((y & MASK_INF) != MASK_INF)
 542              || ((y & MASK_SIGN) == MASK_SIGN));
 543       BID_RETURN (res);
 544     }
 545   } else if ((y & MASK_INF) == MASK_INF) {
 546     // x is finite, so if y is positive infinity, then x is less, return 0
 547     //                 if y is negative infinity, then x is greater, return 1
 548     res = ((y & MASK_SIGN) == MASK_SIGN);
 549     BID_RETURN (res);
 550   }
 551   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 552   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 553     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
 554     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 555     if (sig_x > 9999999999999999ull) {
 556       non_canon_x = 1;
 557     } else {
 558       non_canon_x = 0;
 559     }
 560   } else {
 561     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 562     sig_x = (x & MASK_BINARY_SIG1);
 563     non_canon_x = 0;
 564   }
 565   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 566   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 567     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
 568     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 569     if (sig_y > 9999999999999999ull) {
 570       non_canon_y = 1;
 571     } else {
 572       non_canon_y = 0;
 573     }
 574   } else {
 575     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
 576     sig_y = (y & MASK_BINARY_SIG1);
 577     non_canon_y = 0;
 578   }
 579   // ZERO (CASE4)
 580   // some properties:
 581   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
 582   // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
 583   // therefore ignore the exponent field
 584   //    (Any non-canonical # is considered 0)
 585   if (non_canon_x || sig_x == 0) {
 586     x_is_zero = 1;
 587   }
 588   if (non_canon_y || sig_y == 0) {
 589     y_is_zero = 1;
 590   }
 591   // if both numbers are zero, neither is greater => return NOTGREATERTHAN
 592   if (x_is_zero && y_is_zero) {
 593     res = 0;
 594     BID_RETURN (res);
 595   } else if (x_is_zero) {
 596     // is x is zero, it is greater if Y is negative
 597     res = ((y & MASK_SIGN) == MASK_SIGN);
 598     BID_RETURN (res);
 599   } else if (y_is_zero) {
 600     // is y is zero, X is greater if it is positive
 601     res = ((x & MASK_SIGN) != MASK_SIGN);
 602     BID_RETURN (res);
 603   }
 604   // OPPOSITE SIGN (CASE5)
 605   // now, if the sign bits differ, x is greater if y is negative
 606   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
 607     res = ((y & MASK_SIGN) == MASK_SIGN);
 608     BID_RETURN (res);
 609   }
 610   // REDUNDANT REPRESENTATIONS (CASE6)
 611   // if both components are either bigger or smaller
 612   if (sig_x > sig_y && exp_x >= exp_y) {
 613     res = ((x & MASK_SIGN) != MASK_SIGN);
 614     BID_RETURN (res);
 615   }
 616   if (sig_x < sig_y && exp_x <= exp_y) {
 617     res = ((x & MASK_SIGN) == MASK_SIGN);
 618     BID_RETURN (res);
 619   }
 620   // if exp_x is 15 greater than exp_y, no need for compensation
 621   if (exp_x - exp_y > 15) {
 622     // difference cannot be greater than 10^15
 623     res = ((x & MASK_SIGN) != MASK_SIGN);
 624     BID_RETURN (res);
 625   }
 626   // if exp_x is 15 less than exp_y, no need for compensation
 627   if (exp_y - exp_x > 15) {
 628     res = ((x & MASK_SIGN) == MASK_SIGN);
 629     BID_RETURN (res);
 630   }
 631   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
 632   if (exp_x > exp_y) {  // to simplify the loop below,
 633     // otherwise adjust the x significand upwards
 634     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
 635                             mult_factor[exp_x - exp_y]);
 636     // if postitive, return whichever significand is larger
 637     // (converse if negative)
 638     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
 639       res = 0;
 640       BID_RETURN (res);
 641     }
 642     res = (((sig_n_prime.w[1] > 0)
 643             || sig_n_prime.w[0] > sig_y) ^ ((x & MASK_SIGN) ==
 644                                             MASK_SIGN));
 645     BID_RETURN (res);
 646   }
 647   // adjust the y significand upwards
 648   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
 649                           mult_factor[exp_y - exp_x]);
 650   // if postitive, return whichever significand is larger (converse if negative)
 651   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
 652     res = 0;
 653     BID_RETURN (res);
 654   }
 655   res = (((sig_n_prime.w[1] == 0)
 656           && (sig_x > sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
 657                                             MASK_SIGN));
 658   BID_RETURN (res);
 659 }
 660
 661 #if DECIMAL_CALL_BY_REFERENCE
 662 void
 663 bid64_quiet_less (int *pres, UINT64 * px,
 664                   UINT64 *
 665                   py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM)
 666 {
 667   UINT64 x = *px;
 668   UINT64 y = *py;
 669 #else
 670 int
 671 bid64_quiet_less (UINT64 x,
 672                   UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
 673                   _EXC_INFO_PARAM) {
 674 #endif
 675   int res;
 676   int exp_x, exp_y;
 677   UINT64 sig_x, sig_y;
 678   UINT128 sig_n_prime;
 679   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
 680
 681   // NaN (CASE1)
 682   // if either number is NAN, the comparison is unordered : return 0
 683   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
 684     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
 685       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
 686     }
 687     res = 0;
 688     BID_RETURN (res);
 689   }
 690   // SIMPLE (CASE2)
 691   // if all the bits are the same, these numbers are equal.
 692   if (x == y) {
 693     res = 0;
 694     BID_RETURN (res);
 695   }
 696   // INFINITY (CASE3)
 697   if ((x & MASK_INF) == MASK_INF) {
 698     // if x==neg_inf, { res = (y == neg_inf)?0:1; BID_RETURN (res) }
 699     if ((x & MASK_SIGN) == MASK_SIGN) {
 700       // x is -inf, so it is less than y unless y is -inf
 701       res = (((y & MASK_INF) != MASK_INF)
 702              || (y & MASK_SIGN) != MASK_SIGN);
 703       BID_RETURN (res);
 704     } else {
 705       // x is pos_inf, no way for it to be less than y
 706       res = 0;
 707       BID_RETURN (res);
 708     }
 709   } else if ((y & MASK_INF) == MASK_INF) {
 710     // x is finite, so:
 711     //    if y is +inf, x<y
 712     //    if y is -inf, x>y
 713     res = ((y & MASK_SIGN) != MASK_SIGN);
 714     BID_RETURN (res);
 715   }
 716   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 717   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 718     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
 719     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 720     if (sig_x > 9999999999999999ull) {
 721       non_canon_x = 1;
 722     } else {
 723       non_canon_x = 0;
 724     }
 725   } else {
 726     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 727     sig_x = (x & MASK_BINARY_SIG1);
 728     non_canon_x = 0;
 729   }
 730   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 731   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 732     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
 733     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 734     if (sig_y > 9999999999999999ull) {
 735       non_canon_y = 1;
 736     } else {
 737       non_canon_y = 0;
 738     }
 739   } else {
 740     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
 741     sig_y = (y & MASK_BINARY_SIG1);
 742     non_canon_y = 0;
 743   }
 744   // ZERO (CASE4)
 745   // some properties:
 746   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
 747   // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
 748   //  therefore ignore the exponent field
 749   //    (Any non-canonical # is considered 0)
 750   if (non_canon_x || sig_x == 0) {
 751     x_is_zero = 1;
 752   }
 753   if (non_canon_y || sig_y == 0) {
 754     y_is_zero = 1;
 755   }
 756   if (x_is_zero && y_is_zero) {
 757     // if both numbers are zero, they are equal
 758     res = 0;
 759     BID_RETURN (res);
 760   } else if (x_is_zero) {
 761     // if x is zero, it is lessthan if Y is positive
 762     res = ((y & MASK_SIGN) != MASK_SIGN);
 763     BID_RETURN (res);
 764   } else if (y_is_zero) {
 765     // if y is zero, X is less if it is negative
 766     res = ((x & MASK_SIGN) == MASK_SIGN);
 767     BID_RETURN (res);
 768   }
 769   // OPPOSITE SIGN (CASE5)
 770   // now, if the sign bits differ, x is less than if y is positive
 771   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
 772     res = ((y & MASK_SIGN) != MASK_SIGN);
 773     BID_RETURN (res);
 774   }
 775   // REDUNDANT REPRESENTATIONS (CASE6)
 776   // if both components are either bigger or smaller,
 777   // it is clear what needs to be done
 778   if (sig_x > sig_y && exp_x >= exp_y) {
 779     res = ((x & MASK_SIGN) == MASK_SIGN);
 780     BID_RETURN (res);
 781   }
 782   if (sig_x < sig_y && exp_x <= exp_y) {
 783     res = ((x & MASK_SIGN) != MASK_SIGN);
 784     BID_RETURN (res);
 785   }
 786   // if exp_x is 15 greater than exp_y, no need for compensation
 787   if (exp_x - exp_y > 15) {
 788     res = ((x & MASK_SIGN) == MASK_SIGN);
 789     // difference cannot be greater than 10^15
 790     BID_RETURN (res);
 791   }
 792   // if exp_x is 15 less than exp_y, no need for compensation
 793   if (exp_y - exp_x > 15) {
 794     res = ((x & MASK_SIGN) != MASK_SIGN);
 795     BID_RETURN (res);
 796   }
 797   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
 798   if (exp_x > exp_y) {  // to simplify the loop below,
 799     // otherwise adjust the x significand upwards
 800     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
 801                             mult_factor[exp_x - exp_y]);
 802     // return 0 if values are equal
 803     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
 804       res = 0;
 805       BID_RETURN (res);
 806     }
 807     // if postitive, return whichever significand abs is smaller
 808     // (converse if negative)
 809     res = (((sig_n_prime.w[1] == 0)
 810             && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
 811                                             MASK_SIGN));
 812     BID_RETURN (res);
 813   }
 814   // adjust the y significand upwards
 815   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
 816                           mult_factor[exp_y - exp_x]);
 817   // return 0 if values are equal
 818   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
 819     res = 0;
 820     BID_RETURN (res);
 821   }
 822   // if positive, return whichever significand abs is smaller
 823   // (converse if negative)
 824   res = (((sig_n_prime.w[1] > 0)
 825           || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
 826                                             MASK_SIGN));
 827   BID_RETURN (res);
 828 }
 829
 830 #if DECIMAL_CALL_BY_REFERENCE
 831 void
 832 bid64_quiet_less_equal (int *pres, UINT64 * px,
 833                         UINT64 *
 834                         py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
 835                         _EXC_INFO_PARAM) {
 836   UINT64 x = *px;
 837   UINT64 y = *py;
 838 #else
 839 int
 840 bid64_quiet_less_equal (UINT64 x,
 841                         UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
 842                         _EXC_INFO_PARAM) {
 843 #endif
 844   int res;
 845   int exp_x, exp_y;
 846   UINT64 sig_x, sig_y;
 847   UINT128 sig_n_prime;
 848   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
 849
 850   // NaN (CASE1)
 851   // if either number is NAN, the comparison is unordered, rather than equal :
 852   //     return 0
 853   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
 854     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
 855       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
 856     }
 857     res = 0;
 858     BID_RETURN (res);
 859   }
 860   // SIMPLE (CASE2)
 861   // if all the bits are the same, these numbers are equal (LESSEQUAL).
 862   if (x == y) {
 863     res = 1;
 864     BID_RETURN (res);
 865   }
 866   // INFINITY (CASE3)
 867   if ((x & MASK_INF) == MASK_INF) {
 868     if (((x & MASK_SIGN) == MASK_SIGN)) {
 869       // if x is neg infinity, it must be lessthan or equal to y return 1
 870       res = 1;
 871       BID_RETURN (res);
 872     } else {
 873       // x is pos infinity, it is greater, unless y is positive infinity =>
 874       // return y==pos_infinity
 875       res = !(((y & MASK_INF) != MASK_INF)
 876               || ((y & MASK_SIGN) == MASK_SIGN));
 877       BID_RETURN (res);
 878     }
 879   } else if ((y & MASK_INF) == MASK_INF) {
 880     // x is finite, so if y is positive infinity, then x is less, return 1
 881     //                 if y is negative infinity, then x is greater, return 0
 882     res = ((y & MASK_SIGN) != MASK_SIGN);
 883     BID_RETURN (res);
 884   }
 885   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 886   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 887     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
 888     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 889     if (sig_x > 9999999999999999ull) {
 890       non_canon_x = 1;
 891     } else {
 892       non_canon_x = 0;
 893     }
 894   } else {
 895     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
 896     sig_x = (x & MASK_BINARY_SIG1);
 897     non_canon_x = 0;
 898   }
 899   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
 900   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
 901     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
 902     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
 903     if (sig_y > 9999999999999999ull) {
 904       non_canon_y = 1;
 905     } else {
 906       non_canon_y = 0;
 907     }
 908   } else {
 909     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
 910     sig_y = (y & MASK_BINARY_SIG1);
 911     non_canon_y = 0;
 912   }
 913   // ZERO (CASE4)
 914   // some properties:
 915   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
 916   // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
 917   //     therefore ignore the exponent field
 918   //    (Any non-canonical # is considered 0)
 919   if (non_canon_x || sig_x == 0) {
 920     x_is_zero = 1;
 921   }
 922   if (non_canon_y || sig_y == 0) {
 923     y_is_zero = 1;
 924   }
 925   if (x_is_zero && y_is_zero) {
 926     // if both numbers are zero, they are equal -> return 1
 927     res = 1;
 928     BID_RETURN (res);
 929   } else if (x_is_zero) {
 930     // if x is zero, it is lessthan if Y is positive
 931     res = ((y & MASK_SIGN) != MASK_SIGN);
 932     BID_RETURN (res);
 933   } else if (y_is_zero) {
 934     // if y is zero, X is less if it is negative
 935     res = ((x & MASK_SIGN) == MASK_SIGN);
 936     BID_RETURN (res);
 937   }
 938   // OPPOSITE SIGN (CASE5)
 939   // now, if the sign bits differ, x is less than if y is positive
 940   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
 941     res = ((y & MASK_SIGN) != MASK_SIGN);
 942     BID_RETURN (res);
 943   }
 944   // REDUNDANT REPRESENTATIONS (CASE6)
 945   // if both components are either bigger or smaller
 946   if (sig_x > sig_y && exp_x >= exp_y) {
 947     res = ((x & MASK_SIGN) == MASK_SIGN);
 948     BID_RETURN (res);
 949   }
 950   if (sig_x < sig_y && exp_x <= exp_y) {
 951     res = ((x & MASK_SIGN) != MASK_SIGN);
 952     BID_RETURN (res);
 953   }
 954   // if exp_x is 15 greater than exp_y, no need for compensation
 955   if (exp_x - exp_y > 15) {
 956     res = ((x & MASK_SIGN) == MASK_SIGN);
 957     // difference cannot be greater than 10^15
 958     BID_RETURN (res);
 959   }
 960   // if exp_x is 15 less than exp_y, no need for compensation
 961   if (exp_y - exp_x > 15) {
 962     res = ((x & MASK_SIGN) != MASK_SIGN);
 963     BID_RETURN (res);
 964   }
 965   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
 966   if (exp_x > exp_y) {  // to simplify the loop below,
 967     // otherwise adjust the x significand upwards
 968     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
 969                             mult_factor[exp_x - exp_y]);
 970     // return 1 if values are equal
 971     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
 972       res = 1;
 973       BID_RETURN (res);
 974     }
 975     // if postitive, return whichever significand abs is smaller
 976     //     (converse if negative)
 977     res = (((sig_n_prime.w[1] == 0)
 978             && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
 979                                             MASK_SIGN));
 980     BID_RETURN (res);
 981   }
 982   // adjust the y significand upwards
 983   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
 984                           mult_factor[exp_y - exp_x]);
 985   // return 1 if values are equal
 986   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
 987     res = 1;
 988     BID_RETURN (res);
 989   }
 990   // if positive, return whichever significand abs is smaller
 991   //     (converse if negative)
 992   res = (((sig_n_prime.w[1] > 0)
 993           || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
 994                                             MASK_SIGN));
 995   BID_RETURN (res);
 996 }
 997
 998 #if DECIMAL_CALL_BY_REFERENCE
 999 void
1000 bid64_quiet_less_unordered (int *pres, UINT64 * px,
1001                             UINT64 *
1002                             py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1003                             _EXC_INFO_PARAM) {
1004   UINT64 x = *px;
1005   UINT64 y = *py;
1006 #else
1007 int
1008 bid64_quiet_less_unordered (UINT64 x,
1009                             UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1010                             _EXC_INFO_PARAM) {
1011 #endif
1012   int res;
1013   int exp_x, exp_y;
1014   UINT64 sig_x, sig_y;
1015   UINT128 sig_n_prime;
1016   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
1017
1018   // NaN (CASE1)
1019   // if either number is NAN, the comparison is unordered : return 0
1020   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
1021     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
1022       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
1023     }
1024     res = 1;
1025     BID_RETURN (res);
1026   }
1027   // SIMPLE (CASE2)
1028   // if all the bits are the same, these numbers are equal.
1029   if (x == y) {
1030     res = 0;
1031     BID_RETURN (res);
1032   }
1033   // INFINITY (CASE3)
1034   if ((x & MASK_INF) == MASK_INF) {
1035     // if x==neg_inf, { res = (y == neg_inf)?0:1; BID_RETURN (res) }
1036     if ((x & MASK_SIGN) == MASK_SIGN) {
1037       // x is -inf, so it is less than y unless y is -inf
1038       res = (((y & MASK_INF) != MASK_INF)
1039              || (y & MASK_SIGN) != MASK_SIGN);
1040       BID_RETURN (res);
1041     } else {
1042       // x is pos_inf, no way for it to be less than y
1043       res = 0;
1044       BID_RETURN (res);
1045     }
1046   } else if ((y & MASK_INF) == MASK_INF) {
1047     // x is finite, so:
1048     //    if y is +inf, x<y
1049     //    if y is -inf, x>y
1050     res = ((y & MASK_SIGN) != MASK_SIGN);
1051     BID_RETURN (res);
1052   }
1053   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1054   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1055     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
1056     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1057     if (sig_x > 9999999999999999ull) {
1058       non_canon_x = 1;
1059     } else {
1060       non_canon_x = 0;
1061     }
1062   } else {
1063     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
1064     sig_x = (x & MASK_BINARY_SIG1);
1065     non_canon_x = 0;
1066   }
1067   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1068   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1069     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
1070     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1071     if (sig_y > 9999999999999999ull) {
1072       non_canon_y = 1;
1073     } else {
1074       non_canon_y = 0;
1075     }
1076   } else {
1077     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
1078     sig_y = (y & MASK_BINARY_SIG1);
1079     non_canon_y = 0;
1080   }
1081   // ZERO (CASE4)
1082   // some properties:
1083   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
1084   // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
1085   //     therefore ignore the exponent field
1086   //    (Any non-canonical # is considered 0)
1087   if (non_canon_x || sig_x == 0) {
1088     x_is_zero = 1;
1089   }
1090   if (non_canon_y || sig_y == 0) {
1091     y_is_zero = 1;
1092   }
1093   if (x_is_zero && y_is_zero) {
1094     // if both numbers are zero, they are equal
1095     res = 0;
1096     BID_RETURN (res);
1097   } else if (x_is_zero) {
1098     // if x is zero, it is lessthan if Y is positive
1099     res = ((y & MASK_SIGN) != MASK_SIGN);
1100     BID_RETURN (res);
1101   } else if (y_is_zero) {
1102     // if y is zero, X is less if it is negative
1103     res = ((x & MASK_SIGN) == MASK_SIGN);
1104     BID_RETURN (res);
1105   }
1106   // OPPOSITE SIGN (CASE5)
1107   // now, if the sign bits differ, x is less than if y is positive
1108   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
1109     res = ((y & MASK_SIGN) != MASK_SIGN);
1110     BID_RETURN (res);
1111   }
1112   // REDUNDANT REPRESENTATIONS (CASE6)
1113   // if both components are either bigger or smaller
1114   if (sig_x > sig_y && exp_x >= exp_y) {
1115     res = ((x & MASK_SIGN) == MASK_SIGN);
1116     BID_RETURN (res);
1117   }
1118   if (sig_x < sig_y && exp_x <= exp_y) {
1119     res = ((x & MASK_SIGN) != MASK_SIGN);
1120     BID_RETURN (res);
1121   }
1122   // if exp_x is 15 greater than exp_y, no need for compensation
1123   if (exp_x - exp_y > 15) {
1124     res = ((x & MASK_SIGN) == MASK_SIGN);
1125     // difference cannot be greater than 10^15
1126     BID_RETURN (res);
1127   }
1128   // if exp_x is 15 less than exp_y, no need for compensation
1129   if (exp_y - exp_x > 15) {
1130     res = ((x & MASK_SIGN) != MASK_SIGN);
1131     BID_RETURN (res);
1132   }
1133   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
1134   if (exp_x > exp_y) {  // to simplify the loop below,
1135     // otherwise adjust the x significand upwards
1136     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
1137                             mult_factor[exp_x - exp_y]);
1138     // return 0 if values are equal
1139     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
1140       res = 0;
1141       BID_RETURN (res);
1142     }
1143     // if postitive, return whichever significand abs is smaller
1144     //     (converse if negative)
1145     res = (((sig_n_prime.w[1] == 0)
1146             && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
1147                                             MASK_SIGN));
1148     BID_RETURN (res);
1149   }
1150   // adjust the y significand upwards
1151   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
1152                           mult_factor[exp_y - exp_x]);
1153   // return 0 if values are equal
1154   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
1155     res = 0;
1156     BID_RETURN (res);
1157   }
1158   // if positive, return whichever significand abs is smaller
1159   //     (converse if negative)
1160   res = (((sig_n_prime.w[1] > 0)
1161           || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
1162                                             MASK_SIGN));
1163   BID_RETURN (res);
1164 }
1165
1166 #if DECIMAL_CALL_BY_REFERENCE
1167 void
1168 bid64_quiet_not_equal (int *pres, UINT64 * px,
1169                        UINT64 *
1170                        py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1171                        _EXC_INFO_PARAM) {
1172   UINT64 x = *px;
1173   UINT64 y = *py;
1174 #else
1175 int
1176 bid64_quiet_not_equal (UINT64 x,
1177                        UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1178                        _EXC_INFO_PARAM) {
1179 #endif
1180   int res;
1181   int exp_x, exp_y, exp_t;
1182   UINT64 sig_x, sig_y, sig_t;
1183   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y, lcv;
1184
1185   // NaN (CASE1)
1186   // if either number is NAN, the comparison is unordered,
1187   // rather than equal : return 1
1188   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
1189     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
1190       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
1191     }
1192     res = 1;
1193     BID_RETURN (res);
1194   }
1195   // SIMPLE (CASE2)
1196   // if all the bits are the same, these numbers are equivalent.
1197   if (x == y) {
1198     res = 0;
1199     BID_RETURN (res);
1200   }
1201   // INFINITY (CASE3)
1202   if (((x & MASK_INF) == MASK_INF) && ((y & MASK_INF) == MASK_INF)) {
1203     res = (((x ^ y) & MASK_SIGN) == MASK_SIGN);
1204     BID_RETURN (res);
1205   }
1206   // ONE INFINITY (CASE3')
1207   if (((x & MASK_INF) == MASK_INF) || ((y & MASK_INF) == MASK_INF)) {
1208     res = 1;
1209     BID_RETURN (res);
1210   }
1211   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1212   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1213     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
1214     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1215     if (sig_x > 9999999999999999ull) {
1216       non_canon_x = 1;
1217     } else {
1218       non_canon_x = 0;
1219     }
1220   } else {
1221     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
1222     sig_x = (x & MASK_BINARY_SIG1);
1223     non_canon_x = 0;
1224   }
1225
1226   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1227   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1228     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
1229     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1230     if (sig_y > 9999999999999999ull) {
1231       non_canon_y = 1;
1232     } else {
1233       non_canon_y = 0;
1234     }
1235   } else {
1236     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
1237     sig_y = (y & MASK_BINARY_SIG1);
1238     non_canon_y = 0;
1239   }
1240
1241   // ZERO (CASE4)
1242   // some properties:
1243   // (+ZERO==-ZERO) => therefore ignore the sign
1244   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
1245   //        therefore ignore the exponent field
1246   //    (Any non-canonical # is considered 0)
1247   if (non_canon_x || sig_x == 0) {
1248     x_is_zero = 1;
1249   }
1250   if (non_canon_y || sig_y == 0) {
1251     y_is_zero = 1;
1252   }
1253
1254   if (x_is_zero && y_is_zero) {
1255     res = 0;
1256     BID_RETURN (res);
1257   } else if ((x_is_zero && !y_is_zero) || (!x_is_zero && y_is_zero)) {
1258     res = 1;
1259     BID_RETURN (res);
1260   }
1261   // OPPOSITE SIGN (CASE5)
1262   // now, if the sign bits differ => not equal : return 1
1263   if ((x ^ y) & MASK_SIGN) {
1264     res = 1;
1265     BID_RETURN (res);
1266   }
1267   // REDUNDANT REPRESENTATIONS (CASE6)
1268   if (exp_x > exp_y) {  // to simplify the loop below,
1269     SWAP (exp_x, exp_y, exp_t); // put the larger exp in y,
1270     SWAP (sig_x, sig_y, sig_t); // and the smaller exp in x
1271   }
1272
1273   if (exp_y - exp_x > 15) {
1274     res = 1;
1275     BID_RETURN (res);
1276   }
1277   // difference cannot be greater than 10^16
1278
1279   for (lcv = 0; lcv < (exp_y - exp_x); lcv++) {
1280
1281     // recalculate y's significand upwards
1282     sig_y = sig_y * 10;
1283     if (sig_y > 9999999999999999ull) {
1284       res = 1;
1285       BID_RETURN (res);
1286     }
1287   }
1288
1289   {
1290     res = sig_y != sig_x;
1291     BID_RETURN (res);
1292   }
1293
1294 }
1295
1296 #if DECIMAL_CALL_BY_REFERENCE
1297 void
1298 bid64_quiet_not_greater (int *pres, UINT64 * px,
1299                          UINT64 *
1300                          py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1301                          _EXC_INFO_PARAM) {
1302   UINT64 x = *px;
1303   UINT64 y = *py;
1304 #else
1305 int
1306 bid64_quiet_not_greater (UINT64 x,
1307                          UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1308                          _EXC_INFO_PARAM) {
1309 #endif
1310   int res;
1311   int exp_x, exp_y;
1312   UINT64 sig_x, sig_y;
1313   UINT128 sig_n_prime;
1314   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
1315
1316   // NaN (CASE1)
1317   // if either number is NAN, the comparison is unordered,
1318   //   rather than equal : return 0
1319   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
1320     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
1321       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
1322     }
1323     res = 1;
1324     BID_RETURN (res);
1325   }
1326   // SIMPLE (CASE2)
1327   // if all the bits are the same, these numbers are equal (LESSEQUAL).
1328   if (x == y) {
1329     res = 1;
1330     BID_RETURN (res);
1331   }
1332   // INFINITY (CASE3)
1333   if ((x & MASK_INF) == MASK_INF) {
1334     // if x is neg infinity, it must be lessthan or equal to y return 1
1335     if (((x & MASK_SIGN) == MASK_SIGN)) {
1336       res = 1;
1337       BID_RETURN (res);
1338     }
1339     // x is pos infinity, it is greater, unless y is positive
1340     // infinity => return y==pos_infinity
1341     else {
1342       res = !(((y & MASK_INF) != MASK_INF)
1343               || ((y & MASK_SIGN) == MASK_SIGN));
1344       BID_RETURN (res);
1345     }
1346   } else if ((y & MASK_INF) == MASK_INF) {
1347     // x is finite, so if y is positive infinity, then x is less, return 1
1348     //                 if y is negative infinity, then x is greater, return 0
1349     {
1350       res = ((y & MASK_SIGN) != MASK_SIGN);
1351       BID_RETURN (res);
1352     }
1353   }
1354   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1355   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1356     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
1357     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1358     if (sig_x > 9999999999999999ull) {
1359       non_canon_x = 1;
1360     } else {
1361       non_canon_x = 0;
1362     }
1363   } else {
1364     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
1365     sig_x = (x & MASK_BINARY_SIG1);
1366     non_canon_x = 0;
1367   }
1368
1369   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1370   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1371     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
1372     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1373     if (sig_y > 9999999999999999ull) {
1374       non_canon_y = 1;
1375     } else {
1376       non_canon_y = 0;
1377     }
1378   } else {
1379     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
1380     sig_y = (y & MASK_BINARY_SIG1);
1381     non_canon_y = 0;
1382   }
1383
1384   // ZERO (CASE4)
1385   // some properties:
1386   // (+ZERO==-ZERO) => therefore ignore the sign, and neither
1387   //         number is greater
1388   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
1389   //         therefore ignore the exponent field
1390   //    (Any non-canonical # is considered 0)
1391   if (non_canon_x || sig_x == 0) {
1392     x_is_zero = 1;
1393   }
1394   if (non_canon_y || sig_y == 0) {
1395     y_is_zero = 1;
1396   }
1397   // if both numbers are zero, they are equal -> return 1
1398   if (x_is_zero && y_is_zero) {
1399     res = 1;
1400     BID_RETURN (res);
1401   }
1402   // if x is zero, it is lessthan if Y is positive
1403   else if (x_is_zero) {
1404     res = ((y & MASK_SIGN) != MASK_SIGN);
1405     BID_RETURN (res);
1406   }
1407   // if y is zero, X is less if it is negative
1408   else if (y_is_zero) {
1409     res = ((x & MASK_SIGN) == MASK_SIGN);
1410     BID_RETURN (res);
1411   }
1412   // OPPOSITE SIGN (CASE5)
1413   // now, if the sign bits differ, x is less than if y is positive
1414   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
1415     res = ((y & MASK_SIGN) != MASK_SIGN);
1416     BID_RETURN (res);
1417   }
1418   // REDUNDANT REPRESENTATIONS (CASE6)
1419   // if both components are either bigger or smaller
1420   if (sig_x > sig_y && exp_x >= exp_y) {
1421     res = ((x & MASK_SIGN) == MASK_SIGN);
1422     BID_RETURN (res);
1423   }
1424   if (sig_x < sig_y && exp_x <= exp_y) {
1425     res = ((x & MASK_SIGN) != MASK_SIGN);
1426     BID_RETURN (res);
1427   }
1428   // if exp_x is 15 greater than exp_y, no need for compensation
1429   if (exp_x - exp_y > 15) {
1430     res = ((x & MASK_SIGN) == MASK_SIGN);
1431     BID_RETURN (res);
1432   }
1433   // difference cannot be greater than 10^15
1434
1435   // if exp_x is 15 less than exp_y, no need for compensation
1436   if (exp_y - exp_x > 15) {
1437     res = ((x & MASK_SIGN) != MASK_SIGN);
1438     BID_RETURN (res);
1439   }
1440   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
1441   if (exp_x > exp_y) {  // to simplify the loop below,
1442
1443     // otherwise adjust the x significand upwards
1444     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
1445                             mult_factor[exp_x - exp_y]);
1446
1447     // return 1 if values are equal
1448     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
1449       res = 1;
1450       BID_RETURN (res);
1451     }
1452     // if postitive, return whichever significand abs is smaller
1453     //     (converse if negative)
1454     {
1455       res = (((sig_n_prime.w[1] == 0)
1456               && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
1457                                               MASK_SIGN));
1458       BID_RETURN (res);
1459     }
1460   }
1461   // adjust the y significand upwards
1462   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
1463                           mult_factor[exp_y - exp_x]);
1464
1465   // return 1 if values are equal
1466   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
1467     res = 1;
1468     BID_RETURN (res);
1469   }
1470   // if positive, return whichever significand abs is smaller
1471   //     (converse if negative)
1472   {
1473     res = (((sig_n_prime.w[1] > 0)
1474             || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
1475                                               MASK_SIGN));
1476     BID_RETURN (res);
1477   }
1478 }
1479
1480 #if DECIMAL_CALL_BY_REFERENCE
1481 void
1482 bid64_quiet_not_less (int *pres, UINT64 * px,
1483                       UINT64 *
1484                       py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1485                       _EXC_INFO_PARAM) {
1486   UINT64 x = *px;
1487   UINT64 y = *py;
1488 #else
1489 int
1490 bid64_quiet_not_less (UINT64 x,
1491                       UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1492                       _EXC_INFO_PARAM) {
1493 #endif
1494   int res;
1495   int exp_x, exp_y;
1496   UINT64 sig_x, sig_y;
1497   UINT128 sig_n_prime;
1498   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
1499
1500   // NaN (CASE1)
1501   // if either number is NAN, the comparison is unordered : return 1
1502   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
1503     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
1504       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
1505     }
1506     res = 1;
1507     BID_RETURN (res);
1508   }
1509   // SIMPLE (CASE2)
1510   // if all the bits are the same, these numbers are equal.
1511   if (x == y) {
1512     res = 1;
1513     BID_RETURN (res);
1514   }
1515   // INFINITY (CASE3)
1516   if ((x & MASK_INF) == MASK_INF) {
1517     // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
1518     if ((x & MASK_SIGN) == MASK_SIGN)
1519       // x is -inf, so it is less than y unless y is -inf
1520     {
1521       res = (((y & MASK_INF) == MASK_INF)
1522              && (y & MASK_SIGN) == MASK_SIGN);
1523       BID_RETURN (res);
1524     } else
1525       // x is pos_inf, no way for it to be less than y
1526     {
1527       res = 1;
1528       BID_RETURN (res);
1529     }
1530   } else if ((y & MASK_INF) == MASK_INF) {
1531     // x is finite, so:
1532     //    if y is +inf, x<y
1533     //    if y is -inf, x>y
1534     {
1535       res = ((y & MASK_SIGN) == MASK_SIGN);
1536       BID_RETURN (res);
1537     }
1538   }
1539   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1540   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1541     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
1542     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1543     if (sig_x > 9999999999999999ull) {
1544       non_canon_x = 1;
1545     } else {
1546       non_canon_x = 0;
1547     }
1548   } else {
1549     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
1550     sig_x = (x & MASK_BINARY_SIG1);
1551     non_canon_x = 0;
1552   }
1553
1554   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1555   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1556     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
1557     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1558     if (sig_y > 9999999999999999ull) {
1559       non_canon_y = 1;
1560     } else {
1561       non_canon_y = 0;
1562     }
1563   } else {
1564     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
1565     sig_y = (y & MASK_BINARY_SIG1);
1566     non_canon_y = 0;
1567   }
1568
1569   // ZERO (CASE4)
1570   // some properties:
1571   // (+ZERO==-ZERO) => therefore ignore the sign, and neither
1572   //        number is greater
1573   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
1574   //        therefore ignore the exponent field
1575   //    (Any non-canonical # is considered 0)
1576   if (non_canon_x || sig_x == 0) {
1577     x_is_zero = 1;
1578   }
1579   if (non_canon_y || sig_y == 0) {
1580     y_is_zero = 1;
1581   }
1582   // if both numbers are zero, they are equal
1583   if (x_is_zero && y_is_zero) {
1584     res = 1;
1585     BID_RETURN (res);
1586   }
1587   // if x is zero, it is lessthan if Y is positive
1588   else if (x_is_zero) {
1589     res = ((y & MASK_SIGN) == MASK_SIGN);
1590     BID_RETURN (res);
1591   }
1592   // if y is zero, X is less if it is negative
1593   else if (y_is_zero) {
1594     res = ((x & MASK_SIGN) != MASK_SIGN);
1595     BID_RETURN (res);
1596   }
1597   // OPPOSITE SIGN (CASE5)
1598   // now, if the sign bits differ, x is less than if y is positive
1599   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
1600     res = ((y & MASK_SIGN) == MASK_SIGN);
1601     BID_RETURN (res);
1602   }
1603   // REDUNDANT REPRESENTATIONS (CASE6)
1604   // if both components are either bigger or smaller
1605   if (sig_x > sig_y && exp_x >= exp_y) {
1606     res = ((x & MASK_SIGN) != MASK_SIGN);
1607     BID_RETURN (res);
1608   }
1609   if (sig_x < sig_y && exp_x <= exp_y) {
1610     res = ((x & MASK_SIGN) == MASK_SIGN);
1611     BID_RETURN (res);
1612   }
1613   // if exp_x is 15 greater than exp_y, no need for compensation
1614   if (exp_x - exp_y > 15) {
1615     res = ((x & MASK_SIGN) != MASK_SIGN);
1616     BID_RETURN (res);
1617   }
1618   // difference cannot be greater than 10^15
1619
1620   // if exp_x is 15 less than exp_y, no need for compensation
1621   if (exp_y - exp_x > 15) {
1622     res = ((x & MASK_SIGN) == MASK_SIGN);
1623     BID_RETURN (res);
1624   }
1625   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
1626   if (exp_x > exp_y) {  // to simplify the loop below,
1627
1628     // otherwise adjust the x significand upwards
1629     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
1630                             mult_factor[exp_x - exp_y]);
1631
1632     // return 0 if values are equal
1633     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
1634       res = 1;
1635       BID_RETURN (res);
1636     }
1637     // if postitive, return whichever significand abs is smaller
1638     //     (converse if negative)
1639     {
1640       res = (((sig_n_prime.w[1] == 0)
1641               && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) !=
1642                                               MASK_SIGN));
1643       BID_RETURN (res);
1644     }
1645   }
1646   // adjust the y significand upwards
1647   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
1648                           mult_factor[exp_y - exp_x]);
1649
1650   // return 0 if values are equal
1651   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
1652     res = 1;
1653     BID_RETURN (res);
1654   }
1655   // if positive, return whichever significand abs is smaller
1656   //     (converse if negative)
1657   {
1658     res = (((sig_n_prime.w[1] > 0)
1659             || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) !=
1660                                               MASK_SIGN));
1661     BID_RETURN (res);
1662   }
1663 }
1664
1665 #if DECIMAL_CALL_BY_REFERENCE
1666 void
1667 bid64_quiet_ordered (int *pres, UINT64 * px,
1668                      UINT64 *
1669                      py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1670                      _EXC_INFO_PARAM) {
1671   UINT64 x = *px;
1672   UINT64 y = *py;
1673 #else
1674 int
1675 bid64_quiet_ordered (UINT64 x,
1676                      UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1677                      _EXC_INFO_PARAM) {
1678 #endif
1679   int res;
1680
1681   // NaN (CASE1)
1682   // if either number is NAN, the comparison is ordered, rather than equal : return 0
1683   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
1684     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
1685       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
1686     }
1687     res = 0;
1688     BID_RETURN (res);
1689   } else {
1690     res = 1;
1691     BID_RETURN (res);
1692   }
1693 }
1694
1695 #if DECIMAL_CALL_BY_REFERENCE
1696 void
1697 bid64_quiet_unordered (int *pres, UINT64 * px,
1698                        UINT64 *
1699                        py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1700                        _EXC_INFO_PARAM) {
1701   UINT64 x = *px;
1702   UINT64 y = *py;
1703 #else
1704 int
1705 bid64_quiet_unordered (UINT64 x,
1706                        UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1707                        _EXC_INFO_PARAM) {
1708 #endif
1709   int res;
1710
1711   // NaN (CASE1)
1712   // if either number is NAN, the comparison is unordered,
1713   //     rather than equal : return 0
1714   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
1715     if ((x & MASK_SNAN) == MASK_SNAN || (y & MASK_SNAN) == MASK_SNAN) {
1716       *pfpsf |= INVALID_EXCEPTION;      // set exception if sNaN
1717     }
1718     res = 1;
1719     BID_RETURN (res);
1720   } else {
1721     res = 0;
1722     BID_RETURN (res);
1723   }
1724 }
1725
1726 #if DECIMAL_CALL_BY_REFERENCE
1727 void
1728 bid64_signaling_greater (int *pres, UINT64 * px,
1729                          UINT64 *
1730                          py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1731                          _EXC_INFO_PARAM) {
1732   UINT64 x = *px;
1733   UINT64 y = *py;
1734 #else
1735 int
1736 bid64_signaling_greater (UINT64 x,
1737                          UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1738                          _EXC_INFO_PARAM) {
1739 #endif
1740   int res;
1741   int exp_x, exp_y;
1742   UINT64 sig_x, sig_y;
1743   UINT128 sig_n_prime;
1744   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
1745
1746   // NaN (CASE1)
1747   // if either number is NAN, the comparison is unordered,
1748   //     rather than equal : return 0
1749   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
1750     *pfpsf |= INVALID_EXCEPTION;        // set invalid exception if NaN
1751     res = 0;
1752     BID_RETURN (res);
1753   }
1754   // SIMPLE (CASE2)
1755   // if all the bits are the same, these numbers are equal (not Greater).
1756   if (x == y) {
1757     res = 0;
1758     BID_RETURN (res);
1759   }
1760   // INFINITY (CASE3)
1761   if ((x & MASK_INF) == MASK_INF) {
1762     // if x is neg infinity, there is no way it is greater than y, return 0
1763     if (((x & MASK_SIGN) == MASK_SIGN)) {
1764       res = 0;
1765       BID_RETURN (res);
1766     }
1767     // x is pos infinity, it is greater,
1768     // unless y is positive infinity => return y!=pos_infinity
1769     else {
1770       res = (((y & MASK_INF) != MASK_INF)
1771              || ((y & MASK_SIGN) == MASK_SIGN));
1772       BID_RETURN (res);
1773     }
1774   } else if ((y & MASK_INF) == MASK_INF) {
1775     // x is finite, so if y is positive infinity, then x is less, return 0
1776     //                 if y is negative infinity, then x is greater, return 1
1777     {
1778       res = ((y & MASK_SIGN) == MASK_SIGN);
1779       BID_RETURN (res);
1780     }
1781   }
1782   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1783   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1784     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
1785     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1786     if (sig_x > 9999999999999999ull) {
1787       non_canon_x = 1;
1788     } else {
1789       non_canon_x = 0;
1790     }
1791   } else {
1792     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
1793     sig_x = (x & MASK_BINARY_SIG1);
1794     non_canon_x = 0;
1795   }
1796
1797   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1798   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1799     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
1800     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1801     if (sig_y > 9999999999999999ull) {
1802       non_canon_y = 1;
1803     } else {
1804       non_canon_y = 0;
1805     }
1806   } else {
1807     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
1808     sig_y = (y & MASK_BINARY_SIG1);
1809     non_canon_y = 0;
1810   }
1811
1812   // ZERO (CASE4)
1813   // some properties:
1814   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
1815   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
1816   //      therefore ignore the exponent field
1817   //    (Any non-canonical # is considered 0)
1818   if (non_canon_x || sig_x == 0) {
1819     x_is_zero = 1;
1820   }
1821   if (non_canon_y || sig_y == 0) {
1822     y_is_zero = 1;
1823   }
1824   // if both numbers are zero, neither is greater => return NOTGREATERTHAN
1825   if (x_is_zero && y_is_zero) {
1826     res = 0;
1827     BID_RETURN (res);
1828   }
1829   // is x is zero, it is greater if Y is negative
1830   else if (x_is_zero) {
1831     res = ((y & MASK_SIGN) == MASK_SIGN);
1832     BID_RETURN (res);
1833   }
1834   // is y is zero, X is greater if it is positive
1835   else if (y_is_zero) {
1836     res = ((x & MASK_SIGN) != MASK_SIGN);
1837     BID_RETURN (res);
1838   }
1839   // OPPOSITE SIGN (CASE5)
1840   // now, if the sign bits differ, x is greater if y is negative
1841   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
1842     res = ((y & MASK_SIGN) == MASK_SIGN);
1843     BID_RETURN (res);
1844   }
1845   // REDUNDANT REPRESENTATIONS (CASE6)
1846
1847   // if both components are either bigger or smaller
1848   if (sig_x > sig_y && exp_x >= exp_y) {
1849     res = ((x & MASK_SIGN) != MASK_SIGN);
1850     BID_RETURN (res);
1851   }
1852   if (sig_x < sig_y && exp_x <= exp_y) {
1853     res = ((x & MASK_SIGN) == MASK_SIGN);
1854     BID_RETURN (res);
1855   }
1856   // if exp_x is 15 greater than exp_y, no need for compensation
1857   if (exp_x - exp_y > 15) {
1858     res = ((x & MASK_SIGN) != MASK_SIGN);
1859     BID_RETURN (res);
1860   }
1861   // difference cannot be greater than 10^15
1862
1863   // if exp_x is 15 less than exp_y, no need for compensation
1864   if (exp_y - exp_x > 15) {
1865     res = ((x & MASK_SIGN) == MASK_SIGN);
1866     BID_RETURN (res);
1867   }
1868   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
1869   if (exp_x > exp_y) {  // to simplify the loop below,
1870
1871     // otherwise adjust the x significand upwards
1872     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
1873                             mult_factor[exp_x - exp_y]);
1874
1875
1876     // if postitive, return whichever significand is larger
1877     //     (converse if negative)
1878     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
1879       res = 0;
1880       BID_RETURN (res);
1881     }
1882
1883     {
1884       res = (((sig_n_prime.w[1] > 0)
1885               || sig_n_prime.w[0] > sig_y) ^ ((x & MASK_SIGN) ==
1886                                               MASK_SIGN));
1887       BID_RETURN (res);
1888     }
1889   }
1890   // adjust the y significand upwards
1891   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
1892                           mult_factor[exp_y - exp_x]);
1893
1894   // if postitive, return whichever significand is larger
1895   //     (converse if negative)
1896   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
1897     res = 0;
1898     BID_RETURN (res);
1899   }
1900   {
1901     res = (((sig_n_prime.w[1] == 0)
1902             && (sig_x > sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
1903                                               MASK_SIGN));
1904     BID_RETURN (res);
1905   }
1906 }
1907
1908 #if DECIMAL_CALL_BY_REFERENCE
1909 void
1910 bid64_signaling_greater_equal (int *pres, UINT64 * px,
1911                                UINT64 *
1912                                py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
1913                                _EXC_INFO_PARAM) {
1914   UINT64 x = *px;
1915   UINT64 y = *py;
1916 #else
1917 int
1918 bid64_signaling_greater_equal (UINT64 x,
1919                                UINT64 y _EXC_FLAGS_PARAM
1920                                _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
1921 #endif
1922   int res;
1923   int exp_x, exp_y;
1924   UINT64 sig_x, sig_y;
1925   UINT128 sig_n_prime;
1926   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
1927
1928   // NaN (CASE1)
1929   // if either number is NAN, the comparison is unordered : return 1
1930   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
1931     *pfpsf |= INVALID_EXCEPTION;        // set invalid exception if NaN
1932     res = 0;
1933     BID_RETURN (res);
1934   }
1935   // SIMPLE (CASE2)
1936   // if all the bits are the same, these numbers are equal.
1937   if (x == y) {
1938     res = 1;
1939     BID_RETURN (res);
1940   }
1941   // INFINITY (CASE3)
1942   if ((x & MASK_INF) == MASK_INF) {
1943     // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
1944     if ((x & MASK_SIGN) == MASK_SIGN)
1945       // x is -inf, so it is less than y unless y is -inf
1946     {
1947       res = (((y & MASK_INF) == MASK_INF)
1948              && (y & MASK_SIGN) == MASK_SIGN);
1949       BID_RETURN (res);
1950     } else
1951       // x is pos_inf, no way for it to be less than y
1952     {
1953       res = 1;
1954       BID_RETURN (res);
1955     }
1956   } else if ((y & MASK_INF) == MASK_INF) {
1957     // x is finite, so:
1958     //    if y is +inf, x<y
1959     //    if y is -inf, x>y
1960     {
1961       res = ((y & MASK_SIGN) == MASK_SIGN);
1962       BID_RETURN (res);
1963     }
1964   }
1965   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1966   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1967     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
1968     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1969     if (sig_x > 9999999999999999ull) {
1970       non_canon_x = 1;
1971     } else {
1972       non_canon_x = 0;
1973     }
1974   } else {
1975     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
1976     sig_x = (x & MASK_BINARY_SIG1);
1977     non_canon_x = 0;
1978   }
1979
1980   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
1981   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
1982     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
1983     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
1984     if (sig_y > 9999999999999999ull) {
1985       non_canon_y = 1;
1986     } else {
1987       non_canon_y = 0;
1988     }
1989   } else {
1990     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
1991     sig_y = (y & MASK_BINARY_SIG1);
1992     non_canon_y = 0;
1993   }
1994
1995   // ZERO (CASE4)
1996   // some properties:
1997   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
1998   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
1999   //      therefore ignore the exponent field
2000   //    (Any non-canonical # is considered 0)
2001   if (non_canon_x || sig_x == 0) {
2002     x_is_zero = 1;
2003   }
2004   if (non_canon_y || sig_y == 0) {
2005     y_is_zero = 1;
2006   }
2007   // if both numbers are zero, they are equal
2008   if (x_is_zero && y_is_zero) {
2009     res = 1;
2010     BID_RETURN (res);
2011   }
2012   // if x is zero, it is lessthan if Y is positive
2013   else if (x_is_zero) {
2014     res = ((y & MASK_SIGN) == MASK_SIGN);
2015     BID_RETURN (res);
2016   }
2017   // if y is zero, X is less if it is negative
2018   else if (y_is_zero) {
2019     res = ((x & MASK_SIGN) != MASK_SIGN);
2020     BID_RETURN (res);
2021   }
2022   // OPPOSITE SIGN (CASE5)
2023   // now, if the sign bits differ, x is less than if y is positive
2024   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
2025     res = ((y & MASK_SIGN) == MASK_SIGN);
2026     BID_RETURN (res);
2027   }
2028   // REDUNDANT REPRESENTATIONS (CASE6)
2029   // if both components are either bigger or smaller
2030   if (sig_x > sig_y && exp_x >= exp_y) {
2031     res = ((x & MASK_SIGN) != MASK_SIGN);
2032     BID_RETURN (res);
2033   }
2034   if (sig_x < sig_y && exp_x <= exp_y) {
2035     res = ((x & MASK_SIGN) == MASK_SIGN);
2036     BID_RETURN (res);
2037   }
2038   // if exp_x is 15 greater than exp_y, no need for compensation
2039   if (exp_x - exp_y > 15) {
2040     res = ((x & MASK_SIGN) != MASK_SIGN);
2041     BID_RETURN (res);
2042   }
2043   // difference cannot be greater than 10^15
2044
2045   // if exp_x is 15 less than exp_y, no need for compensation
2046   if (exp_y - exp_x > 15) {
2047     res = ((x & MASK_SIGN) == MASK_SIGN);
2048     BID_RETURN (res);
2049   }
2050   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
2051   if (exp_x > exp_y) {  // to simplify the loop below,
2052
2053     // otherwise adjust the x significand upwards
2054     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
2055                             mult_factor[exp_x - exp_y]);
2056
2057     // return 1 if values are equal
2058     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
2059       res = 1;
2060       BID_RETURN (res);
2061     }
2062     // if postitive, return whichever significand abs is smaller
2063     //     (converse if negative)
2064     {
2065       res = (((sig_n_prime.w[1] == 0)
2066               && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) !=
2067                                               MASK_SIGN));
2068       BID_RETURN (res);
2069     }
2070   }
2071   // adjust the y significand upwards
2072   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
2073                           mult_factor[exp_y - exp_x]);
2074
2075   // return 0 if values are equal
2076   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
2077     res = 1;
2078     BID_RETURN (res);
2079   }
2080   // if positive, return whichever significand abs is smaller
2081   //     (converse if negative)
2082   {
2083     res = (((sig_n_prime.w[1] > 0)
2084             || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) !=
2085                                               MASK_SIGN));
2086     BID_RETURN (res);
2087   }
2088 }
2089
2090 #if DECIMAL_CALL_BY_REFERENCE
2091 void
2092 bid64_signaling_greater_unordered (int *pres, UINT64 * px,
2093                                    UINT64 *
2094                                    py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
2095                                    _EXC_INFO_PARAM) {
2096   UINT64 x = *px;
2097   UINT64 y = *py;
2098 #else
2099 int
2100 bid64_signaling_greater_unordered (UINT64 x,
2101                                    UINT64 y _EXC_FLAGS_PARAM
2102                                    _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
2103 #endif
2104   int res;
2105   int exp_x, exp_y;
2106   UINT64 sig_x, sig_y;
2107   UINT128 sig_n_prime;
2108   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
2109
2110   // NaN (CASE1)
2111   // if either number is NAN, the comparison is unordered,
2112   // rather than equal : return 0
2113   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
2114     *pfpsf |= INVALID_EXCEPTION;        // set invalid exception if NaN
2115     res = 1;
2116     BID_RETURN (res);
2117   }
2118   // SIMPLE (CASE2)
2119   // if all the bits are the same, these numbers are equal (not Greater).
2120   if (x == y) {
2121     res = 0;
2122     BID_RETURN (res);
2123   }
2124   // INFINITY (CASE3)
2125   if ((x & MASK_INF) == MASK_INF) {
2126     // if x is neg infinity, there is no way it is greater than y, return 0
2127     if (((x & MASK_SIGN) == MASK_SIGN)) {
2128       res = 0;
2129       BID_RETURN (res);
2130     }
2131     // x is pos infinity, it is greater,
2132     // unless y is positive infinity => return y!=pos_infinity
2133     else {
2134       res = (((y & MASK_INF) != MASK_INF)
2135              || ((y & MASK_SIGN) == MASK_SIGN));
2136       BID_RETURN (res);
2137     }
2138   } else if ((y & MASK_INF) == MASK_INF) {
2139     // x is finite, so if y is positive infinity, then x is less, return 0
2140     //                 if y is negative infinity, then x is greater, return 1
2141     {
2142       res = ((y & MASK_SIGN) == MASK_SIGN);
2143       BID_RETURN (res);
2144     }
2145   }
2146   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
2147   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
2148     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
2149     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
2150     if (sig_x > 9999999999999999ull) {
2151       non_canon_x = 1;
2152     } else {
2153       non_canon_x = 0;
2154     }
2155   } else {
2156     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
2157     sig_x = (x & MASK_BINARY_SIG1);
2158     non_canon_x = 0;
2159   }
2160
2161   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
2162   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
2163     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
2164     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
2165     if (sig_y > 9999999999999999ull) {
2166       non_canon_y = 1;
2167     } else {
2168       non_canon_y = 0;
2169     }
2170   } else {
2171     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
2172     sig_y = (y & MASK_BINARY_SIG1);
2173     non_canon_y = 0;
2174   }
2175
2176   // ZERO (CASE4)
2177   // some properties:
2178   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
2179   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
2180   //      therefore ignore the exponent field
2181   //    (Any non-canonical # is considered 0)
2182   if (non_canon_x || sig_x == 0) {
2183     x_is_zero = 1;
2184   }
2185   if (non_canon_y || sig_y == 0) {
2186     y_is_zero = 1;
2187   }
2188   // if both numbers are zero, neither is greater => return NOTGREATERTHAN
2189   if (x_is_zero && y_is_zero) {
2190     res = 0;
2191     BID_RETURN (res);
2192   }
2193   // is x is zero, it is greater if Y is negative
2194   else if (x_is_zero) {
2195     res = ((y & MASK_SIGN) == MASK_SIGN);
2196     BID_RETURN (res);
2197   }
2198   // is y is zero, X is greater if it is positive
2199   else if (y_is_zero) {
2200     res = ((x & MASK_SIGN) != MASK_SIGN);
2201     BID_RETURN (res);
2202   }
2203   // OPPOSITE SIGN (CASE5)
2204   // now, if the sign bits differ, x is greater if y is negative
2205   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
2206     res = ((y & MASK_SIGN) == MASK_SIGN);
2207     BID_RETURN (res);
2208   }
2209   // REDUNDANT REPRESENTATIONS (CASE6)
2210
2211   // if both components are either bigger or smaller
2212   if (sig_x > sig_y && exp_x >= exp_y) {
2213     res = ((x & MASK_SIGN) != MASK_SIGN);
2214     BID_RETURN (res);
2215   }
2216   if (sig_x < sig_y && exp_x <= exp_y) {
2217     res = ((x & MASK_SIGN) == MASK_SIGN);
2218     BID_RETURN (res);
2219   }
2220   // if exp_x is 15 greater than exp_y, no need for compensation
2221   if (exp_x - exp_y > 15) {
2222     res = ((x & MASK_SIGN) != MASK_SIGN);
2223     BID_RETURN (res);
2224   }
2225   // difference cannot be greater than 10^15
2226
2227   // if exp_x is 15 less than exp_y, no need for compensation
2228   if (exp_y - exp_x > 15) {
2229     res = ((x & MASK_SIGN) == MASK_SIGN);
2230     BID_RETURN (res);
2231   }
2232   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
2233   if (exp_x > exp_y) {  // to simplify the loop below,
2234
2235     // otherwise adjust the x significand upwards
2236     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
2237                             mult_factor[exp_x - exp_y]);
2238
2239     // if postitive, return whichever significand is larger
2240     //     (converse if negative)
2241     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
2242       res = 0;
2243       BID_RETURN (res);
2244     }
2245
2246     {
2247       res = (((sig_n_prime.w[1] > 0)
2248               || sig_n_prime.w[0] > sig_y) ^ ((x & MASK_SIGN) ==
2249                                               MASK_SIGN));
2250       BID_RETURN (res);
2251     }
2252   }
2253   // adjust the y significand upwards
2254   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
2255                           mult_factor[exp_y - exp_x]);
2256
2257   // if postitive, return whichever significand is larger
2258   //     (converse if negative)
2259   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
2260     res = 0;
2261     BID_RETURN (res);
2262   }
2263   {
2264     res = (((sig_n_prime.w[1] == 0)
2265             && (sig_x > sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
2266                                               MASK_SIGN));
2267     BID_RETURN (res);
2268   }
2269 }
2270
2271 #if DECIMAL_CALL_BY_REFERENCE
2272 void
2273 bid64_signaling_less (int *pres, UINT64 * px,
2274                       UINT64 *
2275                       py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
2276                       _EXC_INFO_PARAM) {
2277   UINT64 x = *px;
2278   UINT64 y = *py;
2279 #else
2280 int
2281 bid64_signaling_less (UINT64 x,
2282                       UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
2283                       _EXC_INFO_PARAM) {
2284 #endif
2285   int res;
2286   int exp_x, exp_y;
2287   UINT64 sig_x, sig_y;
2288   UINT128 sig_n_prime;
2289   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
2290
2291   // NaN (CASE1)
2292   // if either number is NAN, the comparison is unordered : return 0
2293   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
2294     *pfpsf |= INVALID_EXCEPTION;        // set invalid exception if NaN
2295     res = 0;
2296     BID_RETURN (res);
2297   }
2298   // SIMPLE (CASE2)
2299   // if all the bits are the same, these numbers are equal.
2300   if (x == y) {
2301     res = 0;
2302     BID_RETURN (res);
2303   }
2304   // INFINITY (CASE3)
2305   if ((x & MASK_INF) == MASK_INF) {
2306     // if x==neg_inf, { res = (y == neg_inf)?0:1; BID_RETURN (res) }
2307     if ((x & MASK_SIGN) == MASK_SIGN)
2308       // x is -inf, so it is less than y unless y is -inf
2309     {
2310       res = (((y & MASK_INF) != MASK_INF)
2311              || (y & MASK_SIGN) != MASK_SIGN);
2312       BID_RETURN (res);
2313     } else
2314       // x is pos_inf, no way for it to be less than y
2315     {
2316       res = 0;
2317       BID_RETURN (res);
2318     }
2319   } else if ((y & MASK_INF) == MASK_INF) {
2320     // x is finite, so:
2321     //    if y is +inf, x<y
2322     //    if y is -inf, x>y
2323     {
2324       res = ((y & MASK_SIGN) != MASK_SIGN);
2325       BID_RETURN (res);
2326     }
2327   }
2328   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
2329   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
2330     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
2331     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
2332     if (sig_x > 9999999999999999ull) {
2333       non_canon_x = 1;
2334     } else {
2335       non_canon_x = 0;
2336     }
2337   } else {
2338     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
2339     sig_x = (x & MASK_BINARY_SIG1);
2340     non_canon_x = 0;
2341   }
2342
2343   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
2344   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
2345     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
2346     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
2347     if (sig_y > 9999999999999999ull) {
2348       non_canon_y = 1;
2349     } else {
2350       non_canon_y = 0;
2351     }
2352   } else {
2353     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
2354     sig_y = (y & MASK_BINARY_SIG1);
2355     non_canon_y = 0;
2356   }
2357
2358   // ZERO (CASE4)
2359   // some properties:
2360   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
2361   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
2362   //      therefore ignore the exponent field
2363   //    (Any non-canonical # is considered 0)
2364   if (non_canon_x || sig_x == 0) {
2365     x_is_zero = 1;
2366   }
2367   if (non_canon_y || sig_y == 0) {
2368     y_is_zero = 1;
2369   }
2370   // if both numbers are zero, they are equal
2371   if (x_is_zero && y_is_zero) {
2372     res = 0;
2373     BID_RETURN (res);
2374   }
2375   // if x is zero, it is lessthan if Y is positive
2376   else if (x_is_zero) {
2377     res = ((y & MASK_SIGN) != MASK_SIGN);
2378     BID_RETURN (res);
2379   }
2380   // if y is zero, X is less if it is negative
2381   else if (y_is_zero) {
2382     res = ((x & MASK_SIGN) == MASK_SIGN);
2383     BID_RETURN (res);
2384   }
2385   // OPPOSITE SIGN (CASE5)
2386   // now, if the sign bits differ, x is less than if y is positive
2387   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
2388     res = ((y & MASK_SIGN) != MASK_SIGN);
2389     BID_RETURN (res);
2390   }
2391   // REDUNDANT REPRESENTATIONS (CASE6)
2392   // if both components are either bigger or smaller
2393   if (sig_x > sig_y && exp_x >= exp_y) {
2394     res = ((x & MASK_SIGN) == MASK_SIGN);
2395     BID_RETURN (res);
2396   }
2397   if (sig_x < sig_y && exp_x <= exp_y) {
2398     res = ((x & MASK_SIGN) != MASK_SIGN);
2399     BID_RETURN (res);
2400   }
2401   // if exp_x is 15 greater than exp_y, no need for compensation
2402   if (exp_x - exp_y > 15) {
2403     res = ((x & MASK_SIGN) == MASK_SIGN);
2404     BID_RETURN (res);
2405   }
2406   // difference cannot be greater than 10^15
2407
2408   // if exp_x is 15 less than exp_y, no need for compensation
2409   if (exp_y - exp_x > 15) {
2410     res = ((x & MASK_SIGN) != MASK_SIGN);
2411     BID_RETURN (res);
2412   }
2413   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
2414   if (exp_x > exp_y) {  // to simplify the loop below,
2415
2416     // otherwise adjust the x significand upwards
2417     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
2418                             mult_factor[exp_x - exp_y]);
2419
2420     // return 0 if values are equal
2421     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
2422       res = 0;
2423       BID_RETURN (res);
2424     }
2425     // if postitive, return whichever significand abs is smaller
2426     //     (converse if negative)
2427     {
2428       res = (((sig_n_prime.w[1] == 0)
2429               && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
2430                                               MASK_SIGN));
2431       BID_RETURN (res);
2432     }
2433   }
2434   // adjust the y significand upwards
2435   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
2436                           mult_factor[exp_y - exp_x]);
2437
2438   // return 0 if values are equal
2439   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
2440     res = 0;
2441     BID_RETURN (res);
2442   }
2443   // if positive, return whichever significand abs is smaller
2444   //     (converse if negative)
2445   {
2446     res = (((sig_n_prime.w[1] > 0)
2447             || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
2448                                               MASK_SIGN));
2449     BID_RETURN (res);
2450   }
2451 }
2452
2453 #if DECIMAL_CALL_BY_REFERENCE
2454 void
2455 bid64_signaling_less_equal (int *pres, UINT64 * px,
2456                             UINT64 *
2457                             py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
2458                             _EXC_INFO_PARAM) {
2459   UINT64 x = *px;
2460   UINT64 y = *py;
2461 #else
2462 int
2463 bid64_signaling_less_equal (UINT64 x,
2464                             UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
2465                             _EXC_INFO_PARAM) {
2466 #endif
2467   int res;
2468   int exp_x, exp_y;
2469   UINT64 sig_x, sig_y;
2470   UINT128 sig_n_prime;
2471   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
2472
2473   // NaN (CASE1)
2474   // if either number is NAN, the comparison is unordered,
2475   // rather than equal : return 0
2476   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
2477     *pfpsf |= INVALID_EXCEPTION;        // set invalid exception if NaN
2478     res = 0;
2479     BID_RETURN (res);
2480   }
2481   // SIMPLE (CASE2)
2482   // if all the bits are the same, these numbers are equal (LESSEQUAL).
2483   if (x == y) {
2484     res = 1;
2485     BID_RETURN (res);
2486   }
2487   // INFINITY (CASE3)
2488   if ((x & MASK_INF) == MASK_INF) {
2489     // if x is neg infinity, it must be lessthan or equal to y return 1
2490     if (((x & MASK_SIGN) == MASK_SIGN)) {
2491       res = 1;
2492       BID_RETURN (res);
2493     }
2494     // x is pos infinity, it is greater,
2495     // unless y is positive infinity => return y==pos_infinity
2496     else {
2497       res = !(((y & MASK_INF) != MASK_INF)
2498               || ((y & MASK_SIGN) == MASK_SIGN));
2499       BID_RETURN (res);
2500     }
2501   } else if ((y & MASK_INF) == MASK_INF) {
2502     // x is finite, so if y is positive infinity, then x is less, return 1
2503     //                 if y is negative infinity, then x is greater, return 0
2504     {
2505       res = ((y & MASK_SIGN) != MASK_SIGN);
2506       BID_RETURN (res);
2507     }
2508   }
2509   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
2510   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
2511     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
2512     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
2513     if (sig_x > 9999999999999999ull) {
2514       non_canon_x = 1;
2515     } else {
2516       non_canon_x = 0;
2517     }
2518   } else {
2519     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
2520     sig_x = (x & MASK_BINARY_SIG1);
2521     non_canon_x = 0;
2522   }
2523
2524   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
2525   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
2526     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
2527     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
2528     if (sig_y > 9999999999999999ull) {
2529       non_canon_y = 1;
2530     } else {
2531       non_canon_y = 0;
2532     }
2533   } else {
2534     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
2535     sig_y = (y & MASK_BINARY_SIG1);
2536     non_canon_y = 0;
2537   }
2538
2539   // ZERO (CASE4)
2540   // some properties:
2541   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
2542   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
2543   //      therefore ignore the exponent field
2544   //    (Any non-canonical # is considered 0)
2545   if (non_canon_x || sig_x == 0) {
2546     x_is_zero = 1;
2547   }
2548   if (non_canon_y || sig_y == 0) {
2549     y_is_zero = 1;
2550   }
2551   // if both numbers are zero, they are equal -> return 1
2552   if (x_is_zero && y_is_zero) {
2553     res = 1;
2554     BID_RETURN (res);
2555   }
2556   // if x is zero, it is lessthan if Y is positive
2557   else if (x_is_zero) {
2558     res = ((y & MASK_SIGN) != MASK_SIGN);
2559     BID_RETURN (res);
2560   }
2561   // if y is zero, X is less if it is negative
2562   else if (y_is_zero) {
2563     res = ((x & MASK_SIGN) == MASK_SIGN);
2564     BID_RETURN (res);
2565   }
2566   // OPPOSITE SIGN (CASE5)
2567   // now, if the sign bits differ, x is less than if y is positive
2568   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
2569     res = ((y & MASK_SIGN) != MASK_SIGN);
2570     BID_RETURN (res);
2571   }
2572   // REDUNDANT REPRESENTATIONS (CASE6)
2573   // if both components are either bigger or smaller
2574   if (sig_x > sig_y && exp_x >= exp_y) {
2575     res = ((x & MASK_SIGN) == MASK_SIGN);
2576     BID_RETURN (res);
2577   }
2578   if (sig_x < sig_y && exp_x <= exp_y) {
2579     res = ((x & MASK_SIGN) != MASK_SIGN);
2580     BID_RETURN (res);
2581   }
2582   // if exp_x is 15 greater than exp_y, no need for compensation
2583   if (exp_x - exp_y > 15) {
2584     res = ((x & MASK_SIGN) == MASK_SIGN);
2585     BID_RETURN (res);
2586   }
2587   // difference cannot be greater than 10^15
2588
2589   // if exp_x is 15 less than exp_y, no need for compensation
2590   if (exp_y - exp_x > 15) {
2591     res = ((x & MASK_SIGN) != MASK_SIGN);
2592     BID_RETURN (res);
2593   }
2594   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
2595   if (exp_x > exp_y) {  // to simplify the loop below,
2596
2597     // otherwise adjust the x significand upwards
2598     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
2599                             mult_factor[exp_x - exp_y]);
2600
2601     // return 1 if values are equal
2602     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
2603       res = 1;
2604       BID_RETURN (res);
2605     }
2606     // if postitive, return whichever significand abs is smaller
2607     //     (converse if negative)
2608     {
2609       res = (((sig_n_prime.w[1] == 0)
2610               && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
2611                                               MASK_SIGN));
2612       BID_RETURN (res);
2613     }
2614   }
2615   // adjust the y significand upwards
2616   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
2617                           mult_factor[exp_y - exp_x]);
2618
2619   // return 1 if values are equal
2620   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
2621     res = 1;
2622     BID_RETURN (res);
2623   }
2624   // if positive, return whichever significand abs is smaller
2625   //     (converse if negative)
2626   {
2627     res = (((sig_n_prime.w[1] > 0)
2628             || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
2629                                               MASK_SIGN));
2630     BID_RETURN (res);
2631   }
2632 }
2633
2634 #if DECIMAL_CALL_BY_REFERENCE
2635 void
2636 bid64_signaling_less_unordered (int *pres, UINT64 * px,
2637                                 UINT64 *
2638                                 py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
2639                                 _EXC_INFO_PARAM) {
2640   UINT64 x = *px;
2641   UINT64 y = *py;
2642 #else
2643 int
2644 bid64_signaling_less_unordered (UINT64 x,
2645                                 UINT64 y _EXC_FLAGS_PARAM
2646                                 _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
2647 #endif
2648   int res;
2649   int exp_x, exp_y;
2650   UINT64 sig_x, sig_y;
2651   UINT128 sig_n_prime;
2652   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
2653
2654   // NaN (CASE1)
2655   // if either number is NAN, the comparison is unordered : return 0
2656   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
2657     *pfpsf |= INVALID_EXCEPTION;        // set invalid exception if NaN
2658     res = 1;
2659     BID_RETURN (res);
2660   }
2661   // SIMPLE (CASE2)
2662   // if all the bits are the same, these numbers are equal.
2663   if (x == y) {
2664     res = 0;
2665     BID_RETURN (res);
2666   }
2667   // INFINITY (CASE3)
2668   if ((x & MASK_INF) == MASK_INF) {
2669     // if x==neg_inf, { res = (y == neg_inf)?0:1; BID_RETURN (res) }
2670     if ((x & MASK_SIGN) == MASK_SIGN)
2671       // x is -inf, so it is less than y unless y is -inf
2672     {
2673       res = (((y & MASK_INF) != MASK_INF)
2674              || (y & MASK_SIGN) != MASK_SIGN);
2675       BID_RETURN (res);
2676     } else
2677       // x is pos_inf, no way for it to be less than y
2678     {
2679       res = 0;
2680       BID_RETURN (res);
2681     }
2682   } else if ((y & MASK_INF) == MASK_INF) {
2683     // x is finite, so:
2684     //    if y is +inf, x<y
2685     //    if y is -inf, x>y
2686     {
2687       res = ((y & MASK_SIGN) != MASK_SIGN);
2688       BID_RETURN (res);
2689     }
2690   }
2691   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
2692   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
2693     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
2694     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
2695     if (sig_x > 9999999999999999ull) {
2696       non_canon_x = 1;
2697     } else {
2698       non_canon_x = 0;
2699     }
2700   } else {
2701     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
2702     sig_x = (x & MASK_BINARY_SIG1);
2703     non_canon_x = 0;
2704   }
2705
2706   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
2707   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
2708     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
2709     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
2710     if (sig_y > 9999999999999999ull) {
2711       non_canon_y = 1;
2712     } else {
2713       non_canon_y = 0;
2714     }
2715   } else {
2716     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
2717     sig_y = (y & MASK_BINARY_SIG1);
2718     non_canon_y = 0;
2719   }
2720
2721   // ZERO (CASE4)
2722   // some properties:
2723   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
2724   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
2725   //      therefore ignore the exponent field
2726   //    (Any non-canonical # is considered 0)
2727   if (non_canon_x || sig_x == 0) {
2728     x_is_zero = 1;
2729   }
2730   if (non_canon_y || sig_y == 0) {
2731     y_is_zero = 1;
2732   }
2733   // if both numbers are zero, they are equal
2734   if (x_is_zero && y_is_zero) {
2735     res = 0;
2736     BID_RETURN (res);
2737   }
2738   // if x is zero, it is lessthan if Y is positive
2739   else if (x_is_zero) {
2740     res = ((y & MASK_SIGN) != MASK_SIGN);
2741     BID_RETURN (res);
2742   }
2743   // if y is zero, X is less if it is negative
2744   else if (y_is_zero) {
2745     res = ((x & MASK_SIGN) == MASK_SIGN);
2746     BID_RETURN (res);
2747   }
2748   // OPPOSITE SIGN (CASE5)
2749   // now, if the sign bits differ, x is less than if y is positive
2750   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
2751     res = ((y & MASK_SIGN) != MASK_SIGN);
2752     BID_RETURN (res);
2753   }
2754   // REDUNDANT REPRESENTATIONS (CASE6)
2755   // if both components are either bigger or smaller
2756   if (sig_x > sig_y && exp_x >= exp_y) {
2757     res = ((x & MASK_SIGN) == MASK_SIGN);
2758     BID_RETURN (res);
2759   }
2760   if (sig_x < sig_y && exp_x <= exp_y) {
2761     res = ((x & MASK_SIGN) != MASK_SIGN);
2762     BID_RETURN (res);
2763   }
2764   // if exp_x is 15 greater than exp_y, no need for compensation
2765   if (exp_x - exp_y > 15) {
2766     res = ((x & MASK_SIGN) == MASK_SIGN);
2767     BID_RETURN (res);
2768   }
2769   // difference cannot be greater than 10^15
2770
2771   // if exp_x is 15 less than exp_y, no need for compensation
2772   if (exp_y - exp_x > 15) {
2773     res = ((x & MASK_SIGN) != MASK_SIGN);
2774     BID_RETURN (res);
2775   }
2776   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
2777   if (exp_x > exp_y) {  // to simplify the loop below,
2778
2779     // otherwise adjust the x significand upwards
2780     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
2781                             mult_factor[exp_x - exp_y]);
2782
2783     // return 0 if values are equal
2784     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
2785       res = 0;
2786       BID_RETURN (res);
2787     }
2788     // if postitive, return whichever significand abs is smaller
2789     //     (converse if negative)
2790     {
2791       res = (((sig_n_prime.w[1] == 0)
2792               && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
2793                                               MASK_SIGN));
2794       BID_RETURN (res);
2795     }
2796   }
2797   // adjust the y significand upwards
2798   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
2799                           mult_factor[exp_y - exp_x]);
2800
2801   // return 0 if values are equal
2802   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
2803     res = 0;
2804     BID_RETURN (res);
2805   }
2806   // if positive, return whichever significand abs is smaller
2807   //     (converse if negative)
2808   {
2809     res = (((sig_n_prime.w[1] > 0)
2810             || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
2811                                               MASK_SIGN));
2812     BID_RETURN (res);
2813   }
2814 }
2815
2816 #if DECIMAL_CALL_BY_REFERENCE
2817 void
2818 bid64_signaling_not_greater (int *pres, UINT64 * px,
2819                              UINT64 *
2820                              py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
2821                              _EXC_INFO_PARAM) {
2822   UINT64 x = *px;
2823   UINT64 y = *py;
2824 #else
2825 int
2826 bid64_signaling_not_greater (UINT64 x,
2827                              UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
2828                              _EXC_INFO_PARAM) {
2829 #endif
2830   int res;
2831   int exp_x, exp_y;
2832   UINT64 sig_x, sig_y;
2833   UINT128 sig_n_prime;
2834   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
2835
2836   // NaN (CASE1)
2837   // if either number is NAN, the comparison is unordered,
2838   // rather than equal : return 0
2839   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
2840     *pfpsf |= INVALID_EXCEPTION;        // set invalid exception if NaN
2841     res = 1;
2842     BID_RETURN (res);
2843   }
2844   // SIMPLE (CASE2)
2845   // if all the bits are the same, these numbers are equal (LESSEQUAL).
2846   if (x == y) {
2847     res = 1;
2848     BID_RETURN (res);
2849   }
2850   // INFINITY (CASE3)
2851   if ((x & MASK_INF) == MASK_INF) {
2852     // if x is neg infinity, it must be lessthan or equal to y return 1
2853     if (((x & MASK_SIGN) == MASK_SIGN)) {
2854       res = 1;
2855       BID_RETURN (res);
2856     }
2857     // x is pos infinity, it is greater,
2858     // unless y is positive infinity => return y==pos_infinity
2859     else {
2860       res = !(((y & MASK_INF) != MASK_INF)
2861               || ((y & MASK_SIGN) == MASK_SIGN));
2862       BID_RETURN (res);
2863     }
2864   } else if ((y & MASK_INF) == MASK_INF) {
2865     // x is finite, so if y is positive infinity, then x is less, return 1
2866     //                 if y is negative infinity, then x is greater, return 0
2867     {
2868       res = ((y & MASK_SIGN) != MASK_SIGN);
2869       BID_RETURN (res);
2870     }
2871   }
2872   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
2873   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
2874     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
2875     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
2876     if (sig_x > 9999999999999999ull) {
2877       non_canon_x = 1;
2878     } else {
2879       non_canon_x = 0;
2880     }
2881   } else {
2882     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
2883     sig_x = (x & MASK_BINARY_SIG1);
2884     non_canon_x = 0;
2885   }
2886
2887   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
2888   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
2889     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
2890     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
2891     if (sig_y > 9999999999999999ull) {
2892       non_canon_y = 1;
2893     } else {
2894       non_canon_y = 0;
2895     }
2896   } else {
2897     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
2898     sig_y = (y & MASK_BINARY_SIG1);
2899     non_canon_y = 0;
2900   }
2901
2902   // ZERO (CASE4)
2903   // some properties:
2904   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
2905   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
2906   //      therefore ignore the exponent field
2907   //    (Any non-canonical # is considered 0)
2908   if (non_canon_x || sig_x == 0) {
2909     x_is_zero = 1;
2910   }
2911   if (non_canon_y || sig_y == 0) {
2912     y_is_zero = 1;
2913   }
2914   // if both numbers are zero, they are equal -> return 1
2915   if (x_is_zero && y_is_zero) {
2916     res = 1;
2917     BID_RETURN (res);
2918   }
2919   // if x is zero, it is lessthan if Y is positive
2920   else if (x_is_zero) {
2921     res = ((y & MASK_SIGN) != MASK_SIGN);
2922     BID_RETURN (res);
2923   }
2924   // if y is zero, X is less if it is negative
2925   else if (y_is_zero) {
2926     res = ((x & MASK_SIGN) == MASK_SIGN);
2927     BID_RETURN (res);
2928   }
2929   // OPPOSITE SIGN (CASE5)
2930   // now, if the sign bits differ, x is less than if y is positive
2931   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
2932     res = ((y & MASK_SIGN) != MASK_SIGN);
2933     BID_RETURN (res);
2934   }
2935   // REDUNDANT REPRESENTATIONS (CASE6)
2936   // if both components are either bigger or smaller
2937   if (sig_x > sig_y && exp_x >= exp_y) {
2938     res = ((x & MASK_SIGN) == MASK_SIGN);
2939     BID_RETURN (res);
2940   }
2941   if (sig_x < sig_y && exp_x <= exp_y) {
2942     res = ((x & MASK_SIGN) != MASK_SIGN);
2943     BID_RETURN (res);
2944   }
2945   // if exp_x is 15 greater than exp_y, no need for compensation
2946   if (exp_x - exp_y > 15) {
2947     res = ((x & MASK_SIGN) == MASK_SIGN);
2948     BID_RETURN (res);
2949   }
2950   // difference cannot be greater than 10^15
2951
2952   // if exp_x is 15 less than exp_y, no need for compensation
2953   if (exp_y - exp_x > 15) {
2954     res = ((x & MASK_SIGN) != MASK_SIGN);
2955     BID_RETURN (res);
2956   }
2957   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
2958   if (exp_x > exp_y) {  // to simplify the loop below,
2959
2960     // otherwise adjust the x significand upwards
2961     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
2962                             mult_factor[exp_x - exp_y]);
2963
2964     // return 1 if values are equal
2965     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
2966       res = 1;
2967       BID_RETURN (res);
2968     }
2969     // if postitive, return whichever significand abs is smaller
2970     //     (converse if negative)
2971     {
2972       res = (((sig_n_prime.w[1] == 0)
2973               && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
2974                                               MASK_SIGN));
2975       BID_RETURN (res);
2976     }
2977   }
2978   // adjust the y significand upwards
2979   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
2980                           mult_factor[exp_y - exp_x]);
2981
2982   // return 1 if values are equal
2983   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
2984     res = 1;
2985     BID_RETURN (res);
2986   }
2987   // if positive, return whichever significand abs is smaller
2988   //     (converse if negative)
2989   {
2990     res = (((sig_n_prime.w[1] > 0)
2991             || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
2992                                               MASK_SIGN));
2993     BID_RETURN (res);
2994   }
2995 }
2996
2997 #if DECIMAL_CALL_BY_REFERENCE
2998 void
2999 bid64_signaling_not_less (int *pres, UINT64 * px,
3000                           UINT64 *
3001                           py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
3002                           _EXC_INFO_PARAM) {
3003   UINT64 x = *px;
3004   UINT64 y = *py;
3005 #else
3006 int
3007 bid64_signaling_not_less (UINT64 x,
3008                           UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
3009                           _EXC_INFO_PARAM) {
3010 #endif
3011   int res;
3012   int exp_x, exp_y;
3013   UINT64 sig_x, sig_y;
3014   UINT128 sig_n_prime;
3015   char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
3016
3017   // NaN (CASE1)
3018   // if either number is NAN, the comparison is unordered : return 1
3019   if (((x & MASK_NAN) == MASK_NAN) || ((y & MASK_NAN) == MASK_NAN)) {
3020     *pfpsf |= INVALID_EXCEPTION;        // set invalid exception if NaN
3021     res = 1;
3022     BID_RETURN (res);
3023   }
3024   // SIMPLE (CASE2)
3025   // if all the bits are the same, these numbers are equal.
3026   if (x == y) {
3027     res = 1;
3028     BID_RETURN (res);
3029   }
3030   // INFINITY (CASE3)
3031   if ((x & MASK_INF) == MASK_INF) {
3032     // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
3033     if ((x & MASK_SIGN) == MASK_SIGN)
3034       // x is -inf, so it is less than y unless y is -inf
3035     {
3036       res = (((y & MASK_INF) == MASK_INF)
3037              && (y & MASK_SIGN) == MASK_SIGN);
3038       BID_RETURN (res);
3039     } else
3040       // x is pos_inf, no way for it to be less than y
3041     {
3042       res = 1;
3043       BID_RETURN (res);
3044     }
3045   } else if ((y & MASK_INF) == MASK_INF) {
3046     // x is finite, so:
3047     //    if y is +inf, x<y
3048     //    if y is -inf, x>y
3049     {
3050       res = ((y & MASK_SIGN) == MASK_SIGN);
3051       BID_RETURN (res);
3052     }
3053   }
3054   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
3055   if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
3056     exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
3057     sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
3058     if (sig_x > 9999999999999999ull) {
3059       non_canon_x = 1;
3060     } else {
3061       non_canon_x = 0;
3062     }
3063   } else {
3064     exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
3065     sig_x = (x & MASK_BINARY_SIG1);
3066     non_canon_x = 0;
3067   }
3068
3069   // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
3070   if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
3071     exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
3072     sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
3073     if (sig_y > 9999999999999999ull) {
3074       non_canon_y = 1;
3075     } else {
3076       non_canon_y = 0;
3077     }
3078   } else {
3079     exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
3080     sig_y = (y & MASK_BINARY_SIG1);
3081     non_canon_y = 0;
3082   }
3083
3084   // ZERO (CASE4)
3085   // some properties:
3086   // (+ZERO==-ZERO) => therefore ignore the sign, and neither number is greater
3087   //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
3088   //      therefore ignore the exponent field
3089   //    (Any non-canonical # is considered 0)
3090   if (non_canon_x || sig_x == 0) {
3091     x_is_zero = 1;
3092   }
3093   if (non_canon_y || sig_y == 0) {
3094     y_is_zero = 1;
3095   }
3096   // if both numbers are zero, they are equal
3097   if (x_is_zero && y_is_zero) {
3098     res = 1;
3099     BID_RETURN (res);
3100   }
3101   // if x is zero, it is lessthan if Y is positive
3102   else if (x_is_zero) {
3103     res = ((y & MASK_SIGN) == MASK_SIGN);
3104     BID_RETURN (res);
3105   }
3106   // if y is zero, X is less if it is negative
3107   else if (y_is_zero) {
3108     res = ((x & MASK_SIGN) != MASK_SIGN);
3109     BID_RETURN (res);
3110   }
3111   // OPPOSITE SIGN (CASE5)
3112   // now, if the sign bits differ, x is less than if y is positive
3113   if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
3114     res = ((y & MASK_SIGN) == MASK_SIGN);
3115     BID_RETURN (res);
3116   }
3117   // REDUNDANT REPRESENTATIONS (CASE6)
3118   // if both components are either bigger or smaller
3119   if (sig_x > sig_y && exp_x >= exp_y) {
3120     res = ((x & MASK_SIGN) != MASK_SIGN);
3121     BID_RETURN (res);
3122   }
3123   if (sig_x < sig_y && exp_x <= exp_y) {
3124     res = ((x & MASK_SIGN) == MASK_SIGN);
3125     BID_RETURN (res);
3126   }
3127   // if exp_x is 15 greater than exp_y, no need for compensation
3128   if (exp_x - exp_y > 15) {
3129     res = ((x & MASK_SIGN) != MASK_SIGN);
3130     BID_RETURN (res);
3131   }
3132   // difference cannot be greater than 10^15
3133
3134   // if exp_x is 15 less than exp_y, no need for compensation
3135   if (exp_y - exp_x > 15) {
3136     res = ((x & MASK_SIGN) == MASK_SIGN);
3137     BID_RETURN (res);
3138   }
3139   // if |exp_x - exp_y| < 15, it comes down to the compensated significand
3140   if (exp_x > exp_y) {  // to simplify the loop below,
3141
3142     // otherwise adjust the x significand upwards
3143     __mul_64x64_to_128MACH (sig_n_prime, sig_x,
3144                             mult_factor[exp_x - exp_y]);
3145
3146     // return 0 if values are equal
3147     if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
3148       res = 1;
3149       BID_RETURN (res);
3150     }
3151     // if postitive, return whichever significand abs is smaller
3152     //     (converse if negative)
3153     {
3154       res = (((sig_n_prime.w[1] == 0)
3155               && sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) !=
3156                                               MASK_SIGN));
3157       BID_RETURN (res);
3158     }
3159   }
3160   // adjust the y significand upwards
3161   __mul_64x64_to_128MACH (sig_n_prime, sig_y,
3162                           mult_factor[exp_y - exp_x]);
3163
3164   // return 0 if values are equal
3165   if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
3166     res = 1;
3167     BID_RETURN (res);
3168   }
3169   // if positive, return whichever significand abs is smaller
3170   //     (converse if negative)
3171   {
3172     res = (((sig_n_prime.w[1] > 0)
3173             || (sig_x < sig_n_prime.w[0])) ^ ((x & MASK_SIGN) !=
3174                                               MASK_SIGN));
3175     BID_RETURN (res);
3176   }
3177 }