OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

acconfig.h: Added defines for HAVE_BUILTIN math functs for float, double and long double. 

2000-06-06  Steven King <sxking@uswest.net>

        * acconfig.h: Added defines for HAVE_BUILTIN math functs for float,
        double and long double.  Added defines for HAVE libm math functs for
        float and long double.
        * aclocal.m4: Added configure checks for builtin math funcs and libm
        support for float and long double versions of the math functions.
        * config.h.in: Added undefs for math functs.
        * configure: Regenerate.
        * math/mathconf: Changed the _GLIBCPP_HAS_BUILTIN_* to
        _GLIBCPP_HAVE_BUILTIN_*.
        * bits/std_cmath.h: Added long double support.  Use builtins for
        float, double and long if available, otherwise, use libm versions if
        availible, otherwise, punt.
        * shadow/bits/std_cmath.h: ditto

From-SVN: r34436
This commit is contained in:
Steven King 2000-06-06 20:26:13 +00:00 committed by Benjamin Kosnik
parent 764dbbf2dd
commit 54fa741538
11 changed files with 5460 additions and 628 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,19 @@
2000-06-06 Steven King <sxking@uswest.net>
* acconfig.h: Added defines for HAVE_BUILTIN math functs for float,
double and long double. Added defines for HAVE libm math functs for
float and long double.
* aclocal.m4: Added configure checks for builtin math funcs and libm
support for float and long double versions of the math functions.
* config.h.in: Added undefs for math functs.
* configure: Regenerate.
* math/mathconf: Changed the _GLIBCPP_HAS_BUILTIN_* to
_GLIBCPP_HAVE_BUILTIN_*.
* bits/std_cmath.h: Added long double support. Use builtins for
float, double and long if available, otherwise, use libm versions if
availible, otherwise, punt.
* shadow/bits/std_cmath.h: ditto
2000-06-02 Benjamin Kosnik <bkoz@purist.soma.redhat.com>
* bits/locale_facets.h: Tweak.

368
libstdc++-v3/acconfig.h
View File

@ -12,17 +12,194 @@
// Define if code specialized for wchar_t should be used.
#undef _GLIBCPP_USE_WCHAR_T
// Define if the compiler/host combination has __builtin_sinf defined.
#undef _GLIBCPP_HAS_BUILTIN_SINF
// Define if the compiler/host combination has __builtin_acos
#undef HAVE_BUILTIN_ACOS
// Define if the compiler/host combination has __builtin_cosf defined.
#undef _GLIBCPP_HAS_BUILTIN_COSF
// Define if the compiler/host combination has __builtin_acosf
#undef HAVE_BUILTIN_ACOSF
// Define if the compiler/host combination has __builtin_fabsf defined.
#undef _GLIBCPP_HAS_BUILTIN_FABSF
// Define if the compiler/host combination has __builtin_acosl
#undef HAVE_BUILTIN_ACOSL
// Define if the compiler/host combination has __builtin_fabsf defined.
#undef _GLIBCPP_HAS_BUILTIN_SQRTF
// Define if the compiler/host combination has __builtin_asin
#undef HAVE_BUILTIN_ASIN
// Define if the compiler/host combination has __builtin_asinf
#undef HAVE_BUILTIN_ASINF
// Define if the compiler/host combination has __builtin_asinl
#undef HAVE_BUILTIN_ASINL
// Define if the compiler/host combination has __builtin_atan
#undef HAVE_BUILTIN_ATAN
// Define if the compiler/host combination has __builtin_atanf
#undef HAVE_BUILTIN_ATANF
// Define if the compiler/host combination has __builtin_atanl
#undef HAVE_BUILTIN_ATANL
// Define if the compiler/host combination has __builtin_atan2
#undef HAVE_BUILTIN_ATAN2
// Define if the compiler/host combination has __builtin_atan2f
#undef HAVE_BUILTIN_ATAN2F
// Define if the compiler/host combination has __builtin_atan2l
#undef HAVE_BUILTIN_ATAN2L
// Define if the compiler/host combination has __builtin_ceil
#undef HAVE_BUILTIN_CEIL
// Define if the compiler/host combination has __builtin_ceilf
#undef HAVE_BUILTIN_CEILF
// Define if the compiler/host combination has __builtin_ceill
#undef HAVE_BUILTIN_CEILL
// Define if the compiler/host combination has __builtin_cos
#undef HAVE_BUILTIN_COS
// Define if the compiler/host combination has __builtin_cosf
#undef HAVE_BUILTIN_COSF
// Define if the compiler/host combination has __builtin_cosl
#undef HAVE_BUILTIN_COSL
// Define if the compiler/host combination has __builtin_cosh
#undef HAVE_BUILTIN_COSH
// Define if the compiler/host combination has __builtin_coshf
#undef HAVE_BUILTIN_COSHF
// Define if the compiler/host combination has __builtin_coshl
#undef HAVE_BUILTIN_COSHL
// Define if the compiler/host combination has __builtin_exp
#undef HAVE_BUILTIN_EXP
// Define if the compiler/host combination has __builtin_expf
#undef HAVE_BUILTIN_EXPF
// Define if the compiler/host combination has __builtin_expl
#undef HAVE_BUILTIN_EXPL
// Define if the compiler/host combination has __builtin_fabs
#undef HAVE_BUILTIN_FABS
// Define if the compiler/host combination has __builtin_fabsf
#undef HAVE_BUILTIN_FABSF
// Define if the compiler/host combination has __builtin_fabsl
#undef HAVE_BUILTIN_FABSL
// Define if the compiler/host combination has __builtin_floor
#undef HAVE_BUILTIN_FLOOR
// Define if the compiler/host combination has __builtin_floorf
#undef HAVE_BUILTIN_FLOORF
// Define if the compiler/host combination has __builtin_floorl
#undef HAVE_BUILTIN_FLOORL
// Define if the compiler/host combination has __builtin_frexp
#undef HAVE_BUILTIN_FREXP
// Define if the compiler/host combination has __builtin_frexpf
#undef HAVE_BUILTIN_FREXPF
// Define if the compiler/host combination has __builtin_frexpl
#undef HAVE_BUILTIN_FREXPL
// Define if the compiler/host combination has __builtin_ldexp
#undef HAVE_BUILTIN_LDEXP
// Define if the compiler/host combination has __builtin_ldexpf
#undef HAVE_BUILTIN_LDEXPF
// Define if the compiler/host combination has __builtin_ldexpl
#undef HAVE_BUILTIN_LDEXPL
// Define if the compiler/host combination has __builtin_log
#undef HAVE_BUILTIN_LOG
// Define if the compiler/host combination has __builtin_logf
#undef HAVE_BUILTIN_LOGF
// Define if the compiler/host combination has __builtin_logl
#undef HAVE_BUILTIN_LOGL
// Define if the compiler/host combination has __builtin_log10
#undef HAVE_BUILTIN_LOG10
// Define if the compiler/host combination has __builtin_log10f
#undef HAVE_BUILTIN_LOG10F
// Define if the compiler/host combination has __builtin_log10l
#undef HAVE_BUILTIN_LOG10L
// Define if the compiler/host combination has __builtin_modf
#undef HAVE_BUILTIN_MODF
// Define if the compiler/host combination has __builtin_modff
#undef HAVE_BUILTIN_MODFF
// Define if the compiler/host combination has __builtin_modfl
#undef HAVE_BUILTIN_MODFL
// Define if the compiler/host combination has __builtin_pow
#undef HAVE_BUILTIN_POW
// Define if the compiler/host combination has __builtin_powf
#undef HAVE_BUILTIN_POWF
// Define if the compiler/host combination has __builtin_powl
#undef HAVE_BUILTIN_POWL
// Define if the compiler/host combination has __builtin_sin
#undef HAVE_BUILTIN_SIN
// Define if the compiler/host combination has __builtin_sinf
#undef HAVE_BUILTIN_SINF
// Define if the compiler/host combination has __builtin_sinl
#undef HAVE_BUILTIN_SINL
// Define if the compiler/host combination has __builtin_sinh
#undef HAVE_BUILTIN_SINH
// Define if the compiler/host combination has __builtin_sinhf
#undef HAVE_BUILTIN_SINHF
// Define if the compiler/host combination has __builtin_sinhl
#undef HAVE_BUILTIN_SINHL
// Define if the compiler/host combination has __builtin_sqrt
#undef HAVE_BUILTIN_SQRT
// Define if the compiler/host combination has __builtin_sqrtf
#undef HAVE_BUILTIN_SQRTF
// Define if the compiler/host combination has __builtin_sqrtl
#undef HAVE_BUILTIN_SQRTL
// Define if the compiler/host combination has __builtin_tan
#undef HAVE_BUILTIN_TAN
// Define if the compiler/host combination has __builtin_tanf
#undef HAVE_BUILTIN_TANF
// Define if the compiler/host combination has __builtin_tanl
#undef HAVE_BUILTIN_TANL
// Define if the compiler/host combination has __builtin_tanh
#undef HAVE_BUILTIN_TANH
// Define if the compiler/host combination has __builtin_tanhf
#undef HAVE_BUILTIN_TANHF
// Define if the compiler/host combination has __builtin_tanhl
#undef HAVE_BUILTIN_TANHL
// Define if GCC support for __complex__ float is buggy.
#undef _GLIBCPP_BUGGY_FLOAT_COMPLEX
@ -90,66 +267,221 @@
# define cosf _cosf
#endif
#if defined (HAVE__ACOSF) && ! defined (HAVE_ACOSF)
# define HAVE_ACOSF 1
# define acosf _acosf
#endif
#if defined (HAVE__ACOSL) && ! defined (HAVE_ACOSL)
# define HAVE_ACOSL 1
# define acosl _acosl
#endif
#if defined (HAVE__ASINF) && ! defined (HAVE_ASINF)
# define HAVE_ASINF 1
# define asinf _asinf
#endif
#if defined (HAVE__ASINL) && ! defined (HAVE_ASINL)
# define HAVE_ASINL 1
# define asinl _asinl
#endif
#if defined (HAVE__ATANF) && ! defined (HAVE_ATANF)
# define HAVE_ATANF 1
# define atanf _atanf
#endif
#if defined (HAVE__ATANL) && ! defined (HAVE_ATANL)
# define HAVE_ATANL 1
# define atanl _atanl
#endif
#if defined (HAVE__CEILF) && ! defined (HAVE_CEILF)
# define HAVE_CEILF 1
# define aceil _ceilf
#endif
#if defined (HAVE__CEILL) && ! defined (HAVE_CEILL)
# define HAVE_CEILL 1
# define aceil _ceill
#endif
#if defined (HAVE__COSHF) && ! defined (HAVE_COSHF)
# define HAVE_COSHF 1
# define coshf _coshf
#endif
#if defined (HAVE__COSL) && ! defined (HAVE_COSL)
# define HAVE_COSL 1
# define cosl _cosl
#endif
#if defined (HAVE__LOGF) && ! defined (HAVE_LOGF)
# define HAVE_LOGF 1
# define logf _logf
#endif
#if defined (HAVE__COSHL) && ! defined (HAVE_COSHL)
# define HAVE_COSHL 1
# define coshl _coshl
#endif
#if defined (HAVE__EXPF) && ! defined (HAVE_EXPF)
# define HAVE_EXPF 1
# define expf _expf
#endif
#if defined (HAVE__EXPL) && ! defined (HAVE_EXPL)
# define HAVE_EXPL 1
# define expl _expl
#endif
#if defined (HAVE__FABSF) && ! defined (HAVE_FABSF)
# define HAVE_FABSF 1
# define fabsf _fabsf
#endif
#if defined (HAVE__FABSL) && ! defined (HAVE_FABSL)
# define HAVE_FABSL 1
# define fabsl _fabsl
#endif
#if defined (HAVE__FLOORF) && ! defined (HAVE_FLOORF)
# define HAVE_FLOORF 1
# define floorf _floorf
#endif
#if defined (HAVE__FLOORL) && ! defined (HAVE_FLOORL)
# define HAVE_FLOORL 1
# define floorl _floorl
#endif
#if defined (HAVE__FMODF) && ! defined (HAVE_FMODF)
# define HAVE_FMODF 1
# define fmodf _fmodf
#endif
#if defined (HAVE__FMODL) && ! defined (HAVE_FMODL)
# define HAVE_FMODL 1
# define fmodl _fmodl
#endif
#if defined (HAVE__FREXPF) && ! defined (HAVE_FREXPF)
# define HAVE_FREXPF 1
# define frexpf _frexpf
#endif
#if defined (HAVE__FREXPL) && ! defined (HAVE_FREXPL)
# define HAVE_FREXPL 1
# define frexpl _frexpl
#endif
#if defined (HAVE__LDEXPF) && ! defined (HAVE_LDEXPF)
# define HAVE_LDEXPF 1
# define ldexpf _ldexpf
#endif
#if defined (HAVE__LDEXPL) && ! defined (HAVE_LDEXPL)
# define HAVE_LDEXPL 1
# define ldexpl _ldexpl
#endif
#if defined (HAVE__LOG10F) && ! defined (HAVE_LOG10F)
# define HAVE_LOG10F 1
# define log10f _log10f
#endif
#if defined (HAVE__LOGL) && ! defined (HAVE_LOGL)
# define HAVE_LOGL 1
# define logl _logl
#endif
#if defined (HAVE__POWF) && ! defined (HAVE_POWF)
# define HAVE_POWF 1
# define powf _powf
#endif
#if defined (HAVE__LOG10L) && ! defined (HAVE_LOG10L)
# define HAVE_LOG10L 1
# define log10l _log10l
#endif
#if defined (HAVE__MODF) && ! defined (HAVE_MODF)
# define HAVE_MODF 1
# define modf _modf
#endif
#if defined (HAVE__MODL) && ! defined (HAVE_MODL)
# define HAVE_MODL 1
# define modl _modl
#endif
#if defined (HAVE__SINF) && ! defined (HAVE_SINF)
# define HAVE_SINF 1
# define sinf _sinf
#endif
#if defined (HAVE__POWL) && ! defined (HAVE_POWL)
# define HAVE_POWL 1
# define powl _powl
#endif
#if defined (HAVE__SINHF) && ! defined (HAVE_SINHF)
# define HAVE_SINHF 1
# define sinhf _sinhf
#endif
#if defined (HAVE__SINL) && ! defined (HAVE_SINL)
# define HAVE_SINL 1
# define sinl _sinl
#endif
#if defined (HAVE__SQRTF) && ! defined (HAVE_SQRTF)
# define HAVE_SQRTF 1
# define sqrtf _sqrtf
#endif
#if defined (HAVE__SINHL) && ! defined (HAVE_SINHL)
# define HAVE_SINHL 1
# define sinhl _sinhl
#endif
#if defined (HAVE__TANF) && ! defined (HAVE_TANF)
# define HAVE_TANF 1
# define tanf _tanf
#endif
#if defined (HAVE__SQRTL) && ! defined (HAVE_SQRTL)
# define HAVE_SQRTL 1
# define sqrtl _sqrtl
#endif
#if defined (HAVE__TANHF) && ! defined (HAVE_TANHF)
# define HAVE_TANHF 1
# define tanhf _tanhf
#endif
#if defined (HAVE__TANL) && ! defined (HAVE_TANL)
# define HAVE_TANF 1
# define tanf _tanf
#endif
#if defined (HAVE__STRTOF) && ! defined (HAVE_STRTOF)
# define HAVE_STRTOF 1
# define strtof _strtof
#endif
#if defined (HAVE__TANHL) && ! defined (HAVE_TANHL)
# define HAVE_TANHL 1
# define tanhl _tanhl
#endif
#if defined (HAVE__STRTOLD) && ! defined (HAVE_STRTOLD)
# define HAVE_STRTOLD 1
# define strtold _strtold
#endif
#if defined (HAVE__FABSF) && ! defined (HAVE_FABSF)
# define HAVE_FABSF 1
# define fabsf _fabsf
#endif
#if defined (HAVE__SINCOS) && ! defined (HAVE_SINCOS)
# define HAVE_SINCOS 1
# define sincos _sincos
@ -170,6 +502,16 @@
# define finite _finite
#endif
#if defined (HAVE__FINITEF) && ! defined (HAVE_FINITEF)
# define HAVE_FINITEF 1
# define finitef _finitef
#endif
#if defined (HAVE__FINITEL) && ! defined (HAVE_FINITEL)
# define HAVE_FINITEL 1
# define finitel _finitel
#endif
#if defined (HAVE__QFINITE) && ! defined (HAVE_QFINITE)
# define HAVE_QFINITE 1
# define qfinite _qfinite

