?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
block: convert more bdrv_is_allocated* and bdrv_block_status* calls to coroutine...
[qemu/ar7.git] / target / m68k / softfloat.c
blob02dcc03d15d8a8164c0b30a01787c77545302291
1 /*
2 * Ported from a work by Andreas Grabher for Previous, NeXT Computer Emulator,
3 * derived from NetBSD M68040 FPSP functions,
4 * derived from release 2a of the SoftFloat IEC/IEEE Floating-point Arithmetic
5 * Package. Those parts of the code (and some later contributions) are
6 * provided under that license, as detailed below.
7 * It has subsequently been modified by contributors to the QEMU Project,
8 * so some portions are provided under:
9 * the SoftFloat-2a license
10 * the BSD license
11 * GPL-v2-or-later
12 *
13 * Any future contributions to this file will be taken to be licensed under
14 * the Softfloat-2a license unless specifically indicated otherwise.
15 */
16
17 /*
18 * Portions of this work are licensed under the terms of the GNU GPL,
19 * version 2 or later. See the COPYING file in the top-level directory.
20 */
21
22 #include "qemu/osdep.h"
23 #include "softfloat.h"
24 #include "fpu/softfloat-macros.h"
25 #include "softfloat_fpsp_tables.h"
26
27 #define pi_exp 0x4000
28 #define piby2_exp 0x3FFF
29 #define pi_sig UINT64_C(0xc90fdaa22168c235)
30
31 static floatx80 propagateFloatx80NaNOneArg(floatx80 a, float_status *status)
32 {
33 if (floatx80_is_signaling_nan(a, status)) {
34 float_raise(float_flag_invalid, status);
35 a = floatx80_silence_nan(a, status);
36 }
37
38 if (status->default_nan_mode) {
39 return floatx80_default_nan(status);
40 }
41
42 return a;
43 }
44
45 /*
46 * Returns the mantissa of the extended double-precision floating-point
47 * value `a'.
48 */
49
50 floatx80 floatx80_getman(floatx80 a, float_status *status)
51 {
52 bool aSign;
53 int32_t aExp;
54 uint64_t aSig;
55
56 aSig = extractFloatx80Frac(a);
57 aExp = extractFloatx80Exp(a);
58 aSign = extractFloatx80Sign(a);
59
60 if (aExp == 0x7FFF) {
61 if ((uint64_t) (aSig << 1)) {
62 return propagateFloatx80NaNOneArg(a , status);
63 }
64 float_raise(float_flag_invalid , status);
65 return floatx80_default_nan(status);
66 }
67
68 if (aExp == 0) {
69 if (aSig == 0) {
70 return packFloatx80(aSign, 0, 0);
71 }
72 normalizeFloatx80Subnormal(aSig, &aExp, &aSig);
73 }
74
75 return roundAndPackFloatx80(status->floatx80_rounding_precision, aSign,
76 0x3FFF, aSig, 0, status);
77 }
78
79 /*
80 * Returns the exponent of the extended double-precision floating-point
81 * value `a' as an extended double-precision value.
82 */
83
84 floatx80 floatx80_getexp(floatx80 a, float_status *status)
85 {
86 bool aSign;
87 int32_t aExp;
88 uint64_t aSig;
89
90 aSig = extractFloatx80Frac(a);
91 aExp = extractFloatx80Exp(a);
92 aSign = extractFloatx80Sign(a);
93
94 if (aExp == 0x7FFF) {
95 if ((uint64_t) (aSig << 1)) {
96 return propagateFloatx80NaNOneArg(a , status);
97 }
98 float_raise(float_flag_invalid , status);
99 return floatx80_default_nan(status);
100 }
101
102 if (aExp == 0) {
103 if (aSig == 0) {
104 return packFloatx80(aSign, 0, 0);
105 }
106 normalizeFloatx80Subnormal(aSig, &aExp, &aSig);
107 }
108
109 return int32_to_floatx80(aExp - 0x3FFF, status);
110 }
111
112 /*
113 * Scales extended double-precision floating-point value in operand `a' by
114 * value `b'. The function truncates the value in the second operand 'b' to
115 * an integral value and adds that value to the exponent of the operand 'a'.
116 * The operation performed according to the IEC/IEEE Standard for Binary
117 * Floating-Point Arithmetic.
118 */
119
120 floatx80 floatx80_scale(floatx80 a, floatx80 b, float_status *status)
121 {
122 bool aSign, bSign;
123 int32_t aExp, bExp, shiftCount;
124 uint64_t aSig, bSig;
125
126 aSig = extractFloatx80Frac(a);
127 aExp = extractFloatx80Exp(a);
128 aSign = extractFloatx80Sign(a);
129 bSig = extractFloatx80Frac(b);
130 bExp = extractFloatx80Exp(b);
131 bSign = extractFloatx80Sign(b);
132
133 if (bExp == 0x7FFF) {
134 if ((uint64_t) (bSig << 1) ||
135 ((aExp == 0x7FFF) && (uint64_t) (aSig << 1))) {
136 return propagateFloatx80NaN(a, b, status);
137 }
138 float_raise(float_flag_invalid , status);
139 return floatx80_default_nan(status);
140 }
141 if (aExp == 0x7FFF) {
142 if ((uint64_t) (aSig << 1)) {
143 return propagateFloatx80NaN(a, b, status);
144 }
145 return packFloatx80(aSign, floatx80_infinity.high,
146 floatx80_infinity.low);
147 }
148 if (aExp == 0) {
149 if (aSig == 0) {
150 return packFloatx80(aSign, 0, 0);
151 }
152 if (bExp < 0x3FFF) {
153 return a;
154 }
155 normalizeFloatx80Subnormal(aSig, &aExp, &aSig);
156 }
157
158 if (bExp < 0x3FFF) {
159 return a;
160 }
161
162 if (0x400F < bExp) {
163 aExp = bSign ? -0x6001 : 0xE000;
164 return roundAndPackFloatx80(status->floatx80_rounding_precision,
165 aSign, aExp, aSig, 0, status);
166 }
167
168 shiftCount = 0x403E - bExp;
169 bSig >>= shiftCount;
170 aExp = bSign ? (aExp - bSig) : (aExp + bSig);
171
172 return roundAndPackFloatx80(status->floatx80_rounding_precision,
173 aSign, aExp, aSig, 0, status);
174 }
175
176 floatx80 floatx80_move(floatx80 a, float_status *status)
177 {
178 bool aSign;
179 int32_t aExp;
180 uint64_t aSig;
181
182 aSig = extractFloatx80Frac(a);
183 aExp = extractFloatx80Exp(a);
184 aSign = extractFloatx80Sign(a);
185
186 if (aExp == 0x7FFF) {
187 if ((uint64_t)(aSig << 1)) {
188 return propagateFloatx80NaNOneArg(a, status);
189 }
190 return a;
191 }
192 if (aExp == 0) {
193 if (aSig == 0) {
194 return a;
195 }
196 normalizeRoundAndPackFloatx80(status->floatx80_rounding_precision,
197 aSign, aExp, aSig, 0, status);
198 }
199 return roundAndPackFloatx80(status->floatx80_rounding_precision, aSign,
200 aExp, aSig, 0, status);
201 }
202
203 /*
204 * Algorithms for transcendental functions supported by MC68881 and MC68882
205 * mathematical coprocessors. The functions are derived from FPSP library.
206 */
207
208 #define one_exp 0x3FFF
209 #define one_sig UINT64_C(0x8000000000000000)
210
211 /*
212 * Function for compactifying extended double-precision floating point values.
213 */
214
215 static int32_t floatx80_make_compact(int32_t aExp, uint64_t aSig)
216 {
217 return (aExp << 16) | (aSig >> 48);
218 }
219
220 /*
221 * Log base e of x plus 1
222 */
223
224 floatx80 floatx80_lognp1(floatx80 a, float_status *status)
225 {
226 bool aSign;
227 int32_t aExp;
228 uint64_t aSig, fSig;
229
230 FloatRoundMode user_rnd_mode;
231 FloatX80RoundPrec user_rnd_prec;
232
233 int32_t compact, j, k;
234 floatx80 fp0, fp1, fp2, fp3, f, logof2, klog2, saveu;
235
236 aSig = extractFloatx80Frac(a);
237 aExp = extractFloatx80Exp(a);
238 aSign = extractFloatx80Sign(a);
239
240 if (aExp == 0x7FFF) {
241 if ((uint64_t) (aSig << 1)) {
242 propagateFloatx80NaNOneArg(a, status);
243 }
244 if (aSign) {
245 float_raise(float_flag_invalid, status);
246 return floatx80_default_nan(status);
247 }
248 return packFloatx80(0, floatx80_infinity.high, floatx80_infinity.low);
249 }
250
251 if (aExp == 0 && aSig == 0) {
252 return packFloatx80(aSign, 0, 0);
253 }
254
255 if (aSign && aExp >= one_exp) {
256 if (aExp == one_exp && aSig == one_sig) {
257 float_raise(float_flag_divbyzero, status);
258 return packFloatx80(aSign, floatx80_infinity.high,
259 floatx80_infinity.low);
260 }
261 float_raise(float_flag_invalid, status);
262 return floatx80_default_nan(status);
263 }
264
265 if (aExp < 0x3f99 || (aExp == 0x3f99 && aSig == one_sig)) {
266 /* <= min threshold */
267 float_raise(float_flag_inexact, status);
268 return floatx80_move(a, status);
269 }
270
271 user_rnd_mode = status->float_rounding_mode;
272 user_rnd_prec = status->floatx80_rounding_precision;
273 status->float_rounding_mode = float_round_nearest_even;
274 status->floatx80_rounding_precision = floatx80_precision_x;
275
276 compact = floatx80_make_compact(aExp, aSig);
277
278 fp0 = a; /* Z */
279 fp1 = a;
280
281 fp0 = floatx80_add(fp0, float32_to_floatx80(make_float32(0x3F800000),
282 status), status); /* X = (1+Z) */
283
284 aExp = extractFloatx80Exp(fp0);
285 aSig = extractFloatx80Frac(fp0);
286
287 compact = floatx80_make_compact(aExp, aSig);
288
289 if (compact < 0x3FFE8000 || compact > 0x3FFFC000) {
290 /* |X| < 1/2 or |X| > 3/2 */
291 k = aExp - 0x3FFF;
292 fp1 = int32_to_floatx80(k, status);
293
294 fSig = (aSig & UINT64_C(0xFE00000000000000)) | UINT64_C(0x0100000000000000);
295 j = (fSig >> 56) & 0x7E; /* DISPLACEMENT FOR 1/F */
296
297 f = packFloatx80(0, 0x3FFF, fSig); /* F */
298 fp0 = packFloatx80(0, 0x3FFF, aSig); /* Y */
299
300 fp0 = floatx80_sub(fp0, f, status); /* Y-F */
301
302 lp1cont1:
303 /* LP1CONT1 */
304 fp0 = floatx80_mul(fp0, log_tbl[j], status); /* FP0 IS U = (Y-F)/F */
305 logof2 = packFloatx80(0, 0x3FFE, UINT64_C(0xB17217F7D1CF79AC));
306 klog2 = floatx80_mul(fp1, logof2, status); /* FP1 IS K*LOG2 */
307 fp2 = floatx80_mul(fp0, fp0, status); /* FP2 IS V=U*U */
308
309 fp3 = fp2;
310 fp1 = fp2;
311
312 fp1 = floatx80_mul(fp1, float64_to_floatx80(
313 make_float64(0x3FC2499AB5E4040B), status),
314 status); /* V*A6 */
315 fp2 = floatx80_mul(fp2, float64_to_floatx80(
316 make_float64(0xBFC555B5848CB7DB), status),
317 status); /* V*A5 */
318 fp1 = floatx80_add(fp1, float64_to_floatx80(
319 make_float64(0x3FC99999987D8730), status),
320 status); /* A4+V*A6 */
321 fp2 = floatx80_add(fp2, float64_to_floatx80(
322 make_float64(0xBFCFFFFFFF6F7E97), status),
323 status); /* A3+V*A5 */
324 fp1 = floatx80_mul(fp1, fp3, status); /* V*(A4+V*A6) */
325 fp2 = floatx80_mul(fp2, fp3, status); /* V*(A3+V*A5) */
326 fp1 = floatx80_add(fp1, float64_to_floatx80(
327 make_float64(0x3FD55555555555A4), status),
328 status); /* A2+V*(A4+V*A6) */
329 fp2 = floatx80_add(fp2, float64_to_floatx80(
330 make_float64(0xBFE0000000000008), status),
331 status); /* A1+V*(A3+V*A5) */
332 fp1 = floatx80_mul(fp1, fp3, status); /* V*(A2+V*(A4+V*A6)) */
333 fp2 = floatx80_mul(fp2, fp3, status); /* V*(A1+V*(A3+V*A5)) */
334 fp1 = floatx80_mul(fp1, fp0, status); /* U*V*(A2+V*(A4+V*A6)) */
335 fp0 = floatx80_add(fp0, fp2, status); /* U+V*(A1+V*(A3+V*A5)) */
336
337 fp1 = floatx80_add(fp1, log_tbl[j + 1],
338 status); /* LOG(F)+U*V*(A2+V*(A4+V*A6)) */
339 fp0 = floatx80_add(fp0, fp1, status); /* FP0 IS LOG(F) + LOG(1+U) */
340
341 status->float_rounding_mode = user_rnd_mode;
342 status->floatx80_rounding_precision = user_rnd_prec;
343
344 a = floatx80_add(fp0, klog2, status);
345
346 float_raise(float_flag_inexact, status);
347
348 return a;
349 } else if (compact < 0x3FFEF07D || compact > 0x3FFF8841) {
350 /* |X| < 1/16 or |X| > -1/16 */
351 /* LP1CARE */
352 fSig = (aSig & UINT64_C(0xFE00000000000000)) | UINT64_C(0x0100000000000000);
353 f = packFloatx80(0, 0x3FFF, fSig); /* F */
354 j = (fSig >> 56) & 0x7E; /* DISPLACEMENT FOR 1/F */
355
356 if (compact >= 0x3FFF8000) { /* 1+Z >= 1 */
357 /* KISZERO */
358 fp0 = floatx80_sub(float32_to_floatx80(make_float32(0x3F800000),
359 status), f, status); /* 1-F */
360 fp0 = floatx80_add(fp0, fp1, status); /* FP0 IS Y-F = (1-F)+Z */
361 fp1 = packFloatx80(0, 0, 0); /* K = 0 */
362 } else {
363 /* KISNEG */
364 fp0 = floatx80_sub(float32_to_floatx80(make_float32(0x40000000),
365 status), f, status); /* 2-F */
366 fp1 = floatx80_add(fp1, fp1, status); /* 2Z */
367 fp0 = floatx80_add(fp0, fp1, status); /* FP0 IS Y-F = (2-F)+2Z */
368 fp1 = packFloatx80(1, one_exp, one_sig); /* K = -1 */
369 }
370 goto lp1cont1;
371 } else {
372 /* LP1ONE16 */
373 fp1 = floatx80_add(fp1, fp1, status); /* FP1 IS 2Z */
374 fp0 = floatx80_add(fp0, float32_to_floatx80(make_float32(0x3F800000),
375 status), status); /* FP0 IS 1+X */
376
377 /* LP1CONT2 */
378 fp1 = floatx80_div(fp1, fp0, status); /* U */
379 saveu = fp1;
380 fp0 = floatx80_mul(fp1, fp1, status); /* FP0 IS V = U*U */
381 fp1 = floatx80_mul(fp0, fp0, status); /* FP1 IS W = V*V */
382
383 fp3 = float64_to_floatx80(make_float64(0x3F175496ADD7DAD6),
384 status); /* B5 */
385 fp2 = float64_to_floatx80(make_float64(0x3F3C71C2FE80C7E0),
386 status); /* B4 */
387 fp3 = floatx80_mul(fp3, fp1, status); /* W*B5 */
388 fp2 = floatx80_mul(fp2, fp1, status); /* W*B4 */
389 fp3 = floatx80_add(fp3, float64_to_floatx80(
390 make_float64(0x3F624924928BCCFF), status),
391 status); /* B3+W*B5 */
392 fp2 = floatx80_add(fp2, float64_to_floatx80(
393 make_float64(0x3F899999999995EC), status),
394 status); /* B2+W*B4 */
395 fp1 = floatx80_mul(fp1, fp3, status); /* W*(B3+W*B5) */
396 fp2 = floatx80_mul(fp2, fp0, status); /* V*(B2+W*B4) */
397 fp1 = floatx80_add(fp1, float64_to_floatx80(
398 make_float64(0x3FB5555555555555), status),
399 status); /* B1+W*(B3+W*B5) */
400
401 fp0 = floatx80_mul(fp0, saveu, status); /* FP0 IS U*V */
402 fp1 = floatx80_add(fp1, fp2,
403 status); /* B1+W*(B3+W*B5) + V*(B2+W*B4) */
404 fp0 = floatx80_mul(fp0, fp1,
405 status); /* U*V*([B1+W*(B3+W*B5)] + [V*(B2+W*B4)]) */
406
407 status->float_rounding_mode = user_rnd_mode;
408 status->floatx80_rounding_precision = user_rnd_prec;
409
410 a = floatx80_add(fp0, saveu, status);
411
412 /*if (!floatx80_is_zero(a)) { */
413 float_raise(float_flag_inexact, status);
414 /*} */
415
416 return a;
417 }
418 }
419
420 /*
421 * Log base e
422 */
423
424 floatx80 floatx80_logn(floatx80 a, float_status *status)
425 {
426 bool aSign;
427 int32_t aExp;
428 uint64_t aSig, fSig;
429
430 FloatRoundMode user_rnd_mode;
431 FloatX80RoundPrec user_rnd_prec;
432
433 int32_t compact, j, k, adjk;
434 floatx80 fp0, fp1, fp2, fp3, f, logof2, klog2, saveu;
435
436 aSig = extractFloatx80Frac(a);
437 aExp = extractFloatx80Exp(a);
438 aSign = extractFloatx80Sign(a);
439
440 if (aExp == 0x7FFF) {
441 if ((uint64_t) (aSig << 1)) {
442 propagateFloatx80NaNOneArg(a, status);
443 }
444 if (aSign == 0) {
445 return packFloatx80(0, floatx80_infinity.high,
446 floatx80_infinity.low);
447 }
448 }
449
450 adjk = 0;
451
452 if (aExp == 0) {
453 if (aSig == 0) { /* zero */
454 float_raise(float_flag_divbyzero, status);
455 return packFloatx80(1, floatx80_infinity.high,
456 floatx80_infinity.low);
457 }
458 if ((aSig & one_sig) == 0) { /* denormal */
459 normalizeFloatx80Subnormal(aSig, &aExp, &aSig);
460 adjk = -100;
461 aExp += 100;
462 a = packFloatx80(aSign, aExp, aSig);
463 }
464 }
465
466 if (aSign) {
467 float_raise(float_flag_invalid, status);
468 return floatx80_default_nan(status);
469 }
470
471 user_rnd_mode = status->float_rounding_mode;
472 user_rnd_prec = status->floatx80_rounding_precision;
473 status->float_rounding_mode = float_round_nearest_even;
474 status->floatx80_rounding_precision = floatx80_precision_x;
475
476 compact = floatx80_make_compact(aExp, aSig);
477
478 if (compact < 0x3FFEF07D || compact > 0x3FFF8841) {
479 /* |X| < 15/16 or |X| > 17/16 */
480 k = aExp - 0x3FFF;
481 k += adjk;
482 fp1 = int32_to_floatx80(k, status);
483
484 fSig = (aSig & UINT64_C(0xFE00000000000000)) | UINT64_C(0x0100000000000000);
485 j = (fSig >> 56) & 0x7E; /* DISPLACEMENT FOR 1/F */
486
487 f = packFloatx80(0, 0x3FFF, fSig); /* F */
488 fp0 = packFloatx80(0, 0x3FFF, aSig); /* Y */
489
490 fp0 = floatx80_sub(fp0, f, status); /* Y-F */
491
492 /* LP1CONT1 */
493 fp0 = floatx80_mul(fp0, log_tbl[j], status); /* FP0 IS U = (Y-F)/F */
494 logof2 = packFloatx80(0, 0x3FFE, UINT64_C(0xB17217F7D1CF79AC));
495 klog2 = floatx80_mul(fp1, logof2, status); /* FP1 IS K*LOG2 */
496 fp2 = floatx80_mul(fp0, fp0, status); /* FP2 IS V=U*U */
497
498 fp3 = fp2;
499 fp1 = fp2;
500
501 fp1 = floatx80_mul(fp1, float64_to_floatx80(
502 make_float64(0x3FC2499AB5E4040B), status),
503 status); /* V*A6 */
504 fp2 = floatx80_mul(fp2, float64_to_floatx80(
505 make_float64(0xBFC555B5848CB7DB), status),
506 status); /* V*A5 */
507 fp1 = floatx80_add(fp1, float64_to_floatx80(
508 make_float64(0x3FC99999987D8730), status),
509 status); /* A4+V*A6 */
510 fp2 = floatx80_add(fp2, float64_to_floatx80(
511 make_float64(0xBFCFFFFFFF6F7E97), status),
512 status); /* A3+V*A5 */
513 fp1 = floatx80_mul(fp1, fp3, status); /* V*(A4+V*A6) */
514 fp2 = floatx80_mul(fp2, fp3, status); /* V*(A3+V*A5) */
515 fp1 = floatx80_add(fp1, float64_to_floatx80(
516 make_float64(0x3FD55555555555A4), status),
517 status); /* A2+V*(A4+V*A6) */
518 fp2 = floatx80_add(fp2, float64_to_floatx80(
519 make_float64(0xBFE0000000000008), status),
520 status); /* A1+V*(A3+V*A5) */
521 fp1 = floatx80_mul(fp1, fp3, status); /* V*(A2+V*(A4+V*A6)) */
522 fp2 = floatx80_mul(fp2, fp3, status); /* V*(A1+V*(A3+V*A5)) */
523 fp1 = floatx80_mul(fp1, fp0, status); /* U*V*(A2+V*(A4+V*A6)) */
524 fp0 = floatx80_add(fp0, fp2, status); /* U+V*(A1+V*(A3+V*A5)) */
525
526 fp1 = floatx80_add(fp1, log_tbl[j + 1],
527 status); /* LOG(F)+U*V*(A2+V*(A4+V*A6)) */
528 fp0 = floatx80_add(fp0, fp1, status); /* FP0 IS LOG(F) + LOG(1+U) */
529
530 status->float_rounding_mode = user_rnd_mode;
531 status->floatx80_rounding_precision = user_rnd_prec;
532
533 a = floatx80_add(fp0, klog2, status);
534
535 float_raise(float_flag_inexact, status);
536
537 return a;
538 } else { /* |X-1| >= 1/16 */
539 fp0 = a;
540 fp1 = a;
541 fp1 = floatx80_sub(fp1, float32_to_floatx80(make_float32(0x3F800000),
542 status), status); /* FP1 IS X-1 */
543 fp0 = floatx80_add(fp0, float32_to_floatx80(make_float32(0x3F800000),
544 status), status); /* FP0 IS X+1 */
545 fp1 = floatx80_add(fp1, fp1, status); /* FP1 IS 2(X-1) */
546
547 /* LP1CONT2 */
548 fp1 = floatx80_div(fp1, fp0, status); /* U */
549 saveu = fp1;
550 fp0 = floatx80_mul(fp1, fp1, status); /* FP0 IS V = U*U */
551 fp1 = floatx80_mul(fp0, fp0, status); /* FP1 IS W = V*V */
552
553 fp3 = float64_to_floatx80(make_float64(0x3F175496ADD7DAD6),
554 status); /* B5 */
555 fp2 = float64_to_floatx80(make_float64(0x3F3C71C2FE80C7E0),
556 status); /* B4 */
557 fp3 = floatx80_mul(fp3, fp1, status); /* W*B5 */
558 fp2 = floatx80_mul(fp2, fp1, status); /* W*B4 */
559 fp3 = floatx80_add(fp3, float64_to_floatx80(
560 make_float64(0x3F624924928BCCFF), status),
561 status); /* B3+W*B5 */
562 fp2 = floatx80_add(fp2, float64_to_floatx80(
563 make_float64(0x3F899999999995EC), status),
564 status); /* B2+W*B4 */
565 fp1 = floatx80_mul(fp1, fp3, status); /* W*(B3+W*B5) */
566 fp2 = floatx80_mul(fp2, fp0, status); /* V*(B2+W*B4) */
567 fp1 = floatx80_add(fp1, float64_to_floatx80(
568 make_float64(0x3FB5555555555555), status),
569 status); /* B1+W*(B3+W*B5) */
570
571 fp0 = floatx80_mul(fp0, saveu, status); /* FP0 IS U*V */
572 fp1 = floatx80_add(fp1, fp2, status); /* B1+W*(B3+W*B5) + V*(B2+W*B4) */
573 fp0 = floatx80_mul(fp0, fp1,
574 status); /* U*V*([B1+W*(B3+W*B5)] + [V*(B2+W*B4)]) */
575
576 status->float_rounding_mode = user_rnd_mode;
577 status->floatx80_rounding_precision = user_rnd_prec;
578
579 a = floatx80_add(fp0, saveu, status);
580
581 /*if (!floatx80_is_zero(a)) { */
582 float_raise(float_flag_inexact, status);
583 /*} */
584
585 return a;
586 }
587 }
588
589 /*
590 * Log base 10
591 */
592
593 floatx80 floatx80_log10(floatx80 a, float_status *status)
594 {
595 bool aSign;
596 int32_t aExp;
597 uint64_t aSig;
598
599 FloatRoundMode user_rnd_mode;
600 FloatX80RoundPrec user_rnd_prec;
601
602 floatx80 fp0, fp1;
603
604 aSig = extractFloatx80Frac(a);
605 aExp = extractFloatx80Exp(a);
606 aSign = extractFloatx80Sign(a);
607
608 if (aExp == 0x7FFF) {
609 if ((uint64_t) (aSig << 1)) {
610 propagateFloatx80NaNOneArg(a, status);
611 }
612 if (aSign == 0) {
613 return packFloatx80(0, floatx80_infinity.high,
614 floatx80_infinity.low);
615 }
616 }
617
618 if (aExp == 0 && aSig == 0) {
619 float_raise(float_flag_divbyzero, status);
620 return packFloatx80(1, floatx80_infinity.high,
621 floatx80_infinity.low);
622 }
623
624 if (aSign) {
625 float_raise(float_flag_invalid, status);
626 return floatx80_default_nan(status);
627 }
628
629 user_rnd_mode = status->float_rounding_mode;
630 user_rnd_prec = status->floatx80_rounding_precision;
631 status->float_rounding_mode = float_round_nearest_even;
632 status->floatx80_rounding_precision = floatx80_precision_x;
633
634 fp0 = floatx80_logn(a, status);
635 fp1 = packFloatx80(0, 0x3FFD, UINT64_C(0xDE5BD8A937287195)); /* INV_L10 */
636
637 status->float_rounding_mode = user_rnd_mode;
638 status->floatx80_rounding_precision = user_rnd_prec;
639
640 a = floatx80_mul(fp0, fp1, status); /* LOGN(X)*INV_L10 */
641
642 float_raise(float_flag_inexact, status);
643
644 return a;
645 }
646
647 /*
648 * Log base 2
649 */
650
651 floatx80 floatx80_log2(floatx80 a, float_status *status)
652 {
653 bool aSign;
654 int32_t aExp;
655 uint64_t aSig;
656
657 FloatRoundMode user_rnd_mode;
658 FloatX80RoundPrec user_rnd_prec;
659
660 floatx80 fp0, fp1;
661
662 aSig = extractFloatx80Frac(a);
663 aExp = extractFloatx80Exp(a);
664 aSign = extractFloatx80Sign(a);
665
666 if (aExp == 0x7FFF) {
667 if ((uint64_t) (aSig << 1)) {
668 propagateFloatx80NaNOneArg(a, status);
669 }
670 if (aSign == 0) {
671 return packFloatx80(0, floatx80_infinity.high,
672 floatx80_infinity.low);
673 }
674 }
675
676 if (aExp == 0) {
677 if (aSig == 0) {
678 float_raise(float_flag_divbyzero, status);
679 return packFloatx80(1, floatx80_infinity.high,
680 floatx80_infinity.low);
681 }
682 normalizeFloatx80Subnormal(aSig, &aExp, &aSig);
683 }
684
685 if (aSign) {
686 float_raise(float_flag_invalid, status);
687 return floatx80_default_nan(status);
688 }
689
690 user_rnd_mode = status->float_rounding_mode;
691 user_rnd_prec = status->floatx80_rounding_precision;
692 status->float_rounding_mode = float_round_nearest_even;
693 status->floatx80_rounding_precision = floatx80_precision_x;
694
695 if (aSig == one_sig) { /* X is 2^k */
696 status->float_rounding_mode = user_rnd_mode;
697 status->floatx80_rounding_precision = user_rnd_prec;
698
699 a = int32_to_floatx80(aExp - 0x3FFF, status);
700 } else {
701 fp0 = floatx80_logn(a, status);
702 fp1 = packFloatx80(0, 0x3FFF, UINT64_C(0xB8AA3B295C17F0BC)); /* INV_L2 */
703
704 status->float_rounding_mode = user_rnd_mode;
705 status->floatx80_rounding_precision = user_rnd_prec;
706
707 a = floatx80_mul(fp0, fp1, status); /* LOGN(X)*INV_L2 */
708 }
709
710 float_raise(float_flag_inexact, status);
711
712 return a;
713 }
714
715 /*
716 * e to x
717 */
718
719 floatx80 floatx80_etox(floatx80 a, float_status *status)
720 {
721 bool aSign;
722 int32_t aExp;
723 uint64_t aSig;
724
725 FloatRoundMode user_rnd_mode;
726 FloatX80RoundPrec user_rnd_prec;
727
728 int32_t compact, n, j, k, m, m1;
729 floatx80 fp0, fp1, fp2, fp3, l2, scale, adjscale;
730 bool adjflag;
731
732 aSig = extractFloatx80Frac(a);
733 aExp = extractFloatx80Exp(a);
734 aSign = extractFloatx80Sign(a);
735
736 if (aExp == 0x7FFF) {
737 if ((uint64_t) (aSig << 1)) {
738 return propagateFloatx80NaNOneArg(a, status);
739 }
740 if (aSign) {
741 return packFloatx80(0, 0, 0);
742 }
743 return packFloatx80(0, floatx80_infinity.high,
744 floatx80_infinity.low);
745 }
746
747 if (aExp == 0 && aSig == 0) {
748 return packFloatx80(0, one_exp, one_sig);
749 }
750
751 user_rnd_mode = status->float_rounding_mode;
752 user_rnd_prec = status->floatx80_rounding_precision;
753 status->float_rounding_mode = float_round_nearest_even;
754 status->floatx80_rounding_precision = floatx80_precision_x;
755
756 adjflag = 0;
757
758 if (aExp >= 0x3FBE) { /* |X| >= 2^(-65) */
759 compact = floatx80_make_compact(aExp, aSig);
760
761 if (compact < 0x400CB167) { /* |X| < 16380 log2 */
762 fp0 = a;
763 fp1 = a;
764 fp0 = floatx80_mul(fp0, float32_to_floatx80(
765 make_float32(0x42B8AA3B), status),
766 status); /* 64/log2 * X */
767 adjflag = 0;
768 n = floatx80_to_int32(fp0, status); /* int(64/log2*X) */
769 fp0 = int32_to_floatx80(n, status);
770
771 j = n & 0x3F; /* J = N mod 64 */
772 m = n / 64; /* NOTE: this is really arithmetic right shift by 6 */
773 if (n < 0 && j) {
774 /*
775 * arithmetic right shift is division and
776 * round towards minus infinity
777 */
778 m--;
779 }
780 m += 0x3FFF; /* biased exponent of 2^(M) */
781
782 expcont1:
783 fp2 = fp0; /* N */
784 fp0 = floatx80_mul(fp0, float32_to_floatx80(
785 make_float32(0xBC317218), status),
786 status); /* N * L1, L1 = lead(-log2/64) */
787 l2 = packFloatx80(0, 0x3FDC, UINT64_C(0x82E308654361C4C6));
788 fp2 = floatx80_mul(fp2, l2, status); /* N * L2, L1+L2 = -log2/64 */
789 fp0 = floatx80_add(fp0, fp1, status); /* X + N*L1 */
790 fp0 = floatx80_add(fp0, fp2, status); /* R */
791
792 fp1 = floatx80_mul(fp0, fp0, status); /* S = R*R */
793 fp2 = float32_to_floatx80(make_float32(0x3AB60B70),
794 status); /* A5 */
795 fp2 = floatx80_mul(fp2, fp1, status); /* fp2 is S*A5 */
796 fp3 = floatx80_mul(float32_to_floatx80(make_float32(0x3C088895),
797 status), fp1,
798 status); /* fp3 is S*A4 */
799 fp2 = floatx80_add(fp2, float64_to_floatx80(make_float64(
800 0x3FA5555555554431), status),
801 status); /* fp2 is A3+S*A5 */
802 fp3 = floatx80_add(fp3, float64_to_floatx80(make_float64(
803 0x3FC5555555554018), status),
804 status); /* fp3 is A2+S*A4 */
805 fp2 = floatx80_mul(fp2, fp1, status); /* fp2 is S*(A3+S*A5) */
806 fp3 = floatx80_mul(fp3, fp1, status); /* fp3 is S*(A2+S*A4) */
807 fp2 = floatx80_add(fp2, float32_to_floatx80(
808 make_float32(0x3F000000), status),
809 status); /* fp2 is A1+S*(A3+S*A5) */
810 fp3 = floatx80_mul(fp3, fp0, status); /* fp3 IS R*S*(A2+S*A4) */
811 fp2 = floatx80_mul(fp2, fp1,
812 status); /* fp2 IS S*(A1+S*(A3+S*A5)) */
813 fp0 = floatx80_add(fp0, fp3, status); /* fp0 IS R+R*S*(A2+S*A4) */
814 fp0 = floatx80_add(fp0, fp2, status); /* fp0 IS EXP(R) - 1 */
815
816 fp1 = exp_tbl[j];
817 fp0 = floatx80_mul(fp0, fp1, status); /* 2^(J/64)*(Exp(R)-1) */
818 fp0 = floatx80_add(fp0, float32_to_floatx80(exp_tbl2[j], status),
819 status); /* accurate 2^(J/64) */
820 fp0 = floatx80_add(fp0, fp1,
821 status); /* 2^(J/64) + 2^(J/64)*(Exp(R)-1) */
822
823 scale = packFloatx80(0, m, one_sig);
824 if (adjflag) {
825 adjscale = packFloatx80(0, m1, one_sig);
826 fp0 = floatx80_mul(fp0, adjscale, status);
827 }
828
829 status->float_rounding_mode = user_rnd_mode;
830 status->floatx80_rounding_precision = user_rnd_prec;
831
832 a = floatx80_mul(fp0, scale, status);
833
834 float_raise(float_flag_inexact, status);
835
836 return a;
837 } else { /* |X| >= 16380 log2 */
838 if (compact > 0x400CB27C) { /* |X| >= 16480 log2 */
839 status->float_rounding_mode = user_rnd_mode;
840 status->floatx80_rounding_precision = user_rnd_prec;
841 if (aSign) {
842 a = roundAndPackFloatx80(
843 status->floatx80_rounding_precision,
844 0, -0x1000, aSig, 0, status);
845 } else {
846 a = roundAndPackFloatx80(
847 status->floatx80_rounding_precision,
848 0, 0x8000, aSig, 0, status);
849 }
850 float_raise(float_flag_inexact, status);
851
852 return a;
853 } else {
854 fp0 = a;
855 fp1 = a;
856 fp0 = floatx80_mul(fp0, float32_to_floatx80(
857 make_float32(0x42B8AA3B), status),
858 status); /* 64/log2 * X */
859 adjflag = 1;
860 n = floatx80_to_int32(fp0, status); /* int(64/log2*X) */
861 fp0 = int32_to_floatx80(n, status);
862
863 j = n & 0x3F; /* J = N mod 64 */
864 /* NOTE: this is really arithmetic right shift by 6 */
865 k = n / 64;
866 if (n < 0 && j) {
867 /* arithmetic right shift is division and
868 * round towards minus infinity
869 */
870 k--;
871 }
872 /* NOTE: this is really arithmetic right shift by 1 */
873 m1 = k / 2;
874 if (k < 0 && (k & 1)) {
875 /* arithmetic right shift is division and
876 * round towards minus infinity
877 */
878 m1--;
879 }
880 m = k - m1;
881 m1 += 0x3FFF; /* biased exponent of 2^(M1) */
882 m += 0x3FFF; /* biased exponent of 2^(M) */
883
884 goto expcont1;
885 }
886 }
887 } else { /* |X| < 2^(-65) */
888 status->float_rounding_mode = user_rnd_mode;
889 status->floatx80_rounding_precision = user_rnd_prec;
890
891 a = floatx80_add(a, float32_to_floatx80(make_float32(0x3F800000),
892 status), status); /* 1 + X */
893
894 float_raise(float_flag_inexact, status);
895
896 return a;
897 }
898 }
899
900 /*
901 * 2 to x
902 */
903
904 floatx80 floatx80_twotox(floatx80 a, float_status *status)
905 {
906 bool aSign;
907 int32_t aExp;
908 uint64_t aSig;
909
910 FloatRoundMode user_rnd_mode;
911 FloatX80RoundPrec user_rnd_prec;
912
913 int32_t compact, n, j, l, m, m1;
914 floatx80 fp0, fp1, fp2, fp3, adjfact, fact1, fact2;
915
916 aSig = extractFloatx80Frac(a);
917 aExp = extractFloatx80Exp(a);
918 aSign = extractFloatx80Sign(a);
919
920 if (aExp == 0x7FFF) {
921 if ((uint64_t) (aSig << 1)) {
922 return propagateFloatx80NaNOneArg(a, status);
923 }
924 if (aSign) {
925 return packFloatx80(0, 0, 0);
926 }
927 return packFloatx80(0, floatx80_infinity.high,
928 floatx80_infinity.low);
929 }
930
931 if (aExp == 0 && aSig == 0) {
932 return packFloatx80(0, one_exp, one_sig);
933 }
934
935 user_rnd_mode = status->float_rounding_mode;
936 user_rnd_prec = status->floatx80_rounding_precision;
937 status->float_rounding_mode = float_round_nearest_even;
938 status->floatx80_rounding_precision = floatx80_precision_x;
939
940 fp0 = a;
941
942 compact = floatx80_make_compact(aExp, aSig);
943
944 if (compact < 0x3FB98000 || compact > 0x400D80C0) {
945 /* |X| > 16480 or |X| < 2^(-70) */
946 if (compact > 0x3FFF8000) { /* |X| > 16480 */
947 status->float_rounding_mode = user_rnd_mode;
948 status->floatx80_rounding_precision = user_rnd_prec;
949
950 if (aSign) {
951 return roundAndPackFloatx80(status->floatx80_rounding_precision,
952 0, -0x1000, aSig, 0, status);
953 } else {
954 return roundAndPackFloatx80(status->floatx80_rounding_precision,
955 0, 0x8000, aSig, 0, status);
956 }
957 } else { /* |X| < 2^(-70) */
958 status->float_rounding_mode = user_rnd_mode;
959 status->floatx80_rounding_precision = user_rnd_prec;
960
961 a = floatx80_add(fp0, float32_to_floatx80(
962 make_float32(0x3F800000), status),
963 status); /* 1 + X */
964
965 float_raise(float_flag_inexact, status);
966
967 return a;
968 }
969 } else { /* 2^(-70) <= |X| <= 16480 */
970 fp1 = fp0; /* X */
971 fp1 = floatx80_mul(fp1, float32_to_floatx80(
972 make_float32(0x42800000), status),
973 status); /* X * 64 */
974 n = floatx80_to_int32(fp1, status);
975 fp1 = int32_to_floatx80(n, status);
976 j = n & 0x3F;
977 l = n / 64; /* NOTE: this is really arithmetic right shift by 6 */
978 if (n < 0 && j) {
979 /*
980 * arithmetic right shift is division and
981 * round towards minus infinity
982 */
983 l--;
984 }
985 m = l / 2; /* NOTE: this is really arithmetic right shift by 1 */
986 if (l < 0 && (l & 1)) {
987 /*
988 * arithmetic right shift is division and
989 * round towards minus infinity
990 */
991 m--;
992 }
993 m1 = l - m;
994 m1 += 0x3FFF; /* ADJFACT IS 2^(M') */
995
996 adjfact = packFloatx80(0, m1, one_sig);
997 fact1 = exp2_tbl[j];
998 fact1.high += m;
999 fact2.high = exp2_tbl2[j] >> 16;
1000 fact2.high += m;
1001 fact2.low = (uint64_t)(exp2_tbl2[j] & 0xFFFF);
1002 fact2.low <<= 48;
1003
1004 fp1 = floatx80_mul(fp1, float32_to_floatx80(
1005 make_float32(0x3C800000), status),
1006 status); /* (1/64)*N */
1007 fp0 = floatx80_sub(fp0, fp1, status); /* X - (1/64)*INT(64 X) */
1008 fp2 = packFloatx80(0, 0x3FFE, UINT64_C(0xB17217F7D1CF79AC)); /* LOG2 */
1009 fp0 = floatx80_mul(fp0, fp2, status); /* R */
1010
1011 /* EXPR */
1012 fp1 = floatx80_mul(fp0, fp0, status); /* S = R*R */
1013 fp2 = float64_to_floatx80(make_float64(0x3F56C16D6F7BD0B2),
1014 status); /* A5 */
1015 fp3 = float64_to_floatx80(make_float64(0x3F811112302C712C),
1016 status); /* A4 */
1017 fp2 = floatx80_mul(fp2, fp1, status); /* S*A5 */
1018 fp3 = floatx80_mul(fp3, fp1, status); /* S*A4 */
1019 fp2 = floatx80_add(fp2, float64_to_floatx80(
1020 make_float64(0x3FA5555555554CC1), status),
1021 status); /* A3+S*A5 */
1022 fp3 = floatx80_add(fp3, float64_to_floatx80(
1023 make_float64(0x3FC5555555554A54), status),
1024 status); /* A2+S*A4 */
1025 fp2 = floatx80_mul(fp2, fp1, status); /* S*(A3+S*A5) */
1026 fp3 = floatx80_mul(fp3, fp1, status); /* S*(A2+S*A4) */
1027 fp2 = floatx80_add(fp2, float64_to_floatx80(
1028 make_float64(0x3FE0000000000000), status),
1029 status); /* A1+S*(A3+S*A5) */
1030 fp3 = floatx80_mul(fp3, fp0, status); /* R*S*(A2+S*A4) */
1031
1032 fp2 = floatx80_mul(fp2, fp1, status); /* S*(A1+S*(A3+S*A5)) */
1033 fp0 = floatx80_add(fp0, fp3, status); /* R+R*S*(A2+S*A4) */
1034 fp0 = floatx80_add(fp0, fp2, status); /* EXP(R) - 1 */
1035
1036 fp0 = floatx80_mul(fp0, fact1, status);
1037 fp0 = floatx80_add(fp0, fact2, status);
1038 fp0 = floatx80_add(fp0, fact1, status);
1039
1040 status->float_rounding_mode = user_rnd_mode;
1041 status->floatx80_rounding_precision = user_rnd_prec;
1042
1043 a = floatx80_mul(fp0, adjfact, status);
1044
1045 float_raise(float_flag_inexact, status);
1046
1047 return a;
1048 }
1049 }
1050
1051 /*
1052 * 10 to x
1053 */
1054
1055 floatx80 floatx80_tentox(floatx80 a, float_status *status)
1056 {
1057 bool aSign;
1058 int32_t aExp;
1059 uint64_t aSig;
1060
1061 FloatRoundMode user_rnd_mode;
1062 FloatX80RoundPrec user_rnd_prec;
1063
1064 int32_t compact, n, j, l, m, m1;
1065 floatx80 fp0, fp1, fp2, fp3, adjfact, fact1, fact2;
1066
1067 aSig = extractFloatx80Frac(a);
1068 aExp = extractFloatx80Exp(a);
1069 aSign = extractFloatx80Sign(a);
1070
1071 if (aExp == 0x7FFF) {
1072 if ((uint64_t) (aSig << 1)) {
1073 return propagateFloatx80NaNOneArg(a, status);
1074 }
1075 if (aSign) {
1076 return packFloatx80(0, 0, 0);
1077 }
1078 return packFloatx80(0, floatx80_infinity.high,
1079 floatx80_infinity.low);
1080 }
1081
1082 if (aExp == 0 && aSig == 0) {
1083 return packFloatx80(0, one_exp, one_sig);
1084 }
1085
1086 user_rnd_mode = status->float_rounding_mode;
1087 user_rnd_prec = status->floatx80_rounding_precision;
1088 status->float_rounding_mode = float_round_nearest_even;
1089 status->floatx80_rounding_precision = floatx80_precision_x;
1090
1091 fp0 = a;
1092
1093 compact = floatx80_make_compact(aExp, aSig);
1094
1095 if (compact < 0x3FB98000 || compact > 0x400B9B07) {
1096 /* |X| > 16480 LOG2/LOG10 or |X| < 2^(-70) */
1097 if (compact > 0x3FFF8000) { /* |X| > 16480 */
1098 status->float_rounding_mode = user_rnd_mode;
1099 status->floatx80_rounding_precision = user_rnd_prec;
1100
1101 if (aSign) {
1102 return roundAndPackFloatx80(status->floatx80_rounding_precision,
1103 0, -0x1000, aSig, 0, status);
1104 } else {
1105 return roundAndPackFloatx80(status->floatx80_rounding_precision,
1106 0, 0x8000, aSig, 0, status);
1107 }
1108 } else { /* |X| < 2^(-70) */
1109 status->float_rounding_mode = user_rnd_mode;
1110 status->floatx80_rounding_precision = user_rnd_prec;
1111
1112 a = floatx80_add(fp0, float32_to_floatx80(
1113 make_float32(0x3F800000), status),
1114 status); /* 1 + X */
1115
1116 float_raise(float_flag_inexact, status);
1117
1118 return a;
1119 }
1120 } else { /* 2^(-70) <= |X| <= 16480 LOG 2 / LOG 10 */
1121 fp1 = fp0; /* X */
1122 fp1 = floatx80_mul(fp1, float64_to_floatx80(
1123 make_float64(0x406A934F0979A371),
1124 status), status); /* X*64*LOG10/LOG2 */
1125 n = floatx80_to_int32(fp1, status); /* N=INT(X*64*LOG10/LOG2) */
1126 fp1 = int32_to_floatx80(n, status);
1127
1128 j = n & 0x3F;
1129 l = n / 64; /* NOTE: this is really arithmetic right shift by 6 */
1130 if (n < 0 && j) {
1131 /*
1132 * arithmetic right shift is division and
1133 * round towards minus infinity
1134 */
1135 l--;
1136 }
1137 m = l / 2; /* NOTE: this is really arithmetic right shift by 1 */
1138 if (l < 0 && (l & 1)) {
1139 /*
1140 * arithmetic right shift is division and
1141 * round towards minus infinity
1142 */
1143 m--;
1144 }
1145 m1 = l - m;
1146 m1 += 0x3FFF; /* ADJFACT IS 2^(M') */
1147
1148 adjfact = packFloatx80(0, m1, one_sig);
1149 fact1 = exp2_tbl[j];
1150 fact1.high += m;
1151 fact2.high = exp2_tbl2[j] >> 16;
1152 fact2.high += m;
1153 fact2.low = (uint64_t)(exp2_tbl2[j] & 0xFFFF);
1154 fact2.low <<= 48;
1155
1156 fp2 = fp1; /* N */
1157 fp1 = floatx80_mul(fp1, float64_to_floatx80(
1158 make_float64(0x3F734413509F8000), status),
1159 status); /* N*(LOG2/64LOG10)_LEAD */
1160 fp3 = packFloatx80(1, 0x3FCD, UINT64_C(0xC0219DC1DA994FD2));
1161 fp2 = floatx80_mul(fp2, fp3, status); /* N*(LOG2/64LOG10)_TRAIL */
1162 fp0 = floatx80_sub(fp0, fp1, status); /* X - N L_LEAD */
1163 fp0 = floatx80_sub(fp0, fp2, status); /* X - N L_TRAIL */
1164 fp2 = packFloatx80(0, 0x4000, UINT64_C(0x935D8DDDAAA8AC17)); /* LOG10 */
1165 fp0 = floatx80_mul(fp0, fp2, status); /* R */
1166
1167 /* EXPR */
1168 fp1 = floatx80_mul(fp0, fp0, status); /* S = R*R */
1169 fp2 = float64_to_floatx80(make_float64(0x3F56C16D6F7BD0B2),
1170 status); /* A5 */
1171 fp3 = float64_to_floatx80(make_float64(0x3F811112302C712C),
1172 status); /* A4 */
1173 fp2 = floatx80_mul(fp2, fp1, status); /* S*A5 */
1174 fp3 = floatx80_mul(fp3, fp1, status); /* S*A4 */
1175 fp2 = floatx80_add(fp2, float64_to_floatx80(
1176 make_float64(0x3FA5555555554CC1), status),
1177 status); /* A3+S*A5 */
1178 fp3 = floatx80_add(fp3, float64_to_floatx80(
1179 make_float64(0x3FC5555555554A54), status),
1180 status); /* A2+S*A4 */
1181 fp2 = floatx80_mul(fp2, fp1, status); /* S*(A3+S*A5) */
1182 fp3 = floatx80_mul(fp3, fp1, status); /* S*(A2+S*A4) */
1183 fp2 = floatx80_add(fp2, float64_to_floatx80(
1184 make_float64(0x3FE0000000000000), status),
1185 status); /* A1+S*(A3+S*A5) */
1186 fp3 = floatx80_mul(fp3, fp0, status); /* R*S*(A2+S*A4) */
1187
1188 fp2 = floatx80_mul(fp2, fp1, status); /* S*(A1+S*(A3+S*A5)) */
1189 fp0 = floatx80_add(fp0, fp3, status); /* R+R*S*(A2+S*A4) */
1190 fp0 = floatx80_add(fp0, fp2, status); /* EXP(R) - 1 */
1191
1192 fp0 = floatx80_mul(fp0, fact1, status);
1193 fp0 = floatx80_add(fp0, fact2, status);
1194 fp0 = floatx80_add(fp0, fact1, status);
1195
1196 status->float_rounding_mode = user_rnd_mode;
1197 status->floatx80_rounding_precision = user_rnd_prec;
1198
1199 a = floatx80_mul(fp0, adjfact, status);
1200
1201 float_raise(float_flag_inexact, status);
1202
1203 return a;
1204 }
1205 }
1206
1207 /*
1208 * Tangent
1209 */
1210
1211 floatx80 floatx80_tan(floatx80 a, float_status *status)
1212 {
1213 bool aSign, xSign;
1214 int32_t aExp, xExp;
1215 uint64_t aSig, xSig;
1216
1217 FloatRoundMode user_rnd_mode;
1218 FloatX80RoundPrec user_rnd_prec;
1219
1220 int32_t compact, l, n, j;
1221 floatx80 fp0, fp1, fp2, fp3, fp4, fp5, invtwopi, twopi1, twopi2;
1222 float32 twoto63;
1223 bool endflag;
1224
1225 aSig = extractFloatx80Frac(a);
1226 aExp = extractFloatx80Exp(a);
1227 aSign = extractFloatx80Sign(a);
1228
1229 if (aExp == 0x7FFF) {
1230 if ((uint64_t) (aSig << 1)) {
1231 return propagateFloatx80NaNOneArg(a, status);
1232 }
1233 float_raise(float_flag_invalid, status);
1234 return floatx80_default_nan(status);
1235 }
1236
1237 if (aExp == 0 && aSig == 0) {
1238 return packFloatx80(aSign, 0, 0);
1239 }
1240
1241 user_rnd_mode = status->float_rounding_mode;
1242 user_rnd_prec = status->floatx80_rounding_precision;
1243 status->float_rounding_mode = float_round_nearest_even;
1244 status->floatx80_rounding_precision = floatx80_precision_x;
1245
1246 compact = floatx80_make_compact(aExp, aSig);
1247
1248 fp0 = a;
1249
1250 if (compact < 0x3FD78000 || compact > 0x4004BC7E) {
1251 /* 2^(-40) > |X| > 15 PI */
1252 if (compact > 0x3FFF8000) { /* |X| >= 15 PI */
1253 /* REDUCEX */
1254 fp1 = packFloatx80(0, 0, 0);
1255 if (compact == 0x7FFEFFFF) {
1256 twopi1 = packFloatx80(aSign ^ 1, 0x7FFE,
1257 UINT64_C(0xC90FDAA200000000));
1258 twopi2 = packFloatx80(aSign ^ 1, 0x7FDC,
1259 UINT64_C(0x85A308D300000000));
1260 fp0 = floatx80_add(fp0, twopi1, status);
1261 fp1 = fp0;
1262 fp0 = floatx80_add(fp0, twopi2, status);
1263 fp1 = floatx80_sub(fp1, fp0, status);
1264 fp1 = floatx80_add(fp1, twopi2, status);
1265 }
1266 loop:
1267 xSign = extractFloatx80Sign(fp0);
1268 xExp = extractFloatx80Exp(fp0);
1269 xExp -= 0x3FFF;
1270 if (xExp <= 28) {
1271 l = 0;
1272 endflag = true;
1273 } else {
1274 l = xExp - 27;
1275 endflag = false;
1276 }
1277 invtwopi = packFloatx80(0, 0x3FFE - l,
1278 UINT64_C(0xA2F9836E4E44152A)); /* INVTWOPI */
1279 twopi1 = packFloatx80(0, 0x3FFF + l, UINT64_C(0xC90FDAA200000000));
1280 twopi2 = packFloatx80(0, 0x3FDD + l, UINT64_C(0x85A308D300000000));
1281
1282 /* SIGN(INARG)*2^63 IN SGL */
1283 twoto63 = packFloat32(xSign, 0xBE, 0);
1284
1285 fp2 = floatx80_mul(fp0, invtwopi, status);
1286 fp2 = floatx80_add(fp2, float32_to_floatx80(twoto63, status),
1287 status); /* THE FRACT PART OF FP2 IS ROUNDED */
1288 fp2 = floatx80_sub(fp2, float32_to_floatx80(twoto63, status),
1289 status); /* FP2 is N */
1290 fp4 = floatx80_mul(twopi1, fp2, status); /* W = N*P1 */
1291 fp5 = floatx80_mul(twopi2, fp2, status); /* w = N*P2 */
1292 fp3 = floatx80_add(fp4, fp5, status); /* FP3 is P */
1293 fp4 = floatx80_sub(fp4, fp3, status); /* W-P */
1294 fp0 = floatx80_sub(fp0, fp3, status); /* FP0 is A := R - P */
1295 fp4 = floatx80_add(fp4, fp5, status); /* FP4 is p = (W-P)+w */
1296 fp3 = fp0; /* FP3 is A */
1297 fp1 = floatx80_sub(fp1, fp4, status); /* FP1 is a := r - p */
1298 fp0 = floatx80_add(fp0, fp1, status); /* FP0 is R := A+a */
1299
1300 if (endflag) {
1301 n = floatx80_to_int32(fp2, status);
1302 goto tancont;
1303 }
1304 fp3 = floatx80_sub(fp3, fp0, status); /* A-R */
1305 fp1 = floatx80_add(fp1, fp3, status); /* FP1 is r := (A-R)+a */
1306 goto loop;
1307 } else {
1308 status->float_rounding_mode = user_rnd_mode;
1309 status->floatx80_rounding_precision = user_rnd_prec;
1310
1311 a = floatx80_move(a, status);
1312
1313 float_raise(float_flag_inexact, status);
1314
1315 return a;
1316 }
1317 } else {
1318 fp1 = floatx80_mul(fp0, float64_to_floatx80(
1319 make_float64(0x3FE45F306DC9C883), status),
1320 status); /* X*2/PI */
1321
1322 n = floatx80_to_int32(fp1, status);
1323 j = 32 + n;
1324
1325 fp0 = floatx80_sub(fp0, pi_tbl[j], status); /* X-Y1 */
1326 fp0 = floatx80_sub(fp0, float32_to_floatx80(pi_tbl2[j], status),
1327 status); /* FP0 IS R = (X-Y1)-Y2 */
1328
1329 tancont:
1330 if (n & 1) {
1331 /* NODD */
1332 fp1 = fp0; /* R */
1333 fp0 = floatx80_mul(fp0, fp0, status); /* S = R*R */
1334 fp3 = float64_to_floatx80(make_float64(0x3EA0B759F50F8688),
1335 status); /* Q4 */
1336 fp2 = float64_to_floatx80(make_float64(0xBEF2BAA5A8924F04),
1337 status); /* P3 */
1338 fp3 = floatx80_mul(fp3, fp0, status); /* SQ4 */
1339 fp2 = floatx80_mul(fp2, fp0, status); /* SP3 */
1340 fp3 = floatx80_add(fp3, float64_to_floatx80(
1341 make_float64(0xBF346F59B39BA65F), status),
1342 status); /* Q3+SQ4 */
1343 fp4 = packFloatx80(0, 0x3FF6, UINT64_C(0xE073D3FC199C4A00));
1344 fp2 = floatx80_add(fp2, fp4, status); /* P2+SP3 */
1345 fp3 = floatx80_mul(fp3, fp0, status); /* S(Q3+SQ4) */
1346 fp2 = floatx80_mul(fp2, fp0, status); /* S(P2+SP3) */
1347 fp4 = packFloatx80(0, 0x3FF9, UINT64_C(0xD23CD68415D95FA1));
1348 fp3 = floatx80_add(fp3, fp4, status); /* Q2+S(Q3+SQ4) */
1349 fp4 = packFloatx80(1, 0x3FFC, UINT64_C(0x8895A6C5FB423BCA));
1350 fp2 = floatx80_add(fp2, fp4, status); /* P1+S(P2+SP3) */
1351 fp3 = floatx80_mul(fp3, fp0, status); /* S(Q2+S(Q3+SQ4)) */
1352 fp2 = floatx80_mul(fp2, fp0, status); /* S(P1+S(P2+SP3)) */
1353 fp4 = packFloatx80(1, 0x3FFD, UINT64_C(0xEEF57E0DA84BC8CE));
1354 fp3 = floatx80_add(fp3, fp4, status); /* Q1+S(Q2+S(Q3+SQ4)) */
1355 fp2 = floatx80_mul(fp2, fp1, status); /* RS(P1+S(P2+SP3)) */
1356 fp0 = floatx80_mul(fp0, fp3, status); /* S(Q1+S(Q2+S(Q3+SQ4))) */
1357 fp1 = floatx80_add(fp1, fp2, status); /* R+RS(P1+S(P2+SP3)) */
1358 fp0 = floatx80_add(fp0, float32_to_floatx80(
1359 make_float32(0x3F800000), status),
1360 status); /* 1+S(Q1+S(Q2+S(Q3+SQ4))) */
1361
1362 xSign = extractFloatx80Sign(fp1);
1363 xExp = extractFloatx80Exp(fp1);
1364 xSig = extractFloatx80Frac(fp1);
1365 xSign ^= 1;
1366 fp1 = packFloatx80(xSign, xExp, xSig);
1367
1368 status->float_rounding_mode = user_rnd_mode;
1369 status->floatx80_rounding_precision = user_rnd_prec;
1370
1371 a = floatx80_div(fp0, fp1, status);
1372
1373 float_raise(float_flag_inexact, status);
1374
1375 return a;
1376 } else {
1377 fp1 = floatx80_mul(fp0, fp0, status); /* S = R*R */
1378 fp3 = float64_to_floatx80(make_float64(0x3EA0B759F50F8688),
1379 status); /* Q4 */
1380 fp2 = float64_to_floatx80(make_float64(0xBEF2BAA5A8924F04),
1381 status); /* P3 */
1382 fp3 = floatx80_mul(fp3, fp1, status); /* SQ4 */
1383 fp2 = floatx80_mul(fp2, fp1, status); /* SP3 */
1384 fp3 = floatx80_add(fp3, float64_to_floatx80(
1385 make_float64(0xBF346F59B39BA65F), status),
1386 status); /* Q3+SQ4 */
1387 fp4 = packFloatx80(0, 0x3FF6, UINT64_C(0xE073D3FC199C4A00));
1388 fp2 = floatx80_add(fp2, fp4, status); /* P2+SP3 */
1389 fp3 = floatx80_mul(fp3, fp1, status); /* S(Q3+SQ4) */
1390 fp2 = floatx80_mul(fp2, fp1, status); /* S(P2+SP3) */
1391 fp4 = packFloatx80(0, 0x3FF9, UINT64_C(0xD23CD68415D95FA1));
1392 fp3 = floatx80_add(fp3, fp4, status); /* Q2+S(Q3+SQ4) */
1393 fp4 = packFloatx80(1, 0x3FFC, UINT64_C(0x8895A6C5FB423BCA));
1394 fp2 = floatx80_add(fp2, fp4, status); /* P1+S(P2+SP3) */
1395 fp3 = floatx80_mul(fp3, fp1, status); /* S(Q2+S(Q3+SQ4)) */
1396 fp2 = floatx80_mul(fp2, fp1, status); /* S(P1+S(P2+SP3)) */
1397 fp4 = packFloatx80(1, 0x3FFD, UINT64_C(0xEEF57E0DA84BC8CE));
1398 fp3 = floatx80_add(fp3, fp4, status); /* Q1+S(Q2+S(Q3+SQ4)) */
1399 fp2 = floatx80_mul(fp2, fp0, status); /* RS(P1+S(P2+SP3)) */
1400 fp1 = floatx80_mul(fp1, fp3, status); /* S(Q1+S(Q2+S(Q3+SQ4))) */
1401 fp0 = floatx80_add(fp0, fp2, status); /* R+RS(P1+S(P2+SP3)) */
1402 fp1 = floatx80_add(fp1, float32_to_floatx80(
1403 make_float32(0x3F800000), status),
1404 status); /* 1+S(Q1+S(Q2+S(Q3+SQ4))) */
1405
1406 status->float_rounding_mode = user_rnd_mode;
1407 status->floatx80_rounding_precision = user_rnd_prec;
1408
1409 a = floatx80_div(fp0, fp1, status);
1410
1411 float_raise(float_flag_inexact, status);
1412
1413 return a;
1414 }
1415 }
1416 }
1417
1418 /*
1419 * Sine
1420 */
1421
1422 floatx80 floatx80_sin(floatx80 a, float_status *status)
1423 {
1424 bool aSign, xSign;
1425 int32_t aExp, xExp;
1426 uint64_t aSig, xSig;
1427
1428 FloatRoundMode user_rnd_mode;
1429 FloatX80RoundPrec user_rnd_prec;
1430
1431 int32_t compact, l, n, j;
1432 floatx80 fp0, fp1, fp2, fp3, fp4, fp5, x, invtwopi, twopi1, twopi2;
1433 float32 posneg1, twoto63;
1434 bool endflag;
1435
1436 aSig = extractFloatx80Frac(a);
1437 aExp = extractFloatx80Exp(a);
1438 aSign = extractFloatx80Sign(a);
1439
1440 if (aExp == 0x7FFF) {
1441 if ((uint64_t) (aSig << 1)) {
1442 return propagateFloatx80NaNOneArg(a, status);
1443 }
1444 float_raise(float_flag_invalid, status);
1445 return floatx80_default_nan(status);
1446 }
1447
1448 if (aExp == 0 && aSig == 0) {
1449 return packFloatx80(aSign, 0, 0);
1450 }
1451
1452 user_rnd_mode = status->float_rounding_mode;
1453 user_rnd_prec = status->floatx80_rounding_precision;
1454 status->float_rounding_mode = float_round_nearest_even;
1455 status->floatx80_rounding_precision = floatx80_precision_x;
1456
1457 compact = floatx80_make_compact(aExp, aSig);
1458
1459 fp0 = a;
1460
1461 if (compact < 0x3FD78000 || compact > 0x4004BC7E) {
1462 /* 2^(-40) > |X| > 15 PI */
1463 if (compact > 0x3FFF8000) { /* |X| >= 15 PI */
1464 /* REDUCEX */
1465 fp1 = packFloatx80(0, 0, 0);
1466 if (compact == 0x7FFEFFFF) {
1467 twopi1 = packFloatx80(aSign ^ 1, 0x7FFE,
1468 UINT64_C(0xC90FDAA200000000));
1469 twopi2 = packFloatx80(aSign ^ 1, 0x7FDC,
1470 UINT64_C(0x85A308D300000000));
1471 fp0 = floatx80_add(fp0, twopi1, status);
1472 fp1 = fp0;
1473 fp0 = floatx80_add(fp0, twopi2, status);
1474 fp1 = floatx80_sub(fp1, fp0, status);
1475 fp1 = floatx80_add(fp1, twopi2, status);
1476 }
1477 loop:
1478 xSign = extractFloatx80Sign(fp0);
1479 xExp = extractFloatx80Exp(fp0);
1480 xExp -= 0x3FFF;
1481 if (xExp <= 28) {
1482 l = 0;
1483 endflag = true;
1484 } else {
1485 l = xExp - 27;
1486 endflag = false;
1487 }
1488 invtwopi = packFloatx80(0, 0x3FFE - l,
1489 UINT64_C(0xA2F9836E4E44152A)); /* INVTWOPI */
1490 twopi1 = packFloatx80(0, 0x3FFF + l, UINT64_C(0xC90FDAA200000000));
1491 twopi2 = packFloatx80(0, 0x3FDD + l, UINT64_C(0x85A308D300000000));
1492
1493 /* SIGN(INARG)*2^63 IN SGL */
1494 twoto63 = packFloat32(xSign, 0xBE, 0);
1495
1496 fp2 = floatx80_mul(fp0, invtwopi, status);
1497 fp2 = floatx80_add(fp2, float32_to_floatx80(twoto63, status),
1498 status); /* THE FRACT PART OF FP2 IS ROUNDED */
1499 fp2 = floatx80_sub(fp2, float32_to_floatx80(twoto63, status),
1500 status); /* FP2 is N */
1501 fp4 = floatx80_mul(twopi1, fp2, status); /* W = N*P1 */
1502 fp5 = floatx80_mul(twopi2, fp2, status); /* w = N*P2 */
1503 fp3 = floatx80_add(fp4, fp5, status); /* FP3 is P */
1504 fp4 = floatx80_sub(fp4, fp3, status); /* W-P */
1505 fp0 = floatx80_sub(fp0, fp3, status); /* FP0 is A := R - P */
1506 fp4 = floatx80_add(fp4, fp5, status); /* FP4 is p = (W-P)+w */
1507 fp3 = fp0; /* FP3 is A */
1508 fp1 = floatx80_sub(fp1, fp4, status); /* FP1 is a := r - p */
1509 fp0 = floatx80_add(fp0, fp1, status); /* FP0 is R := A+a */
1510
1511 if (endflag) {
1512 n = floatx80_to_int32(fp2, status);
1513 goto sincont;
1514 }
1515 fp3 = floatx80_sub(fp3, fp0, status); /* A-R */
1516 fp1 = floatx80_add(fp1, fp3, status); /* FP1 is r := (A-R)+a */
1517 goto loop;
1518 } else {
1519 /* SINSM */
1520 fp0 = float32_to_floatx80(make_float32(0x3F800000),
1521 status); /* 1 */
1522
1523 status->float_rounding_mode = user_rnd_mode;
1524 status->floatx80_rounding_precision = user_rnd_prec;
1525
1526 /* SINTINY */
1527 a = floatx80_move(a, status);
1528 float_raise(float_flag_inexact, status);
1529
1530 return a;
1531 }
1532 } else {
1533 fp1 = floatx80_mul(fp0, float64_to_floatx80(
1534 make_float64(0x3FE45F306DC9C883), status),
1535 status); /* X*2/PI */
1536
1537 n = floatx80_to_int32(fp1, status);
1538 j = 32 + n;
1539
1540 fp0 = floatx80_sub(fp0, pi_tbl[j], status); /* X-Y1 */
1541 fp0 = floatx80_sub(fp0, float32_to_floatx80(pi_tbl2[j], status),
1542 status); /* FP0 IS R = (X-Y1)-Y2 */
1543
1544 sincont:
1545 if (n & 1) {
1546 /* COSPOLY */
1547 fp0 = floatx80_mul(fp0, fp0, status); /* FP0 IS S */
1548 fp1 = floatx80_mul(fp0, fp0, status); /* FP1 IS T */
1549 fp2 = float64_to_floatx80(make_float64(0x3D2AC4D0D6011EE3),
1550 status); /* B8 */
1551 fp3 = float64_to_floatx80(make_float64(0xBDA9396F9F45AC19),
1552 status); /* B7 */
1553
1554 xSign = extractFloatx80Sign(fp0); /* X IS S */
1555 xExp = extractFloatx80Exp(fp0);
1556 xSig = extractFloatx80Frac(fp0);
1557
1558 if ((n >> 1) & 1) {
1559 xSign ^= 1;
1560 posneg1 = make_float32(0xBF800000); /* -1 */
1561 } else {
1562 xSign ^= 0;
1563 posneg1 = make_float32(0x3F800000); /* 1 */
1564 } /* X IS NOW R'= SGN*R */
1565
1566 fp2 = floatx80_mul(fp2, fp1, status); /* TB8 */
1567 fp3 = floatx80_mul(fp3, fp1, status); /* TB7 */
1568 fp2 = floatx80_add(fp2, float64_to_floatx80(
1569 make_float64(0x3E21EED90612C972), status),
1570 status); /* B6+TB8 */
1571 fp3 = floatx80_add(fp3, float64_to_floatx80(
1572 make_float64(0xBE927E4FB79D9FCF), status),
1573 status); /* B5+TB7 */
1574 fp2 = floatx80_mul(fp2, fp1, status); /* T(B6+TB8) */
1575 fp3 = floatx80_mul(fp3, fp1, status); /* T(B5+TB7) */
1576 fp2 = floatx80_add(fp2, float64_to_floatx80(
1577 make_float64(0x3EFA01A01A01D423), status),
1578 status); /* B4+T(B6+TB8) */
1579 fp4 = packFloatx80(1, 0x3FF5, UINT64_C(0xB60B60B60B61D438));
1580 fp3 = floatx80_add(fp3, fp4, status); /* B3+T(B5+TB7) */
1581 fp2 = floatx80_mul(fp2, fp1, status); /* T(B4+T(B6+TB8)) */
1582 fp1 = floatx80_mul(fp1, fp3, status); /* T(B3+T(B5+TB7)) */
1583 fp4 = packFloatx80(0, 0x3FFA, UINT64_C(0xAAAAAAAAAAAAAB5E));
1584 fp2 = floatx80_add(fp2, fp4, status); /* B2+T(B4+T(B6+TB8)) */
1585 fp1 = floatx80_add(fp1, float32_to_floatx80(
1586 make_float32(0xBF000000), status),
1587 status); /* B1+T(B3+T(B5+TB7)) */
1588 fp0 = floatx80_mul(fp0, fp2, status); /* S(B2+T(B4+T(B6+TB8))) */
1589 fp0 = floatx80_add(fp0, fp1, status); /* [B1+T(B3+T(B5+TB7))]+
1590 * [S(B2+T(B4+T(B6+TB8)))]
1591 */
1592
1593 x = packFloatx80(xSign, xExp, xSig);
1594 fp0 = floatx80_mul(fp0, x, status);
1595
1596 status->float_rounding_mode = user_rnd_mode;
1597 status->floatx80_rounding_precision = user_rnd_prec;
1598
1599 a = floatx80_add(fp0, float32_to_floatx80(posneg1, status), status);
1600
1601 float_raise(float_flag_inexact, status);
1602
1603 return a;
1604 } else {
1605 /* SINPOLY */
1606 xSign = extractFloatx80Sign(fp0); /* X IS R */
1607 xExp = extractFloatx80Exp(fp0);
1608 xSig = extractFloatx80Frac(fp0);
1609
1610 xSign ^= (n >> 1) & 1; /* X IS NOW R'= SGN*R */
1611
1612 fp0 = floatx80_mul(fp0, fp0, status); /* FP0 IS S */
1613 fp1 = floatx80_mul(fp0, fp0, status); /* FP1 IS T */
1614 fp3 = float64_to_floatx80(make_float64(0xBD6AAA77CCC994F5),
1615 status); /* A7 */
1616 fp2 = float64_to_floatx80(make_float64(0x3DE612097AAE8DA1),
1617 status); /* A6 */
1618 fp3 = floatx80_mul(fp3, fp1, status); /* T*A7 */
1619 fp2 = floatx80_mul(fp2, fp1, status); /* T*A6 */
1620 fp3 = floatx80_add(fp3, float64_to_floatx80(
1621 make_float64(0xBE5AE6452A118AE4), status),
1622 status); /* A5+T*A7 */
1623 fp2 = floatx80_add(fp2, float64_to_floatx80(
1624 make_float64(0x3EC71DE3A5341531), status),
1625 status); /* A4+T*A6 */
1626 fp3 = floatx80_mul(fp3, fp1, status); /* T(A5+TA7) */
1627 fp2 = floatx80_mul(fp2, fp1, status); /* T(A4+TA6) */
1628 fp3 = floatx80_add(fp3, float64_to_floatx80(
1629 make_float64(0xBF2A01A01A018B59), status),
1630 status); /* A3+T(A5+TA7) */
1631 fp4 = packFloatx80(0, 0x3FF8, UINT64_C(0x88888888888859AF));
1632 fp2 = floatx80_add(fp2, fp4, status); /* A2+T(A4+TA6) */
1633 fp1 = floatx80_mul(fp1, fp3, status); /* T(A3+T(A5+TA7)) */
1634 fp2 = floatx80_mul(fp2, fp0, status); /* S(A2+T(A4+TA6)) */
1635 fp4 = packFloatx80(1, 0x3FFC, UINT64_C(0xAAAAAAAAAAAAAA99));
1636 fp1 = floatx80_add(fp1, fp4, status); /* A1+T(A3+T(A5+TA7)) */
1637 fp1 = floatx80_add(fp1, fp2,
1638 status); /* [A1+T(A3+T(A5+TA7))]+
1639 * [S(A2+T(A4+TA6))]
1640 */
1641
1642 x = packFloatx80(xSign, xExp, xSig);
1643 fp0 = floatx80_mul(fp0, x, status); /* R'*S */
1644 fp0 = floatx80_mul(fp0, fp1, status); /* SIN(R')-R' */
1645
1646 status->float_rounding_mode = user_rnd_mode;
1647 status->floatx80_rounding_precision = user_rnd_prec;
1648
1649 a = floatx80_add(fp0, x, status);
1650
1651 float_raise(float_flag_inexact, status);
1652
1653 return a;
1654 }
1655 }
1656 }
1657
1658 /*
1659 * Cosine
1660 */
1661
1662 floatx80 floatx80_cos(floatx80 a, float_status *status)
1663 {
1664 bool aSign, xSign;
1665 int32_t aExp, xExp;
1666 uint64_t aSig, xSig;
1667
1668 FloatRoundMode user_rnd_mode;
1669 FloatX80RoundPrec user_rnd_prec;
1670
1671 int32_t compact, l, n, j;
1672 floatx80 fp0, fp1, fp2, fp3, fp4, fp5, x, invtwopi, twopi1, twopi2;
1673 float32 posneg1, twoto63;
1674 bool endflag;
1675
1676 aSig = extractFloatx80Frac(a);
1677 aExp = extractFloatx80Exp(a);
1678 aSign = extractFloatx80Sign(a);
1679
1680 if (aExp == 0x7FFF) {
1681 if ((uint64_t) (aSig << 1)) {
1682 return propagateFloatx80NaNOneArg(a, status);
1683 }
1684 float_raise(float_flag_invalid, status);
1685 return floatx80_default_nan(status);
1686 }
1687
1688 if (aExp == 0 && aSig == 0) {
1689 return packFloatx80(0, one_exp, one_sig);
1690 }
1691
1692 user_rnd_mode = status->float_rounding_mode;
1693 user_rnd_prec = status->floatx80_rounding_precision;
1694 status->float_rounding_mode = float_round_nearest_even;
1695 status->floatx80_rounding_precision = floatx80_precision_x;
1696
1697 compact = floatx80_make_compact(aExp, aSig);
1698
1699 fp0 = a;
1700
1701 if (compact < 0x3FD78000 || compact > 0x4004BC7E) {
1702 /* 2^(-40) > |X| > 15 PI */
1703 if (compact > 0x3FFF8000) { /* |X| >= 15 PI */
1704 /* REDUCEX */
1705 fp1 = packFloatx80(0, 0, 0);
1706 if (compact == 0x7FFEFFFF) {
1707 twopi1 = packFloatx80(aSign ^ 1, 0x7FFE,
1708 UINT64_C(0xC90FDAA200000000));
1709 twopi2 = packFloatx80(aSign ^ 1, 0x7FDC,
1710 UINT64_C(0x85A308D300000000));
1711 fp0 = floatx80_add(fp0, twopi1, status);
1712 fp1 = fp0;
1713 fp0 = floatx80_add(fp0, twopi2, status);
1714 fp1 = floatx80_sub(fp1, fp0, status);
1715 fp1 = floatx80_add(fp1, twopi2, status);
1716 }
1717 loop:
1718 xSign = extractFloatx80Sign(fp0);
1719 xExp = extractFloatx80Exp(fp0);
1720 xExp -= 0x3FFF;
1721 if (xExp <= 28) {
1722 l = 0;
1723 endflag = true;
1724 } else {
1725 l = xExp - 27;
1726 endflag = false;
1727 }
1728 invtwopi = packFloatx80(0, 0x3FFE - l,
1729 UINT64_C(0xA2F9836E4E44152A)); /* INVTWOPI */
1730 twopi1 = packFloatx80(0, 0x3FFF + l, UINT64_C(0xC90FDAA200000000));
1731 twopi2 = packFloatx80(0, 0x3FDD + l, UINT64_C(0x85A308D300000000));
1732
1733 /* SIGN(INARG)*2^63 IN SGL */
1734 twoto63 = packFloat32(xSign, 0xBE, 0);
1735
1736 fp2 = floatx80_mul(fp0, invtwopi, status);
1737 fp2 = floatx80_add(fp2, float32_to_floatx80(twoto63, status),
1738 status); /* THE FRACT PART OF FP2 IS ROUNDED */
1739 fp2 = floatx80_sub(fp2, float32_to_floatx80(twoto63, status),
1740 status); /* FP2 is N */
1741 fp4 = floatx80_mul(twopi1, fp2, status); /* W = N*P1 */
1742 fp5 = floatx80_mul(twopi2, fp2, status); /* w = N*P2 */
1743 fp3 = floatx80_add(fp4, fp5, status); /* FP3 is P */
1744 fp4 = floatx80_sub(fp4, fp3, status); /* W-P */
1745 fp0 = floatx80_sub(fp0, fp3, status); /* FP0 is A := R - P */
1746 fp4 = floatx80_add(fp4, fp5, status); /* FP4 is p = (W-P)+w */
1747 fp3 = fp0; /* FP3 is A */
1748 fp1 = floatx80_sub(fp1, fp4, status); /* FP1 is a := r - p */
1749 fp0 = floatx80_add(fp0, fp1, status); /* FP0 is R := A+a */
1750
1751 if (endflag) {
1752 n = floatx80_to_int32(fp2, status);
1753 goto sincont;
1754 }
1755 fp3 = floatx80_sub(fp3, fp0, status); /* A-R */
1756 fp1 = floatx80_add(fp1, fp3, status); /* FP1 is r := (A-R)+a */
1757 goto loop;
1758 } else {
1759 /* SINSM */
1760 fp0 = float32_to_floatx80(make_float32(0x3F800000), status); /* 1 */
1761
1762 status->float_rounding_mode = user_rnd_mode;
1763 status->floatx80_rounding_precision = user_rnd_prec;
1764
1765 /* COSTINY */
1766 a = floatx80_sub(fp0, float32_to_floatx80(
1767 make_float32(0x00800000), status),
1768 status);
1769 float_raise(float_flag_inexact, status);
1770
1771 return a;
1772 }
1773 } else {
1774 fp1 = floatx80_mul(fp0, float64_to_floatx80(
1775 make_float64(0x3FE45F306DC9C883), status),
1776 status); /* X*2/PI */
1777
1778 n = floatx80_to_int32(fp1, status);
1779 j = 32 + n;
1780
1781 fp0 = floatx80_sub(fp0, pi_tbl[j], status); /* X-Y1 */
1782 fp0 = floatx80_sub(fp0, float32_to_floatx80(pi_tbl2[j], status),
1783 status); /* FP0 IS R = (X-Y1)-Y2 */
1784
1785 sincont:
1786 if ((n + 1) & 1) {
1787 /* COSPOLY */
1788 fp0 = floatx80_mul(fp0, fp0, status); /* FP0 IS S */
1789 fp1 = floatx80_mul(fp0, fp0, status); /* FP1 IS T */
1790 fp2 = float64_to_floatx80(make_float64(0x3D2AC4D0D6011EE3),
1791 status); /* B8 */
1792 fp3 = float64_to_floatx80(make_float64(0xBDA9396F9F45AC19),
1793 status); /* B7 */
1794
1795 xSign = extractFloatx80Sign(fp0); /* X IS S */
1796 xExp = extractFloatx80Exp(fp0);
1797 xSig = extractFloatx80Frac(fp0);
1798
1799 if (((n + 1) >> 1) & 1) {
1800 xSign ^= 1;
1801 posneg1 = make_float32(0xBF800000); /* -1 */
1802 } else {
1803 xSign ^= 0;
1804 posneg1 = make_float32(0x3F800000); /* 1 */
1805 } /* X IS NOW R'= SGN*R */
1806
1807 fp2 = floatx80_mul(fp2, fp1, status); /* TB8 */
1808 fp3 = floatx80_mul(fp3, fp1, status); /* TB7 */
1809 fp2 = floatx80_add(fp2, float64_to_floatx80(
1810 make_float64(0x3E21EED90612C972), status),
1811 status); /* B6+TB8 */
1812 fp3 = floatx80_add(fp3, float64_to_floatx80(
1813 make_float64(0xBE927E4FB79D9FCF), status),
1814 status); /* B5+TB7 */
1815 fp2 = floatx80_mul(fp2, fp1, status); /* T(B6+TB8) */
1816 fp3 = floatx80_mul(fp3, fp1, status); /* T(B5+TB7) */
1817 fp2 = floatx80_add(fp2, float64_to_floatx80(
1818 make_float64(0x3EFA01A01A01D423), status),
1819 status); /* B4+T(B6+TB8) */
1820 fp4 = packFloatx80(1, 0x3FF5, UINT64_C(0xB60B60B60B61D438));
1821 fp3 = floatx80_add(fp3, fp4, status); /* B3+T(B5+TB7) */
1822 fp2 = floatx80_mul(fp2, fp1, status); /* T(B4+T(B6+TB8)) */
1823 fp1 = floatx80_mul(fp1, fp3, status); /* T(B3+T(B5+TB7)) */
1824 fp4 = packFloatx80(0, 0x3FFA, UINT64_C(0xAAAAAAAAAAAAAB5E));
1825 fp2 = floatx80_add(fp2, fp4, status); /* B2+T(B4+T(B6+TB8)) */
1826 fp1 = floatx80_add(fp1, float32_to_floatx80(
1827 make_float32(0xBF000000), status),
1828 status); /* B1+T(B3+T(B5+TB7)) */
1829 fp0 = floatx80_mul(fp0, fp2, status); /* S(B2+T(B4+T(B6+TB8))) */
1830 fp0 = floatx80_add(fp0, fp1, status);
1831 /* [B1+T(B3+T(B5+TB7))]+[S(B2+T(B4+T(B6+TB8)))] */
1832
1833 x = packFloatx80(xSign, xExp, xSig);
1834 fp0 = floatx80_mul(fp0, x, status);
1835
1836 status->float_rounding_mode = user_rnd_mode;
1837 status->floatx80_rounding_precision = user_rnd_prec;
1838
1839 a = floatx80_add(fp0, float32_to_floatx80(posneg1, status), status);
1840
1841 float_raise(float_flag_inexact, status);
1842
1843 return a;
1844 } else {
1845 /* SINPOLY */
1846 xSign = extractFloatx80Sign(fp0); /* X IS R */
1847 xExp = extractFloatx80Exp(fp0);
1848 xSig = extractFloatx80Frac(fp0);
1849
1850 xSign ^= ((n + 1) >> 1) & 1; /* X IS NOW R'= SGN*R */
1851
1852 fp0 = floatx80_mul(fp0, fp0, status); /* FP0 IS S */
1853 fp1 = floatx80_mul(fp0, fp0, status); /* FP1 IS T */
1854 fp3 = float64_to_floatx80(make_float64(0xBD6AAA77CCC994F5),
1855 status); /* A7 */
1856 fp2 = float64_to_floatx80(make_float64(0x3DE612097AAE8DA1),
1857 status); /* A6 */
1858 fp3 = floatx80_mul(fp3, fp1, status); /* T*A7 */
1859 fp2 = floatx80_mul(fp2, fp1, status); /* T*A6 */
1860 fp3 = floatx80_add(fp3, float64_to_floatx80(
1861 make_float64(0xBE5AE6452A118AE4), status),
1862 status); /* A5+T*A7 */
1863 fp2 = floatx80_add(fp2, float64_to_floatx80(
1864 make_float64(0x3EC71DE3A5341531), status),
1865 status); /* A4+T*A6 */
1866 fp3 = floatx80_mul(fp3, fp1, status); /* T(A5+TA7) */
1867 fp2 = floatx80_mul(fp2, fp1, status); /* T(A4+TA6) */
1868 fp3 = floatx80_add(fp3, float64_to_floatx80(
1869 make_float64(0xBF2A01A01A018B59), status),
1870 status); /* A3+T(A5+TA7) */
1871 fp4 = packFloatx80(0, 0x3FF8, UINT64_C(0x88888888888859AF));
1872 fp2 = floatx80_add(fp2, fp4, status); /* A2+T(A4+TA6) */
1873 fp1 = floatx80_mul(fp1, fp3, status); /* T(A3+T(A5+TA7)) */
1874 fp2 = floatx80_mul(fp2, fp0, status); /* S(A2+T(A4+TA6)) */
1875 fp4 = packFloatx80(1, 0x3FFC, UINT64_C(0xAAAAAAAAAAAAAA99));
1876 fp1 = floatx80_add(fp1, fp4, status); /* A1+T(A3+T(A5+TA7)) */
1877 fp1 = floatx80_add(fp1, fp2, status);
1878 /* [A1+T(A3+T(A5+TA7))]+[S(A2+T(A4+TA6))] */
1879
1880 x = packFloatx80(xSign, xExp, xSig);
1881 fp0 = floatx80_mul(fp0, x, status); /* R'*S */
1882 fp0 = floatx80_mul(fp0, fp1, status); /* SIN(R')-R' */
1883
1884 status->float_rounding_mode = user_rnd_mode;
1885 status->floatx80_rounding_precision = user_rnd_prec;
1886
1887 a = floatx80_add(fp0, x, status);
1888
1889 float_raise(float_flag_inexact, status);
1890
1891 return a;
1892 }
1893 }
1894 }
1895
1896 /*
1897 * Arc tangent
1898 */
1899
1900 floatx80 floatx80_atan(floatx80 a, float_status *status)
1901 {
1902 bool aSign;
1903 int32_t aExp;
1904 uint64_t aSig;
1905
1906 FloatRoundMode user_rnd_mode;
1907 FloatX80RoundPrec user_rnd_prec;
1908
1909 int32_t compact, tbl_index;
1910 floatx80 fp0, fp1, fp2, fp3, xsave;
1911
1912 aSig = extractFloatx80Frac(a);
1913 aExp = extractFloatx80Exp(a);
1914 aSign = extractFloatx80Sign(a);
1915
1916 if (aExp == 0x7FFF) {
1917 if ((uint64_t) (aSig << 1)) {
1918 return propagateFloatx80NaNOneArg(a, status);
1919 }
1920 a = packFloatx80(aSign, piby2_exp, pi_sig);
1921 float_raise(float_flag_inexact, status);
1922 return floatx80_move(a, status);
1923 }
1924
1925 if (aExp == 0 && aSig == 0) {
1926 return packFloatx80(aSign, 0, 0);
1927 }
1928
1929 compact = floatx80_make_compact(aExp, aSig);
1930
1931 user_rnd_mode = status->float_rounding_mode;
1932 user_rnd_prec = status->floatx80_rounding_precision;
1933 status->float_rounding_mode = float_round_nearest_even;
1934 status->floatx80_rounding_precision = floatx80_precision_x;
1935
1936 if (compact < 0x3FFB8000 || compact > 0x4002FFFF) {
1937 /* |X| >= 16 or |X| < 1/16 */
1938 if (compact > 0x3FFF8000) { /* |X| >= 16 */
1939 if (compact > 0x40638000) { /* |X| > 2^(100) */
1940 fp0 = packFloatx80(aSign, piby2_exp, pi_sig);
1941 fp1 = packFloatx80(aSign, 0x0001, one_sig);
1942
1943 status->float_rounding_mode = user_rnd_mode;
1944 status->floatx80_rounding_precision = user_rnd_prec;
1945
1946 a = floatx80_sub(fp0, fp1, status);
1947
1948 float_raise(float_flag_inexact, status);
1949
1950 return a;
1951 } else {
1952 fp0 = a;
1953 fp1 = packFloatx80(1, one_exp, one_sig); /* -1 */
1954 fp1 = floatx80_div(fp1, fp0, status); /* X' = -1/X */
1955 xsave = fp1;
1956 fp0 = floatx80_mul(fp1, fp1, status); /* Y = X'*X' */
1957 fp1 = floatx80_mul(fp0, fp0, status); /* Z = Y*Y */
1958 fp3 = float64_to_floatx80(make_float64(0xBFB70BF398539E6A),
1959 status); /* C5 */
1960 fp2 = float64_to_floatx80(make_float64(0x3FBC7187962D1D7D),
1961 status); /* C4 */
1962 fp3 = floatx80_mul(fp3, fp1, status); /* Z*C5 */
1963 fp2 = floatx80_mul(fp2, fp1, status); /* Z*C4 */
1964 fp3 = floatx80_add(fp3, float64_to_floatx80(
1965 make_float64(0xBFC24924827107B8), status),
1966 status); /* C3+Z*C5 */
1967 fp2 = floatx80_add(fp2, float64_to_floatx80(
1968 make_float64(0x3FC999999996263E), status),
1969 status); /* C2+Z*C4 */
1970 fp1 = floatx80_mul(fp1, fp3, status); /* Z*(C3+Z*C5) */
1971 fp2 = floatx80_mul(fp2, fp0, status); /* Y*(C2+Z*C4) */
1972 fp1 = floatx80_add(fp1, float64_to_floatx80(
1973 make_float64(0xBFD5555555555536), status),
1974 status); /* C1+Z*(C3+Z*C5) */
1975 fp0 = floatx80_mul(fp0, xsave, status); /* X'*Y */
1976 /* [Y*(C2+Z*C4)]+[C1+Z*(C3+Z*C5)] */
1977 fp1 = floatx80_add(fp1, fp2, status);
1978 /* X'*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]) ?? */
1979 fp0 = floatx80_mul(fp0, fp1, status);
1980 fp0 = floatx80_add(fp0, xsave, status);
1981 fp1 = packFloatx80(aSign, piby2_exp, pi_sig);
1982
1983 status->float_rounding_mode = user_rnd_mode;
1984 status->floatx80_rounding_precision = user_rnd_prec;
1985
1986 a = floatx80_add(fp0, fp1, status);
1987
1988 float_raise(float_flag_inexact, status);
1989
1990 return a;
1991 }
1992 } else { /* |X| < 1/16 */
1993 if (compact < 0x3FD78000) { /* |X| < 2^(-40) */
1994 status->float_rounding_mode = user_rnd_mode;
1995 status->floatx80_rounding_precision = user_rnd_prec;
1996
1997 a = floatx80_move(a, status);
1998
1999 float_raise(float_flag_inexact, status);
2000
2001 return a;
2002 } else {
2003 fp0 = a;
2004 xsave = a;
2005 fp0 = floatx80_mul(fp0, fp0, status); /* Y = X*X */
2006 fp1 = floatx80_mul(fp0, fp0, status); /* Z = Y*Y */
2007 fp2 = float64_to_floatx80(make_float64(0x3FB344447F876989),
2008 status); /* B6 */
2009 fp3 = float64_to_floatx80(make_float64(0xBFB744EE7FAF45DB),
2010 status); /* B5 */
2011 fp2 = floatx80_mul(fp2, fp1, status); /* Z*B6 */
2012 fp3 = floatx80_mul(fp3, fp1, status); /* Z*B5 */
2013 fp2 = floatx80_add(fp2, float64_to_floatx80(
2014 make_float64(0x3FBC71C646940220), status),
2015 status); /* B4+Z*B6 */
2016 fp3 = floatx80_add(fp3, float64_to_floatx80(
2017 make_float64(0xBFC24924921872F9),
2018 status), status); /* B3+Z*B5 */
2019 fp2 = floatx80_mul(fp2, fp1, status); /* Z*(B4+Z*B6) */
2020 fp1 = floatx80_mul(fp1, fp3, status); /* Z*(B3+Z*B5) */
2021 fp2 = floatx80_add(fp2, float64_to_floatx80(
2022 make_float64(0x3FC9999999998FA9), status),
2023 status); /* B2+Z*(B4+Z*B6) */
2024 fp1 = floatx80_add(fp1, float64_to_floatx80(
2025 make_float64(0xBFD5555555555555), status),
2026 status); /* B1+Z*(B3+Z*B5) */
2027 fp2 = floatx80_mul(fp2, fp0, status); /* Y*(B2+Z*(B4+Z*B6)) */
2028 fp0 = floatx80_mul(fp0, xsave, status); /* X*Y */
2029 /* [B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))] */
2030 fp1 = floatx80_add(fp1, fp2, status);
2031 /* X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]) */
2032 fp0 = floatx80_mul(fp0, fp1, status);
2033
2034 status->float_rounding_mode = user_rnd_mode;
2035 status->floatx80_rounding_precision = user_rnd_prec;
2036
2037 a = floatx80_add(fp0, xsave, status);
2038
2039 float_raise(float_flag_inexact, status);
2040
2041 return a;
2042 }
2043 }
2044 } else {
2045 aSig &= UINT64_C(0xF800000000000000);
2046 aSig |= UINT64_C(0x0400000000000000);
2047 xsave = packFloatx80(aSign, aExp, aSig); /* F */
2048 fp0 = a;
2049 fp1 = a; /* X */
2050 fp2 = packFloatx80(0, one_exp, one_sig); /* 1 */
2051 fp1 = floatx80_mul(fp1, xsave, status); /* X*F */
2052 fp0 = floatx80_sub(fp0, xsave, status); /* X-F */
2053 fp1 = floatx80_add(fp1, fp2, status); /* 1 + X*F */
2054 fp0 = floatx80_div(fp0, fp1, status); /* U = (X-F)/(1+X*F) */
2055
2056 tbl_index = compact;
2057
2058 tbl_index &= 0x7FFF0000;
2059 tbl_index -= 0x3FFB0000;
2060 tbl_index >>= 1;
2061 tbl_index += compact & 0x00007800;
2062 tbl_index >>= 11;
2063
2064 fp3 = atan_tbl[tbl_index];
2065
2066 fp3.high |= aSign ? 0x8000 : 0; /* ATAN(F) */
2067
2068 fp1 = floatx80_mul(fp0, fp0, status); /* V = U*U */
2069 fp2 = float64_to_floatx80(make_float64(0xBFF6687E314987D8),
2070 status); /* A3 */
2071 fp2 = floatx80_add(fp2, fp1, status); /* A3+V */
2072 fp2 = floatx80_mul(fp2, fp1, status); /* V*(A3+V) */
2073 fp1 = floatx80_mul(fp1, fp0, status); /* U*V */
2074 fp2 = floatx80_add(fp2, float64_to_floatx80(
2075 make_float64(0x4002AC6934A26DB3), status),
2076 status); /* A2+V*(A3+V) */
2077 fp1 = floatx80_mul(fp1, float64_to_floatx80(
2078 make_float64(0xBFC2476F4E1DA28E), status),
2079 status); /* A1+U*V */
2080 fp1 = floatx80_mul(fp1, fp2, status); /* A1*U*V*(A2+V*(A3+V)) */
2081 fp0 = floatx80_add(fp0, fp1, status); /* ATAN(U) */
2082
2083 status->float_rounding_mode = user_rnd_mode;
2084 status->floatx80_rounding_precision = user_rnd_prec;
2085
2086 a = floatx80_add(fp0, fp3, status); /* ATAN(X) */
2087
2088 float_raise(float_flag_inexact, status);
2089
2090 return a;
2091 }
2092 }
2093
2094 /*
2095 * Arc sine
2096 */
2097
2098 floatx80 floatx80_asin(floatx80 a, float_status *status)
2099 {
2100 bool aSign;
2101 int32_t aExp;
2102 uint64_t aSig;
2103
2104 FloatRoundMode user_rnd_mode;
2105 FloatX80RoundPrec user_rnd_prec;
2106
2107 int32_t compact;
2108 floatx80 fp0, fp1, fp2, one;
2109
2110 aSig = extractFloatx80Frac(a);
2111 aExp = extractFloatx80Exp(a);
2112 aSign = extractFloatx80Sign(a);
2113
2114 if (aExp == 0x7FFF && (uint64_t) (aSig << 1)) {
2115 return propagateFloatx80NaNOneArg(a, status);
2116 }
2117
2118 if (aExp == 0 && aSig == 0) {
2119 return packFloatx80(aSign, 0, 0);
2120 }
2121
2122 compact = floatx80_make_compact(aExp, aSig);
2123
2124 if (compact >= 0x3FFF8000) { /* |X| >= 1 */
2125 if (aExp == one_exp && aSig == one_sig) { /* |X| == 1 */
2126 float_raise(float_flag_inexact, status);
2127 a = packFloatx80(aSign, piby2_exp, pi_sig);
2128 return floatx80_move(a, status);
2129 } else { /* |X| > 1 */
2130 float_raise(float_flag_invalid, status);
2131 return floatx80_default_nan(status);
2132 }
2133
2134 } /* |X| < 1 */
2135
2136 user_rnd_mode = status->float_rounding_mode;
2137 user_rnd_prec = status->floatx80_rounding_precision;
2138 status->float_rounding_mode = float_round_nearest_even;
2139 status->floatx80_rounding_precision = floatx80_precision_x;
2140
2141 one = packFloatx80(0, one_exp, one_sig);
2142 fp0 = a;
2143
2144 fp1 = floatx80_sub(one, fp0, status); /* 1 - X */
2145 fp2 = floatx80_add(one, fp0, status); /* 1 + X */
2146 fp1 = floatx80_mul(fp2, fp1, status); /* (1+X)*(1-X) */
2147 fp1 = floatx80_sqrt(fp1, status); /* SQRT((1+X)*(1-X)) */
2148 fp0 = floatx80_div(fp0, fp1, status); /* X/SQRT((1+X)*(1-X)) */
2149
2150 status->float_rounding_mode = user_rnd_mode;
2151 status->floatx80_rounding_precision = user_rnd_prec;
2152
2153 a = floatx80_atan(fp0, status); /* ATAN(X/SQRT((1+X)*(1-X))) */
2154
2155 float_raise(float_flag_inexact, status);
2156
2157 return a;
2158 }
2159
2160 /*
2161 * Arc cosine
2162 */
2163
2164 floatx80 floatx80_acos(floatx80 a, float_status *status)
2165 {
2166 bool aSign;
2167 int32_t aExp;
2168 uint64_t aSig;
2169
2170 FloatRoundMode user_rnd_mode;
2171 FloatX80RoundPrec user_rnd_prec;
2172
2173 int32_t compact;
2174 floatx80 fp0, fp1, one;
2175
2176 aSig = extractFloatx80Frac(a);
2177 aExp = extractFloatx80Exp(a);
2178 aSign = extractFloatx80Sign(a);
2179
2180 if (aExp == 0x7FFF && (uint64_t) (aSig << 1)) {
2181 return propagateFloatx80NaNOneArg(a, status);
2182 }
2183 if (aExp == 0 && aSig == 0) {
2184 float_raise(float_flag_inexact, status);
2185 return roundAndPackFloatx80(status->floatx80_rounding_precision, 0,
2186 piby2_exp, pi_sig, 0, status);
2187 }
2188
2189 compact = floatx80_make_compact(aExp, aSig);
2190
2191 if (compact >= 0x3FFF8000) { /* |X| >= 1 */
2192 if (aExp == one_exp && aSig == one_sig) { /* |X| == 1 */
2193 if (aSign) { /* X == -1 */
2194 a = packFloatx80(0, pi_exp, pi_sig);
2195 float_raise(float_flag_inexact, status);
2196 return floatx80_move(a, status);
2197 } else { /* X == +1 */
2198 return packFloatx80(0, 0, 0);
2199 }
2200 } else { /* |X| > 1 */
2201 float_raise(float_flag_invalid, status);
2202 return floatx80_default_nan(status);
2203 }
2204 } /* |X| < 1 */
2205
2206 user_rnd_mode = status->float_rounding_mode;
2207 user_rnd_prec = status->floatx80_rounding_precision;
2208 status->float_rounding_mode = float_round_nearest_even;
2209 status->floatx80_rounding_precision = floatx80_precision_x;
2210
2211 one = packFloatx80(0, one_exp, one_sig);
2212 fp0 = a;
2213
2214 fp1 = floatx80_add(one, fp0, status); /* 1 + X */
2215 fp0 = floatx80_sub(one, fp0, status); /* 1 - X */
2216 fp0 = floatx80_div(fp0, fp1, status); /* (1-X)/(1+X) */
2217 fp0 = floatx80_sqrt(fp0, status); /* SQRT((1-X)/(1+X)) */
2218 fp0 = floatx80_atan(fp0, status); /* ATAN(SQRT((1-X)/(1+X))) */
2219
2220 status->float_rounding_mode = user_rnd_mode;
2221 status->floatx80_rounding_precision = user_rnd_prec;
2222
2223 a = floatx80_add(fp0, fp0, status); /* 2 * ATAN(SQRT((1-X)/(1+X))) */
2224
2225 float_raise(float_flag_inexact, status);
2226
2227 return a;
2228 }
2229
2230 /*
2231 * Hyperbolic arc tangent
2232 */
2233
2234 floatx80 floatx80_atanh(floatx80 a, float_status *status)
2235 {
2236 bool aSign;
2237 int32_t aExp;
2238 uint64_t aSig;
2239
2240 FloatRoundMode user_rnd_mode;
2241 FloatX80RoundPrec user_rnd_prec;
2242
2243 int32_t compact;
2244 floatx80 fp0, fp1, fp2, one;
2245
2246 aSig = extractFloatx80Frac(a);
2247 aExp = extractFloatx80Exp(a);
2248 aSign = extractFloatx80Sign(a);
2249
2250 if (aExp == 0x7FFF && (uint64_t) (aSig << 1)) {
2251 return propagateFloatx80NaNOneArg(a, status);
2252 }
2253
2254 if (aExp == 0 && aSig == 0) {
2255 return packFloatx80(aSign, 0, 0);
2256 }
2257
2258 compact = floatx80_make_compact(aExp, aSig);
2259
2260 if (compact >= 0x3FFF8000) { /* |X| >= 1 */
2261 if (aExp == one_exp && aSig == one_sig) { /* |X| == 1 */
2262 float_raise(float_flag_divbyzero, status);
2263 return packFloatx80(aSign, floatx80_infinity.high,
2264 floatx80_infinity.low);
2265 } else { /* |X| > 1 */
2266 float_raise(float_flag_invalid, status);
2267 return floatx80_default_nan(status);
2268 }
2269 } /* |X| < 1 */
2270
2271 user_rnd_mode = status->float_rounding_mode;
2272 user_rnd_prec = status->floatx80_rounding_precision;
2273 status->float_rounding_mode = float_round_nearest_even;
2274 status->floatx80_rounding_precision = floatx80_precision_x;
2275
2276 one = packFloatx80(0, one_exp, one_sig);
2277 fp2 = packFloatx80(aSign, 0x3FFE, one_sig); /* SIGN(X) * (1/2) */
2278 fp0 = packFloatx80(0, aExp, aSig); /* Y = |X| */
2279 fp1 = packFloatx80(1, aExp, aSig); /* -Y */
2280 fp0 = floatx80_add(fp0, fp0, status); /* 2Y */
2281 fp1 = floatx80_add(fp1, one, status); /* 1-Y */
2282 fp0 = floatx80_div(fp0, fp1, status); /* Z = 2Y/(1-Y) */
2283 fp0 = floatx80_lognp1(fp0, status); /* LOG1P(Z) */
2284
2285 status->float_rounding_mode = user_rnd_mode;
2286 status->floatx80_rounding_precision = user_rnd_prec;
2287
2288 a = floatx80_mul(fp0, fp2,
2289 status); /* ATANH(X) = SIGN(X) * (1/2) * LOG1P(Z) */
2290
2291 float_raise(float_flag_inexact, status);
2292
2293 return a;
2294 }
2295
2296 /*
2297 * e to x minus 1
2298 */
2299
2300 floatx80 floatx80_etoxm1(floatx80 a, float_status *status)
2301 {
2302 bool aSign;
2303 int32_t aExp;
2304 uint64_t aSig;
2305
2306 FloatRoundMode user_rnd_mode;
2307 FloatX80RoundPrec user_rnd_prec;
2308
2309 int32_t compact, n, j, m, m1;
2310 floatx80 fp0, fp1, fp2, fp3, l2, sc, onebysc;
2311
2312 aSig = extractFloatx80Frac(a);
2313 aExp = extractFloatx80Exp(a);
2314 aSign = extractFloatx80Sign(a);
2315
2316 if (aExp == 0x7FFF) {
2317 if ((uint64_t) (aSig << 1)) {
2318 return propagateFloatx80NaNOneArg(a, status);
2319 }
2320 if (aSign) {
2321 return packFloatx80(aSign, one_exp, one_sig);
2322 }
2323 return packFloatx80(0, floatx80_infinity.high,
2324 floatx80_infinity.low);
2325 }
2326
2327 if (aExp == 0 && aSig == 0) {
2328 return packFloatx80(aSign, 0, 0);
2329 }
2330
2331 user_rnd_mode = status->float_rounding_mode;
2332 user_rnd_prec = status->floatx80_rounding_precision;
2333 status->float_rounding_mode = float_round_nearest_even;
2334 status->floatx80_rounding_precision = floatx80_precision_x;
2335
2336 if (aExp >= 0x3FFD) { /* |X| >= 1/4 */
2337 compact = floatx80_make_compact(aExp, aSig);
2338
2339 if (compact <= 0x4004C215) { /* |X| <= 70 log2 */
2340 fp0 = a;
2341 fp1 = a;
2342 fp0 = floatx80_mul(fp0, float32_to_floatx80(
2343 make_float32(0x42B8AA3B), status),
2344 status); /* 64/log2 * X */
2345 n = floatx80_to_int32(fp0, status); /* int(64/log2*X) */
2346 fp0 = int32_to_floatx80(n, status);
2347
2348 j = n & 0x3F; /* J = N mod 64 */
2349 m = n / 64; /* NOTE: this is really arithmetic right shift by 6 */
2350 if (n < 0 && j) {
2351 /*
2352 * arithmetic right shift is division and
2353 * round towards minus infinity
2354 */
2355 m--;
2356 }
2357 m1 = -m;
2358 /*m += 0x3FFF; // biased exponent of 2^(M) */
2359 /*m1 += 0x3FFF; // biased exponent of -2^(-M) */
2360
2361 fp2 = fp0; /* N */
2362 fp0 = floatx80_mul(fp0, float32_to_floatx80(
2363 make_float32(0xBC317218), status),
2364 status); /* N * L1, L1 = lead(-log2/64) */
2365 l2 = packFloatx80(0, 0x3FDC, UINT64_C(0x82E308654361C4C6));
2366 fp2 = floatx80_mul(fp2, l2, status); /* N * L2, L1+L2 = -log2/64 */
2367 fp0 = floatx80_add(fp0, fp1, status); /* X + N*L1 */
2368 fp0 = floatx80_add(fp0, fp2, status); /* R */
2369
2370 fp1 = floatx80_mul(fp0, fp0, status); /* S = R*R */
2371 fp2 = float32_to_floatx80(make_float32(0x3950097B),
2372 status); /* A6 */
2373 fp2 = floatx80_mul(fp2, fp1, status); /* fp2 is S*A6 */
2374 fp3 = floatx80_mul(float32_to_floatx80(make_float32(0x3AB60B6A),
2375 status), fp1, status); /* fp3 is S*A5 */
2376 fp2 = floatx80_add(fp2, float64_to_floatx80(
2377 make_float64(0x3F81111111174385), status),
2378 status); /* fp2 IS A4+S*A6 */
2379 fp3 = floatx80_add(fp3, float64_to_floatx80(
2380 make_float64(0x3FA5555555554F5A), status),
2381 status); /* fp3 is A3+S*A5 */
2382 fp2 = floatx80_mul(fp2, fp1, status); /* fp2 IS S*(A4+S*A6) */
2383 fp3 = floatx80_mul(fp3, fp1, status); /* fp3 IS S*(A3+S*A5) */
2384 fp2 = floatx80_add(fp2, float64_to_floatx80(
2385 make_float64(0x3FC5555555555555), status),
2386 status); /* fp2 IS A2+S*(A4+S*A6) */
2387 fp3 = floatx80_add(fp3, float32_to_floatx80(
2388 make_float32(0x3F000000), status),
2389 status); /* fp3 IS A1+S*(A3+S*A5) */
2390 fp2 = floatx80_mul(fp2, fp1,
2391 status); /* fp2 IS S*(A2+S*(A4+S*A6)) */
2392 fp1 = floatx80_mul(fp1, fp3,
2393 status); /* fp1 IS S*(A1+S*(A3+S*A5)) */
2394 fp2 = floatx80_mul(fp2, fp0,
2395 status); /* fp2 IS R*S*(A2+S*(A4+S*A6)) */
2396 fp0 = floatx80_add(fp0, fp1,
2397 status); /* fp0 IS R+S*(A1+S*(A3+S*A5)) */
2398 fp0 = floatx80_add(fp0, fp2, status); /* fp0 IS EXP(R) - 1 */
2399
2400 fp0 = floatx80_mul(fp0, exp_tbl[j],
2401 status); /* 2^(J/64)*(Exp(R)-1) */
2402
2403 if (m >= 64) {
2404 fp1 = float32_to_floatx80(exp_tbl2[j], status);
2405 onebysc = packFloatx80(1, m1 + 0x3FFF, one_sig); /* -2^(-M) */
2406 fp1 = floatx80_add(fp1, onebysc, status);
2407 fp0 = floatx80_add(fp0, fp1, status);
2408 fp0 = floatx80_add(fp0, exp_tbl[j], status);
2409 } else if (m < -3) {
2410 fp0 = floatx80_add(fp0, float32_to_floatx80(exp_tbl2[j],
2411 status), status);
2412 fp0 = floatx80_add(fp0, exp_tbl[j], status);
2413 onebysc = packFloatx80(1, m1 + 0x3FFF, one_sig); /* -2^(-M) */
2414 fp0 = floatx80_add(fp0, onebysc, status);
2415 } else { /* -3 <= m <= 63 */
2416 fp1 = exp_tbl[j];
2417 fp0 = floatx80_add(fp0, float32_to_floatx80(exp_tbl2[j],
2418 status), status);
2419 onebysc = packFloatx80(1, m1 + 0x3FFF, one_sig); /* -2^(-M) */
2420 fp1 = floatx80_add(fp1, onebysc, status);
2421 fp0 = floatx80_add(fp0, fp1, status);
2422 }
2423
2424 sc = packFloatx80(0, m + 0x3FFF, one_sig);
2425
2426 status->float_rounding_mode = user_rnd_mode;
2427 status->floatx80_rounding_precision = user_rnd_prec;
2428
2429 a = floatx80_mul(fp0, sc, status);
2430
2431 float_raise(float_flag_inexact, status);
2432
2433 return a;
2434 } else { /* |X| > 70 log2 */
2435 if (aSign) {
2436 fp0 = float32_to_floatx80(make_float32(0xBF800000),
2437 status); /* -1 */
2438
2439 status->float_rounding_mode = user_rnd_mode;
2440 status->floatx80_rounding_precision = user_rnd_prec;
2441
2442 a = floatx80_add(fp0, float32_to_floatx80(
2443 make_float32(0x00800000), status),
2444 status); /* -1 + 2^(-126) */
2445
2446 float_raise(float_flag_inexact, status);
2447
2448 return a;
2449 } else {
2450 status->float_rounding_mode = user_rnd_mode;
2451 status->floatx80_rounding_precision = user_rnd_prec;
2452
2453 return floatx80_etox(a, status);
2454 }
2455 }
2456 } else { /* |X| < 1/4 */
2457 if (aExp >= 0x3FBE) {
2458 fp0 = a;
2459 fp0 = floatx80_mul(fp0, fp0, status); /* S = X*X */
2460 fp1 = float32_to_floatx80(make_float32(0x2F30CAA8),
2461 status); /* B12 */
2462 fp1 = floatx80_mul(fp1, fp0, status); /* S * B12 */
2463 fp2 = float32_to_floatx80(make_float32(0x310F8290),
2464 status); /* B11 */
2465 fp1 = floatx80_add(fp1, float32_to_floatx80(
2466 make_float32(0x32D73220), status),
2467 status); /* B10 */
2468 fp2 = floatx80_mul(fp2, fp0, status);
2469 fp1 = floatx80_mul(fp1, fp0, status);
2470 fp2 = floatx80_add(fp2, float32_to_floatx80(
2471 make_float32(0x3493F281), status),
2472 status); /* B9 */
2473 fp1 = floatx80_add(fp1, float64_to_floatx80(
2474 make_float64(0x3EC71DE3A5774682), status),
2475 status); /* B8 */
2476 fp2 = floatx80_mul(fp2, fp0, status);
2477 fp1 = floatx80_mul(fp1, fp0, status);
2478 fp2 = floatx80_add(fp2, float64_to_floatx80(
2479 make_float64(0x3EFA01A019D7CB68), status),
2480 status); /* B7 */
2481 fp1 = floatx80_add(fp1, float64_to_floatx80(
2482 make_float64(0x3F2A01A01A019DF3), status),
2483 status); /* B6 */
2484 fp2 = floatx80_mul(fp2, fp0, status);
2485 fp1 = floatx80_mul(fp1, fp0, status);
2486 fp2 = floatx80_add(fp2, float64_to_floatx80(
2487 make_float64(0x3F56C16C16C170E2), status),
2488 status); /* B5 */
2489 fp1 = floatx80_add(fp1, float64_to_floatx80(
2490 make_float64(0x3F81111111111111), status),
2491 status); /* B4 */
2492 fp2 = floatx80_mul(fp2, fp0, status);
2493 fp1 = floatx80_mul(fp1, fp0, status);
2494 fp2 = floatx80_add(fp2, float64_to_floatx80(
2495 make_float64(0x3FA5555555555555), status),
2496 status); /* B3 */
2497 fp3 = packFloatx80(0, 0x3FFC, UINT64_C(0xAAAAAAAAAAAAAAAB));
2498 fp1 = floatx80_add(fp1, fp3, status); /* B2 */
2499 fp2 = floatx80_mul(fp2, fp0, status);
2500 fp1 = floatx80_mul(fp1, fp0, status);
2501
2502 fp2 = floatx80_mul(fp2, fp0, status);
2503 fp1 = floatx80_mul(fp1, a, status);
2504
2505 fp0 = floatx80_mul(fp0, float32_to_floatx80(
2506 make_float32(0x3F000000), status),
2507 status); /* S*B1 */
2508 fp1 = floatx80_add(fp1, fp2, status); /* Q */
2509 fp0 = floatx80_add(fp0, fp1, status); /* S*B1+Q */
2510
2511 status->float_rounding_mode = user_rnd_mode;
2512 status->floatx80_rounding_precision = user_rnd_prec;
2513
2514 a = floatx80_add(fp0, a, status);
2515
2516 float_raise(float_flag_inexact, status);
2517
2518 return a;
2519 } else { /* |X| < 2^(-65) */
2520 sc = packFloatx80(1, 1, one_sig);
2521 fp0 = a;
2522
2523 if (aExp < 0x0033) { /* |X| < 2^(-16382) */
2524 fp0 = floatx80_mul(fp0, float64_to_floatx80(
2525 make_float64(0x48B0000000000000), status),
2526 status);
2527 fp0 = floatx80_add(fp0, sc, status);
2528
2529 status->float_rounding_mode = user_rnd_mode;
2530 status->floatx80_rounding_precision = user_rnd_prec;
2531
2532 a = floatx80_mul(fp0, float64_to_floatx80(
2533 make_float64(0x3730000000000000), status),
2534 status);
2535 } else {
2536 status->float_rounding_mode = user_rnd_mode;
2537 status->floatx80_rounding_precision = user_rnd_prec;
2538
2539 a = floatx80_add(fp0, sc, status);
2540 }
2541
2542 float_raise(float_flag_inexact, status);
2543
2544 return a;
2545 }
2546 }
2547 }
2548
2549 /*
2550 * Hyperbolic tangent
2551 */
2552
2553 floatx80 floatx80_tanh(floatx80 a, float_status *status)
2554 {
2555 bool aSign, vSign;
2556 int32_t aExp, vExp;
2557 uint64_t aSig, vSig;
2558
2559 FloatRoundMode user_rnd_mode;
2560 FloatX80RoundPrec user_rnd_prec;
2561
2562 int32_t compact;
2563 floatx80 fp0, fp1;
2564 uint32_t sign;
2565
2566 aSig = extractFloatx80Frac(a);
2567 aExp = extractFloatx80Exp(a);
2568 aSign = extractFloatx80Sign(a);
2569
2570 if (aExp == 0x7FFF) {
2571 if ((uint64_t) (aSig << 1)) {
2572 return propagateFloatx80NaNOneArg(a, status);
2573 }
2574 return packFloatx80(aSign, one_exp, one_sig);
2575 }
2576
2577 if (aExp == 0 && aSig == 0) {
2578 return packFloatx80(aSign, 0, 0);
2579 }
2580
2581 user_rnd_mode = status->float_rounding_mode;
2582 user_rnd_prec = status->floatx80_rounding_precision;
2583 status->float_rounding_mode = float_round_nearest_even;
2584 status->floatx80_rounding_precision = floatx80_precision_x;
2585
2586 compact = floatx80_make_compact(aExp, aSig);
2587
2588 if (compact < 0x3FD78000 || compact > 0x3FFFDDCE) {
2589 /* TANHBORS */
2590 if (compact < 0x3FFF8000) {
2591 /* TANHSM */
2592 status->float_rounding_mode = user_rnd_mode;
2593 status->floatx80_rounding_precision = user_rnd_prec;
2594
2595 a = floatx80_move(a, status);
2596
2597 float_raise(float_flag_inexact, status);
2598
2599 return a;
2600 } else {
2601 if (compact > 0x40048AA1) {
2602 /* TANHHUGE */
2603 sign = 0x3F800000;
2604 sign |= aSign ? 0x80000000 : 0x00000000;
2605 fp0 = float32_to_floatx80(make_float32(sign), status);
2606 sign &= 0x80000000;
2607 sign ^= 0x80800000; /* -SIGN(X)*EPS */
2608
2609 status->float_rounding_mode = user_rnd_mode;
2610 status->floatx80_rounding_precision = user_rnd_prec;
2611
2612 a = floatx80_add(fp0, float32_to_floatx80(make_float32(sign),
2613 status), status);
2614
2615 float_raise(float_flag_inexact, status);
2616
2617 return a;
2618 } else {
2619 fp0 = packFloatx80(0, aExp + 1, aSig); /* Y = 2|X| */
2620 fp0 = floatx80_etox(fp0, status); /* FP0 IS EXP(Y) */
2621 fp0 = floatx80_add(fp0, float32_to_floatx80(
2622 make_float32(0x3F800000),
2623 status), status); /* EXP(Y)+1 */
2624 sign = aSign ? 0x80000000 : 0x00000000;
2625 fp1 = floatx80_div(float32_to_floatx80(make_float32(
2626 sign ^ 0xC0000000), status), fp0,
2627 status); /* -SIGN(X)*2 / [EXP(Y)+1] */
2628 fp0 = float32_to_floatx80(make_float32(sign | 0x3F800000),
2629 status); /* SIGN */
2630
2631 status->float_rounding_mode = user_rnd_mode;
2632 status->floatx80_rounding_precision = user_rnd_prec;
2633
2634 a = floatx80_add(fp1, fp0, status);
2635
2636 float_raise(float_flag_inexact, status);
2637
2638 return a;
2639 }
2640 }
2641 } else { /* 2**(-40) < |X| < (5/2)LOG2 */
2642 fp0 = packFloatx80(0, aExp + 1, aSig); /* Y = 2|X| */
2643 fp0 = floatx80_etoxm1(fp0, status); /* FP0 IS Z = EXPM1(Y) */
2644 fp1 = floatx80_add(fp0, float32_to_floatx80(make_float32(0x40000000),
2645 status),
2646 status); /* Z+2 */
2647
2648 vSign = extractFloatx80Sign(fp1);
2649 vExp = extractFloatx80Exp(fp1);
2650 vSig = extractFloatx80Frac(fp1);
2651
2652 fp1 = packFloatx80(vSign ^ aSign, vExp, vSig);
2653
2654 status->float_rounding_mode = user_rnd_mode;
2655 status->floatx80_rounding_precision = user_rnd_prec;
2656
2657 a = floatx80_div(fp0, fp1, status);
2658
2659 float_raise(float_flag_inexact, status);
2660
2661 return a;
2662 }
2663 }
2664
2665 /*
2666 * Hyperbolic sine
2667 */
2668
2669 floatx80 floatx80_sinh(floatx80 a, float_status *status)
2670 {
2671 bool aSign;
2672 int32_t aExp;
2673 uint64_t aSig;
2674
2675 FloatRoundMode user_rnd_mode;
2676 FloatX80RoundPrec user_rnd_prec;
2677
2678 int32_t compact;
2679 floatx80 fp0, fp1, fp2;
2680 float32 fact;
2681
2682 aSig = extractFloatx80Frac(a);
2683 aExp = extractFloatx80Exp(a);
2684 aSign = extractFloatx80Sign(a);
2685
2686 if (aExp == 0x7FFF) {
2687 if ((uint64_t) (aSig << 1)) {
2688 return propagateFloatx80NaNOneArg(a, status);
2689 }
2690 return packFloatx80(aSign, floatx80_infinity.high,
2691 floatx80_infinity.low);
2692 }
2693
2694 if (aExp == 0 && aSig == 0) {
2695 return packFloatx80(aSign, 0, 0);
2696 }
2697
2698 user_rnd_mode = status->float_rounding_mode;
2699 user_rnd_prec = status->floatx80_rounding_precision;
2700 status->float_rounding_mode = float_round_nearest_even;
2701 status->floatx80_rounding_precision = floatx80_precision_x;
2702
2703 compact = floatx80_make_compact(aExp, aSig);
2704
2705 if (compact > 0x400CB167) {
2706 /* SINHBIG */
2707 if (compact > 0x400CB2B3) {
2708 status->float_rounding_mode = user_rnd_mode;
2709 status->floatx80_rounding_precision = user_rnd_prec;
2710
2711 return roundAndPackFloatx80(status->floatx80_rounding_precision,
2712 aSign, 0x8000, aSig, 0, status);
2713 } else {
2714 fp0 = floatx80_abs(a); /* Y = |X| */
2715 fp0 = floatx80_sub(fp0, float64_to_floatx80(
2716 make_float64(0x40C62D38D3D64634), status),
2717 status); /* (|X|-16381LOG2_LEAD) */
2718 fp0 = floatx80_sub(fp0, float64_to_floatx80(
2719 make_float64(0x3D6F90AEB1E75CC7), status),
2720 status); /* |X| - 16381 LOG2, ACCURATE */
2721 fp0 = floatx80_etox(fp0, status);
2722 fp2 = packFloatx80(aSign, 0x7FFB, one_sig);
2723
2724 status->float_rounding_mode = user_rnd_mode;
2725 status->floatx80_rounding_precision = user_rnd_prec;
2726
2727 a = floatx80_mul(fp0, fp2, status);
2728
2729 float_raise(float_flag_inexact, status);
2730
2731 return a;
2732 }
2733 } else { /* |X| < 16380 LOG2 */
2734 fp0 = floatx80_abs(a); /* Y = |X| */
2735 fp0 = floatx80_etoxm1(fp0, status); /* FP0 IS Z = EXPM1(Y) */
2736 fp1 = floatx80_add(fp0, float32_to_floatx80(make_float32(0x3F800000),
2737 status), status); /* 1+Z */
2738 fp2 = fp0;
2739 fp0 = floatx80_div(fp0, fp1, status); /* Z/(1+Z) */
2740 fp0 = floatx80_add(fp0, fp2, status);
2741
2742 fact = packFloat32(aSign, 0x7E, 0);
2743
2744 status->float_rounding_mode = user_rnd_mode;
2745 status->floatx80_rounding_precision = user_rnd_prec;
2746
2747 a = floatx80_mul(fp0, float32_to_floatx80(fact, status), status);
2748
2749 float_raise(float_flag_inexact, status);
2750
2751 return a;
2752 }
2753 }
2754
2755 /*
2756 * Hyperbolic cosine
2757 */
2758
2759 floatx80 floatx80_cosh(floatx80 a, float_status *status)
2760 {
2761 int32_t aExp;
2762 uint64_t aSig;
2763
2764 FloatRoundMode user_rnd_mode;
2765 FloatX80RoundPrec user_rnd_prec;
2766
2767 int32_t compact;
2768 floatx80 fp0, fp1;
2769
2770 aSig = extractFloatx80Frac(a);
2771 aExp = extractFloatx80Exp(a);
2772
2773 if (aExp == 0x7FFF) {
2774 if ((uint64_t) (aSig << 1)) {
2775 return propagateFloatx80NaNOneArg(a, status);
2776 }
2777 return packFloatx80(0, floatx80_infinity.high,
2778 floatx80_infinity.low);
2779 }
2780
2781 if (aExp == 0 && aSig == 0) {
2782 return packFloatx80(0, one_exp, one_sig);
2783 }
2784
2785 user_rnd_mode = status->float_rounding_mode;
2786 user_rnd_prec = status->floatx80_rounding_precision;
2787 status->float_rounding_mode = float_round_nearest_even;
2788 status->floatx80_rounding_precision = floatx80_precision_x;
2789
2790 compact = floatx80_make_compact(aExp, aSig);
2791
2792 if (compact > 0x400CB167) {
2793 if (compact > 0x400CB2B3) {
2794 status->float_rounding_mode = user_rnd_mode;
2795 status->floatx80_rounding_precision = user_rnd_prec;
2796 return roundAndPackFloatx80(status->floatx80_rounding_precision, 0,
2797 0x8000, one_sig, 0, status);
2798 } else {
2799 fp0 = packFloatx80(0, aExp, aSig);
2800 fp0 = floatx80_sub(fp0, float64_to_floatx80(
2801 make_float64(0x40C62D38D3D64634), status),
2802 status);
2803 fp0 = floatx80_sub(fp0, float64_to_floatx80(
2804 make_float64(0x3D6F90AEB1E75CC7), status),
2805 status);
2806 fp0 = floatx80_etox(fp0, status);
2807 fp1 = packFloatx80(0, 0x7FFB, one_sig);
2808
2809 status->float_rounding_mode = user_rnd_mode;
2810 status->floatx80_rounding_precision = user_rnd_prec;
2811
2812 a = floatx80_mul(fp0, fp1, status);
2813
2814 float_raise(float_flag_inexact, status);
2815
2816 return a;
2817 }
2818 }
2819
2820 fp0 = packFloatx80(0, aExp, aSig); /* |X| */
2821 fp0 = floatx80_etox(fp0, status); /* EXP(|X|) */
2822 fp0 = floatx80_mul(fp0, float32_to_floatx80(make_float32(0x3F000000),
2823 status), status); /* (1/2)*EXP(|X|) */
2824 fp1 = float32_to_floatx80(make_float32(0x3E800000), status); /* 1/4 */
2825 fp1 = floatx80_div(fp1, fp0, status); /* 1/(2*EXP(|X|)) */
2826
2827 status->float_rounding_mode = user_rnd_mode;
2828 status->floatx80_rounding_precision = user_rnd_prec;
2829
2830 a = floatx80_add(fp0, fp1, status);
2831
2832 float_raise(float_flag_inexact, status);
2833
2834 return a;
2835 }
AR7 emulation for QEMU