Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /*---------------------------------------------------------------------------+ |
3 | | fpu_trig.c | | |
4 | | | | |
5 | | Implementation of the FPU "transcendental" functions. | | |
6 | | | | |
7 | | Copyright (C) 1992,1993,1994,1997,1999 | | |
8 | | W. Metzenthen, 22 Parker St, Ormond, Vic 3163, | | |
9 | | Australia. E-mail billm@melbpc.org.au | | |
10 | | | | |
11 | | | | |
12 | +---------------------------------------------------------------------------*/ | |
13 | ||
14 | #include "fpu_system.h" | |
15 | #include "exception.h" | |
16 | #include "fpu_emu.h" | |
17 | #include "status_w.h" | |
18 | #include "control_w.h" | |
3d0d14f9 | 19 | #include "reg_constant.h" |
1da177e4 LT |
20 | |
21 | static void rem_kernel(unsigned long long st0, unsigned long long *y, | |
3d0d14f9 | 22 | unsigned long long st1, unsigned long long q, int n); |
1da177e4 LT |
23 | |
24 | #define BETTER_THAN_486 | |
25 | ||
26 | #define FCOS 4 | |
27 | ||
28 | /* Used only by fptan, fsin, fcos, and fsincos. */ | |
29 | /* This routine produces very accurate results, similar to | |
30 | using a value of pi with more than 128 bits precision. */ | |
31 | /* Limited measurements show no results worse than 64 bit precision | |
32 | except for the results for arguments close to 2^63, where the | |
33 | precision of the result sometimes degrades to about 63.9 bits */ | |
e8d591dc | 34 | static int trig_arg(FPU_REG *st0_ptr, int even) |
1da177e4 | 35 | { |
3d0d14f9 IM |
36 | FPU_REG tmp; |
37 | u_char tmptag; | |
38 | unsigned long long q; | |
39 | int old_cw = control_word, saved_status = partial_status; | |
40 | int tag, st0_tag = TAG_Valid; | |
41 | ||
42 | if (exponent(st0_ptr) >= 63) { | |
43 | partial_status |= SW_C2; /* Reduction incomplete. */ | |
44 | return -1; | |
45 | } | |
1da177e4 | 46 | |
3d0d14f9 IM |
47 | control_word &= ~CW_RC; |
48 | control_word |= RC_CHOP; | |
49 | ||
50 | setpositive(st0_ptr); | |
51 | tag = FPU_u_div(st0_ptr, &CONST_PI2, &tmp, PR_64_BITS | RC_CHOP | 0x3f, | |
52 | SIGN_POS); | |
53 | ||
54 | FPU_round_to_int(&tmp, tag); /* Fortunately, this can't overflow | |
55 | to 2^64 */ | |
56 | q = significand(&tmp); | |
57 | if (q) { | |
58 | rem_kernel(significand(st0_ptr), | |
59 | &significand(&tmp), | |
60 | significand(&CONST_PI2), | |
61 | q, exponent(st0_ptr) - exponent(&CONST_PI2)); | |
62 | setexponent16(&tmp, exponent(&CONST_PI2)); | |
63 | st0_tag = FPU_normalize(&tmp); | |
64 | FPU_copy_to_reg0(&tmp, st0_tag); | |
1da177e4 | 65 | } |
3d0d14f9 IM |
66 | |
67 | if ((even && !(q & 1)) || (!even && (q & 1))) { | |
68 | st0_tag = | |
69 | FPU_sub(REV | LOADED | TAG_Valid, (int)&CONST_PI2, | |
70 | FULL_PRECISION); | |
71 | ||
72 | #ifdef BETTER_THAN_486 | |
73 | /* So far, the results are exact but based upon a 64 bit | |
74 | precision approximation to pi/2. The technique used | |
75 | now is equivalent to using an approximation to pi/2 which | |
76 | is accurate to about 128 bits. */ | |
77 | if ((exponent(st0_ptr) <= exponent(&CONST_PI2extra) + 64) | |
78 | || (q > 1)) { | |
79 | /* This code gives the effect of having pi/2 to better than | |
80 | 128 bits precision. */ | |
81 | ||
82 | significand(&tmp) = q + 1; | |
83 | setexponent16(&tmp, 63); | |
84 | FPU_normalize(&tmp); | |
85 | tmptag = | |
86 | FPU_u_mul(&CONST_PI2extra, &tmp, &tmp, | |
87 | FULL_PRECISION, SIGN_POS, | |
88 | exponent(&CONST_PI2extra) + | |
89 | exponent(&tmp)); | |
90 | setsign(&tmp, getsign(&CONST_PI2extra)); | |
91 | st0_tag = FPU_add(&tmp, tmptag, 0, FULL_PRECISION); | |
92 | if (signnegative(st0_ptr)) { | |
93 | /* CONST_PI2extra is negative, so the result of the addition | |
94 | can be negative. This means that the argument is actually | |
95 | in a different quadrant. The correction is always < pi/2, | |
96 | so it can't overflow into yet another quadrant. */ | |
97 | setpositive(st0_ptr); | |
98 | q++; | |
99 | } | |
100 | } | |
1da177e4 | 101 | #endif /* BETTER_THAN_486 */ |
3d0d14f9 | 102 | } |
1da177e4 | 103 | #ifdef BETTER_THAN_486 |
3d0d14f9 IM |
104 | else { |
105 | /* So far, the results are exact but based upon a 64 bit | |
106 | precision approximation to pi/2. The technique used | |
107 | now is equivalent to using an approximation to pi/2 which | |
108 | is accurate to about 128 bits. */ | |
109 | if (((q > 0) | |
110 | && (exponent(st0_ptr) <= exponent(&CONST_PI2extra) + 64)) | |
111 | || (q > 1)) { | |
112 | /* This code gives the effect of having p/2 to better than | |
113 | 128 bits precision. */ | |
114 | ||
115 | significand(&tmp) = q; | |
116 | setexponent16(&tmp, 63); | |
117 | FPU_normalize(&tmp); /* This must return TAG_Valid */ | |
118 | tmptag = | |
119 | FPU_u_mul(&CONST_PI2extra, &tmp, &tmp, | |
120 | FULL_PRECISION, SIGN_POS, | |
121 | exponent(&CONST_PI2extra) + | |
122 | exponent(&tmp)); | |
123 | setsign(&tmp, getsign(&CONST_PI2extra)); | |
124 | st0_tag = FPU_sub(LOADED | (tmptag & 0x0f), (int)&tmp, | |
125 | FULL_PRECISION); | |
126 | if ((exponent(st0_ptr) == exponent(&CONST_PI2)) && | |
127 | ((st0_ptr->sigh > CONST_PI2.sigh) | |
128 | || ((st0_ptr->sigh == CONST_PI2.sigh) | |
129 | && (st0_ptr->sigl > CONST_PI2.sigl)))) { | |
130 | /* CONST_PI2extra is negative, so the result of the | |
131 | subtraction can be larger than pi/2. This means | |
132 | that the argument is actually in a different quadrant. | |
133 | The correction is always < pi/2, so it can't overflow | |
134 | into yet another quadrant. */ | |
135 | st0_tag = | |
136 | FPU_sub(REV | LOADED | TAG_Valid, | |
137 | (int)&CONST_PI2, FULL_PRECISION); | |
138 | q++; | |
139 | } | |
140 | } | |
1da177e4 | 141 | } |
1da177e4 LT |
142 | #endif /* BETTER_THAN_486 */ |
143 | ||
3d0d14f9 IM |
144 | FPU_settag0(st0_tag); |
145 | control_word = old_cw; | |
146 | partial_status = saved_status & ~SW_C2; /* Reduction complete. */ | |
1da177e4 | 147 | |
3d0d14f9 | 148 | return (q & 3) | even; |
1da177e4 LT |
149 | } |
150 | ||
1da177e4 LT |
151 | /* Convert a long to register */ |
152 | static void convert_l2reg(long const *arg, int deststnr) | |
153 | { | |
3d0d14f9 IM |
154 | int tag; |
155 | long num = *arg; | |
156 | u_char sign; | |
157 | FPU_REG *dest = &st(deststnr); | |
1da177e4 | 158 | |
3d0d14f9 IM |
159 | if (num == 0) { |
160 | FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr); | |
161 | return; | |
162 | } | |
163 | ||
164 | if (num > 0) { | |
165 | sign = SIGN_POS; | |
166 | } else { | |
167 | num = -num; | |
168 | sign = SIGN_NEG; | |
169 | } | |
1da177e4 | 170 | |
3d0d14f9 IM |
171 | dest->sigh = num; |
172 | dest->sigl = 0; | |
173 | setexponent16(dest, 31); | |
174 | tag = FPU_normalize(dest); | |
175 | FPU_settagi(deststnr, tag); | |
176 | setsign(dest, sign); | |
177 | return; | |
178 | } | |
179 | ||
e8d591dc | 180 | static void single_arg_error(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 181 | { |
3d0d14f9 IM |
182 | if (st0_tag == TAG_Empty) |
183 | FPU_stack_underflow(); /* Puts a QNaN in st(0) */ | |
184 | else if (st0_tag == TW_NaN) | |
185 | real_1op_NaN(st0_ptr); /* return with a NaN in st(0) */ | |
1da177e4 | 186 | #ifdef PARANOID |
3d0d14f9 IM |
187 | else |
188 | EXCEPTION(EX_INTERNAL | 0x0112); | |
1da177e4 LT |
189 | #endif /* PARANOID */ |
190 | } | |
191 | ||
e8d591dc | 192 | static void single_arg_2_error(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 193 | { |
3d0d14f9 IM |
194 | int isNaN; |
195 | ||
196 | switch (st0_tag) { | |
197 | case TW_NaN: | |
198 | isNaN = (exponent(st0_ptr) == EXP_OVER) | |
199 | && (st0_ptr->sigh & 0x80000000); | |
200 | if (isNaN && !(st0_ptr->sigh & 0x40000000)) { /* Signaling ? */ | |
201 | EXCEPTION(EX_Invalid); | |
202 | if (control_word & CW_Invalid) { | |
203 | /* The masked response */ | |
204 | /* Convert to a QNaN */ | |
205 | st0_ptr->sigh |= 0x40000000; | |
206 | push(); | |
207 | FPU_copy_to_reg0(st0_ptr, TAG_Special); | |
208 | } | |
209 | } else if (isNaN) { | |
210 | /* A QNaN */ | |
211 | push(); | |
212 | FPU_copy_to_reg0(st0_ptr, TAG_Special); | |
213 | } else { | |
214 | /* pseudoNaN or other unsupported */ | |
215 | EXCEPTION(EX_Invalid); | |
216 | if (control_word & CW_Invalid) { | |
217 | /* The masked response */ | |
218 | FPU_copy_to_reg0(&CONST_QNaN, TAG_Special); | |
219 | push(); | |
220 | FPU_copy_to_reg0(&CONST_QNaN, TAG_Special); | |
221 | } | |
222 | } | |
223 | break; /* return with a NaN in st(0) */ | |
1da177e4 | 224 | #ifdef PARANOID |
3d0d14f9 IM |
225 | default: |
226 | EXCEPTION(EX_INTERNAL | 0x0112); | |
1da177e4 | 227 | #endif /* PARANOID */ |
3d0d14f9 | 228 | } |
1da177e4 LT |
229 | } |
230 | ||
1da177e4 LT |
231 | /*---------------------------------------------------------------------------*/ |
232 | ||
e8d591dc | 233 | static void f2xm1(FPU_REG *st0_ptr, u_char tag) |
1da177e4 | 234 | { |
3d0d14f9 | 235 | FPU_REG a; |
1da177e4 | 236 | |
3d0d14f9 | 237 | clear_C1(); |
1da177e4 | 238 | |
3d0d14f9 IM |
239 | if (tag == TAG_Valid) { |
240 | /* For an 80486 FPU, the result is undefined if the arg is >= 1.0 */ | |
241 | if (exponent(st0_ptr) < 0) { | |
242 | denormal_arg: | |
1da177e4 | 243 | |
3d0d14f9 | 244 | FPU_to_exp16(st0_ptr, &a); |
1da177e4 | 245 | |
3d0d14f9 IM |
246 | /* poly_2xm1(x) requires 0 < st(0) < 1. */ |
247 | poly_2xm1(getsign(st0_ptr), &a, st0_ptr); | |
248 | } | |
249 | set_precision_flag_up(); /* 80486 appears to always do this */ | |
250 | return; | |
1da177e4 | 251 | } |
1da177e4 | 252 | |
3d0d14f9 IM |
253 | if (tag == TAG_Zero) |
254 | return; | |
1da177e4 | 255 | |
3d0d14f9 IM |
256 | if (tag == TAG_Special) |
257 | tag = FPU_Special(st0_ptr); | |
1da177e4 | 258 | |
3d0d14f9 IM |
259 | switch (tag) { |
260 | case TW_Denormal: | |
261 | if (denormal_operand() < 0) | |
262 | return; | |
263 | goto denormal_arg; | |
264 | case TW_Infinity: | |
265 | if (signnegative(st0_ptr)) { | |
266 | /* -infinity gives -1 (p16-10) */ | |
267 | FPU_copy_to_reg0(&CONST_1, TAG_Valid); | |
268 | setnegative(st0_ptr); | |
269 | } | |
270 | return; | |
271 | default: | |
272 | single_arg_error(st0_ptr, tag); | |
1da177e4 | 273 | } |
1da177e4 LT |
274 | } |
275 | ||
e8d591dc | 276 | static void fptan(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 277 | { |
3d0d14f9 IM |
278 | FPU_REG *st_new_ptr; |
279 | int q; | |
280 | u_char arg_sign = getsign(st0_ptr); | |
281 | ||
282 | /* Stack underflow has higher priority */ | |
283 | if (st0_tag == TAG_Empty) { | |
284 | FPU_stack_underflow(); /* Puts a QNaN in st(0) */ | |
285 | if (control_word & CW_Invalid) { | |
286 | st_new_ptr = &st(-1); | |
287 | push(); | |
288 | FPU_stack_underflow(); /* Puts a QNaN in the new st(0) */ | |
289 | } | |
290 | return; | |
1da177e4 | 291 | } |
3d0d14f9 IM |
292 | |
293 | if (STACK_OVERFLOW) { | |
294 | FPU_stack_overflow(); | |
295 | return; | |
1da177e4 | 296 | } |
1da177e4 | 297 | |
3d0d14f9 IM |
298 | if (st0_tag == TAG_Valid) { |
299 | if (exponent(st0_ptr) > -40) { | |
300 | if ((q = trig_arg(st0_ptr, 0)) == -1) { | |
301 | /* Operand is out of range */ | |
302 | return; | |
303 | } | |
304 | ||
305 | poly_tan(st0_ptr); | |
306 | setsign(st0_ptr, (q & 1) ^ (arg_sign != 0)); | |
307 | set_precision_flag_up(); /* We do not really know if up or down */ | |
308 | } else { | |
309 | /* For a small arg, the result == the argument */ | |
310 | /* Underflow may happen */ | |
311 | ||
312 | denormal_arg: | |
313 | ||
314 | FPU_to_exp16(st0_ptr, st0_ptr); | |
1da177e4 | 315 | |
3d0d14f9 IM |
316 | st0_tag = |
317 | FPU_round(st0_ptr, 1, 0, FULL_PRECISION, arg_sign); | |
318 | FPU_settag0(st0_tag); | |
319 | } | |
320 | push(); | |
321 | FPU_copy_to_reg0(&CONST_1, TAG_Valid); | |
322 | return; | |
1da177e4 | 323 | } |
1da177e4 | 324 | |
3d0d14f9 IM |
325 | if (st0_tag == TAG_Zero) { |
326 | push(); | |
327 | FPU_copy_to_reg0(&CONST_1, TAG_Valid); | |
328 | setcc(0); | |
329 | return; | |
330 | } | |
331 | ||
332 | if (st0_tag == TAG_Special) | |
333 | st0_tag = FPU_Special(st0_ptr); | |
334 | ||
335 | if (st0_tag == TW_Denormal) { | |
336 | if (denormal_operand() < 0) | |
337 | return; | |
338 | ||
339 | goto denormal_arg; | |
1da177e4 | 340 | } |
1da177e4 | 341 | |
3d0d14f9 IM |
342 | if (st0_tag == TW_Infinity) { |
343 | /* The 80486 treats infinity as an invalid operand */ | |
344 | if (arith_invalid(0) >= 0) { | |
345 | st_new_ptr = &st(-1); | |
346 | push(); | |
347 | arith_invalid(0); | |
348 | } | |
349 | return; | |
350 | } | |
1da177e4 | 351 | |
3d0d14f9 IM |
352 | single_arg_2_error(st0_ptr, st0_tag); |
353 | } | |
1da177e4 | 354 | |
e8d591dc | 355 | static void fxtract(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 356 | { |
3d0d14f9 IM |
357 | FPU_REG *st_new_ptr; |
358 | u_char sign; | |
359 | register FPU_REG *st1_ptr = st0_ptr; /* anticipate */ | |
1da177e4 | 360 | |
3d0d14f9 IM |
361 | if (STACK_OVERFLOW) { |
362 | FPU_stack_overflow(); | |
363 | return; | |
364 | } | |
1da177e4 | 365 | |
3d0d14f9 | 366 | clear_C1(); |
1da177e4 | 367 | |
3d0d14f9 IM |
368 | if (st0_tag == TAG_Valid) { |
369 | long e; | |
1da177e4 | 370 | |
3d0d14f9 IM |
371 | push(); |
372 | sign = getsign(st1_ptr); | |
373 | reg_copy(st1_ptr, st_new_ptr); | |
374 | setexponent16(st_new_ptr, exponent(st_new_ptr)); | |
375 | ||
376 | denormal_arg: | |
377 | ||
378 | e = exponent16(st_new_ptr); | |
379 | convert_l2reg(&e, 1); | |
380 | setexponentpos(st_new_ptr, 0); | |
381 | setsign(st_new_ptr, sign); | |
382 | FPU_settag0(TAG_Valid); /* Needed if arg was a denormal */ | |
383 | return; | |
384 | } else if (st0_tag == TAG_Zero) { | |
385 | sign = getsign(st0_ptr); | |
386 | ||
387 | if (FPU_divide_by_zero(0, SIGN_NEG) < 0) | |
388 | return; | |
1da177e4 | 389 | |
3d0d14f9 IM |
390 | push(); |
391 | FPU_copy_to_reg0(&CONST_Z, TAG_Zero); | |
392 | setsign(st_new_ptr, sign); | |
393 | return; | |
394 | } | |
395 | ||
396 | if (st0_tag == TAG_Special) | |
397 | st0_tag = FPU_Special(st0_ptr); | |
398 | ||
399 | if (st0_tag == TW_Denormal) { | |
400 | if (denormal_operand() < 0) | |
401 | return; | |
402 | ||
403 | push(); | |
404 | sign = getsign(st1_ptr); | |
405 | FPU_to_exp16(st1_ptr, st_new_ptr); | |
406 | goto denormal_arg; | |
407 | } else if (st0_tag == TW_Infinity) { | |
408 | sign = getsign(st0_ptr); | |
409 | setpositive(st0_ptr); | |
410 | push(); | |
411 | FPU_copy_to_reg0(&CONST_INF, TAG_Special); | |
412 | setsign(st_new_ptr, sign); | |
413 | return; | |
414 | } else if (st0_tag == TW_NaN) { | |
415 | if (real_1op_NaN(st0_ptr) < 0) | |
416 | return; | |
417 | ||
418 | push(); | |
419 | FPU_copy_to_reg0(st0_ptr, TAG_Special); | |
420 | return; | |
421 | } else if (st0_tag == TAG_Empty) { | |
422 | /* Is this the correct behaviour? */ | |
423 | if (control_word & EX_Invalid) { | |
424 | FPU_stack_underflow(); | |
425 | push(); | |
426 | FPU_stack_underflow(); | |
427 | } else | |
428 | EXCEPTION(EX_StackUnder); | |
1da177e4 | 429 | } |
1da177e4 | 430 | #ifdef PARANOID |
3d0d14f9 IM |
431 | else |
432 | EXCEPTION(EX_INTERNAL | 0x119); | |
1da177e4 LT |
433 | #endif /* PARANOID */ |
434 | } | |
435 | ||
1da177e4 LT |
436 | static void fdecstp(void) |
437 | { | |
3d0d14f9 IM |
438 | clear_C1(); |
439 | top--; | |
1da177e4 LT |
440 | } |
441 | ||
442 | static void fincstp(void) | |
443 | { | |
3d0d14f9 IM |
444 | clear_C1(); |
445 | top++; | |
1da177e4 LT |
446 | } |
447 | ||
e8d591dc | 448 | static void fsqrt_(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 449 | { |
3d0d14f9 IM |
450 | int expon; |
451 | ||
452 | clear_C1(); | |
1da177e4 | 453 | |
3d0d14f9 IM |
454 | if (st0_tag == TAG_Valid) { |
455 | u_char tag; | |
456 | ||
457 | if (signnegative(st0_ptr)) { | |
458 | arith_invalid(0); /* sqrt(negative) is invalid */ | |
459 | return; | |
460 | } | |
461 | ||
462 | /* make st(0) in [1.0 .. 4.0) */ | |
463 | expon = exponent(st0_ptr); | |
464 | ||
465 | denormal_arg: | |
466 | ||
467 | setexponent16(st0_ptr, (expon & 1)); | |
468 | ||
469 | /* Do the computation, the sign of the result will be positive. */ | |
470 | tag = wm_sqrt(st0_ptr, 0, 0, control_word, SIGN_POS); | |
471 | addexponent(st0_ptr, expon >> 1); | |
472 | FPU_settag0(tag); | |
473 | return; | |
1da177e4 LT |
474 | } |
475 | ||
3d0d14f9 IM |
476 | if (st0_tag == TAG_Zero) |
477 | return; | |
1da177e4 | 478 | |
3d0d14f9 IM |
479 | if (st0_tag == TAG_Special) |
480 | st0_tag = FPU_Special(st0_ptr); | |
1da177e4 | 481 | |
3d0d14f9 IM |
482 | if (st0_tag == TW_Infinity) { |
483 | if (signnegative(st0_ptr)) | |
484 | arith_invalid(0); /* sqrt(-Infinity) is invalid */ | |
485 | return; | |
486 | } else if (st0_tag == TW_Denormal) { | |
487 | if (signnegative(st0_ptr)) { | |
488 | arith_invalid(0); /* sqrt(negative) is invalid */ | |
489 | return; | |
490 | } | |
1da177e4 | 491 | |
3d0d14f9 IM |
492 | if (denormal_operand() < 0) |
493 | return; | |
1da177e4 | 494 | |
3d0d14f9 | 495 | FPU_to_exp16(st0_ptr, st0_ptr); |
1da177e4 | 496 | |
3d0d14f9 IM |
497 | expon = exponent16(st0_ptr); |
498 | ||
499 | goto denormal_arg; | |
500 | } | |
1da177e4 | 501 | |
3d0d14f9 | 502 | single_arg_error(st0_ptr, st0_tag); |
1da177e4 | 503 | |
3d0d14f9 IM |
504 | } |
505 | ||
e8d591dc | 506 | static void frndint_(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 507 | { |
3d0d14f9 | 508 | int flags, tag; |
1da177e4 | 509 | |
3d0d14f9 IM |
510 | if (st0_tag == TAG_Valid) { |
511 | u_char sign; | |
1da177e4 | 512 | |
3d0d14f9 | 513 | denormal_arg: |
1da177e4 | 514 | |
3d0d14f9 | 515 | sign = getsign(st0_ptr); |
1da177e4 | 516 | |
3d0d14f9 IM |
517 | if (exponent(st0_ptr) > 63) |
518 | return; | |
519 | ||
520 | if (st0_tag == TW_Denormal) { | |
521 | if (denormal_operand() < 0) | |
522 | return; | |
523 | } | |
524 | ||
525 | /* Fortunately, this can't overflow to 2^64 */ | |
526 | if ((flags = FPU_round_to_int(st0_ptr, st0_tag))) | |
527 | set_precision_flag(flags); | |
1da177e4 | 528 | |
3d0d14f9 IM |
529 | setexponent16(st0_ptr, 63); |
530 | tag = FPU_normalize(st0_ptr); | |
531 | setsign(st0_ptr, sign); | |
532 | FPU_settag0(tag); | |
533 | return; | |
1da177e4 LT |
534 | } |
535 | ||
3d0d14f9 IM |
536 | if (st0_tag == TAG_Zero) |
537 | return; | |
1da177e4 | 538 | |
3d0d14f9 IM |
539 | if (st0_tag == TAG_Special) |
540 | st0_tag = FPU_Special(st0_ptr); | |
1da177e4 | 541 | |
3d0d14f9 IM |
542 | if (st0_tag == TW_Denormal) |
543 | goto denormal_arg; | |
544 | else if (st0_tag == TW_Infinity) | |
545 | return; | |
546 | else | |
547 | single_arg_error(st0_ptr, st0_tag); | |
548 | } | |
549 | ||
e8d591dc | 550 | static int fsin(FPU_REG *st0_ptr, u_char tag) |
1da177e4 | 551 | { |
3d0d14f9 IM |
552 | u_char arg_sign = getsign(st0_ptr); |
553 | ||
554 | if (tag == TAG_Valid) { | |
555 | int q; | |
556 | ||
557 | if (exponent(st0_ptr) > -40) { | |
558 | if ((q = trig_arg(st0_ptr, 0)) == -1) { | |
559 | /* Operand is out of range */ | |
560 | return 1; | |
561 | } | |
562 | ||
563 | poly_sine(st0_ptr); | |
564 | ||
565 | if (q & 2) | |
566 | changesign(st0_ptr); | |
567 | ||
568 | setsign(st0_ptr, getsign(st0_ptr) ^ arg_sign); | |
569 | ||
570 | /* We do not really know if up or down */ | |
571 | set_precision_flag_up(); | |
572 | return 0; | |
573 | } else { | |
574 | /* For a small arg, the result == the argument */ | |
575 | set_precision_flag_up(); /* Must be up. */ | |
576 | return 0; | |
577 | } | |
1da177e4 | 578 | } |
3d0d14f9 IM |
579 | |
580 | if (tag == TAG_Zero) { | |
581 | setcc(0); | |
582 | return 0; | |
1da177e4 | 583 | } |
1da177e4 | 584 | |
3d0d14f9 IM |
585 | if (tag == TAG_Special) |
586 | tag = FPU_Special(st0_ptr); | |
1da177e4 | 587 | |
3d0d14f9 IM |
588 | if (tag == TW_Denormal) { |
589 | if (denormal_operand() < 0) | |
590 | return 1; | |
591 | ||
592 | /* For a small arg, the result == the argument */ | |
593 | /* Underflow may happen */ | |
594 | FPU_to_exp16(st0_ptr, st0_ptr); | |
595 | ||
596 | tag = FPU_round(st0_ptr, 1, 0, FULL_PRECISION, arg_sign); | |
597 | ||
598 | FPU_settag0(tag); | |
599 | ||
600 | return 0; | |
601 | } else if (tag == TW_Infinity) { | |
602 | /* The 80486 treats infinity as an invalid operand */ | |
603 | arith_invalid(0); | |
604 | return 1; | |
605 | } else { | |
606 | single_arg_error(st0_ptr, tag); | |
607 | return 1; | |
1da177e4 | 608 | } |
3d0d14f9 IM |
609 | } |
610 | ||
e8d591dc | 611 | static int f_cos(FPU_REG *st0_ptr, u_char tag) |
3d0d14f9 IM |
612 | { |
613 | u_char st0_sign; | |
614 | ||
615 | st0_sign = getsign(st0_ptr); | |
1da177e4 | 616 | |
3d0d14f9 IM |
617 | if (tag == TAG_Valid) { |
618 | int q; | |
619 | ||
620 | if (exponent(st0_ptr) > -40) { | |
621 | if ((exponent(st0_ptr) < 0) | |
622 | || ((exponent(st0_ptr) == 0) | |
623 | && (significand(st0_ptr) <= | |
624 | 0xc90fdaa22168c234LL))) { | |
625 | poly_cos(st0_ptr); | |
626 | ||
627 | /* We do not really know if up or down */ | |
628 | set_precision_flag_down(); | |
629 | ||
630 | return 0; | |
631 | } else if ((q = trig_arg(st0_ptr, FCOS)) != -1) { | |
632 | poly_sine(st0_ptr); | |
633 | ||
634 | if ((q + 1) & 2) | |
635 | changesign(st0_ptr); | |
636 | ||
637 | /* We do not really know if up or down */ | |
638 | set_precision_flag_down(); | |
639 | ||
640 | return 0; | |
641 | } else { | |
642 | /* Operand is out of range */ | |
643 | return 1; | |
644 | } | |
645 | } else { | |
646 | denormal_arg: | |
647 | ||
648 | setcc(0); | |
649 | FPU_copy_to_reg0(&CONST_1, TAG_Valid); | |
1da177e4 | 650 | #ifdef PECULIAR_486 |
3d0d14f9 | 651 | set_precision_flag_down(); /* 80486 appears to do this. */ |
1da177e4 | 652 | #else |
3d0d14f9 | 653 | set_precision_flag_up(); /* Must be up. */ |
1da177e4 | 654 | #endif /* PECULIAR_486 */ |
3d0d14f9 IM |
655 | return 0; |
656 | } | |
657 | } else if (tag == TAG_Zero) { | |
658 | FPU_copy_to_reg0(&CONST_1, TAG_Valid); | |
659 | setcc(0); | |
660 | return 0; | |
1da177e4 | 661 | } |
1da177e4 | 662 | |
3d0d14f9 IM |
663 | if (tag == TAG_Special) |
664 | tag = FPU_Special(st0_ptr); | |
665 | ||
666 | if (tag == TW_Denormal) { | |
667 | if (denormal_operand() < 0) | |
668 | return 1; | |
669 | ||
670 | goto denormal_arg; | |
671 | } else if (tag == TW_Infinity) { | |
672 | /* The 80486 treats infinity as an invalid operand */ | |
673 | arith_invalid(0); | |
674 | return 1; | |
675 | } else { | |
676 | single_arg_error(st0_ptr, tag); /* requires st0_ptr == &st(0) */ | |
677 | return 1; | |
678 | } | |
679 | } | |
1da177e4 | 680 | |
e8d591dc | 681 | static void fcos(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 682 | { |
3d0d14f9 | 683 | f_cos(st0_ptr, st0_tag); |
1da177e4 LT |
684 | } |
685 | ||
e8d591dc | 686 | static void fsincos(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 687 | { |
3d0d14f9 IM |
688 | FPU_REG *st_new_ptr; |
689 | FPU_REG arg; | |
690 | u_char tag; | |
691 | ||
692 | /* Stack underflow has higher priority */ | |
693 | if (st0_tag == TAG_Empty) { | |
694 | FPU_stack_underflow(); /* Puts a QNaN in st(0) */ | |
695 | if (control_word & CW_Invalid) { | |
696 | st_new_ptr = &st(-1); | |
697 | push(); | |
698 | FPU_stack_underflow(); /* Puts a QNaN in the new st(0) */ | |
699 | } | |
700 | return; | |
1da177e4 | 701 | } |
3d0d14f9 IM |
702 | |
703 | if (STACK_OVERFLOW) { | |
704 | FPU_stack_overflow(); | |
705 | return; | |
1da177e4 | 706 | } |
1da177e4 | 707 | |
3d0d14f9 IM |
708 | if (st0_tag == TAG_Special) |
709 | tag = FPU_Special(st0_ptr); | |
710 | else | |
711 | tag = st0_tag; | |
712 | ||
713 | if (tag == TW_NaN) { | |
714 | single_arg_2_error(st0_ptr, TW_NaN); | |
715 | return; | |
716 | } else if (tag == TW_Infinity) { | |
717 | /* The 80486 treats infinity as an invalid operand */ | |
718 | if (arith_invalid(0) >= 0) { | |
719 | /* Masked response */ | |
720 | push(); | |
721 | arith_invalid(0); | |
722 | } | |
723 | return; | |
724 | } | |
725 | ||
726 | reg_copy(st0_ptr, &arg); | |
727 | if (!fsin(st0_ptr, st0_tag)) { | |
728 | push(); | |
729 | FPU_copy_to_reg0(&arg, st0_tag); | |
730 | f_cos(&st(0), st0_tag); | |
731 | } else { | |
732 | /* An error, so restore st(0) */ | |
733 | FPU_copy_to_reg0(&arg, st0_tag); | |
734 | } | |
735 | } | |
1da177e4 LT |
736 | |
737 | /*---------------------------------------------------------------------------*/ | |
738 | /* The following all require two arguments: st(0) and st(1) */ | |
739 | ||
740 | /* A lean, mean kernel for the fprem instructions. This relies upon | |
741 | the division and rounding to an integer in do_fprem giving an | |
742 | exact result. Because of this, rem_kernel() needs to deal only with | |
743 | the least significant 64 bits, the more significant bits of the | |
744 | result must be zero. | |
745 | */ | |
746 | static void rem_kernel(unsigned long long st0, unsigned long long *y, | |
3d0d14f9 | 747 | unsigned long long st1, unsigned long long q, int n) |
1da177e4 | 748 | { |
3d0d14f9 IM |
749 | int dummy; |
750 | unsigned long long x; | |
751 | ||
752 | x = st0 << n; | |
753 | ||
754 | /* Do the required multiplication and subtraction in the one operation */ | |
755 | ||
756 | /* lsw x -= lsw st1 * lsw q */ | |
757 | asm volatile ("mull %4; subl %%eax,%0; sbbl %%edx,%1":"=m" | |
758 | (((unsigned *)&x)[0]), "=m"(((unsigned *)&x)[1]), | |
759 | "=a"(dummy) | |
760 | :"2"(((unsigned *)&st1)[0]), "m"(((unsigned *)&q)[0]) | |
761 | :"%dx"); | |
762 | /* msw x -= msw st1 * lsw q */ | |
763 | asm volatile ("mull %3; subl %%eax,%0":"=m" (((unsigned *)&x)[1]), | |
764 | "=a"(dummy) | |
765 | :"1"(((unsigned *)&st1)[1]), "m"(((unsigned *)&q)[0]) | |
766 | :"%dx"); | |
767 | /* msw x -= lsw st1 * msw q */ | |
768 | asm volatile ("mull %3; subl %%eax,%0":"=m" (((unsigned *)&x)[1]), | |
769 | "=a"(dummy) | |
770 | :"1"(((unsigned *)&st1)[0]), "m"(((unsigned *)&q)[1]) | |
771 | :"%dx"); | |
772 | ||
773 | *y = x; | |
1da177e4 LT |
774 | } |
775 | ||
1da177e4 LT |
776 | /* Remainder of st(0) / st(1) */ |
777 | /* This routine produces exact results, i.e. there is never any | |
778 | rounding or truncation, etc of the result. */ | |
e8d591dc | 779 | static void do_fprem(FPU_REG *st0_ptr, u_char st0_tag, int round) |
1da177e4 | 780 | { |
3d0d14f9 IM |
781 | FPU_REG *st1_ptr = &st(1); |
782 | u_char st1_tag = FPU_gettagi(1); | |
783 | ||
784 | if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid))) { | |
785 | FPU_REG tmp, st0, st1; | |
786 | u_char st0_sign, st1_sign; | |
787 | u_char tmptag; | |
788 | int tag; | |
789 | int old_cw; | |
790 | int expdif; | |
791 | long long q; | |
792 | unsigned short saved_status; | |
793 | int cc; | |
794 | ||
795 | fprem_valid: | |
796 | /* Convert registers for internal use. */ | |
797 | st0_sign = FPU_to_exp16(st0_ptr, &st0); | |
798 | st1_sign = FPU_to_exp16(st1_ptr, &st1); | |
799 | expdif = exponent16(&st0) - exponent16(&st1); | |
800 | ||
801 | old_cw = control_word; | |
802 | cc = 0; | |
803 | ||
804 | /* We want the status following the denorm tests, but don't want | |
805 | the status changed by the arithmetic operations. */ | |
806 | saved_status = partial_status; | |
807 | control_word &= ~CW_RC; | |
808 | control_word |= RC_CHOP; | |
809 | ||
810 | if (expdif < 64) { | |
811 | /* This should be the most common case */ | |
812 | ||
813 | if (expdif > -2) { | |
814 | u_char sign = st0_sign ^ st1_sign; | |
815 | tag = FPU_u_div(&st0, &st1, &tmp, | |
816 | PR_64_BITS | RC_CHOP | 0x3f, | |
817 | sign); | |
818 | setsign(&tmp, sign); | |
819 | ||
820 | if (exponent(&tmp) >= 0) { | |
821 | FPU_round_to_int(&tmp, tag); /* Fortunately, this can't | |
822 | overflow to 2^64 */ | |
823 | q = significand(&tmp); | |
824 | ||
825 | rem_kernel(significand(&st0), | |
826 | &significand(&tmp), | |
827 | significand(&st1), | |
828 | q, expdif); | |
829 | ||
830 | setexponent16(&tmp, exponent16(&st1)); | |
831 | } else { | |
832 | reg_copy(&st0, &tmp); | |
833 | q = 0; | |
834 | } | |
835 | ||
836 | if ((round == RC_RND) | |
837 | && (tmp.sigh & 0xc0000000)) { | |
838 | /* We may need to subtract st(1) once more, | |
839 | to get a result <= 1/2 of st(1). */ | |
840 | unsigned long long x; | |
841 | expdif = | |
842 | exponent16(&st1) - exponent16(&tmp); | |
843 | if (expdif <= 1) { | |
844 | if (expdif == 0) | |
845 | x = significand(&st1) - | |
846 | significand(&tmp); | |
847 | else /* expdif is 1 */ | |
848 | x = (significand(&st1) | |
849 | << 1) - | |
850 | significand(&tmp); | |
851 | if ((x < significand(&tmp)) || | |
852 | /* or equi-distant (from 0 & st(1)) and q is odd */ | |
853 | ((x == significand(&tmp)) | |
854 | && (q & 1))) { | |
855 | st0_sign = !st0_sign; | |
856 | significand(&tmp) = x; | |
857 | q++; | |
858 | } | |
859 | } | |
860 | } | |
861 | ||
862 | if (q & 4) | |
863 | cc |= SW_C0; | |
864 | if (q & 2) | |
865 | cc |= SW_C3; | |
866 | if (q & 1) | |
867 | cc |= SW_C1; | |
868 | } else { | |
869 | control_word = old_cw; | |
870 | setcc(0); | |
871 | return; | |
1da177e4 | 872 | } |
3d0d14f9 IM |
873 | } else { |
874 | /* There is a large exponent difference ( >= 64 ) */ | |
875 | /* To make much sense, the code in this section should | |
876 | be done at high precision. */ | |
877 | int exp_1, N; | |
878 | u_char sign; | |
879 | ||
880 | /* prevent overflow here */ | |
881 | /* N is 'a number between 32 and 63' (p26-113) */ | |
882 | reg_copy(&st0, &tmp); | |
883 | tmptag = st0_tag; | |
884 | N = (expdif & 0x0000001f) + 32; /* This choice gives results | |
885 | identical to an AMD 486 */ | |
886 | setexponent16(&tmp, N); | |
887 | exp_1 = exponent16(&st1); | |
888 | setexponent16(&st1, 0); | |
889 | expdif -= N; | |
890 | ||
891 | sign = getsign(&tmp) ^ st1_sign; | |
892 | tag = | |
893 | FPU_u_div(&tmp, &st1, &tmp, | |
894 | PR_64_BITS | RC_CHOP | 0x3f, sign); | |
895 | setsign(&tmp, sign); | |
896 | ||
897 | FPU_round_to_int(&tmp, tag); /* Fortunately, this can't | |
898 | overflow to 2^64 */ | |
899 | ||
900 | rem_kernel(significand(&st0), | |
901 | &significand(&tmp), | |
902 | significand(&st1), | |
903 | significand(&tmp), exponent(&tmp) | |
904 | ); | |
905 | setexponent16(&tmp, exp_1 + expdif); | |
906 | ||
907 | /* It is possible for the operation to be complete here. | |
908 | What does the IEEE standard say? The Intel 80486 manual | |
909 | implies that the operation will never be completed at this | |
910 | point, and the behaviour of a real 80486 confirms this. | |
911 | */ | |
912 | if (!(tmp.sigh | tmp.sigl)) { | |
913 | /* The result is zero */ | |
914 | control_word = old_cw; | |
915 | partial_status = saved_status; | |
916 | FPU_copy_to_reg0(&CONST_Z, TAG_Zero); | |
917 | setsign(&st0, st0_sign); | |
1da177e4 | 918 | #ifdef PECULIAR_486 |
3d0d14f9 | 919 | setcc(SW_C2); |
1da177e4 | 920 | #else |
3d0d14f9 | 921 | setcc(0); |
1da177e4 | 922 | #endif /* PECULIAR_486 */ |
3d0d14f9 IM |
923 | return; |
924 | } | |
925 | cc = SW_C2; | |
926 | } | |
1da177e4 | 927 | |
3d0d14f9 IM |
928 | control_word = old_cw; |
929 | partial_status = saved_status; | |
930 | tag = FPU_normalize_nuo(&tmp); | |
931 | reg_copy(&tmp, st0_ptr); | |
932 | ||
933 | /* The only condition to be looked for is underflow, | |
934 | and it can occur here only if underflow is unmasked. */ | |
935 | if ((exponent16(&tmp) <= EXP_UNDER) && (tag != TAG_Zero) | |
936 | && !(control_word & CW_Underflow)) { | |
937 | setcc(cc); | |
938 | tag = arith_underflow(st0_ptr); | |
939 | setsign(st0_ptr, st0_sign); | |
940 | FPU_settag0(tag); | |
941 | return; | |
942 | } else if ((exponent16(&tmp) > EXP_UNDER) || (tag == TAG_Zero)) { | |
943 | stdexp(st0_ptr); | |
944 | setsign(st0_ptr, st0_sign); | |
945 | } else { | |
946 | tag = | |
947 | FPU_round(st0_ptr, 0, 0, FULL_PRECISION, st0_sign); | |
948 | } | |
949 | FPU_settag0(tag); | |
950 | setcc(cc); | |
1da177e4 | 951 | |
3d0d14f9 IM |
952 | return; |
953 | } | |
1da177e4 | 954 | |
3d0d14f9 IM |
955 | if (st0_tag == TAG_Special) |
956 | st0_tag = FPU_Special(st0_ptr); | |
957 | if (st1_tag == TAG_Special) | |
958 | st1_tag = FPU_Special(st1_ptr); | |
1da177e4 | 959 | |
3d0d14f9 | 960 | if (((st0_tag == TAG_Valid) && (st1_tag == TW_Denormal)) |
1da177e4 | 961 | || ((st0_tag == TW_Denormal) && (st1_tag == TAG_Valid)) |
3d0d14f9 IM |
962 | || ((st0_tag == TW_Denormal) && (st1_tag == TW_Denormal))) { |
963 | if (denormal_operand() < 0) | |
964 | return; | |
965 | goto fprem_valid; | |
966 | } else if ((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty)) { | |
967 | FPU_stack_underflow(); | |
968 | return; | |
969 | } else if (st0_tag == TAG_Zero) { | |
970 | if (st1_tag == TAG_Valid) { | |
971 | setcc(0); | |
972 | return; | |
973 | } else if (st1_tag == TW_Denormal) { | |
974 | if (denormal_operand() < 0) | |
975 | return; | |
976 | setcc(0); | |
977 | return; | |
978 | } else if (st1_tag == TAG_Zero) { | |
979 | arith_invalid(0); | |
980 | return; | |
981 | } /* fprem(?,0) always invalid */ | |
982 | else if (st1_tag == TW_Infinity) { | |
983 | setcc(0); | |
984 | return; | |
985 | } | |
986 | } else if ((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal)) { | |
987 | if (st1_tag == TAG_Zero) { | |
988 | arith_invalid(0); /* fprem(Valid,Zero) is invalid */ | |
989 | return; | |
990 | } else if (st1_tag != TW_NaN) { | |
991 | if (((st0_tag == TW_Denormal) | |
992 | || (st1_tag == TW_Denormal)) | |
993 | && (denormal_operand() < 0)) | |
994 | return; | |
995 | ||
996 | if (st1_tag == TW_Infinity) { | |
997 | /* fprem(Valid,Infinity) is o.k. */ | |
998 | setcc(0); | |
999 | return; | |
1000 | } | |
1001 | } | |
1002 | } else if (st0_tag == TW_Infinity) { | |
1003 | if (st1_tag != TW_NaN) { | |
1004 | arith_invalid(0); /* fprem(Infinity,?) is invalid */ | |
1005 | return; | |
1006 | } | |
1da177e4 | 1007 | } |
1da177e4 | 1008 | |
3d0d14f9 | 1009 | /* One of the registers must contain a NaN if we got here. */ |
1da177e4 LT |
1010 | |
1011 | #ifdef PARANOID | |
3d0d14f9 IM |
1012 | if ((st0_tag != TW_NaN) && (st1_tag != TW_NaN)) |
1013 | EXCEPTION(EX_INTERNAL | 0x118); | |
1da177e4 LT |
1014 | #endif /* PARANOID */ |
1015 | ||
3d0d14f9 | 1016 | real_2op_NaN(st1_ptr, st1_tag, 0, st1_ptr); |
1da177e4 LT |
1017 | |
1018 | } | |
1019 | ||
1da177e4 | 1020 | /* ST(1) <- ST(1) * log ST; pop ST */ |
e8d591dc | 1021 | static void fyl2x(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 1022 | { |
3d0d14f9 IM |
1023 | FPU_REG *st1_ptr = &st(1), exponent; |
1024 | u_char st1_tag = FPU_gettagi(1); | |
1025 | u_char sign; | |
1026 | int e, tag; | |
1027 | ||
1028 | clear_C1(); | |
1029 | ||
1030 | if ((st0_tag == TAG_Valid) && (st1_tag == TAG_Valid)) { | |
1031 | both_valid: | |
1032 | /* Both regs are Valid or Denormal */ | |
1033 | if (signpositive(st0_ptr)) { | |
1034 | if (st0_tag == TW_Denormal) | |
1035 | FPU_to_exp16(st0_ptr, st0_ptr); | |
1036 | else | |
1037 | /* Convert st(0) for internal use. */ | |
1038 | setexponent16(st0_ptr, exponent(st0_ptr)); | |
1039 | ||
1040 | if ((st0_ptr->sigh == 0x80000000) | |
1041 | && (st0_ptr->sigl == 0)) { | |
1042 | /* Special case. The result can be precise. */ | |
1043 | u_char esign; | |
1044 | e = exponent16(st0_ptr); | |
1045 | if (e >= 0) { | |
1046 | exponent.sigh = e; | |
1047 | esign = SIGN_POS; | |
1048 | } else { | |
1049 | exponent.sigh = -e; | |
1050 | esign = SIGN_NEG; | |
1051 | } | |
1052 | exponent.sigl = 0; | |
1053 | setexponent16(&exponent, 31); | |
1054 | tag = FPU_normalize_nuo(&exponent); | |
1055 | stdexp(&exponent); | |
1056 | setsign(&exponent, esign); | |
1057 | tag = | |
1058 | FPU_mul(&exponent, tag, 1, FULL_PRECISION); | |
1059 | if (tag >= 0) | |
1060 | FPU_settagi(1, tag); | |
1061 | } else { | |
1062 | /* The usual case */ | |
1063 | sign = getsign(st1_ptr); | |
1064 | if (st1_tag == TW_Denormal) | |
1065 | FPU_to_exp16(st1_ptr, st1_ptr); | |
1066 | else | |
1067 | /* Convert st(1) for internal use. */ | |
1068 | setexponent16(st1_ptr, | |
1069 | exponent(st1_ptr)); | |
1070 | poly_l2(st0_ptr, st1_ptr, sign); | |
1071 | } | |
1072 | } else { | |
1073 | /* negative */ | |
1074 | if (arith_invalid(1) < 0) | |
1075 | return; | |
1da177e4 | 1076 | } |
1da177e4 | 1077 | |
3d0d14f9 | 1078 | FPU_pop(); |
1da177e4 | 1079 | |
1da177e4 | 1080 | return; |
1da177e4 | 1081 | } |
1da177e4 | 1082 | |
3d0d14f9 IM |
1083 | if (st0_tag == TAG_Special) |
1084 | st0_tag = FPU_Special(st0_ptr); | |
1085 | if (st1_tag == TAG_Special) | |
1086 | st1_tag = FPU_Special(st1_ptr); | |
1da177e4 | 1087 | |
3d0d14f9 IM |
1088 | if ((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty)) { |
1089 | FPU_stack_underflow_pop(1); | |
1da177e4 | 1090 | return; |
3d0d14f9 IM |
1091 | } else if ((st0_tag <= TW_Denormal) && (st1_tag <= TW_Denormal)) { |
1092 | if (st0_tag == TAG_Zero) { | |
1093 | if (st1_tag == TAG_Zero) { | |
1094 | /* Both args zero is invalid */ | |
1095 | if (arith_invalid(1) < 0) | |
1096 | return; | |
1097 | } else { | |
1098 | u_char sign; | |
1099 | sign = getsign(st1_ptr) ^ SIGN_NEG; | |
1100 | if (FPU_divide_by_zero(1, sign) < 0) | |
1101 | return; | |
1102 | ||
1103 | setsign(st1_ptr, sign); | |
1104 | } | |
1105 | } else if (st1_tag == TAG_Zero) { | |
1106 | /* st(1) contains zero, st(0) valid <> 0 */ | |
1107 | /* Zero is the valid answer */ | |
1108 | sign = getsign(st1_ptr); | |
1109 | ||
1110 | if (signnegative(st0_ptr)) { | |
1111 | /* log(negative) */ | |
1112 | if (arith_invalid(1) < 0) | |
1113 | return; | |
1114 | } else if ((st0_tag == TW_Denormal) | |
1115 | && (denormal_operand() < 0)) | |
1116 | return; | |
1117 | else { | |
1118 | if (exponent(st0_ptr) < 0) | |
1119 | sign ^= SIGN_NEG; | |
1120 | ||
1121 | FPU_copy_to_reg1(&CONST_Z, TAG_Zero); | |
1122 | setsign(st1_ptr, sign); | |
1123 | } | |
1124 | } else { | |
1125 | /* One or both operands are denormals. */ | |
1126 | if (denormal_operand() < 0) | |
1127 | return; | |
1128 | goto both_valid; | |
1129 | } | |
1130 | } else if ((st0_tag == TW_NaN) || (st1_tag == TW_NaN)) { | |
1131 | if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0) | |
1132 | return; | |
1133 | } | |
1134 | /* One or both arg must be an infinity */ | |
1135 | else if (st0_tag == TW_Infinity) { | |
1136 | if ((signnegative(st0_ptr)) || (st1_tag == TAG_Zero)) { | |
1137 | /* log(-infinity) or 0*log(infinity) */ | |
1138 | if (arith_invalid(1) < 0) | |
1139 | return; | |
1140 | } else { | |
1141 | u_char sign = getsign(st1_ptr); | |
1142 | ||
1143 | if ((st1_tag == TW_Denormal) | |
1144 | && (denormal_operand() < 0)) | |
1145 | return; | |
1146 | ||
1147 | FPU_copy_to_reg1(&CONST_INF, TAG_Special); | |
1148 | setsign(st1_ptr, sign); | |
1149 | } | |
1da177e4 | 1150 | } |
3d0d14f9 IM |
1151 | /* st(1) must be infinity here */ |
1152 | else if (((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal)) | |
1153 | && (signpositive(st0_ptr))) { | |
1154 | if (exponent(st0_ptr) >= 0) { | |
1155 | if ((exponent(st0_ptr) == 0) && | |
1156 | (st0_ptr->sigh == 0x80000000) && | |
1157 | (st0_ptr->sigl == 0)) { | |
1158 | /* st(0) holds 1.0 */ | |
1159 | /* infinity*log(1) */ | |
1160 | if (arith_invalid(1) < 0) | |
1161 | return; | |
1162 | } | |
1163 | /* else st(0) is positive and > 1.0 */ | |
1164 | } else { | |
1165 | /* st(0) is positive and < 1.0 */ | |
1da177e4 | 1166 | |
3d0d14f9 IM |
1167 | if ((st0_tag == TW_Denormal) |
1168 | && (denormal_operand() < 0)) | |
1169 | return; | |
1da177e4 | 1170 | |
3d0d14f9 IM |
1171 | changesign(st1_ptr); |
1172 | } | |
1173 | } else { | |
1174 | /* st(0) must be zero or negative */ | |
1175 | if (st0_tag == TAG_Zero) { | |
1176 | /* This should be invalid, but a real 80486 is happy with it. */ | |
1da177e4 LT |
1177 | |
1178 | #ifndef PECULIAR_486 | |
3d0d14f9 IM |
1179 | sign = getsign(st1_ptr); |
1180 | if (FPU_divide_by_zero(1, sign) < 0) | |
1181 | return; | |
1da177e4 LT |
1182 | #endif /* PECULIAR_486 */ |
1183 | ||
3d0d14f9 IM |
1184 | changesign(st1_ptr); |
1185 | } else if (arith_invalid(1) < 0) /* log(negative) */ | |
1186 | return; | |
1da177e4 | 1187 | } |
1da177e4 | 1188 | |
3d0d14f9 | 1189 | FPU_pop(); |
1da177e4 LT |
1190 | } |
1191 | ||
e8d591dc | 1192 | static void fpatan(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 1193 | { |
3d0d14f9 IM |
1194 | FPU_REG *st1_ptr = &st(1); |
1195 | u_char st1_tag = FPU_gettagi(1); | |
1196 | int tag; | |
1da177e4 | 1197 | |
3d0d14f9 IM |
1198 | clear_C1(); |
1199 | if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid))) { | |
1200 | valid_atan: | |
1da177e4 | 1201 | |
3d0d14f9 | 1202 | poly_atan(st0_ptr, st0_tag, st1_ptr, st1_tag); |
1da177e4 | 1203 | |
3d0d14f9 | 1204 | FPU_pop(); |
1da177e4 | 1205 | |
3d0d14f9 IM |
1206 | return; |
1207 | } | |
1da177e4 | 1208 | |
3d0d14f9 IM |
1209 | if (st0_tag == TAG_Special) |
1210 | st0_tag = FPU_Special(st0_ptr); | |
1211 | if (st1_tag == TAG_Special) | |
1212 | st1_tag = FPU_Special(st1_ptr); | |
1da177e4 | 1213 | |
3d0d14f9 | 1214 | if (((st0_tag == TAG_Valid) && (st1_tag == TW_Denormal)) |
1da177e4 | 1215 | || ((st0_tag == TW_Denormal) && (st1_tag == TAG_Valid)) |
3d0d14f9 IM |
1216 | || ((st0_tag == TW_Denormal) && (st1_tag == TW_Denormal))) { |
1217 | if (denormal_operand() < 0) | |
1218 | return; | |
1da177e4 | 1219 | |
3d0d14f9 IM |
1220 | goto valid_atan; |
1221 | } else if ((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty)) { | |
1222 | FPU_stack_underflow_pop(1); | |
1223 | return; | |
1224 | } else if ((st0_tag == TW_NaN) || (st1_tag == TW_NaN)) { | |
1225 | if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) >= 0) | |
1226 | FPU_pop(); | |
1da177e4 | 1227 | return; |
3d0d14f9 IM |
1228 | } else if ((st0_tag == TW_Infinity) || (st1_tag == TW_Infinity)) { |
1229 | u_char sign = getsign(st1_ptr); | |
1230 | if (st0_tag == TW_Infinity) { | |
1231 | if (st1_tag == TW_Infinity) { | |
1232 | if (signpositive(st0_ptr)) { | |
1233 | FPU_copy_to_reg1(&CONST_PI4, TAG_Valid); | |
1234 | } else { | |
1235 | setpositive(st1_ptr); | |
1236 | tag = | |
1237 | FPU_u_add(&CONST_PI4, &CONST_PI2, | |
1238 | st1_ptr, FULL_PRECISION, | |
1239 | SIGN_POS, | |
1240 | exponent(&CONST_PI4), | |
1241 | exponent(&CONST_PI2)); | |
1242 | if (tag >= 0) | |
1243 | FPU_settagi(1, tag); | |
1244 | } | |
1245 | } else { | |
1246 | if ((st1_tag == TW_Denormal) | |
1247 | && (denormal_operand() < 0)) | |
1248 | return; | |
1249 | ||
1250 | if (signpositive(st0_ptr)) { | |
1251 | FPU_copy_to_reg1(&CONST_Z, TAG_Zero); | |
1252 | setsign(st1_ptr, sign); /* An 80486 preserves the sign */ | |
1253 | FPU_pop(); | |
1254 | return; | |
1255 | } else { | |
1256 | FPU_copy_to_reg1(&CONST_PI, TAG_Valid); | |
1257 | } | |
1258 | } | |
1259 | } else { | |
1260 | /* st(1) is infinity, st(0) not infinity */ | |
1261 | if ((st0_tag == TW_Denormal) | |
1262 | && (denormal_operand() < 0)) | |
1263 | return; | |
1da177e4 | 1264 | |
3d0d14f9 | 1265 | FPU_copy_to_reg1(&CONST_PI2, TAG_Valid); |
1da177e4 | 1266 | } |
3d0d14f9 IM |
1267 | setsign(st1_ptr, sign); |
1268 | } else if (st1_tag == TAG_Zero) { | |
1269 | /* st(0) must be valid or zero */ | |
1270 | u_char sign = getsign(st1_ptr); | |
1271 | ||
1272 | if ((st0_tag == TW_Denormal) && (denormal_operand() < 0)) | |
1273 | return; | |
1274 | ||
1275 | if (signpositive(st0_ptr)) { | |
1276 | /* An 80486 preserves the sign */ | |
1277 | FPU_pop(); | |
1278 | return; | |
1da177e4 | 1279 | } |
1da177e4 | 1280 | |
3d0d14f9 IM |
1281 | FPU_copy_to_reg1(&CONST_PI, TAG_Valid); |
1282 | setsign(st1_ptr, sign); | |
1283 | } else if (st0_tag == TAG_Zero) { | |
1284 | /* st(1) must be TAG_Valid here */ | |
1285 | u_char sign = getsign(st1_ptr); | |
1da177e4 | 1286 | |
3d0d14f9 IM |
1287 | if ((st1_tag == TW_Denormal) && (denormal_operand() < 0)) |
1288 | return; | |
1da177e4 | 1289 | |
3d0d14f9 IM |
1290 | FPU_copy_to_reg1(&CONST_PI2, TAG_Valid); |
1291 | setsign(st1_ptr, sign); | |
1292 | } | |
1da177e4 | 1293 | #ifdef PARANOID |
3d0d14f9 IM |
1294 | else |
1295 | EXCEPTION(EX_INTERNAL | 0x125); | |
1da177e4 LT |
1296 | #endif /* PARANOID */ |
1297 | ||
3d0d14f9 IM |
1298 | FPU_pop(); |
1299 | set_precision_flag_up(); /* We do not really know if up or down */ | |
1da177e4 LT |
1300 | } |
1301 | ||
e8d591dc | 1302 | static void fprem(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 1303 | { |
3d0d14f9 | 1304 | do_fprem(st0_ptr, st0_tag, RC_CHOP); |
1da177e4 LT |
1305 | } |
1306 | ||
e8d591dc | 1307 | static void fprem1(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 1308 | { |
3d0d14f9 | 1309 | do_fprem(st0_ptr, st0_tag, RC_RND); |
1da177e4 LT |
1310 | } |
1311 | ||
e8d591dc | 1312 | static void fyl2xp1(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 1313 | { |
3d0d14f9 IM |
1314 | u_char sign, sign1; |
1315 | FPU_REG *st1_ptr = &st(1), a, b; | |
1316 | u_char st1_tag = FPU_gettagi(1); | |
1da177e4 | 1317 | |
3d0d14f9 IM |
1318 | clear_C1(); |
1319 | if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid))) { | |
1320 | valid_yl2xp1: | |
1da177e4 | 1321 | |
3d0d14f9 IM |
1322 | sign = getsign(st0_ptr); |
1323 | sign1 = getsign(st1_ptr); | |
1da177e4 | 1324 | |
3d0d14f9 IM |
1325 | FPU_to_exp16(st0_ptr, &a); |
1326 | FPU_to_exp16(st1_ptr, &b); | |
1da177e4 | 1327 | |
3d0d14f9 IM |
1328 | if (poly_l2p1(sign, sign1, &a, &b, st1_ptr)) |
1329 | return; | |
1da177e4 | 1330 | |
3d0d14f9 IM |
1331 | FPU_pop(); |
1332 | return; | |
1333 | } | |
1da177e4 | 1334 | |
3d0d14f9 IM |
1335 | if (st0_tag == TAG_Special) |
1336 | st0_tag = FPU_Special(st0_ptr); | |
1337 | if (st1_tag == TAG_Special) | |
1338 | st1_tag = FPU_Special(st1_ptr); | |
1da177e4 | 1339 | |
3d0d14f9 | 1340 | if (((st0_tag == TAG_Valid) && (st1_tag == TW_Denormal)) |
1da177e4 | 1341 | || ((st0_tag == TW_Denormal) && (st1_tag == TAG_Valid)) |
3d0d14f9 IM |
1342 | || ((st0_tag == TW_Denormal) && (st1_tag == TW_Denormal))) { |
1343 | if (denormal_operand() < 0) | |
1344 | return; | |
1da177e4 | 1345 | |
3d0d14f9 IM |
1346 | goto valid_yl2xp1; |
1347 | } else if ((st0_tag == TAG_Empty) | (st1_tag == TAG_Empty)) { | |
1348 | FPU_stack_underflow_pop(1); | |
1349 | return; | |
1350 | } else if (st0_tag == TAG_Zero) { | |
1351 | switch (st1_tag) { | |
1352 | case TW_Denormal: | |
1353 | if (denormal_operand() < 0) | |
1354 | return; | |
91be2587 | 1355 | /* fall through */ |
3d0d14f9 IM |
1356 | case TAG_Zero: |
1357 | case TAG_Valid: | |
1358 | setsign(st0_ptr, getsign(st0_ptr) ^ getsign(st1_ptr)); | |
1359 | FPU_copy_to_reg1(st0_ptr, st0_tag); | |
1360 | break; | |
1361 | ||
1362 | case TW_Infinity: | |
1363 | /* Infinity*log(1) */ | |
1364 | if (arith_invalid(1) < 0) | |
1365 | return; | |
1366 | break; | |
1367 | ||
1368 | case TW_NaN: | |
1369 | if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0) | |
1370 | return; | |
1371 | break; | |
1372 | ||
1373 | default: | |
1da177e4 | 1374 | #ifdef PARANOID |
3d0d14f9 IM |
1375 | EXCEPTION(EX_INTERNAL | 0x116); |
1376 | return; | |
1da177e4 | 1377 | #endif /* PARANOID */ |
3d0d14f9 IM |
1378 | break; |
1379 | } | |
1380 | } else if ((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal)) { | |
1381 | switch (st1_tag) { | |
1382 | case TAG_Zero: | |
1383 | if (signnegative(st0_ptr)) { | |
1384 | if (exponent(st0_ptr) >= 0) { | |
1385 | /* st(0) holds <= -1.0 */ | |
1386 | #ifdef PECULIAR_486 /* Stupid 80486 doesn't worry about log(negative). */ | |
1387 | changesign(st1_ptr); | |
1da177e4 | 1388 | #else |
3d0d14f9 IM |
1389 | if (arith_invalid(1) < 0) |
1390 | return; | |
1da177e4 | 1391 | #endif /* PECULIAR_486 */ |
3d0d14f9 IM |
1392 | } else if ((st0_tag == TW_Denormal) |
1393 | && (denormal_operand() < 0)) | |
1394 | return; | |
1395 | else | |
1396 | changesign(st1_ptr); | |
1397 | } else if ((st0_tag == TW_Denormal) | |
1398 | && (denormal_operand() < 0)) | |
1399 | return; | |
1400 | break; | |
1401 | ||
1402 | case TW_Infinity: | |
1403 | if (signnegative(st0_ptr)) { | |
1404 | if ((exponent(st0_ptr) >= 0) && | |
1405 | !((st0_ptr->sigh == 0x80000000) && | |
1406 | (st0_ptr->sigl == 0))) { | |
1407 | /* st(0) holds < -1.0 */ | |
1408 | #ifdef PECULIAR_486 /* Stupid 80486 doesn't worry about log(negative). */ | |
1409 | changesign(st1_ptr); | |
1da177e4 | 1410 | #else |
3d0d14f9 IM |
1411 | if (arith_invalid(1) < 0) |
1412 | return; | |
1da177e4 | 1413 | #endif /* PECULIAR_486 */ |
3d0d14f9 IM |
1414 | } else if ((st0_tag == TW_Denormal) |
1415 | && (denormal_operand() < 0)) | |
1416 | return; | |
1417 | else | |
1418 | changesign(st1_ptr); | |
1419 | } else if ((st0_tag == TW_Denormal) | |
1420 | && (denormal_operand() < 0)) | |
1421 | return; | |
1422 | break; | |
1423 | ||
1424 | case TW_NaN: | |
1425 | if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0) | |
1426 | return; | |
1da177e4 | 1427 | } |
1da177e4 | 1428 | |
3d0d14f9 IM |
1429 | } else if (st0_tag == TW_NaN) { |
1430 | if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0) | |
1431 | return; | |
1432 | } else if (st0_tag == TW_Infinity) { | |
1433 | if (st1_tag == TW_NaN) { | |
1434 | if (real_2op_NaN(st0_ptr, st0_tag, 1, st0_ptr) < 0) | |
1435 | return; | |
1436 | } else if (signnegative(st0_ptr)) { | |
1da177e4 | 1437 | #ifndef PECULIAR_486 |
3d0d14f9 IM |
1438 | /* This should have higher priority than denormals, but... */ |
1439 | if (arith_invalid(1) < 0) /* log(-infinity) */ | |
1440 | return; | |
1da177e4 | 1441 | #endif /* PECULIAR_486 */ |
3d0d14f9 IM |
1442 | if ((st1_tag == TW_Denormal) |
1443 | && (denormal_operand() < 0)) | |
1444 | return; | |
1da177e4 | 1445 | #ifdef PECULIAR_486 |
3d0d14f9 IM |
1446 | /* Denormal operands actually get higher priority */ |
1447 | if (arith_invalid(1) < 0) /* log(-infinity) */ | |
1448 | return; | |
1da177e4 | 1449 | #endif /* PECULIAR_486 */ |
3d0d14f9 IM |
1450 | } else if (st1_tag == TAG_Zero) { |
1451 | /* log(infinity) */ | |
1452 | if (arith_invalid(1) < 0) | |
1453 | return; | |
1454 | } | |
1da177e4 | 1455 | |
3d0d14f9 IM |
1456 | /* st(1) must be valid here. */ |
1457 | ||
1458 | else if ((st1_tag == TW_Denormal) && (denormal_operand() < 0)) | |
1459 | return; | |
1da177e4 | 1460 | |
3d0d14f9 IM |
1461 | /* The Manual says that log(Infinity) is invalid, but a real |
1462 | 80486 sensibly says that it is o.k. */ | |
1463 | else { | |
1464 | u_char sign = getsign(st1_ptr); | |
1465 | FPU_copy_to_reg1(&CONST_INF, TAG_Special); | |
1466 | setsign(st1_ptr, sign); | |
1467 | } | |
1da177e4 | 1468 | } |
1da177e4 | 1469 | #ifdef PARANOID |
3d0d14f9 IM |
1470 | else { |
1471 | EXCEPTION(EX_INTERNAL | 0x117); | |
1472 | return; | |
1473 | } | |
1da177e4 LT |
1474 | #endif /* PARANOID */ |
1475 | ||
3d0d14f9 IM |
1476 | FPU_pop(); |
1477 | return; | |
1da177e4 LT |
1478 | |
1479 | } | |
1480 | ||
e8d591dc | 1481 | static void fscale(FPU_REG *st0_ptr, u_char st0_tag) |
1da177e4 | 1482 | { |
3d0d14f9 IM |
1483 | FPU_REG *st1_ptr = &st(1); |
1484 | u_char st1_tag = FPU_gettagi(1); | |
1485 | int old_cw = control_word; | |
1486 | u_char sign = getsign(st0_ptr); | |
1487 | ||
1488 | clear_C1(); | |
1489 | if (!((st0_tag ^ TAG_Valid) | (st1_tag ^ TAG_Valid))) { | |
1490 | long scale; | |
1491 | FPU_REG tmp; | |
1492 | ||
1493 | /* Convert register for internal use. */ | |
1494 | setexponent16(st0_ptr, exponent(st0_ptr)); | |
1495 | ||
1496 | valid_scale: | |
1497 | ||
1498 | if (exponent(st1_ptr) > 30) { | |
1499 | /* 2^31 is far too large, would require 2^(2^30) or 2^(-2^30) */ | |
1500 | ||
1501 | if (signpositive(st1_ptr)) { | |
1502 | EXCEPTION(EX_Overflow); | |
1503 | FPU_copy_to_reg0(&CONST_INF, TAG_Special); | |
1504 | } else { | |
1505 | EXCEPTION(EX_Underflow); | |
1506 | FPU_copy_to_reg0(&CONST_Z, TAG_Zero); | |
1507 | } | |
1508 | setsign(st0_ptr, sign); | |
1509 | return; | |
1510 | } | |
1da177e4 | 1511 | |
3d0d14f9 IM |
1512 | control_word &= ~CW_RC; |
1513 | control_word |= RC_CHOP; | |
1514 | reg_copy(st1_ptr, &tmp); | |
1515 | FPU_round_to_int(&tmp, st1_tag); /* This can never overflow here */ | |
1516 | control_word = old_cw; | |
1517 | scale = signnegative(st1_ptr) ? -tmp.sigl : tmp.sigl; | |
1518 | scale += exponent16(st0_ptr); | |
1da177e4 | 1519 | |
3d0d14f9 | 1520 | setexponent16(st0_ptr, scale); |
1da177e4 | 1521 | |
3d0d14f9 IM |
1522 | /* Use FPU_round() to properly detect under/overflow etc */ |
1523 | FPU_round(st0_ptr, 0, 0, control_word, sign); | |
1da177e4 | 1524 | |
3d0d14f9 | 1525 | return; |
1da177e4 | 1526 | } |
1da177e4 | 1527 | |
3d0d14f9 IM |
1528 | if (st0_tag == TAG_Special) |
1529 | st0_tag = FPU_Special(st0_ptr); | |
1530 | if (st1_tag == TAG_Special) | |
1531 | st1_tag = FPU_Special(st1_ptr); | |
1532 | ||
1533 | if ((st0_tag == TAG_Valid) || (st0_tag == TW_Denormal)) { | |
1534 | switch (st1_tag) { | |
1535 | case TAG_Valid: | |
1536 | /* st(0) must be a denormal */ | |
1537 | if ((st0_tag == TW_Denormal) | |
1538 | && (denormal_operand() < 0)) | |
1539 | return; | |
1540 | ||
1541 | FPU_to_exp16(st0_ptr, st0_ptr); /* Will not be left on stack */ | |
1542 | goto valid_scale; | |
1543 | ||
1544 | case TAG_Zero: | |
1545 | if (st0_tag == TW_Denormal) | |
1546 | denormal_operand(); | |
1547 | return; | |
1548 | ||
1549 | case TW_Denormal: | |
1550 | denormal_operand(); | |
1551 | return; | |
1552 | ||
1553 | case TW_Infinity: | |
1554 | if ((st0_tag == TW_Denormal) | |
1555 | && (denormal_operand() < 0)) | |
1556 | return; | |
1557 | ||
1558 | if (signpositive(st1_ptr)) | |
1559 | FPU_copy_to_reg0(&CONST_INF, TAG_Special); | |
1560 | else | |
1561 | FPU_copy_to_reg0(&CONST_Z, TAG_Zero); | |
1562 | setsign(st0_ptr, sign); | |
1563 | return; | |
1564 | ||
1565 | case TW_NaN: | |
1566 | real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr); | |
1567 | return; | |
1568 | } | |
1569 | } else if (st0_tag == TAG_Zero) { | |
1570 | switch (st1_tag) { | |
1571 | case TAG_Valid: | |
1572 | case TAG_Zero: | |
1573 | return; | |
1574 | ||
1575 | case TW_Denormal: | |
1576 | denormal_operand(); | |
1577 | return; | |
1578 | ||
1579 | case TW_Infinity: | |
1580 | if (signpositive(st1_ptr)) | |
1581 | arith_invalid(0); /* Zero scaled by +Infinity */ | |
1582 | return; | |
1583 | ||
1584 | case TW_NaN: | |
1585 | real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr); | |
1586 | return; | |
1587 | } | |
1588 | } else if (st0_tag == TW_Infinity) { | |
1589 | switch (st1_tag) { | |
1590 | case TAG_Valid: | |
1591 | case TAG_Zero: | |
1592 | return; | |
1593 | ||
1594 | case TW_Denormal: | |
1595 | denormal_operand(); | |
1596 | return; | |
1597 | ||
1598 | case TW_Infinity: | |
1599 | if (signnegative(st1_ptr)) | |
1600 | arith_invalid(0); /* Infinity scaled by -Infinity */ | |
1601 | return; | |
1602 | ||
1603 | case TW_NaN: | |
1604 | real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr); | |
1605 | return; | |
1606 | } | |
1607 | } else if (st0_tag == TW_NaN) { | |
1608 | if (st1_tag != TAG_Empty) { | |
1609 | real_2op_NaN(st1_ptr, st1_tag, 0, st0_ptr); | |
1610 | return; | |
1611 | } | |
1da177e4 | 1612 | } |
1da177e4 | 1613 | #ifdef PARANOID |
3d0d14f9 IM |
1614 | if (!((st0_tag == TAG_Empty) || (st1_tag == TAG_Empty))) { |
1615 | EXCEPTION(EX_INTERNAL | 0x115); | |
1616 | return; | |
1617 | } | |
1da177e4 LT |
1618 | #endif |
1619 | ||
3d0d14f9 IM |
1620 | /* At least one of st(0), st(1) must be empty */ |
1621 | FPU_stack_underflow(); | |
1da177e4 LT |
1622 | |
1623 | } | |
1624 | ||
1da177e4 LT |
1625 | /*---------------------------------------------------------------------------*/ |
1626 | ||
1627 | static FUNC_ST0 const trig_table_a[] = { | |
3d0d14f9 IM |
1628 | f2xm1, fyl2x, fptan, fpatan, |
1629 | fxtract, fprem1, (FUNC_ST0) fdecstp, (FUNC_ST0) fincstp | |
1da177e4 LT |
1630 | }; |
1631 | ||
1632 | void FPU_triga(void) | |
1633 | { | |
3d0d14f9 | 1634 | (trig_table_a[FPU_rm]) (&st(0), FPU_gettag0()); |
1da177e4 LT |
1635 | } |
1636 | ||
3d0d14f9 IM |
1637 | static FUNC_ST0 const trig_table_b[] = { |
1638 | fprem, fyl2xp1, fsqrt_, fsincos, frndint_, fscale, (FUNC_ST0) fsin, fcos | |
1639 | }; | |
1da177e4 LT |
1640 | |
1641 | void FPU_trigb(void) | |
1642 | { | |
3d0d14f9 | 1643 | (trig_table_b[FPU_rm]) (&st(0), FPU_gettag0()); |
1da177e4 | 1644 | } |