]> git.ipfire.org Git - thirdparty/gcc.git/blame - libgcc/config/libbid/bid128_next.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update copyright years.
[thirdparty/gcc.git] / libgcc / config / libbid / bid128_next.c
CommitLineData
8d9254fc 1/* Copyright (C) 2007-2020 Free Software Foundation, Inc.
200359e8
L		 2
3This file is part of GCC.
4
5GCC is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License as published by the Free
748086b7 7Software Foundation; either version 3, or (at your option) any later
200359e8
L		 8version.
9
200359e8
L		 10GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11WARRANTY; without even the implied warranty of MERCHANTABILITY or
12FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13for more details.
14
748086b7
JJ		 15Under Section 7 of GPL version 3, you are granted additional
16permissions described in the GCC Runtime Library Exception, version
173.1, as published by the Free Software Foundation.
18
19You should have received a copy of the GNU General Public License and
20a copy of the GCC Runtime Library Exception along with this program;
21see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
22<http://www.gnu.org/licenses/>. */
200359e8
L		 23
24#define BID_128RES
25#include "bid_internal.h"
26
27/*****************************************************************************
28 * BID128 nextup
29 ****************************************************************************/
30
31#if DECIMAL_CALL_BY_REFERENCE
32void
b2a00c89
L		 33bid128_nextup (UINT128 * pres,
34 UINT128 *
35 px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
200359e8
L		 36 UINT128 x = *px;
37#else
38UINT128
b2a00c89
L		 39bid128_nextup (UINT128 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
40 _EXC_INFO_PARAM) {
200359e8
L		 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;
b2a00c89 50 UINT128 C1; // C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (UINT64)
200359e8 51
b2a00c89 52 BID_SWAP128 (x);
200359e8 53 // unpack the argument
b2a00c89 54 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
200359e8
L		 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
b2a00c89
L		 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;
200359e8 69 }
b2a00c89
L		 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;
200359e8
L		 88 }
89 }
90 BID_RETURN (res);
91 }
b2a00c89
L		 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 }
200359e8
L		 109 }
110
111 if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) {
112 // x is +/-0
b2a00c89 113 res.w[1] = 0x0000000000000000ull; // +1 * 10^emin
200359e8 114 res.w[0] = 0x0000000000000001ull;
b2a00c89 115 } else { // x is not special and is not zero
200359e8 116 if (x.w[1] == 0x5fffed09bead87c0ull
b2a00c89 117 && x.w[0] == 0x378d8e63ffffffffull) {
200359e8 118 // x = +MAXFP = 999...99 * 10^emax
b2a00c89 119 res.w[1] = 0x7800000000000000ull; // +inf
200359e8
L		 120 res.w[0] = 0x0000000000000000ull;
121 } else if (x.w[1] == 0x8000000000000000ull
b2a00c89 122 && x.w[0] == 0x0000000000000001ull) {
200359e8 123 // x = -MINFP = 1...99 * 10^emin
b2a00c89 124 res.w[1] = 0x8000000000000000ull; // -0
200359e8 125 res.w[0] = 0x0000000000000000ull;
b2a00c89 126 } else { // -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
200359e8
L		 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) {
b2a00c89
L		 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);
200359e8 155 }
b2a00c89 156 q1 = nr_digits[x_nr_bits - 1].digits;
200359e8 157 if (q1 == 0) {
b2a00c89
L		 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++;
200359e8
L		 163 }
164 // if q1 < P34 then pad the significand with zeros
165 if (q1 < P34) {
b2a00c89
L		 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 }
200359e8 202 }
b2a00c89
L		 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 }
200359e8
L		 223 }
224 // assemble the result
225 res.w[1] = x_sign | x_exp | C1.w[1];
226 res.w[0] = C1.w[0];
b2a00c89
L		 227 } // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
228 } // end x is not special and is not zero
200359e8
L		 229 BID_RETURN (res);
230}
231
232/*****************************************************************************
233 * BID128 nextdown
234 ****************************************************************************/
235
236#if DECIMAL_CALL_BY_REFERENCE
237void
b2a00c89
L		 238bid128_nextdown (UINT128 * pres,
239 UINT128 *
240 px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
200359e8
L		 241 UINT128 x = *px;
242#else
243UINT128
b2a00c89
L		 244bid128_nextdown (UINT128 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
245 _EXC_INFO_PARAM) {
200359e8
L		 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;
b2a00c89 255 UINT128 C1; // C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (UINT64)
200359e8 256
b2a00c89 257 BID_SWAP128 (x);
200359e8 258 // unpack the argument
b2a00c89 259 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
200359e8
L		 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
b2a00c89
L		 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];
200359e8 285 }
b2a00c89
L		 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;
200359e8
L		 293 }
294 }
295 BID_RETURN (res);
296 }
b2a00c89
L		 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 }
200359e8
L		 314 }
315
316 if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) {
317 // x is +/-0
b2a00c89 318 res.w[1] = 0x8000000000000000ull; // -1 * 10^emin
200359e8 319 res.w[0] = 0x0000000000000001ull;
b2a00c89 320 } else { // x is not special and is not zero
200359e8 321 if (x.w[1] == 0xdfffed09bead87c0ull
b2a00c89 322 && x.w[0] == 0x378d8e63ffffffffull) {
200359e8 323 // x = -MAXFP = -999...99 * 10^emax
b2a00c89 324 res.w[1] = 0xf800000000000000ull; // -inf
200359e8 325 res.w[0] = 0x0000000000000000ull;
b2a00c89
L		 326 } else if (x.w[1] == 0x0ull && x.w[0] == 0x0000000000000001ull) { // +MINFP
327 res.w[1] = 0x0000000000000000ull; // +0
200359e8 328 res.w[0] = 0x0000000000000000ull;
b2a00c89 329 } else { // -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
200359e8
L		 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) {
b2a00c89
L		 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);
200359e8 358 }
b2a00c89 359 q1 = nr_digits[x_nr_bits - 1].digits;
200359e8 360 if (q1 == 0) {
b2a00c89
L		 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++;
200359e8
L		 366 }
367 // if q1 < P then pad the significand with zeros
368 if (q1 < P34) {
b2a00c89
L		 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 }
200359e8 405 }
b2a00c89
L		 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 }
200359e8
L		 426 }
427 // assemble the result
428 res.w[1] = x_sign | x_exp | C1.w[1];
429 res.w[0] = C1.w[0];
b2a00c89
L		 430 } // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp
431 } // end x is not special and is not zero
200359e8
L		 432 BID_RETURN (res);
433}
434
435/*****************************************************************************
436 * BID128 nextafter
437 ****************************************************************************/
438
439#if DECIMAL_CALL_BY_REFERENCE
440void
b2a00c89
L		 441bid128_nextafter (UINT128 * pres, UINT128 * px,
442 UINT128 *
443 py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM)
200359e8
L		 444{
445 UINT128 x = *px;
446 UINT128 y = *py;
447 UINT128 xnswp = *px;
448 UINT128 ynswp = *py;
449#else
450UINT128
b2a00c89
L		 451bid128_nextafter (UINT128 x,
452 UINT128 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
453 _EXC_INFO_PARAM) {
200359e8
L		 454 UINT128 xnswp = x;
455 UINT128 ynswp = y;
456#endif
457
458 UINT128 res;
b2a00c89
L		 459 UINT128 tmp1, tmp2, tmp3;
460 FPSC tmp_fpsf = 0; // dummy fpsf for calls to comparison functions
200359e8 461 int res1, res2;
b2a00c89 462 UINT64 x_exp;
200359e8 463
b2a00c89
L		 464
465 BID_SWAP128 (x);
466 BID_SWAP128 (y);
200359e8
L		 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
b2a00c89
L		 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];
200359e8 515 }
b2a00c89
L		 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;
200359e8 525 }
200359e8
L		 526 }
527 }
528 // neither x nor y is NaN
b2a00c89
L		 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
200359e8 554#if DECIMAL_CALL_BY_REFERENCE
b2a00c89
L		 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);
200359e8
L		 561#else
562 res1 =
b2a00c89
L		 563 bid128_quiet_equal (xnswp,
564 ynswp _EXC_FLAGS_ARG _EXC_MASKS_ARG
565 _EXC_INFO_ARG);
200359e8 566 res2 =
b2a00c89
L		 567 bid128_quiet_greater (xnswp,
568 ynswp _EXC_FLAGS_ARG _EXC_MASKS_ARG
569 _EXC_INFO_ARG);
200359e8 570#endif
b2a00c89
L		 571 *pfpsf = tmp_fpsf; // restore fpsf
572
573 if (res1) { // x = y
200359e8 574 // return x with the sign of y
b2a00c89
L		 575 res.w[1] =
576 (x.w[1] & 0x7fffffffffffffffull) | (y.
577 w[1] & 0x8000000000000000ull);
200359e8 578 res.w[0] = x.w[0];
b2a00c89 579 } else if (res2) { // x > y
200359e8 580#if DECIMAL_CALL_BY_REFERENCE
b2a00c89
L		 581 bid128_nextdown (&res,
582 &xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG
583 _EXC_INFO_ARG);
200359e8
L		 584#else
585 res =
b2a00c89
L		 586 bid128_nextdown (xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG
587 _EXC_INFO_ARG);
200359e8 588#endif
b2a00c89
L		 589 BID_SWAP128 (res);
590 } else { // x < y
200359e8 591#if DECIMAL_CALL_BY_REFERENCE
b2a00c89
L		 592 bid128_nextup (&res,
593 &xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
200359e8 594#else
b2a00c89
L		 595 res =
596 bid128_nextup (xnswp _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
200359e8 597#endif
b2a00c89 598 BID_SWAP128 (res);
200359e8
L		 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
b2a00c89
L		 611 tmp1.w[HIGH_128W] = 0x0000314dc6448d93ull;
612 tmp1.w[LOW_128W] = 0x38c15b0a00000000ull; // +100...0[34] * 10^emin
200359e8
L		 613 tmp2.w[HIGH_128W] = res.w[1] & 0x7fffffffffffffffull;
614 tmp2.w[LOW_128W] = res.w[0];
b2a00c89
L		 615 tmp3.w[HIGH_128W] = res.w[1];
616 tmp3.w[LOW_128W] = res.w[0];
617 tmp_fpsf = *pfpsf; // save fpsf
200359e8 618#if DECIMAL_CALL_BY_REFERENCE
b2a00c89
L		 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);
200359e8
L		 625#else
626 res1 =
b2a00c89
L		 627 bid128_quiet_greater (tmp1,
628 tmp2 _EXC_FLAGS_ARG _EXC_MASKS_ARG
629 _EXC_INFO_ARG);
200359e8 630 res2 =
b2a00c89
L		 631 bid128_quiet_not_equal (xnswp,
632 tmp3 _EXC_FLAGS_ARG _EXC_MASKS_ARG
633 _EXC_INFO_ARG);
200359e8 634#endif
b2a00c89 635 *pfpsf = tmp_fpsf; // restore fpsf
200359e8
L		 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