596
libstdc++-v3/acinclude.m4
View File

@ -223,56 +223,586 @@ AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [
AC_SUBST(FMTFLAGS)
])
dnl
dnl Check to see what builtin math functions are supported
dnl
dnl Define _GLIBCPP_HAS_BUILTIN_SINF if __builtin_sinf
dnl Define _GLIBCPP_HAS_BUILTIN_COSF if __builtin_cosf
dnl Define _GLIBCPP_HAS_BUILTIN_FABSF if __builtin_fabsf
dnl Define _GLIBCPP_HAS_BUILTIN_SQRTF if __builtin_sqrtf
dnl
dnl check for __builtin_acos
dnl check for __builtin_acosf
dnl check for __builtin_acosl
dnl check for __builtin_asin
dnl check for __builtin_asinf
dnl check for __builtin_asinl
dnl check for __builtin_atan
dnl check for __builtin_atanf
dnl check for __builtin_atanl
dnl check for __builtin_atan2
dnl check for __builtin_atan2f
dnl check for __builtin_atan2l
dnl check for __builtin_ceil
dnl check for __builtin_ceilf
dnl check for __builtin_ceill
dnl check for __builtin_cos
dnl check for __builtin_cosf
dnl check for __builtin_cosl
dnl check for __builtin_cosh
dnl check for __builtin_coshf
dnl check for __builtin_coshl
dnl check for __builtin_exp
dnl check for __builtin_expf
dnl check for __builtin_expl
dnl check for __builtin_fabs
dnl check for __builtin_fabsf
dnl check for __builtin_fabsl
dnl check for __builtin_floor
dnl check for __builtin_floorf
dnl check for __builtin_floorl
dnl check for __builtin_frexp
dnl check for __builtin_frexpf
dnl check for __builtin_frexpl
dnl check for __builtin_ldexp
dnl check for __builtin_ldexpf
dnl check for __builtin_ldexpl
dnl check for __builtin_log
dnl check for __builtin_logf
dnl check for __builtin_logl
dnl check for __builtin_log10
dnl check for __builtin_log10f
dnl check for __builtin_log10l
dnl check for __builtin_modf
dnl check for __builtin_modff
dnl check for __builtin_modfl
dnl check for __builtin_pow
dnl check for __builtin_powf
dnl check for __builtin_powl
dnl check for __builtin_sin
dnl check for __builtin_sinf
dnl check for __builtin_sinl
dnl check for __builtin_sinh
dnl check for __builtin_sinhf
dnl check for __builtin_sinhl
dnl check for __builtin_sqrt
dnl check for __builtin_sqrtf
dnl check for __builtin_sqrtl
dnl check for __builtin_tan
dnl check for __builtin_tanf
dnl check for __builtin_tanl
dnl check for __builtin_tanh
dnl check for __builtin_tanhf
dnl check for __builtin_tanhl
dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
dnl Test for builtin math functions.
AC_MSG_CHECKING([for __builtin_sinf])
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_MSG_CHECKING([for __builtin_acos])
AC_TRY_COMPILE([#include <math.h>],
[float foo(void) { __builtin_sinf(0.0); }],
use_builtin_sinf=yes, use_builtin_sinf=no)
AC_MSG_RESULT($use_builtin_sinf)
if test $use_builtin_sinf = "yes"; then
AC_DEFINE(_GLIBCPP_HAS_BUILTIN_SINF)
[ __builtin_acos(0.0);],
use_builtin_acos=yes, use_builtin_acos=no)
AC_MSG_RESULT($use_builtin_acos)
if test $use_builtin_acos = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ACOS)
fi
AC_MSG_CHECKING([for __builtin_acosf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_acosf(0.0);],
use_builtin_acosf=yes, use_builtin_acosf=no)
AC_MSG_RESULT($use_builtin_acosf)
if test $use_builtin_acosf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ACOSF)
fi
AC_MSG_CHECKING([for __builtin_acosl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_acosl(0.0);],
use_builtin_acosl=yes, use_builtin_acosl=no)
AC_MSG_RESULT($use_builtin_acosl)
if test $use_builtin_acosl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ACOSL)
fi
AC_MSG_CHECKING([for __builtin_asin])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_asin(0.0);],
use_builtin_asin=yes, use_builtin_asin=no)
AC_MSG_RESULT($use_builtin_asin)
if test $use_builtin_asin = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ASIN)
fi
AC_MSG_CHECKING([for __builtin_asinf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_asinf(0.0);],
use_builtin_asinf=yes, use_builtin_asinf=no)
AC_MSG_RESULT($use_builtin_asinf)
if test $use_builtin_asinf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ASINF)
fi
AC_MSG_CHECKING([for __builtin_asinl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_asinl(0.0);],
use_builtin_asinl=yes, use_builtin_asinl=no)
AC_MSG_RESULT($use_builtin_asinl)
if test $use_builtin_asinl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ASINL)
fi
AC_MSG_CHECKING([for __builtin_atan])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atan(0.0);],
use_builtin_atan=yes, use_builtin_atan=no)
AC_MSG_RESULT($use_builtin_atan)
if test $use_builtin_atan = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATAN)
fi
AC_MSG_CHECKING([for __builtin_atanf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atanf(0.0);],
use_builtin_atanf=yes, use_builtin_atanf=no)
AC_MSG_RESULT($use_builtin_atanf)
if test $use_builtin_atanf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATANF)
fi
AC_MSG_CHECKING([for __builtin_atanl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atanl(0.0);],
use_builtin_atanl=yes, use_builtin_atanl=no)
AC_MSG_RESULT($use_builtin_atanl)
if test $use_builtin_atanl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATANL)
fi
AC_MSG_CHECKING([for __builtin_atan2])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atan2(0.0);],
use_builtin_atan2=yes, use_builtin_atan2=no)
AC_MSG_RESULT($use_builtin_atan2)
if test $use_builtin_atan2 = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATAN2)
fi
AC_MSG_CHECKING([for __builtin_atan2f])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atan2f(0.0);],
use_builtin_atan2f=yes, use_builtin_atan2f=no)
AC_MSG_RESULT($use_builtin_atan2f)
if test $use_builtin_atan2f = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATAN2F)
fi
AC_MSG_CHECKING([for __builtin_atan2l])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atan2l(0.0);],
use_builtin_atan2l=yes, use_builtin_atan2l=no)
AC_MSG_RESULT($use_builtin_atan2l)
if test $use_builtin_atan2l = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATAN2L)
fi
AC_MSG_CHECKING([for __builtin_ceil])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fceil(0.0);],
use_builtin_ceil=yes, use_builtin_ceil=no)
AC_MSG_RESULT($use_builtin_ceil)
if test $use_builtin_ceil = "yes"; then
AC_DEFINE(HAVE_BUILTIN_CEIL)
fi
AC_MSG_CHECKING([for __builtin_ceilf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ceilf(0.0);],
use_builtin_ceilf=yes, use_builtin_ceilf=no)
AC_MSG_RESULT($use_builtin_ceilf)
if test $use_builtin_ceilf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_CEILF)
fi
AC_MSG_CHECKING([for __builtin_ceill])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ceill(0.0);],
use_builtin_ceill=yes, use_builtin_ceill=no)
AC_MSG_RESULT($use_builtin_ceill)
if test $use_builtin_ceill = "yes"; then
AC_DEFINE(HAVE_BUILTIN_CEILL)
fi
AC_MSG_CHECKING([for __builtin_cos])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_cos(0.0);],
use_builtin_cos=yes, use_builtin_cos=no)
AC_MSG_RESULT($use_builtin_cos)
if test $use_builtin_cos = "yes"; then
AC_DEFINE(HAVE_BUILTIN_COS)
fi
AC_MSG_CHECKING([for __builtin_cosf])
AC_TRY_COMPILE([#include <math.h>],
[float foo(void) { __builtin_cosf(0.0); }],
[ __builtin_cosf(0.0);],
use_builtin_cosf=yes, use_builtin_cosf=no)
AC_MSG_RESULT($use_builtin_cosf)
if test $use_builtin_cosf = "yes"; then
AC_DEFINE(_GLIBCPP_HAS_BUILTIN_COSF)
AC_DEFINE(HAVE_BUILTIN_COSF)
fi
AC_MSG_CHECKING([for __builtin_cosl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_cosl(0.0);],
use_builtin_cosl=yes, use_builtin_cosl=no)
AC_MSG_RESULT($use_builtin_cosl)
if test $use_builtin_cosl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_COSL)
fi
AC_MSG_CHECKING([for __builtin_cosh])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_cosh(0.0);],
use_builtin_cosh=yes, use_builtin_cosh=no)
AC_MSG_RESULT($use_builtin_cosh)
if test $use_builtin_cosh = "yes"; then
AC_DEFINE(HAVE_BUILTIN_COSH)
fi
AC_MSG_CHECKING([for __builtin_coshf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_coshf(0.0);],
use_builtin_coshf=yes, use_builtin_coshf=no)
AC_MSG_RESULT($use_builtin_coshf)
if test $use_builtin_coshf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_COSHF)
fi
AC_MSG_CHECKING([for __builtin_coshl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_coshl(0.0);],
use_builtin_coshl=yes, use_builtin_coshl=no)
AC_MSG_RESULT($use_builtin_coshl)
if test $use_builtin_coshl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_COSHL)
fi
AC_MSG_CHECKING([for __builtin_exp])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_exp(0.0);],
use_builtin_exp=yes, use_builtin_exp=no)
AC_MSG_RESULT($use_builtin_exp)
if test $use_builtin_exp = "yes"; then
AC_DEFINE(HAVE_BUILTIN_EXP)
fi
AC_MSG_CHECKING([for __builtin_expf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_expf(0.0);],
use_builtin_expf=yes, use_builtin_expf=no)
AC_MSG_RESULT($use_builtin_expf)
if test $use_builtin_expf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_EXPF)
fi
AC_MSG_CHECKING([for __builtin_expl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_expl(0.0);],
use_builtin_expl=yes, use_builtin_expl=no)
AC_MSG_RESULT($use_builtin_expl)
if test $use_builtin_expl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_EXPL)
fi
AC_MSG_CHECKING([for __builtin_fabs])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fabs(0.0);],
use_builtin_fabs=yes, use_builtin_fabs=no)
AC_MSG_RESULT($use_builtin_fabs)
if test $use_builtin_fabs = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FABS)
fi
AC_MSG_CHECKING([for __builtin_fabsf])
AC_TRY_COMPILE([#include <math.h>],
[float foo(void) { __builtin_fabsf(0.0); }],
[ __builtin_fabsf(0.0);],
use_builtin_fabsf=yes, use_builtin_fabsf=no)
AC_MSG_RESULT($use_builtin_fabsf)
if test $use_builtin_fabsf = "yes"; then
AC_DEFINE(_GLIBCPP_HAS_BUILTIN_FABSF)
AC_DEFINE(HAVE_BUILTIN_FABSF)
fi
AC_MSG_CHECKING([for __builtin_fabsl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fabsl(0.0);],
use_builtin_fabsl=yes, use_builtin_fabsl=no)
AC_MSG_RESULT($use_builtin_fabsl)
if test $use_builtin_fabsl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FABSL)
fi
AC_MSG_CHECKING([for __builtin_floor])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ffloor(0.0);],
use_builtin_floor=yes, use_builtin_floor=no)
AC_MSG_RESULT($use_builtin_floor)
if test $use_builtin_floor = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FLOOR)
fi
AC_MSG_CHECKING([for __builtin_floorf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_floorf(0.0);],
use_builtin_floorf=yes, use_builtin_floorf=no)
AC_MSG_RESULT($use_builtin_floorf)
if test $use_builtin_floorf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FLOORF)
fi
AC_MSG_CHECKING([for __builtin_floorl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_floorl(0.0);],
use_builtin_floorl=yes, use_builtin_floorl=no)
AC_MSG_RESULT($use_builtin_floorl)
if test $use_builtin_floorl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FLOORL)
fi
AC_MSG_CHECKING([for __builtin_frexp])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_frexp(0.0);],
use_builtin_frexp=yes, use_builtin_frexp=no)
AC_MSG_RESULT($use_builtin_frexp)
if test $use_builtin_frexp = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FREXP)
fi
AC_MSG_CHECKING([for __builtin_frexpf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_frexpf(0.0);],
use_builtin_frexpf=yes, use_builtin_frexpf=no)
AC_MSG_RESULT($use_builtin_frexpf)
if test $use_builtin_frexpf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FREXPF)
fi
AC_MSG_CHECKING([for __builtin_frexpl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_frexpl(0.0);],
use_builtin_frexpl=yes, use_builtin_frexpl=no)
AC_MSG_RESULT($use_builtin_frexpl)
if test $use_builtin_frexpl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FREXPL)
fi
AC_MSG_CHECKING([for __builtin_ldexp])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ldexp(0.0);],
use_builtin_ldexp=yes, use_builtin_ldexp=no)
AC_MSG_RESULT($use_builtin_ldexp)
if test $use_builtin_ldexp = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LDEXP)
fi
AC_MSG_CHECKING([for __builtin_ldexpf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ldexpf(0.0);],
use_builtin_ldexpf=yes, use_builtin_ldexpf=no)
AC_MSG_RESULT($use_builtin_ldexpf)
if test $use_builtin_ldexpf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LDEXPF)
fi
AC_MSG_CHECKING([for __builtin_ldexpl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ldexpl(0.0);],
use_builtin_ldexpl=yes, use_builtin_ldexpl=no)
AC_MSG_RESULT($use_builtin_ldexpl)
if test $use_builtin_ldexpl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LDEXPL)
fi
AC_MSG_CHECKING([for __builtin_log])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_log(0.0);],
use_builtin_log=yes, use_builtin_log=no)
AC_MSG_RESULT($use_builtin_log)
if test $use_builtin_log = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOG)
fi
AC_MSG_CHECKING([for __builtin_logf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_logf(0.0);],
use_builtin_logf=yes, use_builtin_logf=no)
AC_MSG_RESULT($use_builtin_logf)
if test $use_builtin_logf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOGF)
fi
AC_MSG_CHECKING([for __builtin_logl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_logl(0.0);],
use_builtin_logl=yes, use_builtin_logl=no)
AC_MSG_RESULT($use_builtin_logl)
if test $use_builtin_logl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOGL)
fi
AC_MSG_CHECKING([for __builtin_log10])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_log10(0.0);],
use_builtin_log10=yes, use_builtin_log10=no)
AC_MSG_RESULT($use_builtin_log10)
if test $use_builtin_log10 = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOG10)
fi
AC_MSG_CHECKING([for __builtin_log10f])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_log10f(0.0);],
use_builtin_log10f=yes, use_builtin_log10f=no)
AC_MSG_RESULT($use_builtin_log10f)
if test $use_builtin_log10f = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOG10F)
fi
AC_MSG_CHECKING([for __builtin_log10l])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_log10l(0.0);],
use_builtin_log10l=yes, use_builtin_log10l=no)
AC_MSG_RESULT($use_builtin_log10l)
if test $use_builtin_log10l = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOG10L)
fi
AC_MSG_CHECKING([for __builtin_modf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_modf(0.0);],
use_builtin_modf=yes, use_builtin_modf=no)
AC_MSG_RESULT($use_builtin_modf)
if test $use_builtin_modf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_MODF)
fi
AC_MSG_CHECKING([for __builtin_modff])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_modff(0.0);],
use_builtin_modff=yes, use_builtin_modff=no)
AC_MSG_RESULT($use_builtin_modff)
if test $use_builtin_modff = "yes"; then
AC_DEFINE(HAVE_BUILTIN_MODFF)
fi
AC_MSG_CHECKING([for __builtin_modfl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_modfl(0.0);],
use_builtin_modfl=yes, use_builtin_modfl=no)
AC_MSG_RESULT($use_builtin_modfl)
if test $use_builtin_modfl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_MODFL)
fi
AC_MSG_CHECKING([for __builtin_pow])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_pow(0.0);],
use_builtin_pow=yes, use_builtin_pow=no)
AC_MSG_RESULT($use_builtin_pow)
if test $use_builtin_pow = "yes"; then
AC_DEFINE(HAVE_BUILTIN_POW)
fi
AC_MSG_CHECKING([for __builtin_powf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_powf(0.0);],
use_builtin_powf=yes, use_builtin_powf=no)
AC_MSG_RESULT($use_builtin_powf)
if test $use_builtin_powf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_POWF)
fi
AC_MSG_CHECKING([for __builtin_powl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_powl(0.0);],
use_builtin_powl=yes, use_builtin_powl=no)
AC_MSG_RESULT($use_builtin_powl)
if test $use_builtin_powl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_POWL)
fi
AC_MSG_CHECKING([for __builtin_sin])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sin(0.0);],
use_builtin_sin=yes, use_builtin_sin=no)
AC_MSG_RESULT($use_builtin_sin)
if test $use_builtin_sin = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SIN)
fi
AC_MSG_CHECKING([for __builtin_sinf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sinf(0.0);],
use_builtin_sinf=yes, use_builtin_sinf=no)
AC_MSG_RESULT($use_builtin_sinf)
if test $use_builtin_sinf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SINF)
fi
AC_MSG_CHECKING([for __builtin_sinl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sinl(0.0);],
use_builtin_sinl=yes, use_builtin_sinl=no)
AC_MSG_RESULT($use_builtin_sinl)
if test $use_builtin_sinl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SINL)
fi
AC_MSG_CHECKING([for __builtin_sinh])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sinh(0.0);],
use_builtin_sinh=yes, use_builtin_sinh=no)
AC_MSG_RESULT($use_builtin_sinh)
if test $use_builtin_sinh = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SINH)
fi
AC_MSG_CHECKING([for __builtin_sinhf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sinhf(0.0);],
use_builtin_sinhf=yes, use_builtin_sinhf=no)
AC_MSG_RESULT($use_builtin_sinhf)
if test $use_builtin_sinhf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SINHF)
fi
AC_MSG_CHECKING([for __builtin_sinhl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sinhl(0.0);],
use_builtin_sinhl=yes, use_builtin_sinhl=no)
AC_MSG_RESULT($use_builtin_sinhl)
if test $use_builtin_sinhl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SINHL)
fi
AC_MSG_CHECKING([for __builtin_sqrt])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fsqrt(0.0);],
use_builtin_sqrt=yes, use_builtin_sqrt=no)
AC_MSG_RESULT($use_builtin_sqrt)
if test $use_builtin_sqrt = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SQRT)
fi
AC_MSG_CHECKING([for __builtin_sqrtf])
AC_TRY_COMPILE([#include <math.h>],
[float foo(void) { __builtin_sqrtf(0.0); }],
[ __builtin_sqrtf(0.0);],
use_builtin_sqrtf=yes, use_builtin_sqrtf=no)
AC_MSG_RESULT($use_builtin_sqrtf)
if test $use_builtin_sqrtf = "yes"; then
AC_DEFINE(_GLIBCPP_HAS_BUILTIN_SQRTF)
AC_DEFINE(HAVE_BUILTIN_SQRTF)
fi
AC_MSG_CHECKING([for __builtin_sqrtl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sqrtl(0.0);],
use_builtin_sqrtl=yes, use_builtin_sqrtl=no)
AC_MSG_RESULT($use_builtin_sqrtl)
if test $use_builtin_sqrtl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SQRTL)
fi
AC_MSG_CHECKING([for __builtin_tan])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tan(0.0);],
use_builtin_tan=yes, use_builtin_tan=no)
AC_MSG_RESULT($use_builtin_tan)
if test $use_builtin_tan = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TAN)
fi
AC_MSG_CHECKING([for __builtin_tanf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tanf(0.0);],
use_builtin_tanf=yes, use_builtin_tanf=no)
AC_MSG_RESULT($use_builtin_tanf)
if test $use_builtin_tanf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TANF)
fi
AC_MSG_CHECKING([for __builtin_tanl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tanl(0.0);],
use_builtin_tanl=yes, use_builtin_tanl=no)
AC_MSG_RESULT($use_builtin_tanl)
if test $use_builtin_tanl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TANL)
fi
AC_MSG_CHECKING([for __builtin_tanh])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tanh(0.0);],
use_builtin_tanh=yes, use_builtin_tanh=no)
AC_MSG_RESULT($use_builtin_tanh)
if test $use_builtin_tanh = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TANH)
fi
AC_MSG_CHECKING([for __builtin_tanhf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tanhf(0.0);],
use_builtin_tanhf=yes, use_builtin_tanhf=no)
AC_MSG_RESULT($use_builtin_tanhf)
if test $use_builtin_tanhf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TANHF)
fi
AC_MSG_CHECKING([for __builtin_tanhl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tanhl(0.0);],
use_builtin_tanhl=yes, use_builtin_tanhl=no)
AC_MSG_RESULT($use_builtin_tanhl)
if test $use_builtin_tanhl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TANHL)
fi
AC_LANG_RESTORE
])
dnl Check to see what architecture we are compiling for. If it's
dnl supported, use special hand-crafted routines to provide thread
dnl primitives. Also, if architecture-specific flags are required for
@ -496,20 +1026,26 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l))
AC_SUBST(USE_LONG_DOUBLE)
dnl Check to see if basic C math functions have faster float versions.
AC_CHECK_FUNCS(modf isnan isnanf isnanl isinf isinff isinfl copysign \
copysignl cosf coshf logf log10f powf sinf sinhf sqrtf tanf tanhf \
strtof strtold fabsf sincos sincosf sincosl finite finite fqfinite \
fpclass qfpclass)
dnl Check to see if basic C math functions have float, long double versions.
AC_CHECK_FUNCS(isnan isnanf isnanl isinf isinff isinfl copysign copysignl \
acosf acosl asinf asinl atanf atanl atan2f atan2l ceilf ceill cosf cosl \
coshf coshl expf expl fabsf fabsl floorf floorl frexpf frexpl ldexpf \
ldexpl logf logl log10f log10l modf modff modfl powf powl sinf sinl sinhf \
sinhl sqrtf sqrtl tanf tanl tanhf tanhl strtof strtold sincos sincosf \
sincosl finite finitef finitel fqfinite fpclass qfpclass)
#Some runtimes have these functions with a preceding underscore. Please
# keep this sync'd with the one above. And if you add any new symbol,
# please add the corresponding block in the @BOTTOM@ section of
# acconfig.h.
AC_CHECK_FUNCS(_modf _isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \
_copysignl _cosf _coshf _logf _log10f _powf _sinf _sinhf _sqrtf _tanf _tanhf \
_strtof _strtold _fabsf _sincos _sincosf _sincosl _finite _finitef _qfinite \
_fpclass _qfpclass)
AC_CHECK_FUNCS(_isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \
_copysignl _acosf _acosl _asinf _asinl _atanf _atanl _atan2f _atan2l \
_ceilf _ceill _cosf _cosl _coshf _coshl _expf _expl _fabsf _fabsl \
_floorf _floorl _frexpf _frexpl _ldexpf _ldexpl _logf _logl _log10f \
_log10l _modf _modff _modfl _powf _powl _sinf _sinl _sinhf _sinhl _sqrtf \
_sqrtl _tanf _tanl _tanhf _tanhl _strtof _strtold _sincos _sincosf _sincosl \
_finite _finitef _finitel _fqfinite _fpclass _qfpclass)
LIBS="$save_LIBS"
])

