mirrors/gcc
1
0
Fork 0
mirror of https://gcc.gnu.org/git/gcc.git synced 2024-11-23 19:03:59 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[multiple changes]

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

        * acinclude.m4: Check for sinl, _sinl using 1 parameter.

2000-06-22  Benjamin Kosnik  <bkoz@purist.soma.redhat.com>

	* acinclude.m4 (GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT): Redo. Use the
	same approach as GLIBCPP_CHECK_MATH_SUPPORT, only don't try to
	link against libm and don't use -fno-builtins...
	* math/mathconf.h: Change up builtin macros to new schema.
	* bits/std_cmath.h: And here. Wheee!
	* shadow/bits/std_cmath.h: And here.
	* acconfig.h: Change up builtin macros here.
	* math/cosf.c:  Remove.
	* math/fabsf.c:  Likewise.
	* math/sinf.c:  Likewise.
	* math/sqrtf.c:  Likewise.
	* math/Makefile.am (EXTRA_DIST):  Remove those four files.
	* math/Makefile.in:  Regenerate.

From-SVN: r34655
This commit is contained in:
Benjamin Kosnik 2000-06-22 23:59:04 +00:00
parent 28398c70a3
commit 11fc1858a0
11 changed files with 2213 additions and 4725 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,23 @@
2000-06-22 Steven King <sxking@uswest.net>
* acinclude.m4: Check for sinl, _sinl using 1 parameter.
2000-06-22 Benjamin Kosnik <bkoz@purist.soma.redhat.com>
* acinclude.m4 (GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT): Redo. Use the
same approach as GLIBCPP_CHECK_MATH_SUPPORT, only don't try to
link against libm and don't use -fno-builtins...
* math/mathconf.h: Change up builtin macros to new schema.
* bits/std_cmath.h: And here. Wheee!
* shadow/bits/std_cmath.h: And here.
* acconfig.h: Change up builtin macros here.
* math/cosf.c: Remove.
* math/fabsf.c: Likewise.
* math/sinf.c: Likewise.
* math/sqrtf.c: Likewise.
* math/Makefile.am (EXTRA_DIST): Remove those four files.
* math/Makefile.in: Regenerate.
2000-06-22 Anthony Williams <anthony@anthonyw.cjb.net>
* testsuite/21_strings/find.cc: Patch.

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

@ -12,203 +12,47 @@
// Define if code specialized for wchar_t should be used.
#undef _GLIBCPP_USE_WCHAR_T
// Define if the compiler/host combination has __builtin_acos
#undef HAVE_BUILTIN_ACOS
// Define if the compiler/host combination has __builtin_abs
#undef HAVE___BUILTIN_ABS
// Define if the compiler/host combination has __builtin_acosf
#undef HAVE_BUILTIN_ACOSF
// Define if the compiler/host combination has __builtin_acosl
#undef HAVE_BUILTIN_ACOSL
// 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_labs
#undef HAVE___BUILTIN_LABS
// Define if the compiler/host combination has __builtin_cos
#undef HAVE_BUILTIN_COS
#undef HAVE___BUILTIN_COS
// Define if the compiler/host combination has __builtin_cosf
#undef HAVE_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
#undef HAVE___BUILTIN_COSL
// Define if the compiler/host combination has __builtin_fabs
#undef HAVE_BUILTIN_FABS
#undef HAVE___BUILTIN_FABS
// Define if the compiler/host combination has __builtin_fabsf
#undef HAVE_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_fmod
#undef HAVE_BUILTIN_FMOD
// Define if the compiler/host combination has __builtin_fmodf
#undef HAVE_BUILTIN_FMODF
// Define if the compiler/host combination has __builtin_fmodl
#undef HAVE_BUILTIN_FMODL
// 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
#undef HAVE___BUILTIN_FABSL
// Define if the compiler/host combination has __builtin_sin
#undef HAVE_BUILTIN_SIN
#undef HAVE___BUILTIN_SIN
// Define if the compiler/host combination has __builtin_sinf
#undef HAVE_BUILTIN_SINF
#undef HAVE___BUILTIN_SINF
// Define if the compiler/host combination has __builtin_sinl
#undef HAVE_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_fsqrt
#undef HAVE___BUILTIN_FSQRT
// Define if the compiler/host combination has __builtin_sqrtf
#undef HAVE_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
#undef HAVE___BUILTIN_SQRTL
// Define if GCC support for __complex__ float is buggy.
#undef _GLIBCPP_BUGGY_FLOAT_COMPLEX

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

