Mercurial > hg > CbC > CbC_gcc

comparison libdecnumber/bid/bid2dpd_dpd2bid.c @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents a06113de4d67
children 84e7813d76e9
comparison
equal deleted inserted replaced
68:561a7518be6b 111:04ced10e8804
1 /* Copyright (C) 2007, 2009 Free Software Foundation, Inc. 1 /* Copyright (C) 2007-2017 Free Software Foundation, Inc.
2 2
3 This file is part of GCC. 3 This file is part of GCC.
4 4
5 GCC is free software; you can redistribute it and/or modify it under 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 6 the terms of the GNU General Public License as published by the Free
112 b2 = coefficient_x - 1000 * b01; 112 b2 = coefficient_x - 1000 * b01;
113 b0 = b01 / 1000; 113 b0 = b01 / 1000;
114 b1 = b01 - 1000 * b0; 114 b1 = b01 - 1000 * b0;
115 dcoeff = b2d[b2] | b2d2[b1]; 115 dcoeff = b2d[b2] | b2d2[b1];
116 if (b0 >= 8) { /* is b0 8 or 9? */ 116 if (b0 >= 8) { /* is b0 8 or 9? */
117 res = sign | ((0x600 | ((exp >> 6) << 7) | 117 res = sign | ((0x600 | ((exp >> 6) << 7) |
118 ((b0 & 1) << 6) | (exp & 0x3f)) << 20) | dcoeff; 118 ((b0 & 1) << 6) | (exp & 0x3f)) << 20) | dcoeff;
119 } else { /* else b0 is 0..7 */ 119 } else { /* else b0 is 0..7 */
120 res = sign | ((((exp >> 6) << 9) | (b0 << 6) | 120 res = sign | ((((exp >> 6) << 9) | (b0 << 6) |
121 (exp & 0x3f)) << 20) | dcoeff; 121 (exp & 0x3f)) << 20) | dcoeff;
122 } 122 }
123 *pres = res; 123 *pres = res;
124 } 124 }
125 125
136 sign = (x & 0x80000000); 136 sign = (x & 0x80000000);
137 trailing = (x & 0x000fffff); 137 trailing = (x & 0x000fffff);
138 if ((x & 0x78000000) == 0x78000000) { 138 if ((x & 0x78000000) == 0x78000000) {
139 *pres = x; 139 *pres = x;
140 return; 140 return;
141 } else { /* normal number */ 141 }
142 if ((x & 0x60000000) == 0x60000000) { /* G0..G1 = 11 -> d0 = 8 + G4 */ 142 /* normal number */
143 d0 = d2b3[((x >> 26) & 1) | 8]; /* d0 = (comb & 0x0100 ? 9 : 8); */ 143 if ((x & 0x60000000) == 0x60000000) { /* G0..G1 = 11 -> d0 = 8 + G4 */
144 exp = (x >> 27) & 3; /* exp leading bits are G2..G3 */ 144 d0 = d2b3[((x >> 26) & 1) | 8]; /* d0 = (comb & 0x0100 ? 9 : 8); */
145 } else { 145 exp = (x >> 27) & 3; /* exp leading bits are G2..G3 */
146 d0 = d2b3[(x >> 26) & 0x7]; 146 } else {
147 exp = (x >> 29) & 3; /* exp loading bits are G0..G1 */ 147 d0 = d2b3[(x >> 26) & 0x7];
148 } 148 exp = (x >> 29) & 3; /* exp loading bits are G0..G1 */
149 d1 = d2b2[(trailing >> 10) & 0x3ff]; 149 }
150 d2 = d2b[(trailing) & 0x3ff]; 150 d1 = d2b2[(trailing >> 10) & 0x3ff];
151 bcoeff = d2 + d1 + d0; 151 d2 = d2b[(trailing) & 0x3ff];
152 exp = (exp << 6) + ((x >> 20) & 0x3f); 152 bcoeff = d2 + d1 + d0;
153 if (bcoeff < (1 << 23)) { 153 exp = (exp << 6) + ((x >> 20) & 0x3f);
154 r = exp; 154 if (bcoeff < (1 << 23)) {
155 r <<= 23; 155 r = exp;
156 r |= (bcoeff | sign); 156 r <<= 23;
157 } else { 157 r |= (bcoeff | sign);
158 r = exp; 158 } else {
159 r <<= 21; 159 r = exp;
160 r |= (sign | 0x60000000ul); 160 r <<= 21;
161 /* add coeff, without leading bits */ 161 r |= (sign | 0x60000000ul);
162 r |= (((unsigned int) bcoeff) & 0x1fffff); 162 /* add coeff, without leading bits */
163 } 163 r |= (((unsigned int) bcoeff) & 0x1fffff);
164 } 164 }
165 *pres = r; 165 *pres = r;
166 } 166 }
167 167
168 void _bid_to_dpd64 (_Decimal64 *, _Decimal64 *); 168 void _bid_to_dpd64 (_Decimal64 *, _Decimal64 *);
182 sign = (x & 0x8000000000000000ull); 182 sign = (x & 0x8000000000000000ull);
183 comb = (x & 0x7ffc000000000000ull) >> 51; 183 comb = (x & 0x7ffc000000000000ull) >> 51;
184 if ((comb & 0xf00) == 0xf00) { 184 if ((comb & 0xf00) == 0xf00) {
185 *pres = x; 185 *pres = x;
186 return; 186 return;
187 } else { /* Normal number */ 187 }
188 if ((comb & 0xc00) == 0xc00) { /* G0..G1 = 11 -> exp is G2..G11 */ 188 /* Normal number */
189 exp = (comb) & 0x3ff; 189 if ((comb & 0xc00) == 0xc00) { /* G0..G1 = 11 -> exp is G2..G11 */
190 bcoeff = (x & 0x0007ffffffffffffull) | 0x0020000000000000ull; 190 exp = (comb) & 0x3ff;
191 } else { 191 bcoeff = (x & 0x0007ffffffffffffull) | 0x0020000000000000ull;
192 exp = (comb >> 2) & 0x3ff; 192 } else {
193 bcoeff = (x & 0x001fffffffffffffull); 193 exp = (comb >> 2) & 0x3ff;
194 } 194 bcoeff = (x & 0x001fffffffffffffull);
195 D61 = 2305843009ull; /* Floor(2^61 / 10^9) */ 195 }
196 /* Multiply the binary coefficient by ceil(2^64 / 1000), and take the upper 196 D61 = 2305843009ull; /* Floor(2^61 / 10^9) */
197 64-bits in order to compute a division by 1000. */ 197 /* Multiply the binary coefficient by ceil(2^64 / 1000), and take the upper
198 yhi = (D61 * (UINT64)(bcoeff >> (UINT64)27)) >> (UINT64)34; 198 64-bits in order to compute a division by 1000. */
199 ylo = bcoeff - 1000000000ull * yhi; 199 yhi = (D61 * (UINT64)(bcoeff >> (UINT64)27)) >> (UINT64)34;
200 if (ylo >= 1000000000) { 200 ylo = bcoeff - 1000000000ull * yhi;
201 ylo = ylo - 1000000000; 201 if (ylo >= 1000000000) {
202 yhi = yhi + 1; 202 ylo = ylo - 1000000000;
203 } 203 yhi = yhi + 1;
204 d103 = 0x4189374c; 204 }
205 B34 = ((UINT64) ylo * d103) >> (32 + 8); 205 d103 = 0x4189374c;
206 B01 = ((UINT64) yhi * d103) >> (32 + 8); 206 B34 = ((UINT64) ylo * d103) >> (32 + 8);
207 b5 = ylo - B34 * 1000; 207 B01 = ((UINT64) yhi * d103) >> (32 + 8);
208 b2 = yhi - B01 * 1000; 208 b5 = ylo - B34 * 1000;
209 b3 = ((UINT64) B34 * d103) >> (32 + 8); 209 b2 = yhi - B01 * 1000;
210 b0 = ((UINT64) B01 * d103) >> (32 + 8); 210 b3 = ((UINT64) B34 * d103) >> (32 + 8);
211 b4 = (unsigned int) B34 - (unsigned int) b3 *1000; 211 b0 = ((UINT64) B01 * d103) >> (32 + 8);
212 b1 = (unsigned int) B01 - (unsigned int) dm103[b0]; 212 b4 = (unsigned int) B34 - (unsigned int) b3 *1000;
213 dcoeff = b2d[b5] | b2d2[b4] | b2d3[b3] | b2d4[b2] | b2d5[b1]; 213 b1 = (unsigned int) B01 - (unsigned int) dm103[b0];
214 if (b0 >= 8) /* is b0 8 or 9? */ 214 dcoeff = b2d[b5] | b2d2[b4] | b2d3[b3] | b2d4[b2] | b2d5[b1];
215 res = sign | ((0x1800 | ((exp >> 8) << 9) | ((b0 & 1) << 8) | 215 if (b0 >= 8) /* is b0 8 or 9? */
216 (exp & 0xff)) << 50) | dcoeff; 216 res = sign | ((0x1800 | ((exp >> 8) << 9) | ((b0 & 1) << 8) |
217 else /* else b0 is 0..7 */ 217 (exp & 0xff)) << 50) | dcoeff;
218 res = sign | ((((exp >> 8) << 11) | (b0 << 8) | 218 else /* else b0 is 0..7 */
219 (exp & 0xff)) << 50) | dcoeff; 219 res = sign | ((((exp >> 8) << 11) | (b0 << 8) |
220 } 220 (exp & 0xff)) << 50) | dcoeff;
221 *pres = res; 221 *pres = res;
222 } 222 }
223 223
224 void _dpd_to_bid64 (_Decimal64 *, _Decimal64 *); 224 void _dpd_to_bid64 (_Decimal64 *, _Decimal64 *);
225 225
235 235
236 sign = (x & 0x8000000000000000ull); 236 sign = (x & 0x8000000000000000ull);
237 comb = (x & 0x7ffc000000000000ull) >> 50; 237 comb = (x & 0x7ffc000000000000ull) >> 50;
238 trailing = (x & 0x0003ffffffffffffull); 238 trailing = (x & 0x0003ffffffffffffull);
239 if ((comb & 0x1e00) == 0x1e00) { 239 if ((comb & 0x1e00) == 0x1e00) {
240 if ((comb & 0x1f00) == 0x1f00) { /* G0..G4 = 11111 -> NaN */ 240 *pres = x;
241 if (comb & 0x0100) { /* G5 = 1 -> sNaN */
242 *pres = x;
243 } else { /* G5 = 0 -> qNaN */
244 *pres = x;
245 }
246 } else { /*if ((comb & 0x1e00) == 0x1e00); G0..G4 = 11110 -> INF */
247 *pres = x;
248 }
249 return; 241 return;
250 } else { /* normal number */ 242 }
251 if ((comb & 0x1800) == 0x1800) { /* G0..G1 = 11 -> d0 = 8 + G4 */ 243 /* normal number */
252 d0 = d2b6[((comb >> 8) & 1) | 8]; /* d0 = (comb & 0x0100 ? 9 : 8); */ 244 if ((comb & 0x1800) == 0x1800) { /* G0..G1 = 11 -> d0 = 8 + G4 */
253 exp = (comb & 0x600) >> 1; /* exp = (comb & 0x0400 ? 1 : 0) * 0x200 + 245 d0 = d2b6[((comb >> 8) & 1) | 8]; /* d0 = (comb & 0x0100 ? 9 : 8); */
254 (comb & 0x0200 ? 1 : 0) * 0x100; exp leading bits are G2..G3 */ 246 exp = (comb & 0x600) >> 1; /* exp = (comb & 0x0400 ? 1 : 0) * 0x200 +
255 } else { 247 (comb & 0x0200 ? 1 : 0) * 0x100; exp leading bits are G2..G3 */
256 d0 = d2b6[(comb >> 8) & 0x7]; 248 } else {
257 exp = (comb & 0x1800) >> 3; /* exp = (comb & 0x1000 ? 1 : 0) * 0x200 + 249 d0 = d2b6[(comb >> 8) & 0x7];
258 (comb & 0x0800 ? 1 : 0) * 0x100; exp loading bits are G0..G1 */ 250 exp = (comb & 0x1800) >> 3; /* exp = (comb & 0x1000 ? 1 : 0) * 0x200 +
259 } 251 (comb & 0x0800 ? 1 : 0) * 0x100; exp loading bits are G0..G1 */
260 d1 = d2b5[(trailing >> 40) & 0x3ff]; 252 }
261 d2 = d2b4[(trailing >> 30) & 0x3ff]; 253 d1 = d2b5[(trailing >> 40) & 0x3ff];
262 d3 = d2b3[(trailing >> 20) & 0x3ff]; 254 d2 = d2b4[(trailing >> 30) & 0x3ff];
263 d4 = d2b2[(trailing >> 10) & 0x3ff]; 255 d3 = d2b3[(trailing >> 20) & 0x3ff];
264 d5 = d2b[(trailing) & 0x3ff]; 256 d4 = d2b2[(trailing >> 10) & 0x3ff];
265 bcoeff = (d5 + d4 + d3) + d2 + d1 + d0; 257 d5 = d2b[(trailing) & 0x3ff];
266 exp += (comb & 0xff); 258 bcoeff = (d5 + d4 + d3) + d2 + d1 + d0;
267 mask = 1; 259 exp += (comb & 0xff);
268 mask <<= 53; 260 mask = 1;
269 if (bcoeff < mask) { /* check whether coefficient fits in 10*5+3 bits */ 261 mask <<= 53;
270 res = exp; 262 if (bcoeff < mask) { /* check whether coefficient fits in 10*5+3 bits */
271 res <<= 53; 263 res = exp;
272 res |= (bcoeff | sign); 264 res <<= 53;
273 *pres = res; 265 res |= (bcoeff | sign);
274 return; 266 *pres = res;
275 } 267 return;
276 /* special format */ 268 }
277 res = (exp << 51) | (sign | 0x6000000000000000ull); 269 /* special format */
278 /* add coeff, without leading bits */ 270 res = (exp << 51) | (sign | 0x6000000000000000ull);
279 mask = (mask >> 2) - 1; 271 /* add coeff, without leading bits */
280 bcoeff &= mask; 272 mask = (mask >> 2) - 1;
281 res |= bcoeff; 273 bcoeff &= mask;
282 } 274 res |= bcoeff;
283 *pres = res; 275 *pres = res;
284 } 276 }
285 277
286 void _bid_to_dpd128 (_Decimal128 *, _Decimal128 *); 278 void _bid_to_dpd128 (_Decimal128 *, _Decimal128 *);
287 279
302 sign.w[1] = (x.w[1] & 0x8000000000000000ull); 294 sign.w[1] = (x.w[1] & 0x8000000000000000ull);
303 sign.w[0] = 0; 295 sign.w[0] = 0;
304 comb = (x.w[1] /*& 0x7fffc00000000000ull */ ) >> 46; 296 comb = (x.w[1] /*& 0x7fffc00000000000ull */ ) >> 46;
305 exp = 0; 297 exp = 0;
306 if ((comb & 0x1e000) == 0x1e000) { 298 if ((comb & 0x1e000) == 0x1e000) {
307 if ((comb & 0x1f000) == 0x1f000) { /* G0..G4 = 11111 -> NaN */ 299 res = x;
308 if (comb & 0x01000) { /* G5 = 1 -> sNaN */
309 res = x;
310 } else { /* G5 = 0 -> qNaN */
311 res = x;
312 }
313 } else { /* G0..G4 = 11110 -> INF */
314 res = x;
315 }
316 } else { /* normal number */ 300 } else { /* normal number */
317 exp = ((x.w[1] & 0x7fff000000000000ull) >> 49) & 0x3fff; 301 exp = ((x.w[1] & 0x7fff000000000000ull) >> 49) & 0x3fff;
318 bcoeff.w[1] = (x.w[1] & 0x0001ffffffffffffull); 302 bcoeff.w[1] = (x.w[1] & 0x0001ffffffffffffull);
319 bcoeff.w[0] = x.w[0]; 303 bcoeff.w[0] = x.w[0];
320 d1018 = reciprocals10_128[18]; 304 d1018 = reciprocals10_128[18];
345 k8 = BLH32 - (unsigned int) k7 *1000; 329 k8 = BLH32 - (unsigned int) k7 *1000;
346 k9 = ((UINT64) BLL32 * d106) >> (32 + 18); 330 k9 = ((UINT64) BLL32 * d106) >> (32 + 18);
347 BLL32 -= (unsigned int) k9 *1000000; 331 BLL32 -= (unsigned int) k9 *1000000;
348 k10 = ((UINT64) BLL32 * d103) >> (32 + 8); 332 k10 = ((UINT64) BLL32 * d103) >> (32 + 8);
349 k11 = BLL32 - (unsigned int) k10 *1000; 333 k11 = BLL32 - (unsigned int) k10 *1000;
350 dcoeff.w[1] = (b2d[k5] >> 4) | (b2d[k4] << 6) | (b2d[k3] << 16) | 334 dcoeff.w[1] = (b2d[k5] >> 4) | (b2d[k4] << 6) | (b2d[k3] << 16) |
351 (b2d[k2] << 26) | (b2d[k1] << 36); 335 (b2d[k2] << 26) | (b2d[k1] << 36);
352 dcoeff.w[0] = b2d[k11] | (b2d[k10] << 10) | (b2d[k9] << 20) | 336 dcoeff.w[0] = b2d[k11] | (b2d[k10] << 10) | (b2d[k9] << 20) |
353 (b2d[k8] << 30) | (b2d[k7] << 40) | (b2d[k6] << 50) | (b2d[k5] << 60); 337 (b2d[k8] << 30) | (b2d[k7] << 40) | (b2d[k6] << 50) | (b2d[k5] << 60);
354 res.w[0] = dcoeff.w[0]; 338 res.w[0] = dcoeff.w[0];
355 if (k0 >= 8) { 339 if (k0 >= 8) {
356 res.w[1] = sign.w[1] | ((0x18000 | ((exp >> 12) << 13) | 340 res.w[1] = sign.w[1] | ((0x18000 | ((exp >> 12) << 13) |
357 ((k0 & 1) << 12) | (exp & 0xfff)) << 46) | dcoeff.w[1]; 341 ((k0 & 1) << 12) | (exp & 0xfff)) << 46) | dcoeff.w[1];
358 } else { 342 } else {
359 res.w[1] = sign.w[1] | ((((exp >> 12) << 15) | (k0 << 12) | 343 res.w[1] = sign.w[1] | ((((exp >> 12) << 15) | (k0 << 12) |
360 (exp & 0xfff)) << 46) | dcoeff.w[1]; 344 (exp & 0xfff)) << 46) | dcoeff.w[1];
361 } 345 }
362 } 346 }
363 *pres = res; 347 *pres = res;
364 } 348 }
380 sign.w[0] = 0; 364 sign.w[0] = 0;
381 comb = (x.w[1] & 0x7fffc00000000000ull) >> 46; 365 comb = (x.w[1] & 0x7fffc00000000000ull) >> 46;
382 trailing.w[1] = x.w[1]; 366 trailing.w[1] = x.w[1];
383 trailing.w[0] = x.w[0]; 367 trailing.w[0] = x.w[0];
384 if ((comb & 0x1e000) == 0x1e000) { 368 if ((comb & 0x1e000) == 0x1e000) {
385 if ((comb & 0x1f000) == 0x1f000) { /* G0..G4 = 11111 -> NaN */
386 if (comb & 0x01000) { /* G5 = 1 -> sNaN */
387 *pres = x;
388 } else { /* G5 = 0 -> qNaN */
389 *pres = x;
390 }
391 } else { /* G0..G4 = 11110 -> INF */
392 *pres = x; 369 *pres = x;
393 } 370 return;
394 return; 371 }
395 } else { /* Normal number */ 372 if ((comb & 0x18000) == 0x18000) { /* G0..G1 = 11 -> d0 = 8 + G4 */
396 if ((comb & 0x18000) == 0x18000) { /* G0..G1 = 11 -> d0 = 8 + G4 */ 373 d0 = d2b6[8 + ((comb & 0x01000) >> 12)];
397 d0 = d2b6[8 + ((comb & 0x01000) >> 12)]; 374 exp = (comb & 0x06000) >> 1; /* exp leading bits are G2..G3 */
398 exp = (comb & 0x06000) >> 1; /* exp leading bits are G2..G3 */ 375 } else {
399 } else { 376 d0 = d2b6[((comb & 0x07000) >> 12)];
400 d0 = d2b6[((comb & 0x07000) >> 12)]; 377 exp = (comb & 0x18000) >> 3; /* exp loading bits are G0..G1 */
401 exp = (comb & 0x18000) >> 3; /* exp loading bits are G0..G1 */ 378 }
402 } 379 d11 = d2b[(trailing.w[0]) & 0x3ff];
403 d11 = d2b[(trailing.w[0]) & 0x3ff]; 380 d10 = d2b2[(trailing.w[0] >> 10) & 0x3ff];
404 d10 = d2b2[(trailing.w[0] >> 10) & 0x3ff]; 381 d9 = d2b3[(trailing.w[0] >> 20) & 0x3ff];
405 d9 = d2b3[(trailing.w[0] >> 20) & 0x3ff]; 382 d8 = d2b4[(trailing.w[0] >> 30) & 0x3ff];
406 d8 = d2b4[(trailing.w[0] >> 30) & 0x3ff]; 383 d7 = d2b5[(trailing.w[0] >> 40) & 0x3ff];
407 d7 = d2b5[(trailing.w[0] >> 40) & 0x3ff]; 384 d6 = d2b6[(trailing.w[0] >> 50) & 0x3ff];
408 d6 = d2b6[(trailing.w[0] >> 50) & 0x3ff]; 385 d5 = d2b[(trailing.w[0] >> 60) | ((trailing.w[1] & 0x3f) << 4)];
409 d5 = d2b[(trailing.w[0] >> 60) | ((trailing.w[1] & 0x3f) << 4)]; 386 d4 = d2b2[(trailing.w[1] >> 6) & 0x3ff];
410 d4 = d2b2[(trailing.w[1] >> 6) & 0x3ff]; 387 d3 = d2b3[(trailing.w[1] >> 16) & 0x3ff];
411 d3 = d2b3[(trailing.w[1] >> 16) & 0x3ff]; 388 d2 = d2b4[(trailing.w[1] >> 26) & 0x3ff];
412 d2 = d2b4[(trailing.w[1] >> 26) & 0x3ff]; 389 d1 = d2b5[(trailing.w[1] >> 36) & 0x3ff];
413 d1 = d2b5[(trailing.w[1] >> 36) & 0x3ff]; 390 tl = d11 + d10 + d9 + d8 + d7 + d6;
414 tl = d11 + d10 + d9 + d8 + d7 + d6; 391 th = d5 + d4 + d3 + d2 + d1 + d0;
415 th = d5 + d4 + d3 + d2 + d1 + d0; 392 __mul_64x64_to_128 (bcoeff, th, 1000000000000000000ull);
416 __mul_64x64_to_128 (bcoeff, th, 1000000000000000000ull); 393 __add_128_64 (bcoeff, bcoeff, tl);
417 __add_128_64 (bcoeff, bcoeff, tl); 394 exp += (comb & 0xfff);
418 exp += (comb & 0xfff); 395 res.w[0] = bcoeff.w[0];
419 res.w[0] = bcoeff.w[0]; 396 res.w[1] = (exp << 49) | sign.w[1] | bcoeff.w[1];
420 res.w[1] = (exp << 49) | sign.w[1] | bcoeff.w[1]; 397 *pres = res;
421 } 398 }
422 *pres = res;
423 }