596
libstdc++-v3/aclocal.m4 vendored
View File

@ -235,56 +235,586 @@ AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [
AC_SUBST(FMTFLAGS)
])
dnl
dnl Check to see what builtin math functions are supported
dnl
dnl Define _GLIBCPP_HAS_BUILTIN_SINF if __builtin_sinf
dnl Define _GLIBCPP_HAS_BUILTIN_COSF if __builtin_cosf
dnl Define _GLIBCPP_HAS_BUILTIN_FABSF if __builtin_fabsf
dnl Define _GLIBCPP_HAS_BUILTIN_SQRTF if __builtin_sqrtf
dnl
dnl check for __builtin_acos
dnl check for __builtin_acosf
dnl check for __builtin_acosl
dnl check for __builtin_asin
dnl check for __builtin_asinf
dnl check for __builtin_asinl
dnl check for __builtin_atan
dnl check for __builtin_atanf
dnl check for __builtin_atanl
dnl check for __builtin_atan2
dnl check for __builtin_atan2f
dnl check for __builtin_atan2l
dnl check for __builtin_ceil
dnl check for __builtin_ceilf
dnl check for __builtin_ceill
dnl check for __builtin_cos
dnl check for __builtin_cosf
dnl check for __builtin_cosl
dnl check for __builtin_cosh
dnl check for __builtin_coshf
dnl check for __builtin_coshl
dnl check for __builtin_exp
dnl check for __builtin_expf
dnl check for __builtin_expl
dnl check for __builtin_fabs
dnl check for __builtin_fabsf
dnl check for __builtin_fabsl
dnl check for __builtin_floor
dnl check for __builtin_floorf
dnl check for __builtin_floorl
dnl check for __builtin_frexp
dnl check for __builtin_frexpf
dnl check for __builtin_frexpl
dnl check for __builtin_ldexp
dnl check for __builtin_ldexpf
dnl check for __builtin_ldexpl
dnl check for __builtin_log
dnl check for __builtin_logf
dnl check for __builtin_logl
dnl check for __builtin_log10
dnl check for __builtin_log10f
dnl check for __builtin_log10l
dnl check for __builtin_modf
dnl check for __builtin_modff
dnl check for __builtin_modfl
dnl check for __builtin_pow
dnl check for __builtin_powf
dnl check for __builtin_powl
dnl check for __builtin_sin
dnl check for __builtin_sinf
dnl check for __builtin_sinl
dnl check for __builtin_sinh
dnl check for __builtin_sinhf
dnl check for __builtin_sinhl
dnl check for __builtin_sqrt
dnl check for __builtin_sqrtf
dnl check for __builtin_sqrtl
dnl check for __builtin_tan
dnl check for __builtin_tanf
dnl check for __builtin_tanl
dnl check for __builtin_tanh
dnl check for __builtin_tanhf
dnl check for __builtin_tanhl
dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
dnl Test for builtin math functions.
AC_MSG_CHECKING([for __builtin_sinf])
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_MSG_CHECKING([for __builtin_acos])
AC_TRY_COMPILE([#include <math.h>],
[float foo(void) { __builtin_sinf(0.0); }],
use_builtin_sinf=yes, use_builtin_sinf=no)
AC_MSG_RESULT($use_builtin_sinf)
if test $use_builtin_sinf = "yes"; then
AC_DEFINE(_GLIBCPP_HAS_BUILTIN_SINF)
[ __builtin_acos(0.0);],
use_builtin_acos=yes, use_builtin_acos=no)
AC_MSG_RESULT($use_builtin_acos)
if test $use_builtin_acos = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ACOS)
fi
AC_MSG_CHECKING([for __builtin_acosf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_acosf(0.0);],
use_builtin_acosf=yes, use_builtin_acosf=no)
AC_MSG_RESULT($use_builtin_acosf)
if test $use_builtin_acosf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ACOSF)
fi
AC_MSG_CHECKING([for __builtin_acosl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_acosl(0.0);],
use_builtin_acosl=yes, use_builtin_acosl=no)
AC_MSG_RESULT($use_builtin_acosl)
if test $use_builtin_acosl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ACOSL)
fi
AC_MSG_CHECKING([for __builtin_asin])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_asin(0.0);],
use_builtin_asin=yes, use_builtin_asin=no)
AC_MSG_RESULT($use_builtin_asin)
if test $use_builtin_asin = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ASIN)
fi
AC_MSG_CHECKING([for __builtin_asinf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_asinf(0.0);],
use_builtin_asinf=yes, use_builtin_asinf=no)
AC_MSG_RESULT($use_builtin_asinf)
if test $use_builtin_asinf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ASINF)
fi
AC_MSG_CHECKING([for __builtin_asinl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_asinl(0.0);],
use_builtin_asinl=yes, use_builtin_asinl=no)
AC_MSG_RESULT($use_builtin_asinl)
if test $use_builtin_asinl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ASINL)
fi
AC_MSG_CHECKING([for __builtin_atan])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atan(0.0);],
use_builtin_atan=yes, use_builtin_atan=no)
AC_MSG_RESULT($use_builtin_atan)
if test $use_builtin_atan = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATAN)
fi
AC_MSG_CHECKING([for __builtin_atanf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atanf(0.0);],
use_builtin_atanf=yes, use_builtin_atanf=no)
AC_MSG_RESULT($use_builtin_atanf)
if test $use_builtin_atanf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATANF)
fi
AC_MSG_CHECKING([for __builtin_atanl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atanl(0.0);],
use_builtin_atanl=yes, use_builtin_atanl=no)
AC_MSG_RESULT($use_builtin_atanl)
if test $use_builtin_atanl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATANL)
fi
AC_MSG_CHECKING([for __builtin_atan2])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atan2(0.0);],
use_builtin_atan2=yes, use_builtin_atan2=no)
AC_MSG_RESULT($use_builtin_atan2)
if test $use_builtin_atan2 = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATAN2)
fi
AC_MSG_CHECKING([for __builtin_atan2f])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atan2f(0.0);],
use_builtin_atan2f=yes, use_builtin_atan2f=no)
AC_MSG_RESULT($use_builtin_atan2f)
if test $use_builtin_atan2f = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATAN2F)
fi
AC_MSG_CHECKING([for __builtin_atan2l])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_atan2l(0.0);],
use_builtin_atan2l=yes, use_builtin_atan2l=no)
AC_MSG_RESULT($use_builtin_atan2l)
if test $use_builtin_atan2l = "yes"; then
AC_DEFINE(HAVE_BUILTIN_ATAN2L)
fi
AC_MSG_CHECKING([for __builtin_ceil])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fceil(0.0);],
use_builtin_ceil=yes, use_builtin_ceil=no)
AC_MSG_RESULT($use_builtin_ceil)
if test $use_builtin_ceil = "yes"; then
AC_DEFINE(HAVE_BUILTIN_CEIL)
fi
AC_MSG_CHECKING([for __builtin_ceilf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ceilf(0.0);],
use_builtin_ceilf=yes, use_builtin_ceilf=no)
AC_MSG_RESULT($use_builtin_ceilf)
if test $use_builtin_ceilf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_CEILF)
fi
AC_MSG_CHECKING([for __builtin_ceill])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ceill(0.0);],
use_builtin_ceill=yes, use_builtin_ceill=no)
AC_MSG_RESULT($use_builtin_ceill)
if test $use_builtin_ceill = "yes"; then
AC_DEFINE(HAVE_BUILTIN_CEILL)
fi
AC_MSG_CHECKING([for __builtin_cos])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_cos(0.0);],
use_builtin_cos=yes, use_builtin_cos=no)
AC_MSG_RESULT($use_builtin_cos)
if test $use_builtin_cos = "yes"; then
AC_DEFINE(HAVE_BUILTIN_COS)
fi
AC_MSG_CHECKING([for __builtin_cosf])
AC_TRY_COMPILE([#include <math.h>],
[float foo(void) { __builtin_cosf(0.0); }],
[ __builtin_cosf(0.0);],
use_builtin_cosf=yes, use_builtin_cosf=no)
AC_MSG_RESULT($use_builtin_cosf)
if test $use_builtin_cosf = "yes"; then
AC_DEFINE(_GLIBCPP_HAS_BUILTIN_COSF)
AC_DEFINE(HAVE_BUILTIN_COSF)
fi
AC_MSG_CHECKING([for __builtin_cosl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_cosl(0.0);],
use_builtin_cosl=yes, use_builtin_cosl=no)
AC_MSG_RESULT($use_builtin_cosl)
if test $use_builtin_cosl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_COSL)
fi
AC_MSG_CHECKING([for __builtin_cosh])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_cosh(0.0);],
use_builtin_cosh=yes, use_builtin_cosh=no)
AC_MSG_RESULT($use_builtin_cosh)
if test $use_builtin_cosh = "yes"; then
AC_DEFINE(HAVE_BUILTIN_COSH)
fi
AC_MSG_CHECKING([for __builtin_coshf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_coshf(0.0);],
use_builtin_coshf=yes, use_builtin_coshf=no)
AC_MSG_RESULT($use_builtin_coshf)
if test $use_builtin_coshf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_COSHF)
fi
AC_MSG_CHECKING([for __builtin_coshl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_coshl(0.0);],
use_builtin_coshl=yes, use_builtin_coshl=no)
AC_MSG_RESULT($use_builtin_coshl)
if test $use_builtin_coshl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_COSHL)
fi
AC_MSG_CHECKING([for __builtin_exp])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_exp(0.0);],
use_builtin_exp=yes, use_builtin_exp=no)
AC_MSG_RESULT($use_builtin_exp)
if test $use_builtin_exp = "yes"; then
AC_DEFINE(HAVE_BUILTIN_EXP)
fi
AC_MSG_CHECKING([for __builtin_expf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_expf(0.0);],
use_builtin_expf=yes, use_builtin_expf=no)
AC_MSG_RESULT($use_builtin_expf)
if test $use_builtin_expf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_EXPF)
fi
AC_MSG_CHECKING([for __builtin_expl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_expl(0.0);],
use_builtin_expl=yes, use_builtin_expl=no)
AC_MSG_RESULT($use_builtin_expl)
if test $use_builtin_expl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_EXPL)
fi
AC_MSG_CHECKING([for __builtin_fabs])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fabs(0.0);],
use_builtin_fabs=yes, use_builtin_fabs=no)
AC_MSG_RESULT($use_builtin_fabs)
if test $use_builtin_fabs = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FABS)
fi
AC_MSG_CHECKING([for __builtin_fabsf])
AC_TRY_COMPILE([#include <math.h>],
[float foo(void) { __builtin_fabsf(0.0); }],
[ __builtin_fabsf(0.0);],
use_builtin_fabsf=yes, use_builtin_fabsf=no)
AC_MSG_RESULT($use_builtin_fabsf)
if test $use_builtin_fabsf = "yes"; then
AC_DEFINE(_GLIBCPP_HAS_BUILTIN_FABSF)
AC_DEFINE(HAVE_BUILTIN_FABSF)
fi
AC_MSG_CHECKING([for __builtin_fabsl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fabsl(0.0);],
use_builtin_fabsl=yes, use_builtin_fabsl=no)
AC_MSG_RESULT($use_builtin_fabsl)
if test $use_builtin_fabsl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FABSL)
fi
AC_MSG_CHECKING([for __builtin_floor])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ffloor(0.0);],
use_builtin_floor=yes, use_builtin_floor=no)
AC_MSG_RESULT($use_builtin_floor)
if test $use_builtin_floor = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FLOOR)
fi
AC_MSG_CHECKING([for __builtin_floorf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_floorf(0.0);],
use_builtin_floorf=yes, use_builtin_floorf=no)
AC_MSG_RESULT($use_builtin_floorf)
if test $use_builtin_floorf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FLOORF)
fi
AC_MSG_CHECKING([for __builtin_floorl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_floorl(0.0);],
use_builtin_floorl=yes, use_builtin_floorl=no)
AC_MSG_RESULT($use_builtin_floorl)
if test $use_builtin_floorl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FLOORL)
fi
AC_MSG_CHECKING([for __builtin_frexp])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_frexp(0.0);],
use_builtin_frexp=yes, use_builtin_frexp=no)
AC_MSG_RESULT($use_builtin_frexp)
if test $use_builtin_frexp = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FREXP)
fi
AC_MSG_CHECKING([for __builtin_frexpf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_frexpf(0.0);],
use_builtin_frexpf=yes, use_builtin_frexpf=no)
AC_MSG_RESULT($use_builtin_frexpf)
if test $use_builtin_frexpf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FREXPF)
fi
AC_MSG_CHECKING([for __builtin_frexpl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_frexpl(0.0);],
use_builtin_frexpl=yes, use_builtin_frexpl=no)
AC_MSG_RESULT($use_builtin_frexpl)
if test $use_builtin_frexpl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FREXPL)
fi
AC_MSG_CHECKING([for __builtin_ldexp])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ldexp(0.0);],
use_builtin_ldexp=yes, use_builtin_ldexp=no)
AC_MSG_RESULT($use_builtin_ldexp)
if test $use_builtin_ldexp = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LDEXP)
fi
AC_MSG_CHECKING([for __builtin_ldexpf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ldexpf(0.0);],
use_builtin_ldexpf=yes, use_builtin_ldexpf=no)
AC_MSG_RESULT($use_builtin_ldexpf)
if test $use_builtin_ldexpf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LDEXPF)
fi
AC_MSG_CHECKING([for __builtin_ldexpl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_ldexpl(0.0);],
use_builtin_ldexpl=yes, use_builtin_ldexpl=no)
AC_MSG_RESULT($use_builtin_ldexpl)
if test $use_builtin_ldexpl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LDEXPL)
fi
AC_MSG_CHECKING([for __builtin_log])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_log(0.0);],
use_builtin_log=yes, use_builtin_log=no)
AC_MSG_RESULT($use_builtin_log)
if test $use_builtin_log = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOG)
fi
AC_MSG_CHECKING([for __builtin_logf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_logf(0.0);],
use_builtin_logf=yes, use_builtin_logf=no)
AC_MSG_RESULT($use_builtin_logf)
if test $use_builtin_logf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOGF)
fi
AC_MSG_CHECKING([for __builtin_logl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_logl(0.0);],
use_builtin_logl=yes, use_builtin_logl=no)
AC_MSG_RESULT($use_builtin_logl)
if test $use_builtin_logl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOGL)
fi
AC_MSG_CHECKING([for __builtin_log10])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_log10(0.0);],
use_builtin_log10=yes, use_builtin_log10=no)
AC_MSG_RESULT($use_builtin_log10)
if test $use_builtin_log10 = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOG10)
fi
AC_MSG_CHECKING([for __builtin_log10f])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_log10f(0.0);],
use_builtin_log10f=yes, use_builtin_log10f=no)
AC_MSG_RESULT($use_builtin_log10f)
if test $use_builtin_log10f = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOG10F)
fi
AC_MSG_CHECKING([for __builtin_log10l])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_log10l(0.0);],
use_builtin_log10l=yes, use_builtin_log10l=no)
AC_MSG_RESULT($use_builtin_log10l)
if test $use_builtin_log10l = "yes"; then
AC_DEFINE(HAVE_BUILTIN_LOG10L)
fi
AC_MSG_CHECKING([for __builtin_modf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_modf(0.0);],
use_builtin_modf=yes, use_builtin_modf=no)
AC_MSG_RESULT($use_builtin_modf)
if test $use_builtin_modf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_MODF)
fi
AC_MSG_CHECKING([for __builtin_modff])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_modff(0.0);],
use_builtin_modff=yes, use_builtin_modff=no)
AC_MSG_RESULT($use_builtin_modff)
if test $use_builtin_modff = "yes"; then
AC_DEFINE(HAVE_BUILTIN_MODFF)
fi
AC_MSG_CHECKING([for __builtin_modfl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_modfl(0.0);],
use_builtin_modfl=yes, use_builtin_modfl=no)
AC_MSG_RESULT($use_builtin_modfl)
if test $use_builtin_modfl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_MODFL)
fi
AC_MSG_CHECKING([for __builtin_pow])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_pow(0.0);],
use_builtin_pow=yes, use_builtin_pow=no)
AC_MSG_RESULT($use_builtin_pow)
if test $use_builtin_pow = "yes"; then
AC_DEFINE(HAVE_BUILTIN_POW)
fi
AC_MSG_CHECKING([for __builtin_powf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_powf(0.0);],
use_builtin_powf=yes, use_builtin_powf=no)
AC_MSG_RESULT($use_builtin_powf)
if test $use_builtin_powf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_POWF)
fi
AC_MSG_CHECKING([for __builtin_powl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_powl(0.0);],
use_builtin_powl=yes, use_builtin_powl=no)
AC_MSG_RESULT($use_builtin_powl)
if test $use_builtin_powl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_POWL)
fi
AC_MSG_CHECKING([for __builtin_sin])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sin(0.0);],
use_builtin_sin=yes, use_builtin_sin=no)
AC_MSG_RESULT($use_builtin_sin)
if test $use_builtin_sin = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SIN)
fi
AC_MSG_CHECKING([for __builtin_sinf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sinf(0.0);],
use_builtin_sinf=yes, use_builtin_sinf=no)
AC_MSG_RESULT($use_builtin_sinf)
if test $use_builtin_sinf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SINF)
fi
AC_MSG_CHECKING([for __builtin_sinl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sinl(0.0);],
use_builtin_sinl=yes, use_builtin_sinl=no)
AC_MSG_RESULT($use_builtin_sinl)
if test $use_builtin_sinl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SINL)
fi
AC_MSG_CHECKING([for __builtin_sinh])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sinh(0.0);],
use_builtin_sinh=yes, use_builtin_sinh=no)
AC_MSG_RESULT($use_builtin_sinh)
if test $use_builtin_sinh = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SINH)
fi
AC_MSG_CHECKING([for __builtin_sinhf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sinhf(0.0);],
use_builtin_sinhf=yes, use_builtin_sinhf=no)
AC_MSG_RESULT($use_builtin_sinhf)
if test $use_builtin_sinhf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SINHF)
fi
AC_MSG_CHECKING([for __builtin_sinhl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sinhl(0.0);],
use_builtin_sinhl=yes, use_builtin_sinhl=no)
AC_MSG_RESULT($use_builtin_sinhl)
if test $use_builtin_sinhl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SINHL)
fi
AC_MSG_CHECKING([for __builtin_sqrt])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fsqrt(0.0);],
use_builtin_sqrt=yes, use_builtin_sqrt=no)
AC_MSG_RESULT($use_builtin_sqrt)
if test $use_builtin_sqrt = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SQRT)
fi
AC_MSG_CHECKING([for __builtin_sqrtf])
AC_TRY_COMPILE([#include <math.h>],
[float foo(void) { __builtin_sqrtf(0.0); }],
[ __builtin_sqrtf(0.0);],
use_builtin_sqrtf=yes, use_builtin_sqrtf=no)
AC_MSG_RESULT($use_builtin_sqrtf)
if test $use_builtin_sqrtf = "yes"; then
AC_DEFINE(_GLIBCPP_HAS_BUILTIN_SQRTF)
AC_DEFINE(HAVE_BUILTIN_SQRTF)
fi
AC_MSG_CHECKING([for __builtin_sqrtl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_sqrtl(0.0);],
use_builtin_sqrtl=yes, use_builtin_sqrtl=no)
AC_MSG_RESULT($use_builtin_sqrtl)
if test $use_builtin_sqrtl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_SQRTL)
fi
AC_MSG_CHECKING([for __builtin_tan])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tan(0.0);],
use_builtin_tan=yes, use_builtin_tan=no)
AC_MSG_RESULT($use_builtin_tan)
if test $use_builtin_tan = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TAN)
fi
AC_MSG_CHECKING([for __builtin_tanf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tanf(0.0);],
use_builtin_tanf=yes, use_builtin_tanf=no)
AC_MSG_RESULT($use_builtin_tanf)
if test $use_builtin_tanf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TANF)
fi
AC_MSG_CHECKING([for __builtin_tanl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tanl(0.0);],
use_builtin_tanl=yes, use_builtin_tanl=no)
AC_MSG_RESULT($use_builtin_tanl)
if test $use_builtin_tanl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TANL)
fi
AC_MSG_CHECKING([for __builtin_tanh])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tanh(0.0);],
use_builtin_tanh=yes, use_builtin_tanh=no)
AC_MSG_RESULT($use_builtin_tanh)
if test $use_builtin_tanh = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TANH)
fi
AC_MSG_CHECKING([for __builtin_tanhf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tanhf(0.0);],
use_builtin_tanhf=yes, use_builtin_tanhf=no)
AC_MSG_RESULT($use_builtin_tanhf)
if test $use_builtin_tanhf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TANHF)
fi
AC_MSG_CHECKING([for __builtin_tanhl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_tanhl(0.0);],
use_builtin_tanhl=yes, use_builtin_tanhl=no)
AC_MSG_RESULT($use_builtin_tanhl)
if test $use_builtin_tanhl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_TANHL)
fi
AC_LANG_RESTORE
])
dnl Check to see what architecture we are compiling for. If it's
dnl supported, use special hand-crafted routines to provide thread
dnl primitives. Also, if architecture-specific flags are required for
@ -508,20 +1038,26 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l))
AC_SUBST(USE_LONG_DOUBLE)
dnl Check to see if basic C math functions have faster float versions.
AC_CHECK_FUNCS(modf isnan isnanf isnanl isinf isinff isinfl copysign \
copysignl cosf coshf logf log10f powf sinf sinhf sqrtf tanf tanhf \
strtof strtold fabsf sincos sincosf sincosl finite finite fqfinite \
fpclass qfpclass)
dnl Check to see if basic C math functions have float, long double versions.
AC_CHECK_FUNCS(isnan isnanf isnanl isinf isinff isinfl copysign copysignl \
acosf acosl asinf asinl atanf atanl atan2f atan2l ceilf ceill cosf cosl \
coshf coshl expf expl fabsf fabsl floorf floorl frexpf frexpl ldexpf \
ldexpl logf logl log10f log10l modf modff modfl powf powl sinf sinl sinhf \
sinhl sqrtf sqrtl tanf tanl tanhf tanhl strtof strtold sincos sincosf \
sincosl finite finitef finitel fqfinite fpclass qfpclass)
#Some runtimes have these functions with a preceding underscore. Please
# keep this sync'd with the one above. And if you add any new symbol,
# please add the corresponding block in the @BOTTOM@ section of
# acconfig.h.
AC_CHECK_FUNCS(_modf _isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \
_copysignl _cosf _coshf _logf _log10f _powf _sinf _sinhf _sqrtf _tanf _tanhf \
_strtof _strtold _fabsf _sincos _sincosf _sincosl _finite _finitef _qfinite \
_fpclass _qfpclass)
AC_CHECK_FUNCS(_isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \
_copysignl _acosf _acosl _asinf _asinl _atanf _atanl _atan2f _atan2l \
_ceilf _ceill _cosf _cosl _coshf _coshl _expf _expl _fabsf _fabsl \
_floorf _floorl _frexpf _frexpl _ldexpf _ldexpl _logf _logl _log10f \
_log10l _modf _modff _modfl _powf _powl _sinf _sinl _sinhf _sinhl _sqrtf \
_sqrtl _tanf _tanl _tanhf _tanhl _strtof _strtold _sincos _sincosf _sincosl \
_finite _finitef _finitel _fqfinite _fpclass _qfpclass)
LIBS="$save_LIBS"
])

