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