1 /* Copyright (C) 2007-2023 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 }