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 /*****************************************************************************
27 * BID64 minimum function - returns greater of two numbers
28 *****************************************************************************/
29
30 static const UINT64 mult_factor[16] = {
31 1ull, 10ull, 100ull, 1000ull,
32 10000ull, 100000ull, 1000000ull, 10000000ull,
33 100000000ull, 1000000000ull, 10000000000ull, 100000000000ull,
34 1000000000000ull, 10000000000000ull,
35 100000000000000ull, 1000000000000000ull
36 };
37
38 #if DECIMAL_CALL_BY_REFERENCE
39 void
40 bid64_minnum (UINT64 * pres, UINT64 * px, UINT64 * py _EXC_FLAGS_PARAM) {
41 UINT64 x = *px;
42 UINT64 y = *py;
43 #else
44 UINT64
45 bid64_minnum (UINT64 x, UINT64 y _EXC_FLAGS_PARAM) {
46 #endif
47
48 UINT64 res;
49 int exp_x, exp_y;
50 UINT64 sig_x, sig_y;
51 UINT128 sig_n_prime;
52 char x_is_zero = 0, y_is_zero = 0;
53
54 // check for non-canonical x
55 if ((x & MASK_NAN) == MASK_NAN) { // x is NaN
56 x = x & 0xfe03ffffffffffffull; // clear G6-G12
57 if ((x & 0x0003ffffffffffffull) > 999999999999999ull) {
58 x = x & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
59 }
60 } else if ((x & MASK_INF) == MASK_INF) { // check for Infinity
61 x = x & (MASK_SIGN | MASK_INF);
62 } else { // x is not special
63 // check for non-canonical values - treated as zero
64 if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
65 // if the steering bits are 11, then the exponent is G[0:w+1]
66 if (((x & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >
67 9999999999999999ull) {
68 // non-canonical
69 x = (x & MASK_SIGN) | ((x & MASK_BINARY_EXPONENT2) << 2);
70 } // else canonical
71 } // else canonical
72 }
73
74 // check for non-canonical y
75 if ((y & MASK_NAN) == MASK_NAN) { // y is NaN
76 y = y & 0xfe03ffffffffffffull; // clear G6-G12
77 if ((y & 0x0003ffffffffffffull) > 999999999999999ull) {
78 y = y & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
79 }
80 } else if ((y & MASK_INF) == MASK_INF) { // check for Infinity
81 y = y & (MASK_SIGN | MASK_INF);
82 } else { // y is not special
83 // check for non-canonical values - treated as zero
84 if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
85 // if the steering bits are 11, then the exponent is G[0:w+1]
86 if (((y & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >
87 9999999999999999ull) {
88 // non-canonical
89 y = (y & MASK_SIGN) | ((y & MASK_BINARY_EXPONENT2) << 2);
90 } // else canonical
91 } // else canonical
92 }
93
94 // NaN (CASE1)
95 if ((x & MASK_NAN) == MASK_NAN) { // x is NAN
96 if ((x & MASK_SNAN) == MASK_SNAN) { // x is SNaN
97 // if x is SNAN, then return quiet (x)
98 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
99 x = x & 0xfdffffffffffffffull; // quietize x
100 res = x;
101 } else { // x is QNaN
102 if ((y & MASK_NAN) == MASK_NAN) { // y is NAN
103 if ((y & MASK_SNAN) == MASK_SNAN) { // y is SNAN
104 *pfpsf |= INVALID_EXCEPTION; // set invalid flag
105 }
106 res = x;
107 } else {
108 res = y;
109 }
110 }
111 BID_RETURN (res);
112 } else if ((y & MASK_NAN) == MASK_NAN) { // y is NaN, but x is not
113 if ((y & MASK_SNAN) == MASK_SNAN) {
114 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
115 y = y & 0xfdffffffffffffffull; // quietize y
116 res = y;
117 } else {
118 // will return x (which is not NaN)
119 res = x;
120 }
121 BID_RETURN (res);
122 }
123 // SIMPLE (CASE2)
124 // if all the bits are the same, these numbers are equal, return either number
125 if (x == y) {
126 res = x;
127 BID_RETURN (res);
128 }
129 // INFINITY (CASE3)
130 if ((x & MASK_INF) == MASK_INF) {
131 // if x is neg infinity, there is no way it is greater than y, return x
132 if (((x & MASK_SIGN) == MASK_SIGN)) {
133 res = x;
134 BID_RETURN (res);
135 }
136 // x is pos infinity, return y
137 else {
138 res = y;
139 BID_RETURN (res);
140 }
141 } else if ((y & MASK_INF) == MASK_INF) {
142 // x is finite, so if y is positive infinity, then x is less, return y
143 // if y is negative infinity, then x is greater, return x
144 res = ((y & MASK_SIGN) == MASK_SIGN) ? y : x;
145 BID_RETURN (res);
146 }
147 // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
148 if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
149 exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
150 sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
151 } else {
152 exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
153 sig_x = (x & MASK_BINARY_SIG1);
154 }
155
156 // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
157 if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
158 exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
159 sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
160 } else {
161 exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
162 sig_y = (y & MASK_BINARY_SIG1);
163 }
164
165 // ZERO (CASE4)
166 // some properties:
167 // (+ZERO == -ZERO) => therefore
168 // ignore the sign, and neither number is greater
169 // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
170 // ignore the exponent field
171 // (Any non-canonical # is considered 0)
172 if (sig_x == 0) {
173 x_is_zero = 1;
174 }
175 if (sig_y == 0) {
176 y_is_zero = 1;
177 }
178
179 if (x_is_zero && y_is_zero) {
180 // if both numbers are zero, neither is greater => return either
181 res = y;
182 BID_RETURN (res);
183 } else if (x_is_zero) {
184 // is x is zero, it is greater if Y is negative
185 res = ((y & MASK_SIGN) == MASK_SIGN) ? y : x;
186 BID_RETURN (res);
187 } else if (y_is_zero) {
188 // is y is zero, X is greater if it is positive
189 res = ((x & MASK_SIGN) != MASK_SIGN) ? y : x;;
190 BID_RETURN (res);
191 }
192 // OPPOSITE SIGN (CASE5)
193 // now, if the sign bits differ, x is greater if y is negative
194 if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
195 res = ((y & MASK_SIGN) == MASK_SIGN) ? y : x;
196 BID_RETURN (res);
197 }
198 // REDUNDANT REPRESENTATIONS (CASE6)
199
200 // if both components are either bigger or smaller,
201 // it is clear what needs to be done
202 if (sig_x > sig_y && exp_x >= exp_y) {
203 res = ((x & MASK_SIGN) != MASK_SIGN) ? y : x;
204 BID_RETURN (res);
205 }
206 if (sig_x < sig_y && exp_x <= exp_y) {
207 res = ((x & MASK_SIGN) == MASK_SIGN) ? y : x;
208 BID_RETURN (res);
209 }
210 // if exp_x is 15 greater than exp_y, no need for compensation
211 if (exp_x - exp_y > 15) {
212 res = ((x & MASK_SIGN) != MASK_SIGN) ? y : x; // difference cannot be >10^15
213 BID_RETURN (res);
214 }
215 // if exp_x is 15 less than exp_y, no need for compensation
216 if (exp_y - exp_x > 15) {
217 res = ((x & MASK_SIGN) == MASK_SIGN) ? y : x;
218 BID_RETURN (res);
219 }
220 // if |exp_x - exp_y| < 15, it comes down to the compensated significand
221 if (exp_x > exp_y) { // to simplify the loop below,
222
223 // otherwise adjust the x significand upwards
224 __mul_64x64_to_128MACH (sig_n_prime, sig_x,
225 mult_factor[exp_x - exp_y]);
226 // if postitive, return whichever significand is larger
227 // (converse if negative)
228 if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
229 res = y;
230 BID_RETURN (res);
231 }
232
233 res = (((sig_n_prime.w[1] > 0)
234 || sig_n_prime.w[0] > sig_y) ^ ((x & MASK_SIGN) ==
235 MASK_SIGN)) ? y : x;
236 BID_RETURN (res);
237 }
238 // adjust the y significand upwards
239 __mul_64x64_to_128MACH (sig_n_prime, sig_y,
240 mult_factor[exp_y - exp_x]);
241
242 // if postitive, return whichever significand is larger (converse if negative)
243 if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
244 res = y;
245 BID_RETURN (res);
246 }
247 res = (((sig_n_prime.w[1] == 0)
248 && (sig_x > sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
249 MASK_SIGN)) ? y : x;
250 BID_RETURN (res);
251 }
252
253 /*****************************************************************************
254 * BID64 minimum magnitude function - returns greater of two numbers
255 *****************************************************************************/
256
257 #if DECIMAL_CALL_BY_REFERENCE
258 void
259 bid64_minnum_mag (UINT64 * pres, UINT64 * px,
260 UINT64 * py _EXC_FLAGS_PARAM) {
261 UINT64 x = *px;
262 UINT64 y = *py;
263 #else
264 UINT64
265 bid64_minnum_mag (UINT64 x, UINT64 y _EXC_FLAGS_PARAM) {
266 #endif
267
268 UINT64 res;
269 int exp_x, exp_y;
270 UINT64 sig_x, sig_y;
271 UINT128 sig_n_prime;
272
273 // check for non-canonical x
274 if ((x & MASK_NAN) == MASK_NAN) { // x is NaN
275 x = x & 0xfe03ffffffffffffull; // clear G6-G12
276 if ((x & 0x0003ffffffffffffull) > 999999999999999ull) {
277 x = x & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
278 }
279 } else if ((x & MASK_INF) == MASK_INF) { // check for Infinity
280 x = x & (MASK_SIGN | MASK_INF);
281 } else { // x is not special
282 // check for non-canonical values - treated as zero
283 if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
284 // if the steering bits are 11, then the exponent is G[0:w+1]
285 if (((x & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >
286 9999999999999999ull) {
287 // non-canonical
288 x = (x & MASK_SIGN) | ((x & MASK_BINARY_EXPONENT2) << 2);
289 } // else canonical
290 } // else canonical
291 }
292
293 // check for non-canonical y
294 if ((y & MASK_NAN) == MASK_NAN) { // y is NaN
295 y = y & 0xfe03ffffffffffffull; // clear G6-G12
296 if ((y & 0x0003ffffffffffffull) > 999999999999999ull) {
297 y = y & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
298 }
299 } else if ((y & MASK_INF) == MASK_INF) { // check for Infinity
300 y = y & (MASK_SIGN | MASK_INF);
301 } else { // y is not special
302 // check for non-canonical values - treated as zero
303 if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
304 // if the steering bits are 11, then the exponent is G[0:w+1]
305 if (((y & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >
306 9999999999999999ull) {
307 // non-canonical
308 y = (y & MASK_SIGN) | ((y & MASK_BINARY_EXPONENT2) << 2);
309 } // else canonical
310 } // else canonical
311 }
312
313 // NaN (CASE1)
314 if ((x & MASK_NAN) == MASK_NAN) { // x is NAN
315 if ((x & MASK_SNAN) == MASK_SNAN) { // x is SNaN
316 // if x is SNAN, then return quiet (x)
317 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
318 x = x & 0xfdffffffffffffffull; // quietize x
319 res = x;
320 } else { // x is QNaN
321 if ((y & MASK_NAN) == MASK_NAN) { // y is NAN
322 if ((y & MASK_SNAN) == MASK_SNAN) { // y is SNAN
323 *pfpsf |= INVALID_EXCEPTION; // set invalid flag
324 }
325 res = x;
326 } else {
327 res = y;
328 }
329 }
330 BID_RETURN (res);
331 } else if ((y & MASK_NAN) == MASK_NAN) { // y is NaN, but x is not
332 if ((y & MASK_SNAN) == MASK_SNAN) {
333 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
334 y = y & 0xfdffffffffffffffull; // quietize y
335 res = y;
336 } else {
337 // will return x (which is not NaN)
338 res = x;
339 }
340 BID_RETURN (res);
341 }
342 // SIMPLE (CASE2)
343 // if all the bits are the same, these numbers are equal, return either number
344 if (x == y) {
345 res = x;
346 BID_RETURN (res);
347 }
348 // INFINITY (CASE3)
349 if ((x & MASK_INF) == MASK_INF) {
350 // x is infinity, its magnitude is greater than or equal to y
351 // return x only if y is infinity and x is negative
352 res = ((x & MASK_SIGN) == MASK_SIGN
353 && (y & MASK_INF) == MASK_INF) ? x : y;
354 BID_RETURN (res);
355 } else if ((y & MASK_INF) == MASK_INF) {
356 // y is infinity, then it must be greater in magnitude, return x
357 res = x;
358 BID_RETURN (res);
359 }
360 // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
361 if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
362 exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
363 sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
364 } else {
365 exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
366 sig_x = (x & MASK_BINARY_SIG1);
367 }
368
369 // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
370 if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
371 exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
372 sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
373 } else {
374 exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
375 sig_y = (y & MASK_BINARY_SIG1);
376 }
377
378 // ZERO (CASE4)
379 // some properties:
380 // (+ZERO == -ZERO) => therefore
381 // ignore the sign, and neither number is greater
382 // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
383 // ignore the exponent field
384 // (Any non-canonical # is considered 0)
385 if (sig_x == 0) {
386 res = x; // x_is_zero, its magnitude must be smaller than y
387 BID_RETURN (res);
388 }
389 if (sig_y == 0) {
390 res = y; // y_is_zero, its magnitude must be smaller than x
391 BID_RETURN (res);
392 }
393 // REDUNDANT REPRESENTATIONS (CASE6)
394 // if both components are either bigger or smaller,
395 // it is clear what needs to be done
396 if (sig_x > sig_y && exp_x >= exp_y) {
397 res = y;
398 BID_RETURN (res);
399 }
400 if (sig_x < sig_y && exp_x <= exp_y) {
401 res = x;
402 BID_RETURN (res);
403 }
404 // if exp_x is 15 greater than exp_y, no need for compensation
405 if (exp_x - exp_y > 15) {
406 res = y; // difference cannot be greater than 10^15
407 BID_RETURN (res);
408 }
409 // if exp_x is 15 less than exp_y, no need for compensation
410 if (exp_y - exp_x > 15) {
411 res = x;
412 BID_RETURN (res);
413 }
414 // if |exp_x - exp_y| < 15, it comes down to the compensated significand
415 if (exp_x > exp_y) { // to simplify the loop below,
416 // otherwise adjust the x significand upwards
417 __mul_64x64_to_128MACH (sig_n_prime, sig_x,
418 mult_factor[exp_x - exp_y]);
419 // now, sig_n_prime has: sig_x * 10^(exp_x-exp_y), this is
420 // the compensated signif.
421 if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
422 // two numbers are equal, return minNum(x,y)
423 res = ((y & MASK_SIGN) == MASK_SIGN) ? y : x;
424 BID_RETURN (res);
425 }
426 // now, if compensated_x (sig_n_prime) is greater than y, return y,
427 // otherwise return x
428 res = ((sig_n_prime.w[1] != 0) || sig_n_prime.w[0] > sig_y) ? y : x;
429 BID_RETURN (res);
430 }
431 // exp_y must be greater than exp_x, thus adjust the y significand upwards
432 __mul_64x64_to_128MACH (sig_n_prime, sig_y,
433 mult_factor[exp_y - exp_x]);
434
435 if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
436 res = ((y & MASK_SIGN) == MASK_SIGN) ? y : x;
437 // two numbers are equal, return either
438 BID_RETURN (res);
439 }
440
441 res = ((sig_n_prime.w[1] == 0) && (sig_x > sig_n_prime.w[0])) ? y : x;
442 BID_RETURN (res);
443 }
444
445 /*****************************************************************************
446 * BID64 maximum function - returns greater of two numbers
447 *****************************************************************************/
448
449 #if DECIMAL_CALL_BY_REFERENCE
450 void
451 bid64_maxnum (UINT64 * pres, UINT64 * px, UINT64 * py _EXC_FLAGS_PARAM) {
452 UINT64 x = *px;
453 UINT64 y = *py;
454 #else
455 UINT64
456 bid64_maxnum (UINT64 x, UINT64 y _EXC_FLAGS_PARAM) {
457 #endif
458
459 UINT64 res;
460 int exp_x, exp_y;
461 UINT64 sig_x, sig_y;
462 UINT128 sig_n_prime;
463 char x_is_zero = 0, y_is_zero = 0;
464
465 // check for non-canonical x
466 if ((x & MASK_NAN) == MASK_NAN) { // x is NaN
467 x = x & 0xfe03ffffffffffffull; // clear G6-G12
468 if ((x & 0x0003ffffffffffffull) > 999999999999999ull) {
469 x = x & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
470 }
471 } else if ((x & MASK_INF) == MASK_INF) { // check for Infinity
472 x = x & (MASK_SIGN | MASK_INF);
473 } else { // x is not special
474 // check for non-canonical values - treated as zero
475 if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
476 // if the steering bits are 11, then the exponent is G[0:w+1]
477 if (((x & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >
478 9999999999999999ull) {
479 // non-canonical
480 x = (x & MASK_SIGN) | ((x & MASK_BINARY_EXPONENT2) << 2);
481 } // else canonical
482 } // else canonical
483 }
484
485 // check for non-canonical y
486 if ((y & MASK_NAN) == MASK_NAN) { // y is NaN
487 y = y & 0xfe03ffffffffffffull; // clear G6-G12
488 if ((y & 0x0003ffffffffffffull) > 999999999999999ull) {
489 y = y & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
490 }
491 } else if ((y & MASK_INF) == MASK_INF) { // check for Infinity
492 y = y & (MASK_SIGN | MASK_INF);
493 } else { // y is not special
494 // check for non-canonical values - treated as zero
495 if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
496 // if the steering bits are 11, then the exponent is G[0:w+1]
497 if (((y & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >
498 9999999999999999ull) {
499 // non-canonical
500 y = (y & MASK_SIGN) | ((y & MASK_BINARY_EXPONENT2) << 2);
501 } // else canonical
502 } // else canonical
503 }
504
505 // NaN (CASE1)
506 if ((x & MASK_NAN) == MASK_NAN) { // x is NAN
507 if ((x & MASK_SNAN) == MASK_SNAN) { // x is SNaN
508 // if x is SNAN, then return quiet (x)
509 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
510 x = x & 0xfdffffffffffffffull; // quietize x
511 res = x;
512 } else { // x is QNaN
513 if ((y & MASK_NAN) == MASK_NAN) { // y is NAN
514 if ((y & MASK_SNAN) == MASK_SNAN) { // y is SNAN
515 *pfpsf |= INVALID_EXCEPTION; // set invalid flag
516 }
517 res = x;
518 } else {
519 res = y;
520 }
521 }
522 BID_RETURN (res);
523 } else if ((y & MASK_NAN) == MASK_NAN) { // y is NaN, but x is not
524 if ((y & MASK_SNAN) == MASK_SNAN) {
525 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
526 y = y & 0xfdffffffffffffffull; // quietize y
527 res = y;
528 } else {
529 // will return x (which is not NaN)
530 res = x;
531 }
532 BID_RETURN (res);
533 }
534 // SIMPLE (CASE2)
535 // if all the bits are the same, these numbers are equal (not Greater).
536 if (x == y) {
537 res = x;
538 BID_RETURN (res);
539 }
540 // INFINITY (CASE3)
541 if ((x & MASK_INF) == MASK_INF) {
542 // if x is neg infinity, there is no way it is greater than y, return y
543 // x is pos infinity, it is greater, unless y is positive infinity =>
544 // return y!=pos_infinity
545 if (((x & MASK_SIGN) == MASK_SIGN)) {
546 res = y;
547 BID_RETURN (res);
548 } else {
549 res = (((y & MASK_INF) != MASK_INF)
550 || ((y & MASK_SIGN) == MASK_SIGN)) ? x : y;
551 BID_RETURN (res);
552 }
553 } else if ((y & MASK_INF) == MASK_INF) {
554 // x is finite, so if y is positive infinity, then x is less, return y
555 // if y is negative infinity, then x is greater, return x
556 res = ((y & MASK_SIGN) == MASK_SIGN) ? x : y;
557 BID_RETURN (res);
558 }
559 // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
560 if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
561 exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
562 sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
563 } else {
564 exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
565 sig_x = (x & MASK_BINARY_SIG1);
566 }
567
568 // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
569 if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
570 exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
571 sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
572 } else {
573 exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
574 sig_y = (y & MASK_BINARY_SIG1);
575 }
576
577 // ZERO (CASE4)
578 // some properties:
579 // (+ZERO == -ZERO) => therefore
580 // ignore the sign, and neither number is greater
581 // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
582 // ignore the exponent field
583 // (Any non-canonical # is considered 0)
584 if (sig_x == 0) {
585 x_is_zero = 1;
586 }
587 if (sig_y == 0) {
588 y_is_zero = 1;
589 }
590
591 if (x_is_zero && y_is_zero) {
592 // if both numbers are zero, neither is greater => return NOTGREATERTHAN
593 res = y;
594 BID_RETURN (res);
595 } else if (x_is_zero) {
596 // is x is zero, it is greater if Y is negative
597 res = ((y & MASK_SIGN) == MASK_SIGN) ? x : y;
598 BID_RETURN (res);
599 } else if (y_is_zero) {
600 // is y is zero, X is greater if it is positive
601 res = ((x & MASK_SIGN) != MASK_SIGN) ? x : y;;
602 BID_RETURN (res);
603 }
604 // OPPOSITE SIGN (CASE5)
605 // now, if the sign bits differ, x is greater if y is negative
606 if (((x ^ y) & MASK_SIGN) == MASK_SIGN) {
607 res = ((y & MASK_SIGN) == MASK_SIGN) ? x : y;
608 BID_RETURN (res);
609 }
610 // REDUNDANT REPRESENTATIONS (CASE6)
611
612 // if both components are either bigger or smaller,
613 // it is clear what needs to be done
614 if (sig_x > sig_y && exp_x >= exp_y) {
615 res = ((x & MASK_SIGN) != MASK_SIGN) ? x : y;
616 BID_RETURN (res);
617 }
618 if (sig_x < sig_y && exp_x <= exp_y) {
619 res = ((x & MASK_SIGN) == MASK_SIGN) ? x : y;
620 BID_RETURN (res);
621 }
622 // if exp_x is 15 greater than exp_y, no need for compensation
623 if (exp_x - exp_y > 15) {
624 res = ((x & MASK_SIGN) != MASK_SIGN) ? x : y;
625 // difference cannot be > 10^15
626 BID_RETURN (res);
627 }
628 // if exp_x is 15 less than exp_y, no need for compensation
629 if (exp_y - exp_x > 15) {
630 res = ((x & MASK_SIGN) == MASK_SIGN) ? x : y;
631 BID_RETURN (res);
632 }
633 // if |exp_x - exp_y| < 15, it comes down to the compensated significand
634 if (exp_x > exp_y) { // to simplify the loop below,
635 // otherwise adjust the x significand upwards
636 __mul_64x64_to_128MACH (sig_n_prime, sig_x,
637 mult_factor[exp_x - exp_y]);
638 // if postitive, return whichever significand is larger
639 // (converse if negative)
640 if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
641 res = y;
642 BID_RETURN (res);
643 }
644 res = (((sig_n_prime.w[1] > 0)
645 || sig_n_prime.w[0] > sig_y) ^ ((x & MASK_SIGN) ==
646 MASK_SIGN)) ? x : y;
647 BID_RETURN (res);
648 }
649 // adjust the y significand upwards
650 __mul_64x64_to_128MACH (sig_n_prime, sig_y,
651 mult_factor[exp_y - exp_x]);
652
653 // if postitive, return whichever significand is larger (converse if negative)
654 if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
655 res = y;
656 BID_RETURN (res);
657 }
658 res = (((sig_n_prime.w[1] == 0)
659 && (sig_x > sig_n_prime.w[0])) ^ ((x & MASK_SIGN) ==
660 MASK_SIGN)) ? x : y;
661 BID_RETURN (res);
662 }
663
664 /*****************************************************************************
665 * BID64 maximum magnitude function - returns greater of two numbers
666 *****************************************************************************/
667
668 #if DECIMAL_CALL_BY_REFERENCE
669 void
670 bid64_maxnum_mag (UINT64 * pres, UINT64 * px,
671 UINT64 * py _EXC_FLAGS_PARAM) {
672 UINT64 x = *px;
673 UINT64 y = *py;
674 #else
675 UINT64
676 bid64_maxnum_mag (UINT64 x, UINT64 y _EXC_FLAGS_PARAM) {
677 #endif
678
679 UINT64 res;
680 int exp_x, exp_y;
681 UINT64 sig_x, sig_y;
682 UINT128 sig_n_prime;
683
684 // check for non-canonical x
685 if ((x & MASK_NAN) == MASK_NAN) { // x is NaN
686 x = x & 0xfe03ffffffffffffull; // clear G6-G12
687 if ((x & 0x0003ffffffffffffull) > 999999999999999ull) {
688 x = x & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
689 }
690 } else if ((x & MASK_INF) == MASK_INF) { // check for Infinity
691 x = x & (MASK_SIGN | MASK_INF);
692 } else { // x is not special
693 // check for non-canonical values - treated as zero
694 if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
695 // if the steering bits are 11, then the exponent is G[0:w+1]
696 if (((x & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >
697 9999999999999999ull) {
698 // non-canonical
699 x = (x & MASK_SIGN) | ((x & MASK_BINARY_EXPONENT2) << 2);
700 } // else canonical
701 } // else canonical
702 }
703
704 // check for non-canonical y
705 if ((y & MASK_NAN) == MASK_NAN) { // y is NaN
706 y = y & 0xfe03ffffffffffffull; // clear G6-G12
707 if ((y & 0x0003ffffffffffffull) > 999999999999999ull) {
708 y = y & 0xfe00000000000000ull; // clear G6-G12 and the payload bits
709 }
710 } else if ((y & MASK_INF) == MASK_INF) { // check for Infinity
711 y = y & (MASK_SIGN | MASK_INF);
712 } else { // y is not special
713 // check for non-canonical values - treated as zero
714 if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
715 // if the steering bits are 11, then the exponent is G[0:w+1]
716 if (((y & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >
717 9999999999999999ull) {
718 // non-canonical
719 y = (y & MASK_SIGN) | ((y & MASK_BINARY_EXPONENT2) << 2);
720 } // else canonical
721 } // else canonical
722 }
723
724 // NaN (CASE1)
725 if ((x & MASK_NAN) == MASK_NAN) { // x is NAN
726 if ((x & MASK_SNAN) == MASK_SNAN) { // x is SNaN
727 // if x is SNAN, then return quiet (x)
728 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
729 x = x & 0xfdffffffffffffffull; // quietize x
730 res = x;
731 } else { // x is QNaN
732 if ((y & MASK_NAN) == MASK_NAN) { // y is NAN
733 if ((y & MASK_SNAN) == MASK_SNAN) { // y is SNAN
734 *pfpsf |= INVALID_EXCEPTION; // set invalid flag
735 }
736 res = x;
737 } else {
738 res = y;
739 }
740 }
741 BID_RETURN (res);
742 } else if ((y & MASK_NAN) == MASK_NAN) { // y is NaN, but x is not
743 if ((y & MASK_SNAN) == MASK_SNAN) {
744 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
745 y = y & 0xfdffffffffffffffull; // quietize y
746 res = y;
747 } else {
748 // will return x (which is not NaN)
749 res = x;
750 }
751 BID_RETURN (res);
752 }
753 // SIMPLE (CASE2)
754 // if all the bits are the same, these numbers are equal, return either number
755 if (x == y) {
756 res = x;
757 BID_RETURN (res);
758 }
759 // INFINITY (CASE3)
760 if ((x & MASK_INF) == MASK_INF) {
761 // x is infinity, its magnitude is greater than or equal to y
762 // return y as long as x isn't negative infinity
763 res = ((x & MASK_SIGN) == MASK_SIGN
764 && (y & MASK_INF) == MASK_INF) ? y : x;
765 BID_RETURN (res);
766 } else if ((y & MASK_INF) == MASK_INF) {
767 // y is infinity, then it must be greater in magnitude
768 res = y;
769 BID_RETURN (res);
770 }
771 // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
772 if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
773 exp_x = (x & MASK_BINARY_EXPONENT2) >> 51;
774 sig_x = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
775 } else {
776 exp_x = (x & MASK_BINARY_EXPONENT1) >> 53;
777 sig_x = (x & MASK_BINARY_SIG1);
778 }
779
780 // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>
781 if ((y & MASK_STEERING_BITS) == MASK_STEERING_BITS) {
782 exp_y = (y & MASK_BINARY_EXPONENT2) >> 51;
783 sig_y = (y & MASK_BINARY_SIG2) | MASK_BINARY_OR2;
784 } else {
785 exp_y = (y & MASK_BINARY_EXPONENT1) >> 53;
786 sig_y = (y & MASK_BINARY_SIG1);
787 }
788
789 // ZERO (CASE4)
790 // some properties:
791 // (+ZERO == -ZERO) => therefore
792 // ignore the sign, and neither number is greater
793 // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
794 // ignore the exponent field
795 // (Any non-canonical # is considered 0)
796 if (sig_x == 0) {
797 res = y; // x_is_zero, its magnitude must be smaller than y
798 BID_RETURN (res);
799 }
800 if (sig_y == 0) {
801 res = x; // y_is_zero, its magnitude must be smaller than x
802 BID_RETURN (res);
803 }
804 // REDUNDANT REPRESENTATIONS (CASE6)
805 // if both components are either bigger or smaller,
806 // it is clear what needs to be done
807 if (sig_x > sig_y && exp_x >= exp_y) {
808 res = x;
809 BID_RETURN (res);
810 }
811 if (sig_x < sig_y && exp_x <= exp_y) {
812 res = y;
813 BID_RETURN (res);
814 }
815 // if exp_x is 15 greater than exp_y, no need for compensation
816 if (exp_x - exp_y > 15) {
817 res = x; // difference cannot be greater than 10^15
818 BID_RETURN (res);
819 }
820 // if exp_x is 15 less than exp_y, no need for compensation
821 if (exp_y - exp_x > 15) {
822 res = y;
823 BID_RETURN (res);
824 }
825 // if |exp_x - exp_y| < 15, it comes down to the compensated significand
826 if (exp_x > exp_y) { // to simplify the loop below,
827 // otherwise adjust the x significand upwards
828 __mul_64x64_to_128MACH (sig_n_prime, sig_x,
829 mult_factor[exp_x - exp_y]);
830 // now, sig_n_prime has: sig_x * 10^(exp_x-exp_y),
831 // this is the compensated signif.
832 if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
833 // two numbers are equal, return maxNum(x,y)
834 res = ((y & MASK_SIGN) == MASK_SIGN) ? x : y;
835 BID_RETURN (res);
836 }
837 // now, if compensated_x (sig_n_prime) is greater than y return y,
838 // otherwise return x
839 res = ((sig_n_prime.w[1] != 0) || sig_n_prime.w[0] > sig_y) ? x : y;
840 BID_RETURN (res);
841 }
842 // exp_y must be greater than exp_x, thus adjust the y significand upwards
843 __mul_64x64_to_128MACH (sig_n_prime, sig_y,
844 mult_factor[exp_y - exp_x]);
845
846 if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
847 res = ((y & MASK_SIGN) == MASK_SIGN) ? x : y;
848 // two numbers are equal, return either
849 BID_RETURN (res);
850 }
851
852 res = ((sig_n_prime.w[1] == 0) && (sig_x > sig_n_prime.w[0])) ? x : y;
853 BID_RETURN (res);
854 }