gcc/ginclude/math-68881.h

   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 */