sysdeps/m68k/fpu/__math.h

   1 /* Copyright (C) 1991 Free Software Foundation, Inc.
   2 This file is part of the GNU C Library.
   3
   4 The GNU C Library is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU Library General Public License as
   6 published by the Free Software Foundation; either version 2 of the
   7 License, or (at your option) any later version.
   8
   9 The GNU C Library is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 Library General Public License for more details.
  13
  14 You should have received a copy of the GNU Library General Public
  15 License along with the GNU C Library; see the file COPYING.LIB.  If
  16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  17 Cambridge, MA 02139, USA.  */
  18
  19 #ifdef  __GNUC__
  20
  21 /* IGNORE($ */
  22 #ifdef  __STDC__
  23 /* $) IFANSI($ */
  24 #define __m81_s(x)      #x
  25 #define __m81_ul(x)     __ ## x
  26 /* $) IGNORE($ */
  27 #else
  28 /* $) IFTRAD($ */
  29 #define __m81_s(x)      "x"
  30 #define __m81_ul(x)     __/**/x
  31 /* $) IGNORE($ */
  32 #endif
  33 /* $) */
  34
  35 #ifdef  __NO_MATH_INLINES
  36 #define __m81_u(x)      __m81_ul(x)
  37 #else
  38 #define __m81_u(x)      x
  39 #define __MATH_INLINES  1
  40 #endif
  41
  42 #define __inline_mathop2(func, op)                                            \
  43   extern __inline __const double                                              \
  44   __m81_u(func)(double __mathop_x)                                            \
  45   {                                                                           \
  46     double __result;                                                          \
  47     __asm("f" __m81_s(op) "%.x %1, %0" : "=f" (__result) : "f" (__mathop_x)); \
  48     return __result;                                                          \
  49   }
  50 #define __inline_mathop(op)             __inline_mathop2(op, op)
  51
  52 __inline_mathop(acos)
  53 __inline_mathop(asin)
  54 __inline_mathop(atan)
  55 __inline_mathop(cos)
  56 __inline_mathop(sin)
  57 __inline_mathop(tan)
  58 __inline_mathop(cosh)
  59 __inline_mathop(sinh)
  60 __inline_mathop(tanh)
  61 __inline_mathop2(exp, etox)
  62 __inline_mathop2(fabs, abs)
  63 __inline_mathop(log10)
  64 __inline_mathop2(log, logn)
  65 __inline_mathop2(floor, intrz)
  66 __inline_mathop(sqrt)
  67
  68 #ifdef  __USE_MISC
  69 __inline_mathop2(rint, int)
  70 __inline_mathop2(expm1, etoxm1)
  71 __inline_mathop2(log1p, lognp1)
  72 __inline_mathop(atanh)
  73 #endif
  74
  75 extern __inline __const double
  76 __m81_u(__drem)(double __x, double __y)
  77 {
  78   double __result;
  79   __asm("frem%.x %1, %0" : "=f" (__result) : "f" (__y), "0" (__x));
  80   return __result;
  81 }
  82
  83 extern __inline __const double
  84 __m81_u(__scalb)(double __x, int __n)
  85 {
  86   double __result;
  87   if (__x == 0.0)
  88     __result = __x;
  89   else
  90     __asm("fscale%.l %1, %0" : "=f" (__result) : "g" (__n), "0" (__x));
  91   return __result;
  92 }
  93
  94 extern __inline __const double
  95 __m81_u(ldexp)(double __x, int __e)
  96 {
  97   double __result;
  98   double __double_e = (double) __e;
  99   __asm("fscale%.x %1, %0" : "=f" (__result) : "f" (__double_e), "0" (__x));
 100   return __result;
 101 }
 102
 103 extern __inline __const double
 104 __m81_u(fmod)(double __x, double __y)
 105 {
 106   double __result;
 107   __asm("fmod%.x %1, %0" : "=f" (__result) : "f" (__y), "0" (__x));
 108   return __result;
 109 }
 110
 111 extern __inline double
 112 __m81_u(frexp)(double __value, int *__expptr)
 113 {
 114   double __mantissa, __exponent;
 115   __asm("fgetexp%.x %1, %0" : "=f" (__exponent) : "f" (__value));
 116   __asm("fgetman%.x %1, %0" : "=f" (__mantissa) : "f" (__value));
 117   *__expptr = (int) __exponent;
 118   return __mantissa;
 119 }
 120
 121 extern __inline __const double
 122 __m81_u(pow)(double __x, double __y)
 123 {
 124   double __result;
 125   if (__y == 0.0 || __x == 1.0)
 126     __result = 1.0;
 127   else if (__y == 1.0)
 128     __result = __x;
 129   else if (__y == 2.0)
 130     __result = __x * __x;
 131   else if (__x == 10.0)
 132     __asm("ftentox%.x %1, %0" : "=f" (__result) : "f" (__y));
 133   else if (__x == 2.0)
 134     __asm("ftwotox%.x %1, %0" : "=f" (__result) : "f" (__y));
 135   else
 136     __result = __m81_u(exp)(__y * __m81_u(log)(__x));
 137   return __result;
 138 }
 139
 140 extern __inline __const double
 141 __m81_u(ceil)(double __x)
 142 {
 143   double __result;
 144   unsigned long int __ctrl_reg;
 145   __asm("fmove%.l fpcr, %0" : "=g" (__ctrl_reg));
 146   /* Set rounding towards positive infinity.  */
 147   __asm("fmove%.l %0, fpcr" : /* No outputs.  */ : "g" (__ctrl_reg | 0x30));
 148   /* Convert X to an integer, using +Inf rounding.  */
 149   __asm("fint%.x %1, %0" : "=f" (__result) : "f" (__x));
 150   /* Restore the previous rounding mode.  */
 151   __asm("fmove%.l %0, fpcr" : /* No outputs.  */ : "g" (__ctrl_reg));
 152   return __result;
 153 }
 154
 155 extern __inline double
 156 __m81_u(modf)(double __value, double *__iptr)
 157 {
 158   double __modf_int = __m81_u(floor)(__value);
 159   *__iptr = __modf_int;
 160   return __value - __modf_int;
 161 }
 162
 163 extern __inline int
 164 __m81_u(__isinf)(double __value)
 165 {
 166   /* There is no branch-condition for infinity,
 167      so we must extract and examine the condition codes manually.  */
 168   unsigned long int __fpsr;
 169   __asm("ftst%.x %1\n"
 170         "fmove%.l fpsr, %0" : "=g" (__fpsr) : "f" (__value));
 171   return (__fpsr & (2 << (3 * 8))) ? (__value < 0 ? -1 : 1) : 0;
 172 }
 173
 174 extern __inline int
 175 __m81_u(__isnan)(double __value)
 176 {
 177   char __result;
 178   __asm("ftst%.x %1\n"
 179         "fsun %0" : "=g" (__result) : "f" (__value));
 180   return __result;
 181 }
 182
 183 #endif  /* GCC.  */