823
libstdc++-v3/bits/std_cmath.h
View File

@ -39,207 +39,652 @@
# include_next <math.h>
# include_next <stdlib.h>
#include <bits/c++config.h>
# include <bits/c++config.h>
namespace std {
inline long
abs(long __l) { return ::labs(__l); }
//
// float
//
inline ldiv_t
div(long __a, long __b) { return ::ldiv(__a, __b); }
// double
inline double
abs(double __x) { return ::fabs(__x); }
double
pow(double, int);
// float
inline float
ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
inline float
floor(float __x) { return ::floor(static_cast<double>(__x)); }
inline float
fmod(float __x, float __y)
{ return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
inline float
frexp(float __x, int* __p)
{ return ::frexp(static_cast<double>(__x), __p); }
inline float
ldexp(float __x, int __i)
{ return ::ldexp(static_cast<double>(__x), __i); }
inline float
pow(float __x, float __y)
{ return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
float
pow(float, int);
#if _GLIBCPP_HAVE_ABSF
inline float
abs(float __x) { return ::absf(__x); }
#else
inline float
abs(float __x) { return ::fabs(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_ACOSF
inline float
acos(float __x) { return ::acosf(__x); }
#else
inline float
acos(float __x) { return ::acos(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_ASINF
inline float
asin(float __x) { return ::asinf(__x); }
#else
inline float
asin(float __x) { return ::asin(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_ATANF
inline float
atan(float __x) { return ::atanf(__x); }
#else
inline float
atan(float __x) { return ::atan(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_ATAN2F
inline float
atan2(float __x, float __y) { return ::atan2f(__x, __y); }
#else
inline float
atan2(float __x, float __y)
{ return ::atan2(static_cast<double>(__x), static_cast<double>(__y)); }
#endif
#if _GLIBCPP_HAVE_TANF
inline float
tan(float __x) { return ::tanf(__x); }
#else
inline float
tan(float __x) { return ::tan(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_SINHF
inline float
sinh(float __x) { return ::sinhf(__x); }
#else
inline float
sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_TANHF
inline float
tanh(float __x) { return ::tanhf(__x); }
#else
inline float
tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_COSHF
inline float
cosh(float __x) { return ::coshf(__x); }
#else
inline float
cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_EXPF
inline float
exp(float __x) { return ::expf(__x); }
#else
inline float
exp(float __x) { return ::exp(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_LOGF
inline float
log(float __x) { return ::logf(__x); }
#else
inline float
log(float __x) { return ::log(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_LOG10F
inline float
log10(float __x) { return ::log10f(__x); }
#else
inline float
log10(float __x) { return ::log10(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_MODFF
inline float
modf(float __x, float* __p) { return ::modff(__x, __p); }
#else
inline float
modf(float __x, float* __p)
{
double __tmp;
double __res = ::modf(static_cast<double>(__x), &__tmp);
*__p = static_cast<float> (__tmp);
return __res;
}
#endif
#if GLIBCPP_HAS_BUILTIN_SINF
inline float
sin(float __x) { return __builtin_sinf(__x); }
#elif _GLIBCPP_HAVE_SINF
inline float
sin(float __x) { return ::sinf(__x); }
#else
inline float
sin(float __x) { return ::sin(static_cast<double>(__x)); }
#endif
#if GLIBCPP_HAS_BUILTIN_COSF
inline float
cos(float __x) { return __builtin_cosf(__x); }
#elif _GLIBCPP_HAVE_COSF
inline float
cos(float __x) { return ::cosf(__x); }
#else
inline float
cos(float __x) { return ::cos(static_cast<double>(__x)); }
#endif
#if GLIBCPP_HAS_BUILTIN_FABSF
inline float
fabs(float __x) { return __builtin_fabsf(__x); }
#if _GLIBCPP_HAVE_BUILTIN_FABSF
inline float abs(float __x)
{ return __builtin_fabsf(__x); }
#elif _GLIBCPP_HAVE_FABSF
inline float
fabs(float __x) { return ::fabsf(__x); }
inline float abs(float __x)
{ return ::fabsf(__x); }
#else
inline float
fabs(float __x) { return ::fabs(static_cast<double>(__x)); }
inline float abs(float __x)
{ return ::fabs(static_cast<double>(__x)); }
#endif
#if GLIBCPP_HAS_BUILTIN_SQRTF
inline float
sqrt(float __x) { return __builtin_sqrtf(__x); }
#if _GLIBCPP_HAVE_BUILTIN_ACOSF
inline float acos(float __x)
{ return __builtin_acosf(__x); }
#elif _GLIBCPP_HAVE_ACOSF
inline float acos(float __x)
{ return ::acosf(__x); }
#else
inline float acos(float __x)
{ return ::acos(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ASINF
inline float asin(float __x)
{ return __builtin_asinf(__x); }
#elif _GLIBCPP_HAVE_ASINF
inline float asin(float __x)
{ return ::asinf(__x); }
#else
inline float asin(float __x)
{ return ::asin(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATANF
inline float atan(float __x)
{ return __builtin_atanf(__x); }
#elif _GLIBCPP_HAVE_ATANF
inline float atan(float __x)
{ return ::atanf(__x); }
#else
inline float atan(float __x)
{ return ::atan(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATAN2F
inline float atan2(float __y, float __x)
{ return __builtin_atan2f(__y, __x); }
#elif _GLIBCPP_HAVE_ATAN2F
inline float atan2(float __y, float __x)
{ return ::atan2f(__y, __x); }
#else
inline float atan2(float __y, float __x)
{ return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_CEILF
inline float ceil(float __x)
{ return __builtin_ceilf(__x); }
#elif _GLIBCPP_HAVE_CEILF
inline float ceil(float __x)
{ return ::ceilf(__x); }
#else
inline float ceil(float __x)
{ return ::ceil(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSF
inline float cos(float __x)
{ return __builtin_cosf(__x); }
#elif _GLIBCPP_HAVE_COSF
inline float cos(float __x)
{ return ::cosf(__x); }
#else
inline float cos(float __x)
{ return ::cos(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSHF
inline float cosh(float __x)
{ return __builtin_coshf(__x); }
#elif _GLIBCPP_HAVE_COSHF
inline float cosh(float __x)
{ return ::coshf(__x); }
#else
inline float cosh(float __x)
{ return ::cosh(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_EXPF
inline float exp(float __x)
{ return __builtin_expf(__x); }
#elif _GLIBCPP_HAVE_EXPF
inline float exp(float __x)
{ return ::expf(__x); }
#else
inline float exp(float __x)
{ return ::exp(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FABSF
inline float fabs(float __x)
{ return __builtin_fabsf(__x); }
#elif _GLIBCPP_HAVE_FABSF
inline float fabs(float __x)
{ return ::fabsf(__x); }
#else
inline float fabs(float __x)
{ return ::fabs(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FLOORF
inline float floor(float __x)
{ return __builtin_floorf(__x); }
#elif _GLIBCPP_HAVE_FLOORF
inline float floor(float __x)
{ return ::floorf(__x); }
#else
inline float floor(float __x)
{ return ::floor(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FMODFF
inline float fmod(float __x, float __y)
{ return __builtin_fmodf(__x, __y); }
#elif _GLIBCPP_HAVE_FMODFF
inline float fmod(float __x, float __y)
{ return ::fmodf(__x, __y); }
#else
inline float fmod(float __x, float __y)
{ return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FREXPF
inline float frexp(float __x, int* __exp)
{ return __builtin_frexpf(__x, __exp); }
#elif _GLIBCPP_HAVE_FREXPF
inline float frexp(float __x, int* __exp)
{ return ::frexpf(__x, __exp); }
#else
inline float frexp(float __x, int* __exp)
{ return ::frexp(__x, __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LDEXPF
inline float ldexp(float __x, int __exp)
{ return __builtin_ldexpf(__x, __exp); }
#elif _GLIBCPP_HAVE_LDEXPF
inline float ldexp(float __x, int __exp)
{ return ::ldexpf(__x, __exp); }
#else
inline float ldexp(float __x, int __exp)
{ return ::ldexp(static_cast<double>(__x), __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOGF
inline float log(float __x)
{ return __builtin_logf(__x); }
#elif _GLIBCPP_HAVE_LOGF
inline float log(float __x)
{ return ::logf(__x); }
#else
inline float log(float __x)
{ return ::log(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOG10F
inline float log10(float __x)
{ return __builtin_log10f(__x); }
#elif _GLIBCPP_HAVE_LOG10F
inline float log10(float __x)
{ return ::log10f(__x); }
#else
inline float log10(float __x)
{ return ::log10(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_MODF
inline float modf(float __x, float* __iptr)
{ return __builtin_modff(__x, __iptr); }
#elif _GLIBCPP_HAVE_MODF
inline float modf(float __x, float* __iptr)
{ return ::modff(__x, __iptr); }
#else
inline float modf(float __x, float* __iptr)
{
double __tmp;
double __res = _C_legacy::modf(static_cast<double>(__x), &__tmp);
*__iptr = static_cast<float> (__tmp);
return __res;
}
#endif
#if _GLIBCPP_HAVE_BUILTIN_POWF
inline float pow(float __x, float __y)
{ return __builtin_powf(__x, __y); }
#elif _GLIBCPP_HAVE_POWF
inline float pow(float __x, float __y)
{ return ::powf(__x, __y); }
#else
inline float pow(float __x, float __y)
{ return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
#endif
float pow (float, int);
#if _GLIBCPP_HAVE_BUILTIN_SINF
inline float sin(float __x)
{ return __builtin_sinf(__x); }
#elif _GLIBCPP_HAVE_SINF
inline float sin(float __x)
{ return ::sinf(__x); }
#else
inline float sin(float __x)
{ return ::sin(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SINHF
inline float sinh(float __x)
{ return __builtin_sinhf(__x); }
#elif _GLIBCPP_HAVE_SINHF
inline float sinh(float __x)
{ return ::sinhf(__x); }
#else
inline float sinh(float __x)
{ return ::sinh(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SQRTF
inline float sqrt(float __x)
{ return __builtin_sqrtf(__x); }
#elif _GLIBCPP_HAVE_SQRTF
inline float
sqrt(float __x) { return ::sqrtf(__x); }
inline float sqrt(float __x)
{ return ::sqrtf(__x); }
#else
inline float
sqrt(float __x) { return ::sqrt(static_cast<double>(__x)); }
inline float sqrt(float __x)
{ return ::sqrt(static_cast<double>(__x)); }
#endif
// XXX long double
long double
pow(long double, int);
#if _GLIBCPP_HAVE_BUILTIN_TANF
inline float tan(float __x)
{ return __builtin_tanf(__x); }
#elif _GLIBCPP_HAVE_TANF
inline float tan(float __x)
{ return ::tanf(__x); }
#else
inline float tan(float __x)
{ return ::tan(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANHF
inline float tanh(float __x)
{ return __builtin_tanhf(__x); }
#elif _GLIBCPP_HAVE_TANHF
inline float tanh(float __x)
{ return ::tanhf(__x); }
#else
inline float tanh(float __x)
{ return ::tanh(static_cast<double>(__x)); }
#endif
//
// double
//
#if _GLIBCPP_HAVE_BUILTIN_FABS
inline double abs(double __x)
{ return __builtin_fabs(__x); }
#else
inline double abs(double __x)
{ return ::fabs(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ACOS
inline double acos(double __x)
{ return __builtin_acos(__x); }
#else
inline double acos(double __x)
{ return ::acos(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ASIN
inline double asin(double __x)
{ return __builtin_asin(__x); }
#else
inline double asin(double __x)
{ return ::asin(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATAN
inline double atan(double __x)
{ return __builtin_atan(__x); }
#else
inline double atan(double __x)
{ return ::atan(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATAN2
inline double atan2(double __y, double __x)
{ return __builtin_atan2(__y, __x); }
#else
inline double atan2(double __y, double __x)
{ return ::atan2(__y, __x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_CEIL
inline double ceil(double __x)
{ return __builtin_fceil(__x); }
#else
inline double ceil(double __x)
{ return ::ceil(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COS
inline double cos(double __x)
{ return __builtin_cos(__x); }
#else
inline double cos(double __x)
{ return ::cos(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSH
inline double cosh(double __x)
{ return __builtin_cosh(__x); }
#else
inline double cosh(double __x)
{ return ::cosh(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_EXP
inline double exp(double __x)
{ return __builtin_exp(__x); }
#else
inline double exp(double __x)
{ return ::exp(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FABS
inline double fabs(double __x)
{ return __builtin_fabs(__x); }
#else
inline double fabs(double __x)
{ return ::fabs(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FLOOR
inline double floor(double __x)
{ return __builtin_ffloor(__x); }
#else
inline double floor(double __x)
{ return ::floor(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FMOD
inline double fmod(double __x, double __y)
{ return __builtin_fmod(__x, __y); }
#else
inline double fmod(double __x, double __y)
{ return ::fmod(__x, __y); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FREXP
inline double frexp(double __x, int* __exp)
{ return __builtin_frexp(__x, __exp); }
#else
inline double frexp(double __x, int* __exp)
{ return ::frexp(__x, __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LDEXP
inline double ldexp(double __x, int __exp)
{ return __builtin_ldexp(__x, __exp); }
#else
inline double ldexp(double __x, int __exp)
{ return ::ldexp(__x, __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOG
inline double log(double __x)
{ return __builtin_log(__x); }
#else
inline double log(double __x)
{ return ::log(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOG10
inline double log10(double __x)
{ return __builtin_log10(__x); }
#else
inline double log10(double __x)
{ return ::log10(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_MODF
inline double modf(double __x, double* __iptr)
{ return __builtin_modf(__x, __iptr); }
#else
inline double modf(double __x, double* __iptr)
{ return ::modf(__x, __iptr); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_POW
inline double pow(double __x, double __y)
{ return __builtin_pow(__x, static_cast<double>(__y)); }
#else
inline double pow(double __x, double __y)
{ return ::pow(__x, __y); }
#endif
double pow (double, int);
#if _GLIBCPP_HAVE_BUILTIN_SIN
inline double sin(double __x)
{ return __builtin_sin(__x); }
#else
inline double sin(double __x)
{ return ::sin(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SINH
inline double sinh(double __x)
{ return __builtin_sinh(__x); }
#else
inline double sinh(double __x)
{ return ::sinh(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SQRT
inline double sqrt(double __x)
{ return __builtin_fsqrt(__x); }
#else
inline double sqrt(double __x)
{ return ::sqrt(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TAN
inline double tan(double __x)
{ return __builtin_tan(__x); }
#else
inline double tan(double __x)
{ return ::tan(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANH
inline double tanh(double __x)
{ return __builtin_tanh(__x); }
#else
inline double tanh(double __x)
{ return ::tanh(__x); }
#endif
//
// long double
//
#if _GLIBCPP_HAVE_BUILTIN_FABSL
inline long double abs(long double __x)
{ return __builtin_fabsl(__x); }
#elif _GLIBCPP_HAVE_FABSL
inline long double abs(long double __x)
{ return ::fabsl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ACOSL
inline long double acos(long double __x)
{ return __builtin_acosl(__x); }
#elif _GLIBCPP_HAVE_ACOSL
inline long double acos(long double __x)
{ return ::acosl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ASINL
inline long double asin(long double __x)
{ return __builtin_asinl(__x); }
#elif _GLIBCPP_HAVE_ASINL
inline long double asin(long double __x)
{ return ::asinl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATANL
inline long double atan(long double __x)
{ return __builtin_atanl(__x); }
#elif _GLIBCPP_HAVE_ATANL
inline long double atan(long double __x)
{ return ::atanl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATAN2L
inline long double atan2(long double __y, long double __x)
{ return __builtin_atan2l(__y, __x); }
#elif _GLIBCPP_HAVE_ATAN2L
inline long double atan2(long double __y, long double __x)
{ return ::atan2l(__y, __x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_CEILL
inline long double ceil(long double __x)
{ return __builtin_ceill(__x); }
#elif _GLIBCPP_HAVE_CEILL
inline long double ceil(long double __x)
{ return ::ceill(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSL
inline long double cos(long double __x)
{ return __builtin_cosl(__x); }
#elif _GLIBCPP_HAVE_COSL
inline long double cos(long double __x)
{ return ::cosl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSHL
inline long double cosh(long double __x)
{ return __builtin_coshl(__x); }
#elif _GLIBCPP_HAVE_COSHL
inline long double cosh(long double __x)
{ return ::coshl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_EXPL
inline long double exp(long double __x)
{ return __builtin_expl(__x); }
#elif _GLIBCPP_HAVE_EXPL
inline long double exp(long double __x)
{ return ::expl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FABSL
inline long double fabs(long double __x)
{ return __builtin_fabsl(__x); }
#elif _GLIBCPP_HAVE_FABSL
inline long double fabs(long double __x)
{ return ::fabsl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FLOORL
inline long double floor(long double __x)
{ return __builtin_floorl(__x); }
#elif _GLIBCPP_HAVE_FLOORL
inline long double floor(long double __x)
{ return ::floorl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FMODL
inline long double fmod(long double __x, long double __y)
{ return __builtin_fmodl(__x, __y); }
#elif _GLIBCPP_HAVE_FMODL
inline long double fmod(long double __x, long double __y)
{ return ::fmodl(__x, __y); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FREXPL
inline long double frexp(long double __x, int* __exp)
{ return __builtin_frexpl(__x, __exp); }
#elif _GLIBCPP_HAVE_FREXPL
inline long double frexp(long double __x, int* __exp)
{ return ::frexpl(__x, __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LDEXPL
inline long double ldexp(long double __x, int __exp)
{ return __builtin_ldexpl(__x, __exp); }
#elif _GLIBCPP_HAVE_LDEXPL
inline long double ldexp(long double __x, int __exp)
{ return ::ldexpl(__x, __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOGL
inline long double log(long double __x)
{ return __builtin_logl(__x); }
#elif _GLIBCPP_HAVE_LOGL
inline long double log(long double __x)
{ return ::logl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOG10L
inline long double log10(long double __x)
{ return __builtin_log10l(__x); }
#elif _GLIBCPP_HAVE_LOG10L
inline long double log10(long double __x)
{ return ::log10l(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_MODFL
inline long double mod(long double __x, long double* __iptr)
{ return __builtin_modfl(__x, __iptr); }
#elif _GLIBCPP_HAVE_MODFL
inline long double modf(long double __x, long double* __iptr)
{ return ::modfl(__x, __iptr); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_POWL
inline long double pow(long double __x, long double __y)
{ return __builtin_powl(__x, __y); }
#elif _GLIBCPP_HAVE_POWL
inline long double pow(long double __x, long double __y)
{ return ::powl(__x, __y); }
#endif
long double pow(long double, int);
#if _GLIBCPP_HAVE_BUILTIN_SINL
inline long double sin(long double __x)
{ return __builtin_sinl(__x); }
#elif _GLIBCPP_HAVE_SINL
inline long double sin(long double __x)
{ return ::sinl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SINHL
inline long double sinh(long double __x)
{ return __builtin_sinhl(__x); }
#elif _GLIBCPP_HAVE_SINHL
inline long double sinh(long double __x)
{ return ::sinhl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SQRTL
inline long double sqrt(long double __x)
{ return __builtin_sqrtl(__x); }
#elif _GLIBCPP_HAVE_SQRTL
inline long double sqrt(long double __x)
{ return ::sqrtl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANL
inline long double tan(long double __x)
{ return __builtin_tanl(__x); }
#elif _GLIBCPP_HAVE_TANL
inline long double tan(long double __x)
{ return ::tanl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANHL
inline long double tanh(long double __x)
{ return __builtin_tanhl(__x); }
#elif _GLIBCPP_HAVE_TANHL
inline long double tanh(long double __x)
{ return ::tanhl(__x); }
#endif
} // std

561
libstdc++-v3/config.h.in
View File

@ -15,17 +15,194 @@
// Define if code specialized for wchar_t should be used.
#undef _GLIBCPP_USE_WCHAR_T
// Define if the compiler/host combination has __builtin_sinf defined.
#undef _GLIBCPP_HAS_BUILTIN_SINF
// Define if the compiler/host combination has __builtin_acos
#undef HAVE_BUILTIN_ACOS
// Define if the compiler/host combination has __builtin_cosf defined.
#undef _GLIBCPP_HAS_BUILTIN_COSF
// Define if the compiler/host combination has __builtin_acosf
#undef HAVE_BUILTIN_ACOSF
// Define if the compiler/host combination has __builtin_fabsf defined.
#undef _GLIBCPP_HAS_BUILTIN_FABSF
// Define if the compiler/host combination has __builtin_acosl
#undef HAVE_BUILTIN_ACOSL
// Define if the compiler/host combination has __builtin_fabsf defined.
#undef _GLIBCPP_HAS_BUILTIN_SQRTF
// Define if the compiler/host combination has __builtin_asin
#undef HAVE_BUILTIN_ASIN
// Define if the compiler/host combination has __builtin_asinf
#undef HAVE_BUILTIN_ASINF
// Define if the compiler/host combination has __builtin_asinl
#undef HAVE_BUILTIN_ASINL
// Define if the compiler/host combination has __builtin_atan
#undef HAVE_BUILTIN_ATAN
// Define if the compiler/host combination has __builtin_atanf
#undef HAVE_BUILTIN_ATANF
// Define if the compiler/host combination has __builtin_atanl
#undef HAVE_BUILTIN_ATANL
// Define if the compiler/host combination has __builtin_atan2
#undef HAVE_BUILTIN_ATAN2
// Define if the compiler/host combination has __builtin_atan2f
#undef HAVE_BUILTIN_ATAN2F
// Define if the compiler/host combination has __builtin_atan2l
#undef HAVE_BUILTIN_ATAN2L
// Define if the compiler/host combination has __builtin_ceil
#undef HAVE_BUILTIN_CEIL
// Define if the compiler/host combination has __builtin_ceilf
#undef HAVE_BUILTIN_CEILF
// Define if the compiler/host combination has __builtin_ceill
#undef HAVE_BUILTIN_CEILL
// Define if the compiler/host combination has __builtin_cos
#undef HAVE_BUILTIN_COS
// Define if the compiler/host combination has __builtin_cosf
#undef HAVE_BUILTIN_COSF
// Define if the compiler/host combination has __builtin_cosl
#undef HAVE_BUILTIN_COSL
// Define if the compiler/host combination has __builtin_cosh
#undef HAVE_BUILTIN_COSH
// Define if the compiler/host combination has __builtin_coshf
#undef HAVE_BUILTIN_COSHF
// Define if the compiler/host combination has __builtin_coshl
#undef HAVE_BUILTIN_COSHL
// Define if the compiler/host combination has __builtin_exp
#undef HAVE_BUILTIN_EXP
// Define if the compiler/host combination has __builtin_expf
#undef HAVE_BUILTIN_EXPF
// Define if the compiler/host combination has __builtin_expl
#undef HAVE_BUILTIN_EXPL
// Define if the compiler/host combination has __builtin_fabs
#undef HAVE_BUILTIN_FABS
// Define if the compiler/host combination has __builtin_fabsf
#undef HAVE_BUILTIN_FABSF
// Define if the compiler/host combination has __builtin_fabsl
#undef HAVE_BUILTIN_FABSL
// Define if the compiler/host combination has __builtin_floor
#undef HAVE_BUILTIN_FLOOR
// Define if the compiler/host combination has __builtin_floorf
#undef HAVE_BUILTIN_FLOORF
// Define if the compiler/host combination has __builtin_floorl
#undef HAVE_BUILTIN_FLOORL
// Define if the compiler/host combination has __builtin_frexp
#undef HAVE_BUILTIN_FREXP
// Define if the compiler/host combination has __builtin_frexpf
#undef HAVE_BUILTIN_FREXPF
// Define if the compiler/host combination has __builtin_frexpl
#undef HAVE_BUILTIN_FREXPL
// Define if the compiler/host combination has __builtin_ldexp
#undef HAVE_BUILTIN_LDEXP
// Define if the compiler/host combination has __builtin_ldexpf
#undef HAVE_BUILTIN_LDEXPF
// Define if the compiler/host combination has __builtin_ldexpl
#undef HAVE_BUILTIN_LDEXPL
// Define if the compiler/host combination has __builtin_log
#undef HAVE_BUILTIN_LOG
// Define if the compiler/host combination has __builtin_logf
#undef HAVE_BUILTIN_LOGF
// Define if the compiler/host combination has __builtin_logl
#undef HAVE_BUILTIN_LOGL
// Define if the compiler/host combination has __builtin_log10
#undef HAVE_BUILTIN_LOG10
// Define if the compiler/host combination has __builtin_log10f
#undef HAVE_BUILTIN_LOG10F
// Define if the compiler/host combination has __builtin_log10l
#undef HAVE_BUILTIN_LOG10L
// Define if the compiler/host combination has __builtin_modf
#undef HAVE_BUILTIN_MODF
// Define if the compiler/host combination has __builtin_modff
#undef HAVE_BUILTIN_MODFF
// Define if the compiler/host combination has __builtin_modfl
#undef HAVE_BUILTIN_MODFL
// Define if the compiler/host combination has __builtin_pow
#undef HAVE_BUILTIN_POW
// Define if the compiler/host combination has __builtin_powf
#undef HAVE_BUILTIN_POWF
// Define if the compiler/host combination has __builtin_powl
#undef HAVE_BUILTIN_POWL
// Define if the compiler/host combination has __builtin_sin
#undef HAVE_BUILTIN_SIN
// Define if the compiler/host combination has __builtin_sinf
#undef HAVE_BUILTIN_SINF
// Define if the compiler/host combination has __builtin_sinl
#undef HAVE_BUILTIN_SINL
// Define if the compiler/host combination has __builtin_sinh
#undef HAVE_BUILTIN_SINH
// Define if the compiler/host combination has __builtin_sinhf
#undef HAVE_BUILTIN_SINHF
// Define if the compiler/host combination has __builtin_sinhl
#undef HAVE_BUILTIN_SINHL
// Define if the compiler/host combination has __builtin_sqrt
#undef HAVE_BUILTIN_SQRT
// Define if the compiler/host combination has __builtin_sqrtf
#undef HAVE_BUILTIN_SQRTF
// Define if the compiler/host combination has __builtin_sqrtl
#undef HAVE_BUILTIN_SQRTL
// Define if the compiler/host combination has __builtin_tan
#undef HAVE_BUILTIN_TAN
// Define if the compiler/host combination has __builtin_tanf
#undef HAVE_BUILTIN_TANF
// Define if the compiler/host combination has __builtin_tanl
#undef HAVE_BUILTIN_TANL
// Define if the compiler/host combination has __builtin_tanh
#undef HAVE_BUILTIN_TANH
// Define if the compiler/host combination has __builtin_tanhf
#undef HAVE_BUILTIN_TANHF
// Define if the compiler/host combination has __builtin_tanhl
#undef HAVE_BUILTIN_TANHL
// Define if GCC support for __complex__ float is buggy.
#undef _GLIBCPP_BUGGY_FLOAT_COMPLEX
@ -42,6 +219,36 @@
// Define if modf is present in <math.h>
#undef HAVE_MODF
/* Define if you have the _acosf function. */
#undef HAVE__ACOSF
/* Define if you have the _acosl function. */
#undef HAVE__ACOSL
/* Define if you have the _asinf function. */
#undef HAVE__ASINF
/* Define if you have the _asinl function. */
#undef HAVE__ASINL
/* Define if you have the _atan2f function. */
#undef HAVE__ATAN2F
/* Define if you have the _atan2l function. */
#undef HAVE__ATAN2L
/* Define if you have the _atanf function. */
#undef HAVE__ATANF
/* Define if you have the _atanl function. */
#undef HAVE__ATANL
/* Define if you have the _ceilf function. */
#undef HAVE__CEILF
/* Define if you have the _ceill function. */
#undef HAVE__CEILL
/* Define if you have the _copysign function. */
#undef HAVE__COPYSIGN
@ -54,18 +261,51 @@
/* Define if you have the _coshf function. */
#undef HAVE__COSHF
/* Define if you have the _coshl function. */
#undef HAVE__COSHL
/* Define if you have the _cosl function. */
#undef HAVE__COSL
/* Define if you have the _expf function. */
#undef HAVE__EXPF
/* Define if you have the _expl function. */
#undef HAVE__EXPL
/* Define if you have the _fabsf function. */
#undef HAVE__FABSF
/* Define if you have the _fabsl function. */
#undef HAVE__FABSL
/* Define if you have the _finite function. */
#undef HAVE__FINITE
/* Define if you have the _finitef function. */
#undef HAVE__FINITEF
/* Define if you have the _finitel function. */
#undef HAVE__FINITEL
/* Define if you have the _floorf function. */
#undef HAVE__FLOORF
/* Define if you have the _floorl function. */
#undef HAVE__FLOORL
/* Define if you have the _fpclass function. */
#undef HAVE__FPCLASS
/* Define if you have the _fqfinite function. */
#undef HAVE__FQFINITE
/* Define if you have the _frexpf function. */
#undef HAVE__FREXPF
/* Define if you have the _frexpl function. */
#undef HAVE__FREXPL
/* Define if you have the _isinf function. */
#undef HAVE__ISINF
@ -84,20 +324,38 @@
/* Define if you have the _isnanl function. */
#undef HAVE__ISNANL
/* Define if you have the _ldexpf function. */
#undef HAVE__LDEXPF
/* Define if you have the _ldexpl function. */
#undef HAVE__LDEXPL
/* Define if you have the _log10f function. */
#undef HAVE__LOG10F
/* Define if you have the _log10l function. */
#undef HAVE__LOG10L
/* Define if you have the _logf function. */
#undef HAVE__LOGF
/* Define if you have the _logl function. */
#undef HAVE__LOGL
/* Define if you have the _modf function. */
#undef HAVE__MODF
/* Define if you have the _modff function. */
#undef HAVE__MODFF
/* Define if you have the _modfl function. */
#undef HAVE__MODFL
/* Define if you have the _powf function. */
#undef HAVE__POWF
/* Define if you have the _qfinite function. */
#undef HAVE__QFINITE
/* Define if you have the _powl function. */
#undef HAVE__POWL
/* Define if you have the _qfpclass function. */
#undef HAVE__QFPCLASS
@ -117,9 +375,18 @@
/* Define if you have the _sinhf function. */
#undef HAVE__SINHF
/* Define if you have the _sinhl function. */
#undef HAVE__SINHL
/* Define if you have the _sinl function. */
#undef HAVE__SINL
/* Define if you have the _sqrtf function. */
#undef HAVE__SQRTF
/* Define if you have the _sqrtl function. */
#undef HAVE__SQRTL
/* Define if you have the _strtof function. */
#undef HAVE__STRTOF
@ -132,9 +399,36 @@
/* Define if you have the _tanhf function. */
#undef HAVE__TANHF
/* Define if you have the _tanhl function. */
#undef HAVE__TANHL
/* Define if you have the _tanl function. */
#undef HAVE__TANL
/* Define if you have the acosf function. */
#undef HAVE_ACOSF
/* Define if you have the acosl function. */
#undef HAVE_ACOSL
/* Define if you have the asinf function. */
#undef HAVE_ASINF
/* Define if you have the asinl function. */
#undef HAVE_ASINL
/* Define if you have the atan2f function. */
#undef HAVE_ATAN2F
/* Define if you have the atan2l function. */
#undef HAVE_ATAN2L
/* Define if you have the atanf function. */
#undef HAVE_ATANF
/* Define if you have the atanl function. */
#undef HAVE_ATANL
/* Define if you have the c_log function. */
#undef HAVE_C_LOG
@ -171,6 +465,12 @@
/* Define if you have the ccosl function. */
#undef HAVE_CCOSL
/* Define if you have the ceilf function. */
#undef HAVE_CEILF
/* Define if you have the ceill function. */
#undef HAVE_CEILL
/* Define if you have the cexp function. */
#undef HAVE_CEXP
@ -204,6 +504,12 @@
/* Define if you have the coshf function. */
#undef HAVE_COSHF
/* Define if you have the coshl function. */
#undef HAVE_COSHL
/* Define if you have the cosl function. */
#undef HAVE_COSL
/* Define if you have the cpow function. */
#undef HAVE_CPOW
@ -261,18 +567,42 @@
/* Define if you have the expf function. */
#undef HAVE_EXPF
/* Define if you have the expl function. */
#undef HAVE_EXPL
/* Define if you have the fabsf function. */
#undef HAVE_FABSF
/* Define if you have the fabsl function. */
#undef HAVE_FABSL
/* Define if you have the finite function. */
#undef HAVE_FINITE
/* Define if you have the finitef function. */
#undef HAVE_FINITEF
/* Define if you have the finitel function. */
#undef HAVE_FINITEL
/* Define if you have the floorf function. */
#undef HAVE_FLOORF
/* Define if you have the floorl function. */
#undef HAVE_FLOORL
/* Define if you have the fpclass function. */
#undef HAVE_FPCLASS
/* Define if you have the fqfinite function. */
#undef HAVE_FQFINITE
/* Define if you have the frexpf function. */
#undef HAVE_FREXPF
/* Define if you have the frexpl function. */
#undef HAVE_FREXPL
/* Define if you have the getpagesize function. */
#undef HAVE_GETPAGESIZE
@ -312,21 +642,42 @@
/* Define if you have the isnanl function. */
#undef HAVE_ISNANL
/* Define if you have the ldexpf function. */
#undef HAVE_LDEXPF
/* Define if you have the ldexpl function. */
#undef HAVE_LDEXPL
/* Define if you have the log10f function. */
#undef HAVE_LOG10F
/* Define if you have the log10l function. */
#undef HAVE_LOG10L
/* Define if you have the logf function. */
#undef HAVE_LOGF
/* Define if you have the logl function. */
#undef HAVE_LOGL
/* Define if you have the modf function. */
#undef HAVE_MODF
/* Define if you have the modff function. */
#undef HAVE_MODFF
/* Define if you have the modfl function. */
#undef HAVE_MODFL
/* Define if you have the nan function. */
#undef HAVE_NAN
/* Define if you have the powf function. */
#undef HAVE_POWF
/* Define if you have the powl function. */
#undef HAVE_POWL
/* Define if you have the qfpclass function. */
#undef HAVE_QFPCLASS
@ -348,9 +699,18 @@
/* Define if you have the sinhf function. */
#undef HAVE_SINHF
/* Define if you have the sinhl function. */
#undef HAVE_SINHL
/* Define if you have the sinl function. */
#undef HAVE_SINL
/* Define if you have the sqrtf function. */
#undef HAVE_SQRTF
/* Define if you have the sqrtl function. */
#undef HAVE_SQRTL
/* Define if you have the strtof function. */
#undef HAVE_STRTOF
@ -363,6 +723,12 @@
/* Define if you have the tanhf function. */
#undef HAVE_TANHF
/* Define if you have the tanhl function. */
#undef HAVE_TANHL
/* Define if you have the tanl function. */
#undef HAVE_TANL
/* Define if you have the wcslen function. */
#undef HAVE_WCSLEN
@ -476,66 +842,221 @@
# define cosf _cosf
#endif
#if defined (HAVE__ACOSF) && ! defined (HAVE_ACOSF)
# define HAVE_ACOSF 1
# define acosf _acosf
#endif
#if defined (HAVE__ACOSL) && ! defined (HAVE_ACOSL)
# define HAVE_ACOSL 1
# define acosl _acosl
#endif
#if defined (HAVE__ASINF) && ! defined (HAVE_ASINF)
# define HAVE_ASINF 1
# define asinf _asinf
#endif
#if defined (HAVE__ASINL) && ! defined (HAVE_ASINL)
# define HAVE_ASINL 1
# define asinl _asinl
#endif
#if defined (HAVE__ATANF) && ! defined (HAVE_ATANF)
# define HAVE_ATANF 1
# define atanf _atanf
#endif
#if defined (HAVE__ATANL) && ! defined (HAVE_ATANL)
# define HAVE_ATANL 1
# define atanl _atanl
#endif
#if defined (HAVE__CEILF) && ! defined (HAVE_CEILF)
# define HAVE_CEILF 1
# define aceil _ceilf
#endif
#if defined (HAVE__CEILL) && ! defined (HAVE_CEILL)
# define HAVE_CEILL 1
# define aceil _ceill
#endif
#if defined (HAVE__COSHF) && ! defined (HAVE_COSHF)
# define HAVE_COSHF 1
# define coshf _coshf
#endif
#if defined (HAVE__COSL) && ! defined (HAVE_COSL)
# define HAVE_COSL 1
# define cosl _cosl
#endif
#if defined (HAVE__LOGF) && ! defined (HAVE_LOGF)
# define HAVE_LOGF 1
# define logf _logf
#endif
#if defined (HAVE__COSHL) && ! defined (HAVE_COSHL)
# define HAVE_COSHL 1
# define coshl _coshl
#endif
#if defined (HAVE__EXPF) && ! defined (HAVE_EXPF)
# define HAVE_EXPF 1
# define expf _expf
#endif
#if defined (HAVE__EXPL) && ! defined (HAVE_EXPL)
# define HAVE_EXPL 1
# define expl _expl
#endif
#if defined (HAVE__FABSF) && ! defined (HAVE_FABSF)
# define HAVE_FABSF 1
# define fabsf _fabsf
#endif
#if defined (HAVE__FABSL) && ! defined (HAVE_FABSL)
# define HAVE_FABSL 1
# define fabsl _fabsl
#endif
#if defined (HAVE__FLOORF) && ! defined (HAVE_FLOORF)
# define HAVE_FLOORF 1
# define floorf _floorf
#endif
#if defined (HAVE__FLOORL) && ! defined (HAVE_FLOORL)
# define HAVE_FLOORL 1
# define floorl _floorl
#endif
#if defined (HAVE__FMODF) && ! defined (HAVE_FMODF)
# define HAVE_FMODF 1
# define fmodf _fmodf
#endif
#if defined (HAVE__FMODL) && ! defined (HAVE_FMODL)
# define HAVE_FMODL 1
# define fmodl _fmodl
#endif
#if defined (HAVE__FREXPF) && ! defined (HAVE_FREXPF)
# define HAVE_FREXPF 1
# define frexpf _frexpf
#endif
#if defined (HAVE__FREXPL) && ! defined (HAVE_FREXPL)
# define HAVE_FREXPL 1
# define frexpl _frexpl
#endif
#if defined (HAVE__LDEXPF) && ! defined (HAVE_LDEXPF)
# define HAVE_LDEXPF 1
# define ldexpf _ldexpf
#endif
#if defined (HAVE__LDEXPL) && ! defined (HAVE_LDEXPL)
# define HAVE_LDEXPL 1
# define ldexpl _ldexpl
#endif
#if defined (HAVE__LOG10F) && ! defined (HAVE_LOG10F)
# define HAVE_LOG10F 1
# define log10f _log10f
#endif
#if defined (HAVE__LOGL) && ! defined (HAVE_LOGL)
# define HAVE_LOGL 1
# define logl _logl
#endif
#if defined (HAVE__POWF) && ! defined (HAVE_POWF)
# define HAVE_POWF 1
# define powf _powf
#endif
#if defined (HAVE__LOG10L) && ! defined (HAVE_LOG10L)
# define HAVE_LOG10L 1
# define log10l _log10l
#endif
#if defined (HAVE__MODF) && ! defined (HAVE_MODF)
# define HAVE_MODF 1
# define modf _modf
#endif
#if defined (HAVE__MODL) && ! defined (HAVE_MODL)
# define HAVE_MODL 1
# define modl _modl
#endif
#if defined (HAVE__SINF) && ! defined (HAVE_SINF)
# define HAVE_SINF 1
# define sinf _sinf
#endif
#if defined (HAVE__POWL) && ! defined (HAVE_POWL)
# define HAVE_POWL 1
# define powl _powl
#endif
#if defined (HAVE__SINHF) && ! defined (HAVE_SINHF)
# define HAVE_SINHF 1
# define sinhf _sinhf
#endif
#if defined (HAVE__SINL) && ! defined (HAVE_SINL)
# define HAVE_SINL 1
# define sinl _sinl
#endif
#if defined (HAVE__SQRTF) && ! defined (HAVE_SQRTF)
# define HAVE_SQRTF 1
# define sqrtf _sqrtf
#endif
#if defined (HAVE__SINHL) && ! defined (HAVE_SINHL)
# define HAVE_SINHL 1
# define sinhl _sinhl
#endif
#if defined (HAVE__TANF) && ! defined (HAVE_TANF)
# define HAVE_TANF 1
# define tanf _tanf
#endif
#if defined (HAVE__SQRTL) && ! defined (HAVE_SQRTL)
# define HAVE_SQRTL 1
# define sqrtl _sqrtl
#endif
#if defined (HAVE__TANHF) && ! defined (HAVE_TANHF)
# define HAVE_TANHF 1
# define tanhf _tanhf
#endif
#if defined (HAVE__TANL) && ! defined (HAVE_TANL)
# define HAVE_TANF 1
# define tanf _tanf
#endif
#if defined (HAVE__STRTOF) && ! defined (HAVE_STRTOF)
# define HAVE_STRTOF 1
# define strtof _strtof
#endif
#if defined (HAVE__TANHL) && ! defined (HAVE_TANHL)
# define HAVE_TANHL 1
# define tanhl _tanhl
#endif
#if defined (HAVE__STRTOLD) && ! defined (HAVE_STRTOLD)
# define HAVE_STRTOLD 1
# define strtold _strtold
#endif
#if defined (HAVE__FABSF) && ! defined (HAVE_FABSF)
# define HAVE_FABSF 1
# define fabsf _fabsf
#endif
#if defined (HAVE__SINCOS) && ! defined (HAVE_SINCOS)
# define HAVE_SINCOS 1
# define sincos _sincos
@ -556,6 +1077,16 @@
# define finite _finite
#endif
#if defined (HAVE__FINITEF) && ! defined (HAVE_FINITEF)
# define HAVE_FINITEF 1
# define finitef _finitef
#endif
#if defined (HAVE__FINITEL) && ! defined (HAVE_FINITEL)
# define HAVE_FINITEL 1
# define finitel _finitel
#endif
#if defined (HAVE__QFINITE) && ! defined (HAVE_QFINITE)
# define HAVE_QFINITE 1
# define qfinite _qfinite

2076
libstdc++-v3/configure vendored
View File

File diff suppressed because it is too large Load Diff

10
libstdc++-v3/libio/Makefile.in
View File

@ -116,19 +116,17 @@ includes =
libio_headers = \
libio.h libioP.h iolibio.h
@GLIBCPP_NEED_LIBIO_TRUE@LIBIO_SRCS = \
@GLIBCPP_NEED_LIBIO_TRUE@\
@GLIBCPP_NEED_LIBIO_TRUE@LIBIO_SRCS = @GLIBCPP_NEED_LIBIO_TRUE@\
@GLIBCPP_NEED_LIBIO_TRUE@ filedoalloc.c genops.c fileops.c stdfiles.c cleanup.c
@GLIBCPP_NEED_LIBIO_FALSE@LIBIO_SRCS = \
@GLIBCPP_NEED_LIBIO_FALSE@LIBIO_SRCS =
EXTRA_DIST = iostreamP.h
libio_la_LIBADD = $(LIBIO_SRCS)
libio_la_DEPENDENCIES = $(libio_la_LIBADD)
libio_la_SOURCES = $(LIBIO_SRCS)
@GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@LIBIO_CONFIG_H = \
@GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@_G_config.h
@GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE@LIBIO_CONFIG_H = \
@GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@LIBIO_CONFIG_H = @GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@_G_config.h
@GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE@LIBIO_CONFIG_H =
mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs
CONFIG_HEADER = ../config.h
CONFIG_CLEAN_FILES =

8
libstdc++-v3/math/mathconf.h
View File

@ -328,10 +328,10 @@ do { \
/* Replacement for non-existing float functions. */
#if !defined(_GLIBCPP_HAVE_FABSF) && !defined(_GLIBCPP_HAS_BUILTIN_FABSF)
#if !defined(_GLIBCPP_HAVE_FABSF) && !defined(_GLIBCPP_HAVE_BUILTIN_FABSF)
# define fabsf(x) fabs (x)
#endif
#if !defined(_GLIBCPP_HAVE_COSF) && !defined(_GLIBCPP_HAS_BUILTIN_COSF)
#if !defined(_GLIBCPP_HAVE_COSF) && !defined(_GLIBCPP_HAVE_BUILTIN_COSF)
# define cosf(x) cos (x)
#endif
#ifndef _GLIBCPP_HAVE_COSHF
@ -349,13 +349,13 @@ do { \
#ifndef _GLIBCPP_HAVE_POWF
# define powf(x, y) pow (x, y)
#endif
#if !defined(_GLIBCPP_HAVE_SINF) && !defined(_GLIBCPP_HAS_BUILTIN_SINF)
#if !defined(_GLIBCPP_HAVE_SINF) && !defined(_GLIBCPP_HAVE_BUILTIN_SINF)
# define sinf(x) sin (x)
#endif
#ifndef _GLIBCPP_HAVE_SINHF
# define sinhf(x) sinh (x)
#endif
#if !defined(_GLIBCPP_HAVE_SQRTF) && !defined(_GLIBCPP_HAS_BUILTIN_SQRTF)
#if !defined(_GLIBCPP_HAVE_SQRTF) && !defined(_GLIBCPP_HAVE_BUILTIN_SQRTF)
# define sqrtf(x) sqrt (x)
#endif
#ifndef _GLIBCPP_HAVE_TANF

1015
libstdc++-v3/shadow/bits/std_cmath.h
View File

File diff suppressed because it is too large Load Diff

19
libstdc++-v3/src/Makefile.in
View File

@ -105,12 +105,9 @@ libinst_wstring_la = @libinst_wstring_la@
AUTOMAKE_OPTIONS = 1.3 gnits
MAINT_CHARSET = latin1
@USE_LIBDIR_TRUE@toolexeclibdir = \
@USE_LIBDIR_TRUE@$(libdir)$(MULTISUBDIR)
@USE_LIBDIR_FALSE@toolexeclibdir = \
@USE_LIBDIR_FALSE@$(toolexecdir)/lib$(MULTISUBDIR)
@USE_LIBDIR_FALSE@toolexecdir = \
@USE_LIBDIR_FALSE@$(exec_prefix)/$(target_alias)
@USE_LIBDIR_TRUE@toolexeclibdir = @USE_LIBDIR_TRUE@$(libdir)$(MULTISUBDIR)
@USE_LIBDIR_FALSE@toolexeclibdir = @USE_LIBDIR_FALSE@$(toolexecdir)/lib$(MULTISUBDIR)
@USE_LIBDIR_FALSE@toolexecdir = @USE_LIBDIR_FALSE@$(exec_prefix)/$(target_alias)
toolexeclib_LTLIBRARIES = libstdc++.la
EXTRA_LTLIBRARIES = libinst-string.la libinst-wstring.la
@ -256,10 +253,9 @@ std_headers = \
map memory new numeric ostream queue set sstream stack stdexcept \
streambuf string strstream typeinfo utility valarray vector
@GLIBCPP_NEED_LIBIO_TRUE@libio_headers = \
@GLIBCPP_NEED_LIBIO_TRUE@\
@GLIBCPP_NEED_LIBIO_TRUE@libio_headers = @GLIBCPP_NEED_LIBIO_TRUE@\
@GLIBCPP_NEED_LIBIO_TRUE@ $(top_builddir)/libio/_G_config.h $(top_srcdir)/libio/libio.h
@GLIBCPP_NEED_LIBIO_FALSE@libio_headers = \
@GLIBCPP_NEED_LIBIO_FALSE@libio_headers =
generated_headers = \
$(top_builddir)/bits/std_limits.h $(top_builddir)/bits/c++config.h \
@ -338,9 +334,8 @@ libstdc___la_LIBADD = \
libstdc___la_LDFLAGS = -version-info 3:0:0 -lm
libstdc___la_DEPENDENCIES = $(libstdc___la_LIBADD)
@GLIBCPP_USE_CSHADOW_TRUE@CSHADOW_H = \
@GLIBCPP_USE_CSHADOW_TRUE@$(top_builddir)/stamp-cshadow
@GLIBCPP_USE_CSHADOW_FALSE@CSHADOW_H = \
@GLIBCPP_USE_CSHADOW_TRUE@CSHADOW_H = @GLIBCPP_USE_CSHADOW_TRUE@$(top_builddir)/stamp-cshadow
@GLIBCPP_USE_CSHADOW_FALSE@CSHADOW_H =
# We cannot use the default rules to install headers since we cannot
# statically decide which headers to install. So we have our own special