@ -286,613 +286,7 @@ AC_DEFUN(GLIBCPP_CHECK_LINKER_FEATURES, [
dnl
dnl Check to see what builtin math functions are supported
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_fmod
dnl check for __builtin_fmodf
dnl check for __builtin_fmodl
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_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_MSG_CHECKING([for __builtin_acos])
AC_TRY_COMPILE([#include <math.h>],
[ __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, 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, 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, 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>],
[ __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(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>],
[ __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(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_floor(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_fmod])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fmod(0.0, 0.0);],
use_builtin_fmod=yes, use_builtin_fmod=no)
AC_MSG_RESULT($use_builtin_fmod)
if test $use_builtin_fmod = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FMOD)
fi
AC_MSG_CHECKING([for __builtin_fmodf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fmodf(0.0, 0.0);],
use_builtin_fmodf=yes, use_builtin_fmodf=no)
AC_MSG_RESULT($use_builtin_fmodf)
if test $use_builtin_fmodf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FMODF)
fi
AC_MSG_CHECKING([for __builtin_fmodl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fmodl(0.0, 0.0);],
use_builtin_fmodl=yes, use_builtin_fmodl=no)
AC_MSG_RESULT($use_builtin_fmodl)
if test $use_builtin_fmodl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FMODL)
fi
AC_MSG_CHECKING([for __builtin_frexp])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_frexp(0.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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>],
[ __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(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
dnl Check to see if the argument passed is
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
@ -919,7 +313,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, [
dnl
dnl Check to see if the argument passed is
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
@ -946,7 +340,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2, [
dnl
dnl Check to see if the argument passed is
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
@ -972,6 +366,109 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3, [
])
dnl
dnl Because the builtins are picky picky picky about the arguments they take,
dnl do an explict linkage tests here.
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
dnl Define HAVE_CARGF etc if "cargf" is declared and links
dnl
dnl argument 1 is name of function to check
dnl
dnl ASSUMES argument is a math function with ONE parameter
dnl
dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_MSG_CHECKING([for $1 declaration])
AC_TRY_COMPILE([#include <math.h>],
[ $1(0);],
[use_$1=yes], [use_$1=no])
AC_MSG_RESULT($use_$1)
AC_LANG_RESTORE
if test x$use_$1 = x"yes"; then
AC_MSG_CHECKING([for $1 linkage])
AC_TRY_LINK([#include <math.h>],
[ $1(0);],
[link_$1=yes], [link_$1=no])
AC_MSG_RESULT($link_$1)
if test x$link_$1 = x"yes"; then
ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
AC_DEFINE_UNQUOTED(${ac_tr_func})
fi
fi
])
dnl
dnl Check to see what builtin math functions are supported
dnl
dnl check for __builtin_abs
dnl check for __builtin_fabsf
dnl check for __builtin_fabs
dnl check for __builtin_fabl
dnl check for __builtin_labs
dnl check for __builtin_sqrtf
dnl check for __builtin_sqrtl
dnl check for __builtin_fsqrt
dnl check for __builtin_sinf
dnl check for __builtin_sin
dnl check for __builtin_sinl
dnl check for __builtin_cosf
dnl check for __builtin_cos
dnl check for __builtin_cosl
dnl
dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
dnl Test for builtin math functions.
dnl These are made in gcc/c-common.c
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fsqrt)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
dnl There is, without a doubt, a more elegant way to have these
dnl names exported so that they won't be stripped out of acconfig.h by
dnl autoheader. I leave this as an exercise to somebody less frustrated
dnl than I.... please email the libstdc++ list if you can figure out a
dnl more elegant approach (see autoconf/acgen.m4 and specifically
dnl AC_CHECK_FUNC for things to steal.)
dummyvar=no
if test x$dummyvar = x"yes"; then
AC_DEFINE(HAVE___BUILTIN_ABS)
AC_DEFINE(HAVE___BUILTIN_LABS)
AC_DEFINE(HAVE___BUILTIN_COS)
AC_DEFINE(HAVE___BUILTIN_COSF)
AC_DEFINE(HAVE___BUILTIN_COSL)
AC_DEFINE(HAVE___BUILTIN_FABS)
AC_DEFINE(HAVE___BUILTIN_FABSF)
AC_DEFINE(HAVE___BUILTIN_FABSL)
AC_DEFINE(HAVE___BUILTIN_SIN)
AC_DEFINE(HAVE___BUILTIN_SINF)
AC_DEFINE(HAVE___BUILTIN_SINL)
AC_DEFINE(HAVE___BUILTIN_FSQRT)
AC_DEFINE(HAVE___BUILTIN_SQRTF)
AC_DEFINE(HAVE___BUILTIN_SQRTL)
fi
])
dnl
dnl Check to see what the underlying c library or math library is like.
dnl These checks need to do two things:
@ -1035,7 +532,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
dnl Check to see if basic C math functions have long double versions.
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(copysignl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(acosl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(asinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(atanl)
@ -1053,7 +550,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(sinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sinhl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(tanl)
@ -1105,7 +602,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
dnl Check to see if basic C math functions have long double versions.
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isnanl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isinfl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_copysignl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_copysignl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_acosl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_asinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_atanl)
@ -1123,7 +620,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_log10l)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_modfl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_powl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_sinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sinhl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sqrtl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_tanl)
@ -1149,16 +646,20 @@ AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [
AC_CHECK_HEADERS([complex.h])
AC_REPLACE_MATHFUNCS(ccos ccosf ccosh ccoshf cexp cexpf c_log c_logf \
clog10 clog10f cpow cpowf csin csinf csinh csinhf csqrt csqrtf \
ctan ctanf ctanh ctanhf \
carg cargf nan hypot hypotf atan2f expf copysignf)
ctan ctanf ctanh ctanhf carg cargf nan hypot hypotf atan2f expf copysignf)
dnl Compile the long double complex functions only if the function
dnl provides the non-complex long double functions that are needed.
dnl Currently this includes copysignl and atan2l, which should be
dnl cached from the GLIBCPP_CHECK_MATH_SUPPORT macro, above.
USE_COMPLEX_LONG_DOUBLE=no
if test x$ac_cv_func_atan2l = x"yes" \
&& test x$ac_cv_func_copysignl = x"yes"; then
USE_COMPLEX_LONG_DOUBLE=yes
AC_REPLACE_MATHFUNCS(ccoshl ccosl cexpl cpowl csinhl csinl \
csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l)
fi
dnl We compile the long double complex functions only if the function
dnl provides the non-complex long double functions.
USE_LONG_DOUBLE=no
AC_CHECK_FUNC(copysignl,
USE_LONG_DOUBLE=yes
AC_REPLACE_MATHFUNCS(ccoshl ccosl cexpl cpowl csinhl csinl \
csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l))
AC_SUBST(USE_COMPLEX_LONG_DOUBLE)
])

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

