Mercurial > hg > CbC > CbC_gcc
comparison libgcc/config/libbid/bid128_next.c @ 0:a06113de4d67
first commit
author | kent <kent@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 17 Jul 2009 14:47:48 +0900 |
parents | |
children | 04ced10e8804 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a06113de4d67 |
---|---|
1 /* Copyright (C) 2007, 2009 Free Software Foundation, Inc. | |
2 | |
3 This file is part of GCC. | |
4 | |
5 GCC is free software; you can redistribute it and/or modify it under | |
6 the terms of the GNU General Public License as published by the Free | |
7 Software Foundation; either version 3, or (at your option) any later | |
8 version. | |
9 | |
10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
13 for more details. | |
14 | |
15 Under Section 7 of GPL version 3, you are granted additional | |
16 permissions described in the GCC Runtime Library Exception, version | |
17 3.1, as published by the Free Software Foundation. | |
18 | |
19 You should have received a copy of the GNU General Public License and | |
20 a copy of the GCC Runtime Library Exception along with this program; | |
21 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
22 <http://www.gnu.org/licenses/>. */ | |
23 | |
24 #define BID_128RES | |
25 #include "bid_internal.h" | |
26 | |
27 /***************************************************************************** | |
28 * BID128 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 } |