This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[v3] Use GCC's math builtins in std_cmath.h


My apologies to Ben for taking so long with this.  The following patch
standardizes libstdc++-v3/include/std_cmath.h to consistently use
__builtin_foo for mathematical functions, following Kaveh's work to
support all of C99's and BSD's math functions as GCC builtins.

It then turns out that doing this, std_cmath no longer needs to provide
function prototypes or using directives for the C library's versions in
the __gnu_cxx::__c99_binding namespace.  I'm not sure if this adversely
affects the ABI, but the patch below simply removes these statements
now that they're no longer needed.

Finally, I also include stub implementations of the float and long double
forms of functions that we now require but aren't provided by the system
library, and that we don't already have stubs for in libmath/stubs.c.


The following patch has been tested on i686-pc-linux-gnu with a complete
"make bootstrap", all languages except treelang, and regression tested
with a top-level "make -k check" with no new failures.  Then to test that
there were no typos in "stubs.c", I also bootstrapped all languages except
treelang and Ada on sparc-sun-solaris2.8 which provides neither float nor
long double forms of C99's math functions, again without problems.


Although this clean-up isn't a bug-fix per se, it could be seen as
a step towards resolving PRs libstdc++/7706 and libstdc++/11706.
Ok for mainline??



2003-11-14  Roger Sayle  <roger@eyesopen.com>

	* include/std_cmath.h: Don't import C99's float transcendentals
	into the __gnu_cxx::__c99_binding namespace.
	(acos, asin, atan, atan2, ceil, cosh, exp, floor, fmod, frexp,
	ldexp, log, log10, modf, pow, sinh, tan, tanh): Implement using
	GCC's math builtins, i.e. __builtin_foo.
	* libmath/stubs.c (acosf, acosl, asinf, asinl, atanf, atanl,
	ceilf, ceill, floorf, floorl, fmodf, fmodl, frexpf, frexpl,
	ldexpf, ldexpl, modff, modfl): Provide stub implementations.


Index: include/c_std/std_cmath.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/c_std/std_cmath.h,v
retrieving revision 1.12
diff -c -3 -p -r1.12 std_cmath.h
*** include/c_std/std_cmath.h	30 Jul 2003 16:51:50 -0000	1.12
--- include/c_std/std_cmath.h	14 Nov 2003 04:40:49 -0000
***************
*** 77,166 ****
  #undef tan
  #undef tanh