@ -298,613 +298,7 @@ AC_DEFUN(GLIBCPP_CHECK_LINKER_FEATURES, [
dnl
dnl Check to see what builtin math functions are supported
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_fmod
dnl check for __builtin_fmodf
dnl check for __builtin_fmodl
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_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_MSG_CHECKING([for __builtin_acos])
AC_TRY_COMPILE([#include <math.h>],
[ __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, 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, 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, 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>],
[ __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(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>],
[ __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(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_floor(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_fmod])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fmod(0.0, 0.0);],
use_builtin_fmod=yes, use_builtin_fmod=no)
AC_MSG_RESULT($use_builtin_fmod)
if test $use_builtin_fmod = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FMOD)
fi
AC_MSG_CHECKING([for __builtin_fmodf])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fmodf(0.0, 0.0);],
use_builtin_fmodf=yes, use_builtin_fmodf=no)
AC_MSG_RESULT($use_builtin_fmodf)
if test $use_builtin_fmodf = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FMODF)
fi
AC_MSG_CHECKING([for __builtin_fmodl])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_fmodl(0.0, 0.0);],
use_builtin_fmodl=yes, use_builtin_fmodl=no)
AC_MSG_RESULT($use_builtin_fmodl)
if test $use_builtin_fmodl = "yes"; then
AC_DEFINE(HAVE_BUILTIN_FMODL)
fi
AC_MSG_CHECKING([for __builtin_frexp])
AC_TRY_COMPILE([#include <math.h>],
[ __builtin_frexp(0.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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>],
[ __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(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
dnl Check to see if the argument passed is
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
@ -931,7 +325,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, [
dnl
dnl Check to see if the argument passed is
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
@ -958,7 +352,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2, [
dnl
dnl Check to see if the argument passed is
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
@ -984,6 +378,109 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3, [
])
dnl
dnl Because the builtins are picky picky picky about the arguments they take,
dnl do an explict linkage tests here.
dnl Check to see if the (math function) argument passed is
dnl 1) declared when using the c++ compiler
dnl 2) has "C" linkage
dnl
dnl Define HAVE_CARGF etc if "cargf" is declared and links
dnl
dnl argument 1 is name of function to check
dnl
dnl ASSUMES argument is a math function with ONE parameter
dnl
dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_MSG_CHECKING([for $1 declaration])
AC_TRY_COMPILE([#include <math.h>],
[ $1(0);],
[use_$1=yes], [use_$1=no])
AC_MSG_RESULT($use_$1)
AC_LANG_RESTORE
if test x$use_$1 = x"yes"; then
AC_MSG_CHECKING([for $1 linkage])
AC_TRY_LINK([#include <math.h>],
[ $1(0);],
[link_$1=yes], [link_$1=no])
AC_MSG_RESULT($link_$1)
if test x$link_$1 = x"yes"; then
ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
AC_DEFINE_UNQUOTED(${ac_tr_func})
fi
fi
])
dnl
dnl Check to see what builtin math functions are supported
dnl
dnl check for __builtin_abs
dnl check for __builtin_fabsf
dnl check for __builtin_fabs
dnl check for __builtin_fabl
dnl check for __builtin_labs
dnl check for __builtin_sqrtf
dnl check for __builtin_sqrtl
dnl check for __builtin_fsqrt
dnl check for __builtin_sinf
dnl check for __builtin_sin
dnl check for __builtin_sinl
dnl check for __builtin_cosf
dnl check for __builtin_cos
dnl check for __builtin_cosl
dnl
dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
dnl Test for builtin math functions.
dnl These are made in gcc/c-common.c
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fsqrt)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
dnl There is, without a doubt, a more elegant way to have these
dnl names exported so that they won't be stripped out of acconfig.h by
dnl autoheader. I leave this as an exercise to somebody less frustrated
dnl than I.... please email the libstdc++ list if you can figure out a
dnl more elegant approach (see autoconf/acgen.m4 and specifically
dnl AC_CHECK_FUNC for things to steal.)
dummyvar=no
if test x$dummyvar = x"yes"; then
AC_DEFINE(HAVE___BUILTIN_ABS)
AC_DEFINE(HAVE___BUILTIN_LABS)
AC_DEFINE(HAVE___BUILTIN_COS)
AC_DEFINE(HAVE___BUILTIN_COSF)
AC_DEFINE(HAVE___BUILTIN_COSL)
AC_DEFINE(HAVE___BUILTIN_FABS)
AC_DEFINE(HAVE___BUILTIN_FABSF)
AC_DEFINE(HAVE___BUILTIN_FABSL)
AC_DEFINE(HAVE___BUILTIN_SIN)
AC_DEFINE(HAVE___BUILTIN_SINF)
AC_DEFINE(HAVE___BUILTIN_SINL)
AC_DEFINE(HAVE___BUILTIN_FSQRT)
AC_DEFINE(HAVE___BUILTIN_SQRTF)
AC_DEFINE(HAVE___BUILTIN_SQRTL)
fi
])
dnl
dnl Check to see what the underlying c library or math library is like.
dnl These checks need to do two things:
@ -1047,7 +544,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
dnl Check to see if basic C math functions have long double versions.
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(copysignl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(acosl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(asinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(atanl)
@ -1065,7 +562,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(sinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sinhl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(tanl)
@ -1117,7 +614,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
dnl Check to see if basic C math functions have long double versions.
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isnanl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isinfl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_copysignl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_copysignl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_acosl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_asinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_atanl)
@ -1135,7 +632,7 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_log10l)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_modfl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_powl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_sinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sinl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sinhl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sqrtl)
GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_tanl)
@ -1161,16 +658,20 @@ AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [
AC_CHECK_HEADERS([complex.h])
AC_REPLACE_MATHFUNCS(ccos ccosf ccosh ccoshf cexp cexpf c_log c_logf \
clog10 clog10f cpow cpowf csin csinf csinh csinhf csqrt csqrtf \
ctan ctanf ctanh ctanhf \
carg cargf nan hypot hypotf atan2f expf copysignf)
ctan ctanf ctanh ctanhf carg cargf nan hypot hypotf atan2f expf copysignf)
dnl Compile the long double complex functions only if the function
dnl provides the non-complex long double functions that are needed.
dnl Currently this includes copysignl and atan2l, which should be
dnl cached from the GLIBCPP_CHECK_MATH_SUPPORT macro, above.
USE_COMPLEX_LONG_DOUBLE=no
if test x$ac_cv_func_atan2l = x"yes" \
&& test x$ac_cv_func_copysignl = x"yes"; then
USE_COMPLEX_LONG_DOUBLE=yes
AC_REPLACE_MATHFUNCS(ccoshl ccosl cexpl cpowl csinhl csinl \
csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l)
fi
dnl We compile the long double complex functions only if the function
dnl provides the non-complex long double functions.
USE_LONG_DOUBLE=no
AC_CHECK_FUNC(copysignl,
USE_LONG_DOUBLE=yes
AC_REPLACE_MATHFUNCS(ccoshl ccosl cexpl cpowl csinhl csinl \
csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l))
AC_SUBST(USE_COMPLEX_LONG_DOUBLE)
])

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

