|
0
|
1 /* Copyright (C) 2007, 2009 Free Software Foundation, Inc.
|
|
|
2
|
|
|
3 This file is part of GCC.
|
|
|
4
|
|
|
5 GCC is free software; you can redistribute it and/or modify it under
|
|
|
6 the terms of the GNU General Public License as published by the Free
|
|
|
7 Software Foundation; either version 3, or (at your option) any later
|
|
|
8 version.
|
|
|
9
|
|
|
10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
13 for more details.
|
|
|
14
|
|
|
15 Under Section 7 of GPL version 3, you are granted additional
|
|
|
16 permissions described in the GCC Runtime Library Exception, version
|
|
|
17 3.1, as published by the Free Software Foundation.
|
|
|
18
|
|
|
19 You should have received a copy of the GNU General Public License and
|
|
|
20 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
21 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
22 <http://www.gnu.org/licenses/>. */
|
|
|
23
|
|
|
24 #define BID_128RES
|
|
|
25 #include "bid_internal.h"
|
|
|
26
|
|
|
27 /*****************************************************************************
|
|
|
28 * BID128 minimum number
|
|
|
29 *****************************************************************************/
|
|
|
30
|
|
|
31 #if DECIMAL_CALL_BY_REFERENCE
|
|
|
32 void
|
|
|
33 bid128_minnum (UINT128 * pres, UINT128 * px,
|
|
|
34 UINT128 * py _EXC_FLAGS_PARAM) {
|
|
|
35 UINT128 x = *px;
|
|
|
36 UINT128 y = *py;
|
|
|
37 #else
|
|
|
38 UINT128
|
|
|
39 bid128_minnum (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
|
|
|
40 #endif
|
|
|
41
|
|
|
42 UINT128 res;
|
|
|
43 int exp_x, exp_y;
|
|
|
44 int diff;
|
|
|
45 UINT128 sig_x, sig_y;
|
|
|
46 UINT192 sig_n_prime192;
|
|
|
47 UINT256 sig_n_prime256;
|
|
|
48 char x_is_zero = 0, y_is_zero = 0;
|
|
|
49
|
|
|
50 BID_SWAP128 (x);
|
|
|
51 BID_SWAP128 (y);
|
|
|
52
|
|
|
53 // check for non-canonical x
|
|
|
54 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
|
|
|
55 x.w[1] = x.w[1] & 0xfe003fffffffffffull; // clear out G[6]-G[16]
|
|
|
56 // check for non-canonical NaN payload
|
|
|
57 if (((x.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
|
|
|
58 (((x.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) &&
|
|
|
59 (x.w[0] > 0x38c15b09ffffffffull))) {
|
|
|
60 x.w[1] = x.w[1] & 0xffffc00000000000ull;
|
|
|
61 x.w[0] = 0x0ull;
|
|
|
62 }
|
|
|
63 } else if ((x.w[1] & MASK_ANY_INF) == MASK_INF) { // x = inf
|
|
|
64 x.w[1] = x.w[1] & (MASK_SIGN | MASK_INF);
|
|
|
65 x.w[0] = 0x0ull;
|
|
|
66 } else { // x is not special
|
|
|
67 // check for non-canonical values - treated as zero
|
|
|
68 if ((x.w[1] & MASK_STEERING_BITS) == MASK_STEERING_BITS) { // G0_G1=11
|
|
|
69 // non-canonical
|
|
|
70 x.w[1] = (x.w[1] & MASK_SIGN) | ((x.w[1] << 2) & MASK_EXP);
|
|
|
71 x.w[0] = 0x0ull;
|
|
|
72 } else { // G0_G1 != 11
|
|
|
73 if ((x.w[1] & MASK_COEFF) > 0x0001ed09bead87c0ull ||
|
|
|
74 ((x.w[1] & MASK_COEFF) == 0x0001ed09bead87c0ull
|
|
|
75 && x.w[0] > 0x378d8e63ffffffffull)) {
|
|
|
76 // x is non-canonical if coefficient is larger than 10^34 -1
|
|
|
77 x.w[1] = (x.w[1] & MASK_SIGN) | (x.w[1] & MASK_EXP);
|
|
|
78 x.w[0] = 0x0ull;
|
|
|
79 } else { // canonical
|
|
|
80 ;
|
|
|
81 }
|
|
|
82 }
|
|
|
83 }
|
|
|
84 // check for non-canonical y
|
|
|
85 if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NAN
|
|
|
86 y.w[1] = y.w[1] & 0xfe003fffffffffffull; // clear out G[6]-G[16]
|
|
|
87 // check for non-canonical NaN payload
|
|
|
88 if (((y.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
|
|
|
89 (((y.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) &&
|
|
|
90 (y.w[0] > 0x38c15b09ffffffffull))) {
|
|
|
91 y.w[1] = y.w[1] & 0xffffc00000000000ull;
|
|
|
92 y.w[0] = 0x0ull;
|
|
|
93 }
|
|
|
94 } else if ((y.w[1] & MASK_ANY_INF) == MASK_INF) { // y = inf
|
|
|
95 y.w[1] = y.w[1] & (MASK_SIGN | MASK_INF);
|
|
|
96 y.w[0] = 0x0ull;
|
|
|
97 } else { // y is not special
|
|
|
98 // check for non-canonical values - treated as zero
|
|
|
99 if ((y.w[1] & MASK_STEERING_BITS) == MASK_STEERING_BITS) { // G0_G1=11
|
|
|
100 // non-canonical
|
|
|
101 y.w[1] = (y.w[1] & MASK_SIGN) | ((y.w[1] << 2) & MASK_EXP);
|
|
|
102 y.w[0] = 0x0ull;
|
|
|
103 } else { // G0_G1 != 11
|
|
|
104 if ((y.w[1] & MASK_COEFF) > 0x0001ed09bead87c0ull ||
|
|
|
105 ((y.w[1] & MASK_COEFF) == 0x0001ed09bead87c0ull
|
|
|
106 && y.w[0] > 0x378d8e63ffffffffull)) {
|
|
|
107 // y is non-canonical if coefficient is larger than 10^34 -1
|
|
|
108 y.w[1] = (y.w[1] & MASK_SIGN) | (y.w[1] & MASK_EXP);
|
|
|
109 y.w[0] = 0x0ull;
|
|
|
110 } else { // canonical
|
|
|
111 ;
|
|
|
112 }
|
|
|
113 }
|
|
|
114 }
|
|
|
115
|
|
|
116 // NaN (CASE1)
|
|
|
117 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
|
|
|
118 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNaN
|
|
|
119 // if x is SNAN, then return quiet (x)
|
|
|
120 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
|
|
|
121 x.w[1] = x.w[1] & 0xfdffffffffffffffull; // quietize x
|
|
|
122 res = x;
|
|
|
123 } else { // x is QNaN
|
|
|
124 if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NAN
|
|
|
125 if ((y.w[1] & MASK_SNAN) == MASK_SNAN) { // y is SNAN
|
|
|
126 *pfpsf |= INVALID_EXCEPTION; // set invalid flag
|
|
|
127 }
|
|
|
128 res = x;
|
|
|
129 } else {
|
|
|
130 res = y;
|
|
|
131 }
|
|
|
132 }
|
|
|
133 BID_RETURN (res);
|
|
|
134 } else if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NaN, but x is not
|
|
|
135 if ((y.w[1] & MASK_SNAN) == MASK_SNAN) {
|
|
|
136 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
|
|
|
137 y.w[1] = y.w[1] & 0xfdffffffffffffffull; // quietize y
|
|
|
138 res = y;
|
|
|
139 } else {
|
|
|
140 // will return x (which is not NaN)
|
|
|
141 res = x;
|
|
|
142 }
|
|
|
143 BID_RETURN (res);
|
|
|
144 }
|
|
|
145 // SIMPLE (CASE2)
|
|
|
146 // if all the bits are the same, these numbers are equal (not Greater).
|
|
|
147 if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
|
|
|
148 res = x;
|
|
|
149 BID_RETURN (res);
|
|
|
150 }
|
|
|
151 // INFINITY (CASE3)
|
|
|
152 if ((x.w[1] & MASK_INF) == MASK_INF) {
|
|
|
153 // if x is neg infinity, there is no way it is greater than y, return 0
|
|
|
154 res = (((x.w[1] & MASK_SIGN) == MASK_SIGN)) ? x : y;
|
|
|
155 BID_RETURN (res);
|
|
|
156 } else if ((y.w[1] & MASK_INF) == MASK_INF) {
|
|
|
157 // x is finite, so if y is positive infinity, then x is less, return 0
|
|
|
158 // if y is negative infinity, then x is greater, return 1
|
|
|
159 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? y : x;
|
|
|
160 BID_RETURN (res);
|
|
|
161 }
|
|
|
162 // CONVERT X
|
|
|
163 sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
|
|
|
164 sig_x.w[0] = x.w[0];
|
|
|
165 exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
|
|
|
166
|
|
|
167 // CONVERT Y
|
|
|
168 exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
|
|
|
169 sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
|
|
|
170 sig_y.w[0] = y.w[0];
|
|
|
171
|
|
|
172 // ZERO (CASE4)
|
|
|
173 // some properties:
|
|
|
174 // (+ZERO == -ZERO) => therefore ignore the sign
|
|
|
175 // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => ignore the exponent
|
|
|
176 // field
|
|
|
177 // (Any non-canonical # is considered 0)
|
|
|
178 if ((sig_x.w[1] == 0) && (sig_x.w[0] == 0)) {
|
|
|
179 x_is_zero = 1;
|
|
|
180 }
|
|
|
181 if ((sig_y.w[1] == 0) && (sig_y.w[0] == 0)) {
|
|
|
182 y_is_zero = 1;
|
|
|
183 }
|
|
|
184
|
|
|
185 if (x_is_zero && y_is_zero) {
|
|
|
186 // if both numbers are zero, neither is greater => return either number
|
|
|
187 res = x;
|
|
|
188 BID_RETURN (res);
|
|
|
189 } else if (x_is_zero) {
|
|
|
190 // is x is zero, it is greater if Y is negative
|
|
|
191 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? y : x;
|
|
|
192 BID_RETURN (res);
|
|
|
193 } else if (y_is_zero) {
|
|
|
194 // is y is zero, X is greater if it is positive
|
|
|
195 res = ((x.w[1] & MASK_SIGN) != MASK_SIGN) ? y : x;
|
|
|
196 BID_RETURN (res);
|
|
|
197 }
|
|
|
198 // OPPOSITE SIGN (CASE5)
|
|
|
199 // now, if the sign bits differ, x is greater if y is negative
|
|
|
200 if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
|
|
|
201 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? y : x;
|
|
|
202 BID_RETURN (res);
|
|
|
203 }
|
|
|
204 // REDUNDANT REPRESENTATIONS (CASE6)
|
|
|
205 // if exponents are the same, then we have a simple comparison of
|
|
|
206 // the significands
|
|
|
207 if (exp_y == exp_x) {
|
|
|
208 res = (((sig_x.w[1] > sig_y.w[1])
|
|
|
209 || (sig_x.w[1] == sig_y.w[1]
|
|
|
210 && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) ==
|
|
|
211 MASK_SIGN)) ? y : x;
|
|
|
212 BID_RETURN (res);
|
|
|
213 }
|
|
|
214 // if both components are either bigger or smaller, it is clear what
|
|
|
215 // needs to be done
|
|
|
216 if (sig_x.w[1] >= sig_y.w[1] && sig_x.w[0] >= sig_y.w[0]
|
|
|
217 && exp_x > exp_y) {
|
|
|
218 res = ((x.w[1] & MASK_SIGN) != MASK_SIGN) ? y : x;
|
|
|
219 BID_RETURN (res);
|
|
|
220 }
|
|
|
221 if (sig_x.w[1] <= sig_y.w[1] && sig_x.w[0] <= sig_y.w[0]
|
|
|
222 && exp_x < exp_y) {
|
|
|
223 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? y : x;
|
|
|
224 BID_RETURN (res);
|
|
|
225 }
|
|
|
226
|
|
|
227 diff = exp_x - exp_y;
|
|
|
228
|
|
|
229 // if |exp_x - exp_y| < 33, it comes down to the compensated significand
|
|
|
230 if (diff > 0) { // to simplify the loop below,
|
|
|
231 // if exp_x is 33 greater than exp_y, no need for compensation
|
|
|
232 if (diff > 33) {
|
|
|
233 // difference cannot be greater than 10^33
|
|
|
234 res = ((x.w[1] & MASK_SIGN) != MASK_SIGN) ? y : x;
|
|
|
235 BID_RETURN (res);
|
|
|
236 }
|
|
|
237 if (diff > 19) { //128 by 128 bit multiply -> 256 bits
|
|
|
238 __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
|
|
|
239 // if postitive, return whichever significand is larger
|
|
|
240 // (converse if negative)
|
|
|
241 res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
|
|
|
242 || (sig_n_prime256.w[1] > sig_y.w[1])
|
|
|
243 || (sig_n_prime256.w[1] == sig_y.w[1]
|
|
|
244 && sig_n_prime256.w[0] >
|
|
|
245 sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) ==
|
|
|
246 MASK_SIGN)) ? y : x;
|
|
|
247 BID_RETURN (res);
|
|
|
248 }
|
|
|
249 __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
|
|
|
250 // if postitive, return whichever significand is larger
|
|
|
251 // (converse if negative)
|
|
|
252 res =
|
|
|
253 (((sig_n_prime192.w[2] > 0) || (sig_n_prime192.w[1] > sig_y.w[1])
|
|
|
254 || (sig_n_prime192.w[1] == sig_y.w[1]
|
|
|
255 && sig_n_prime192.w[0] >
|
|
|
256 sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)) ? y : x;
|
|
|
257 BID_RETURN (res);
|
|
|
258 }
|
|
|
259 diff = exp_y - exp_x;
|
|
|
260 // if exp_x is 33 less than exp_y, no need for compensation
|
|
|
261 if (diff > 33) {
|
|
|
262 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? y : x;
|
|
|
263 BID_RETURN (res);
|
|
|
264 }
|
|
|
265 if (diff > 19) { //128 by 128 bit multiply -> 256 bits
|
|
|
266 // adjust the y significand upwards
|
|
|
267 __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
|
|
|
268 // if postitive, return whichever significand is larger
|
|
|
269 // (converse if negative)
|
|
|
270 res =
|
|
|
271 ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
|
|
|
272 || (sig_n_prime256.w[1] > sig_x.w[1]
|
|
|
273 || (sig_n_prime256.w[1] == sig_x.w[1]
|
|
|
274 && sig_n_prime256.w[0] >
|
|
|
275 sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) ==
|
|
|
276 MASK_SIGN)) ? x : y;
|
|
|
277 BID_RETURN (res);
|
|
|
278 }
|
|
|
279 // adjust the y significand upwards
|
|
|
280 __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
|
|
|
281 // if postitive, return whichever significand is larger (converse if negative)
|
|
|
282 res =
|
|
|
283 ((sig_n_prime192.w[2] != 0
|
|
|
284 || (sig_n_prime192.w[1] > sig_x.w[1]
|
|
|
285 || (sig_n_prime192.w[1] == sig_x.w[1]
|
|
|
286 && sig_n_prime192.w[0] > sig_x.w[0])))
|
|
|
287 ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)) ? x : y;
|
|
|
288 BID_RETURN (res);
|
|
|
289 }
|
|
|
290
|
|
|
291 /*****************************************************************************
|
|
|
292 * BID128 minimum magnitude function - returns greater of two numbers
|
|
|
293 *****************************************************************************/
|
|
|
294
|
|
|
295 #if DECIMAL_CALL_BY_REFERENCE
|
|
|
296 void
|
|
|
297 bid128_minnum_mag (UINT128 * pres, UINT128 * px,
|
|
|
298 UINT128 * py _EXC_FLAGS_PARAM) {
|
|
|
299 UINT128 x = *px;
|
|
|
300 UINT128 y = *py;
|
|
|
301 #else
|
|
|
302 UINT128
|
|
|
303 bid128_minnum_mag (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
|
|
|
304 #endif
|
|
|
305
|
|
|
306 UINT128 res;
|
|
|
307 int exp_x, exp_y;
|
|
|
308 int diff;
|
|
|
309 UINT128 sig_x, sig_y;
|
|
|
310 UINT192 sig_n_prime192;
|
|
|
311 UINT256 sig_n_prime256;
|
|
|
312
|
|
|
313 BID_SWAP128 (x);
|
|
|
314 BID_SWAP128 (y);
|
|
|
315
|
|
|
316 // check for non-canonical x
|
|
|
317 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
|
|
|
318 x.w[1] = x.w[1] & 0xfe003fffffffffffull; // clear out G[6]-G[16]
|
|
|
319 // check for non-canonical NaN payload
|
|
|
320 if (((x.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
|
|
|
321 (((x.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) &&
|
|
|
322 (x.w[0] > 0x38c15b09ffffffffull))) {
|
|
|
323 x.w[1] = x.w[1] & 0xffffc00000000000ull;
|
|
|
324 x.w[0] = 0x0ull;
|
|
|
325 }
|
|
|
326 } else if ((x.w[1] & MASK_ANY_INF) == MASK_INF) { // x = inf
|
|
|
327 x.w[1] = x.w[1] & (MASK_SIGN | MASK_INF);
|
|
|
328 x.w[0] = 0x0ull;
|
|
|
329 } else { // x is not special
|
|
|
330 // check for non-canonical values - treated as zero
|
|
|
331 if ((x.w[1] & MASK_STEERING_BITS) == MASK_STEERING_BITS) { // G0_G1=11
|
|
|
332 // non-canonical
|
|
|
333 x.w[1] = (x.w[1] & MASK_SIGN) | ((x.w[1] << 2) & MASK_EXP);
|
|
|
334 x.w[0] = 0x0ull;
|
|
|
335 } else { // G0_G1 != 11
|
|
|
336 if ((x.w[1] & MASK_COEFF) > 0x0001ed09bead87c0ull ||
|
|
|
337 ((x.w[1] & MASK_COEFF) == 0x0001ed09bead87c0ull
|
|
|
338 && x.w[0] > 0x378d8e63ffffffffull)) {
|
|
|
339 // x is non-canonical if coefficient is larger than 10^34 -1
|
|
|
340 x.w[1] = (x.w[1] & MASK_SIGN) | (x.w[1] & MASK_EXP);
|
|
|
341 x.w[0] = 0x0ull;
|
|
|
342 } else { // canonical
|
|
|
343 ;
|
|
|
344 }
|
|
|
345 }
|
|
|
346 }
|
|
|
347 // check for non-canonical y
|
|
|
348 if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NAN
|
|
|
349 y.w[1] = y.w[1] & 0xfe003fffffffffffull; // clear out G[6]-G[16]
|
|
|
350 // check for non-canonical NaN payload
|
|
|
351 if (((y.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
|
|
|
352 (((y.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) &&
|
|
|
353 (y.w[0] > 0x38c15b09ffffffffull))) {
|
|
|
354 y.w[1] = y.w[1] & 0xffffc00000000000ull;
|
|
|
355 y.w[0] = 0x0ull;
|
|
|
356 }
|
|
|
357 } else if ((y.w[1] & MASK_ANY_INF) == MASK_INF) { // y = inf
|
|
|
358 y.w[1] = y.w[1] & (MASK_SIGN | MASK_INF);
|
|
|
359 y.w[0] = 0x0ull;
|
|
|
360 } else { // y is not special
|
|
|
361 // check for non-canonical values - treated as zero
|
|
|
362 if ((y.w[1] & MASK_STEERING_BITS) == MASK_STEERING_BITS) { // G0_G1=11
|
|
|
363 // non-canonical
|
|
|
364 y.w[1] = (y.w[1] & MASK_SIGN) | ((y.w[1] << 2) & MASK_EXP);
|
|
|
365 y.w[0] = 0x0ull;
|
|
|
366 } else { // G0_G1 != 11
|
|
|
367 if ((y.w[1] & MASK_COEFF) > 0x0001ed09bead87c0ull ||
|
|
|
368 ((y.w[1] & MASK_COEFF) == 0x0001ed09bead87c0ull
|
|
|
369 && y.w[0] > 0x378d8e63ffffffffull)) {
|
|
|
370 // y is non-canonical if coefficient is larger than 10^34 -1
|
|
|
371 y.w[1] = (y.w[1] & MASK_SIGN) | (y.w[1] & MASK_EXP);
|
|
|
372 y.w[0] = 0x0ull;
|
|
|
373 } else { // canonical
|
|
|
374 ;
|
|
|
375 }
|
|
|
376 }
|
|
|
377 }
|
|
|
378
|
|
|
379 // NaN (CASE1)
|
|
|
380 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
|
|
|
381 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNaN
|
|
|
382 // if x is SNAN, then return quiet (x)
|
|
|
383 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
|
|
|
384 x.w[1] = x.w[1] & 0xfdffffffffffffffull; // quietize x
|
|
|
385 res = x;
|
|
|
386 } else { // x is QNaN
|
|
|
387 if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NAN
|
|
|
388 if ((y.w[1] & MASK_SNAN) == MASK_SNAN) { // y is SNAN
|
|
|
389 *pfpsf |= INVALID_EXCEPTION; // set invalid flag
|
|
|
390 }
|
|
|
391 res = x;
|
|
|
392 } else {
|
|
|
393 res = y;
|
|
|
394 }
|
|
|
395 }
|
|
|
396 BID_RETURN (res);
|
|
|
397 } else if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NaN, but x is not
|
|
|
398 if ((y.w[1] & MASK_SNAN) == MASK_SNAN) {
|
|
|
399 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
|
|
|
400 y.w[1] = y.w[1] & 0xfdffffffffffffffull; // quietize y
|
|
|
401 res = y;
|
|
|
402 } else {
|
|
|
403 // will return x (which is not NaN)
|
|
|
404 res = x;
|
|
|
405 }
|
|
|
406 BID_RETURN (res);
|
|
|
407 }
|
|
|
408 // SIMPLE (CASE2)
|
|
|
409 // if all the bits are the same, these numbers are equal (not Greater).
|
|
|
410 if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
|
|
|
411 res = y;
|
|
|
412 BID_RETURN (res);
|
|
|
413 }
|
|
|
414 // INFINITY (CASE3)
|
|
|
415 if ((x.w[1] & MASK_INF) == MASK_INF) {
|
|
|
416 // if x infinity, it has maximum magnitude.
|
|
|
417 // Check if magnitudes are equal. If x is negative, return it.
|
|
|
418 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN
|
|
|
419 && (y.w[1] & MASK_INF) == MASK_INF) ? x : y;
|
|
|
420 BID_RETURN (res);
|
|
|
421 } else if ((y.w[1] & MASK_INF) == MASK_INF) {
|
|
|
422 // x is finite, so if y is infinity, then x is less in magnitude
|
|
|
423 res = x;
|
|
|
424 BID_RETURN (res);
|
|
|
425 }
|
|
|
426 // CONVERT X
|
|
|
427 sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
|
|
|
428 sig_x.w[0] = x.w[0];
|
|
|
429 exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
|
|
|
430
|
|
|
431 // CONVERT Y
|
|
|
432 exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
|
|
|
433 sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
|
|
|
434 sig_y.w[0] = y.w[0];
|
|
|
435
|
|
|
436 // ZERO (CASE4)
|
|
|
437 // some properties:
|
|
|
438 // (+ZERO == -ZERO) => therefore ignore the sign
|
|
|
439 // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
|
|
|
440 // therefore ignore the exponent field
|
|
|
441 // (Any non-canonical # is considered 0)
|
|
|
442 if ((sig_x.w[1] == 0) && (sig_x.w[0] == 0)) {
|
|
|
443 res = x;
|
|
|
444 BID_RETURN (res);
|
|
|
445 }
|
|
|
446 if ((sig_y.w[1] == 0) && (sig_y.w[0] == 0)) {
|
|
|
447 res = y;
|
|
|
448 BID_RETURN (res);
|
|
|
449 }
|
|
|
450 // REDUNDANT REPRESENTATIONS (CASE6)
|
|
|
451 // check if exponents are the same and significands are the same
|
|
|
452 if (exp_y == exp_x && sig_x.w[1] == sig_y.w[1]
|
|
|
453 && sig_x.w[0] == sig_y.w[0]) {
|
|
|
454 if (x.w[1] & 0x8000000000000000ull) { // x is negative
|
|
|
455 res = x;
|
|
|
456 BID_RETURN (res);
|
|
|
457 } else {
|
|
|
458 res = y;
|
|
|
459 BID_RETURN (res);
|
|
|
460 }
|
|
|
461 } else if (((sig_x.w[1] > sig_y.w[1] || (sig_x.w[1] == sig_y.w[1]
|
|
|
462 && sig_x.w[0] > sig_y.w[0]))
|
|
|
463 && exp_x == exp_y)
|
|
|
464 || ((sig_x.w[1] > sig_y.w[1]
|
|
|
465 || (sig_x.w[1] == sig_y.w[1]
|
|
|
466 && sig_x.w[0] >= sig_y.w[0]))
|
|
|
467 && exp_x > exp_y)) {
|
|
|
468 // if both components are either bigger or smaller, it is clear what
|
|
|
469 // needs to be done; also if the magnitudes are equal
|
|
|
470 res = y;
|
|
|
471 BID_RETURN (res);
|
|
|
472 } else if (((sig_y.w[1] > sig_x.w[1] || (sig_y.w[1] == sig_x.w[1]
|
|
|
473 && sig_y.w[0] > sig_x.w[0]))
|
|
|
474 && exp_y == exp_x)
|
|
|
475 || ((sig_y.w[1] > sig_x.w[1]
|
|
|
476 || (sig_y.w[1] == sig_x.w[1]
|
|
|
477 && sig_y.w[0] >= sig_x.w[0]))
|
|
|
478 && exp_y > exp_x)) {
|
|
|
479 res = x;
|
|
|
480 BID_RETURN (res);
|
|
|
481 } else {
|
|
|
482 ; // continue
|
|
|
483 }
|
|
|
484 diff = exp_x - exp_y;
|
|
|
485 // if |exp_x - exp_y| < 33, it comes down to the compensated significand
|
|
|
486 if (diff > 0) { // to simplify the loop below,
|
|
|
487 // if exp_x is 33 greater than exp_y, no need for compensation
|
|
|
488 if (diff > 33) {
|
|
|
489 res = y; // difference cannot be greater than 10^33
|
|
|
490 BID_RETURN (res);
|
|
|
491 }
|
|
|
492 if (diff > 19) { //128 by 128 bit multiply -> 256 bits
|
|
|
493 __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
|
|
|
494 // if positive, return whichever significand is larger
|
|
|
495 // (converse if negative)
|
|
|
496 if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
|
|
|
497 && sig_n_prime256.w[1] == sig_y.w[1]
|
|
|
498 && (sig_n_prime256.w[0] == sig_y.w[0])) {
|
|
|
499 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? y : x; // if equal
|
|
|
500 BID_RETURN (res);
|
|
|
501 }
|
|
|
502 res = (((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
|
|
|
503 || (sig_n_prime256.w[1] > sig_y.w[1])
|
|
|
504 || (sig_n_prime256.w[1] == sig_y.w[1]
|
|
|
505 && sig_n_prime256.w[0] > sig_y.w[0])) ? y : x;
|
|
|
506 BID_RETURN (res);
|
|
|
507 }
|
|
|
508 __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
|
|
|
509 // if positive, return whichever significand is larger
|
|
|
510 // (converse if negative)
|
|
|
511 if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
|
|
|
512 && (sig_n_prime192.w[0] == sig_y.w[0])) {
|
|
|
513 // if = in magnitude, return +, (if possible)
|
|
|
514 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? y : x;
|
|
|
515 BID_RETURN (res);
|
|
|
516 }
|
|
|
517 res = ((sig_n_prime192.w[2] > 0)
|
|
|
518 || (sig_n_prime192.w[1] > sig_y.w[1])
|
|
|
519 || (sig_n_prime192.w[1] == sig_y.w[1]
|
|
|
520 && sig_n_prime192.w[0] > sig_y.w[0])) ? y : x;
|
|
|
521 BID_RETURN (res);
|
|
|
522 }
|
|
|
523 diff = exp_y - exp_x;
|
|
|
524 // if exp_x is 33 less than exp_y, no need for compensation
|
|
|
525 if (diff > 33) {
|
|
|
526 res = x;
|
|
|
527 BID_RETURN (res);
|
|
|
528 }
|
|
|
529 if (diff > 19) { //128 by 128 bit multiply -> 256 bits
|
|
|
530 // adjust the y significand upwards
|
|
|
531 __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
|
|
|
532 // if positive, return whichever significand is larger
|
|
|
533 // (converse if negative)
|
|
|
534 if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
|
|
|
535 && sig_n_prime256.w[1] == sig_x.w[1]
|
|
|
536 && (sig_n_prime256.w[0] == sig_x.w[0])) {
|
|
|
537 // if = in magnitude, return +, (if possible)
|
|
|
538 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? y : x;
|
|
|
539 BID_RETURN (res);
|
|
|
540 }
|
|
|
541 res = (sig_n_prime256.w[3] == 0 && sig_n_prime256.w[2] == 0
|
|
|
542 && (sig_n_prime256.w[1] < sig_x.w[1]
|
|
|
543 || (sig_n_prime256.w[1] == sig_x.w[1]
|
|
|
544 && sig_n_prime256.w[0] < sig_x.w[0]))) ? y : x;
|
|
|
545 BID_RETURN (res);
|
|
|
546 }
|
|
|
547 // adjust the y significand upwards
|
|
|
548 __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
|
|
|
549 // if positive, return whichever significand is larger (converse if negative)
|
|
|
550 if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
|
|
|
551 && (sig_n_prime192.w[0] == sig_x.w[0])) {
|
|
|
552 // if = in magnitude, return +, if possible)
|
|
|
553 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? y : x;
|
|
|
554 BID_RETURN (res);
|
|
|
555 }
|
|
|
556 res = (sig_n_prime192.w[2] == 0
|
|
|
557 && (sig_n_prime192.w[1] < sig_x.w[1]
|
|
|
558 || (sig_n_prime192.w[1] == sig_x.w[1]
|
|
|
559 && sig_n_prime192.w[0] < sig_x.w[0]))) ? y : x;
|
|
|
560 BID_RETURN (res);
|
|
|
561 }
|
|
|
562
|
|
|
563 /*****************************************************************************
|
|
|
564 * BID128 maximum function - returns greater of two numbers
|
|
|
565 *****************************************************************************/
|
|
|
566
|
|
|
567 #if DECIMAL_CALL_BY_REFERENCE
|
|
|
568 void
|
|
|
569 bid128_maxnum (UINT128 * pres, UINT128 * px,
|
|
|
570 UINT128 * py _EXC_FLAGS_PARAM) {
|
|
|
571 UINT128 x = *px;
|
|
|
572 UINT128 y = *py;
|
|
|
573 #else
|
|
|
574 UINT128
|
|
|
575 bid128_maxnum (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
|
|
|
576 #endif
|
|
|
577
|
|
|
578 UINT128 res;
|
|
|
579 int exp_x, exp_y;
|
|
|
580 int diff;
|
|
|
581 UINT128 sig_x, sig_y;
|
|
|
582 UINT192 sig_n_prime192;
|
|
|
583 UINT256 sig_n_prime256;
|
|
|
584 char x_is_zero = 0, y_is_zero = 0;
|
|
|
585
|
|
|
586 BID_SWAP128 (x);
|
|
|
587 BID_SWAP128 (y);
|
|
|
588
|
|
|
589 // check for non-canonical x
|
|
|
590 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
|
|
|
591 x.w[1] = x.w[1] & 0xfe003fffffffffffull; // clear out G[6]-G[16]
|
|
|
592 // check for non-canonical NaN payload
|
|
|
593 if (((x.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
|
|
|
594 (((x.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) &&
|
|
|
595 (x.w[0] > 0x38c15b09ffffffffull))) {
|
|
|
596 x.w[1] = x.w[1] & 0xffffc00000000000ull;
|
|
|
597 x.w[0] = 0x0ull;
|
|
|
598 }
|
|
|
599 } else if ((x.w[1] & MASK_ANY_INF) == MASK_INF) { // x = inf
|
|
|
600 x.w[1] = x.w[1] & (MASK_SIGN | MASK_INF);
|
|
|
601 x.w[0] = 0x0ull;
|
|
|
602 } else { // x is not special
|
|
|
603 // check for non-canonical values - treated as zero
|
|
|
604 if ((x.w[1] & MASK_STEERING_BITS) == MASK_STEERING_BITS) { // G0_G1=11
|
|
|
605 // non-canonical
|
|
|
606 x.w[1] = (x.w[1] & MASK_SIGN) | ((x.w[1] << 2) & MASK_EXP);
|
|
|
607 x.w[0] = 0x0ull;
|
|
|
608 } else { // G0_G1 != 11
|
|
|
609 if ((x.w[1] & MASK_COEFF) > 0x0001ed09bead87c0ull ||
|
|
|
610 ((x.w[1] & MASK_COEFF) == 0x0001ed09bead87c0ull
|
|
|
611 && x.w[0] > 0x378d8e63ffffffffull)) {
|
|
|
612 // x is non-canonical if coefficient is larger than 10^34 -1
|
|
|
613 x.w[1] = (x.w[1] & MASK_SIGN) | (x.w[1] & MASK_EXP);
|
|
|
614 x.w[0] = 0x0ull;
|
|
|
615 } else { // canonical
|
|
|
616 ;
|
|
|
617 }
|
|
|
618 }
|
|
|
619 }
|
|
|
620 // check for non-canonical y
|
|
|
621 if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NAN
|
|
|
622 y.w[1] = y.w[1] & 0xfe003fffffffffffull; // clear out G[6]-G[16]
|
|
|
623 // check for non-canonical NaN payload
|
|
|
624 if (((y.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
|
|
|
625 (((y.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) &&
|
|
|
626 (y.w[0] > 0x38c15b09ffffffffull))) {
|
|
|
627 y.w[1] = y.w[1] & 0xffffc00000000000ull;
|
|
|
628 y.w[0] = 0x0ull;
|
|
|
629 }
|
|
|
630 } else if ((y.w[1] & MASK_ANY_INF) == MASK_INF) { // y = inf
|
|
|
631 y.w[1] = y.w[1] & (MASK_SIGN | MASK_INF);
|
|
|
632 y.w[0] = 0x0ull;
|
|
|
633 } else { // y is not special
|
|
|
634 // check for non-canonical values - treated as zero
|
|
|
635 if ((y.w[1] & MASK_STEERING_BITS) == MASK_STEERING_BITS) { // G0_G1=11
|
|
|
636 // non-canonical
|
|
|
637 y.w[1] = (y.w[1] & MASK_SIGN) | ((y.w[1] << 2) & MASK_EXP);
|
|
|
638 y.w[0] = 0x0ull;
|
|
|
639 } else { // G0_G1 != 11
|
|
|
640 if ((y.w[1] & MASK_COEFF) > 0x0001ed09bead87c0ull ||
|
|
|
641 ((y.w[1] & MASK_COEFF) == 0x0001ed09bead87c0ull
|
|
|
642 && y.w[0] > 0x378d8e63ffffffffull)) {
|
|
|
643 // y is non-canonical if coefficient is larger than 10^34 -1
|
|
|
644 y.w[1] = (y.w[1] & MASK_SIGN) | (y.w[1] & MASK_EXP);
|
|
|
645 y.w[0] = 0x0ull;
|
|
|
646 } else { // canonical
|
|
|
647 ;
|
|
|
648 }
|
|
|
649 }
|
|
|
650 }
|
|
|
651
|
|
|
652 // NaN (CASE1)
|
|
|
653 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
|
|
|
654 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNaN
|
|
|
655 // if x is SNAN, then return quiet (x)
|
|
|
656 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
|
|
|
657 x.w[1] = x.w[1] & 0xfdffffffffffffffull; // quietize x
|
|
|
658 res = x;
|
|
|
659 } else { // x is QNaN
|
|
|
660 if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NAN
|
|
|
661 if ((y.w[1] & MASK_SNAN) == MASK_SNAN) { // y is SNAN
|
|
|
662 *pfpsf |= INVALID_EXCEPTION; // set invalid flag
|
|
|
663 }
|
|
|
664 res = x;
|
|
|
665 } else {
|
|
|
666 res = y;
|
|
|
667 }
|
|
|
668 }
|
|
|
669 BID_RETURN (res);
|
|
|
670 } else if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NaN, but x is not
|
|
|
671 if ((y.w[1] & MASK_SNAN) == MASK_SNAN) {
|
|
|
672 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
|
|
|
673 y.w[1] = y.w[1] & 0xfdffffffffffffffull; // quietize y
|
|
|
674 res = y;
|
|
|
675 } else {
|
|
|
676 // will return x (which is not NaN)
|
|
|
677 res = x;
|
|
|
678 }
|
|
|
679 BID_RETURN (res);
|
|
|
680 }
|
|
|
681 // SIMPLE (CASE2)
|
|
|
682 // if all the bits are the same, these numbers are equal (not Greater).
|
|
|
683 if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
|
|
|
684 res = x;
|
|
|
685 BID_RETURN (res);
|
|
|
686 }
|
|
|
687 // INFINITY (CASE3)
|
|
|
688 if ((x.w[1] & MASK_INF) == MASK_INF) {
|
|
|
689 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? y : x;
|
|
|
690 BID_RETURN (res);
|
|
|
691 } else if ((y.w[1] & MASK_INF) == MASK_INF) {
|
|
|
692 // x is finite, so if y is positive infinity, then x is less, return 0
|
|
|
693 // if y is negative infinity, then x is greater, return 1
|
|
|
694 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? x : y;
|
|
|
695 BID_RETURN (res);
|
|
|
696 }
|
|
|
697 // CONVERT X
|
|
|
698 sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
|
|
|
699 sig_x.w[0] = x.w[0];
|
|
|
700 exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
|
|
|
701
|
|
|
702 // CONVERT Y
|
|
|
703 exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
|
|
|
704 sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
|
|
|
705 sig_y.w[0] = y.w[0];
|
|
|
706
|
|
|
707 // ZERO (CASE4)
|
|
|
708 // some properties:
|
|
|
709 // (+ZERO == -ZERO) => therefore ignore the sign
|
|
|
710 // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
|
|
|
711 // therefore ignore the exponent field
|
|
|
712 // (Any non-canonical # is considered 0)
|
|
|
713 if ((sig_x.w[1] == 0) && (sig_x.w[0] == 0)) {
|
|
|
714 x_is_zero = 1;
|
|
|
715 }
|
|
|
716 if ((sig_y.w[1] == 0) && (sig_y.w[0] == 0)) {
|
|
|
717 y_is_zero = 1;
|
|
|
718 }
|
|
|
719
|
|
|
720 if (x_is_zero && y_is_zero) {
|
|
|
721 // if both numbers are zero, neither is greater => return either number
|
|
|
722 res = x;
|
|
|
723 BID_RETURN (res);
|
|
|
724 } else if (x_is_zero) {
|
|
|
725 // is x is zero, it is greater if Y is negative
|
|
|
726 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? x : y;
|
|
|
727 BID_RETURN (res);
|
|
|
728 } else if (y_is_zero) {
|
|
|
729 // is y is zero, X is greater if it is positive
|
|
|
730 res = ((x.w[1] & MASK_SIGN) != MASK_SIGN) ? x : y;
|
|
|
731 BID_RETURN (res);
|
|
|
732 }
|
|
|
733 // OPPOSITE SIGN (CASE5)
|
|
|
734 // now, if the sign bits differ, x is greater if y is negative
|
|
|
735 if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
|
|
|
736 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? x : y;
|
|
|
737 BID_RETURN (res);
|
|
|
738 }
|
|
|
739 // REDUNDANT REPRESENTATIONS (CASE6)
|
|
|
740 // if exponents are the same, then we have a simple comparison of
|
|
|
741 // the significands
|
|
|
742 if (exp_y == exp_x) {
|
|
|
743 res = (((sig_x.w[1] > sig_y.w[1]) || (sig_x.w[1] == sig_y.w[1] &&
|
|
|
744 sig_x.w[0] >= sig_y.w[0])) ^
|
|
|
745 ((x.w[1] & MASK_SIGN) == MASK_SIGN)) ? x : y;
|
|
|
746 BID_RETURN (res);
|
|
|
747 }
|
|
|
748 // if both components are either bigger or smaller, it is clear what
|
|
|
749 // needs to be done
|
|
|
750 if ((sig_x.w[1] > sig_y.w[1]
|
|
|
751 || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
|
|
|
752 && exp_x >= exp_y) {
|
|
|
753 res = ((x.w[1] & MASK_SIGN) != MASK_SIGN) ? x : y;
|
|
|
754 BID_RETURN (res);
|
|
|
755 }
|
|
|
756 if ((sig_x.w[1] < sig_y.w[1]
|
|
|
757 || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
|
|
|
758 && exp_x <= exp_y) {
|
|
|
759 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? x : y;
|
|
|
760 BID_RETURN (res);
|
|
|
761 }
|
|
|
762 diff = exp_x - exp_y;
|
|
|
763 // if |exp_x - exp_y| < 33, it comes down to the compensated significand
|
|
|
764 if (diff > 0) { // to simplify the loop below,
|
|
|
765 // if exp_x is 33 greater than exp_y, no need for compensation
|
|
|
766 if (diff > 33) {
|
|
|
767 // difference cannot be greater than 10^33
|
|
|
768 res = ((x.w[1] & MASK_SIGN) != MASK_SIGN) ? x : y;
|
|
|
769 BID_RETURN (res);
|
|
|
770 }
|
|
|
771 if (diff > 19) { //128 by 128 bit multiply -> 256 bits
|
|
|
772 __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
|
|
|
773 // if postitive, return whichever significand is larger
|
|
|
774 // (converse if negative)
|
|
|
775 res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
|
|
|
776 || (sig_n_prime256.w[1] > sig_y.w[1])
|
|
|
777 || (sig_n_prime256.w[1] == sig_y.w[1]
|
|
|
778 && sig_n_prime256.w[0] >
|
|
|
779 sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) ==
|
|
|
780 MASK_SIGN)) ? x : y;
|
|
|
781 BID_RETURN (res);
|
|
|
782 }
|
|
|
783 __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
|
|
|
784 // if postitive, return whichever significand is larger
|
|
|
785 // (converse if negative)
|
|
|
786 res =
|
|
|
787 (((sig_n_prime192.w[2] > 0) || (sig_n_prime192.w[1] > sig_y.w[1])
|
|
|
788 || (sig_n_prime192.w[1] == sig_y.w[1]
|
|
|
789 && sig_n_prime192.w[0] >
|
|
|
790 sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)) ? x : y;
|
|
|
791 BID_RETURN (res);
|
|
|
792 }
|
|
|
793 diff = exp_y - exp_x;
|
|
|
794 // if exp_x is 33 less than exp_y, no need for compensation
|
|
|
795 if (diff > 33) {
|
|
|
796 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? x : y;
|
|
|
797 BID_RETURN (res);
|
|
|
798 }
|
|
|
799 if (diff > 19) { //128 by 128 bit multiply -> 256 bits
|
|
|
800 // adjust the y significand upwards
|
|
|
801 __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
|
|
|
802 // if postitive, return whichever significand is larger
|
|
|
803 // (converse if negative)
|
|
|
804 res =
|
|
|
805 ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
|
|
|
806 || (sig_n_prime256.w[1] > sig_x.w[1]
|
|
|
807 || (sig_n_prime256.w[1] == sig_x.w[1]
|
|
|
808 && sig_n_prime256.w[0] >
|
|
|
809 sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) !=
|
|
|
810 MASK_SIGN)) ? x : y;
|
|
|
811 BID_RETURN (res);
|
|
|
812 }
|
|
|
813 // adjust the y significand upwards
|
|
|
814 __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
|
|
|
815 // if postitive, return whichever significand is larger (converse if negative)
|
|
|
816 res =
|
|
|
817 ((sig_n_prime192.w[2] != 0
|
|
|
818 || (sig_n_prime192.w[1] > sig_x.w[1]
|
|
|
819 || (sig_n_prime192.w[1] == sig_x.w[1]
|
|
|
820 && sig_n_prime192.w[0] >
|
|
|
821 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) !=
|
|
|
822 MASK_SIGN)) ? x : y;
|
|
|
823 BID_RETURN (res);
|
|
|
824 }
|
|
|
825
|
|
|
826 /*****************************************************************************
|
|
|
827 * BID128 maximum magnitude function - returns greater of two numbers
|
|
|
828 *****************************************************************************/
|
|
|
829
|
|
|
830 #if DECIMAL_CALL_BY_REFERENCE
|
|
|
831 void
|
|
|
832 bid128_maxnum_mag (UINT128 * pres, UINT128 * px,
|
|
|
833 UINT128 * py _EXC_FLAGS_PARAM) {
|
|
|
834 UINT128 x = *px;
|
|
|
835 UINT128 y = *py;
|
|
|
836 #else
|
|
|
837 UINT128
|
|
|
838 bid128_maxnum_mag (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
|
|
|
839 #endif
|
|
|
840
|
|
|
841 UINT128 res;
|
|
|
842 int exp_x, exp_y;
|
|
|
843 int diff;
|
|
|
844 UINT128 sig_x, sig_y;
|
|
|
845 UINT192 sig_n_prime192;
|
|
|
846 UINT256 sig_n_prime256;
|
|
|
847
|
|
|
848 BID_SWAP128 (x);
|
|
|
849 BID_SWAP128 (y);
|
|
|
850
|
|
|
851 // check for non-canonical x
|
|
|
852 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
|
|
|
853 x.w[1] = x.w[1] & 0xfe003fffffffffffull; // clear out G[6]-G[16]
|
|
|
854 // check for non-canonical NaN payload
|
|
|
855 if (((x.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
|
|
|
856 (((x.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) &&
|
|
|
857 (x.w[0] > 0x38c15b09ffffffffull))) {
|
|
|
858 x.w[1] = x.w[1] & 0xffffc00000000000ull;
|
|
|
859 x.w[0] = 0x0ull;
|
|
|
860 }
|
|
|
861 } else if ((x.w[1] & MASK_ANY_INF) == MASK_INF) { // x = inf
|
|
|
862 x.w[1] = x.w[1] & (MASK_SIGN | MASK_INF);
|
|
|
863 x.w[0] = 0x0ull;
|
|
|
864 } else { // x is not special
|
|
|
865 // check for non-canonical values - treated as zero
|
|
|
866 if ((x.w[1] & MASK_STEERING_BITS) == MASK_STEERING_BITS) { // G0_G1=11
|
|
|
867 // non-canonical
|
|
|
868 x.w[1] = (x.w[1] & MASK_SIGN) | ((x.w[1] << 2) & MASK_EXP);
|
|
|
869 x.w[0] = 0x0ull;
|
|
|
870 } else { // G0_G1 != 11
|
|
|
871 if ((x.w[1] & MASK_COEFF) > 0x0001ed09bead87c0ull ||
|
|
|
872 ((x.w[1] & MASK_COEFF) == 0x0001ed09bead87c0ull
|
|
|
873 && x.w[0] > 0x378d8e63ffffffffull)) {
|
|
|
874 // x is non-canonical if coefficient is larger than 10^34 -1
|
|
|
875 x.w[1] = (x.w[1] & MASK_SIGN) | (x.w[1] & MASK_EXP);
|
|
|
876 x.w[0] = 0x0ull;
|
|
|
877 } else { // canonical
|
|
|
878 ;
|
|
|
879 }
|
|
|
880 }
|
|
|
881 }
|
|
|
882 // check for non-canonical y
|
|
|
883 if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NAN
|
|
|
884 y.w[1] = y.w[1] & 0xfe003fffffffffffull; // clear out G[6]-G[16]
|
|
|
885 // check for non-canonical NaN payload
|
|
|
886 if (((y.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
|
|
|
887 (((y.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull) &&
|
|
|
888 (y.w[0] > 0x38c15b09ffffffffull))) {
|
|
|
889 y.w[1] = y.w[1] & 0xffffc00000000000ull;
|
|
|
890 y.w[0] = 0x0ull;
|
|
|
891 }
|
|
|
892 } else if ((y.w[1] & MASK_ANY_INF) == MASK_INF) { // y = inf
|
|
|
893 y.w[1] = y.w[1] & (MASK_SIGN | MASK_INF);
|
|
|
894 y.w[0] = 0x0ull;
|
|
|
895 } else { // y is not special
|
|
|
896 // check for non-canonical values - treated as zero
|
|
|
897 if ((y.w[1] & MASK_STEERING_BITS) == MASK_STEERING_BITS) { // G0_G1=11
|
|
|
898 // non-canonical
|
|
|
899 y.w[1] = (y.w[1] & MASK_SIGN) | ((y.w[1] << 2) & MASK_EXP);
|
|
|
900 y.w[0] = 0x0ull;
|
|
|
901 } else { // G0_G1 != 11
|
|
|
902 if ((y.w[1] & MASK_COEFF) > 0x0001ed09bead87c0ull ||
|
|
|
903 ((y.w[1] & MASK_COEFF) == 0x0001ed09bead87c0ull &&
|
|
|
904 y.w[0] > 0x378d8e63ffffffffull)) {
|
|
|
905 // y is non-canonical if coefficient is larger than 10^34 -1
|
|
|
906 y.w[1] = (y.w[1] & MASK_SIGN) | (y.w[1] & MASK_EXP);
|
|
|
907 y.w[0] = 0x0ull;
|
|
|
908 } else { // canonical
|
|
|
909 ;
|
|
|
910 }
|
|
|
911 }
|
|
|
912 }
|
|
|
913
|
|
|
914 // NaN (CASE1)
|
|
|
915 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
|
|
|
916 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNaN
|
|
|
917 // if x is SNAN, then return quiet (x)
|
|
|
918 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
|
|
|
919 x.w[1] = x.w[1] & 0xfdffffffffffffffull; // quietize x
|
|
|
920 res = x;
|
|
|
921 } else { // x is QNaN
|
|
|
922 if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NAN
|
|
|
923 if ((y.w[1] & MASK_SNAN) == MASK_SNAN) { // y is SNAN
|
|
|
924 *pfpsf |= INVALID_EXCEPTION; // set invalid flag
|
|
|
925 }
|
|
|
926 res = x;
|
|
|
927 } else {
|
|
|
928 res = y;
|
|
|
929 }
|
|
|
930 }
|
|
|
931 BID_RETURN (res);
|
|
|
932 } else if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NaN, but x is not
|
|
|
933 if ((y.w[1] & MASK_SNAN) == MASK_SNAN) {
|
|
|
934 *pfpsf |= INVALID_EXCEPTION; // set exception if SNaN
|
|
|
935 y.w[1] = y.w[1] & 0xfdffffffffffffffull; // quietize y
|
|
|
936 res = y;
|
|
|
937 } else {
|
|
|
938 // will return x (which is not NaN)
|
|
|
939 res = x;
|
|
|
940 }
|
|
|
941 BID_RETURN (res);
|
|
|
942 }
|
|
|
943 // SIMPLE (CASE2)
|
|
|
944 // if all the bits are the same, these numbers are equal (not Greater).
|
|
|
945 if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
|
|
|
946 res = y;
|
|
|
947 BID_RETURN (res);
|
|
|
948 }
|
|
|
949 // INFINITY (CASE3)
|
|
|
950 if ((x.w[1] & MASK_INF) == MASK_INF) {
|
|
|
951 // if x infinity, it has maximum magnitude
|
|
|
952 res = ((x.w[1] & MASK_SIGN) == MASK_SIGN
|
|
|
953 && (y.w[1] & MASK_INF) == MASK_INF) ? y : x;
|
|
|
954 BID_RETURN (res);
|
|
|
955 } else if ((y.w[1] & MASK_INF) == MASK_INF) {
|
|
|
956 // x is finite, so if y is positive infinity, then x is less, return 0
|
|
|
957 // if y is negative infinity, then x is greater, return 1
|
|
|
958 res = y;
|
|
|
959 BID_RETURN (res);
|
|
|
960 }
|
|
|
961 // CONVERT X
|
|
|
962 sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
|
|
|
963 sig_x.w[0] = x.w[0];
|
|
|
964 exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
|
|
|
965
|
|
|
966 // CONVERT Y
|
|
|
967 exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
|
|
|
968 sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
|
|
|
969 sig_y.w[0] = y.w[0];
|
|
|
970
|
|
|
971 // ZERO (CASE4)
|
|
|
972 // some properties:
|
|
|
973 // (+ZERO == -ZERO) => therefore ignore the sign
|
|
|
974 // (ZERO x 10^A == ZERO x 10^B) for any valid A, B =>
|
|
|
975 // therefore ignore the exponent field
|
|
|
976 // (Any non-canonical # is considered 0)
|
|
|
977 if ((sig_x.w[1] == 0) && (sig_x.w[0] == 0)) {
|
|
|
978 res = y;
|
|
|
979 BID_RETURN (res);
|
|
|
980 }
|
|
|
981 if ((sig_y.w[1] == 0) && (sig_y.w[0] == 0)) {
|
|
|
982 res = x;
|
|
|
983 BID_RETURN (res);
|
|
|
984 }
|
|
|
985 // REDUNDANT REPRESENTATIONS (CASE6)
|
|
|
986 if (exp_y == exp_x && sig_x.w[1] == sig_y.w[1]
|
|
|
987 && sig_x.w[0] == sig_y.w[0]) {
|
|
|
988 // check if exponents are the same and significands are the same
|
|
|
989 if (x.w[1] & 0x8000000000000000ull) { // x is negative
|
|
|
990 res = y;
|
|
|
991 BID_RETURN (res);
|
|
|
992 } else {
|
|
|
993 res = x;
|
|
|
994 BID_RETURN (res);
|
|
|
995 }
|
|
|
996 } else if (((sig_x.w[1] > sig_y.w[1] || (sig_x.w[1] == sig_y.w[1]
|
|
|
997 && sig_x.w[0] > sig_y.w[0]))
|
|
|
998 && exp_x == exp_y)
|
|
|
999 || ((sig_x.w[1] > sig_y.w[1]
|
|
|
1000 || (sig_x.w[1] == sig_y.w[1]
|
|
|
1001 && sig_x.w[0] >= sig_y.w[0]))
|
|
|
1002 && exp_x > exp_y)) {
|
|
|
1003 // if both components are either bigger or smaller, it is clear what
|
|
|
1004 // needs to be done; also if the magnitudes are equal
|
|
|
1005 res = x;
|
|
|
1006 BID_RETURN (res);
|
|
|
1007 } else if (((sig_y.w[1] > sig_x.w[1] || (sig_y.w[1] == sig_x.w[1]
|
|
|
1008 && sig_y.w[0] > sig_x.w[0]))
|
|
|
1009 && exp_y == exp_x)
|
|
|
1010 || ((sig_y.w[1] > sig_x.w[1]
|
|
|
1011 || (sig_y.w[1] == sig_x.w[1]
|
|
|
1012 && sig_y.w[0] >= sig_x.w[0]))
|
|
|
1013 && exp_y > exp_x)) {
|
|
|
1014 res = y;
|
|
|
1015 BID_RETURN (res);
|
|
|
1016 } else {
|
|
|
1017 ; // continue
|
|
|
1018 }
|
|
|
1019 diff = exp_x - exp_y;
|
|
|
1020 // if |exp_x - exp_y| < 33, it comes down to the compensated significand
|
|
|
1021 if (diff > 0) { // to simplify the loop below,
|
|
|
1022 // if exp_x is 33 greater than exp_y, no need for compensation
|
|
|
1023 if (diff > 33) {
|
|
|
1024 res = x; // difference cannot be greater than 10^33
|
|
|
1025 BID_RETURN (res);
|
|
|
1026 }
|
|
|
1027 if (diff > 19) { //128 by 128 bit multiply -> 256 bits
|
|
|
1028 __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
|
|
|
1029 // if postitive, return whichever significand is larger
|
|
|
1030 // (converse if negative)
|
|
|
1031 if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
|
|
|
1032 && sig_n_prime256.w[1] == sig_y.w[1]
|
|
|
1033 && (sig_n_prime256.w[0] == sig_y.w[0])) {
|
|
|
1034 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? x : y; // if equal
|
|
|
1035 BID_RETURN (res);
|
|
|
1036 }
|
|
|
1037 res = (((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
|
|
|
1038 || (sig_n_prime256.w[1] > sig_y.w[1])
|
|
|
1039 || (sig_n_prime256.w[1] == sig_y.w[1]
|
|
|
1040 && sig_n_prime256.w[0] > sig_y.w[0])) ? x : y;
|
|
|
1041 BID_RETURN (res);
|
|
|
1042 }
|
|
|
1043 __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
|
|
|
1044 // if postitive, return whichever significand is larger (converse if negative)
|
|
|
1045 if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
|
|
|
1046 && (sig_n_prime192.w[0] == sig_y.w[0])) {
|
|
|
1047 // if equal, return positive magnitude
|
|
|
1048 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? x : y;
|
|
|
1049 BID_RETURN (res);
|
|
|
1050 }
|
|
|
1051 res = ((sig_n_prime192.w[2] > 0)
|
|
|
1052 || (sig_n_prime192.w[1] > sig_y.w[1])
|
|
|
1053 || (sig_n_prime192.w[1] == sig_y.w[1]
|
|
|
1054 && sig_n_prime192.w[0] > sig_y.w[0])) ? x : y;
|
|
|
1055 BID_RETURN (res);
|
|
|
1056 }
|
|
|
1057 diff = exp_y - exp_x;
|
|
|
1058 // if exp_x is 33 less than exp_y, no need for compensation
|
|
|
1059 if (diff > 33) {
|
|
|
1060 res = y;
|
|
|
1061 BID_RETURN (res);
|
|
|
1062 }
|
|
|
1063 if (diff > 19) { //128 by 128 bit multiply -> 256 bits
|
|
|
1064 // adjust the y significand upwards
|
|
|
1065 __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
|
|
|
1066 // if postitive, return whichever significand is larger
|
|
|
1067 // (converse if negative)
|
|
|
1068 if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
|
|
|
1069 && sig_n_prime256.w[1] == sig_x.w[1]
|
|
|
1070 && (sig_n_prime256.w[0] == sig_x.w[0])) {
|
|
|
1071 // if equal, return positive (if possible)
|
|
|
1072 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? x : y;
|
|
|
1073 BID_RETURN (res);
|
|
|
1074 }
|
|
|
1075 res = (sig_n_prime256.w[3] == 0 && sig_n_prime256.w[2] == 0
|
|
|
1076 && (sig_n_prime256.w[1] < sig_x.w[1]
|
|
|
1077 || (sig_n_prime256.w[1] == sig_x.w[1]
|
|
|
1078 && sig_n_prime256.w[0] < sig_x.w[0]))) ? x : y;
|
|
|
1079 BID_RETURN (res);
|
|
|
1080 }
|
|
|
1081 // adjust the y significand upwards
|
|
|
1082 __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
|
|
|
1083 // if postitive, return whichever significand is larger (converse if negative)
|
|
|
1084 if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
|
|
|
1085 && (sig_n_prime192.w[0] == sig_x.w[0])) {
|
|
|
1086 // if equal, return positive (if possible)
|
|
|
1087 res = ((y.w[1] & MASK_SIGN) == MASK_SIGN) ? x : y;
|
|
|
1088 BID_RETURN (res);
|
|
|
1089 }
|
|
|
1090 res = (sig_n_prime192.w[2] == 0
|
|
|
1091 && (sig_n_prime192.w[1] < sig_x.w[1]
|
|
|
1092 || (sig_n_prime192.w[1] == sig_x.w[1]
|
|
|
1093 && sig_n_prime192.w[0] < sig_x.w[0]))) ? x : y;
|
|
|
1094 BID_RETURN (res);
|
|
|
1095 }
|