- // ...and in the darkness bind them...
- namespace __gnu_cxx
- {
-   namespace  __c99_binding
-   {
- #if _GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_CHECK || \
-     _GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC
-     extern "C" float (acosf)(float);
-     extern "C" float (asinf)(float);
-     extern "C" float (atanf)(float);
-     extern "C" float (atan2f)(float, float);
-     extern "C" float (ceilf)(float);
-     extern "C" float (coshf)(float);
-     extern "C" float (expf)(float);
-     extern "C" float (floorf)(float);
-     extern "C" float (fmodf)(float, float);
-     extern "C" float (frexpf)(float, int*);
-     extern "C" float (ldexpf)(float, int);
-     extern "C" float (logf)(float);
-     extern "C" float (log10f)(float);
-     extern "C" float (modff)(float, float*);
-     extern "C" float (powf)(float, float);
-     extern "C" float (sinhf)(float);
-     extern "C" float (tanf)(float);
-     extern "C" float (tanhf)(float);
- #endif
- #if !_GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC
- #if _GLIBCXX_HAVE_ACOSF
-     using ::acosf;
- #endif
- #if _GLIBCXX_HAVE_ASINF
-     using ::asinf;
- #endif
- #if _GLIBCXX_HAVE_ATANF
-     using ::atanf;
- #endif
- #if _GLIBCXX_HAVE_ATAN2F
-     using ::atan2f;
- #endif
- #if _GLIBCXX_HAVE_CEILF
-     using ::ceilf;
- #endif
- #if _GLIBCXX_HAVE_COSHF
-     using ::coshf;
- #endif
- #if _GLIBCXX_HAVE_EXPF
-     using ::expf;
- #endif
- #if _GLIBCXX_HAVE_FLOORF
-     using ::floorf;
- #endif
- #if _GLIBCXX_HAVE_FMODF
-     using ::fmodf;
- #endif
- #if _GLIBCXX_HAVE_FREXPF
-     using ::frexpf;
- #endif
- #if _GLIBCXX_HAVE_LDEXPF
-     using ::ldexpf;
- #endif
- #if _GLIBCXX_HAVE_LOGF
-     using ::logf;
- #endif
- #if _GLIBCXX_HAVE_LOG10F
-     using ::log10f;
- #endif
- #if _GLIBCXX_HAVE_MODFF
-     using ::modff;
- #endif
- #if _GLIBCXX_HAVE_POWF
-     using ::powf;
- #endif
- #if _GLIBCXX_HAVE_SINHF
-     using ::sinhf;
- #endif
- #if _GLIBCXX_HAVE_TANF
-     using ::tanf;
- #endif
- #if _GLIBCXX_HAVE_TANHF
-     using ::tanhf;
- #endif
- #endif /* _GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC */
-   }
- }

  namespace std
  {
--- 77,82 ----
*************** namespace std
*** 180,304 ****
    abs(long double __x)
    { return __builtin_fabsl(__x); }

- #if _GLIBCXX_HAVE_ACOSF
-   inline float
-   acos(float __x) { return __gnu_cxx::__c99_binding::acosf(__x); }
- #else
-   inline float
-   acos(float __x) { return ::acos(static_cast<double>(__x)); }
- #endif
-
    using ::acos;
!
! #if _GLIBCXX_HAVE_ACOSL
!   inline long double
!   acos(long double __x) { return ::acosl(__x); }
! #else
!   inline long double
!   acos(long double __x) { return ::acos(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      acos(_Tp __x)
      {
!       return ::acos(static_cast<double>(__x));
      }

    using ::asin;

- #if _GLIBCXX_HAVE_ASINF
-   inline float
-   asin(float __x) { return __gnu_cxx::__c99_binding::asinf(__x); }
- #else
    inline float
!   asin(float __x) { return ::asin(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_ASINL
    inline long double
!   asin(long double __x) { return ::asinl(__x); }
! #else
!   inline long double
!   asin(long double __x) { return ::asin(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      asin(_Tp __x)
!     { return ::asin(static_cast<double>(__x)); }

    using ::atan;

- #if _GLIBCXX_HAVE_ATANF
-   inline float
-   atan(float __x) { return __gnu_cxx::__c99_binding::atanf(__x); }
- #else
    inline float
!   atan(float __x) { return ::atan(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_ATANL
-   inline long double
-   atan(long double __x) { return ::atanl(__x); }
- #else
    inline long double
!   atan(long double __x) { return ::atan(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      atan(_Tp __x)
!     { return ::atan(static_cast<double>(__x)); }

    using ::atan2;

- #if _GLIBCXX_HAVE_ATAN2F
-   inline float
-   atan2(float __y, float __x) { return __gnu_cxx::__c99_binding::atan2f(__y, __x); }
- #else
    inline float
    atan2(float __y, float __x)
!   { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_ATAN2L
-   inline long double
-   atan2(long double __y, long double __x) { return ::atan2l(__y, __x); }
- #else
    inline long double
!   atan2(long double __y, long double __x)
!   { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
! #endif

    template<typename _Tp, typename _Up>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type
                                          && __is_integer<_Up>::_M_type>::_M_type
!     atan2(_Tp __x, _Up __y)
!     { return ::atan2(static_cast<double>(__x), static_cast<double>(__y)); }

    using ::ceil;

- #if _GLIBCXX_HAVE_CEILF
-   inline float
-   ceil(float __x) { return __gnu_cxx::__c99_binding::ceilf(__x); }
- #else
    inline float
!   ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_CEILL
    inline long double
!   ceil(long double __x) { return ::ceill(__x); }
! #else
!   inline long double
!   ceil(long double __x) { return ::ceil(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      ceil(_Tp __x)
!     { return ::ceil(static_cast<double>(__x)); }

    using ::cos;

--- 96,178 ----
    abs(long double __x)
    { return __builtin_fabsl(__x); }

    using ::acos;
!
!   inline float
!   acos(float __x)
!   { return __builtin_acosf(__x); }
!
!   inline long double
!   acos(long double __x)
!   { return __builtin_acosl(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      acos(_Tp __x)
      {
!       return __builtin_acos(__x);
      }

    using ::asin;

    inline float
!   asin(float __x)
!   { return __builtin_asinf(__x); }

    inline long double
!   asin(long double __x)
!   { return __builtin_asinl(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      asin(_Tp __x)
!     { return __builtin_asin(__x); }

    using ::atan;

    inline float
!   atan(float __x)
!   { return __builtin_atanf(__x); }

    inline long double
!   atan(long double __x)
!   { return __builtin_atanl(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      atan(_Tp __x)
!     { return __builtin_atan(__x); }

    using ::atan2;

    inline float
    atan2(float __y, float __x)
!   { return __builtin_atan2f(__y, __x); }

    inline long double
!   atan2(long double __y, long double __x)
!   { return __builtin_atan2l(__y, __x); }

    template<typename _Tp, typename _Up>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type
                                          && __is_integer<_Up>::_M_type>::_M_type
!     atan2(_Tp __y, _Up __x)
!     { return __builtin_atan2(__y, __x); }

    using ::ceil;

    inline float
!   ceil(float __x)
!   { return __builtin_ceilf(__x); }

    inline long double
!   ceil(long double __x)
!   { return __builtin_ceill(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      ceil(_Tp __x)
!     { return __builtin_ceil(__x); }

    using ::cos;

*************** namespace std
*** 317,365 ****

    using ::cosh;

- #if _GLIBCXX_HAVE_COSHF
-   inline float
-   cosh(float __x) { return __gnu_cxx::__c99_binding::coshf(__x); }
- #else
    inline float
!   cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_COSHL
-   inline long double
-   cosh(long double __x) { return ::coshl(__x); }
- #else
    inline long double
!   cosh(long double __x) { return ::cosh(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      cosh(_Tp __x)
!     { return ::cosh(static_cast<double>(__x)); }

    using ::exp;

- #if _GLIBCXX_HAVE_EXPF
    inline float
!   exp(float __x) { return __gnu_cxx::__c99_binding::expf(__x); }
! #else
!   inline float
!   exp(float __x) { return ::exp(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_EXPL
-   inline long double
-   exp(long double __x) { return ::expl(__x); }
- #else
    inline long double
!   exp(long double __x) { return ::exp(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      exp(_Tp __x)
!     { return ::exp(static_cast<double>(__x)); }

    using ::fabs;

--- 191,223 ----

    using ::cosh;

    inline float
!   cosh(float __x)
!   { return __builtin_coshf(__x); }

    inline long double
!   cosh(long double __x)
!   { return __builtin_coshl(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      cosh(_Tp __x)
!     { return __builtin_cosh(__x); }

    using ::exp;

    inline float
!   exp(float __x)
!   { return __builtin_expf(__x); }

    inline long double
!   exp(long double __x)
!   { return __builtin_expl(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      exp(_Tp __x)
!     { return __builtin_exp(__x); }

    using ::fabs;

*************** namespace std
*** 378,548 ****

    using ::floor;

- #if _GLIBCXX_HAVE_FLOORF
    inline float
!   floor(float __x) { return __gnu_cxx::__c99_binding::floorf(__x); }
! #else
!   inline float
!   floor(float __x) { return ::floor(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_FLOORL
-   inline long double
-   floor(long double __x) { return ::floorl(__x); }
- #else
    inline long double
!   floor(long double __x) { return ::floor(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      floor(_Tp __x)
!     { return ::floor(static_cast<double>(__x)); }

    using ::fmod;

- #if _GLIBCXX_HAVE_FMODF
-   inline float
-   fmod(float __x, float __y) { return __gnu_cxx::__c99_binding::fmodf(__x, __y); }
- #else
    inline float
    fmod(float __x, float __y)
!   { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
! #endif

- #if _GLIBCXX_HAVE_FMODL
    inline long double
!   fmod(long double __x, long double __y) { return ::fmodl(__x, __y); }
! #else
!   inline long double
!   fmod(long double __x, long double __y)
!   { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
! #endif

    using ::frexp;

- #if _GLIBCXX_HAVE_FREXPF
-   inline float
-   frexp(float __x, int* __exp) { return __gnu_cxx::__c99_binding::frexpf(__x, __exp); }
- #else
    inline float
!   frexp(float __x, int* __exp) { return ::frexp(__x, __exp); }
! #endif

- #if _GLIBCXX_HAVE_FREXPL
-   inline long double
-   frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); }
- #else
    inline long double
!   frexp(long double __x, int* __exp)
!   { return ::frexp(static_cast<double>(__x), __exp); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      frexp(_Tp __x, int* __exp)
!     { return ::frexp(static_cast<double>(__x), __exp); }

    using ::ldexp;

- #if _GLIBCXX_HAVE_LDEXPF
-   inline float
-   ldexp(float __x, int __exp) { return __gnu_cxx::__c99_binding::ldexpf(__x, __exp); }
- #else
    inline float
    ldexp(float __x, int __exp)
!   { return ::ldexp(static_cast<double>(__x), __exp); }
! #endif

- #if _GLIBCXX_HAVE_LDEXPL
-   inline long double
-   ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); }
- #else
    inline long double
!   ldexp(long double __x, int __exp)
!   { return ::ldexp(static_cast<double>(__x), __exp); }
! #endif

    template<typename _Tp>
    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
    ldexp(_Tp __x, int __exp)
!   { return ::ldexp(static_cast<double>(__x), __exp); }

    using ::log;

- #if _GLIBCXX_HAVE_LOGF
    inline float
!   log(float __x) { return __gnu_cxx::__c99_binding::logf(__x); }
! #else
!   inline float log(float __x)
!   { return ::log(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_LOGL
-   inline long double
-   log(long double __x) { return ::logl(__x); }
- #else
    inline long double
!   log(long double __x) { return ::log(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      log(_Tp __x)
!     { return ::log(static_cast<double>(__x)); }

    using ::log10;

- #if _GLIBCXX_HAVE_LOG10F
    inline float
!   log10(float __x) { return __gnu_cxx::__c99_binding::log10f(__x); }
! #else
!   inline float
!   log10(float __x) { return ::log10(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_LOG10L
-   inline long double
-   log10(long double __x) { return ::log10l(__x); }
- #else
    inline long double
!   log10(long double __x) { return ::log10(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      log10(_Tp __x)
!     { return ::log10(static_cast<double>(__x)); }

    using ::modf;

- #if _GLIBCXX_HAVE_MODFF
-   inline float
-   modf(float __x, float* __iptr) { return __gnu_cxx::__c99_binding::modff(__x, __iptr); }
- #else
    inline float
    modf(float __x, float* __iptr)
!   {
!     double __tmp;
!     double __res = ::modf(static_cast<double>(__x), &__tmp);
!     *__iptr = static_cast<float>(__tmp);
!     return __res;
!   }
! #endif
!
! #if _GLIBCXX_HAVE_MODFL
!   inline long double
!   modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
! #else
!   inline long double
!   modf(long double __x, long double* __iptr)
!   {
!     double __tmp;
!     double __res = ::modf(static_cast<double>(__x), &__tmp);
!     * __iptr = static_cast<long double>(__tmp);
!     return __res;
!   }
! #endif

    template<typename _Tp>
      inline _Tp
--- 236,333 ----

    using ::floor;

    inline float
!   floor(float __x)
!   { return __builtin_floorf(__x); }

    inline long double
!   floor(long double __x)
!   { return __builtin_floorl(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      floor(_Tp __x)
!     { return __builtin_floor(__x); }

    using ::fmod;

    inline float
    fmod(float __x, float __y)
!   { return __builtin_fmodf(__x, __y); }

    inline long double
!   fmod(long double __x, long double __y)
!   { return __builtin_fmodl(__x, __y); }

    using ::frexp;

    inline float
!   frexp(float __x, int* __exp)
!   { return __builtin_frexpf(__x, __exp); }

    inline long double
!   frexp(long double __x, int* __exp)
!   { return __builtin_frexpl(__x, __exp); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      frexp(_Tp __x, int* __exp)
!     { return __builtin_frexp(__x, __exp); }

    using ::ldexp;

    inline float
    ldexp(float __x, int __exp)
!   { return __builtin_ldexpf(__x, __exp); }

    inline long double
!   ldexp(long double __x, int __exp)
!   { return __builtin_ldexpl(__x, __exp); }

    template<typename _Tp>
    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
    ldexp(_Tp __x, int __exp)
!   { return __builtin_ldexp(__x, __exp); }

    using ::log;

    inline float
!   log(float __x)
!   { return __builtin_logf(__x); }

    inline long double
!   log(long double __x)
!   { return __builtin_logl(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      log(_Tp __x)
!     { return __builtin_log(__x); }

    using ::log10;

    inline float
!   log10(float __x)
!   { return __builtin_log10f(__x); }

    inline long double
!   log10(long double __x)
!   { return __builtin_log10l(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      log10(_Tp __x)
!     { return __builtin_log10(__x); }

    using ::modf;

    inline float
    modf(float __x, float* __iptr)
!   { return __builtin_modff(__x, __iptr); }
!
!   inline long double
!   modf(long double __x, long double* __iptr)
!   { return __builtin_modfl(__x, __iptr); }

    template<typename _Tp>
      inline _Tp
*************** namespace std
*** 555,577 ****

    using ::pow;

- #if _GLIBCXX_HAVE_POWF
-   inline float
-   pow(float __x, float __y) { return __gnu_cxx::__c99_binding::powf(__x, __y); }
- #else
    inline float
    pow(float __x, float __y)
!   { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
! #endif

- #if _GLIBCXX_HAVE_POWL
-   inline long double
-   pow(long double __x, long double __y) { return ::powl(__x, __y); }
- #else
    inline long double
!   pow(long double __x, long double __y)
!   { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
! #endif

    inline double
    pow(double __x, int __i)
--- 340,352 ----

    using ::pow;

    inline float
    pow(float __x, float __y)
!   { return __builtin_powf(__x, __y); }

    inline long double
!   pow(long double __x, long double __y)
!   { return __builtin_powl(__x, __y); }

    inline double
    pow(double __x, int __i)
*************** namespace std
*** 602,627 ****

    using ::sinh;

- #if _GLIBCXX_HAVE_SINHF
-   inline float
-   sinh(float __x) { return __gnu_cxx::__c99_binding::sinhf(__x); }
- #else
    inline float
!   sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_SINHL
    inline long double
!   sinh(long double __x) { return ::sinhl(__x); }
! #else
!   inline long double
!   sinh(long double __x) { return ::sinh(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      sinh(_Tp __x)
!     { return ::sinh(static_cast<_Tp>(__x)); }

    using ::sqrt;

--- 377,394 ----

    using ::sinh;

    inline float
!   sinh(float __x)
!   { return __builtin_sinhf(__x); }

    inline long double
!   sinh(long double __x)
!   { return __builtin_sinhl(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      sinh(_Tp __x)
!     { return __builtin_sinh(__x); }

    using ::sqrt;

*************** namespace std
*** 640,688 ****

    using ::tan;

- #if _GLIBCXX_HAVE_TANF
-   inline float
-   tan(float __x) { return __gnu_cxx::__c99_binding::tanf(__x); }
- #else
    inline float
!   tan(float __x) { return ::tan(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_TANL
-   inline long double
-   tan(long double __x) { return ::tanl(__x); }
- #else
    inline long double
!   tan(long double __x) { return ::tan(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      tan(_Tp __x)
!     { return ::tan(static_cast<double>(__x)); }

    using ::tanh;

- #if _GLIBCXX_HAVE_TANHF
    inline float
!   tanh(float __x) { return __gnu_cxx::__c99_binding::tanhf(__x); }
! #else
!   inline float
!   tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
! #endif

- #if _GLIBCXX_HAVE_TANHL
-   inline long double
-   tanh(long double __x) { return ::tanhl(__x); }
- #else
    inline long double
!   tanh(long double __x) { return ::tanh(static_cast<double>(__x)); }
! #endif

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      tanh(_Tp __x)
!     { return ::tanh(static_cast<double>(__x)); }
  }


--- 407,439 ----

    using ::tan;

    inline float
!   tan(float __x)
!   { return __builtin_tanf(__x); }

    inline long double
!   tan(long double __x)
!   { return __builtin_tanl(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      tan(_Tp __x)
!     { return __builtin_tan(__x); }

    using ::tanh;

    inline float
!   tanh(float __x)
!   { return __builtin_tanhf(__x); }

    inline long double
!   tanh(long double __x)
!   { return __builtin_tanhl(__x); }

    template<typename _Tp>
      inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
      tanh(_Tp __x)
!     { return __builtin_tanh(__x); }
  }


Index: libmath/stubs.c
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libmath/stubs.c,v
retrieving revision 1.12
diff -c -3 -p -r1.12 stubs.c
*** libmath/stubs.c	4 Nov 2003 05:02:40 -0000	1.12
--- libmath/stubs.c	14 Nov 2003 04:40:49 -0000
***************
*** 34,39 ****
--- 34,90 ----
     we use the crude approximation.  We'll do better later.  */


+ #ifndef HAVE_ACOSF
+ float
+ acosf(float x)
+ {
+   return (float) acos(x);
+ }
+ #endif
+
+ #ifndef HAVE_ACOSL
+ long double
+ acosl(long double x)
+ {
+   return acos((double) x);
+ }
+ #endif
+
+
+ #ifndef HAVE_ASINF
+ float
+ asinf(float x)
+ {
+   return (float) asin(x);
+ }
+ #endif
+
+ #ifndef HAVE_ASINL
+ long double
+ asinl(long double x)
+ {
+   return asin((double) x);
+ }
+ #endif
+
+
+ #ifndef HAVE_ATANF
+ float
+ atanf(float x)
+ {
+   return (float) atan(x);
+ }
+ #endif
+
+ #ifndef HAVE_ATANL
+ long double
+ atanl(long double x)
+ {
+   return atan ((double) x);
+ }
+ #endif
+
+
  #ifndef HAVE_ATAN2F
  float
  atan2f(float x, float y)
*************** atan2l(long double x, long double y)
*** 51,56 ****
--- 102,124 ----
  #endif


+ #ifndef HAVE_CEILF
+ float
+ ceilf(float x)
+ {
+   return (float) ceil(x);
+ }
+ #endif
+
+ #ifndef HAVE_CEILL
+ long double
+ ceill(long double x)
+ {
+   return ceil((double) x);
+ }
+ #endif
+
+
  #ifndef HAVE_COSF
  float
  cosf(float x)
*************** expl(long double x)
*** 102,107 ****
--- 170,226 ----
  #endif


+ #ifndef HAVE_FLOORF
+ float
+ floorf(float x)
+ {
+   return (float) floor(x);
+ }
+ #endif
+
+ #ifndef HAVE_FLOORL
+ long double
+ floorl(long double x)
+ {
+   return floor((double) x);
+ }
+ #endif
+
+
+ #ifndef HAVE_FMODF
+ float
+ fmodf(float x, float y)
+ {
+   return (float) fmod(x, y);
+ }
+ #endif
+
+ #ifndef HAVE_FMODL
+ long double
+ fmodl(long double x, long double y)
+ {
+   return fmod((double) x, (double) y);
+ }
+ #endif
+
+
+ #ifndef HAVE_FREXPF
+ float
+ frexpf(float x, int *exp)
+ {
+   return (float) frexp(x, exp);
+ }
+ #endif
+
+ #ifndef HAVE_FREXPL
+ long double
+ frexpl(long double x, int *exp)
+ {
+   return frexp((double) x, exp);
+ }
+ #endif
+
+
  #ifndef HAVE_SQRTF
  float
  sqrtf(float x)
*************** hypotl(long double x, long double y)
*** 158,163 ****
--- 277,299 ----



+ #ifndef HAVE_LDEXPF
+ float
+ ldexpf(float x, int exp)
+ {
+   return (float) ldexp(x, exp);
+ }
+ #endif
+
+ #ifndef HAVE_LDEXPL
+ long double
+ ldexpl(long double x, int exp)
+ {
+   return ldexp((double) x, exp);
+ }
+ #endif
+
+
  #ifndef HAVE_LOGF
  float
  logf(float x)
*************** long double
*** 188,193 ****
--- 324,354 ----
  log10l(long double x)
  {
    return log10((double) x);
+ }
+ #endif
+
+
+ #ifndef HAVE_MODFF
+ float
+ modff(float x, float *iptr)
+ {
+   double result, temp;
+
+   result = modf(x, &temp);
+   *iptr = (float) temp;
+   return (float) result;
+ }
+ #endif
+
+ #ifndef HAVE_MODFL
+ long double
+ modfl(long double x, long double *iptr)
+ {
+   double result, temp;
+
+   result = modf((double) x, &temp);
+   *iptr = temp;
+   return result;
  }
  #endif


Roger
--
Roger Sayle,                         E-mail: roger@eyesopen.com
OpenEye Scientific Software,         WWW: http://www.eyesopen.com/
Suite 1107, 3600 Cerrillos Road,     Tel: (+1) 505-473-7385
Santa Fe, New Mexico, 87507.         Fax: (+1) 505-473-0833


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]