]> git.ipfire.org Git - thirdparty/gcc.git/blob - libgcc/config/libbid/bid128_next.c
projects / thirdparty / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update copyright years.
[thirdparty/gcc.git] / libgcc / config / libbid / bid128_next.c
1 /* Copyright (C) 2007-2020 Free Software Foundation, Inc.
2
3 This file is part of GCC.
4
5 GCC is free software; you can redistribute it and/or modify it under
6 the terms of the GNU General Public License as published by the Free
7 Software Foundation; either version 3, or (at your option) any later
8 version.
9
10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 for more details.
14
15 Under Section 7 of GPL version 3, you are granted additional
16 permissions described in the GCC Runtime Library Exception, version
17 3.1, as published by the Free Software Foundation.
18
19 You should have received a copy of the GNU General Public License and
20 a copy of the GCC Runtime Library Exception along with this program;
21 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
22 <http://www.gnu.org/licenses/>. */
23
24 #define BID_128RES
25 #include "bid_internal.h"
26
27 /*****************************************************************************
28 * BID128 nextup
29 ****************************************************************************/
30
31 #if DECIMAL_CALL_BY_REFERENCE
32 void
33 bid128_nextup (UINT128 * pres,
34 UINT128 *
35 px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
36 UINT128 x = *px;
37 #else
38 UINT128
39 bid128_nextup (UINT128 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
40 _EXC_INFO_PARAM) {
41 #endif
42
43 UINT128 res;
44 UINT64 x_sign;
45 UINT64 x_exp;
46 int exp;
47 BID_UI64DOUBLE tmp1;
48 int x_nr_bits;
49 int q1, ind;
50 UINT128 C1; // C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (UINT64)
51
52 BID_SWAP128 (x);
53 // unpack the argument
54 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
55 C1.w[1] = x.w[1] & MASK_COEFF;
56 C1.w[0] = x.w[0];
57
58 // check for NaN or Infinity
59 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) {
60 // x is special
61 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
62 // if x = NaN, then res = Q (x)
63 // check first for non-canonical NaN payload
64 if (((x.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
65 (((x.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull)
66 && (x.w[0] > 0x38c15b09ffffffffull))) {
67 x.w[1] = x.w[1] & 0xffffc00000000000ull;
68 x.w[0] = 0x0ull;
69 }
70 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN
71 // set invalid flag
72 *pfpsf |= INVALID_EXCEPTION;
73 // return quiet (x)
74 res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out also G[6]-G[16]
75 res.w[0] = x.w[0];
76 } else { // x is QNaN
77 // return x
78 res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out G[6]-G[16]
79 res.w[0] = x.w[0];
80 }
81 } else { // x is not NaN, so it must be infinity
82 if (!x_sign) { // x is +inf
83 res.w[1] = 0x7800000000000000ull; // +inf
84 res.w[0] = 0x0000000000000000ull;
85 } else { // x is -inf
86 res.w[1] = 0xdfffed09bead87c0ull; // -MAXFP = -999...99 * 10^emax
87 res.w[0] = 0x378d8e63ffffffffull;
88 }
89 }
90 BID_RETURN (res);
91 }
92 // check for non-canonical values (treated as zero)
93 if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11
94 // non-canonical
95 x_exp = (x.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits
96 C1.w[1] = 0; // significand high
97 C1.w[0] = 0; // significand low
98 } else { // G0_G1 != 11
99 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bits
100 if (C1.w[1] > 0x0001ed09bead87c0ull ||
101 (C1.w[1] == 0x0001ed09bead87c0ull
102 && C1.w[0] > 0x378d8e63ffffffffull)) {
103 // x is non-canonical if coefficient is larger than 10^34 -1
104 C1.w[1] = 0;
105 C1.w[0] = 0;
106 } else { // canonical
107 ;
108 }
109 }
110
111 if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) {
112 // x is +/-0
113 res.w[1] = 0x0000000000000000ull; // +1 * 10^emin
114 res.w[0] = 0x0000000000000001ull;
115 } else { // x is not special and is not zero
116 if (x.w[1] == 0x5fffed09bead87c0ull
117 && x.w[0] == 0x378d8e63ffffffffull) {
118 // x = +MAXFP = 999...99 * 10^emax
119 res.w[1] = 0x7800000000000000ull; // +inf
120 res.w[0] = 0x0000000000000000ull;
121 } else if (x.w[1] == 0x8000000000000000ull
122 && x.w[0] == 0x0000000000000001ull) {
123 // x = -MINFP = 1...99 * 10^emin
124 res.w[1] = 0x8000000000000000ull; // -0
125 res.w[0] = 0x0000000000000000ull;
126 } else { // -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
127 // can add/subtract 1 ulp to the significand
128
129 // Note: we could check here if x >= 10^34 to speed up the case q1 = 34
130 // q1 = nr. of decimal digits in x
131 // determine first the nr. of bits in x
132 if (C1.w[1] == 0) {
133 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53
134 // split the 64-bit value in two 32-bit halves to avoid rnd errors
135 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32
136 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion
137 x_nr_bits =
138 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) -
139 0x3ff);
140 } else { // x < 2^32
141 tmp1.d = (double) (C1.w[0]); // exact conversion
142 x_nr_bits =
143 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) -
144 0x3ff);
145 }
146 } else { // if x < 2^53
147 tmp1.d = (double) C1.w[0]; // exact conversion
148 x_nr_bits =
149 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
150 }
151 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1])
152 tmp1.d = (double) C1.w[1]; // exact conversion
153 x_nr_bits =
154 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
155 }
156 q1 = nr_digits[x_nr_bits - 1].digits;
157 if (q1 == 0) {
158 q1 = nr_digits[x_nr_bits - 1].digits1;
159 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi
160 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi
161 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo))
162 q1++;
163 }
164 // if q1 < P34 then pad the significand with zeros
165 if (q1 < P34) {
166 exp = (x_exp >> 49) - 6176;
167 if (exp + 6176 > P34 - q1) {
168 ind = P34 - q1; // 1 <= ind <= P34 - 1
169 // pad with P34 - q1 zeros, until exponent = emin
170 // C1 = C1 * 10^ind
171 if (q1 <= 19) { // 64-bit C1
172 if (ind <= 19) { // 64-bit 10^ind and 64-bit C1
173 __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]);
174 } else { // 128-bit 10^ind and 64-bit C1
175 __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]);
176 }
177 } else { // C1 is (most likely) 128-bit
178 if (ind <= 14) { // 64-bit 10^ind and 128-bit C1 (most likely)
179 __mul_128x64_to_128 (C1, ten2k64[ind], C1);
180 } else if (ind <= 19) { // 64-bit 10^ind and 64-bit C1 (q1 <= 19)
181 __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]);
182 } else { // 128-bit 10^ind and 64-bit C1 (C1 must be 64-bit)
183 __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]);
184 }
185 }
186 x_exp = x_exp - ((UINT64) ind << 49);
187 } else { // pad with zeros until the exponent reaches emin
188 ind = exp + 6176;
189 // C1 = C1 * 10^ind
190 if (ind <= 19) { // 1 <= P34 - q1 <= 19 <=> 15 <= q1 <= 33
191 if (q1 <= 19) { // 64-bit C1, 64-bit 10^ind
192 __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]);
193 } else { // 20 <= q1 <= 33 => 128-bit C1, 64-bit 10^ind
194 __mul_128x64_to_128 (C1, ten2k64[ind], C1);
195 }
196 } else { // if 20 <= P34 - q1 <= 33 <=> 1 <= q1 <= 14 =>
197 // 64-bit C1, 128-bit 10^ind
198 __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]);
199 }
200 x_exp = EXP_MIN;
201 }
202 }
203 if (!x_sign) { // x > 0
204 // add 1 ulp (add 1 to the significand)
205 C1.w[0]++;
206 if (C1.w[0] == 0)
207 C1.w[1]++;
208 if (C1.w[1] == 0x0001ed09bead87c0ull && C1.w[0] == 0x378d8e6400000000ull) { // if C1 = 10^34
209 C1.w[1] = 0x0000314dc6448d93ull; // C1 = 10^33
210 C1.w[0] = 0x38c15b0a00000000ull;
211 x_exp = x_exp + EXP_P1;
212 }
213 } else { // x < 0
214 // subtract 1 ulp (subtract 1 from the significand)
215 C1.w[0]--;
216 if (C1.w[0] == 0xffffffffffffffffull)
217 C1.w[1]--;
218 if (x_exp != 0 && C1.w[1] == 0x0000314dc6448d93ull && C1.w[0] == 0x38c15b09ffffffffull) { // if C1 = 10^33 - 1
219 C1.w[1] = 0x0001ed09bead87c0ull; // C1 = 10^34 - 1
220 C1.w[0] = 0x378d8e63ffffffffull;
221 x_exp = x_exp - EXP_P1;
222 }
223 }
224 // assemble the result
225 res.w[1] = x_sign | x_exp | C1.w[1];
226 res.w[0] = C1.w[0];
227 } // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
228 } // end x is not special and is not zero
229 BID_RETURN (res);
230 }
231
232 /*****************************************************************************
233 * BID128 nextdown
234 ****************************************************************************/
235
236 #if DECIMAL_CALL_BY_REFERENCE
237 void
238 bid128_nextdown (UINT128 * pres,
239 UINT128 *
240 px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
241 UINT128 x = *px;
242 #else
243 UINT128
244 bid128_nextdown (UINT128 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
245 _EXC_INFO_PARAM) {
246 #endif
247
248 UINT128 res;
249 UINT64 x_sign;
250 UINT64 x_exp;
251 int exp;
252 BID_UI64DOUBLE tmp1;
253 int x_nr_bits;
254 int q1, ind;
255 UINT128 C1; // C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (UINT64)
256
257 BID_SWAP128 (x);
258 // unpack the argument
259 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
260 C1.w[1] = x.w[1] & MASK_COEFF;
261 C1.w[0] = x.w[0];
262
263 // check for NaN or Infinity
264 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) {
265 // x is special
266 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
267 // if x = NaN, then res = Q (x)
268 // check first for non-canonical NaN payload
269 if (((x.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
270 (((x.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull)
271 && (x.w[0] > 0x38c15b09ffffffffull))) {
272 x.w[1] = x.w[1] & 0xffffc00000000000ull;
273 x.w[0] = 0x0ull;
274 }
275 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN
276 // set invalid flag
277 *pfpsf |= INVALID_EXCEPTION;
278 // return quiet (x)
279 res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out also G[6]-G[16]
280 res.w[0] = x.w[0];
281 } else { // x is QNaN
282 // return x
283 res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out G[6]-G[16]
284 res.w[0] = x.w[0];
285 }
286 } else { // x is not NaN, so it must be infinity
287 if (!x_sign) { // x is +inf
288 res.w[1] = 0x5fffed09bead87c0ull; // +MAXFP = +999...99 * 10^emax
289 res.w[0] = 0x378d8e63ffffffffull;
290 } else { // x is -inf
291 res.w[1] = 0xf800000000000000ull; // -inf
292 res.w[0] = 0x0000000000000000ull;
293 }
294 }
295 BID_RETURN (res);
296 }
297 // check for non-canonical values (treated as zero)
298 if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11
299 // non-canonical
300 x_exp = (x.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits
301 C1.w[1] = 0; // significand high
302 C1.w[0] = 0; // significand low
303 } else { // G0_G1 != 11
304 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bits
305 if (C1.w[1] > 0x0001ed09bead87c0ull ||
306 (C1.w[1] == 0x0001ed09bead87c0ull
307 && C1.w[0] > 0x378d8e63ffffffffull)) {
308 // x is non-canonical if coefficient is larger than 10^34 -1
309 C1.w[1] = 0;
310 C1.w[0] = 0;
311 } else { // canonical
312 ;
313 }
314 }
315
316 if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) {
317 // x is +/-0
318 res.w[1] = 0x8000000000000000ull; // -1 * 10^emin
319 res.w[0] = 0x0000000000000001ull;
320 } else { // x is not special and is not zero
321 if (x.w[1] == 0xdfffed09bead87c0ull
322 && x.w[0] == 0x378d8e63ffffffffull) {
323 // x = -MAXFP = -999...99 * 10^emax
324 res.w[1] = 0xf800000000000000ull; // -inf
325 res.w[0] = 0x0000000000000000ull;
326 } else if (x.w[1] == 0x0ull && x.w[0] == 0x0000000000000001ull) { // +MINFP
327 res.w[1] = 0x0000000000000000ull; // +0
328 res.w[0] = 0x0000000000000000ull;
329 } else { // -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
330 // can add/subtract 1 ulp to the significand
331
332 // Note: we could check here if x >= 10^34 to speed up the case q1 = 34
333 // q1 = nr. of decimal digits in x
334 // determine first the nr. of bits in x
335 if (C1.w[1] == 0) {
336 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53
337 // split the 64-bit value in two 32-bit halves to avoid rnd errors
338 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32
339 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion
340 x_nr_bits =
341 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) -
342 0x3ff);
343 } else { // x < 2^32
344 tmp1.d = (double) (C1.w[0]); // exact conversion
345 x_nr_bits =
346 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) -
347 0x3ff);
348 }
349 } else { // if x < 2^53
350 tmp1.d = (double) C1.w[0]; // exact conversion
351 x_nr_bits =
352 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
353 }
354 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1])
355 tmp1.d = (double) C1.w[1]; // exact conversion
356 x_nr_bits =
357 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);
358 }
359 q1 = nr_digits[x_nr_bits - 1].digits;
360 if (q1 == 0) {
361 q1 = nr_digits[x_nr_bits - 1].digits1;
362 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi
363 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi
364 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo))
365 q1++;
366 }
367 // if q1 < P then pad the significand with zeros
368 if (q1 < P34) {
369 exp = (x_exp >> 49) - 6176;
370 if (exp + 6176 > P34 - q1) {
371 ind = P34 - q1; // 1 <= ind <= P34 - 1
372 // pad with P34 - q1 zeros, until exponent = emin
373 // C1 = C1 * 10^ind
374 if (q1 <= 19) { // 64-bit C1
375 if (ind <= 19) { // 64-bit 10^ind and 64-bit C1
376 __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]);
377 } else { // 128-bit 10^ind and 64-bit C1
378 __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]);
379 }
380 } else { // C1 is (most likely) 128-bit
381 if (ind <= 14) { // 64-bit 10^ind and 128-bit C1 (most likely)
382 __mul_128x64_to_128 (C1, ten2k64[ind], C1);
383 } else if (ind <= 19) { // 64-bit 10^ind and 64-bit C1 (q1 <= 19)
384 __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]);
385 } else { // 128-bit 10^ind and 64-bit C1 (C1 must be 64-bit)
386 __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]);
387 }
388 }
389 x_exp = x_exp - ((UINT64) ind << 49);
390 } else { // pad with zeros until the exponent reaches emin
391 ind = exp + 6176;
392 // C1 = C1 * 10^ind
393 if (ind <= 19) { // 1 <= P34 - q1 <= 19 <=> 15 <= q1 <= 33
394 if (q1 <= 19) { // 64-bit C1, 64-bit 10^ind
395 __mul_64x64_to_128MACH (C1, C1.w[0], ten2k64[ind]);
396 } else { // 20 <= q1 <= 33 => 128-bit C1, 64-bit 10^ind
397 __mul_128x64_to_128 (C1, ten2k64[ind], C1);
398 }
399 } else { // if 20 <= P34 - q1 <= 33 <=> 1 <= q1 <= 14 =>
400 // 64-bit C1, 128-bit 10^ind
401 __mul_128x64_to_128 (C1, C1.w[0], ten2k128[ind - 20]);
402 }
403 x_exp = EXP_MIN;
404 }
405 }
406 if (x_sign) { // x < 0
407 // add 1 ulp (add 1 to the significand)
408 C1.w[0]++;
409 if (C1.w[0] == 0)
410 C1.w[1]++;
411 if (C1.w[1] == 0x0001ed09bead87c0ull && C1.w[0] == 0x378d8e6400000000ull) { // if C1 = 10^34
412 C1.w[1] = 0x0000314dc6448d93ull; // C1 = 10^33
413 C1.w[0] = 0x38c15b0a00000000ull;
414 x_exp = x_exp + EXP_P1;
415 }
416 } else { // x > 0
417 // subtract 1 ulp (subtract 1 from the significand)
418 C1.w[0]--;
419 if (C1.w[0] == 0xffffffffffffffffull)
420 C1.w[1]--;
421 if (x_exp != 0 && C1.w[1] == 0x0000314dc6448d93ull && C1.w[0] == 0x38c15b09ffffffffull) { // if C1 = 10^33 - 1
422 C1.w[1] = 0x0001ed09bead87c0ull; // C1 = 10^34 - 1
423 C1.w[0] = 0x378d8e63ffffffffull;
424 x_exp = x_exp - EXP_P1;
425 }
426 }
427 // assemble the result
428 res.w[1] = x_sign | x_exp | C1.w[1];
429 res.w[0] = C1.w[0];
430 } // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
431 } // end x is not special and is not zero
432 BID_RETURN (res);
433 }
434
435 /*****************************************************************************
436 * BID128 nextafter
437 ****************************************************************************/
438
439 #if DECIMAL_CALL_BY_REFERENCE
440 void
441 bid128_nextafter (UINT128 * pres, UINT128 * px,
442 UINT128 *
443 py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM)
444 {
445 UINT128 x = *px;
446 UINT128 y = *py;
447 UINT128 xnswp = *px;
448 UINT128 ynswp = *py;
449 #else
450 UINT128
451 bid128_nextafter (UINT128 x,
452 UINT128 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
453 _EXC_INFO_PARAM) {
454 UINT128 xnswp = x;
455 UINT128 ynswp = y;
456 #endif
457
458 UINT128 res;
459 UINT128 tmp1, tmp2, tmp3;
460 FPSC tmp_fpsf = 0; // dummy fpsf for calls to comparison functions
461 int res1, res2;
462 UINT64 x_exp;
463
464
465 BID_SWAP128 (x);
466 BID_SWAP128 (y);
467 // check for NaNs
468 if (((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL)
469 || ((y.w[1] & MASK_SPECIAL) == MASK_SPECIAL)) {
470 // x is special or y is special
471 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN
472 // if x = NaN, then res = Q (x)
473 // check first for non-canonical NaN payload
474 if (((x.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
475 (((x.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull)
476 && (x.w[0] > 0x38c15b09ffffffffull))) {
477 x.w[1] = x.w[1] & 0xffffc00000000000ull;
478 x.w[0] = 0x0ull;
479 }
480 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN
481 // set invalid flag
482 *pfpsf |= INVALID_EXCEPTION;
483 // return quiet (x)
484 res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out also G[6]-G[16]
485 res.w[0] = x.w[0];
486 } else { // x is QNaN
487 // return x
488 res.w[1] = x.w[1] & 0xfc003fffffffffffull; // clear out G[6]-G[16]
489 res.w[0] = x.w[0];
490 if ((y.w[1] & MASK_SNAN) == MASK_SNAN) { // y is SNAN
491 // set invalid flag
492 *pfpsf |= INVALID_EXCEPTION;
493 }
494 }
495 BID_RETURN (res)
496 } else if ((y.w[1] & MASK_NAN) == MASK_NAN) { // y is NAN
497 // if x = NaN, then res = Q (x)
498 // check first for non-canonical NaN payload
499 if (((y.w[1] & 0x00003fffffffffffull) > 0x0000314dc6448d93ull) ||
500 (((y.w[1] & 0x00003fffffffffffull) == 0x0000314dc6448d93ull)
501 && (y.w[0] > 0x38c15b09ffffffffull))) {
502 y.w[1] = y.w[1] & 0xffffc00000000000ull;
503 y.w[0] = 0x0ull;
504 }
505 if ((y.w[1] & MASK_SNAN) == MASK_SNAN) { // y is SNAN
506 // set invalid flag
507 *pfpsf |= INVALID_EXCEPTION;
508 // return quiet (x)
509 res.w[1] = y.w[1] & 0xfc003fffffffffffull; // clear out also G[6]-G[16]
510 res.w[0] = y.w[0];
511 } else { // x is QNaN
512 // return x
513 res.w[1] = y.w[1] & 0xfc003fffffffffffull; // clear out G[6]-G[16]
514 res.w[0] = y.w[0];
515 }
516 BID_RETURN (res)
517 } else { // at least one is infinity
518 if ((x.w[1] & MASK_ANY_INF) == MASK_INF) { // x = inf
519 x.w[1] = x.w[1] & (MASK_SIGN | MASK_INF);
520 x.w[0] = 0x0ull;
521 }
522 if ((y.w[1] & MASK_ANY_INF) == MASK_INF) { // y = inf
523 y.w[1] = y.w[1] & (MASK_SIGN | MASK_INF);
524 y.w[0] = 0x0ull;
525 }
526 }
527 }
528 // neither x nor y is NaN
529
530 // if not infinity, check for non-canonical values x (treated as zero)
531 if ((x.w[1] & MASK_ANY_INF) != MASK_INF) { // x != inf
532 if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11
533 // non-canonical
534 x_exp = (x.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits
535 x.w[1] = (x.w[1] & MASK_SIGN) | x_exp;
536 x.w[0] = 0x0ull;
537 } else { // G0_G1 != 11
538 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bits
539 if ((x.w[1] & MASK_COEFF) > 0x0001ed09bead87c0ull ||
540 ((x.w[1] & MASK_COEFF) == 0x0001ed09bead87c0ull
541 && x.w[0] > 0x378d8e63ffffffffull)) {
542 // x is non-canonical if coefficient is larger than 10^34 -1
543 x.w[1] = (x.w[1] & MASK_SIGN) | x_exp;
544 x.w[0] = 0x0ull;
545 } else { // canonical
546 ;
547 }
548 }
549 }
550 // no need to check for non-canonical y
551
552 // neither x nor y is NaN
553 tmp_fpsf = *pfpsf; // save fpsf
554 #if DECIMAL_CALL_BY_REFERENCE
555 bid128_quiet_equal (&res1, &xnswp,
556 &ynswp _EXC_FLAGS_ARG _EXC_MASKS_ARG
557 _EXC_INFO_ARG);
558 bid128_quiet_greater (&res2, &xnswp,
559 &ynswp _EXC_FLAGS_ARG _EXC_MASKS_ARG
560 _EXC_INFO_ARG);
561 #else
562 res1 =
563 bid128_quiet_equal (xnswp,
564 ynswp _EXC_FLAGS_ARG _EXC_MASKS_ARG
565 _EXC_INFO_ARG);
566 res2 =
567 bid128_quiet_greater (xnswp,
568 ynswp _EXC_FLAGS_ARG _EXC_MASKS_ARG
569 _EXC_INFO_ARG);
570 #endif
571 *pfpsf = tmp_fpsf; // restore fpsf
572
573 if (res1) { // x = y
574 // return x with the sign of y
575 res.w[1] =
576 (x.w[1] & 0x7fffffffffffffffull) | (y.
577 w[1] & 0x8000000000000000ull);
578 res.w[0] = x.w[0];
579 } else if (res2) { // x > y
580 #if DECIMAL_CALL_BY_REFERENCE
581 bid128_nextdown (&res,
582 &xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG
583 _EXC_INFO_ARG);
584 #else
585 res =
586 bid128_nextdown (xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG
587 _EXC_INFO_ARG);
588 #endif
589 BID_SWAP128 (res);
590 } else { // x < y
591 #if DECIMAL_CALL_BY_REFERENCE
592 bid128_nextup (&res,
593 &xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
594 #else
595 res =
596 bid128_nextup (xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
597 #endif
598 BID_SWAP128 (res);
599 }
600 // if the operand x is finite but the result is infinite, signal
601 // overflow and inexact
602 if (((x.w[1] & MASK_SPECIAL) != MASK_SPECIAL)
603 && ((res.w[1] & MASK_SPECIAL) == MASK_SPECIAL)) {
604 // set the inexact flag
605 *pfpsf |= INEXACT_EXCEPTION;
606 // set the overflow flag
607 *pfpsf |= OVERFLOW_EXCEPTION;
608 }
609 // if the result is in (-10^emin, 10^emin), and is different from the
610 // operand x, signal underflow and inexact
611 tmp1.w[HIGH_128W] = 0x0000314dc6448d93ull;
612 tmp1.w[LOW_128W] = 0x38c15b0a00000000ull; // +100...0[34] * 10^emin
613 tmp2.w[HIGH_128W] = res.w[1] & 0x7fffffffffffffffull;
614 tmp2.w[LOW_128W] = res.w[0];
615 tmp3.w[HIGH_128W] = res.w[1];
616 tmp3.w[LOW_128W] = res.w[0];
617 tmp_fpsf = *pfpsf; // save fpsf
618 #if DECIMAL_CALL_BY_REFERENCE
619 bid128_quiet_greater (&res1, &tmp1,
620 &tmp2 _EXC_FLAGS_ARG _EXC_MASKS_ARG
621 _EXC_INFO_ARG);
622 bid128_quiet_not_equal (&res2, &xnswp,
623 &tmp3 _EXC_FLAGS_ARG _EXC_MASKS_ARG
624 _EXC_INFO_ARG);
625 #else
626 res1 =
627 bid128_quiet_greater (tmp1,
628 tmp2 _EXC_FLAGS_ARG _EXC_MASKS_ARG
629 _EXC_INFO_ARG);
630 res2 =
631 bid128_quiet_not_equal (xnswp,
632 tmp3 _EXC_FLAGS_ARG _EXC_MASKS_ARG
633 _EXC_INFO_ARG);
634 #endif
635 *pfpsf = tmp_fpsf; // restore fpsf
636 if (res1 && res2) {
637 // set the inexact flag
638 *pfpsf |= INEXACT_EXCEPTION;
639 // set the underflow flag
640 *pfpsf |= UNDERFLOW_EXCEPTION;
641 }
642 BID_RETURN (res);
643 }
Mirror of https://gcc.gnu.org/git/gcc.git