1 /* Copyright (C) 2007-2013 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 DECNUMDIGITS 34 // work with up to 34 digits
25
26 #include "bid_internal.h"
27 #include "bid_b2d.h"
28
29 UINT32
bid_to_bid32(UINT32 ba)30 bid_to_bid32 (UINT32 ba) {
31 UINT32 res;
32 UINT32 sign, comb, exp;
33 UINT32 trailing;
34 UINT32 bcoeff;
35
36 sign = (ba & 0x80000000ul);
37 comb = (ba & 0x7ff00000ul) >> 20;
38 trailing = (ba & 0x000ffffful);
39
40 if ((comb & 0x780) == 0x780) {
41 ba &= 0xfff0000ul;
42 return ba;
43 } else {
44 if ((comb & 0x600) == 0x600) { // G0..G1 = 11 -> exp is G2..G11
45 exp = (comb >> 1) & 0xff;
46 bcoeff = ((8 + (comb & 1)) << 20) | trailing;
47 } else {
48 exp = (comb >> 3) & 0xff;
49 bcoeff = ((comb & 7) << 20) | trailing;
50 }
51 if (bcoeff >= 10000000)
52 bcoeff = 0;
53 res = very_fast_get_BID32 (sign, exp, bcoeff);
54 }
55 return res;
56 }
57
58 UINT64
bid_to_bid64(UINT64 ba)59 bid_to_bid64 (UINT64 ba) {
60 UINT64 res;
61 UINT64 sign, comb, exp;
62 UINT64 trailing;
63 UINT64 bcoeff;
64
65 sign = (ba & 0x8000000000000000ull);
66 comb = (ba & 0x7ffc000000000000ull) >> 50;
67 trailing = (ba & 0x0003ffffffffffffull);
68
69 if ((comb & 0x1e00) == 0x1e00) {
70 ba &= 0xfff000000000000ULL;
71 return ba;
72 } else {
73 if ((comb & 0x1800) == 0x1800) { // G0..G1 = 11 -> exp is G2..G11
74 exp = (comb >> 1) & 0x3ff;
75 bcoeff = ((8 + (comb & 1)) << 50) | trailing;
76 } else {
77 exp = (comb >> 3) & 0x3ff;
78 bcoeff = ((comb & 7) << 50) | trailing;
79 }
80 if (bcoeff >= 10000000000000000ull)
81 bcoeff = 0ull;
82 res = very_fast_get_BID64 (sign, exp, bcoeff);
83 }
84 return res;
85 }
86
87 #if DECIMAL_CALL_BY_REFERENCE
88 void
bid_to_dpd32(UINT32 * pres,UINT32 * pba)89 bid_to_dpd32 (UINT32 * pres, UINT32 * pba) {
90 UINT32 ba = *pba;
91 #else
92 UINT32
93 bid_to_dpd32 (UINT32 ba) {
94 #endif
95 UINT32 res;
96
97 UINT32 sign, comb, exp, trailing;
98 UINT32 b0, b1, b2;
99 UINT32 bcoeff, dcoeff;
100 UINT32 nanb = 0;
101
102 sign = (ba & 0x80000000);
103 comb = (ba & 0x7ff00000) >> 20;
104 trailing = (ba & 0xfffff);
105
106 // Detect infinity, and return canonical infinity
107 if ((comb & 0x7c0) == 0x780) {
108 res = sign | 0x78000000;
109 BID_RETURN (res);
110 // Detect NaN, and canonicalize trailing
111 } else if ((comb & 0x7c0) == 0x7c0) {
112 if (trailing > 999999)
113 trailing = 0;
114 nanb = ba & 0xfe000000;
115 exp = 0;
116 bcoeff = trailing;
117 } else { // Normal number
118 if ((comb & 0x600) == 0x600) { // G0..G1 = 11 -> exp is G2..G11
119 exp = (comb >> 1) & 0xff;
120 bcoeff = ((8 + (comb & 1)) << 20) | trailing;
121 } else {
122 exp = (comb >> 3) & 0xff;
123 bcoeff = ((comb & 7) << 20) | trailing;
124 }
125 // Zero the coefficient if non-canonical (>= 10^7)
126 if (bcoeff >= 10000000)
127 bcoeff = 0;
128 }
129
130 b0 = bcoeff / 1000000;
131 b1 = (bcoeff / 1000) % 1000;
132 b2 = bcoeff % 1000;
133 dcoeff = (b2d[b1] << 10) | b2d[b2];
134
135 if (b0 >= 8) // is b0 8 or 9?
136 res =
137 sign |
138 ((0x600 | ((exp >> 6) << 7) | ((b0 & 1) << 6) | (exp & 0x3f)) <<
139 20) | dcoeff;
140 else // else b0 is 0..7
141 res =
142 sign | ((((exp >> 6) << 9) | (b0 << 6) | (exp & 0x3f)) << 20) |
143 dcoeff;
144
145 res |= nanb;
146
147 BID_RETURN (res);
148 }
149
150 #if DECIMAL_CALL_BY_REFERENCE
151 void
152 bid_to_dpd64 (UINT64 * pres, UINT64 * pba) {
153 UINT64 ba = *pba;
154 #else
155 UINT64
156 bid_to_dpd64 (UINT64 ba) {
157 #endif
158 UINT64 res;
159
160 UINT64 sign, comb, exp;
161 UINT64 trailing;
162 UINT32 b0, b1, b2, b3, b4, b5;
163 UINT64 bcoeff;
164 UINT64 dcoeff;
165 UINT32 yhi, ylo;
166 UINT64 nanb = 0;
167
168 //printf("arg bid "FMT_LLX16" \n", ba);
169 sign = (ba & 0x8000000000000000ull);
170 comb = (ba & 0x7ffc000000000000ull) >> 50;
171 trailing = (ba & 0x0003ffffffffffffull);
172
173 // Detect infinity, and return canonical infinity
174 if ((comb & 0x1f00) == 0x1e00) {
175 res = sign | 0x7800000000000000ull;
176 BID_RETURN (res);
177 // Detect NaN, and canonicalize trailing
178 } else if ((comb & 0x1e00) == 0x1e00) {
179 if (trailing > 999999999999999ull)
180 trailing = 0;
181 nanb = ba & 0xfe00000000000000ull;
182 exp = 0;
183 bcoeff = trailing;
184 } else { // Normal number
185 if ((comb & 0x1800) == 0x1800) { // G0..G1 = 11 -> exp is G2..G11
186 exp = (comb >> 1) & 0x3ff;
187 bcoeff = ((8 + (comb & 1)) << 50) | trailing;
188 } else {
189 exp = (comb >> 3) & 0x3ff;
190 bcoeff = ((comb & 7) << 50) | trailing;
191 }
192
193 // Zero the coefficient if it is non-canonical (>= 10^16)
194 if (bcoeff >= 10000000000000000ull)
195 bcoeff = 0;
196 }
197
198 // Floor(2^61 / 10^9)
199 #define D61 (2305843009ull)
200
201 // Multipy the binary coefficient by ceil(2^64 / 1000), and take the upper
202 // 64-bits in order to compute a division by 1000.
203
204 #if 1
205 yhi =
206 ((UINT64) D61 *
207 (UINT64) (UINT32) (bcoeff >> (UINT64) 27)) >> (UINT64) 34;
208 ylo = bcoeff - 1000000000ull * yhi;
209 if (ylo >= 1000000000) {
210 ylo = ylo - 1000000000;
211 yhi = yhi + 1;
212 }
213 #else
214 yhi = bcoeff / 1000000000ull;
215 ylo = bcoeff % 1000000000ull;
216 #endif
217
218 // yhi = ABBBCCC ylo = DDDEEEFFF
219 b5 = ylo % 1000; // b5 = FFF
220 b3 = ylo / 1000000; // b3 = DDD
221 b4 = (ylo / 1000) - (1000 * b3); // b4 = EEE
222 b2 = yhi % 1000; // b2 = CCC
223 b0 = yhi / 1000000; // b0 = A
224 b1 = (yhi / 1000) - (1000 * b0); // b1 = BBB
225
226 dcoeff = b2d[b5] | b2d2[b4] | b2d3[b3] | b2d4[b2] | b2d5[b1];
227
228 if (b0 >= 8) // is b0 8 or 9?
229 res =
230 sign |
231 ((0x1800 | ((exp >> 8) << 9) | ((b0 & 1) << 8) | (exp & 0xff)) <<
232 50) | dcoeff;
233 else // else b0 is 0..7
234 res =
235 sign | ((((exp >> 8) << 11) | (b0 << 8) | (exp & 0xff)) << 50) |
236 dcoeff;
237
238 res |= nanb;
239
240 BID_RETURN (res);
241 }
242
243 #if DECIMAL_CALL_BY_REFERENCE
244 void
245 dpd_to_bid32 (UINT32 * pres, UINT32 * pda) {
246 UINT32 da = *pda;
247 #else
248 UINT32
249 dpd_to_bid32 (UINT32 da) {
250 #endif
251 UINT32 in = *(UINT32 *) & da;
252 UINT32 res;
253
254 UINT32 sign, comb, exp;
255 UINT32 trailing;
256 UINT32 d0 = 0, d1, d2;
257 UINT64 bcoeff;
258 UINT32 nanb = 0;
259
260 sign = (in & 0x80000000);
261 comb = (in & 0x7ff00000) >> 20;
262 trailing = (in & 0x000fffff);
263
264 if ((comb & 0x7e0) == 0x780) { // G0..G4 = 1111 -> Inf
265 res = in & 0xf8000000;
266 BID_RETURN (res);
267 } else if ((comb & 0x7c0) == 0x7c0) { // G0..G5 = 11111 -> NaN
268 nanb = in & 0xfe000000;
269 exp = 0;
270 } else { // Normal number
271 if ((comb & 0x600) == 0x600) { // G0..G1 = 11 -> d0 = 8 + G4
272 d0 = ((comb >> 6) & 1) | 8;
273 exp = ((comb & 0x180) >> 1) | (comb & 0x3f);
274 } else {
275 d0 = (comb >> 6) & 0x7;
276 exp = ((comb & 0x600) >> 3) | (comb & 0x3f);
277 }
278 }
279 d1 = d2b2[(trailing >> 10) & 0x3ff];
280 d2 = d2b[(trailing) & 0x3ff];
281
282 bcoeff = d2 + d1 + (1000000 * d0);
283 if (bcoeff < 0x800000) {
284 res = (exp << 23) | bcoeff | sign;
285 } else {
286 res = (exp << 21) | sign | 0x60000000 | (bcoeff & 0x1fffff);
287 }
288
289 res |= nanb;
290
291 BID_RETURN (res);
292 }
293
294 #if DECIMAL_CALL_BY_REFERENCE
295 void
296 dpd_to_bid64 (UINT64 * pres, UINT64 * pda) {
297 UINT64 da = *pda;
298 #else
299 UINT64
300 dpd_to_bid64 (UINT64 da) {
301 #endif
302 UINT64 in = *(UINT64 *) & da;
303 UINT64 res;
304
305 UINT64 sign, comb, exp;
306 UINT64 trailing;
307 // UINT64 d0, d1, d2, d3, d4, d5;
308
309 UINT64 d1, d2;
310 UINT32 d0, d3, d4, d5;
311 UINT64 bcoeff;
312 UINT64 nanb = 0;
313
314 //printf("arg dpd "FMT_LLX16" \n", in);
315 sign = (in & 0x8000000000000000ull);
316 comb = (in & 0x7ffc000000000000ull) >> 50;
317 trailing = (in & 0x0003ffffffffffffull);
318
319 if ((comb & 0x1f00) == 0x1e00) { // G0..G4 = 1111 -> Inf
320 res = in & 0xf800000000000000ull;
321 BID_RETURN (res);
322 } else if ((comb & 0x1f00) == 0x1f00) { // G0..G5 = 11111 -> NaN
323 nanb = in & 0xfe00000000000000ull;
324 exp = 0;
325 d0 = 0;
326 } else { // Normal number
327 if ((comb & 0x1800) == 0x1800) { // G0..G1 = 11 -> d0 = 8 + G4
328 d0 = ((comb >> 8) & 1) | 8;
329 // d0 = (comb & 0x0100 ? 9 : 8);
330 exp = (comb & 0x600) >> 1;
331 // exp = (comb & 0x0400 ? 1 : 0) * 0x200 + (comb & 0x0200 ? 1 : 0) * 0x100; // exp leading bits are G2..G3
332 } else {
333 d0 = (comb >> 8) & 0x7;
334 exp = (comb & 0x1800) >> 3;
335 // exp = (comb & 0x1000 ? 1 : 0) * 0x200 + (comb & 0x0800 ? 1 : 0) * 0x100; // exp loading bits are G0..G1
336 }
337 }
338 d1 = d2b5[(trailing >> 40) & 0x3ff];
339 d2 = d2b4[(trailing >> 30) & 0x3ff];
340 d3 = d2b3[(trailing >> 20) & 0x3ff];
341 d4 = d2b2[(trailing >> 10) & 0x3ff];
342 d5 = d2b[(trailing) & 0x3ff];
343
344 bcoeff = (d5 + d4 + d3) + d2 + d1 + (1000000000000000ull * d0);
345 exp += (comb & 0xff);
346 res = very_fast_get_BID64 (sign, exp, bcoeff);
347
348 res |= nanb;
349
350 BID_RETURN (res);
351 }
352
353 #if DECIMAL_CALL_BY_REFERENCE
354 void
355 bid_to_dpd128 (UINT128 * pres, UINT128 * pba) {
356 UINT128 ba = *pba;
357 #else
358 UINT128
359 bid_to_dpd128 (UINT128 ba) {
360 #endif
361 UINT128 res;
362
363 UINT128 sign;
364 UINT32 comb, exp;
365 UINT128 trailing;
366 UINT128 d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11;
367 UINT128 bcoeff;
368 UINT128 dcoeff;
369 UINT64 nanb = 0;
370
371 sign.w[1] = (ba.w[HIGH_128W] & 0x8000000000000000ull);
372 sign.w[0] = 0;
373 comb = (ba.w[HIGH_128W] & 0x7fffc00000000000ull) >> 46;
374 trailing.w[1] = (ba.w[HIGH_128W] & 0x00003fffffffffffull);
375 trailing.w[0] = ba.w[LOW_128W];
376 exp = 0;
377
378 if ((comb & 0x1f000) == 0x1e000) { // G0..G4 = 1111 -> Inf
379 res.w[HIGH_128W] = ba.w[HIGH_128W] & 0xf800000000000000ull;
380 res.w[LOW_128W] = 0;
381 BID_RETURN (res);
382 // Detect NaN, and canonicalize trailing
383 } else if ((comb & 0x1f000) == 0x1f000) {
384 if ((trailing.w[1] > 0x0000314dc6448d93ULL) || // significand is non-canonical
385 ((trailing.w[1] == 0x0000314dc6448d93ULL)
386 && (trailing.w[0] >= 0x38c15b0a00000000ULL))
387 // significand is non-canonical
388 ) {
389 trailing.w[1] = trailing.w[0] = 0ull;
390 }
391 bcoeff.w[1] = trailing.w[1];
392 bcoeff.w[0] = trailing.w[0];
393 nanb = ba.w[HIGH_128W] & 0xfe00000000000000ull;
394 exp = 0;
395 } else { // Normal number
396 if ((comb & 0x18000) == 0x18000) { // G0..G1 = 11 -> exp is G2..G11
397 exp = (comb >> 1) & 0x3fff;
398 bcoeff.w[1] =
399 ((UINT64) (8 + (comb & 1)) << (UINT64) 46) | trailing.w[1];
400 bcoeff.w[0] = trailing.w[0];
401 } else {
402 exp = (comb >> 3) & 0x3fff;
403 bcoeff.w[1] =
404 ((UINT64) (comb & 7) << (UINT64) 46) | trailing.w[1];
405 bcoeff.w[0] = trailing.w[0];
406 }
407 // Zero the coefficient if non-canonical (>= 10^34)
408 if (bcoeff.w[1] > 0x1ed09bead87c0ull ||
409 (bcoeff.w[1] == 0x1ed09bead87c0ull
410 && bcoeff.w[0] >= 0x378D8E6400000000ull)) {
411 bcoeff.w[0] = bcoeff.w[1] = 0;
412 }
413 }
414 // Constant 2^128 / 1000 + 1
415 {
416 UINT128 t;
417 UINT64 t2;
418 UINT128 d1000;
419 UINT128 b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1;
420 d1000.w[1] = 0x4189374BC6A7EFull;
421 d1000.w[0] = 0x9DB22D0E56041894ull;
422 __mul_128x128_high (b11, bcoeff, d1000);
423 __mul_128x128_high (b10, b11, d1000);
424 __mul_128x128_high (b9, b10, d1000);
425 __mul_128x128_high (b8, b9, d1000);
426 __mul_128x128_high (b7, b8, d1000);
427 __mul_128x128_high (b6, b7, d1000);
428 __mul_128x128_high (b5, b6, d1000);
429 __mul_128x128_high (b4, b5, d1000);
430 __mul_128x128_high (b3, b4, d1000);
431 __mul_128x128_high (b2, b3, d1000);
432 __mul_128x128_high (b1, b2, d1000);
433
434
435 __mul_64x128_full (t2, t, 1000ull, b11);
436 __sub_128_128 (d11, bcoeff, t);
437 __mul_64x128_full (t2, t, 1000ull, b10);
438 __sub_128_128 (d10, b11, t);
439 __mul_64x128_full (t2, t, 1000ull, b9);
440 __sub_128_128 (d9, b10, t);
441 __mul_64x128_full (t2, t, 1000ull, b8);
442 __sub_128_128 (d8, b9, t);
443 __mul_64x128_full (t2, t, 1000ull, b7);
444 __sub_128_128 (d7, b8, t);
445 __mul_64x128_full (t2, t, 1000ull, b6);
446 __sub_128_128 (d6, b7, t);
447 __mul_64x128_full (t2, t, 1000ull, b5);
448 __sub_128_128 (d5, b6, t);
449 __mul_64x128_full (t2, t, 1000ull, b4);
450 __sub_128_128 (d4, b5, t);
451 __mul_64x128_full (t2, t, 1000ull, b3);
452 __sub_128_128 (d3, b4, t);
453 __mul_64x128_full (t2, t, 1000ull, b2);
454 __sub_128_128 (d2, b3, t);
455 __mul_64x128_full (t2, t, 1000ull, b1);
456 __sub_128_128 (d1, b2, t);
457 d0 = b1;
458
459 }
460
461 dcoeff.w[0] = b2d[d11.w[0]] | (b2d[d10.w[0]] << 10) |
462 (b2d[d9.w[0]] << 20) | (b2d[d8.w[0]] << 30) | (b2d[d7.w[0]] << 40) |
463 (b2d[d6.w[0]] << 50) | (b2d[d5.w[0]] << 60);
464 dcoeff.w[1] =
465 (b2d[d5.w[0]] >> 4) | (b2d[d4.w[0]] << 6) | (b2d[d3.w[0]] << 16) |
466 (b2d[d2.w[0]] << 26) | (b2d[d1.w[0]] << 36);
467
468 res.w[0] = dcoeff.w[0];
469 if (d0.w[0] >= 8) {
470 res.w[1] =
471 sign.
472 w[1] |
473 ((0x18000 | ((exp >> 12) << 13) | ((d0.w[0] & 1) << 12) |
474 (exp & 0xfff)) << 46) | dcoeff.w[1];
475 } else {
476 res.w[1] =
477 sign.
478 w[1] | ((((exp >> 12) << 15) | (d0.w[0] << 12) | (exp & 0xfff))
479 << 46) | dcoeff.w[1];
480 }
481
482 res.w[1] |= nanb;
483
484 BID_SWAP128 (res);
485 BID_RETURN (res);
486 }
487
488 #if DECIMAL_CALL_BY_REFERENCE
489 void
490 dpd_to_bid128 (UINT128 * pres, UINT128 * pda) {
491 UINT128 da = *pda;
492 #else
493 UINT128
494 dpd_to_bid128 (UINT128 da) {
495 #endif
496 UINT128 in = *(UINT128 *) & da;
497 UINT128 res;
498
499 UINT128 sign;
500 UINT64 exp, comb;
501 UINT128 trailing;
502 UINT64 d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11;
503 UINT128 bcoeff;
504 UINT64 tl, th;
505 UINT64 nanb = 0;
506
507 sign.w[1] = (in.w[HIGH_128W] & 0x8000000000000000ull);
508 sign.w[0] = 0;
509 comb = (in.w[HIGH_128W] & 0x7fffc00000000000ull) >> 46;
510 trailing.w[1] = (in.w[HIGH_128W] & 0x00003fffffffffffull);
511 trailing.w[0] = in.w[LOW_128W];
512 exp = 0;
513
514 if ((comb & 0x1f000) == 0x1e000) { // G0..G4 = 1111 -> Inf
515 res.w[HIGH_128W] = in.w[HIGH_128W] & 0xf800000000000000ull;
516 res.w[LOW_128W] = 0ull;
517 BID_RETURN (res);
518 } else if ((comb & 0x1f000) == 0x1f000) { // G0..G4 = 11111 -> NaN
519 nanb = in.w[HIGH_128W] & 0xfe00000000000000ull;
520 exp = 0;
521 d0 = 0;
522 } else { // Normal number
523 if ((comb & 0x18000) == 0x18000) { // G0..G1 = 11 -> d0 = 8 + G4
524 d0 = 8 + (comb & 0x01000 ? 1 : 0);
525 exp =
526 (comb & 0x04000 ? 1 : 0) * 0x2000 +
527 (comb & 0x02000 ? 1 : 0) * 0x1000;
528 // exp leading bits are G2..G3
529 } else {
530 d0 =
531 4 * (comb & 0x04000 ? 1 : 0) + 2 * (comb & 0x2000 ? 1 : 0) +
532 (comb & 0x1000 ? 1 : 0);
533 exp =
534 (comb & 0x10000 ? 1 : 0) * 0x2000 +
535 (comb & 0x08000 ? 1 : 0) * 0x1000;
536 // exp loading bits are G0..G1
537 }
538 }
539
540 d11 = d2b[(trailing.w[0]) & 0x3ff];
541 d10 = d2b[(trailing.w[0] >> 10) & 0x3ff];
542 d9 = d2b[(trailing.w[0] >> 20) & 0x3ff];
543 d8 = d2b[(trailing.w[0] >> 30) & 0x3ff];
544 d7 = d2b[(trailing.w[0] >> 40) & 0x3ff];
545 d6 = d2b[(trailing.w[0] >> 50) & 0x3ff];
546 d5 = d2b[(trailing.w[0] >> 60) | ((trailing.w[1] & 0x3f) << 4)];
547 d4 = d2b[(trailing.w[1] >> 6) & 0x3ff];
548 d3 = d2b[(trailing.w[1] >> 16) & 0x3ff];
549 d2 = d2b[(trailing.w[1] >> 26) & 0x3ff];
550 d1 = d2b[(trailing.w[1] >> 36) & 0x3ff];
551
552 tl =
553 d11 + (d10 * 1000ull) + (d9 * 1000000ull) + (d8 * 1000000000ull) +
554 (d7 * 1000000000000ull) + (d6 * 1000000000000000ull);
555 th =
556 d5 + (d4 * 1000ull) + (d3 * 1000000ull) + (d2 * 1000000000ull) +
557 (d1 * 1000000000000ull) + (d0 * 1000000000000000ull);
558 __mul_64x64_to_128 (bcoeff, th, 1000000000000000000ull);
559 __add_128_64 (bcoeff, bcoeff, tl);
560
561 if (!nanb)
562 exp += (comb & 0xfff);
563
564 res.w[0] = bcoeff.w[0];
565 res.w[1] = (exp << 49) | sign.w[1] | bcoeff.w[1];
566
567 res.w[1] |= nanb;
568
569 BID_SWAP128 (res);
570 BID_RETURN (res);
571 }
572
573 UINT128
574 bid_to_bid128 (UINT128 bq) {
575 UINT128 res;
576 UINT64 sign, comb, exp;
577 UINT64 trailing;
578 UINT64 bcoeff;
579
580 UINT128 rq;
581 UINT128 qcoeff;
582 UINT64 ba, bb;
583
584 ba = *((UINT64 *) & bq + HIGH_128W);
585 bb = *((UINT64 *) & bq + LOW_128W);
586
587 sign = (ba & 0x8000000000000000ull);
588 comb = (ba & 0x7fffc00000000000ull) >> 46;
589 trailing = (ba & 0x00003fffffffffffull);
590
591 if ((comb & 0x18000) == 0x18000) { // G0..G1 = 11 -> exp is G2..G11
592 exp = (comb >> 1) & 0x3fff;
593 bcoeff = ((8 + (comb & 1)) << 46) | trailing;
594 } else {
595 exp = (comb >> 3) & 0x3fff;
596 bcoeff = ((comb & 7) << 46) | trailing;
597 }
598
599 if ((comb & 0x1f000) == 0x1f000) { //NaN
600 ba &= 0xfe003fffffffffffULL; // make exponent 0
601 bcoeff &= 0x00003fffffffffffull; // NaN payloat is only T.
602 if ((bcoeff > 0x0000314dc6448d93ULL) || // significand is non-canonical
603 ((bcoeff == 0x0000314dc6448d93ULL)
604 && (bb >= 0x38c15b0a00000000ULL))
605 // significand is non-canonical
606 ) {
607 bcoeff = 0ull;
608 ba &= ~0x00003fffffffffffull;
609 bb = 0ull;
610 }
611 *((UINT64 *) & rq + HIGH_128W) = ba;
612 *((UINT64 *) & rq + LOW_128W) = bb;
613 return rq;
614 } else if ((comb & 0x1e000) == 0x1e000) { //Inf
615 ba &= 0xf800000000000000ULL; // make exponent and significand 0
616 bb = 0;
617 *((UINT64 *) & rq + HIGH_128W) = ba;
618 *((UINT64 *) & rq + LOW_128W) = bb;
619 return rq;
620 }
621
622 if ((bcoeff > 0x0001ed09bead87c0ull)
623 || ((bcoeff == 0x0001ed09bead87c0ull)
624 && (bb > 0x378d8e63ffffffffull))) {
625 // significand is non-canonical
626 bcoeff = 0ull;
627 bb = 0ull;
628 }
629
630 *((UINT64 *) & qcoeff + 1) = bcoeff;
631 *((UINT64 *) & qcoeff + 0) = bb;
632
633 get_BID128_fast (&res, sign, exp, qcoeff);
634
635 BID_SWAP128 (res);
636 return res;
637 }
638
639 UINT32
640 bid32_canonize (UINT32 ba) {
641 FPSC bidrnd;
642 unsigned int rnd = 0;
643
644 UINT32 res;
645 UINT32 sign, comb, exp;
646 UINT32 trailing;
647 UINT32 bcoeff;
648
649 sign = (ba & 0x80000000);
650 comb = (ba & 0x7ff00000) >> 20;
651 trailing = (ba & 0x000fffff);
652
653 if ((comb & 0x600) == 0x600) { // G0..G1 = 11 -> exp is G2..G11
654 exp = (comb >> 1) & 0xff;
655 bcoeff = ((8 + (comb & 1)) << 20) | trailing;
656 } else {
657 exp = (comb >> 3) & 0xff;
658 bcoeff = ((comb & 7) << 20) | trailing;
659 }
660
661 if ((comb & 0x7c0) == 0x7c0) { //NaN
662 ba &= 0xfe0fffff; // make exponent 0
663 bcoeff &= 0x000fffff; // NaN payloat is only T.
664 if (bcoeff >= 1000000)
665 ba &= 0xfff00000; //treat non-canonical significand
666 return ba;
667 } else if ((comb & 0x780) == 0x780) { //Inf
668 ba &= 0xf8000000; // make exponent and significand 0
669 return ba;
670 }
671
672 if (bcoeff >= 10000000)
673 bcoeff = 0;
674 rnd = bidrnd = ROUNDING_TO_NEAREST;
675 res = get_BID32 (sign, exp, bcoeff, rnd, &bidrnd);
676 return res;
677 }
678
679 UINT64
680 bid64_canonize (UINT64 ba) {
681 UINT64 res;
682 UINT64 sign, comb, exp;
683 UINT64 trailing;
684 UINT64 bcoeff;
685
686 sign = (ba & 0x8000000000000000ull);
687 comb = (ba & 0x7ffc000000000000ull) >> 50;
688 trailing = (ba & 0x0003ffffffffffffull);
689
690
691 if ((comb & 0x1800) == 0x1800) { // G0..G1 = 11 -> exp is G2..G11
692 exp = (comb >> 1) & 0x3ff;
693 bcoeff = ((8 + (comb & 1)) << 50) | trailing;
694 } else {
695 exp = (comb >> 3) & 0x3ff;
696 bcoeff = ((comb & 7) << 50) | trailing;
697 }
698
699 if ((comb & 0x1f00) == 0x1f00) { //NaN
700 ba &= 0xfe03ffffffffffffULL; // make exponent 0
701 bcoeff &= 0x0003ffffffffffffull; // NaN payloat is only T.
702 if (bcoeff >= 1000000000000000ull)
703 ba &= 0xfe00000000000000ull; // treat non canonical significand and zero G6-G12
704 return ba;
705 } else if ((comb & 0x1e00) == 0x1e00) { //Inf
706 ba &= 0xf800000000000000ULL; // make exponent and significand 0
707 return ba;
708 }
709
710 if (bcoeff >= 10000000000000000ull) {
711 bcoeff = 0ull;
712 }
713 res = very_fast_get_BID64 (sign, exp, bcoeff);
714 return res;
715 }
716
717 UINT128
718 bid128_canonize (UINT128 bq) {
719 UINT128 res;
720 UINT64 sign, comb, exp;
721 UINT64 trailing;
722 UINT64 bcoeff;
723
724 UINT128 rq;
725 UINT128 qcoeff;
726 UINT64 ba, bb;
727
728 ba = *((UINT64 *) & bq + HIGH_128W);
729 bb = *((UINT64 *) & bq + LOW_128W);
730
731 sign = (ba & 0x8000000000000000ull);
732 comb = (ba & 0x7fffc00000000000ull) >> 46;
733 trailing = (ba & 0x00003fffffffffffull);
734
735 if ((comb & 0x18000) == 0x18000) { // G0..G1 = 11 -> exp is G2..G11
736 exp = (comb >> 1) & 0x3fff;
737 bcoeff = ((8 + (comb & 1)) << 46) | trailing;
738 } else {
739 exp = (comb >> 3) & 0x3fff;
740 bcoeff = ((comb & 7) << 46) | trailing;
741 }
742
743 if ((comb & 0x1f000) == 0x1f000) { //NaN
744 ba &= 0xfe003fffffffffffULL; // make exponent 0
745 bcoeff &= 0x00003fffffffffffull; // NaN payload is only T.
746
747 if ((bcoeff > 0x0000314dc6448d93ULL) || // significand is non-canonical
748 ((bcoeff == 0x0000314dc6448d93ULL)
749 && (bb >= 0x38c15b0a00000000ULL))
750 // significand is non-canonical
751 ) {
752 bcoeff = 0ull;
753 ba &= ~0x00003fffffffffffull;
754 bb = 0ull;
755 }
756 *((UINT64 *) & rq + HIGH_128W) = ba;
757 *((UINT64 *) & rq + LOW_128W) = bb;
758 return rq;
759 } else if ((comb & 0x1e000) == 0x1e000) { //Inf
760 ba &= 0xf800000000000000ULL; // make exponent and significand 0
761 bb = 0;
762 *((UINT64 *) & rq + HIGH_128W) = ba;
763 *((UINT64 *) & rq + LOW_128W) = bb;
764 return rq;
765 }
766
767 if ((bcoeff > 0x0001ed09bead87c0ull) || // significand is non-canonical
768 ((bcoeff == 0x0001ed09bead87c0ull)
769 && (bb > 0x378d8e63ffffffffull))
770 // significand is non-canonical
771 ) {
772 bcoeff = 0ull;
773 bb = 0ull;
774 }
775
776 *((UINT64 *) & qcoeff + 1) = bcoeff;
777 *((UINT64 *) & qcoeff + 0) = bb;
778
779 get_BID128_fast (&res, sign, exp, qcoeff);
780 BID_SWAP128 (res);
781 return res;
782 }
783