1 /******************************************************************\
2 * *
3 * <math-68881.h> last modified: 23 May 1992. *
4 * *
5 * Copyright (C) 1989 by Matthew Self. *
6 * You may freely distribute verbatim copies of this software *
7 * provided that this copyright notice is retained in all copies. *
8 * You may distribute modifications to this software under the *
9 * conditions above if you also clearly note such modifications *
10 * with their author and date. *
11 * *
12 * Note: errno is not set to EDOM when domain errors occur for *
13 * most of these functions. Rather, it is assumed that the *
14 * 68881's OPERR exception will be enabled and handled *
15 * appropriately by the operating system. Similarly, overflow *
16 * and underflow do not set errno to ERANGE. *
17 * *
18 * Send bugs to Matthew Self (self@bayes.arc.nasa.gov). *
19 * *
20 \******************************************************************/
21
22 /* This file is NOT a part of GCC, just distributed with it. */
23
24 /* If you find this in GCC,
25 please send bug reports to bug-gcc@prep.ai.mit.edu. */
26
27 /* Changed by Richard Stallman:
28 May 1993, add conditional to prevent multiple inclusion.
29 % inserted before a #.
30 New function `hypot' added.
31 Nans written in hex to avoid 0rnan.
32 May 1992, use %! for fpcr register. Break lines before function names.
33 December 1989, add parens around `&' in pow.
34 November 1990, added alternate definition of HUGE_VAL for Sun. */
35
36 /* Changed by Jim Wilson:
37 September 1993, Use #undef before HUGE_VAL instead of #ifdef/#endif. */
38
39 /* Changed by Ian Lance Taylor:
40 September 1994, use extern inline instead of static inline. */
41
42 #ifndef __math_68881
43 #define __math_68881
44
45 #include <errno.h>
46
47 #undef HUGE_VAL
48 #ifdef __sun__
49 /* The Sun assembler fails to handle the hex constant in the usual defn. */
50 #define HUGE_VAL \
51 ({ \
52 static union { int i[2]; double d; } u = { {0x7ff00000, 0} }; \
53 u.d; \
54 })
55 #else
56 #define HUGE_VAL \
57 ({ \
58 double huge_val; \
59 \
60 __asm ("fmove%.d #0x7ff0000000000000,%0" /* Infinity */ \
61 : "=f" (huge_val) \
62 : /* no inputs */); \
63 huge_val; \
64 })
65 #endif
66
67 __inline extern double
68 sin (double x)
69 {
70 double value;
71
72 __asm ("fsin%.x %1,%0"
73 : "=f" (value)
74 : "f" (x));
75 return value;
76 }
77
78 __inline extern double
79 cos (double x)
80 {
81 double value;
82
83 __asm ("fcos%.x %1,%0"
84 : "=f" (value)
85 : "f" (x));
86 return value;
87 }
88
89 __inline extern double
90 tan (double x)
91 {
92 double value;
93
94 __asm ("ftan%.x %1,%0"
95 : "=f" (value)
96 : "f" (x));
97 return value;
98 }
99
100 __inline extern double
101 asin (double x)
102 {
103 double value;
104
105 __asm ("fasin%.x %1,%0"
106 : "=f" (value)
107 : "f" (x));
108 return value;
109 }
110
111 __inline extern double
112 acos (double x)
113 {
114 double value;
115
116 __asm ("facos%.x %1,%0"
117 : "=f" (value)
118 : "f" (x));
119 return value;
120 }
121
122 __inline extern double
123 atan (double x)
124 {
125 double value;
126
127 __asm ("fatan%.x %1,%0"
128 : "=f" (value)
129 : "f" (x));
130 return value;
131 }
132
133 __inline extern double
134 atan2 (double y, double x)
135 {
136 double pi, pi_over_2;
137
138 __asm ("fmovecr%.x #0,%0" /* extended precision pi */
139 : "=f" (pi)
140 : /* no inputs */ );
141 __asm ("fscale%.b #-1,%0" /* no loss of accuracy */
142 : "=f" (pi_over_2)
143 : "0" (pi));
144 if (x > 0)
145 {
146 if (y > 0)
147 {
148 if (x > y)
149 return atan (y / x);
150 else
151 return pi_over_2 - atan (x / y);
152 }
153 else
154 {
155 if (x > -y)
156 return atan (y / x);
157 else
158 return - pi_over_2 - atan (x / y);
159 }
160 }
161 else
162 {
163 if (y < 0)
164 {
165 if (-x > -y)
166 return - pi + atan (y / x);
167 else
168 return - pi_over_2 - atan (x / y);
169 }
170 else
171 {
172 if (-x > y)
173 return pi + atan (y / x);
174 else if (y > 0)
175 return pi_over_2 - atan (x / y);
176 else
177 {
178 double value;
179
180 errno = EDOM;
181 __asm ("fmove%.d #0x7fffffffffffffff,%0" /* quiet NaN */
182 : "=f" (value)
183 : /* no inputs */);
184 return value;
185 }
186 }
187 }
188 }
189
190 __inline extern double
191 sinh (double x)
192 {
193 double value;
194
195 __asm ("fsinh%.x %1,%0"
196 : "=f" (value)
197 : "f" (x));
198 return value;
199 }
200
201 __inline extern double
202 cosh (double x)
203 {
204 double value;
205
206 __asm ("fcosh%.x %1,%0"
207 : "=f" (value)
208 : "f" (x));
209 return value;
210 }
211
212 __inline extern double
213 tanh (double x)
214 {
215 double value;
216
217 __asm ("ftanh%.x %1,%0"
218 : "=f" (value)
219 : "f" (x));
220 return value;
221 }
222
223 __inline extern double
224 atanh (double x)
225 {
226 double value;
227
228 __asm ("fatanh%.x %1,%0"
229 : "=f" (value)
230 : "f" (x));
231 return value;
232 }
233
234 __inline extern double
235 exp (double x)
236 {
237 double value;
238
239 __asm ("fetox%.x %1,%0"
240 : "=f" (value)
241 : "f" (x));
242 return value;
243 }
244
245 __inline extern double
246 expm1 (double x)
247 {
248 double value;
249
250 __asm ("fetoxm1%.x %1,%0"
251 : "=f" (value)
252 : "f" (x));
253 return value;
254 }
255
256 __inline extern double
257 log (double x)
258 {
259 double value;
260
261 __asm ("flogn%.x %1,%0"
262 : "=f" (value)
263 : "f" (x));
264 return value;
265 }
266
267 __inline extern double
268 log1p (double x)
269 {
270 double value;
271
272 __asm ("flognp1%.x %1,%0"
273 : "=f" (value)
274 : "f" (x));
275 return value;
276 }
277
278 __inline extern double
279 log10 (double x)
280 {
281 double value;
282
283 __asm ("flog10%.x %1,%0"
284 : "=f" (value)
285 : "f" (x));
286 return value;
287 }
288
289 __inline extern double
290 sqrt (double x)
291 {
292 double value;
293
294 __asm ("fsqrt%.x %1,%0"
295 : "=f" (value)
296 : "f" (x));
297 return value;
298 }
299
300 __inline extern double
301 hypot (double x, double y)
302 {
303 return sqrt (x*x + y*y);
304 }
305
306 __inline extern double
307 pow (double x, double y)
308 {
309 if (x > 0)
310 return exp (y * log (x));
311 else if (x == 0)
312 {
313 if (y > 0)
314 return 0.0;
315 else
316 {
317 double value;
318
319 errno = EDOM;
320 __asm ("fmove%.d #0x7fffffffffffffff,%0" /* quiet NaN */
321 : "=f" (value)
322 : /* no inputs */);
323 return value;
324 }
325 }
326 else
327 {
328 double temp;
329
330 __asm ("fintrz%.x %1,%0"
331 : "=f" (temp) /* integer-valued float */
332 : "f" (y));
333 if (y == temp)
334 {
335 int i = (int) y;
336
337 if ((i & 1) == 0) /* even */
338 return exp (y * log (-x));
339 else
340 return - exp (y * log (-x));
341 }
342 else
343 {
344 double value;
345
346 errno = EDOM;
347 __asm ("fmove%.d #0x7fffffffffffffff,%0" /* quiet NaN */
348 : "=f" (value)
349 : /* no inputs */);
350 return value;
351 }
352 }
353 }
354
355 __inline extern double
356 fabs (double x)
357 {
358 double value;
359
360 __asm ("fabs%.x %1,%0"
361 : "=f" (value)
362 : "f" (x));
363 return value;
364 }
365
366 __inline extern double
367 ceil (double x)
368 {
369 int rounding_mode, round_up;
370 double value;
371
372 __asm volatile ("fmove%.l %!,%0"
373 : "=dm" (rounding_mode)
374 : /* no inputs */ );
375 round_up = rounding_mode | 0x30;
376 __asm volatile ("fmove%.l %0,%!"
377 : /* no outputs */
378 : "dmi" (round_up));
379 __asm volatile ("fint%.x %1,%0"
380 : "=f" (value)
381 : "f" (x));
382 __asm volatile ("fmove%.l %0,%!"
383 : /* no outputs */
384 : "dmi" (rounding_mode));
385 return value;
386 }
387
388 __inline extern double
389 floor (double x)
390 {
391 int rounding_mode, round_down;
392 double value;
393
394 __asm volatile ("fmove%.l %!,%0"
395 : "=dm" (rounding_mode)
396 : /* no inputs */ );
397 round_down = (rounding_mode & ~0x10)
398 | 0x20;
399 __asm volatile ("fmove%.l %0,%!"
400 : /* no outputs */
401 : "dmi" (round_down));
402 __asm volatile ("fint%.x %1,%0"
403 : "=f" (value)
404 : "f" (x));
405 __asm volatile ("fmove%.l %0,%!"
406 : /* no outputs */
407 : "dmi" (rounding_mode));
408 return value;
409 }
410
411 __inline extern double
412 rint (double x)
413 {
414 int rounding_mode, round_nearest;
415 double value;
416
417 __asm volatile ("fmove%.l %!,%0"
418 : "=dm" (rounding_mode)
419 : /* no inputs */ );
420 round_nearest = rounding_mode & ~0x30;
421 __asm volatile ("fmove%.l %0,%!"
422 : /* no outputs */
423 : "dmi" (round_nearest));
424 __asm volatile ("fint%.x %1,%0"
425 : "=f" (value)
426 : "f" (x));
427 __asm volatile ("fmove%.l %0,%!"
428 : /* no outputs */
429 : "dmi" (rounding_mode));
430 return value;
431 }
432
433 __inline extern double
434 fmod (double x, double y)
435 {
436 double value;
437
438 __asm ("fmod%.x %2,%0"
439 : "=f" (value)
440 : "0" (x),
441 "f" (y));
442 return value;
443 }
444
445 __inline extern double
446 drem (double x, double y)
447 {
448 double value;
449
450 __asm ("frem%.x %2,%0"
451 : "=f" (value)
452 : "0" (x),
453 "f" (y));
454 return value;
455 }
456
457 __inline extern double
458 scalb (double x, int n)
459 {
460 double value;
461
462 __asm ("fscale%.l %2,%0"
463 : "=f" (value)
464 : "0" (x),
465 "dmi" (n));
466 return value;
467 }
468
469 __inline extern double
470 logb (double x)
471 {
472 double exponent;
473
474 __asm ("fgetexp%.x %1,%0"
475 : "=f" (exponent)
476 : "f" (x));
477 return exponent;
478 }
479
480 __inline extern double
481 ldexp (double x, int n)
482 {
483 double value;
484
485 __asm ("fscale%.l %2,%0"
486 : "=f" (value)
487 : "0" (x),
488 "dmi" (n));
489 return value;
490 }
491
492 __inline extern double
493 frexp (double x, int *exp)
494 {
495 double float_exponent;
496 int int_exponent;
497 double mantissa;
498
499 __asm ("fgetexp%.x %1,%0"
500 : "=f" (float_exponent) /* integer-valued float */
501 : "f" (x));
502 int_exponent = (int) float_exponent;
503 __asm ("fgetman%.x %1,%0"
504 : "=f" (mantissa) /* 1.0 <= mantissa < 2.0 */
505 : "f" (x));
506 if (mantissa != 0)
507 {
508 __asm ("fscale%.b #-1,%0"
509 : "=f" (mantissa) /* mantissa /= 2.0 */
510 : "0" (mantissa));
511 int_exponent += 1;
512 }
513 *exp = int_exponent;
514 return mantissa;
515 }
516
517 __inline extern double
518 modf (double x, double *ip)
519 {
520 double temp;
521
522 __asm ("fintrz%.x %1,%0"
523 : "=f" (temp) /* integer-valued float */
524 : "f" (x));
525 *ip = temp;
526 return x - temp;
527 }
528
529 #endif /* not __math_68881 */