OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [libbid/] [bid64_compare.c] - Blame information for rev 734

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.