?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2007-09-27 H.J. Lu <hongjiu.lu@intel.com>
[official-gcc.git] / libgcc / config / libbid / bid128_noncomp.c
blob576c1485cfa09fb32718a17610fc204eff9fe524
1 /* Copyright (C) 2007 Free Software Foundation, Inc.
2
3 This file is part of GCC.
4
5 GCC is free software; you can redistribute it and/or modify it under
6 the terms of the GNU General Public License as published by the Free
7 Software Foundation; either version 2, or (at your option) any later
8 version.
9
10 In addition to the permissions in the GNU General Public License, the
11 Free Software Foundation gives you unlimited permission to link the
12 compiled version of this file into combinations with other programs,
13 and to distribute those combinations without any restriction coming
14 from the use of this file. (The General Public License restrictions
15 do apply in other respects; for example, they cover modification of
16 the file, and distribution when not linked into a combine
17 executable.)
18
19 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
20 WARRANTY; without even the implied warranty of MERCHANTABILITY or
21 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with GCC; see the file COPYING. If not, write to the Free
26 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
27 02110-1301, USA. */
28
29 #include "bid_internal.h"
30
31 /*****************************************************************************
32 *
33 * BID128 non-computational functions:
34 * - bid128_isSigned
35 * - bid128_isNormal
36 * - bid128_isSubnormal
37 * - bid128_isFinite
38 * - bid128_isZero
39 * - bid128_isInf
40 * - bid128_isSignaling
41 * - bid128_isCanonical
42 * - bid128_isNaN
43 * - bid128_copy
44 * - bid128_negate
45 * - bid128_abs
46 * - bid128_copySign
47 * - bid128_class
48 * - bid128_totalOrder
49 * - bid128_totalOrderMag
50 * - bid128_sameQuantum
51 * - bid128_radix
52 ****************************************************************************/
53
54 #if DECIMAL_CALL_BY_REFERENCE
55 void
56 bid128_isSigned (int *pres,
57 UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
58 UINT128 x = *px;
59 #else
60 int
61 bid128_isSigned (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
62 #endif
63 int res;
64
65 res = ((x.w[HIGH_128W] & MASK_SIGN) == MASK_SIGN);
66 BID_RETURN (res);
67 }
68
69 // return 1 iff x is not zero, nor NaN nor subnormal nor infinity
70 #if DECIMAL_CALL_BY_REFERENCE
71 void
72 bid128_isNormal (int *pres,
73 UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
74 UINT128 x = *px;
75 #else
76 int
77 bid128_isNormal (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
78 #endif
79 int res;
80 UINT64 x_exp, C1_hi, C1_lo;
81 BID_UI64DOUBLE tmp1;
82 int exp, q, x_nr_bits;
83
84 BID_SWAP128 (x);
85 // test for special values - infinity or NaN
86 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) {
87 // x is special
88 res = 0;
89 BID_RETURN (res);
90 }
91 // unpack x
92 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions
93 C1_hi = x.w[1] & MASK_COEFF;
94 C1_lo = x.w[0];
95 // test for zero
96 if (C1_hi == 0 && C1_lo == 0) {
97 res = 0;
98 BID_RETURN (res);
99 }
100 // test for non-canonical values of the argument x
101 if ((((C1_hi > 0x0001ed09bead87c0ull)
102 || ((C1_hi == 0x0001ed09bead87c0ull)
103 && (C1_lo > 0x378d8e63ffffffffull)))
104 && ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull))
105 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) {
106 res = 0;
107 BID_RETURN (res);
108 }
109 // x is subnormal or normal
110 // determine the number of digits q in the significand
111 // q = nr. of decimal digits in x
112 // determine first the nr. of bits in x
113 if (C1_hi == 0) {
114 if (C1_lo >= 0x0020000000000000ull) { // x >= 2^53
115 // split the 64-bit value in two 32-bit halves to avoid rounding errors
116 if (C1_lo >= 0x0000000100000000ull) { // x >= 2^32
117 tmp1.d = (double) (C1_lo >> 32); // exact conversion
118 x_nr_bits =
119 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
120 } else { // x < 2^32
121 tmp1.d = (double) (C1_lo); // exact conversion
122 x_nr_bits =
123 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
124 }
125 } else { // if x < 2^53
126 tmp1.d = (double) C1_lo; // exact conversion
127 x_nr_bits =
128 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
129 }
130 } else { // C1_hi != 0 => nr. bits = 64 + nr_bits (C1_hi)
131 tmp1.d = (double) C1_hi; // exact conversion
132 x_nr_bits =
133 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
134 }
135 q = nr_digits[x_nr_bits - 1].digits;
136 if (q == 0) {
137 q = nr_digits[x_nr_bits - 1].digits1;
138 if (C1_hi > nr_digits[x_nr_bits - 1].threshold_hi ||
139 (C1_hi == nr_digits[x_nr_bits - 1].threshold_hi &&
140 C1_lo >= nr_digits[x_nr_bits - 1].threshold_lo))
141 q++;
142 }
143 exp = (int) (x_exp >> 49) - 6176;
144 // test for subnormal values of x
145 if (exp + q <= -6143) {
146 res = 0;
147 BID_RETURN (res);
148 } else {
149 res = 1;
150 BID_RETURN (res);
151 }
152 }
153
154 // return 1 iff x is not zero, nor NaN nor normal nor infinity
155 #if DECIMAL_CALL_BY_REFERENCE
156 void
157 bid128_isSubnormal (int *pres,
158 UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
159 UINT128 x = *px;
160 #else
161 int
162 bid128_isSubnormal (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
163 #endif
164 int res;
165 UINT64 x_exp, C1_hi, C1_lo;
166 BID_UI64DOUBLE tmp1;
167 int exp, q, x_nr_bits;
168
169 BID_SWAP128 (x);
170 // test for special values - infinity or NaN
171 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) {
172 // x is special
173 res = 0;
174 BID_RETURN (res);
175 }
176 // unpack x
177 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions
178 C1_hi = x.w[1] & MASK_COEFF;
179 C1_lo = x.w[0];
180 // test for zero
181 if (C1_hi == 0 && C1_lo == 0) {
182 res = 0;
183 BID_RETURN (res);
184 }
185 // test for non-canonical values of the argument x
186 if ((((C1_hi > 0x0001ed09bead87c0ull)
187 || ((C1_hi == 0x0001ed09bead87c0ull)
188 && (C1_lo > 0x378d8e63ffffffffull)))
189 && ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull))
190 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) {
191 res = 0;
192 BID_RETURN (res);
193 }
194 // x is subnormal or normal
195 // determine the number of digits q in the significand
196 // q = nr. of decimal digits in x
197 // determine first the nr. of bits in x
198 if (C1_hi == 0) {
199 if (C1_lo >= 0x0020000000000000ull) { // x >= 2^53
200 // split the 64-bit value in two 32-bit halves to avoid rounding errors
201 if (C1_lo >= 0x0000000100000000ull) { // x >= 2^32
202 tmp1.d = (double) (C1_lo >> 32); // exact conversion
203 x_nr_bits =
204 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
205 } else { // x < 2^32
206 tmp1.d = (double) (C1_lo); // exact conversion
207 x_nr_bits =
208 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
209 }
210 } else { // if x < 2^53
211 tmp1.d = (double) C1_lo; // exact conversion
212 x_nr_bits =
213 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
214 }
215 } else { // C1_hi != 0 => nr. bits = 64 + nr_bits (C1_hi)
216 tmp1.d = (double) C1_hi; // exact conversion
217 x_nr_bits =
218 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
219 }
220 q = nr_digits[x_nr_bits - 1].digits;
221 if (q == 0) {
222 q = nr_digits[x_nr_bits - 1].digits1;
223 if (C1_hi > nr_digits[x_nr_bits - 1].threshold_hi ||
224 (C1_hi == nr_digits[x_nr_bits - 1].threshold_hi &&
225 C1_lo >= nr_digits[x_nr_bits - 1].threshold_lo))
226 q++;
227 }
228 exp = (int) (x_exp >> 49) - 6176;
229 // test for subnormal values of x
230 if (exp + q <= -6143) {
231 res = 1;
232 } else {
233 res = 0;
234 }
235 BID_RETURN (res);
236 }
237
238 #if DECIMAL_CALL_BY_REFERENCE
239 void
240 bid128_isFinite (int *pres,
241 UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
242 UINT128 x = *px;
243 #else
244 int
245 bid128_isFinite (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
246 #endif
247 int res;
248 res = ((x.w[HIGH_128W] & MASK_INF) != MASK_INF);
249 BID_RETURN (res);
250 }
251
252 #if DECIMAL_CALL_BY_REFERENCE
253 void
254 bid128_isZero (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
255 UINT128 x = *px;
256 #else
257 int
258 bid128_isZero (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
259 #endif
260 int res;
261 UINT128 sig_x;
262
263 BID_SWAP128 (x);
264 if ((x.w[1] & MASK_INF) == MASK_INF) {
265 res = 0;
266 BID_RETURN (res);
267 }
268 sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
269 sig_x.w[0] = x.w[0];
270 if ((sig_x.w[1] > 0x0001ed09bead87c0ull) || // significand is non-canonical
271 ((sig_x.w[1] == 0x0001ed09bead87c0ull) && (sig_x.w[0] > 0x378d8e63ffffffffull)) || // significand is non-canonical
272 ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull && (x.w[1] & MASK_INF) != MASK_INF) || // significand is non-canonical
273 (sig_x.w[1] == 0 && sig_x.w[0] == 0)) { // significand is 0
274 res = 1;
275 BID_RETURN (res);
276 }
277 res = 0;
278 BID_RETURN (res);
279 }
280
281 #if DECIMAL_CALL_BY_REFERENCE
282 void
283 bid128_isInf (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
284 UINT128 x = *px;
285 #else
286 int
287 bid128_isInf (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
288 #endif
289 int res;
290 res = ((x.w[HIGH_128W] & MASK_INF) == MASK_INF)
291 && ((x.w[HIGH_128W] & MASK_NAN) != MASK_NAN);
292 BID_RETURN (res);
293 }
294
295 #if DECIMAL_CALL_BY_REFERENCE
296 void
297 bid128_isSignaling (int *pres,
298 UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
299 UINT128 x = *px;
300 #else
301 int
302 bid128_isSignaling (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
303 #endif
304 int res;
305
306 res = ((x.w[HIGH_128W] & MASK_SNAN) == MASK_SNAN);
307 BID_RETURN (res);
308 }
309
310 // return 1 iff x is a canonical number ,infinity, or NaN.
311 #if DECIMAL_CALL_BY_REFERENCE
312 void
313 bid128_isCanonical (int *pres,
314 UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
315 UINT128 x = *px;
316 #else
317 int
318 bid128_isCanonical (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
319 #endif
320 int res;
321 UINT128 sig_x;
322
323 BID_SWAP128 (x);
324 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // NaN
325 if (x.w[1] & 0x01ffc00000000000ull) {
326 res = 0;
327 BID_RETURN (res);
328 }
329 sig_x.w[1] = x.w[1] & 0x00003fffffffffffull; // 46 bits
330 sig_x.w[0] = x.w[0]; // 64 bits
331 // payload must be < 10^33 = 0x0000314dc6448d93_38c15b0a00000000
332 if (sig_x.w[1] < 0x0000314dc6448d93ull
333 || (sig_x.w[1] == 0x0000314dc6448d93ull
334 && sig_x.w[0] < 0x38c15b0a00000000ull)) {
335 res = 1;
336 } else {
337 res = 0;
338 }
339 BID_RETURN (res);
340 } else if ((x.w[1] & MASK_INF) == MASK_INF) { // infinity
341 if ((x.w[1] & 0x03ffffffffffffffull) || x.w[0]) {
342 res = 0;
343 } else {
344 res = 1;
345 }
346 BID_RETURN (res);
347 }
348 // not NaN or infinity; extract significand to ensure it is canonical
349 sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
350 sig_x.w[0] = x.w[0];
351 // a canonical number has a coefficient < 10^34
352 // (0x0001ed09_bead87c0_378d8e64_00000000)
353 if ((sig_x.w[1] > 0x0001ed09bead87c0ull) || // significand is non-canonical
354 ((sig_x.w[1] == 0x0001ed09bead87c0ull) && (sig_x.w[0] > 0x378d8e63ffffffffull)) || // significand is non-canonical
355 ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) {
356 res = 0;
357 } else {
358 res = 1;
359 }
360 BID_RETURN (res);
361 }
362
363 #if DECIMAL_CALL_BY_REFERENCE
364 void
365 bid128_isNaN (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
366 UINT128 x = *px;
367 #else
368 int
369 bid128_isNaN (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
370 #endif
371 int res;
372
373 res = ((x.w[HIGH_128W] & MASK_NAN) == MASK_NAN);
374 BID_RETURN (res);
375 }
376
377 // copies a floating-point operand x to destination y, with no change
378 #if DECIMAL_CALL_BY_REFERENCE
379 void
380 bid128_copy (UINT128 * pres,
381 UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
382 UINT128 x = *px;
383 #else
384 UINT128
385 bid128_copy (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
386 #endif
387 UINT128 res;
388
389 res = x;
390 BID_RETURN (res);
391 }
392
393 // copies a floating-point operand x to destination y, reversing the sign
394 #if DECIMAL_CALL_BY_REFERENCE
395 void
396 bid128_negate (UINT128 * pres,
397 UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
398 UINT128 x = *px;
399 #else
400 UINT128
401 bid128_negate (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
402 #endif
403 UINT128 res;
404
405 x.w[HIGH_128W] ^= MASK_SIGN;
406 res = x;
407 BID_RETURN (res);
408 }
409
410 // copies a floating-point operand x to destination y, changing the sign to positive
411 #if DECIMAL_CALL_BY_REFERENCE
412 void
413 bid128_abs (UINT128 * pres,
414 UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
415 UINT128 x = *px;
416 #else
417 UINT128
418 bid128_abs (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
419 #endif
420 UINT128 res;
421
422 x.w[HIGH_128W] &= ~MASK_SIGN;
423 res = x;
424 BID_RETURN (res);
425 }
426
427 // copies operand x to destination in the same format as x, but with the sign of y
428 #if DECIMAL_CALL_BY_REFERENCE
429 void
430 bid128_copySign (UINT128 * pres, UINT128 * px,
431 UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
432 UINT128 x = *px;
433 UINT128 y = *py;
434 #else
435 UINT128
436 bid128_copySign (UINT128 x, UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
437 #endif
438 UINT128 res;
439
440 x.w[HIGH_128W] =
441 (x.w[HIGH_128W] & ~MASK_SIGN) | (y.w[HIGH_128W] & MASK_SIGN);
442 res = x;
443 BID_RETURN (res);
444 }
445
446 #if DECIMAL_CALL_BY_REFERENCE
447 void
448 bid128_class (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
449 UINT128 x = *px;
450 #else
451 int
452 bid128_class (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
453 #endif
454 int res;
455 UINT256 sig_x_prime256;
456 UINT192 sig_x_prime192;
457 UINT128 sig_x;
458 int exp_x;
459
460 BID_SWAP128 (x);
461 if ((x.w[1] & MASK_NAN) == MASK_NAN) {
462 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) {
463 res = signalingNaN;
464 } else {
465 res = quietNaN;
466 }
467 BID_RETURN (res);
468 }
469 if ((x.w[1] & MASK_INF) == MASK_INF) {
470 if ((x.w[1] & MASK_SIGN) == MASK_SIGN) {
471 res = negativeInfinity;
472 } else {
473 res = positiveInfinity;
474 }
475 BID_RETURN (res);
476 }
477 // decode number into exponent and significand
478 sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
479 sig_x.w[0] = x.w[0];
480 // check for zero or non-canonical
481 if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
482 || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
483 && (sig_x.w[0] > 0x378d8e63ffffffffull))
484 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)
485 || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
486 if ((x.w[1] & MASK_SIGN) == MASK_SIGN) {
487 res = negativeZero;
488 } else {
489 res = positiveZero;
490 }
491 BID_RETURN (res);
492 }
493 exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
494 // if exponent is less than -6176, the number may be subnormal
495 // (less than the smallest normal value)
496 // the smallest normal value is 1 x 10^-6143 = 10^33 x 10^-6176
497 // if (exp_x - 6176 < -6143)
498 if (exp_x < 33) { // sig_x * 10^exp_x
499 if (exp_x > 19) {
500 __mul_128x128_to_256 (sig_x_prime256, sig_x,
501 ten2k128[exp_x - 20]);
502 // 10^33 = 0x0000314dc6448d93_38c15b0a00000000
503 if ((sig_x_prime256.w[3] == 0) && (sig_x_prime256.w[2] == 0)
504 && ((sig_x_prime256.w[1] < 0x0000314dc6448d93ull)
505 || ((sig_x_prime256.w[1] == 0x0000314dc6448d93ull)
506 && (sig_x_prime256.w[0] < 0x38c15b0a00000000ull)))) {
507 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? negativeSubnormal :
508 positiveSubnormal;
509 BID_RETURN (res);
510 }
511 } else {
512 __mul_64x128_to_192 (sig_x_prime192, ten2k64[exp_x], sig_x);
513 // 10^33 = 0x0000314dc6448d93_38c15b0a00000000
514 if ((sig_x_prime192.w[2] == 0)
515 && ((sig_x_prime192.w[1] < 0x0000314dc6448d93ull)
516 || ((sig_x_prime192.w[1] == 0x0000314dc6448d93ull)
517 && (sig_x_prime192.w[0] < 0x38c15b0a00000000ull)))) {
518 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? negativeSubnormal :
519 positiveSubnormal;
520 BID_RETURN (res);
521 }
522 }
523 }
524 // otherwise, normal number, determine the sign
525 res =
526 ((x.w[1] & MASK_SIGN) ==
527 MASK_SIGN) ? negativeNormal : positiveNormal;
528 BID_RETURN (res);
529 }
530
531 // true if the exponents of x and y are the same, false otherwise.
532 // The special cases of sameQuantum(NaN, NaN) and sameQuantum(Inf, Inf) are true
533 // If exactly one operand is infinite or exactly one operand is NaN, then false
534 #if DECIMAL_CALL_BY_REFERENCE
535 void
536 bid128_sameQuantum (int *pres, UINT128 * px,
537 UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
538 UINT128 x = *px;
539 UINT128 y = *py;
540 #else
541 int
542 bid128_sameQuantum (UINT128 x,
543 UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
544 #endif
545 int res;
546 UINT64 x_exp, y_exp;
547
548 BID_SWAP128 (x);
549 BID_SWAP128 (y);
550 // if both operands are NaN, return true
551 if ((x.w[1] & MASK_NAN) == MASK_NAN
552 || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
553 res = ((x.w[1] & MASK_NAN) == MASK_NAN
554 && (y.w[1] & MASK_NAN) == MASK_NAN);
555 BID_RETURN (res);
556 }
557 // if both operands are INF, return true
558 if ((x.w[1] & MASK_INF) == MASK_INF
559 || (y.w[1] & MASK_INF) == MASK_INF) {
560 res = ((x.w[1] & MASK_INF) == MASK_INF)
561 && ((y.w[1] & MASK_INF) == MASK_INF);
562 BID_RETURN (res);
563 }
564 // decode exponents for both numbers, and return true if they match
565 if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11
566 x_exp = (x.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits
567 } else { // G0_G1 != 11
568 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bits
569 }
570 if ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11
571 y_exp = (y.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits
572 } else { // G0_G1 != 11
573 y_exp = y.w[1] & MASK_EXP; // biased and shifted left 49 bits
574 }
575 res = (x_exp == y_exp);
576 BID_RETURN (res);
577 }
578
579 #if DECIMAL_CALL_BY_REFERENCE
580 void
581 bid128_totalOrder (int *pres, UINT128 * px,
582 UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
583 UINT128 x = *px;
584 UINT128 y = *py;
585 #else
586 int
587 bid128_totalOrder (UINT128 x,
588 UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
589 #endif
590 int res;
591 int exp_x, exp_y;
592 UINT128 sig_x, sig_y, pyld_y, pyld_x;
593 UINT192 sig_n_prime192;
594 UINT256 sig_n_prime256;
595 char x_is_zero = 0, y_is_zero = 0;
596
597 BID_SWAP128 (x);
598 BID_SWAP128 (y);
599 // NaN (CASE 1)
600 // if x and y are unordered numerically because either operand is NaN
601 // (1) totalOrder(-NaN, number) is true
602 // (2) totalOrder(number, +NaN) is true
603 // (3) if x and y are both NaN:
604 // i) negative sign bit < positive sign bit
605 // ii) signaling < quiet for +NaN, reverse for -NaN
606 // iii) lesser payload < greater payload for +NaN (reverse for -NaN)
607 // iv) else if bitwise identical (in canonical form), return 1
608 if ((x.w[1] & MASK_NAN) == MASK_NAN) {
609 // if x is -NaN
610 if ((x.w[1] & MASK_SIGN) == MASK_SIGN) {
611 // return true, unless y is -NaN also
612 if ((y.w[1] & MASK_NAN) != MASK_NAN
613 || (y.w[1] & MASK_SIGN) != MASK_SIGN) {
614 res = 1; // y is a number, return 1
615 BID_RETURN (res);
616 } else { // if y and x are both -NaN
617 pyld_x.w[1] = x.w[1] & 0x00003fffffffffffull;
618 pyld_x.w[0] = x.w[0];
619 pyld_y.w[1] = y.w[1] & 0x00003fffffffffffull;
620 pyld_y.w[0] = y.w[0];
621 if ((pyld_x.w[1] > 0x0000314dc6448d93ull)
622 || ((pyld_x.w[1] == 0x0000314dc6448d93ull)
623 && (pyld_x.w[0] > 0x38c15b09ffffffffull))) {
624 pyld_x.w[1] = 0;
625 pyld_x.w[0] = 0;
626 }
627 if ((pyld_y.w[1] > 0x0000314dc6448d93ull)
628 || ((pyld_y.w[1] == 0x0000314dc6448d93ull)
629 && (pyld_y.w[0] > 0x38c15b09ffffffffull))) {
630 pyld_y.w[1] = 0;
631 pyld_y.w[0] = 0;
632 }
633 // if x and y are both -SNaN or both -QNaN, we have to compare payloads
634 // this statement evaluates to true if both are SNaN or QNaN
635 if (!
636 (((y.w[1] & MASK_SNAN) == MASK_SNAN) ^
637 ((x.w[1] & MASK_SNAN) == MASK_SNAN))) {
638 // it comes down to the payload. we want to return true if x has a
639 // larger payload, or if the payloads are equal (canonical forms
640 // are bitwise identical)
641 if ((pyld_x.w[1] > pyld_y.w[1]) ||
642 ((pyld_x.w[1] == pyld_y.w[1])
643 && (pyld_x.w[0] >= pyld_y.w[0])))
644 res = 1;
645 else
646 res = 0;
647 BID_RETURN (res);
648 } else {
649 // either x = -SNaN and y = -QNaN or x = -QNaN and y = -SNaN
650 res = ((y.w[1] & MASK_SNAN) == MASK_SNAN);
651 // totalOrder (-QNaN, -SNaN) == 1
652 BID_RETURN (res);
653 }
654 }
655 } else { // x is +NaN
656 // return false, unless y is +NaN also
657 if ((y.w[1] & MASK_NAN) != MASK_NAN
658 || (y.w[1] & MASK_SIGN) == MASK_SIGN) {
659 res = 0; // y is a number, return 1
660 BID_RETURN (res);
661 } else {
662 // x and y are both +NaN;
663 pyld_x.w[1] = x.w[1] & 0x00003fffffffffffull;
664 pyld_x.w[0] = x.w[0];
665 pyld_y.w[1] = y.w[1] & 0x00003fffffffffffull;
666 pyld_y.w[0] = y.w[0];
667 if ((pyld_x.w[1] > 0x0000314dc6448d93ull)
668 || ((pyld_x.w[1] == 0x0000314dc6448d93ull)
669 && (pyld_x.w[0] > 0x38c15b09ffffffffull))) {
670 pyld_x.w[1] = 0;
671 pyld_x.w[0] = 0;
672 }
673 if ((pyld_y.w[1] > 0x0000314dc6448d93ull)
674 || ((pyld_y.w[1] == 0x0000314dc6448d93ull)
675 && (pyld_y.w[0] > 0x38c15b09ffffffffull))) {
676 pyld_y.w[1] = 0;
677 pyld_y.w[0] = 0;
678 }
679 // if x and y are both +SNaN or both +QNaN, we have to compare payloads
680 // this statement evaluates to true if both are SNaN or QNaN
681 if (!
682 (((y.w[1] & MASK_SNAN) == MASK_SNAN) ^
683 ((x.w[1] & MASK_SNAN) == MASK_SNAN))) {
684 // it comes down to the payload. we want to return true if x has a
685 // smaller payload, or if the payloads are equal (canonical forms
686 // are bitwise identical)
687 if ((pyld_x.w[1] < pyld_y.w[1]) ||
688 ((pyld_x.w[1] == pyld_y.w[1])
689 && (pyld_x.w[0] <= pyld_y.w[0])))
690 res = 1;
691 else
692 res = 0;
693 BID_RETURN (res);
694 } else {
695 // either x = SNaN and y = QNaN or x = QNaN and y = SNaN
696 res = ((x.w[1] & MASK_SNAN) == MASK_SNAN);
697 // totalOrder (-QNaN, -SNaN) == 1
698 BID_RETURN (res);
699 }
700 }
701 }
702 } else if ((y.w[1] & MASK_NAN) == MASK_NAN) {
703 // x is certainly not NAN in this case.
704 // return true if y is positive
705 res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
706 BID_RETURN (res);
707 }
708 // SIMPLE (CASE 2)
709 // if all the bits are the same, the numbers are equal.
710 if ((x.w[1] == y.w[1]) && (x.w[0] == y.w[0])) {
711 res = 1;
712 BID_RETURN (res);
713 }
714 // OPPOSITE SIGNS (CASE 3)
715 // if signs are opposite, return 1 if x is negative
716 // (if x < y, totalOrder is true)
717 if (((x.w[1] & MASK_SIGN) == MASK_SIGN) ^ ((y.w[1] & MASK_SIGN) ==
718 MASK_SIGN)) {
719 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
720 BID_RETURN (res);
721 }
722 // INFINITY (CASE 4)
723 if ((x.w[1] & MASK_INF) == MASK_INF) {
724 // if x == neg_inf, return (y == neg_inf);
725 if ((x.w[1] & MASK_SIGN) == MASK_SIGN) {
726 res = 1;
727 BID_RETURN (res);
728 } else {
729 // x is positive infinity, only return1 if y is positive infinity as well
730 res = ((y.w[1] & MASK_INF) == MASK_INF);
731 BID_RETURN (res);
732 // && (y & MASK_SIGN) != MASK_SIGN); (we know y has same sign as x)
733 }
734 } else if ((y.w[1] & MASK_INF) == MASK_INF) {
735 // x is finite, so:
736 // if y is +inf, x<y
737 // if y is -inf, x>y
738 res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
739 BID_RETURN (res);
740 }
741 // CONVERT x
742 sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
743 sig_x.w[0] = x.w[0];
744 exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
745
746 // CHECK IF x IS CANONICAL
747 // 9999999999999999999999999999999999 (decimal) =
748 // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
749 // [0, 10^34) is the 754r supported canonical range.
750 // If the value exceeds that, it is interpreted as 0.
751 if ((((sig_x.w[1] > 0x0001ed09bead87c0ull) ||
752 ((sig_x.w[1] == 0x0001ed09bead87c0ull) &&
753 (sig_x.w[0] > 0x378d8e63ffffffffull))) &&
754 ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) ||
755 ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) ||
756 ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
757 x_is_zero = 1;
758 // check for the case where the exponent is shifted right by 2 bits!
759 if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) {
760 exp_x = (x.w[1] >> 47) & 0x000000000003fffull;
761 }
762 }
763 // CONVERT y
764 exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
765 sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
766 sig_y.w[0] = y.w[0];
767
768 // CHECK IF y IS CANONICAL
769 // 9999999999999999999999999999999999(decimal) =
770 // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
771 // [0, 10^34) is the 754r supported canonical range.
772 // If the value exceeds that, it is interpreted as 0.
773 if ((((sig_y.w[1] > 0x0001ed09bead87c0ull) ||
774 ((sig_y.w[1] == 0x0001ed09bead87c0ull) &&
775 (sig_y.w[0] > 0x378d8e63ffffffffull))) &&
776 ((y.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) ||
777 ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) ||
778 ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
779 y_is_zero = 1;
780 // check for the case where the exponent is shifted right by 2 bits!
781 if ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) {
782 exp_y = (y.w[1] >> 47) & 0x000000000003fffull;
783 }
784 }
785 // ZERO (CASE 5)
786 // if x and y represent the same entities, and both are negative
787 // return true iff exp_x <= exp_y
788 if (x_is_zero && y_is_zero) {
789 // we know that signs must be the same because we would have caught it
790 // in case3 if signs were different
791 // totalOrder(x,y) iff exp_x >= exp_y for negative numbers
792 // totalOrder(x,y) iff exp_x <= exp_y for positive numbers
793 if (exp_x == exp_y) {
794 res = 1;
795 BID_RETURN (res);
796 }
797 res = ((exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
798 BID_RETURN (res);
799 }
800 // if x is zero and y isn't, clearly x has the smaller payload
801 if (x_is_zero) {
802 res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
803 BID_RETURN (res);
804 }
805 // if y is zero, and x isn't, clearly y has the smaller payload
806 if (y_is_zero) {
807 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
808 BID_RETURN (res);
809 }
810 // REDUNDANT REPRESENTATIONS (CASE 6)
811 // if both components are either bigger or smaller
812 if (((sig_x.w[1] > sig_y.w[1])
813 || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
814 && exp_x >= exp_y) {
815 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
816 BID_RETURN (res);
817 }
818 if (((sig_x.w[1] < sig_y.w[1])
819 || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
820 && exp_x <= exp_y) {
821 res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
822 BID_RETURN (res);
823 }
824 // if |exp_x - exp_y| < 33, it comes down to the compensated significand
825 if (exp_x > exp_y) {
826 // if exp_x is 33 greater than exp_y, it is definitely larger,
827 // so no need for compensation
828 if (exp_x - exp_y > 33) {
829 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
830 BID_RETURN (res);
831 // difference cannot be greater than 10^33
832 }
833 // otherwise adjust the x significand upwards
834 if (exp_x - exp_y > 19) {
835 __mul_128x128_to_256 (sig_n_prime256, sig_x,
836 ten2k128[exp_x - exp_y - 20]);
837 // the compensated significands are equal (ie "x and y represent the same
838 // entities") return 1 if (negative && expx > expy) ||
839 // (positive && expx < expy)
840 if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0)
841 && (sig_n_prime256.w[1] == sig_y.w[1])
842 && (sig_n_prime256.w[0] == sig_y.w[0])) {
843 // the case exp_x == exp_y cannot occur, because all bits must be
844 // the same - would have been caught if (x == y)
845 res = ((exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
846 BID_RETURN (res);
847 }
848 // if positive, return 1 if adjusted x is smaller than y
849 res = (((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0)
850 && ((sig_n_prime256.w[1] < sig_y.w[1])
851 || (sig_n_prime256.w[1] == sig_y.w[1]
852 && sig_n_prime256.w[0] <
853 sig_y.w[0]))) ^ ((x.w[1] & MASK_SIGN) ==
854 MASK_SIGN));
855 BID_RETURN (res);
856 }
857 __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_x - exp_y], sig_x);
858 // if positive, return whichever significand is larger
859 // (converse if negative)
860 if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
861 && (sig_n_prime192.w[0] == sig_y.w[0])) {
862 res = ((exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
863 BID_RETURN (res);
864 }
865 res = (((sig_n_prime192.w[2] == 0)
866 && ((sig_n_prime192.w[1] < sig_y.w[1])
867 || (sig_n_prime192.w[1] == sig_y.w[1]
868 && sig_n_prime192.w[0] <
869 sig_y.w[0]))) ^ ((x.w[1] & MASK_SIGN) ==
870 MASK_SIGN));
871 BID_RETURN (res);
872 }
873 // if exp_x is 33 less than exp_y, it is definitely smaller,
874 // no need for compensation
875 if (exp_y - exp_x > 33) {
876 res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
877 BID_RETURN (res);
878 }
879 if (exp_y - exp_x > 19) {
880 // adjust the y significand upwards
881 __mul_128x128_to_256 (sig_n_prime256, sig_y,
882 ten2k128[exp_y - exp_x - 20]);
883 // if x and y represent the same entities and both are negative
884 // return true iff exp_x <= exp_y
885 if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0)
886 && (sig_n_prime256.w[1] == sig_x.w[1])
887 && (sig_n_prime256.w[0] == sig_x.w[0])) {
888 res = (exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN);
889 BID_RETURN (res);
890 }
891 // values are not equal, for positive numbers return 1 if x is less than y
892 // and 0 otherwise
893 res = (((sig_n_prime256.w[3] != 0) ||
894 // if upper128 bits of compensated y are non-zero, y is bigger
895 (sig_n_prime256.w[2] != 0) ||
896 // if upper128 bits of compensated y are non-zero, y is bigger
897 (sig_n_prime256.w[1] > sig_x.w[1]) ||
898 // if compensated y is bigger, y is bigger
899 (sig_n_prime256.w[1] == sig_x.w[1]
900 && sig_n_prime256.w[0] >
901 sig_x.w[0])) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
902 BID_RETURN (res);
903 }
904 __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_y - exp_x], sig_y);
905 if ((sig_n_prime192.w[2] == 0) && (sig_n_prime192.w[1] == sig_x.w[1])
906 && (sig_n_prime192.w[0] == sig_x.w[0])) {
907 res = (exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN);
908 BID_RETURN (res);
909 }
910 res = (((sig_n_prime192.w[2] != 0) ||
911 // if upper128 bits of compensated y are non-zero, y is bigger
912 (sig_n_prime192.w[1] > sig_x.w[1]) ||
913 // if compensated y is bigger, y is bigger
914 (sig_n_prime192.w[1] == sig_x.w[1]
915 && sig_n_prime192.w[0] >
916 sig_x.w[0])) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
917 BID_RETURN (res);
918 }
919
920 #if DECIMAL_CALL_BY_REFERENCE
921 void
922 bid128_totalOrderMag (int *pres, UINT128 * px,
923 UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
924 UINT128 x = *px;
925 UINT128 y = *py;
926 #else
927 int
928 bid128_totalOrderMag (UINT128 x,
929 UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
930 #endif
931 int res;
932 int exp_x, exp_y;
933 UINT128 sig_x, sig_y, pyld_y, pyld_x;
934 UINT192 sig_n_prime192;
935 UINT256 sig_n_prime256;
936 char x_is_zero = 0, y_is_zero = 0;
937
938 BID_SWAP128 (x);
939 BID_SWAP128 (y);
940 x.w[1] = x.w[1] & 0x7fffffffffffffffull;
941 y.w[1] = y.w[1] & 0x7fffffffffffffffull;
942
943 // NaN (CASE 1)
944 // if x and y are unordered numerically because either operand is NaN
945 // (1) totalOrder(number, +NaN) is true
946 // (2) if x and y are both NaN:
947 // i) signaling < quiet for +NaN
948 // ii) lesser payload < greater payload for +NaN
949 // iii) else if bitwise identical (in canonical form), return 1
950 if ((x.w[1] & MASK_NAN) == MASK_NAN) {
951 // x is +NaN
952 // return false, unless y is +NaN also
953 if ((y.w[1] & MASK_NAN) != MASK_NAN) {
954 res = 0; // y is a number, return 0
955 BID_RETURN (res);
956 } else {
957 // x and y are both +NaN;
958 pyld_x.w[1] = x.w[1] & 0x00003fffffffffffull;
959 pyld_x.w[0] = x.w[0];
960 pyld_y.w[1] = y.w[1] & 0x00003fffffffffffull;
961 pyld_y.w[0] = y.w[0];
962 if ((pyld_x.w[1] > 0x0000314dc6448d93ull)
963 || ((pyld_x.w[1] == 0x0000314dc6448d93ull)
964 && (pyld_x.w[0] > 0x38c15b09ffffffffull))) {
965 pyld_x.w[1] = 0;
966 pyld_x.w[0] = 0;
967 }
968 if ((pyld_y.w[1] > 0x0000314dc6448d93ull)
969 || ((pyld_y.w[1] == 0x0000314dc6448d93ull)
970 && (pyld_y.w[0] > 0x38c15b09ffffffffull))) {
971 pyld_y.w[1] = 0;
972 pyld_y.w[0] = 0;
973 }
974 // if x and y are both +SNaN or both +QNaN, we have to compare payloads
975 // this statement evaluates to true if both are SNaN or QNaN
976 if (!
977 (((y.w[1] & MASK_SNAN) == MASK_SNAN) ^
978 ((x.w[1] & MASK_SNAN) == MASK_SNAN))) {
979 // it comes down to the payload. we want to return true if x has a
980 // smaller payload, or if the payloads are equal (canonical forms
981 // are bitwise identical)
982 if ((pyld_x.w[1] < pyld_y.w[1]) ||
983 ((pyld_x.w[1] == pyld_y.w[1])
984 && (pyld_x.w[0] <= pyld_y.w[0]))) {
985 res = 1;
986 } else {
987 res = 0;
988 }
989 BID_RETURN (res);
990 } else {
991 // either x = SNaN and y = QNaN or x = QNaN and y = SNaN
992 res = ((x.w[1] & MASK_SNAN) == MASK_SNAN);
993 // totalOrder (-QNaN, -SNaN) == 1
994 BID_RETURN (res);
995 }
996 }
997 } else if ((y.w[1] & MASK_NAN) == MASK_NAN) {
998 // x is certainly not NAN in this case.
999 // return true because y is positive
1000 res = 1;
1001 BID_RETURN (res);
1002 }
1003 // SIMPLE (CASE 2)
1004 // if all the bits are the same, the numbers are equal.
1005 if ((x.w[1] == y.w[1]) && (x.w[0] == y.w[0])) {
1006 res = 1;
1007 BID_RETURN (res);
1008 }
1009 // INFINITY (CASE 3)
1010 if ((x.w[1] & MASK_INF) == MASK_INF) {
1011 // x is positive infinity, only return 1 if y is positive infinity as well
1012 res = ((y.w[1] & MASK_INF) == MASK_INF);
1013 BID_RETURN (res);
1014 // (we know y has same sign as x)
1015 } else if ((y.w[1] & MASK_INF) == MASK_INF) {
1016 // x is finite, so:
1017 // since y is +inf, x<y
1018 res = 1;
1019 BID_RETURN (res);
1020 } else {
1021 ; // continue
1022 }
1023
1024 // CONVERT x
1025 sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
1026 sig_x.w[0] = x.w[0];
1027 exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
1028
1029 // CHECK IF x IS CANONICAL
1030 // 9999999999999999999999999999999999 (decimal) =
1031 // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
1032 // [0, 10^34) is the 754r supported canonical range.
1033 // If the value exceeds that, it is interpreted as 0.
1034 if ((((sig_x.w[1] > 0x0001ed09bead87c0ull) ||
1035 ((sig_x.w[1] == 0x0001ed09bead87c0ull) &&
1036 (sig_x.w[0] > 0x378d8e63ffffffffull))) &&
1037 ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) ||
1038 ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) ||
1039 ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
1040 x_is_zero = 1;
1041 // check for the case where the exponent is shifted right by 2 bits!
1042 if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) {
1043 exp_x = (x.w[1] >> 47) & 0x000000000003fffull;
1044 }
1045 }
1046 // CONVERT y
1047 exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
1048 sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
1049 sig_y.w[0] = y.w[0];
1050
1051 // CHECK IF y IS CANONICAL
1052 // 9999999999999999999999999999999999(decimal) =
1053 // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
1054 // [0, 10^34) is the 754r supported canonical range.
1055 // If the value exceeds that, it is interpreted as 0.
1056 if ((((sig_y.w[1] > 0x0001ed09bead87c0ull) ||
1057 ((sig_y.w[1] == 0x0001ed09bead87c0ull) &&
1058 (sig_y.w[0] > 0x378d8e63ffffffffull))) &&
1059 ((y.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) ||
1060 ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) ||
1061 ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
1062 y_is_zero = 1;
1063 // check for the case where the exponent is shifted right by 2 bits!
1064 if ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) {
1065 exp_y = (y.w[1] >> 47) & 0x000000000003fffull;
1066 }
1067 }
1068 // ZERO (CASE 4)
1069 if (x_is_zero && y_is_zero) {
1070 // we know that signs must be the same because we would have caught it
1071 // in case3 if signs were different
1072 // totalOrder(x,y) iff exp_x <= exp_y for positive numbers
1073 if (exp_x == exp_y) {
1074 res = 1;
1075 BID_RETURN (res);
1076 }
1077 res = (exp_x <= exp_y);
1078 BID_RETURN (res);
1079 }
1080 // if x is zero and y isn't, clearly x has the smaller payload
1081 if (x_is_zero) {
1082 res = 1;
1083 BID_RETURN (res);
1084 }
1085 // if y is zero, and x isn't, clearly y has the smaller payload
1086 if (y_is_zero) {
1087 res = 0;
1088 BID_RETURN (res);
1089 }
1090 // REDUNDANT REPRESENTATIONS (CASE 5)
1091 // if both components are either bigger or smaller
1092 if (((sig_x.w[1] > sig_y.w[1])
1093 || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
1094 && exp_x >= exp_y) {
1095 res = 0;
1096 BID_RETURN (res);
1097 }
1098 if (((sig_x.w[1] < sig_y.w[1])
1099 || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
1100 && exp_x <= exp_y) {
1101 res = 1;
1102 BID_RETURN (res);
1103 }
1104 // if |exp_x - exp_y| < 33, it comes down to the compensated significand
1105 if (exp_x > exp_y) {
1106 // if exp_x is 33 greater than exp_y, it is definitely larger,
1107 // so no need for compensation
1108 if (exp_x - exp_y > 33) {
1109 res = 0; // difference cannot be greater than 10^33
1110 BID_RETURN (res);
1111 }
1112 // otherwise adjust the x significand upwards
1113 if (exp_x - exp_y > 19) {
1114 __mul_128x128_to_256 (sig_n_prime256, sig_x,
1115 ten2k128[exp_x - exp_y - 20]);
1116 // the compensated significands are equal (ie "x and y represent the same
1117 // entities") return 1 if (negative && expx > expy) ||
1118 // (positive && expx < expy)
1119 if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0)
1120 && (sig_n_prime256.w[1] == sig_y.w[1])
1121 && (sig_n_prime256.w[0] == sig_y.w[0])) {
1122 // the case (exp_x == exp_y) cannot occur, because all bits must be
1123 // the same - would have been caught if (x == y)
1124 res = (exp_x <= exp_y);
1125 BID_RETURN (res);
1126 }
1127 // since positive, return 1 if adjusted x is smaller than y
1128 res = ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0)
1129 && ((sig_n_prime256.w[1] < sig_y.w[1])
1130 || (sig_n_prime256.w[1] == sig_y.w[1]
1131 && sig_n_prime256.w[0] < sig_y.w[0])));
1132 BID_RETURN (res);
1133 }
1134 __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_x - exp_y], sig_x);
1135 // if positive, return whichever significand is larger
1136 // (converse if negative)
1137 if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
1138 && (sig_n_prime192.w[0] == sig_y.w[0])) {
1139 res = (exp_x <= exp_y);
1140 BID_RETURN (res);
1141 }
1142 res = ((sig_n_prime192.w[2] == 0)
1143 && ((sig_n_prime192.w[1] < sig_y.w[1])
1144 || (sig_n_prime192.w[1] == sig_y.w[1]
1145 && sig_n_prime192.w[0] < sig_y.w[0])));
1146 BID_RETURN (res);
1147 }
1148 // if exp_x is 33 less than exp_y, it is definitely smaller,
1149 // no need for compensation
1150 if (exp_y - exp_x > 33) {
1151 res = 1;
1152 BID_RETURN (res);
1153 }
1154 if (exp_y - exp_x > 19) {
1155 // adjust the y significand upwards
1156 __mul_128x128_to_256 (sig_n_prime256, sig_y,
1157 ten2k128[exp_y - exp_x - 20]);
1158 if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0)
1159 && (sig_n_prime256.w[1] == sig_x.w[1])
1160 && (sig_n_prime256.w[0] == sig_x.w[0])) {
1161 res = (exp_x <= exp_y);
1162 BID_RETURN (res);
1163 }
1164 // values are not equal, for positive numbers return 1 if x is less than y
1165 // and 0 otherwise
1166 res = ((sig_n_prime256.w[3] != 0) ||
1167 // if upper128 bits of compensated y are non-zero, y is bigger
1168 (sig_n_prime256.w[2] != 0) ||
1169 // if upper128 bits of compensated y are non-zero, y is bigger
1170 (sig_n_prime256.w[1] > sig_x.w[1]) ||
1171 // if compensated y is bigger, y is bigger
1172 (sig_n_prime256.w[1] == sig_x.w[1]
1173 && sig_n_prime256.w[0] > sig_x.w[0]));
1174 BID_RETURN (res);
1175 }
1176 __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_y - exp_x], sig_y);
1177 if ((sig_n_prime192.w[2] == 0) && (sig_n_prime192.w[1] == sig_x.w[1])
1178 && (sig_n_prime192.w[0] == sig_x.w[0])) {
1179 res = (exp_x <= exp_y);
1180 BID_RETURN (res);
1181 }
1182 res = ((sig_n_prime192.w[2] != 0) ||
1183 // if upper128 bits of compensated y are non-zero, y is bigger
1184 (sig_n_prime192.w[1] > sig_x.w[1]) ||
1185 // if compensated y is bigger, y is bigger
1186 (sig_n_prime192.w[1] == sig_x.w[1]
1187 && sig_n_prime192.w[0] > sig_x.w[0]));
1188 BID_RETURN (res);
1189 }
1190
1191 #if DECIMAL_CALL_BY_REFERENCE
1192 void
1193 bid128_radix (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
1194 UINT128 x = *px;
1195 #else
1196 int
1197 bid128_radix (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
1198 #endif
1199 int res;
1200 if (x.w[LOW_128W]) // dummy test
1201 res = 10;
1202 else
1203 res = 10;
1204 BID_RETURN (res);
1205 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org