@ -47,7 +47,7 @@ namespace std {
// float
//
#if _GLIBCPP_HAVE_BUILTIN_FABSF
#if _GLIBCPP_HAVE___BUILTIN_FABSF
inline float abs(float __x)
{ return __builtin_fabsf(__x); }
#elif _GLIBCPP_HAVE_FABSF
@ -58,10 +58,7 @@ namespace std {
{ return ::fabs(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ACOSF
inline float acos(float __x)
{ return __builtin_acosf(__x); }
#elif _GLIBCPP_HAVE_ACOSF
#if _GLIBCPP_HAVE_ACOSF
inline float acos(float __x)
{ return ::acosf(__x); }
#else
@ -69,10 +66,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_ASINF
inline float asin(float __x)
{ return ::asinf(__x); }
#else
@ -80,10 +74,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_ATANF
inline float atan(float __x)
{ return ::atanf(__x); }
#else
@ -91,10 +82,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_ATAN2F
inline float atan2(float __y, float __x)
{ return ::atan2f(__y, __x); }
#else
@ -102,10 +90,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_CEILF
inline float ceil(float __x)
{ return ::ceilf(__x); }
#else
@ -113,7 +98,7 @@ namespace std {
{ return ::ceil(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSF
#if _GLIBCPP_HAVE___BUILTIN_COSF
inline float cos(float __x)
{ return __builtin_cosf(__x); }
#elif _GLIBCPP_HAVE_COSF
@ -124,10 +109,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_COSHF
inline float cosh(float __x)
{ return ::coshf(__x); }
#else
@ -135,10 +117,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_EXPF
inline float exp(float __x)
{ return ::expf(__x); }
#else
@ -146,7 +125,7 @@ namespace std {
{ return ::exp(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FABSF
#if _GLIBCPP_HAVE___BUILTIN_FABSF
inline float fabs(float __x)
{ return __builtin_fabsf(__x); }
#elif _GLIBCPP_HAVE_FABSF
@ -157,10 +136,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_FLOORF
inline float floor(float __x)
{ return ::floorf(__x); }
#else
@ -168,10 +144,7 @@ namespace std {
{ return ::floor(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FMODF
inline float fmod(float __x, float __y)
{ return __builtin_fmodf(__x, __y); }
#elif _GLIBCPP_HAVE_FMODF
#if _GLIBCPP_HAVE_FMODF
inline float fmod(float __x, float __y)
{ return ::fmodf(__x, __y); }
#else
@ -179,10 +152,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_FREXPF
inline float frexp(float __x, int* __exp)
{ return ::frexpf(__x, __exp); }
#else
@ -190,10 +160,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_LDEXPF
inline float ldexp(float __x, int __exp)
{ return ::ldexpf(__x, __exp); }
#else
@ -201,10 +168,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_LOGF
inline float log(float __x)
{ return ::logf(__x); }
#else
@ -212,10 +176,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_LOG10F
inline float log10(float __x)
{ return ::log10f(__x); }
#else
@ -223,10 +184,7 @@ namespace std {
{ return ::log10(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_MODFF
inline float modf(float __x, float* __iptr)
{ return __builtin_modff(__x, __iptr); }
#elif _GLIBCPP_HAVE_MODFF
#if _GLIBCPP_HAVE_MODFF
inline float modf(float __x, float* __iptr)
{ return ::modff(__x, __iptr); }
#else
@ -239,10 +197,7 @@ namespace std {
}
#endif
#if _GLIBCPP_HAVE_BUILTIN_POWF
inline float pow(float __x, float __y)
{ return __builtin_powf(__x, __y); }
#elif _GLIBCPP_HAVE_POWF
#if _GLIBCPP_HAVE_POWF
inline float pow(float __x, float __y)
{ return ::powf(__x, __y); }
#else
@ -250,9 +205,9 @@ namespace std {
{ return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
#endif
float pow (float, int);
float pow(float, int);
#if _GLIBCPP_HAVE_BUILTIN_SINF
#if _GLIBCPP_HAVE___BUILTIN_SINF
inline float sin(float __x)
{ return __builtin_sinf(__x); }
#elif _GLIBCPP_HAVE_SINF
@ -263,10 +218,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_SINHF
inline float sinh(float __x)
{ return ::sinhf(__x); }
#else
@ -274,7 +226,7 @@ namespace std {
{ return ::sinh(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SQRTF
#if _GLIBCPP_HAVE___BUILTIN_SQRTF
inline float sqrt(float __x)
{ return __builtin_sqrtf(__x); }
#elif _GLIBCPP_HAVE_SQRTF
@ -285,10 +237,7 @@ namespace std {
{ return ::sqrt(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANF
inline float tan(float __x)
{ return __builtin_tanf(__x); }
#elif _GLIBCPP_HAVE_TANF
#if _GLIBCPP_HAVE_TANF
inline float tan(float __x)
{ return ::tanf(__x); }
#else
@ -296,10 +245,7 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE_TANHF
inline float tanh(float __x)
{ return ::tanhf(__x); }
#else
@ -311,7 +257,7 @@ namespace std {
// double
//
#if _GLIBCPP_HAVE_BUILTIN_FABS
#if _GLIBCPP_HAVE___BUILTIN_FABS
inline double abs(double __x)
{ return __builtin_fabs(__x); }
#else
@ -319,47 +265,22 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE___BUILTIN_COS
inline double cos(double __x)
{ return __builtin_cos(__x); }
#else
@ -367,23 +288,14 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE___BUILTIN_FABS
inline double fabs(double __x)
{ return __builtin_fabs(__x); }
#else
@ -391,73 +303,33 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE___BUILTIN_SIN
inline double sin(double __x)
{ return __builtin_sin(__x); }
#else
@ -465,15 +337,10 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE___BUILTIN_SQRT
inline double sqrt(double __x)
{ return __builtin_fsqrt(__x); }
#else
@ -481,26 +348,16 @@ namespace std {
{ 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
#if _GLIBCPP_HAVE___BUILTIN_FABSL
inline long double abs(long double __x)
{ return __builtin_fabsl(__x); }
#elif _GLIBCPP_HAVE_FABSL
@ -508,47 +365,32 @@ namespace std {
{ return ::fabsl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ACOSL
inline long double acos(long double __x)
{ return __builtin_acosl(__x); }
#elif _GLIBCPP_HAVE_ACOSL
#if _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
#if _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
#if _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
#if _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
#if _GLIBCPP_HAVE_CEILL
inline long double ceil(long double __x)
{ return ::ceill(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSL
#if _GLIBCPP_HAVE___BUILTIN_COSL
inline long double cos(long double __x)
{ return __builtin_cosl(__x); }
#elif _GLIBCPP_HAVE_COSL
@ -556,23 +398,17 @@ namespace std {
{ return ::cosl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSHL
inline long double cosh(long double __x)
{ return __builtin_coshl(__x); }
#elif _GLIBCPP_HAVE_COSHL
#if _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
#if _GLIBCPP_HAVE_EXPL
inline long double exp(long double __x)
{ return ::expl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FABSL
#if _GLIBCPP_HAVE___BUILTIN_FABSL
inline long double fabs(long double __x)
{ return __builtin_fabsl(__x); }
#elif _GLIBCPP_HAVE_FABSL
@ -580,73 +416,49 @@ namespace std {
{ return ::fabsl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FLOORL
inline long double floor(long double __x)
{ return __builtin_floorl(__x); }
#elif _GLIBCPP_HAVE_FLOORL
#if _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
#if _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
#if _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
#if _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
#if _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
#if _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
#if _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
#if _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
#if _GLIBCPP_HAVE___BUILTIN_SINL
inline long double sin(long double __x)
{ return __builtin_sinl(__x); }
#elif _GLIBCPP_HAVE_SINL
@ -654,15 +466,12 @@ namespace std {
{ return ::sinl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SINHL
inline long double sinh(long double __x)
{ return __builtin_sinhl(__x); }
#elif _GLIBCPP_HAVE_SINHL
#if _GLIBCPP_HAVE_SINHL
inline long double sinh(long double __x)
{ return ::sinhl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SQRTL
#if _GLIBCPP_HAVE___BUILTIN_SQRTL
inline long double sqrt(long double __x)
{ return __builtin_sqrtl(__x); }
#elif _GLIBCPP_HAVE_SQRTL
@ -670,18 +479,12 @@ namespace std {
{ return ::sqrtl(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANL
inline long double tan(long double __x)
{ return __builtin_tanl(__x); }
#elif _GLIBCPP_HAVE_TANL
#if _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
#if _GLIBCPP_HAVE_TANHL
inline long double tanh(long double __x)
{ return ::tanhl(__x); }
#endif

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

@ -15,203 +15,47 @@
// Define if code specialized for wchar_t should be used.
#undef _GLIBCPP_USE_WCHAR_T
// Define if the compiler/host combination has __builtin_acos
#undef HAVE_BUILTIN_ACOS
// Define if the compiler/host combination has __builtin_abs
#undef HAVE___BUILTIN_ABS
// Define if the compiler/host combination has __builtin_acosf
#undef HAVE_BUILTIN_ACOSF
// Define if the compiler/host combination has __builtin_acosl
#undef HAVE_BUILTIN_ACOSL
// 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_labs
#undef HAVE___BUILTIN_LABS
// Define if the compiler/host combination has __builtin_cos
#undef HAVE_BUILTIN_COS
#undef HAVE___BUILTIN_COS
// Define if the compiler/host combination has __builtin_cosf
#undef HAVE_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
#undef HAVE___BUILTIN_COSL
// Define if the compiler/host combination has __builtin_fabs
#undef HAVE_BUILTIN_FABS
#undef HAVE___BUILTIN_FABS
// Define if the compiler/host combination has __builtin_fabsf
#undef HAVE_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_fmod
#undef HAVE_BUILTIN_FMOD
// Define if the compiler/host combination has __builtin_fmodf
#undef HAVE_BUILTIN_FMODF
// Define if the compiler/host combination has __builtin_fmodl
#undef HAVE_BUILTIN_FMODL
// 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
#undef HAVE___BUILTIN_FABSL
// Define if the compiler/host combination has __builtin_sin
#undef HAVE_BUILTIN_SIN
#undef HAVE___BUILTIN_SIN
// Define if the compiler/host combination has __builtin_sinf
#undef HAVE_BUILTIN_SINF
#undef HAVE___BUILTIN_SINF
// Define if the compiler/host combination has __builtin_sinl
#undef HAVE_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_fsqrt
#undef HAVE___BUILTIN_FSQRT
// Define if the compiler/host combination has __builtin_sqrtf
#undef HAVE_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
#undef HAVE___BUILTIN_SQRTL
// Define if GCC support for __complex__ float is buggy.
#undef _GLIBCPP_BUGGY_FLOAT_COMPLEX

4440
libstdc++-v3/configure vendored
View File

File diff suppressed because it is too large Load Diff

1
libstdc++-v3/math/Makefile.am
View File

@ -31,7 +31,6 @@ EXTRA_LONG_DOUBLE_yes = \
signbitl.c cabsl.c
EXTRA_DIST = \
cosf.c fabsf.c sinf.c sqrtf.c \
ccos.c ccosf.c ccosh.c ccoshf.c ccoshl.c \
cexp.c cexpf.c c_log.c c_logf.c clog10.c clog10f.c \
cpow.c cpowf.c csin.c csinf.c csinh.c csinhf.c \

1
libstdc++-v3/math/Makefile.in
View File

@ -118,7 +118,6 @@ EXTRA_LONG_DOUBLE_yes = \
EXTRA_DIST = \
cosf.c fabsf.c sinf.c sqrtf.c \
ccos.c ccosf.c ccosh.c ccoshf.c ccoshl.c \
cexp.c cexpf.c c_log.c c_logf.c clog10.c clog10f.c \
cpow.c cpowf.c csin.c csinf.c csinh.c csinhf.c \

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_HAVE_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_HAVE_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_HAVE_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_HAVE_BUILTIN_SQRTF)
#if !defined(_GLIBCPP_HAVE_SQRTF) && !defined(_GLIBCPP_HAVE___BUILTIN_SQRTF)
# define sqrtf(x) sqrt (x)
#endif
#ifndef _GLIBCPP_HAVE_TANF

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

@ -1,6 +1,6 @@
// -*- C++ -*- header wrapper.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@ -43,10 +43,8 @@
# include_next <math.h>
}
inline double _CPP_HUGE_VAL_capture() { return HUGE_VAL; }
#if _GLIBCPP_HAVE_BUILTIN_ACOSF
inline float _CPP_acos_capture(float __x)
{ return __builtin_acosf(__x); }
#elif _GLIBCPP_HAVE_ACOSF
#if _GLIBCPP_HAVE_ACOSF
inline float _CPP_acos_capture(float __x)
{ return acosf(__x); }
#else
@ -54,10 +52,7 @@
{ return acos(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ASINF
inline float _CPP_asin_capture(float __x)
{ return __builtin_asinf(__x); }
#elif _GLIBCPP_HAVE_ASINF
#if _GLIBCPP_HAVE_ASINF
inline float _CPP_asin_capture(float __x)
{ return asinf(__x); }
#else
@ -65,10 +60,7 @@
{ return asin(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATANF
inline float _CPP_atan_capture(float __x)
{ return __builtin_atanf(__x); }
#elif _GLIBCPP_HAVE_ATANF
#if _GLIBCPP_HAVE_ATANF
inline float _CPP_atan_capture(float __x)
{ return atanf(__x); }
#else
@ -76,10 +68,7 @@
{ return atan(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATAN2F
inline float _CPP_atan2_capture(float __y, float __x)
{ return __builtin_atan2f(__y, __x); }
#elif _GLIBCPP_HAVE_ATAN2F
#if _GLIBCPP_HAVE_ATAN2F
inline float _CPP_atan2_capture(float __y, float __x)
{ return atan2f(__y, __x); }
#else
@ -87,10 +76,7 @@
{ return atan2(static_cast<double>(__y), static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_CEILF
inline float _CPP_ceil_capture(float __x)
{ return __builtin_ceilf(__x); }
#elif _GLIBCPP_HAVE_CEILF
#if _GLIBCPP_HAVE_CEILF
inline float _CPP_ceil_capture(float __x)
{ return ceilf(__x); }
#else
@ -98,7 +84,7 @@
{ return ceil(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSF
#if _GLIBCPP_HAVE___BUILTIN_COSF
inline float _CPP_cos_capture(float __x)
{ return __builtin_cosf(__x); }
#elif _GLIBCPP_HAVE_COSF
@ -109,10 +95,7 @@
{ return cos(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSHF
inline float _CPP_cosh_capture(float __x)
{ return __builtin_coshf(__x); }
#elif _GLIBCPP_HAVE_COSHF
#if _GLIBCPP_HAVE_COSHF
inline float _CPP_cosh_capture(float __x)
{ return coshf(__x); }
#else
@ -120,10 +103,7 @@
{ return cosh(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_EXPF
inline float _CPP_exp_capture(float __x)
{ return __builtin_expf(__x); }
#elif _GLIBCPP_HAVE_EXPF
#if _GLIBCPP_HAVE_EXPF
inline float _CPP_exp_capture(float __x)
{ return expf(__x); }
#else
@ -131,7 +111,7 @@
{ return exp(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FABSF
#if _GLIBCPP_HAVE___BUILTIN_FABSF
inline float _CPP_fabs_capture(float __x)
{ return __builtin_fabsf(__x); }
#elif _GLIBCPP_HAVE_FABSF
@ -142,10 +122,7 @@
{ return fabs(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FLOORF
inline float _CPP_floor_capture(float __x)
{ return __builtin_floorf(__x); }
#elif _GLIBCPP_HAVE_FLOORF
#if _GLIBCPP_HAVE_FLOORF
inline float _CPP_floor_capture(float __x)
{ return floorf(__x); }
#else
@ -153,10 +130,7 @@
{ return floor(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FMODFF
inline float _CPP_fmod_capture(float __x, float __y)
{ return __builtin_fmodf(__x, __y); }
#elif _GLIBCPP_HAVE_FMODFF
#if _GLIBCPP_HAVE_FMODFF
inline float _CPP_fmod_capture(float __x, float __y)
{ return fmodf(__x, __y); }
#else
@ -164,10 +138,7 @@
{ return fmod(static_cast<double>(__x), static_cast<double>(__y)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FREXPF
inline float _CPP_frexp_capture(float __x, int* __exp)
{ return __builtin_frexpf(__x, __exp); }
#elif _GLIBCPP_HAVE_FREXPF
#if _GLIBCPP_HAVE_FREXPF
inline float _CPP_frexp_capture(float __x, int* __exp)
{ return frexpf(__x, __exp); }
#else
@ -175,10 +146,7 @@
{ return frexp(__x, __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LDEXPF
inline float _CPP_ldexp_capture(float __x, int __exp)
{ return __builtin_ldexpf(__x, __exp); }
#elif _GLIBCPP_HAVE_LDEXPF
#if _GLIBCPP_HAVE_LDEXPF
inline float _CPP_ldexp_capture(float __x, int __exp)
{ return ldexpf(__x, __exp); }
#else
@ -186,10 +154,7 @@
{ return ldexp(static_cast<double>(__x), __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOGF
inline float _CPP_log_capture(float __x)
{ return __builtin_logf(__x); }
#elif _GLIBCPP_HAVE_LOGF
#if _GLIBCPP_HAVE_LOGF
inline float _CPP_log_capture(float __x)
{ return logf(__x); }
#else
@ -197,10 +162,7 @@
{ return log(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOG10F
inline float _CPP_log10_capture(float __x)
{ return __builtin_log10f(__x); }
#elif _GLIBCPP_HAVE_LOG10F
#if _GLIBCPP_HAVE_LOG10F
inline float _CPP_log10_capture(float __x)
{ return log10f(__x); }
#else
@ -208,10 +170,7 @@
{ return log10(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_MODFF
inline float _CPP_modf_capture(float __x, float* __iptr)
{ return __builtin_modff(__x, __iptr); }
#elif _GLIBCPP_HAVE_MODFF
#if _GLIBCPP_HAVE_MODFF
inline float _CPP_modf_capture(float __x, float* __iptr)
{ return modff(__x, __iptr); }
#else
@ -224,10 +183,7 @@
}
#endif
#if _GLIBCPP_HAVE_BUILTIN_POWF
inline float _CPP_pow_capture(float __x, float __y)
{ return __builtin_powf(__x, __y); }
#elif _GLIBCPP_HAVE_POWF
#if _GLIBCPP_HAVE_POWF
inline float _CPP_pow_capture(float __x, float __y)
{ return powf(__x, __y); }
#else
@ -237,7 +193,7 @@
float pow(float, int);
#if _GLIBCPP_HAVE_BUILTIN_SINF
#if _GLIBCPP_HAVE___BUILTIN_SINF
inline float _CPP_sin_capture(float __x)
{ return __builtin_sinf(__x); }
#elif _GLIBCPP_HAVE_SINF
@ -248,10 +204,7 @@
{ return sin(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SINHF
inline float _CPP_sinh_capture(float __x)
{ return __builtin_sinhf(__x); }
#elif _GLIBCPP_HAVE_SINHF
#if _GLIBCPP_HAVE_SINHF
inline float _CPP_sinh_capture(float __x)
{ return sinhf(__x); }
#else
@ -259,7 +212,7 @@
{ return sinh(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SQRTF
#if _GLIBCPP_HAVE___BUILTIN_SQRTF
inline float _CPP_sqrt_capture(float __x)
{ return __builtin_sqrtf(__x); }
#elif _GLIBCPP_HAVE_SQRTF
@ -270,10 +223,7 @@
{ return sqrt(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANF
inline float _CPP_tan_capture(float __x)
{ return __builtin_tanf(__x); }
#elif _GLIBCPP_HAVE_TANF
#if _GLIBCPP_HAVE_TANF
inline float _CPP_tan_capture(float __x)
{ return tanf(__x); }
#else
@ -281,10 +231,7 @@
{ return tan(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANHF
inline float _CPP_tanh_capture(float __x)
{ return __builtin_tanhf(__x); }
#elif _GLIBCPP_HAVE_TANHF
#if _GLIBCPP_HAVE_TANHF
inline float _CPP_tanh_capture(float __x)
{ return tanhf(__x); }
#else
@ -296,47 +243,22 @@
// double
//
#if _GLIBCPP_HAVE_BUILTIN_ACOS
inline double _CPP_acos_capture(double __x)
{ return __builtin_acos(__x); }
#else
inline double _CPP_acos_capture(double __x)
{ return acos(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ASIN
inline double _CPP_asin_capture(double __x)
{ return __builtin_asin(__x); }
#else
inline double _CPP_asin_capture(double __x)
{ return asin(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATAN
inline double _CPP_atan_capture(double __x)
{ return __builtin_atan(__x); }
#else
inline double _CPP_atan_capture(double __x)
{ return atan(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATAN2
inline double _CPP_atan2_capture(double __y, double __x)
{ return __builtin_atan2(__y, __x); }
#else
inline double _CPP_atan2_capture(double __y, double __x)
{ return atan2(__y, __x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_CEIL
inline double _CPP_ceil_capture(double __x)
{ return __builtin_fceil(__x); }
#else
inline double _CPP_ceil_capture(double __x)
{ return ceil(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COS
#if _GLIBCPP_HAVE___BUILTIN_COS
inline double _CPP_cos_capture(double __x)
{ return __builtin_cos(__x); }
#else
@ -344,23 +266,13 @@
{ return cos(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSH
inline double _CPP_cosh_capture(double __x)
{ return __builtin_cosh(__x); }
#else
inline double _CPP_cosh_capture(double __x)
{ return cosh(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_EXP
inline double _CPP_exp_capture(double __x)
{ return __builtin_exp(__x); }
#else
inline double _CPP_exp_capture(double __x)
{ return exp(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FABS
#if _GLIBCPP_HAVE___BUILTIN_FABS
inline double _CPP_fabs_capture(double __x)
{ return __builtin_fabs(__x); }
#else
@ -368,71 +280,31 @@
{ return fabs(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FLOOR
inline double _CPP_floor_capture(double __x)
{ return __builtin_ffloor(__x); }
#else
inline double _CPP_floor_capture(double __x)
{ return floor(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FMOD
inline double _CPP_fmod_capture(double __x, double __y)
{ return __builtin_fmod(__x, __y); }
#else
inline double _CPP_fmod_capture(double __x, double __y)
{ return fmod(__x, __y); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FREXP
inline double _CPP_frexp_capture(double __x, int* __exp)
{ return __builtin_frexp(__x, __exp); }
#else
inline double _CPP_frexp_capture(double __x, int* __exp)
{ return frexp(__x, __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LDEXP
inline double _CPP_ldexp_capture(double __x, int __exp)
{ return __builtin_ldexp(__x, __exp); }
#else
inline double _CPP_ldexp_capture(double __x, int __exp)
{ return ldexp(__x, __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOG
inline double _CPP_log_capture(double __x)
{ return __builtin_log(__x); }
#else
inline double _CPP_log_capture(double __x)
{ return log(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOG10
inline double _CPP_log10_capture(double __x)
{ return __builtin_log10(__x); }
#else
inline double _CPP_log10_capture(double __x)
{ return log10(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_MODF
inline double _CPP_modf_capture(double __x, double* __iptr)
{ return __builtin_modf(__x, __iptr); }
#else
inline double _CPP_modf_capture(double __x, double* __iptr)
{ return modf(__x, __iptr); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_POW
inline double _CPP_pow_capture(double __x, double __y)
{ return __builtin_pow(__x, static_cast<double>(__y)); }
#else
inline double _CPP_pow_capture(double __x, double __y)
{ return pow(__x, __y); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SIN
#if _GLIBCPP_HAVE___BUILTIN_SIN
inline double _CPP_sin_capture(double __x)
{ return __builtin_sin(__x); }
#else
@ -440,15 +312,10 @@
{ return sin(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SINH
inline double _CPP_sinh_capture(double __x)
{ return __builtin_sinh(__x); }
#else
inline double _CPP_sinh_capture(double __x)
{ return sinh(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SQRT
#if _GLIBCPP_HAVE___BUILTIN_SQRT
inline double _CPP_sqrt_capture(double __x)
{ return __builtin_fsqrt(__x); }
#else
@ -456,30 +323,17 @@
{ return sqrt(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TAN
inline double _CPP_tan_capture(double __x)
{ return __builtin_tan(__x); }
#else
inline double _CPP_tan_capture(double __x)
{ return tan(__x); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANH
inline double _CPP_tanh_capture(double __x)
{ return __builtin_tanh(__x); }
#else
inline double _CPP_tanh_capture(double __x)
{ return tanh(__x); }
#endif
//
// long double
//
#if _GLIBCPP_HAVE_BUILTIN_ACOSL
inline long double _CPP_acos_capture(long double __x)
{ return __builtin_acosl(__x); }
#elif _GLIBCPP_HAVE_ACOSL
#if _GLIBCPP_HAVE_ACOSL
inline long double _CPP_acos_capture(long double __x)
{ return acosl(__x); }
#else
@ -487,10 +341,7 @@
{ return acos(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ASINL
inline long double _CPP_asin_capture(long double __x)
{ return __builtin_asinl(__x); }
#elif _GLIBCPP_HAVE_ASINL
#if _GLIBCPP_HAVE_ASINL
inline long double _CPP_asin_capture(long double __x)
{ return asinl(__x); }
#else
@ -498,10 +349,7 @@
{ return asin(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATANL
inline long double _CPP_atan_capture(long double __x)
{ return __builtin_atanl(__x); }
#elif _GLIBCPP_HAVE_ATANL
#if _GLIBCPP_HAVE_ATANL
inline long double _CPP_atan_capture(long double __x)
{ return atanl(__x); }
#else
@ -509,10 +357,7 @@
{ return atan(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_ATAN2L
inline long double _CPP_atan2_capture(long double __y, long double __x)
{ return __builtin_atan2l(__y, __x); }
#elif _GLIBCPP_HAVE_ATAN2L
#if _GLIBCPP_HAVE_ATAN2L
inline long double _CPP_atan2_capture(long double __y, long double __x)
{ return atan2l(__y, __x); }
#else
@ -520,9 +365,6 @@
{ return atan2(static_cast<double>(__y), static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_CEILL
inline long double _CPP_ceil_capture(long double __x)
{ return __builtin_ceill(__x); }
#elif _GLIBCPP_HAVE_CEILL
inline long double _CPP_ceil_capture(long double __x)
{ return ceill(__x); }
@ -531,7 +373,7 @@
{ return ceil(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSL
#if _GLIBCPP_HAVE___BUILTIN_COSL
inline long double _CPP_cos_capture(long double __x)
{ return __builtin_cosl(__x); }
#elif _GLIBCPP_HAVE_COSL
@ -542,10 +384,7 @@
{ return cos(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_COSHL
inline long double _CPP_cosh_capture(long double __x)
{ return __builtin_coshl(__x); }
#elif _GLIBCPP_HAVE_COSHL
#if _GLIBCPP_HAVE_COSHL
inline long double _CPP_cosh_capture(long double __x)
{ return coshl(__x); }
#else
@ -553,10 +392,7 @@
{ return cosh(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_EXPL
inline long double _CPP_exp_capture(long double __x)
{ return __builtin_expl(__x); }
#elif _GLIBCPP_HAVE_EXPL
#if _GLIBCPP_HAVE_EXPL
inline long double _CPP_exp_capture(long double __x)
{ return expl(__x); }
#else
@ -564,7 +400,7 @@
{ return exp(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FABSL
#if _GLIBCPP_HAVE___BUILTIN_FABSL
inline long double _CPP_fabs_capture(long double __x)
{ return __builtin_fabsl(__x); }
#elif _GLIBCPP_HAVE_FABSL
@ -575,10 +411,7 @@
{ return fabs(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FLOORL
inline long double _CPP_floor_capture(long double __x)
{ return __builtin_floorl(__x); }
#elif _GLIBCPP_HAVE_FLOORL
#if _GLIBCPP_HAVE_FLOORL
inline long double _CPP_floor_capture(long double __x)
{ return floorl(__x); }
#else
@ -586,10 +419,7 @@
{ return floor(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FMODL
inline long double _CPP_fmod_capture(long double __x, long double __y)
{ return __builtin_fmodl(__x, __y); }
#elif _GLIBCPP_HAVE_FMODL
#if _GLIBCPP_HAVE_FMODL
inline long double _CPP_fmod_capture(long double __x, long double __y)
{ return fmodl(__x, __y); }
#else
@ -597,10 +427,7 @@
{ return fmod(static_cast<double>(__x), static_cast<double>(__y)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_FREXPL
inline long double _CPP_frexp_capture(long double __x, int* __exp)
{ return __builtin_frexpl(__x, __exp); }
#elif _GLIBCPP_HAVE_FREXPL
#if _GLIBCPP_HAVE_FREXPL
inline long double _CPP_frexp_capture(long double __x, int* __exp)
{ return frexpl(__x, __exp); }
#else
@ -608,10 +435,7 @@
{ return frexp(static_cast<double>(__x), __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LDEXPL
inline long double _CPP_ldexp_capture(long double __x, int __exp)
{ return __builtin_ldexpl(__x, __exp); }
#elif _GLIBCPP_HAVE_LDEXPL
#if _GLIBCPP_HAVE_LDEXPL
inline long double _CPP_ldexp_capture(long double __x, int __exp)
{ return ldexpl(__x, __exp); }
#else
@ -619,10 +443,7 @@
{ return ldexp(static_cast<double>(__x), __exp); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOGL
inline long double _CPP_log_capture(long double __x)
{ return __builtin_logl(__x); }
#elif _GLIBCPP_HAVE_LOGL
#if _GLIBCPP_HAVE_LOGL
inline long double _CPP_log_capture(long double __x)
{ return logl(__x); }
#else
@ -630,10 +451,7 @@
{ return log(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_LOG10L
inline long double _CPP_log10_capture(long double __x)
{ return __builtin_log10l(__x); }
#elif _GLIBCPP_HAVE_LOG10L
#if _GLIBCPP_HAVE_LOG10L
inline long double _CPP_log10_capture(long double __x)
{ return log10l(__x); }
#else
@ -641,10 +459,7 @@
{ return log10(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_MODFL
inline long double _CPP_mod_capture(long double __x, long double* __iptr)
{ return __builtin_modfl(__x, __iptr); }
#elif _GLIBCPP_HAVE_MODFL
#if _GLIBCPP_HAVE_MODFL
inline long double _CPP_modf_capture(long double __x, long double* __iptr)
{ return modfl(__x, __iptr); }
#else
@ -657,10 +472,7 @@
}
#endif
#if _GLIBCPP_HAVE_BUILTIN_POWL
inline long double _CPP_pow_capture(long double __x, long double __y)
{ return __builtin_powl(__x, __y); }
#elif _GLIBCPP_HAVE_POWL
#if _GLIBCPP_HAVE_POWL
inline long double _CPP_pow_capture(long double __x, long double __y)
{ return powl(__x, __y); }
#else
@ -668,7 +480,7 @@
{ return pow(static_cast<double>(__x), static_cast<double>(__y)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SINL
#if _GLIBCPP_HAVE___BUILTIN_SINL
inline long double _CPP_sin_capture(long double __x)
{ return __builtin_sinl(__x); }
#elif _GLIBCPP_HAVE_SINL
@ -679,10 +491,7 @@
{ return sin(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SINHL
inline long double _CPP_sinh_capture(long double __x)
{ return __builtin_sinhl(__x); }
#elif _GLIBCPP_HAVE_SINHL
#if _GLIBCPP_HAVE_SINHL
inline long double _CPP_sinh_capture(long double __x)
{ return sinhl(__x); }
#else
@ -690,7 +499,7 @@
{ return sinh(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_SQRTL
#if _GLIBCPP_HAVE___BUILTIN_SQRTL
inline long double _CPP_sqrt_capture(long double __x)
{ return __builtin_sqrtl(__x); }
#elif _GLIBCPP_HAVE_SQRTL
@ -701,10 +510,7 @@
{ return sqrt(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANL
inline long double _CPP_tan_capture(long double __x)
{ return __builtin_tanl(__x); }
#elif _GLIBCPP_HAVE_TANL
#if _GLIBCPP_HAVE_TANL
inline long double _CPP_tan_capture(long double __x)
{ return tanl(__x); }
#else
@ -712,10 +518,7 @@
{ return tan(static_cast<double>(__x)); }
#endif
#if _GLIBCPP_HAVE_BUILTIN_TANHL
inline long double _CPP_tanh_capture(long double __x)
{ return __builtin_tanhl(__x); }
#elif _GLIBCPP_HAVE_TANHL
#if _GLIBCPP_HAVE_TANHL
inline long double _CPP_tanh_capture(long double __x)
{ return tanhl(__x); }
#else