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

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


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@34436 138bc75d-0d04-0410-961f-82ee72b054a4

11 files changed, 5400 insertions, 568 deletions

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 8e8b6f827bc..961e57a77f9 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,19 @@
+2000-06-06  Steven King  <sxking@uswest.net>
+
+	* acconfig.h: Added defines for HAVE_BUILTIN math functs for float,
+	double and long double.  Added defines for HAVE libm math functs for
+	float and long double.
+	* aclocal.m4: Added configure checks for builtin math funcs and libm
+	support for float and long double versions of the math functions.
+	* config.h.in: Added undefs for math functs.
+	* configure: Regenerate.
+	* math/mathconf: Changed the _GLIBCPP_HAS_BUILTIN_* to
+	_GLIBCPP_HAVE_BUILTIN_*.
+	* bits/std_cmath.h: Added long double support.  Use builtins for
+	float, double and long if available, otherwise, use libm versions if
+	availible, otherwise, punt.
+	* shadow/bits/std_cmath.h: ditto
+
 2000-06-02  Benjamin Kosnik  <bkoz@purist.soma.redhat.com>
 
 	* bits/locale_facets.h: Tweak.
diff --git a/libstdc++-v3/acconfig.h b/libstdc++-v3/acconfig.h
index e6f1734197a..510465d6559 100644
--- a/libstdc++-v3/acconfig.h
+++ b/libstdc++-v3/acconfig.h
@@ -12,17 +12,194 @@
 // Define if code specialized for wchar_t should be used.
 #undef _GLIBCPP_USE_WCHAR_T
 
-// Define if the compiler/host combination has __builtin_sinf defined.
-#undef _GLIBCPP_HAS_BUILTIN_SINF
+// Define if the compiler/host combination has __builtin_acos
+#undef HAVE_BUILTIN_ACOS
 
-// Define if the compiler/host combination has __builtin_cosf defined.
-#undef _GLIBCPP_HAS_BUILTIN_COSF
+// Define if the compiler/host combination has __builtin_acosf
+#undef HAVE_BUILTIN_ACOSF
 
-// Define if the compiler/host combination has __builtin_fabsf defined.
-#undef _GLIBCPP_HAS_BUILTIN_FABSF
+// Define if the compiler/host combination has __builtin_acosl
+#undef HAVE_BUILTIN_ACOSL
 
-// Define if the compiler/host combination has __builtin_fabsf defined.
-#undef _GLIBCPP_HAS_BUILTIN_SQRTF
+// Define if the compiler/host combination has __builtin_asin
+#undef HAVE_BUILTIN_ASIN
+
+// Define if the compiler/host combination has __builtin_asinf
+#undef HAVE_BUILTIN_ASINF
+
+// Define if the compiler/host combination has __builtin_asinl
+#undef HAVE_BUILTIN_ASINL
+
+// Define if the compiler/host combination has __builtin_atan
+#undef HAVE_BUILTIN_ATAN
+
+// Define if the compiler/host combination has __builtin_atanf
+#undef HAVE_BUILTIN_ATANF
+
+// Define if the compiler/host combination has __builtin_atanl
+#undef HAVE_BUILTIN_ATANL
+
+// Define if the compiler/host combination has __builtin_atan2
+#undef HAVE_BUILTIN_ATAN2
+
+// Define if the compiler/host combination has __builtin_atan2f
+#undef HAVE_BUILTIN_ATAN2F
+
+// Define if the compiler/host combination has __builtin_atan2l
+#undef HAVE_BUILTIN_ATAN2L
+
+// Define if the compiler/host combination has __builtin_ceil
+#undef HAVE_BUILTIN_CEIL
+
+// Define if the compiler/host combination has __builtin_ceilf
+#undef HAVE_BUILTIN_CEILF
+
+// Define if the compiler/host combination has __builtin_ceill
+#undef HAVE_BUILTIN_CEILL
+
+// Define if the compiler/host combination has __builtin_cos
+#undef HAVE_BUILTIN_COS
+
+// Define if the compiler/host combination has __builtin_cosf
+#undef HAVE_BUILTIN_COSF
+
+// Define if the compiler/host combination has __builtin_cosl
+#undef HAVE_BUILTIN_COSL
+
+// Define if the compiler/host combination has __builtin_cosh
+#undef HAVE_BUILTIN_COSH
+
+// Define if the compiler/host combination has __builtin_coshf
+#undef HAVE_BUILTIN_COSHF
+
+// Define if the compiler/host combination has __builtin_coshl
+#undef HAVE_BUILTIN_COSHL
+
+// Define if the compiler/host combination has __builtin_exp
+#undef HAVE_BUILTIN_EXP
+
+// Define if the compiler/host combination has __builtin_expf
+#undef HAVE_BUILTIN_EXPF
+
+// Define if the compiler/host combination has __builtin_expl
+#undef HAVE_BUILTIN_EXPL
+
+// Define if the compiler/host combination has __builtin_fabs
+#undef HAVE_BUILTIN_FABS
+
+// Define if the compiler/host combination has __builtin_fabsf
+#undef HAVE_BUILTIN_FABSF
+
+// Define if the compiler/host combination has __builtin_fabsl
+#undef HAVE_BUILTIN_FABSL
+
+// Define if the compiler/host combination has __builtin_floor
+#undef HAVE_BUILTIN_FLOOR
+
+// Define if the compiler/host combination has __builtin_floorf
+#undef HAVE_BUILTIN_FLOORF
+
+// Define if the compiler/host combination has __builtin_floorl
+#undef HAVE_BUILTIN_FLOORL
+
+// Define if the compiler/host combination has __builtin_frexp
+#undef HAVE_BUILTIN_FREXP
+
+// Define if the compiler/host combination has __builtin_frexpf
+#undef HAVE_BUILTIN_FREXPF
+
+// Define if the compiler/host combination has __builtin_frexpl
+#undef HAVE_BUILTIN_FREXPL
+
+// Define if the compiler/host combination has __builtin_ldexp
+#undef HAVE_BUILTIN_LDEXP
+
+// Define if the compiler/host combination has __builtin_ldexpf
+#undef HAVE_BUILTIN_LDEXPF
+
+// Define if the compiler/host combination has __builtin_ldexpl
+#undef HAVE_BUILTIN_LDEXPL
+
+// Define if the compiler/host combination has __builtin_log
+#undef HAVE_BUILTIN_LOG
+
+// Define if the compiler/host combination has __builtin_logf
+#undef HAVE_BUILTIN_LOGF
+
+// Define if the compiler/host combination has __builtin_logl
+#undef HAVE_BUILTIN_LOGL
+
+// Define if the compiler/host combination has __builtin_log10
+#undef HAVE_BUILTIN_LOG10
+
+// Define if the compiler/host combination has __builtin_log10f
+#undef HAVE_BUILTIN_LOG10F
+
+// Define if the compiler/host combination has __builtin_log10l
+#undef HAVE_BUILTIN_LOG10L
+
+// Define if the compiler/host combination has __builtin_modf
+#undef HAVE_BUILTIN_MODF
+
+// Define if the compiler/host combination has __builtin_modff
+#undef HAVE_BUILTIN_MODFF
+
+// Define if the compiler/host combination has __builtin_modfl
+#undef HAVE_BUILTIN_MODFL
+
+// Define if the compiler/host combination has __builtin_pow
+#undef HAVE_BUILTIN_POW
+
+// Define if the compiler/host combination has __builtin_powf
+#undef HAVE_BUILTIN_POWF
+
+// Define if the compiler/host combination has __builtin_powl
+#undef HAVE_BUILTIN_POWL
+
+// Define if the compiler/host combination has __builtin_sin
+#undef HAVE_BUILTIN_SIN
+
+// Define if the compiler/host combination has __builtin_sinf
+#undef HAVE_BUILTIN_SINF
+
+// Define if the compiler/host combination has __builtin_sinl
+#undef HAVE_BUILTIN_SINL
+
+// Define if the compiler/host combination has __builtin_sinh
+#undef HAVE_BUILTIN_SINH
+
+// Define if the compiler/host combination has __builtin_sinhf
+#undef HAVE_BUILTIN_SINHF
+
+// Define if the compiler/host combination has __builtin_sinhl
+#undef HAVE_BUILTIN_SINHL
+
+// Define if the compiler/host combination has __builtin_sqrt
+#undef HAVE_BUILTIN_SQRT
+
+// Define if the compiler/host combination has __builtin_sqrtf
+#undef HAVE_BUILTIN_SQRTF
+
+// Define if the compiler/host combination has __builtin_sqrtl
+#undef HAVE_BUILTIN_SQRTL
+
+// Define if the compiler/host combination has __builtin_tan
+#undef HAVE_BUILTIN_TAN
+
+// Define if the compiler/host combination has __builtin_tanf
+#undef HAVE_BUILTIN_TANF
+
+// Define if the compiler/host combination has __builtin_tanl
+#undef HAVE_BUILTIN_TANL
+
+// Define if the compiler/host combination has __builtin_tanh
+#undef HAVE_BUILTIN_TANH
+
+// Define if the compiler/host combination has __builtin_tanhf
+#undef HAVE_BUILTIN_TANHF
+
+// Define if the compiler/host combination has __builtin_tanhl
+#undef HAVE_BUILTIN_TANHL
 
 // Define if GCC support for __complex__ float is buggy.
 #undef _GLIBCPP_BUGGY_FLOAT_COMPLEX
@@ -90,66 +267,221 @@
 # define cosf _cosf
 #endif
 
+#if defined (HAVE__ACOSF) && ! defined (HAVE_ACOSF)
+# define HAVE_ACOSF 1
+# define acosf _acosf
+#endif
+
+#if defined (HAVE__ACOSL) && ! defined (HAVE_ACOSL)
+# define HAVE_ACOSL 1
+# define acosl _acosl
+#endif
+
+#if defined (HAVE__ASINF) && ! defined (HAVE_ASINF)
+# define HAVE_ASINF 1
+# define asinf _asinf
+#endif
+
+#if defined (HAVE__ASINL) && ! defined (HAVE_ASINL)
+# define HAVE_ASINL 1
+# define asinl _asinl
+#endif
+
+#if defined (HAVE__ATANF) && ! defined (HAVE_ATANF)
+# define HAVE_ATANF 1
+# define atanf _atanf
+#endif
+
+#if defined (HAVE__ATANL) && ! defined (HAVE_ATANL)
+# define HAVE_ATANL 1
+# define atanl _atanl
+#endif
+
+#if defined (HAVE__CEILF) && ! defined (HAVE_CEILF)
+# define HAVE_CEILF 1
+# define aceil _ceilf
+#endif
+
+#if defined (HAVE__CEILL) && ! defined (HAVE_CEILL)
+# define HAVE_CEILL 1
+# define aceil _ceill
+#endif
+
 #if defined (HAVE__COSHF) && ! defined (HAVE_COSHF)
 # define HAVE_COSHF 1
 # define coshf _coshf
 #endif
 
+#if defined (HAVE__COSL) && ! defined (HAVE_COSL)
+# define HAVE_COSL 1
+# define cosl _cosl
+#endif
+
 #if defined (HAVE__LOGF) && ! defined (HAVE_LOGF)
 # define HAVE_LOGF 1
 # define logf _logf
 #endif
 
+#if defined (HAVE__COSHL) && ! defined (HAVE_COSHL)
+# define HAVE_COSHL 1
+# define coshl _coshl
+#endif
+
+#if defined (HAVE__EXPF) && ! defined (HAVE_EXPF)
+# define HAVE_EXPF 1
+# define expf _expf
+#endif
+
+#if defined (HAVE__EXPL) && ! defined (HAVE_EXPL)
+# define HAVE_EXPL 1
+# define expl _expl
+#endif
+
+#if defined (HAVE__FABSF) && ! defined (HAVE_FABSF)
+# define HAVE_FABSF 1
+# define fabsf _fabsf
+#endif
+
+#if defined (HAVE__FABSL) && ! defined (HAVE_FABSL)
+# define HAVE_FABSL 1
+# define fabsl _fabsl
+#endif
+
+#if defined (HAVE__FLOORF) && ! defined (HAVE_FLOORF)
+# define HAVE_FLOORF 1
+# define floorf _floorf
+#endif
+
+#if defined (HAVE__FLOORL) && ! defined (HAVE_FLOORL)
+# define HAVE_FLOORL 1
+# define floorl _floorl
+#endif
+
+#if defined (HAVE__FMODF) && ! defined (HAVE_FMODF)
+# define HAVE_FMODF 1
+# define fmodf _fmodf
+#endif
+
+#if defined (HAVE__FMODL) && ! defined (HAVE_FMODL)
+# define HAVE_FMODL 1
+# define fmodl _fmodl
+#endif
+
+#if defined (HAVE__FREXPF) && ! defined (HAVE_FREXPF)
+# define HAVE_FREXPF 1
+# define frexpf _frexpf
+#endif
+
+#if defined (HAVE__FREXPL) && ! defined (HAVE_FREXPL)
+# define HAVE_FREXPL 1
+# define frexpl _frexpl
+#endif
+
+#if defined (HAVE__LDEXPF) && ! defined (HAVE_LDEXPF)
+# define HAVE_LDEXPF 1
+# define ldexpf _ldexpf
+#endif
+
+#if defined (HAVE__LDEXPL) && ! defined (HAVE_LDEXPL)
+# define HAVE_LDEXPL 1
+# define ldexpl _ldexpl
+#endif
+
 #if defined (HAVE__LOG10F) && ! defined (HAVE_LOG10F)
 # define HAVE_LOG10F 1
 # define log10f _log10f
 #endif
 
+#if defined (HAVE__LOGL) && ! defined (HAVE_LOGL)
+# define HAVE_LOGL 1
+# define logl _logl
+#endif
+
 #if defined (HAVE__POWF) && ! defined (HAVE_POWF)
 # define HAVE_POWF 1
 # define powf _powf
 #endif
 
+#if defined (HAVE__LOG10L) && ! defined (HAVE_LOG10L)
+# define HAVE_LOG10L 1
+# define log10l _log10l
+#endif
+
+#if defined (HAVE__MODF) && ! defined (HAVE_MODF)
+# define HAVE_MODF 1
+# define modf _modf
+#endif
+
+#if defined (HAVE__MODL) && ! defined (HAVE_MODL)
+# define HAVE_MODL 1
+# define modl _modl
+#endif
+
 #if defined (HAVE__SINF) && ! defined (HAVE_SINF)
 # define HAVE_SINF 1
 # define sinf _sinf
 #endif
 
+#if defined (HAVE__POWL) && ! defined (HAVE_POWL)
+# define HAVE_POWL 1
+# define powl _powl
+#endif
+
 #if defined (HAVE__SINHF) && ! defined (HAVE_SINHF)
 # define HAVE_SINHF 1
 # define sinhf _sinhf
 #endif
 
+#if defined (HAVE__SINL) && ! defined (HAVE_SINL)
+# define HAVE_SINL 1
+# define sinl _sinl
+#endif
+
 #if defined (HAVE__SQRTF) && ! defined (HAVE_SQRTF)
 # define HAVE_SQRTF 1
 # define sqrtf _sqrtf
 #endif
 
+#if defined (HAVE__SINHL) && ! defined (HAVE_SINHL)
+# define HAVE_SINHL 1
+# define sinhl _sinhl
+#endif
+
 #if defined (HAVE__TANF) && ! defined (HAVE_TANF)
 # define HAVE_TANF 1
 # define tanf _tanf
 #endif
 
+#if defined (HAVE__SQRTL) && ! defined (HAVE_SQRTL)
+# define HAVE_SQRTL 1
+# define sqrtl _sqrtl
+#endif
+
 #if defined (HAVE__TANHF) && ! defined (HAVE_TANHF)
 # define HAVE_TANHF 1
 # define tanhf _tanhf
 #endif
 
+#if defined (HAVE__TANL) && ! defined (HAVE_TANL)
+# define HAVE_TANF 1
+# define tanf _tanf
+#endif
+
 #if defined (HAVE__STRTOF) && ! defined (HAVE_STRTOF)
 # define HAVE_STRTOF 1
 # define strtof _strtof
 #endif
 
+#if defined (HAVE__TANHL) && ! defined (HAVE_TANHL)
+# define HAVE_TANHL 1
+# define tanhl _tanhl
+#endif
+
 #if defined (HAVE__STRTOLD) && ! defined (HAVE_STRTOLD)
 # define HAVE_STRTOLD 1
 # define strtold _strtold
 #endif
 
-#if defined (HAVE__FABSF) && ! defined (HAVE_FABSF)
-# define HAVE_FABSF 1
-# define fabsf _fabsf
-#endif
-
 #if defined (HAVE__SINCOS) && ! defined (HAVE_SINCOS)
 # define HAVE_SINCOS 1
 # define sincos _sincos
@@ -170,6 +502,16 @@
 # define finite _finite
 #endif
 
+#if defined (HAVE__FINITEF) && ! defined (HAVE_FINITEF)
+# define HAVE_FINITEF 1
+# define finitef _finitef
+#endif
+
+#if defined (HAVE__FINITEL) && ! defined (HAVE_FINITEL)
+# define HAVE_FINITEL 1
+# define finitel _finitel
+#endif
+
 #if defined (HAVE__QFINITE) && ! defined (HAVE_QFINITE)
 # define HAVE_QFINITE 1
 # define qfinite _qfinite
diff --git a/libstdc++-v3/acinclude.m4 b/libstdc++-v3/acinclude.m4
index 8e67e6d669c..bbea099065d 100644
--- a/libstdc++-v3/acinclude.m4
+++ b/libstdc++-v3/acinclude.m4
@@ -223,56 +223,586 @@ AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [
   AC_SUBST(FMTFLAGS)
 ])
 
-
 dnl
 dnl Check to see what builtin math functions are supported
 dnl
-dnl Define _GLIBCPP_HAS_BUILTIN_SINF if __builtin_sinf
-dnl Define _GLIBCPP_HAS_BUILTIN_COSF if __builtin_cosf
-dnl Define _GLIBCPP_HAS_BUILTIN_FABSF if __builtin_fabsf
-dnl Define _GLIBCPP_HAS_BUILTIN_SQRTF if __builtin_sqrtf
-dnl
+dnl check for __builtin_acos
+dnl check for __builtin_acosf
+dnl check for __builtin_acosl
+dnl check for __builtin_asin
+dnl check for __builtin_asinf
+dnl check for __builtin_asinl
+dnl check for __builtin_atan
+dnl check for __builtin_atanf
+dnl check for __builtin_atanl
+dnl check for __builtin_atan2
+dnl check for __builtin_atan2f
+dnl check for __builtin_atan2l
+dnl check for __builtin_ceil
+dnl check for __builtin_ceilf
+dnl check for __builtin_ceill
+dnl check for __builtin_cos
+dnl check for __builtin_cosf
+dnl check for __builtin_cosl
+dnl check for __builtin_cosh
+dnl check for __builtin_coshf
+dnl check for __builtin_coshl
+dnl check for __builtin_exp
+dnl check for __builtin_expf
+dnl check for __builtin_expl
+dnl check for __builtin_fabs
+dnl check for __builtin_fabsf
+dnl check for __builtin_fabsl
+dnl check for __builtin_floor
+dnl check for __builtin_floorf
+dnl check for __builtin_floorl
+dnl check for __builtin_frexp
+dnl check for __builtin_frexpf
+dnl check for __builtin_frexpl
+dnl check for __builtin_ldexp
+dnl check for __builtin_ldexpf
+dnl check for __builtin_ldexpl
+dnl check for __builtin_log
+dnl check for __builtin_logf
+dnl check for __builtin_logl
+dnl check for __builtin_log10
+dnl check for __builtin_log10f
+dnl check for __builtin_log10l
+dnl check for __builtin_modf
+dnl check for __builtin_modff
+dnl check for __builtin_modfl
+dnl check for __builtin_pow
+dnl check for __builtin_powf
+dnl check for __builtin_powl
+dnl check for __builtin_sin
+dnl check for __builtin_sinf
+dnl check for __builtin_sinl
+dnl check for __builtin_sinh
+dnl check for __builtin_sinhf
+dnl check for __builtin_sinhl
+dnl check for __builtin_sqrt
+dnl check for __builtin_sqrtf
+dnl check for __builtin_sqrtl
+dnl check for __builtin_tan
+dnl check for __builtin_tanf
+dnl check for __builtin_tanl
+dnl check for __builtin_tanh
+dnl check for __builtin_tanhf
+dnl check for __builtin_tanhl
 dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
   dnl Test for builtin math functions.
-  AC_MSG_CHECKING([for __builtin_sinf])
+  AC_LANG_SAVE
+  AC_LANG_CPLUSPLUS
+  AC_MSG_CHECKING([for __builtin_acos])
   AC_TRY_COMPILE([#include <math.h>], 
-  [float foo(void) { __builtin_sinf(0.0); }], 
-  use_builtin_sinf=yes, use_builtin_sinf=no)
-  AC_MSG_RESULT($use_builtin_sinf)
-  if test $use_builtin_sinf = "yes"; then
-    AC_DEFINE(_GLIBCPP_HAS_BUILTIN_SINF)
+  [ __builtin_acos(0.0);], 
+  use_builtin_acos=yes, use_builtin_acos=no)
+  AC_MSG_RESULT($use_builtin_acos)
+  if test $use_builtin_acos = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ACOS)
+  fi
+  AC_MSG_CHECKING([for __builtin_acosf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_acosf(0.0);], 
+  use_builtin_acosf=yes, use_builtin_acosf=no)
+  AC_MSG_RESULT($use_builtin_acosf)
+  if test $use_builtin_acosf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ACOSF)
+  fi
+  AC_MSG_CHECKING([for __builtin_acosl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_acosl(0.0);], 
+  use_builtin_acosl=yes, use_builtin_acosl=no)
+  AC_MSG_RESULT($use_builtin_acosl)
+  if test $use_builtin_acosl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ACOSL)
+  fi
+  AC_MSG_CHECKING([for __builtin_asin])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_asin(0.0);], 
+  use_builtin_asin=yes, use_builtin_asin=no)
+  AC_MSG_RESULT($use_builtin_asin)
+  if test $use_builtin_asin = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ASIN)
+  fi
+  AC_MSG_CHECKING([for __builtin_asinf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_asinf(0.0);], 
+  use_builtin_asinf=yes, use_builtin_asinf=no)
+  AC_MSG_RESULT($use_builtin_asinf)
+  if test $use_builtin_asinf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ASINF)
+  fi
+  AC_MSG_CHECKING([for __builtin_asinl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_asinl(0.0);], 
+  use_builtin_asinl=yes, use_builtin_asinl=no)
+  AC_MSG_RESULT($use_builtin_asinl)
+  if test $use_builtin_asinl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ASINL)
+  fi
+  AC_MSG_CHECKING([for __builtin_atan])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atan(0.0);], 
+  use_builtin_atan=yes, use_builtin_atan=no)
+  AC_MSG_RESULT($use_builtin_atan)
+  if test $use_builtin_atan = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATAN)
+  fi
+  AC_MSG_CHECKING([for __builtin_atanf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atanf(0.0);], 
+  use_builtin_atanf=yes, use_builtin_atanf=no)
+  AC_MSG_RESULT($use_builtin_atanf)
+  if test $use_builtin_atanf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATANF)
+  fi
+  AC_MSG_CHECKING([for __builtin_atanl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atanl(0.0);], 
+  use_builtin_atanl=yes, use_builtin_atanl=no)
+  AC_MSG_RESULT($use_builtin_atanl)
+  if test $use_builtin_atanl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATANL)
+  fi
+  AC_MSG_CHECKING([for __builtin_atan2])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atan2(0.0);], 
+  use_builtin_atan2=yes, use_builtin_atan2=no)
+  AC_MSG_RESULT($use_builtin_atan2)
+  if test $use_builtin_atan2 = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATAN2)
+  fi
+  AC_MSG_CHECKING([for __builtin_atan2f])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atan2f(0.0);], 
+  use_builtin_atan2f=yes, use_builtin_atan2f=no)
+  AC_MSG_RESULT($use_builtin_atan2f)
+  if test $use_builtin_atan2f = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATAN2F)
+  fi
+  AC_MSG_CHECKING([for __builtin_atan2l])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atan2l(0.0);], 
+  use_builtin_atan2l=yes, use_builtin_atan2l=no)
+  AC_MSG_RESULT($use_builtin_atan2l)
+  if test $use_builtin_atan2l = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATAN2L)
+  fi
+  AC_MSG_CHECKING([for __builtin_ceil])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_fceil(0.0);], 
+  use_builtin_ceil=yes, use_builtin_ceil=no)
+  AC_MSG_RESULT($use_builtin_ceil)
+  if test $use_builtin_ceil = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_CEIL)
+  fi
+  AC_MSG_CHECKING([for __builtin_ceilf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ceilf(0.0);], 
+  use_builtin_ceilf=yes, use_builtin_ceilf=no)
+  AC_MSG_RESULT($use_builtin_ceilf)
+  if test $use_builtin_ceilf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_CEILF)
+  fi
+  AC_MSG_CHECKING([for __builtin_ceill])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ceill(0.0);], 
+  use_builtin_ceill=yes, use_builtin_ceill=no)
+  AC_MSG_RESULT($use_builtin_ceill)
+  if test $use_builtin_ceill = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_CEILL)
+  fi
+  AC_MSG_CHECKING([for __builtin_cos])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_cos(0.0);], 
+  use_builtin_cos=yes, use_builtin_cos=no)
+  AC_MSG_RESULT($use_builtin_cos)
+  if test $use_builtin_cos = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_COS)
   fi
-
   AC_MSG_CHECKING([for __builtin_cosf])
   AC_TRY_COMPILE([#include <math.h>], 
-  [float foo(void) { __builtin_cosf(0.0); }], 
+  [ __builtin_cosf(0.0);], 
   use_builtin_cosf=yes, use_builtin_cosf=no)
   AC_MSG_RESULT($use_builtin_cosf)
   if test $use_builtin_cosf = "yes"; then
-    AC_DEFINE(_GLIBCPP_HAS_BUILTIN_COSF)
+    AC_DEFINE(HAVE_BUILTIN_COSF)
+  fi
+  AC_MSG_CHECKING([for __builtin_cosl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_cosl(0.0);], 
+  use_builtin_cosl=yes, use_builtin_cosl=no)
+  AC_MSG_RESULT($use_builtin_cosl)
+  if test $use_builtin_cosl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_COSL)
+  fi
+  AC_MSG_CHECKING([for __builtin_cosh])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_cosh(0.0);], 
+  use_builtin_cosh=yes, use_builtin_cosh=no)
+  AC_MSG_RESULT($use_builtin_cosh)
+  if test $use_builtin_cosh = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_COSH)
+  fi
+  AC_MSG_CHECKING([for __builtin_coshf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_coshf(0.0);], 
+  use_builtin_coshf=yes, use_builtin_coshf=no)
+  AC_MSG_RESULT($use_builtin_coshf)
+  if test $use_builtin_coshf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_COSHF)
+  fi
+  AC_MSG_CHECKING([for __builtin_coshl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_coshl(0.0);], 
+  use_builtin_coshl=yes, use_builtin_coshl=no)
+  AC_MSG_RESULT($use_builtin_coshl)
+  if test $use_builtin_coshl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_COSHL)
+  fi
+  AC_MSG_CHECKING([for __builtin_exp])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_exp(0.0);], 
+  use_builtin_exp=yes, use_builtin_exp=no)
+  AC_MSG_RESULT($use_builtin_exp)
+  if test $use_builtin_exp = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_EXP)
+  fi
+  AC_MSG_CHECKING([for __builtin_expf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_expf(0.0);], 
+  use_builtin_expf=yes, use_builtin_expf=no)
+  AC_MSG_RESULT($use_builtin_expf)
+  if test $use_builtin_expf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_EXPF)
+  fi
+  AC_MSG_CHECKING([for __builtin_expl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_expl(0.0);], 
+  use_builtin_expl=yes, use_builtin_expl=no)
+  AC_MSG_RESULT($use_builtin_expl)
+  if test $use_builtin_expl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_EXPL)
+  fi
+  AC_MSG_CHECKING([for __builtin_fabs])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_fabs(0.0);], 
+  use_builtin_fabs=yes, use_builtin_fabs=no)
+  AC_MSG_RESULT($use_builtin_fabs)
+  if test $use_builtin_fabs = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FABS)
   fi
-
   AC_MSG_CHECKING([for __builtin_fabsf])
   AC_TRY_COMPILE([#include <math.h>], 
-  [float foo(void) { __builtin_fabsf(0.0); }], 
+  [ __builtin_fabsf(0.0);], 
   use_builtin_fabsf=yes, use_builtin_fabsf=no)
   AC_MSG_RESULT($use_builtin_fabsf)
   if test $use_builtin_fabsf = "yes"; then
-    AC_DEFINE(_GLIBCPP_HAS_BUILTIN_FABSF)
+    AC_DEFINE(HAVE_BUILTIN_FABSF)
+  fi
+  AC_MSG_CHECKING([for __builtin_fabsl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_fabsl(0.0);], 
+  use_builtin_fabsl=yes, use_builtin_fabsl=no)
+  AC_MSG_RESULT($use_builtin_fabsl)
+  if test $use_builtin_fabsl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FABSL)
+  fi
+  AC_MSG_CHECKING([for __builtin_floor])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ffloor(0.0);], 
+  use_builtin_floor=yes, use_builtin_floor=no)
+  AC_MSG_RESULT($use_builtin_floor)
+  if test $use_builtin_floor = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FLOOR)
+  fi
+  AC_MSG_CHECKING([for __builtin_floorf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_floorf(0.0);], 
+  use_builtin_floorf=yes, use_builtin_floorf=no)
+  AC_MSG_RESULT($use_builtin_floorf)
+  if test $use_builtin_floorf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FLOORF)
+  fi
+  AC_MSG_CHECKING([for __builtin_floorl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_floorl(0.0);], 
+  use_builtin_floorl=yes, use_builtin_floorl=no)
+  AC_MSG_RESULT($use_builtin_floorl)
+  if test $use_builtin_floorl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FLOORL)
+  fi
+  AC_MSG_CHECKING([for __builtin_frexp])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_frexp(0.0);], 
+  use_builtin_frexp=yes, use_builtin_frexp=no)
+  AC_MSG_RESULT($use_builtin_frexp)
+  if test $use_builtin_frexp = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FREXP)
+  fi
+  AC_MSG_CHECKING([for __builtin_frexpf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_frexpf(0.0);], 
+  use_builtin_frexpf=yes, use_builtin_frexpf=no)
+  AC_MSG_RESULT($use_builtin_frexpf)
+  if test $use_builtin_frexpf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FREXPF)
+  fi
+  AC_MSG_CHECKING([for __builtin_frexpl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_frexpl(0.0);], 
+  use_builtin_frexpl=yes, use_builtin_frexpl=no)
+  AC_MSG_RESULT($use_builtin_frexpl)
+  if test $use_builtin_frexpl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FREXPL)
+  fi
+  AC_MSG_CHECKING([for __builtin_ldexp])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ldexp(0.0);], 
+  use_builtin_ldexp=yes, use_builtin_ldexp=no)
+  AC_MSG_RESULT($use_builtin_ldexp)
+  if test $use_builtin_ldexp = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LDEXP)
+  fi
+  AC_MSG_CHECKING([for __builtin_ldexpf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ldexpf(0.0);], 
+  use_builtin_ldexpf=yes, use_builtin_ldexpf=no)
+  AC_MSG_RESULT($use_builtin_ldexpf)
+  if test $use_builtin_ldexpf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LDEXPF)
+  fi
+  AC_MSG_CHECKING([for __builtin_ldexpl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ldexpl(0.0);], 
+  use_builtin_ldexpl=yes, use_builtin_ldexpl=no)
+  AC_MSG_RESULT($use_builtin_ldexpl)
+  if test $use_builtin_ldexpl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LDEXPL)
+  fi
+  AC_MSG_CHECKING([for __builtin_log])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_log(0.0);], 
+  use_builtin_log=yes, use_builtin_log=no)
+  AC_MSG_RESULT($use_builtin_log)
+  if test $use_builtin_log = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOG)
+  fi
+  AC_MSG_CHECKING([for __builtin_logf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_logf(0.0);], 
+  use_builtin_logf=yes, use_builtin_logf=no)
+  AC_MSG_RESULT($use_builtin_logf)
+  if test $use_builtin_logf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOGF)
+  fi
+  AC_MSG_CHECKING([for __builtin_logl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_logl(0.0);], 
+  use_builtin_logl=yes, use_builtin_logl=no)
+  AC_MSG_RESULT($use_builtin_logl)
+  if test $use_builtin_logl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOGL)
+  fi
+  AC_MSG_CHECKING([for __builtin_log10])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_log10(0.0);], 
+  use_builtin_log10=yes, use_builtin_log10=no)
+  AC_MSG_RESULT($use_builtin_log10)
+  if test $use_builtin_log10 = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOG10)
+  fi
+  AC_MSG_CHECKING([for __builtin_log10f])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_log10f(0.0);], 
+  use_builtin_log10f=yes, use_builtin_log10f=no)
+  AC_MSG_RESULT($use_builtin_log10f)
+  if test $use_builtin_log10f = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOG10F)
+  fi
+  AC_MSG_CHECKING([for __builtin_log10l])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_log10l(0.0);], 
+  use_builtin_log10l=yes, use_builtin_log10l=no)
+  AC_MSG_RESULT($use_builtin_log10l)
+  if test $use_builtin_log10l = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOG10L)
+  fi
+  AC_MSG_CHECKING([for __builtin_modf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_modf(0.0);], 
+  use_builtin_modf=yes, use_builtin_modf=no)
+  AC_MSG_RESULT($use_builtin_modf)
+  if test $use_builtin_modf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_MODF)
+  fi
+  AC_MSG_CHECKING([for __builtin_modff])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_modff(0.0);], 
+  use_builtin_modff=yes, use_builtin_modff=no)
+  AC_MSG_RESULT($use_builtin_modff)
+  if test $use_builtin_modff = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_MODFF)
+  fi
+  AC_MSG_CHECKING([for __builtin_modfl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_modfl(0.0);], 
+  use_builtin_modfl=yes, use_builtin_modfl=no)
+  AC_MSG_RESULT($use_builtin_modfl)
+  if test $use_builtin_modfl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_MODFL)
+  fi
+  AC_MSG_CHECKING([for __builtin_pow])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_pow(0.0);], 
+  use_builtin_pow=yes, use_builtin_pow=no)
+  AC_MSG_RESULT($use_builtin_pow)
+  if test $use_builtin_pow = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_POW)
+  fi
+  AC_MSG_CHECKING([for __builtin_powf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_powf(0.0);], 
+  use_builtin_powf=yes, use_builtin_powf=no)
+  AC_MSG_RESULT($use_builtin_powf)
+  if test $use_builtin_powf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_POWF)
+  fi
+  AC_MSG_CHECKING([for __builtin_powl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_powl(0.0);], 
+  use_builtin_powl=yes, use_builtin_powl=no)
+  AC_MSG_RESULT($use_builtin_powl)
+  if test $use_builtin_powl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_POWL)
+  fi
+  AC_MSG_CHECKING([for __builtin_sin])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sin(0.0);], 
+  use_builtin_sin=yes, use_builtin_sin=no)
+  AC_MSG_RESULT($use_builtin_sin)
+  if test $use_builtin_sin = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SIN)
+  fi
+  AC_MSG_CHECKING([for __builtin_sinf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sinf(0.0);], 
+  use_builtin_sinf=yes, use_builtin_sinf=no)
+  AC_MSG_RESULT($use_builtin_sinf)
+  if test $use_builtin_sinf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SINF)
+  fi
+  AC_MSG_CHECKING([for __builtin_sinl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sinl(0.0);], 
+  use_builtin_sinl=yes, use_builtin_sinl=no)
+  AC_MSG_RESULT($use_builtin_sinl)
+  if test $use_builtin_sinl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SINL)
+  fi
+  AC_MSG_CHECKING([for __builtin_sinh])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sinh(0.0);], 
+  use_builtin_sinh=yes, use_builtin_sinh=no)
+  AC_MSG_RESULT($use_builtin_sinh)
+  if test $use_builtin_sinh = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SINH)
+  fi
+  AC_MSG_CHECKING([for __builtin_sinhf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sinhf(0.0);], 
+  use_builtin_sinhf=yes, use_builtin_sinhf=no)
+  AC_MSG_RESULT($use_builtin_sinhf)
+  if test $use_builtin_sinhf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SINHF)
+  fi
+  AC_MSG_CHECKING([for __builtin_sinhl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sinhl(0.0);], 
+  use_builtin_sinhl=yes, use_builtin_sinhl=no)
+  AC_MSG_RESULT($use_builtin_sinhl)
+  if test $use_builtin_sinhl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SINHL)
+  fi
+  AC_MSG_CHECKING([for __builtin_sqrt])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_fsqrt(0.0);], 
+  use_builtin_sqrt=yes, use_builtin_sqrt=no)
+  AC_MSG_RESULT($use_builtin_sqrt)
+  if test $use_builtin_sqrt = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SQRT)
   fi
-
   AC_MSG_CHECKING([for __builtin_sqrtf])
   AC_TRY_COMPILE([#include <math.h>], 
-  [float foo(void) { __builtin_sqrtf(0.0); }], 
+  [ __builtin_sqrtf(0.0);], 
   use_builtin_sqrtf=yes, use_builtin_sqrtf=no)
   AC_MSG_RESULT($use_builtin_sqrtf)
   if test $use_builtin_sqrtf = "yes"; then
-    AC_DEFINE(_GLIBCPP_HAS_BUILTIN_SQRTF)
+    AC_DEFINE(HAVE_BUILTIN_SQRTF)
   fi
+  AC_MSG_CHECKING([for __builtin_sqrtl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sqrtl(0.0);], 
+  use_builtin_sqrtl=yes, use_builtin_sqrtl=no)
+  AC_MSG_RESULT($use_builtin_sqrtl)
+  if test $use_builtin_sqrtl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SQRTL)
+  fi
+  AC_MSG_CHECKING([for __builtin_tan])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tan(0.0);], 
+  use_builtin_tan=yes, use_builtin_tan=no)
+  AC_MSG_RESULT($use_builtin_tan)
+  if test $use_builtin_tan = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TAN)
+  fi
+  AC_MSG_CHECKING([for __builtin_tanf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tanf(0.0);], 
+  use_builtin_tanf=yes, use_builtin_tanf=no)
+  AC_MSG_RESULT($use_builtin_tanf)
+  if test $use_builtin_tanf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TANF)
+  fi
+  AC_MSG_CHECKING([for __builtin_tanl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tanl(0.0);], 
+  use_builtin_tanl=yes, use_builtin_tanl=no)
+  AC_MSG_RESULT($use_builtin_tanl)
+  if test $use_builtin_tanl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TANL)
+  fi
+  AC_MSG_CHECKING([for __builtin_tanh])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tanh(0.0);], 
+  use_builtin_tanh=yes, use_builtin_tanh=no)
+  AC_MSG_RESULT($use_builtin_tanh)
+  if test $use_builtin_tanh = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TANH)
+  fi
+  AC_MSG_CHECKING([for __builtin_tanhf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tanhf(0.0);], 
+  use_builtin_tanhf=yes, use_builtin_tanhf=no)
+  AC_MSG_RESULT($use_builtin_tanhf)
+  if test $use_builtin_tanhf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TANHF)
+  fi
+  AC_MSG_CHECKING([for __builtin_tanhl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tanhl(0.0);], 
+  use_builtin_tanhl=yes, use_builtin_tanhl=no)
+  AC_MSG_RESULT($use_builtin_tanhl)
+  if test $use_builtin_tanhl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TANHL)
+  fi
+  AC_LANG_RESTORE
 ])
 
 
+
 dnl Check to see what architecture we are compiling for. If it's
 dnl supported, use special hand-crafted routines to provide thread
 dnl primitives. Also, if architecture-specific flags are required for 
@@ -496,20 +1026,26 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
   csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l))
   AC_SUBST(USE_LONG_DOUBLE)
 
-  dnl Check to see if basic C math functions have faster float versions.
-  AC_CHECK_FUNCS(modf isnan isnanf isnanl isinf isinff isinfl copysign \
-  copysignl cosf coshf logf log10f powf sinf sinhf sqrtf tanf tanhf \
-  strtof strtold fabsf sincos sincosf sincosl finite finite fqfinite \
-  fpclass qfpclass)
+  dnl Check to see if basic C math functions have float, long double versions.
+  AC_CHECK_FUNCS(isnan isnanf isnanl isinf isinff isinfl copysign copysignl \
+  acosf acosl asinf asinl atanf atanl atan2f atan2l ceilf ceill cosf cosl \
+  coshf coshl expf expl fabsf fabsl floorf floorl frexpf frexpl ldexpf \
+  ldexpl logf logl log10f log10l modf modff modfl powf powl sinf sinl sinhf \
+  sinhl sqrtf sqrtl tanf tanl tanhf tanhl strtof strtold sincos sincosf \
+  sincosl finite finitef finitel fqfinite fpclass qfpclass)
 
 #Some runtimes have these functions with a preceding underscore. Please
 # keep this sync'd with the one above. And if you add any new symbol,
 # please add the corresponding block in the @BOTTOM@ section of
 # acconfig.h.
-AC_CHECK_FUNCS(_modf _isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \
-_copysignl _cosf _coshf _logf _log10f _powf _sinf _sinhf _sqrtf _tanf _tanhf \
-_strtof _strtold _fabsf _sincos _sincosf _sincosl _finite _finitef _qfinite \
-_fpclass _qfpclass)
+
+  AC_CHECK_FUNCS(_isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \
+  _copysignl _acosf _acosl _asinf _asinl _atanf _atanl _atan2f _atan2l \
+  _ceilf _ceill _cosf _cosl _coshf _coshl _expf _expl _fabsf _fabsl \
+  _floorf _floorl _frexpf _frexpl _ldexpf _ldexpl _logf _logl _log10f \
+  _log10l _modf _modff _modfl _powf _powl _sinf _sinl _sinhf _sinhl _sqrtf \
+  _sqrtl _tanf _tanl _tanhf _tanhl _strtof _strtold _sincos _sincosf _sincosl \
+  _finite _finitef _finitel _fqfinite _fpclass _qfpclass)
 
 LIBS="$save_LIBS"
 ])
diff --git a/libstdc++-v3/aclocal.m4 b/libstdc++-v3/aclocal.m4
index 612291e6792..a1984a2f6e4 100644
--- a/libstdc++-v3/aclocal.m4
+++ b/libstdc++-v3/aclocal.m4
@@ -235,56 +235,586 @@ AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [
   AC_SUBST(FMTFLAGS)
 ])
 
-
 dnl
 dnl Check to see what builtin math functions are supported
 dnl
-dnl Define _GLIBCPP_HAS_BUILTIN_SINF if __builtin_sinf
-dnl Define _GLIBCPP_HAS_BUILTIN_COSF if __builtin_cosf
-dnl Define _GLIBCPP_HAS_BUILTIN_FABSF if __builtin_fabsf
-dnl Define _GLIBCPP_HAS_BUILTIN_SQRTF if __builtin_sqrtf
-dnl
+dnl check for __builtin_acos
+dnl check for __builtin_acosf
+dnl check for __builtin_acosl
+dnl check for __builtin_asin
+dnl check for __builtin_asinf
+dnl check for __builtin_asinl
+dnl check for __builtin_atan
+dnl check for __builtin_atanf
+dnl check for __builtin_atanl
+dnl check for __builtin_atan2
+dnl check for __builtin_atan2f
+dnl check for __builtin_atan2l
+dnl check for __builtin_ceil
+dnl check for __builtin_ceilf
+dnl check for __builtin_ceill
+dnl check for __builtin_cos
+dnl check for __builtin_cosf
+dnl check for __builtin_cosl
+dnl check for __builtin_cosh
+dnl check for __builtin_coshf
+dnl check for __builtin_coshl
+dnl check for __builtin_exp
+dnl check for __builtin_expf
+dnl check for __builtin_expl
+dnl check for __builtin_fabs
+dnl check for __builtin_fabsf
+dnl check for __builtin_fabsl
+dnl check for __builtin_floor
+dnl check for __builtin_floorf
+dnl check for __builtin_floorl
+dnl check for __builtin_frexp
+dnl check for __builtin_frexpf
+dnl check for __builtin_frexpl
+dnl check for __builtin_ldexp
+dnl check for __builtin_ldexpf
+dnl check for __builtin_ldexpl
+dnl check for __builtin_log
+dnl check for __builtin_logf
+dnl check for __builtin_logl
+dnl check for __builtin_log10
+dnl check for __builtin_log10f
+dnl check for __builtin_log10l
+dnl check for __builtin_modf
+dnl check for __builtin_modff
+dnl check for __builtin_modfl
+dnl check for __builtin_pow
+dnl check for __builtin_powf
+dnl check for __builtin_powl
+dnl check for __builtin_sin
+dnl check for __builtin_sinf
+dnl check for __builtin_sinl
+dnl check for __builtin_sinh
+dnl check for __builtin_sinhf
+dnl check for __builtin_sinhl
+dnl check for __builtin_sqrt
+dnl check for __builtin_sqrtf
+dnl check for __builtin_sqrtl
+dnl check for __builtin_tan
+dnl check for __builtin_tanf
+dnl check for __builtin_tanl
+dnl check for __builtin_tanh
+dnl check for __builtin_tanhf
+dnl check for __builtin_tanhl
 dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
   dnl Test for builtin math functions.
-  AC_MSG_CHECKING([for __builtin_sinf])
+  AC_LANG_SAVE
+  AC_LANG_CPLUSPLUS
+  AC_MSG_CHECKING([for __builtin_acos])
   AC_TRY_COMPILE([#include <math.h>], 
-  [float foo(void) { __builtin_sinf(0.0); }], 
-  use_builtin_sinf=yes, use_builtin_sinf=no)
-  AC_MSG_RESULT($use_builtin_sinf)
-  if test $use_builtin_sinf = "yes"; then
-    AC_DEFINE(_GLIBCPP_HAS_BUILTIN_SINF)
+  [ __builtin_acos(0.0);], 
+  use_builtin_acos=yes, use_builtin_acos=no)
+  AC_MSG_RESULT($use_builtin_acos)
+  if test $use_builtin_acos = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ACOS)
+  fi
+  AC_MSG_CHECKING([for __builtin_acosf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_acosf(0.0);], 
+  use_builtin_acosf=yes, use_builtin_acosf=no)
+  AC_MSG_RESULT($use_builtin_acosf)
+  if test $use_builtin_acosf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ACOSF)
+  fi
+  AC_MSG_CHECKING([for __builtin_acosl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_acosl(0.0);], 
+  use_builtin_acosl=yes, use_builtin_acosl=no)
+  AC_MSG_RESULT($use_builtin_acosl)
+  if test $use_builtin_acosl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ACOSL)
+  fi
+  AC_MSG_CHECKING([for __builtin_asin])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_asin(0.0);], 
+  use_builtin_asin=yes, use_builtin_asin=no)
+  AC_MSG_RESULT($use_builtin_asin)
+  if test $use_builtin_asin = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ASIN)
+  fi
+  AC_MSG_CHECKING([for __builtin_asinf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_asinf(0.0);], 
+  use_builtin_asinf=yes, use_builtin_asinf=no)
+  AC_MSG_RESULT($use_builtin_asinf)
+  if test $use_builtin_asinf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ASINF)
+  fi
+  AC_MSG_CHECKING([for __builtin_asinl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_asinl(0.0);], 
+  use_builtin_asinl=yes, use_builtin_asinl=no)
+  AC_MSG_RESULT($use_builtin_asinl)
+  if test $use_builtin_asinl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ASINL)
+  fi
+  AC_MSG_CHECKING([for __builtin_atan])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atan(0.0);], 
+  use_builtin_atan=yes, use_builtin_atan=no)
+  AC_MSG_RESULT($use_builtin_atan)
+  if test $use_builtin_atan = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATAN)
+  fi
+  AC_MSG_CHECKING([for __builtin_atanf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atanf(0.0);], 
+  use_builtin_atanf=yes, use_builtin_atanf=no)
+  AC_MSG_RESULT($use_builtin_atanf)
+  if test $use_builtin_atanf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATANF)
+  fi
+  AC_MSG_CHECKING([for __builtin_atanl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atanl(0.0);], 
+  use_builtin_atanl=yes, use_builtin_atanl=no)
+  AC_MSG_RESULT($use_builtin_atanl)
+  if test $use_builtin_atanl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATANL)
+  fi
+  AC_MSG_CHECKING([for __builtin_atan2])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atan2(0.0);], 
+  use_builtin_atan2=yes, use_builtin_atan2=no)
+  AC_MSG_RESULT($use_builtin_atan2)
+  if test $use_builtin_atan2 = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATAN2)
+  fi
+  AC_MSG_CHECKING([for __builtin_atan2f])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atan2f(0.0);], 
+  use_builtin_atan2f=yes, use_builtin_atan2f=no)
+  AC_MSG_RESULT($use_builtin_atan2f)
+  if test $use_builtin_atan2f = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATAN2F)
+  fi
+  AC_MSG_CHECKING([for __builtin_atan2l])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_atan2l(0.0);], 
+  use_builtin_atan2l=yes, use_builtin_atan2l=no)
+  AC_MSG_RESULT($use_builtin_atan2l)
+  if test $use_builtin_atan2l = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_ATAN2L)
+  fi
+  AC_MSG_CHECKING([for __builtin_ceil])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_fceil(0.0);], 
+  use_builtin_ceil=yes, use_builtin_ceil=no)
+  AC_MSG_RESULT($use_builtin_ceil)
+  if test $use_builtin_ceil = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_CEIL)
+  fi
+  AC_MSG_CHECKING([for __builtin_ceilf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ceilf(0.0);], 
+  use_builtin_ceilf=yes, use_builtin_ceilf=no)
+  AC_MSG_RESULT($use_builtin_ceilf)
+  if test $use_builtin_ceilf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_CEILF)
+  fi
+  AC_MSG_CHECKING([for __builtin_ceill])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ceill(0.0);], 
+  use_builtin_ceill=yes, use_builtin_ceill=no)
+  AC_MSG_RESULT($use_builtin_ceill)
+  if test $use_builtin_ceill = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_CEILL)
+  fi
+  AC_MSG_CHECKING([for __builtin_cos])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_cos(0.0);], 
+  use_builtin_cos=yes, use_builtin_cos=no)
+  AC_MSG_RESULT($use_builtin_cos)
+  if test $use_builtin_cos = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_COS)
   fi
-
   AC_MSG_CHECKING([for __builtin_cosf])
   AC_TRY_COMPILE([#include <math.h>], 
-  [float foo(void) { __builtin_cosf(0.0); }], 
+  [ __builtin_cosf(0.0);], 
   use_builtin_cosf=yes, use_builtin_cosf=no)
   AC_MSG_RESULT($use_builtin_cosf)
   if test $use_builtin_cosf = "yes"; then
-    AC_DEFINE(_GLIBCPP_HAS_BUILTIN_COSF)
+    AC_DEFINE(HAVE_BUILTIN_COSF)
+  fi
+  AC_MSG_CHECKING([for __builtin_cosl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_cosl(0.0);], 
+  use_builtin_cosl=yes, use_builtin_cosl=no)
+  AC_MSG_RESULT($use_builtin_cosl)
+  if test $use_builtin_cosl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_COSL)
+  fi
+  AC_MSG_CHECKING([for __builtin_cosh])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_cosh(0.0);], 
+  use_builtin_cosh=yes, use_builtin_cosh=no)
+  AC_MSG_RESULT($use_builtin_cosh)
+  if test $use_builtin_cosh = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_COSH)
+  fi
+  AC_MSG_CHECKING([for __builtin_coshf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_coshf(0.0);], 
+  use_builtin_coshf=yes, use_builtin_coshf=no)
+  AC_MSG_RESULT($use_builtin_coshf)
+  if test $use_builtin_coshf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_COSHF)
+  fi
+  AC_MSG_CHECKING([for __builtin_coshl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_coshl(0.0);], 
+  use_builtin_coshl=yes, use_builtin_coshl=no)
+  AC_MSG_RESULT($use_builtin_coshl)
+  if test $use_builtin_coshl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_COSHL)
+  fi
+  AC_MSG_CHECKING([for __builtin_exp])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_exp(0.0);], 
+  use_builtin_exp=yes, use_builtin_exp=no)
+  AC_MSG_RESULT($use_builtin_exp)
+  if test $use_builtin_exp = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_EXP)
+  fi
+  AC_MSG_CHECKING([for __builtin_expf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_expf(0.0);], 
+  use_builtin_expf=yes, use_builtin_expf=no)
+  AC_MSG_RESULT($use_builtin_expf)
+  if test $use_builtin_expf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_EXPF)
+  fi
+  AC_MSG_CHECKING([for __builtin_expl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_expl(0.0);], 
+  use_builtin_expl=yes, use_builtin_expl=no)
+  AC_MSG_RESULT($use_builtin_expl)
+  if test $use_builtin_expl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_EXPL)
+  fi
+  AC_MSG_CHECKING([for __builtin_fabs])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_fabs(0.0);], 
+  use_builtin_fabs=yes, use_builtin_fabs=no)
+  AC_MSG_RESULT($use_builtin_fabs)
+  if test $use_builtin_fabs = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FABS)
   fi
-
   AC_MSG_CHECKING([for __builtin_fabsf])
   AC_TRY_COMPILE([#include <math.h>], 
-  [float foo(void) { __builtin_fabsf(0.0); }], 
+  [ __builtin_fabsf(0.0);], 
   use_builtin_fabsf=yes, use_builtin_fabsf=no)
   AC_MSG_RESULT($use_builtin_fabsf)
   if test $use_builtin_fabsf = "yes"; then
-    AC_DEFINE(_GLIBCPP_HAS_BUILTIN_FABSF)
+    AC_DEFINE(HAVE_BUILTIN_FABSF)
+  fi
+  AC_MSG_CHECKING([for __builtin_fabsl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_fabsl(0.0);], 
+  use_builtin_fabsl=yes, use_builtin_fabsl=no)
+  AC_MSG_RESULT($use_builtin_fabsl)
+  if test $use_builtin_fabsl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FABSL)
+  fi
+  AC_MSG_CHECKING([for __builtin_floor])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ffloor(0.0);], 
+  use_builtin_floor=yes, use_builtin_floor=no)
+  AC_MSG_RESULT($use_builtin_floor)
+  if test $use_builtin_floor = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FLOOR)
+  fi
+  AC_MSG_CHECKING([for __builtin_floorf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_floorf(0.0);], 
+  use_builtin_floorf=yes, use_builtin_floorf=no)
+  AC_MSG_RESULT($use_builtin_floorf)
+  if test $use_builtin_floorf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FLOORF)
+  fi
+  AC_MSG_CHECKING([for __builtin_floorl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_floorl(0.0);], 
+  use_builtin_floorl=yes, use_builtin_floorl=no)
+  AC_MSG_RESULT($use_builtin_floorl)
+  if test $use_builtin_floorl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FLOORL)
+  fi
+  AC_MSG_CHECKING([for __builtin_frexp])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_frexp(0.0);], 
+  use_builtin_frexp=yes, use_builtin_frexp=no)
+  AC_MSG_RESULT($use_builtin_frexp)
+  if test $use_builtin_frexp = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FREXP)
+  fi
+  AC_MSG_CHECKING([for __builtin_frexpf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_frexpf(0.0);], 
+  use_builtin_frexpf=yes, use_builtin_frexpf=no)
+  AC_MSG_RESULT($use_builtin_frexpf)
+  if test $use_builtin_frexpf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FREXPF)
+  fi
+  AC_MSG_CHECKING([for __builtin_frexpl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_frexpl(0.0);], 
+  use_builtin_frexpl=yes, use_builtin_frexpl=no)
+  AC_MSG_RESULT($use_builtin_frexpl)
+  if test $use_builtin_frexpl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_FREXPL)
+  fi
+  AC_MSG_CHECKING([for __builtin_ldexp])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ldexp(0.0);], 
+  use_builtin_ldexp=yes, use_builtin_ldexp=no)
+  AC_MSG_RESULT($use_builtin_ldexp)
+  if test $use_builtin_ldexp = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LDEXP)
+  fi
+  AC_MSG_CHECKING([for __builtin_ldexpf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ldexpf(0.0);], 
+  use_builtin_ldexpf=yes, use_builtin_ldexpf=no)
+  AC_MSG_RESULT($use_builtin_ldexpf)
+  if test $use_builtin_ldexpf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LDEXPF)
+  fi
+  AC_MSG_CHECKING([for __builtin_ldexpl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_ldexpl(0.0);], 
+  use_builtin_ldexpl=yes, use_builtin_ldexpl=no)
+  AC_MSG_RESULT($use_builtin_ldexpl)
+  if test $use_builtin_ldexpl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LDEXPL)
+  fi
+  AC_MSG_CHECKING([for __builtin_log])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_log(0.0);], 
+  use_builtin_log=yes, use_builtin_log=no)
+  AC_MSG_RESULT($use_builtin_log)
+  if test $use_builtin_log = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOG)
+  fi
+  AC_MSG_CHECKING([for __builtin_logf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_logf(0.0);], 
+  use_builtin_logf=yes, use_builtin_logf=no)
+  AC_MSG_RESULT($use_builtin_logf)
+  if test $use_builtin_logf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOGF)
+  fi
+  AC_MSG_CHECKING([for __builtin_logl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_logl(0.0);], 
+  use_builtin_logl=yes, use_builtin_logl=no)
+  AC_MSG_RESULT($use_builtin_logl)
+  if test $use_builtin_logl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOGL)
+  fi
+  AC_MSG_CHECKING([for __builtin_log10])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_log10(0.0);], 
+  use_builtin_log10=yes, use_builtin_log10=no)
+  AC_MSG_RESULT($use_builtin_log10)
+  if test $use_builtin_log10 = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOG10)
+  fi
+  AC_MSG_CHECKING([for __builtin_log10f])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_log10f(0.0);], 
+  use_builtin_log10f=yes, use_builtin_log10f=no)
+  AC_MSG_RESULT($use_builtin_log10f)
+  if test $use_builtin_log10f = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOG10F)
+  fi
+  AC_MSG_CHECKING([for __builtin_log10l])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_log10l(0.0);], 
+  use_builtin_log10l=yes, use_builtin_log10l=no)
+  AC_MSG_RESULT($use_builtin_log10l)
+  if test $use_builtin_log10l = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_LOG10L)
+  fi
+  AC_MSG_CHECKING([for __builtin_modf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_modf(0.0);], 
+  use_builtin_modf=yes, use_builtin_modf=no)
+  AC_MSG_RESULT($use_builtin_modf)
+  if test $use_builtin_modf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_MODF)
+  fi
+  AC_MSG_CHECKING([for __builtin_modff])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_modff(0.0);], 
+  use_builtin_modff=yes, use_builtin_modff=no)
+  AC_MSG_RESULT($use_builtin_modff)
+  if test $use_builtin_modff = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_MODFF)
+  fi
+  AC_MSG_CHECKING([for __builtin_modfl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_modfl(0.0);], 
+  use_builtin_modfl=yes, use_builtin_modfl=no)
+  AC_MSG_RESULT($use_builtin_modfl)
+  if test $use_builtin_modfl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_MODFL)
+  fi
+  AC_MSG_CHECKING([for __builtin_pow])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_pow(0.0);], 
+  use_builtin_pow=yes, use_builtin_pow=no)
+  AC_MSG_RESULT($use_builtin_pow)
+  if test $use_builtin_pow = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_POW)
+  fi
+  AC_MSG_CHECKING([for __builtin_powf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_powf(0.0);], 
+  use_builtin_powf=yes, use_builtin_powf=no)
+  AC_MSG_RESULT($use_builtin_powf)
+  if test $use_builtin_powf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_POWF)
+  fi
+  AC_MSG_CHECKING([for __builtin_powl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_powl(0.0);], 
+  use_builtin_powl=yes, use_builtin_powl=no)
+  AC_MSG_RESULT($use_builtin_powl)
+  if test $use_builtin_powl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_POWL)
+  fi
+  AC_MSG_CHECKING([for __builtin_sin])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sin(0.0);], 
+  use_builtin_sin=yes, use_builtin_sin=no)
+  AC_MSG_RESULT($use_builtin_sin)
+  if test $use_builtin_sin = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SIN)
+  fi
+  AC_MSG_CHECKING([for __builtin_sinf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sinf(0.0);], 
+  use_builtin_sinf=yes, use_builtin_sinf=no)
+  AC_MSG_RESULT($use_builtin_sinf)
+  if test $use_builtin_sinf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SINF)
+  fi
+  AC_MSG_CHECKING([for __builtin_sinl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sinl(0.0);], 
+  use_builtin_sinl=yes, use_builtin_sinl=no)
+  AC_MSG_RESULT($use_builtin_sinl)
+  if test $use_builtin_sinl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SINL)
+  fi
+  AC_MSG_CHECKING([for __builtin_sinh])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sinh(0.0);], 
+  use_builtin_sinh=yes, use_builtin_sinh=no)
+  AC_MSG_RESULT($use_builtin_sinh)
+  if test $use_builtin_sinh = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SINH)
+  fi
+  AC_MSG_CHECKING([for __builtin_sinhf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sinhf(0.0);], 
+  use_builtin_sinhf=yes, use_builtin_sinhf=no)
+  AC_MSG_RESULT($use_builtin_sinhf)
+  if test $use_builtin_sinhf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SINHF)
+  fi
+  AC_MSG_CHECKING([for __builtin_sinhl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sinhl(0.0);], 
+  use_builtin_sinhl=yes, use_builtin_sinhl=no)
+  AC_MSG_RESULT($use_builtin_sinhl)
+  if test $use_builtin_sinhl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SINHL)
+  fi
+  AC_MSG_CHECKING([for __builtin_sqrt])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_fsqrt(0.0);], 
+  use_builtin_sqrt=yes, use_builtin_sqrt=no)
+  AC_MSG_RESULT($use_builtin_sqrt)
+  if test $use_builtin_sqrt = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SQRT)
   fi
-
   AC_MSG_CHECKING([for __builtin_sqrtf])
   AC_TRY_COMPILE([#include <math.h>], 
-  [float foo(void) { __builtin_sqrtf(0.0); }], 
+  [ __builtin_sqrtf(0.0);], 
   use_builtin_sqrtf=yes, use_builtin_sqrtf=no)
   AC_MSG_RESULT($use_builtin_sqrtf)
   if test $use_builtin_sqrtf = "yes"; then
-    AC_DEFINE(_GLIBCPP_HAS_BUILTIN_SQRTF)
+    AC_DEFINE(HAVE_BUILTIN_SQRTF)
   fi
+  AC_MSG_CHECKING([for __builtin_sqrtl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_sqrtl(0.0);], 
+  use_builtin_sqrtl=yes, use_builtin_sqrtl=no)
+  AC_MSG_RESULT($use_builtin_sqrtl)
+  if test $use_builtin_sqrtl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_SQRTL)
+  fi
+  AC_MSG_CHECKING([for __builtin_tan])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tan(0.0);], 
+  use_builtin_tan=yes, use_builtin_tan=no)
+  AC_MSG_RESULT($use_builtin_tan)
+  if test $use_builtin_tan = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TAN)
+  fi
+  AC_MSG_CHECKING([for __builtin_tanf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tanf(0.0);], 
+  use_builtin_tanf=yes, use_builtin_tanf=no)
+  AC_MSG_RESULT($use_builtin_tanf)
+  if test $use_builtin_tanf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TANF)
+  fi
+  AC_MSG_CHECKING([for __builtin_tanl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tanl(0.0);], 
+  use_builtin_tanl=yes, use_builtin_tanl=no)
+  AC_MSG_RESULT($use_builtin_tanl)
+  if test $use_builtin_tanl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TANL)
+  fi
+  AC_MSG_CHECKING([for __builtin_tanh])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tanh(0.0);], 
+  use_builtin_tanh=yes, use_builtin_tanh=no)
+  AC_MSG_RESULT($use_builtin_tanh)
+  if test $use_builtin_tanh = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TANH)
+  fi
+  AC_MSG_CHECKING([for __builtin_tanhf])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tanhf(0.0);], 
+  use_builtin_tanhf=yes, use_builtin_tanhf=no)
+  AC_MSG_RESULT($use_builtin_tanhf)
+  if test $use_builtin_tanhf = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TANHF)
+  fi
+  AC_MSG_CHECKING([for __builtin_tanhl])
+  AC_TRY_COMPILE([#include <math.h>], 
+  [ __builtin_tanhl(0.0);], 
+  use_builtin_tanhl=yes, use_builtin_tanhl=no)
+  AC_MSG_RESULT($use_builtin_tanhl)
+  if test $use_builtin_tanhl = "yes"; then
+    AC_DEFINE(HAVE_BUILTIN_TANHL)
+  fi
+  AC_LANG_RESTORE
 ])
 
 
+
 dnl Check to see what architecture we are compiling for. If it's
 dnl supported, use special hand-crafted routines to provide thread
 dnl primitives. Also, if architecture-specific flags are required for 
@@ -508,20 +1038,26 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
   csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l))
   AC_SUBST(USE_LONG_DOUBLE)
 
-  dnl Check to see if basic C math functions have faster float versions.
-  AC_CHECK_FUNCS(modf isnan isnanf isnanl isinf isinff isinfl copysign \
-  copysignl cosf coshf logf log10f powf sinf sinhf sqrtf tanf tanhf \
-  strtof strtold fabsf sincos sincosf sincosl finite finite fqfinite \
-  fpclass qfpclass)
+  dnl Check to see if basic C math functions have float, long double versions.
+  AC_CHECK_FUNCS(isnan isnanf isnanl isinf isinff isinfl copysign copysignl \
+  acosf acosl asinf asinl atanf atanl atan2f atan2l ceilf ceill cosf cosl \
+  coshf coshl expf expl fabsf fabsl floorf floorl frexpf frexpl ldexpf \
+  ldexpl logf logl log10f log10l modf modff modfl powf powl sinf sinl sinhf \
+  sinhl sqrtf sqrtl tanf tanl tanhf tanhl strtof strtold sincos sincosf \
+  sincosl finite finitef finitel fqfinite fpclass qfpclass)
 
 #Some runtimes have these functions with a preceding underscore. Please
 # keep this sync'd with the one above. And if you add any new symbol,
 # please add the corresponding block in the @BOTTOM@ section of
 # acconfig.h.
-AC_CHECK_FUNCS(_modf _isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \
-_copysignl _cosf _coshf _logf _log10f _powf _sinf _sinhf _sqrtf _tanf _tanhf \
-_strtof _strtold _fabsf _sincos _sincosf _sincosl _finite _finitef _qfinite \
-_fpclass _qfpclass)
+
+  AC_CHECK_FUNCS(_isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \
+  _copysignl _acosf _acosl _asinf _asinl _atanf _atanl _atan2f _atan2l \
+  _ceilf _ceill _cosf _cosl _coshf _coshl _expf _expl _fabsf _fabsl \
+  _floorf _floorl _frexpf _frexpl _ldexpf _ldexpl _logf _logl _log10f \
+  _log10l _modf _modff _modfl _powf _powl _sinf _sinl _sinhf _sinhl _sqrtf \
+  _sqrtl _tanf _tanl _tanhf _tanhl _strtof _strtold _sincos _sincosf _sincosl \
+  _finite _finitef _finitel _fqfinite _fpclass _qfpclass)
 
 LIBS="$save_LIBS"
 ])
diff --git a/libstdc++-v3/bits/std_cmath.h b/libstdc++-v3/bits/std_cmath.h
index 39f6c860db2..80cd18abf2e 100644
--- a/libstdc++-v3/bits/std_cmath.h
+++ b/libstdc++-v3/bits/std_cmath.h
@@ -39,207 +39,652 @@
 # include_next <math.h>
 # include_next <stdlib.h>
 
-#include <bits/c++config.h>
+# include <bits/c++config.h>
 
 namespace std {
 
-  inline long
-  abs(long __l) { return ::labs(__l); }
+    //
+    // float
+    //
 
-  inline ldiv_t
-  div(long __a, long __b) { return ::ldiv(__a, __b); }
+#if _GLIBCPP_HAVE_BUILTIN_FABSF
+    inline float abs(float __x)
+      { return __builtin_fabsf(__x); }
+#elif _GLIBCPP_HAVE_FABSF
+    inline float abs(float __x)
+      { return ::fabsf(__x); }
+#else
+    inline float abs(float __x)
+      { return ::fabs(static_cast<double>(__x)); }
+#endif
 
-  // double
-  inline double
-  abs(double __x) { return ::fabs(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_ACOSF
+    inline float acos(float __x)
+      { return __builtin_acosf(__x); }
+#elif _GLIBCPP_HAVE_ACOSF
+    inline float acos(float __x)
+      { return ::acosf(__x); }
+#else
+    inline float acos(float __x)
+      { return ::acos(static_cast<double>(__x)); }
+#endif
 
-  double
-  pow(double, int);
+#if _GLIBCPP_HAVE_BUILTIN_ASINF
+    inline float asin(float __x)
+      { return __builtin_asinf(__x); }
+#elif _GLIBCPP_HAVE_ASINF
+    inline float asin(float __x)
+      { return ::asinf(__x); }
+#else
+    inline float asin(float __x)
+      { return ::asin(static_cast<double>(__x)); }
+#endif
 
-  // float
-  inline float
-  ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
+#if _GLIBCPP_HAVE_BUILTIN_ATANF
+    inline float atan(float __x)
+      { return __builtin_atanf(__x); }
+#elif _GLIBCPP_HAVE_ATANF
+    inline float atan(float __x)
+      { return ::atanf(__x); }
+#else
+    inline float atan(float __x)
+      { return ::atan(static_cast<double>(__x)); }
+#endif
 
-  inline float
-  floor(float __x) { return ::floor(static_cast<double>(__x)); }
+#if _GLIBCPP_HAVE_BUILTIN_ATAN2F
+    inline float atan2(float __y, float __x)
+      { return __builtin_atan2f(__y, __x); }
+#elif _GLIBCPP_HAVE_ATAN2F
+    inline float atan2(float __y, float __x)
+      { return ::atan2f(__y, __x); }
+#else
+    inline float atan2(float __y, float __x)
+      { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
+#endif
 
-  inline float
-  fmod(float __x, float __y) 
-  { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
+#if _GLIBCPP_HAVE_BUILTIN_CEILF
+    inline float ceil(float __x)
+      { return __builtin_ceilf(__x); }
+#elif _GLIBCPP_HAVE_CEILF
+    inline float ceil(float __x)
+      { return ::ceilf(__x); }
+#else
+    inline float ceil(float __x)
+      { return ::ceil(static_cast<double>(__x)); }
+#endif
 
-  inline float
-  frexp(float __x, int* __p) 
-  { return ::frexp(static_cast<double>(__x), __p); }
+#if _GLIBCPP_HAVE_BUILTIN_COSF
+    inline float cos(float __x)
+      { return __builtin_cosf(__x); }
+#elif _GLIBCPP_HAVE_COSF
+    inline float cos(float __x)
+      { return ::cosf(__x); }
+#else
+    inline float cos(float __x)
+      { return ::cos(static_cast<double>(__x)); }
+#endif
 
-  inline float
-  ldexp(float __x, int __i) 
-  { return ::ldexp(static_cast<double>(__x), __i); }
+#if _GLIBCPP_HAVE_BUILTIN_COSHF
+    inline float cosh(float __x)
+      { return __builtin_coshf(__x); }
+#elif _GLIBCPP_HAVE_COSHF
+    inline float cosh(float __x)
+      { return ::coshf(__x); }
+#else
+    inline float cosh(float __x)
+      { return ::cosh(static_cast<double>(__x)); }
+#endif
 
-  inline float
-  pow(float __x, float __y) 
-  { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
+#if _GLIBCPP_HAVE_BUILTIN_EXPF
+    inline float exp(float __x)
+      { return __builtin_expf(__x); }
+#elif _GLIBCPP_HAVE_EXPF
+    inline float exp(float __x)
+      { return ::expf(__x); }
+#else
+    inline float exp(float __x)
+      { return ::exp(static_cast<double>(__x)); }
+#endif
 
-  float
-  pow(float, int); 
+#if _GLIBCPP_HAVE_BUILTIN_FABSF
+    inline float fabs(float __x)
+      { return __builtin_fabsf(__x); }
+#elif _GLIBCPP_HAVE_FABSF
+    inline float fabs(float __x)
+      { return ::fabsf(__x); }
+#else
+    inline float fabs(float __x)
+      { return ::fabs(static_cast<double>(__x)); }
+#endif
 
-#if _GLIBCPP_HAVE_ABSF
-  inline float
-  abs(float __x) { return ::absf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_FLOORF
+    inline float floor(float __x)
+      { return __builtin_floorf(__x); }
+#elif _GLIBCPP_HAVE_FLOORF
+    inline float floor(float __x)
+      { return ::floorf(__x); }
 #else
-  inline float
-  abs(float __x) { return ::fabs(static_cast<double>(__x)); }
+    inline float floor(float __x)
+      { return ::floor(static_cast<double>(__x)); }
 #endif
 
-#if _GLIBCPP_HAVE_ACOSF
-  inline float
-  acos(float __x) { return ::acosf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_FMODFF
+    inline float fmod(float __x, float __y)
+      { return __builtin_fmodf(__x, __y); }
+#elif _GLIBCPP_HAVE_FMODFF
+    inline float fmod(float __x, float __y)
+      { return ::fmodf(__x, __y); }
 #else
-  inline float
-  acos(float __x) { return ::acos(static_cast<double>(__x)); }
+    inline float fmod(float __x, float __y)
+      { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
 #endif
 
-#if _GLIBCPP_HAVE_ASINF
-  inline float
-  asin(float __x) { return ::asinf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_FREXPF
+    inline float frexp(float __x, int* __exp)
+      { return __builtin_frexpf(__x, __exp); }
+#elif _GLIBCPP_HAVE_FREXPF
+    inline float frexp(float __x, int* __exp)
+      { return ::frexpf(__x, __exp); }
 #else
-  inline float
-  asin(float __x) { return ::asin(static_cast<double>(__x)); }
+    inline float frexp(float __x, int* __exp)
+      { return ::frexp(__x, __exp); }
 #endif
 
-#if _GLIBCPP_HAVE_ATANF
-  inline float
-  atan(float __x) { return ::atanf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_LDEXPF
+    inline float ldexp(float __x, int __exp)
+      { return __builtin_ldexpf(__x, __exp); }
+#elif _GLIBCPP_HAVE_LDEXPF
+    inline float ldexp(float __x, int __exp)
+      { return ::ldexpf(__x, __exp); }
 #else
-  inline float
-  atan(float __x) { return ::atan(static_cast<double>(__x)); }
+    inline float ldexp(float __x, int __exp)
+      { return ::ldexp(static_cast<double>(__x), __exp); }
 #endif
 
-#if _GLIBCPP_HAVE_ATAN2F
-  inline float
-  atan2(float __x, float __y) { return ::atan2f(__x, __y); }
+#if _GLIBCPP_HAVE_BUILTIN_LOGF
+    inline float log(float __x)
+      { return __builtin_logf(__x); }
+#elif _GLIBCPP_HAVE_LOGF
+    inline float log(float __x)
+      { return ::logf(__x); }
 #else
-  inline float
-  atan2(float __x, float __y) 
-  { return ::atan2(static_cast<double>(__x), static_cast<double>(__y)); }
+    inline float log(float __x)
+      { return ::log(static_cast<double>(__x)); }
 #endif
 
-#if _GLIBCPP_HAVE_TANF
-  inline float
-  tan(float __x) { return ::tanf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_LOG10F
+    inline float log10(float __x)
+      { return __builtin_log10f(__x); }
+#elif _GLIBCPP_HAVE_LOG10F
+    inline float log10(float __x)
+      { return ::log10f(__x); }
 #else
-  inline float
-  tan(float __x) { return ::tan(static_cast<double>(__x)); }
+    inline float log10(float __x)
+      { return ::log10(static_cast<double>(__x)); }
 #endif
 
-#if _GLIBCPP_HAVE_SINHF
-  inline float
-  sinh(float __x) { return ::sinhf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_MODF
+    inline float modf(float __x, float* __iptr)
+      { return __builtin_modff(__x, __iptr); }
+#elif _GLIBCPP_HAVE_MODF
+    inline float modf(float __x, float* __iptr)
+      { return ::modff(__x, __iptr); }
 #else
-  inline float
-  sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
+    inline float modf(float __x, float* __iptr)
+    {
+       double __tmp;
+       double __res = _C_legacy::modf(static_cast<double>(__x), &__tmp);
+       *__iptr = static_cast<float> (__tmp);
+       return __res;
+    }
 #endif
 
-#if _GLIBCPP_HAVE_TANHF
-  inline float
-  tanh(float __x) { return ::tanhf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_POWF
+    inline float pow(float __x, float __y)
+      { return __builtin_powf(__x, __y); }
+#elif _GLIBCPP_HAVE_POWF
+    inline float pow(float __x, float __y)
+      { return ::powf(__x, __y); }
 #else
-  inline float
-  tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
+    inline float pow(float __x, float __y)
+      { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
 #endif
 
-#if _GLIBCPP_HAVE_COSHF
-  inline float
-  cosh(float __x) { return ::coshf(__x); }
+    float pow (float, int);
+
+#if _GLIBCPP_HAVE_BUILTIN_SINF
+    inline float sin(float __x)
+      { return __builtin_sinf(__x); }
+#elif _GLIBCPP_HAVE_SINF
+    inline float sin(float __x)
+      { return ::sinf(__x); }
 #else
-  inline float
-  cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
+    inline float sin(float __x)
+      { return ::sin(static_cast<double>(__x)); }
 #endif
- 
-#if _GLIBCPP_HAVE_EXPF
-  inline float
-  exp(float __x) { return ::expf(__x); }
+
+#if _GLIBCPP_HAVE_BUILTIN_SINHF
+    inline float sinh(float __x)
+      { return __builtin_sinhf(__x); }
+#elif _GLIBCPP_HAVE_SINHF
+    inline float sinh(float __x)
+      { return ::sinhf(__x); }
 #else
-  inline float
-  exp(float __x) { return ::exp(static_cast<double>(__x)); }
+    inline float sinh(float __x)
+      { return ::sinh(static_cast<double>(__x)); }
 #endif
 
-#if _GLIBCPP_HAVE_LOGF
-  inline float
-  log(float __x) { return ::logf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_SQRTF
+    inline float sqrt(float __x)
+      { return __builtin_sqrtf(__x); }
+#elif _GLIBCPP_HAVE_SQRTF
+    inline float sqrt(float __x)
+      { return ::sqrtf(__x); }
 #else
-  inline float
-  log(float __x) { return ::log(static_cast<double>(__x)); }
+    inline float sqrt(float __x)
+      { return ::sqrt(static_cast<double>(__x)); }
 #endif
 
-#if _GLIBCPP_HAVE_LOG10F
-  inline float
-  log10(float __x) { return ::log10f(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_TANF
+    inline float tan(float __x)
+      { return __builtin_tanf(__x); }
+#elif _GLIBCPP_HAVE_TANF
+    inline float tan(float __x)
+      { return ::tanf(__x); }
 #else
-  inline float
-  log10(float __x) { return ::log10(static_cast<double>(__x)); }
+    inline float tan(float __x)
+      { return ::tan(static_cast<double>(__x)); }
 #endif
 
-#if _GLIBCPP_HAVE_MODFF
-  inline float
-  modf(float __x, float* __p) { return ::modff(__x, __p); }
+#if _GLIBCPP_HAVE_BUILTIN_TANHF
+    inline float tanh(float __x)
+      { return __builtin_tanhf(__x); }
+#elif _GLIBCPP_HAVE_TANHF
+    inline float tanh(float __x)
+      { return ::tanhf(__x); }
 #else
-  inline float
-  modf(float __x, float* __p) 
-  {
-    double __tmp;
-    double __res = ::modf(static_cast<double>(__x), &__tmp);
-    *__p = static_cast<float> (__tmp);
-    return __res;
-  }
+    inline float tanh(float __x)
+      { return ::tanh(static_cast<double>(__x)); }
 #endif
 
-#if GLIBCPP_HAS_BUILTIN_SINF
-  inline float
-  sin(float __x) { return __builtin_sinf(__x); }
-#elif _GLIBCPP_HAVE_SINF
-  inline float
-  sin(float __x) { return ::sinf(__x); }
+    //
+    // double
+    //
+
+#if _GLIBCPP_HAVE_BUILTIN_FABS
+    inline double abs(double __x)
+      { return __builtin_fabs(__x); }
 #else
-  inline float
-  sin(float __x) { return ::sin(static_cast<double>(__x)); }
+    inline double abs(double __x)
+      { return ::fabs(__x); }
 #endif
 
-#if GLIBCPP_HAS_BUILTIN_COSF
-  inline float
-  cos(float __x) { return __builtin_cosf(__x); }
-#elif _GLIBCPP_HAVE_COSF
-  inline float
-  cos(float __x) { return ::cosf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_ACOS
+    inline double acos(double __x)
+      { return __builtin_acos(__x); }
 #else
-  inline float
-  cos(float __x) { return ::cos(static_cast<double>(__x)); }
+    inline double acos(double __x)
+      { return ::acos(__x); }
 #endif
 
-#if GLIBCPP_HAS_BUILTIN_FABSF
-  inline float
-  fabs(float __x) { return __builtin_fabsf(__x); }
-#elif _GLIBCPP_HAVE_FABSF
-  inline float
-  fabs(float __x) { return ::fabsf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_ASIN
+    inline double asin(double __x)
+      { return __builtin_asin(__x); }
 #else
-  inline float
-  fabs(float __x) { return ::fabs(static_cast<double>(__x)); }
+    inline double asin(double __x)
+      { return ::asin(__x); }
 #endif
 
-#if GLIBCPP_HAS_BUILTIN_SQRTF
-  inline float
-  sqrt(float __x) { return __builtin_sqrtf(__x); }
-#elif _GLIBCPP_HAVE_SQRTF
-  inline float
-  sqrt(float __x) { return ::sqrtf(__x); }
+#if _GLIBCPP_HAVE_BUILTIN_ATAN
+    inline double atan(double __x)
+      { return __builtin_atan(__x); }
+#else
+    inline double atan(double __x)
+      { return ::atan(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_ATAN2
+    inline double atan2(double __y, double __x)
+      { return __builtin_atan2(__y, __x); }
+#else
+    inline double atan2(double __y, double __x)
+      { return ::atan2(__y, __x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_CEIL
+    inline double ceil(double __x)
+      { return __builtin_fceil(__x); }
+#else
+    inline double ceil(double __x)
+      { return ::ceil(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_COS
+    inline double cos(double __x)
+      { return __builtin_cos(__x); }
+#else
+    inline double cos(double __x)
+      { return ::cos(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_COSH
+    inline double cosh(double __x)
+      { return __builtin_cosh(__x); }
+#else
+    inline double cosh(double __x)
+      { return ::cosh(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_EXP
+    inline double exp(double __x)
+      { return __builtin_exp(__x); }
+#else
+    inline double exp(double __x)
+      { return ::exp(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_FABS
+    inline double fabs(double __x)
+      { return __builtin_fabs(__x); }
+#else
+    inline double fabs(double __x)
+      { return ::fabs(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_FLOOR
+    inline double floor(double __x)
+      { return __builtin_ffloor(__x); }
+#else
+    inline double floor(double __x)
+      { return ::floor(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_FMOD
+    inline double fmod(double __x, double __y)
+      { return __builtin_fmod(__x, __y); }
+#else
+    inline double fmod(double __x, double __y)
+      { return ::fmod(__x, __y); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_FREXP
+    inline double frexp(double __x, int* __exp)
+      { return __builtin_frexp(__x, __exp); }
+#else
+    inline double frexp(double __x, int* __exp)
+      { return ::frexp(__x, __exp); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_LDEXP
+    inline double ldexp(double __x, int __exp)
+      { return __builtin_ldexp(__x, __exp); }
+#else
+    inline double ldexp(double __x, int __exp)
+      { return ::ldexp(__x, __exp); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_LOG
+    inline double log(double __x)
+      { return __builtin_log(__x); }
+#else
+    inline double log(double __x)
+      { return ::log(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_LOG10
+    inline double log10(double __x)
+      { return __builtin_log10(__x); }
 #else
-  inline float
-  sqrt(float __x) { return ::sqrt(static_cast<double>(__x)); }
+    inline double log10(double __x)
+      { return ::log10(__x); }
 #endif
 
-  // XXX long double
-  long double
-  pow(long double, int);
+#if _GLIBCPP_HAVE_BUILTIN_MODF
+    inline double modf(double __x, double* __iptr)
+      { return __builtin_modf(__x, __iptr); }
+#else
+    inline double modf(double __x, double* __iptr)
+      { return ::modf(__x, __iptr); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_POW
+    inline double pow(double __x, double __y)
+      { return __builtin_pow(__x, static_cast<double>(__y)); }
+#else
+    inline double pow(double __x, double __y)
+      { return ::pow(__x, __y); }
+#endif
+
+    double pow (double, int);
+
+#if _GLIBCPP_HAVE_BUILTIN_SIN
+    inline double sin(double __x)
+      { return __builtin_sin(__x); }
+#else
+    inline double sin(double __x)
+      { return ::sin(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_SINH
+    inline double sinh(double __x)
+      { return __builtin_sinh(__x); }
+#else
+    inline double sinh(double __x)
+      { return ::sinh(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_SQRT
+    inline double sqrt(double __x)
+      { return __builtin_fsqrt(__x); }
+#else
+    inline double sqrt(double __x)
+      { return ::sqrt(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_TAN
+    inline double tan(double __x)
+      { return __builtin_tan(__x); }
+#else
+    inline double tan(double __x)
+      { return ::tan(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_TANH
+    inline double tanh(double __x)
+      { return __builtin_tanh(__x); }
+#else
+    inline double tanh(double __x)
+      { return ::tanh(__x); }
+#endif
+
+    //
+    // long double
+    //
+#if _GLIBCPP_HAVE_BUILTIN_FABSL
+    inline long double abs(long double __x)
+      { return __builtin_fabsl(__x); }
+#elif _GLIBCPP_HAVE_FABSL
+    inline long double abs(long double __x)
+      { return ::fabsl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_ACOSL
+    inline long double acos(long double __x)
+      { return __builtin_acosl(__x); }
+#elif _GLIBCPP_HAVE_ACOSL
+    inline long double acos(long double __x)
+      { return ::acosl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_ASINL
+    inline long double asin(long double __x)
+      { return __builtin_asinl(__x); }
+#elif _GLIBCPP_HAVE_ASINL
+    inline long double asin(long double __x)
+      { return ::asinl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_ATANL
+    inline long double atan(long double __x)
+      { return __builtin_atanl(__x); }
+#elif _GLIBCPP_HAVE_ATANL
+    inline long double atan(long double __x)
+      { return ::atanl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_ATAN2L
+    inline long double atan2(long double __y, long double __x)
+      { return __builtin_atan2l(__y, __x); }
+#elif _GLIBCPP_HAVE_ATAN2L
+    inline long double atan2(long double __y, long double __x)
+      { return ::atan2l(__y, __x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_CEILL
+    inline long double ceil(long double __x)
+      { return __builtin_ceill(__x); }
+#elif _GLIBCPP_HAVE_CEILL
+    inline long double ceil(long double __x)
+      { return ::ceill(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_COSL
+    inline long double cos(long double __x)
+      { return __builtin_cosl(__x); }
+#elif _GLIBCPP_HAVE_COSL
+    inline long double cos(long double __x)
+      { return ::cosl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_COSHL
+    inline long double cosh(long double __x)
+      { return __builtin_coshl(__x); }
+#elif _GLIBCPP_HAVE_COSHL
+    inline long double cosh(long double __x)
+      { return ::coshl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_EXPL
+    inline long double exp(long double __x)
+      { return __builtin_expl(__x); }
+#elif _GLIBCPP_HAVE_EXPL
+    inline long double exp(long double __x)
+      { return ::expl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_FABSL
+    inline long double fabs(long double __x)
+      { return __builtin_fabsl(__x); }
+#elif _GLIBCPP_HAVE_FABSL
+    inline long double fabs(long double __x)
+      { return ::fabsl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_FLOORL
+    inline long double floor(long double __x)
+      { return __builtin_floorl(__x); }
+#elif _GLIBCPP_HAVE_FLOORL
+    inline long double floor(long double __x)
+      { return ::floorl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_FMODL
+    inline long double fmod(long double __x, long double __y)
+      { return __builtin_fmodl(__x, __y); }
+#elif _GLIBCPP_HAVE_FMODL
+    inline long double fmod(long double __x, long double __y)
+      { return ::fmodl(__x, __y); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_FREXPL
+    inline long double frexp(long double __x, int* __exp)
+      { return __builtin_frexpl(__x, __exp); }
+#elif _GLIBCPP_HAVE_FREXPL
+    inline long double frexp(long double __x, int* __exp)
+      { return ::frexpl(__x, __exp); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_LDEXPL
+    inline long double ldexp(long double __x, int __exp)
+      { return __builtin_ldexpl(__x, __exp); }
+#elif _GLIBCPP_HAVE_LDEXPL
+    inline long double ldexp(long double __x, int __exp)
+      { return ::ldexpl(__x, __exp); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_LOGL
+    inline long double log(long double __x)
+      { return __builtin_logl(__x); }
+#elif _GLIBCPP_HAVE_LOGL
+    inline long double log(long double __x)
+      { return ::logl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_LOG10L
+    inline long double log10(long double __x)
+      { return __builtin_log10l(__x); }
+#elif _GLIBCPP_HAVE_LOG10L
+    inline long double log10(long double __x)
+      { return ::log10l(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_MODFL
+    inline long double mod(long double __x, long double* __iptr)
+      { return __builtin_modfl(__x, __iptr); }
+#elif _GLIBCPP_HAVE_MODFL
+    inline long double modf(long double __x, long double* __iptr)
+      { return ::modfl(__x, __iptr); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_POWL
+    inline long double pow(long double __x, long double __y)
+      { return __builtin_powl(__x, __y); }
+#elif _GLIBCPP_HAVE_POWL
+    inline long double pow(long double __x, long double __y)
+      { return ::powl(__x, __y); }
+#endif
+
+    long double pow(long double, int);
+
+#if _GLIBCPP_HAVE_BUILTIN_SINL
+    inline long double sin(long double __x)
+      { return __builtin_sinl(__x); }
+#elif _GLIBCPP_HAVE_SINL
+    inline long double sin(long double __x)
+      { return ::sinl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_SINHL
+    inline long double sinh(long double __x)
+      { return __builtin_sinhl(__x); }
+#elif _GLIBCPP_HAVE_SINHL
+    inline long double sinh(long double __x)
+      { return ::sinhl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_SQRTL
+    inline long double sqrt(long double __x)
+      { return __builtin_sqrtl(__x); }
+#elif _GLIBCPP_HAVE_SQRTL
+    inline long double sqrt(long double __x)
+      { return ::sqrtl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_TANL
+    inline long double tan(long double __x)
+      { return __builtin_tanl(__x); }
+#elif _GLIBCPP_HAVE_TANL
+    inline long double tan(long double __x)
+      { return ::tanl(__x); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_TANHL
+    inline long double tanh(long double __x)
+      { return __builtin_tanhl(__x); }
+#elif _GLIBCPP_HAVE_TANHL
+    inline long double tanh(long double __x)
+      { return ::tanhl(__x); }
+#endif
 
 } // std
 
diff --git a/libstdc++-v3/config.h.in b/libstdc++-v3/config.h.in
index 44af55539c8..8549b5a13ad 100644
--- a/libstdc++-v3/config.h.in
+++ b/libstdc++-v3/config.h.in
@@ -15,17 +15,194 @@
 // Define if code specialized for wchar_t should be used.
 #undef _GLIBCPP_USE_WCHAR_T
 
-// Define if the compiler/host combination has __builtin_sinf defined.
-#undef _GLIBCPP_HAS_BUILTIN_SINF
+// Define if the compiler/host combination has __builtin_acos
+#undef HAVE_BUILTIN_ACOS
 
-// Define if the compiler/host combination has __builtin_cosf defined.
-#undef _GLIBCPP_HAS_BUILTIN_COSF
+// Define if the compiler/host combination has __builtin_acosf
+#undef HAVE_BUILTIN_ACOSF
 
-// Define if the compiler/host combination has __builtin_fabsf defined.
-#undef _GLIBCPP_HAS_BUILTIN_FABSF
+// Define if the compiler/host combination has __builtin_acosl
+#undef HAVE_BUILTIN_ACOSL
 
-// Define if the compiler/host combination has __builtin_fabsf defined.
-#undef _GLIBCPP_HAS_BUILTIN_SQRTF
+// Define if the compiler/host combination has __builtin_asin
+#undef HAVE_BUILTIN_ASIN
+
+// Define if the compiler/host combination has __builtin_asinf
+#undef HAVE_BUILTIN_ASINF
+
+// Define if the compiler/host combination has __builtin_asinl
+#undef HAVE_BUILTIN_ASINL
+
+// Define if the compiler/host combination has __builtin_atan
+#undef HAVE_BUILTIN_ATAN
+
+// Define if the compiler/host combination has __builtin_atanf
+#undef HAVE_BUILTIN_ATANF
+
+// Define if the compiler/host combination has __builtin_atanl
+#undef HAVE_BUILTIN_ATANL
+
+// Define if the compiler/host combination has __builtin_atan2
+#undef HAVE_BUILTIN_ATAN2
+
+// Define if the compiler/host combination has __builtin_atan2f
+#undef HAVE_BUILTIN_ATAN2F
+
+// Define if the compiler/host combination has __builtin_atan2l
+#undef HAVE_BUILTIN_ATAN2L
+
+// Define if the compiler/host combination has __builtin_ceil
+#undef HAVE_BUILTIN_CEIL
+
+// Define if the compiler/host combination has __builtin_ceilf
+#undef HAVE_BUILTIN_CEILF
+
+// Define if the compiler/host combination has __builtin_ceill
+#undef HAVE_BUILTIN_CEILL
+
+// Define if the compiler/host combination has __builtin_cos
+#undef HAVE_BUILTIN_COS
+
+// Define if the compiler/host combination has __builtin_cosf
+#undef HAVE_BUILTIN_COSF
+
+// Define if the compiler/host combination has __builtin_cosl
+#undef HAVE_BUILTIN_COSL
+
+// Define if the compiler/host combination has __builtin_cosh
+#undef HAVE_BUILTIN_COSH
+
+// Define if the compiler/host combination has __builtin_coshf
+#undef HAVE_BUILTIN_COSHF
+
+// Define if the compiler/host combination has __builtin_coshl
+#undef HAVE_BUILTIN_COSHL
+
+// Define if the compiler/host combination has __builtin_exp
+#undef HAVE_BUILTIN_EXP
+
+// Define if the compiler/host combination has __builtin_expf
+#undef HAVE_BUILTIN_EXPF
+
+// Define if the compiler/host combination has __builtin_expl
+#undef HAVE_BUILTIN_EXPL
+
+// Define if the compiler/host combination has __builtin_fabs
+#undef HAVE_BUILTIN_FABS
+
+// Define if the compiler/host combination has __builtin_fabsf
+#undef HAVE_BUILTIN_FABSF
+
+// Define if the compiler/host combination has __builtin_fabsl
+#undef HAVE_BUILTIN_FABSL
+
+// Define if the compiler/host combination has __builtin_floor
+#undef HAVE_BUILTIN_FLOOR
+
+// Define if the compiler/host combination has __builtin_floorf
+#undef HAVE_BUILTIN_FLOORF
+
+// Define if the compiler/host combination has __builtin_floorl
+#undef HAVE_BUILTIN_FLOORL
+
+// Define if the compiler/host combination has __builtin_frexp
+#undef HAVE_BUILTIN_FREXP
+
+// Define if the compiler/host combination has __builtin_frexpf
+#undef HAVE_BUILTIN_FREXPF
+
+// Define if the compiler/host combination has __builtin_frexpl
+#undef HAVE_BUILTIN_FREXPL
+
+// Define if the compiler/host combination has __builtin_ldexp
+#undef HAVE_BUILTIN_LDEXP
+
+// Define if the compiler/host combination has __builtin_ldexpf
+#undef HAVE_BUILTIN_LDEXPF
+
+// Define if the compiler/host combination has __builtin_ldexpl
+#undef HAVE_BUILTIN_LDEXPL
+
+// Define if the compiler/host combination has __builtin_log
+#undef HAVE_BUILTIN_LOG
+
+// Define if the compiler/host combination has __builtin_logf
+#undef HAVE_BUILTIN_LOGF
+
+// Define if the compiler/host combination has __builtin_logl
+#undef HAVE_BUILTIN_LOGL
+
+// Define if the compiler/host combination has __builtin_log10
+#undef HAVE_BUILTIN_LOG10
+
+// Define if the compiler/host combination has __builtin_log10f
+#undef HAVE_BUILTIN_LOG10F
+
+// Define if the compiler/host combination has __builtin_log10l
+#undef HAVE_BUILTIN_LOG10L
+
+// Define if the compiler/host combination has __builtin_modf
+#undef HAVE_BUILTIN_MODF
+
+// Define if the compiler/host combination has __builtin_modff
+#undef HAVE_BUILTIN_MODFF
+
+// Define if the compiler/host combination has __builtin_modfl
+#undef HAVE_BUILTIN_MODFL
+
+// Define if the compiler/host combination has __builtin_pow
+#undef HAVE_BUILTIN_POW
+
+// Define if the compiler/host combination has __builtin_powf
+#undef HAVE_BUILTIN_POWF
+
+// Define if the compiler/host combination has __builtin_powl
+#undef HAVE_BUILTIN_POWL
+
+// Define if the compiler/host combination has __builtin_sin
+#undef HAVE_BUILTIN_SIN
+
+// Define if the compiler/host combination has __builtin_sinf
+#undef HAVE_BUILTIN_SINF
+
+// Define if the compiler/host combination has __builtin_sinl
+#undef HAVE_BUILTIN_SINL
+
+// Define if the compiler/host combination has __builtin_sinh
+#undef HAVE_BUILTIN_SINH
+
+// Define if the compiler/host combination has __builtin_sinhf
+#undef HAVE_BUILTIN_SINHF
+
+// Define if the compiler/host combination has __builtin_sinhl
+#undef HAVE_BUILTIN_SINHL
+
+// Define if the compiler/host combination has __builtin_sqrt
+#undef HAVE_BUILTIN_SQRT
+
+// Define if the compiler/host combination has __builtin_sqrtf
+#undef HAVE_BUILTIN_SQRTF
+
+// Define if the compiler/host combination has __builtin_sqrtl
+#undef HAVE_BUILTIN_SQRTL
+
+// Define if the compiler/host combination has __builtin_tan
+#undef HAVE_BUILTIN_TAN
+
+// Define if the compiler/host combination has __builtin_tanf
+#undef HAVE_BUILTIN_TANF
+
+// Define if the compiler/host combination has __builtin_tanl
+#undef HAVE_BUILTIN_TANL
+
+// Define if the compiler/host combination has __builtin_tanh
+#undef HAVE_BUILTIN_TANH
+
+// Define if the compiler/host combination has __builtin_tanhf
+#undef HAVE_BUILTIN_TANHF
+
+// Define if the compiler/host combination has __builtin_tanhl
+#undef HAVE_BUILTIN_TANHL
 
 // Define if GCC support for __complex__ float is buggy.
 #undef _GLIBCPP_BUGGY_FLOAT_COMPLEX
@@ -42,6 +219,36 @@
 // Define if modf is present in <math.h>
 #undef HAVE_MODF
 
+/* Define if you have the _acosf function.  */
+#undef HAVE__ACOSF
+
+/* Define if you have the _acosl function.  */
+#undef HAVE__ACOSL
+
+/* Define if you have the _asinf function.  */
+#undef HAVE__ASINF
+
+/* Define if you have the _asinl function.  */
+#undef HAVE__ASINL
+
+/* Define if you have the _atan2f function.  */
+#undef HAVE__ATAN2F
+
+/* Define if you have the _atan2l function.  */
+#undef HAVE__ATAN2L
+
+/* Define if you have the _atanf function.  */
+#undef HAVE__ATANF
+
+/* Define if you have the _atanl function.  */
+#undef HAVE__ATANL
+
+/* Define if you have the _ceilf function.  */
+#undef HAVE__CEILF
+
+/* Define if you have the _ceill function.  */
+#undef HAVE__CEILL
+
 /* Define if you have the _copysign function.  */
 #undef HAVE__COPYSIGN
 
@@ -54,18 +261,51 @@
 /* Define if you have the _coshf function.  */
 #undef HAVE__COSHF
 
+/* Define if you have the _coshl function.  */
+#undef HAVE__COSHL
+
+/* Define if you have the _cosl function.  */
+#undef HAVE__COSL
+
+/* Define if you have the _expf function.  */
+#undef HAVE__EXPF
+
+/* Define if you have the _expl function.  */
+#undef HAVE__EXPL
+
 /* Define if you have the _fabsf function.  */
 #undef HAVE__FABSF
 
+/* Define if you have the _fabsl function.  */
+#undef HAVE__FABSL
+
 /* Define if you have the _finite function.  */
 #undef HAVE__FINITE
 
 /* Define if you have the _finitef function.  */
 #undef HAVE__FINITEF
 
+/* Define if you have the _finitel function.  */
+#undef HAVE__FINITEL
+
+/* Define if you have the _floorf function.  */
+#undef HAVE__FLOORF
+
+/* Define if you have the _floorl function.  */
+#undef HAVE__FLOORL
+
 /* Define if you have the _fpclass function.  */
 #undef HAVE__FPCLASS
 
+/* Define if you have the _fqfinite function.  */
+#undef HAVE__FQFINITE
+
+/* Define if you have the _frexpf function.  */
+#undef HAVE__FREXPF
+
+/* Define if you have the _frexpl function.  */
+#undef HAVE__FREXPL
+
 /* Define if you have the _isinf function.  */
 #undef HAVE__ISINF
 
@@ -84,20 +324,38 @@
 /* Define if you have the _isnanl function.  */
 #undef HAVE__ISNANL
 
+/* Define if you have the _ldexpf function.  */
+#undef HAVE__LDEXPF
+
+/* Define if you have the _ldexpl function.  */
+#undef HAVE__LDEXPL
+
 /* Define if you have the _log10f function.  */
 #undef HAVE__LOG10F
 
+/* Define if you have the _log10l function.  */
+#undef HAVE__LOG10L
+
 /* Define if you have the _logf function.  */
 #undef HAVE__LOGF
 
+/* Define if you have the _logl function.  */
+#undef HAVE__LOGL
+
 /* Define if you have the _modf function.  */
 #undef HAVE__MODF
 
+/* Define if you have the _modff function.  */
+#undef HAVE__MODFF
+
+/* Define if you have the _modfl function.  */
+#undef HAVE__MODFL
+
 /* Define if you have the _powf function.  */
 #undef HAVE__POWF
 
-/* Define if you have the _qfinite function.  */
-#undef HAVE__QFINITE
+/* Define if you have the _powl function.  */
+#undef HAVE__POWL
 
 /* Define if you have the _qfpclass function.  */
 #undef HAVE__QFPCLASS
@@ -117,9 +375,18 @@
 /* Define if you have the _sinhf function.  */
 #undef HAVE__SINHF
 
+/* Define if you have the _sinhl function.  */
+#undef HAVE__SINHL
+
+/* Define if you have the _sinl function.  */
+#undef HAVE__SINL
+
 /* Define if you have the _sqrtf function.  */
 #undef HAVE__SQRTF
 
+/* Define if you have the _sqrtl function.  */
+#undef HAVE__SQRTL
+
 /* Define if you have the _strtof function.  */
 #undef HAVE__STRTOF
 
@@ -132,9 +399,36 @@
 /* Define if you have the _tanhf function.  */
 #undef HAVE__TANHF
 
+/* Define if you have the _tanhl function.  */
+#undef HAVE__TANHL
+
+/* Define if you have the _tanl function.  */
+#undef HAVE__TANL
+
+/* Define if you have the acosf function.  */
+#undef HAVE_ACOSF
+
+/* Define if you have the acosl function.  */
+#undef HAVE_ACOSL
+
+/* Define if you have the asinf function.  */
+#undef HAVE_ASINF
+
+/* Define if you have the asinl function.  */
+#undef HAVE_ASINL
+
 /* Define if you have the atan2f function.  */
 #undef HAVE_ATAN2F
 
+/* Define if you have the atan2l function.  */
+#undef HAVE_ATAN2L
+
+/* Define if you have the atanf function.  */
+#undef HAVE_ATANF
+
+/* Define if you have the atanl function.  */
+#undef HAVE_ATANL
+
 /* Define if you have the c_log function.  */
 #undef HAVE_C_LOG
 
@@ -171,6 +465,12 @@
 /* Define if you have the ccosl function.  */
 #undef HAVE_CCOSL
 
+/* Define if you have the ceilf function.  */
+#undef HAVE_CEILF
+
+/* Define if you have the ceill function.  */
+#undef HAVE_CEILL
+
 /* Define if you have the cexp function.  */
 #undef HAVE_CEXP
 
@@ -204,6 +504,12 @@
 /* Define if you have the coshf function.  */
 #undef HAVE_COSHF
 
+/* Define if you have the coshl function.  */
+#undef HAVE_COSHL
+
+/* Define if you have the cosl function.  */
+#undef HAVE_COSL
+
 /* Define if you have the cpow function.  */
 #undef HAVE_CPOW
 
@@ -261,18 +567,42 @@
 /* Define if you have the expf function.  */
 #undef HAVE_EXPF
 
+/* Define if you have the expl function.  */
+#undef HAVE_EXPL
+
 /* Define if you have the fabsf function.  */
 #undef HAVE_FABSF
 
+/* Define if you have the fabsl function.  */
+#undef HAVE_FABSL
+
 /* Define if you have the finite function.  */
 #undef HAVE_FINITE
 
+/* Define if you have the finitef function.  */
+#undef HAVE_FINITEF
+
+/* Define if you have the finitel function.  */
+#undef HAVE_FINITEL
+
+/* Define if you have the floorf function.  */
+#undef HAVE_FLOORF
+
+/* Define if you have the floorl function.  */
+#undef HAVE_FLOORL
+
 /* Define if you have the fpclass function.  */
 #undef HAVE_FPCLASS
 
 /* Define if you have the fqfinite function.  */
 #undef HAVE_FQFINITE
 
+/* Define if you have the frexpf function.  */
+#undef HAVE_FREXPF
+
+/* Define if you have the frexpl function.  */
+#undef HAVE_FREXPL
+
 /* Define if you have the getpagesize function.  */
 #undef HAVE_GETPAGESIZE
 
@@ -312,21 +642,42 @@
 /* Define if you have the isnanl function.  */
 #undef HAVE_ISNANL
 
+/* Define if you have the ldexpf function.  */
+#undef HAVE_LDEXPF
+
+/* Define if you have the ldexpl function.  */
+#undef HAVE_LDEXPL
+
 /* Define if you have the log10f function.  */
 #undef HAVE_LOG10F
 
+/* Define if you have the log10l function.  */
+#undef HAVE_LOG10L
+
 /* Define if you have the logf function.  */
 #undef HAVE_LOGF
 
+/* Define if you have the logl function.  */
+#undef HAVE_LOGL
+
 /* Define if you have the modf function.  */
 #undef HAVE_MODF
 
+/* Define if you have the modff function.  */
+#undef HAVE_MODFF
+
+/* Define if you have the modfl function.  */
+#undef HAVE_MODFL
+
 /* Define if you have the nan function.  */
 #undef HAVE_NAN
 
 /* Define if you have the powf function.  */
 #undef HAVE_POWF
 
+/* Define if you have the powl function.  */
+#undef HAVE_POWL
+
 /* Define if you have the qfpclass function.  */
 #undef HAVE_QFPCLASS
 
@@ -348,9 +699,18 @@
 /* Define if you have the sinhf function.  */
 #undef HAVE_SINHF
 
+/* Define if you have the sinhl function.  */
+#undef HAVE_SINHL
+
+/* Define if you have the sinl function.  */
+#undef HAVE_SINL
+
 /* Define if you have the sqrtf function.  */
 #undef HAVE_SQRTF
 
+/* Define if you have the sqrtl function.  */
+#undef HAVE_SQRTL
+
 /* Define if you have the strtof function.  */
 #undef HAVE_STRTOF
 
@@ -363,6 +723,12 @@
 /* Define if you have the tanhf function.  */
 #undef HAVE_TANHF
 
+/* Define if you have the tanhl function.  */
+#undef HAVE_TANHL
+
+/* Define if you have the tanl function.  */
+#undef HAVE_TANL
+
 /* Define if you have the wcslen function.  */
 #undef HAVE_WCSLEN
 
@@ -476,66 +842,221 @@
 # define cosf _cosf
 #endif
 
+#if defined (HAVE__ACOSF) && ! defined (HAVE_ACOSF)
+# define HAVE_ACOSF 1
+# define acosf _acosf
+#endif
+
+#if defined (HAVE__ACOSL) && ! defined (HAVE_ACOSL)
+# define HAVE_ACOSL 1
+# define acosl _acosl
+#endif
+
+#if defined (HAVE__ASINF) && ! defined (HAVE_ASINF)
+# define HAVE_ASINF 1
+# define asinf _asinf
+#endif
+
+#if defined (HAVE__ASINL) && ! defined (HAVE_ASINL)
+# define HAVE_ASINL 1
+# define asinl _asinl
+#endif
+
+#if defined (HAVE__ATANF) && ! defined (HAVE_ATANF)
+# define HAVE_ATANF 1
+# define atanf _atanf
+#endif
+
+#if defined (HAVE__ATANL) && ! defined (HAVE_ATANL)
+# define HAVE_ATANL 1
+# define atanl _atanl
+#endif
+
+#if defined (HAVE__CEILF) && ! defined (HAVE_CEILF)
+# define HAVE_CEILF 1
+# define aceil _ceilf
+#endif
+
+#if defined (HAVE__CEILL) && ! defined (HAVE_CEILL)
+# define HAVE_CEILL 1
+# define aceil _ceill
+#endif
+
 #if defined (HAVE__COSHF) && ! defined (HAVE_COSHF)
 # define HAVE_COSHF 1
 # define coshf _coshf
 #endif
 
+#if defined (HAVE__COSL) && ! defined (HAVE_COSL)
+# define HAVE_COSL 1
+# define cosl _cosl
+#endif
+
 #if defined (HAVE__LOGF) && ! defined (HAVE_LOGF)
 # define HAVE_LOGF 1
 # define logf _logf
 #endif
 
+#if defined (HAVE__COSHL) && ! defined (HAVE_COSHL)
+# define HAVE_COSHL 1
+# define coshl _coshl
+#endif
+
+#if defined (HAVE__EXPF) && ! defined (HAVE_EXPF)
+# define HAVE_EXPF 1
+# define expf _expf
+#endif
+
+#if defined (HAVE__EXPL) && ! defined (HAVE_EXPL)
+# define HAVE_EXPL 1
+# define expl _expl
+#endif
+
+#if defined (HAVE__FABSF) && ! defined (HAVE_FABSF)
+# define HAVE_FABSF 1
+# define fabsf _fabsf
+#endif
+
+#if defined (HAVE__FABSL) && ! defined (HAVE_FABSL)
+# define HAVE_FABSL 1
+# define fabsl _fabsl
+#endif
+
+#if defined (HAVE__FLOORF) && ! defined (HAVE_FLOORF)
+# define HAVE_FLOORF 1
+# define floorf _floorf
+#endif
+
+#if defined (HAVE__FLOORL) && ! defined (HAVE_FLOORL)
+# define HAVE_FLOORL 1
+# define floorl _floorl
+#endif
+
+#if defined (HAVE__FMODF) && ! defined (HAVE_FMODF)
+# define HAVE_FMODF 1
+# define fmodf _fmodf
+#endif
+
+#if defined (HAVE__FMODL) && ! defined (HAVE_FMODL)
+# define HAVE_FMODL 1
+# define fmodl _fmodl
+#endif
+
+#if defined (HAVE__FREXPF) && ! defined (HAVE_FREXPF)
+# define HAVE_FREXPF 1
+# define frexpf _frexpf
+#endif
+
+#if defined (HAVE__FREXPL) && ! defined (HAVE_FREXPL)
+# define HAVE_FREXPL 1
+# define frexpl _frexpl
+#endif
+
+#if defined (HAVE__LDEXPF) && ! defined (HAVE_LDEXPF)
+# define HAVE_LDEXPF 1
+# define ldexpf _ldexpf
+#endif
+
+#if defined (HAVE__LDEXPL) && ! defined (HAVE_LDEXPL)
+# define HAVE_LDEXPL 1
+# define ldexpl _ldexpl
+#endif
+
 #if defined (HAVE__LOG10F) && ! defined (HAVE_LOG10F)
 # define HAVE_LOG10F 1
 # define log10f _log10f
 #endif
 
+#if defined (HAVE__LOGL) && ! defined (HAVE_LOGL)
+# define HAVE_LOGL 1
+# define logl _logl
+#endif
+
 #if defined (HAVE__POWF) && ! defined (HAVE_POWF)
 # define HAVE_POWF 1
 # define powf _powf
 #endif
 
+#if defined (HAVE__LOG10L) && ! defined (HAVE_LOG10L)
+# define HAVE_LOG10L 1
+# define log10l _log10l
+#endif
+
+#if defined (HAVE__MODF) && ! defined (HAVE_MODF)
+# define HAVE_MODF 1
+# define modf _modf
+#endif
+
+#if defined (HAVE__MODL) && ! defined (HAVE_MODL)
+# define HAVE_MODL 1
+# define modl _modl
+#endif
+
 #if defined (HAVE__SINF) && ! defined (HAVE_SINF)
 # define HAVE_SINF 1
 # define sinf _sinf
 #endif
 
+#if defined (HAVE__POWL) && ! defined (HAVE_POWL)
+# define HAVE_POWL 1
+# define powl _powl
+#endif
+
 #if defined (HAVE__SINHF) && ! defined (HAVE_SINHF)
 # define HAVE_SINHF 1
 # define sinhf _sinhf
 #endif
 
+#if defined (HAVE__SINL) && ! defined (HAVE_SINL)
+# define HAVE_SINL 1
+# define sinl _sinl
+#endif
+
 #if defined (HAVE__SQRTF) && ! defined (HAVE_SQRTF)
 # define HAVE_SQRTF 1
 # define sqrtf _sqrtf
 #endif
 
+#if defined (HAVE__SINHL) && ! defined (HAVE_SINHL)
+# define HAVE_SINHL 1
+# define sinhl _sinhl
+#endif
+
 #if defined (HAVE__TANF) && ! defined (HAVE_TANF)
 # define HAVE_TANF 1
 # define tanf _tanf
 #endif
 
+#if defined (HAVE__SQRTL) && ! defined (HAVE_SQRTL)
+# define HAVE_SQRTL 1
+# define sqrtl _sqrtl
+#endif
+
 #if defined (HAVE__TANHF) && ! defined (HAVE_TANHF)
 # define HAVE_TANHF 1
 # define tanhf _tanhf
 #endif
 
+#if defined (HAVE__TANL) && ! defined (HAVE_TANL)
+# define HAVE_TANF 1
+# define tanf _tanf
+#endif
+
 #if defined (HAVE__STRTOF) && ! defined (HAVE_STRTOF)
 # define HAVE_STRTOF 1
 # define strtof _strtof
 #endif
 
+#if defined (HAVE__TANHL) && ! defined (HAVE_TANHL)
+# define HAVE_TANHL 1
+# define tanhl _tanhl
+#endif
+
 #if defined (HAVE__STRTOLD) && ! defined (HAVE_STRTOLD)
 # define HAVE_STRTOLD 1
 # define strtold _strtold
 #endif
 
-#if defined (HAVE__FABSF) && ! defined (HAVE_FABSF)
-# define HAVE_FABSF 1
-# define fabsf _fabsf
-#endif
-
 #if defined (HAVE__SINCOS) && ! defined (HAVE_SINCOS)
 # define HAVE_SINCOS 1
 # define sincos _sincos
@@ -556,6 +1077,16 @@
 # define finite _finite
 #endif
 
+#if defined (HAVE__FINITEF) && ! defined (HAVE_FINITEF)
+# define HAVE_FINITEF 1
+# define finitef _finitef
+#endif
+
+#if defined (HAVE__FINITEL) && ! defined (HAVE_FINITEL)
+# define HAVE_FINITEL 1
+# define finitel _finitel
+#endif
+
 #if defined (HAVE__QFINITE) && ! defined (HAVE_QFINITE)
 # define HAVE_QFINITE 1
 # define qfinite _qfinite
diff --git a/libstdc++-v3/configure b/libstdc++-v3/configure
index 3ec9382c586..a9939eafb61 100755
--- a/libstdc++-v3/configure
+++ b/libstdc++-v3/configure
@@ -64,6 +64,7 @@ program_suffix=NONE
 program_transform_name=s,x,x,
 silent=
 site=
+sitefile=
 srcdir=
 target=NONE
 verbose=
@@ -178,6 +179,7 @@ Configuration:
   --help                  print this message
   --no-create             do not create output files
   --quiet, --silent       do not print \`checking...' messages
+  --site-file=FILE        use FILE as the site file
   --version               print the version of autoconf that created configure
 Directory and file names:
   --prefix=PREFIX         install architecture-independent files in PREFIX
@@ -348,6 +350,11 @@ EOF
   -site=* | --site=* | --sit=*)
     site="$ac_optarg" ;;
 
+  -site-file | --site-file | --site-fil | --site-fi | --site-f)
+    ac_prev=sitefile ;;
+  -site-file=* | --site-file=* | --site-fil=* | --site-fi=* | --site-f=*)
+    sitefile="$ac_optarg" ;;
+
   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
     ac_prev=srcdir ;;
   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
@@ -513,12 +520,16 @@ fi
 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 
 # Prefer explicitly selected file to automatically selected ones.
-if test -z "$CONFIG_SITE"; then
-  if test "x$prefix" != xNONE; then
-    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
-  else
-    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+if test -z "$sitefile"; then
+  if test -z "$CONFIG_SITE"; then
+    if test "x$prefix" != xNONE; then
+      CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+    else
+      CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+    fi
   fi
+else
+  CONFIG_SITE="$sitefile"
 fi
 for ac_site_file in $CONFIG_SITE; do
   if test -r "$ac_site_file"; then
@@ -606,7 +617,7 @@ else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 fi
 
 echo $ac_n "checking host system type""... $ac_c" 1>&6
-echo "configure:610: checking host system type" >&5
+echo "configure:621: checking host system type" >&5
 
 host_alias=$host
 case "$host_alias" in
@@ -627,7 +638,7 @@ host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$host" 1>&6
 
 echo $ac_n "checking target system type""... $ac_c" 1>&6
-echo "configure:631: checking target system type" >&5
+echo "configure:642: checking target system type" >&5
 
 target_alias=$target
 case "$target_alias" in
@@ -645,7 +656,7 @@ target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$target" 1>&6
 
 echo $ac_n "checking build system type""... $ac_c" 1>&6
-echo "configure:649: checking build system type" >&5
+echo "configure:660: checking build system type" >&5
 
 build_alias=$build
 case "$build_alias" in
@@ -694,7 +705,7 @@ fi
 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 # ./install, which can be erroneously created by make from ./install.sh.
 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
-echo "configure:698: checking for a BSD compatible install" >&5
+echo "configure:709: checking for a BSD compatible install" >&5
 if test -z "$INSTALL"; then
 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -747,7 +758,7 @@ test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 
 echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6
-echo "configure:751: checking whether build environment is sane" >&5
+echo "configure:762: checking whether build environment is sane" >&5
 # Just in case
 sleep 1
 echo timestamp > conftestfile
@@ -804,7 +815,7 @@ test "$program_suffix" != NONE &&
 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 
 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
-echo "configure:808: checking whether ${MAKE-make} sets \${MAKE}" >&5
+echo "configure:819: checking whether ${MAKE-make} sets \${MAKE}" >&5
 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -837,12 +848,12 @@ else
 fi
 
 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
-echo "configure:841: checking for Cygwin environment" >&5
+echo "configure:852: checking for Cygwin environment" >&5
 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 846 "configure"
+#line 857 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -853,7 +864,7 @@ int main() {
 return __CYGWIN__;
 ; return 0; }
 EOF
-if { (eval echo configure:857: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:868: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_cygwin=yes
 else
@@ -870,19 +881,19 @@ echo "$ac_t""$ac_cv_cygwin" 1>&6
 CYGWIN=
 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
-echo "configure:874: checking for mingw32 environment" >&5
+echo "configure:885: checking for mingw32 environment" >&5
 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 879 "configure"
+#line 890 "configure"
 #include "confdefs.h"
 
 int main() {
 return __MINGW32__;
 ; return 0; }
 EOF
-if { (eval echo configure:886: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:897: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_mingw32=yes
 else
@@ -929,7 +940,7 @@ else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 fi
 
 echo $ac_n "checking host system type""... $ac_c" 1>&6
-echo "configure:933: checking host system type" >&5
+echo "configure:944: checking host system type" >&5
 
 host_alias=$host
 case "$host_alias" in
@@ -970,7 +981,7 @@ EOF
 
 missing_dir=`cd $ac_aux_dir && pwd`
 echo $ac_n "checking for working aclocal""... $ac_c" 1>&6
-echo "configure:974: checking for working aclocal" >&5
+echo "configure:985: checking for working aclocal" >&5
 # Run test in a subshell; some versions of sh will print an error if
 # an executable is not found, even if stderr is redirected.
 # Redirect stdin to placate older versions of autoconf.  Sigh.
@@ -983,7 +994,7 @@ else
 fi
 
 echo $ac_n "checking for working autoconf""... $ac_c" 1>&6
-echo "configure:987: checking for working autoconf" >&5
+echo "configure:998: checking for working autoconf" >&5
 # Run test in a subshell; some versions of sh will print an error if
 # an executable is not found, even if stderr is redirected.
 # Redirect stdin to placate older versions of autoconf.  Sigh.
@@ -996,7 +1007,7 @@ else
 fi
 
 echo $ac_n "checking for working automake""... $ac_c" 1>&6
-echo "configure:1000: checking for working automake" >&5
+echo "configure:1011: checking for working automake" >&5
 # Run test in a subshell; some versions of sh will print an error if
 # an executable is not found, even if stderr is redirected.
 # Redirect stdin to placate older versions of autoconf.  Sigh.
@@ -1009,7 +1020,7 @@ else
 fi
 
 echo $ac_n "checking for working autoheader""... $ac_c" 1>&6
-echo "configure:1013: checking for working autoheader" >&5
+echo "configure:1024: checking for working autoheader" >&5
 # Run test in a subshell; some versions of sh will print an error if
 # an executable is not found, even if stderr is redirected.
 # Redirect stdin to placate older versions of autoconf.  Sigh.
@@ -1022,7 +1033,7 @@ else
 fi
 
 echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6
-echo "configure:1026: checking for working makeinfo" >&5
+echo "configure:1037: checking for working makeinfo" >&5
 # Run test in a subshell; some versions of sh will print an error if
 # an executable is not found, even if stderr is redirected.
 # Redirect stdin to placate older versions of autoconf.  Sigh.
@@ -1048,7 +1059,7 @@ fi
 # Extract the first word of "gcc", so it can be a program name with args.
 set dummy gcc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1052: checking for $ac_word" >&5
+echo "configure:1063: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1078,7 +1089,7 @@ if test -z "$CC"; then
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1082: checking for $ac_word" >&5
+echo "configure:1093: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1127,7 +1138,7 @@ fi
 fi
 
 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:1131: checking whether we are using GNU C" >&5
+echo "configure:1142: checking whether we are using GNU C" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1136,7 +1147,7 @@ else
   yes;
 #endif
 EOF
-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1140: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1151: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
   ac_cv_prog_gcc=yes
 else
   ac_cv_prog_gcc=no
@@ -1151,7 +1162,7 @@ if test $ac_cv_prog_gcc = yes; then
   ac_save_CFLAGS="$CFLAGS"
   CFLAGS=
   echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
-echo "configure:1155: checking whether ${CC-cc} accepts -g" >&5
+echo "configure:1166: checking whether ${CC-cc} accepts -g" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1188,7 +1199,7 @@ do
 # Extract the first word of "$ac_prog", so it can be a program name with args.
 set dummy $ac_prog; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1192: checking for $ac_word" >&5
+echo "configure:1203: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CXX'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1221,7 +1232,7 @@ test -n "$CXX" || CXX="gcc"
 test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; }
 
 echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
-echo "configure:1225: checking whether we are using GNU C++" >&5
+echo "configure:1236: checking whether we are using GNU C++" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1230,7 +1241,7 @@ else
   yes;
 #endif
 EOF
-if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1234: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1245: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
   ac_cv_prog_gxx=yes
 else
   ac_cv_prog_gxx=no
@@ -1245,7 +1256,7 @@ if test $ac_cv_prog_gxx = yes; then
   ac_save_CXXFLAGS="$CXXFLAGS"
   CXXFLAGS=
   echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
-echo "configure:1249: checking whether ${CXX-g++} accepts -g" >&5
+echo "configure:1260: checking whether ${CXX-g++} accepts -g" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1278,7 +1289,7 @@ fi
 # LIBGCJ_CONFIGURE, which doesn't work because that means that it will
 # be run before AC_CANONICAL_HOST.
 echo $ac_n "checking build system type""... $ac_c" 1>&6
-echo "configure:1282: checking build system type" >&5
+echo "configure:1293: checking build system type" >&5
 
 build_alias=$build
 case "$build_alias" in
@@ -1299,7 +1310,7 @@ echo "$ac_t""$build" 1>&6
 # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
 set dummy ${ac_tool_prefix}as; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1303: checking for $ac_word" >&5
+echo "configure:1314: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1331,7 +1342,7 @@ fi
 # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
 set dummy ${ac_tool_prefix}ar; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1335: checking for $ac_word" >&5
+echo "configure:1346: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1363,7 +1374,7 @@ fi
 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1367: checking for $ac_word" >&5
+echo "configure:1378: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1395,7 +1406,7 @@ if test -n "$ac_tool_prefix"; then
   # Extract the first word of "ranlib", so it can be a program name with args.
 set dummy ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1399: checking for $ac_word" >&5
+echo "configure:1410: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1440,7 +1451,7 @@ fi
 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 # ./install, which can be erroneously created by make from ./install.sh.
 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
-echo "configure:1444: checking for a BSD compatible install" >&5
+echo "configure:1455: checking for a BSD compatible install" >&5
 if test -z "$INSTALL"; then
 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1494,7 +1505,7 @@ test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 
 
 echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
-echo "configure:1498: checking whether to enable maintainer-specific portions of Makefiles" >&5
+echo "configure:1509: checking whether to enable maintainer-specific portions of Makefiles" >&5
     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
 if test "${enable_maintainer_mode+set}" = set; then
   enableval="$enable_maintainer_mode"
@@ -1528,7 +1539,7 @@ if false; then
   
 
 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
-echo "configure:1532: checking for executable suffix" >&5
+echo "configure:1543: checking for executable suffix" >&5
 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1538,10 +1549,10 @@ else
   rm -f conftest*
   echo 'int main () { return 0; }' > conftest.$ac_ext
   ac_cv_exeext=
-  if { (eval echo configure:1542: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
+  if { (eval echo configure:1553: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
     for file in conftest.*; do
       case $file in
-      *.c | *.o | *.obj) ;;
+      *.c | *.o | *.obj | *.ilk | *.pdb) ;;
       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
       esac
     done
@@ -1652,7 +1663,7 @@ fi
 # Extract the first word of "ranlib", so it can be a program name with args.
 set dummy ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1656: checking for $ac_word" >&5
+echo "configure:1667: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1691,7 +1702,7 @@ ac_prog=ld
 if test "$ac_cv_prog_gcc" = yes; then
   # Check if gcc -print-prog-name=ld gives a path.
   echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
-echo "configure:1695: checking for ld used by GCC" >&5
+echo "configure:1706: checking for ld used by GCC" >&5
   ac_prog=`($CC -print-prog-name=ld) 2>&5`
   case "$ac_prog" in
     # Accept absolute paths.
@@ -1715,10 +1726,10 @@ echo "configure:1695: checking for ld used by GCC" >&5
   esac
 elif test "$with_gnu_ld" = yes; then
   echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
-echo "configure:1719: checking for GNU ld" >&5
+echo "configure:1730: checking for GNU ld" >&5
 else
   echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
-echo "configure:1722: checking for non-GNU ld" >&5
+echo "configure:1733: checking for non-GNU ld" >&5
 fi
 if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1753,7 +1764,7 @@ else
 fi
 test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
 echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
-echo "configure:1757: checking if the linker ($LD) is GNU ld" >&5
+echo "configure:1768: checking if the linker ($LD) is GNU ld" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1769,7 +1780,7 @@ echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
 
 
 echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
-echo "configure:1773: checking for BSD-compatible nm" >&5
+echo "configure:1784: checking for BSD-compatible nm" >&5
 if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1805,7 +1816,7 @@ NM="$ac_cv_path_NM"
 echo "$ac_t""$NM" 1>&6
 
 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
-echo "configure:1809: checking whether ln -s works" >&5
+echo "configure:1820: checking whether ln -s works" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1854,8 +1865,8 @@ test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
 case "$lt_target" in
 *-*-irix6*)
   # Find out which ABI we are using.
-  echo '#line 1858 "configure"' > conftest.$ac_ext
-  if { (eval echo configure:1859: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  echo '#line 1869 "configure"' > conftest.$ac_ext
+  if { (eval echo configure:1870: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
     case "`/usr/bin/file conftest.o`" in
     *32-bit*)
       LD="${LD-ld} -32"
@@ -1876,19 +1887,19 @@ case "$lt_target" in
   SAVE_CFLAGS="$CFLAGS"
   CFLAGS="$CFLAGS -belf"
   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
-echo "configure:1880: checking whether the C compiler needs -belf" >&5
+echo "configure:1891: checking whether the C compiler needs -belf" >&5
 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1885 "configure"
+#line 1896 "configure"
 #include "confdefs.h"
 
 int main() {
 
 ; return 0; }
 EOF
-if { (eval echo configure:1892: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1903: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   lt_cv_cc_needs_belf=yes
 else
@@ -1995,7 +2006,7 @@ exec 5>>./config.log
 
 # Check for c++ or library specific bits that don't require linking.
 echo $ac_n "checking how to run the C++ preprocessor""... $ac_c" 1>&6
-echo "configure:1999: checking how to run the C++ preprocessor" >&5
+echo "configure:2010: checking how to run the C++ preprocessor" >&5
 if test -z "$CXXCPP"; then
 if eval "test \"`echo '$''{'ac_cv_prog_CXXCPP'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2008,12 +2019,12 @@ ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftes
 cross_compiling=$ac_cv_prog_cxx_cross
   CXXCPP="${CXX-g++} -E"
   cat > conftest.$ac_ext <<EOF
-#line 2012 "configure"
+#line 2023 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2017: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2028: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -2055,9 +2066,9 @@ cross_compiling=$ac_cv_prog_cxx_cross
 
   # Sanity check that g++ is capable of dealing with v-3.
   echo $ac_n "checking for g++ that will successfully compile this code""... $ac_c" 1>&6
-echo "configure:2059: checking for g++ that will successfully compile this code" >&5
+echo "configure:2070: checking for g++ that will successfully compile this code" >&5
   cat > conftest.$ac_ext <<EOF
-#line 2061 "configure"
+#line 2072 "configure"
 #include "confdefs.h"
 
   #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) 
@@ -2079,10 +2090,10 @@ rm -f conftest*
 
   # Check for pragma system_header.
   echo $ac_n "checking for g++ that supports pragma system_header""... $ac_c" 1>&6
-echo "configure:2083: checking for g++ that supports pragma system_header" >&5
+echo "configure:2094: checking for g++ that supports pragma system_header" >&5
   CXXFLAGS='-Wunknown-pragmas -Werror'
   cat > conftest.$ac_ext <<EOF
-#line 2086 "configure"
+#line 2097 "configure"
 #include "confdefs.h"
 #pragma system_header
 int main() {
@@ -2090,7 +2101,7 @@ int foo;
   
 ; return 0; }
 EOF
-if { (eval echo configure:2094: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2105: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_newpragma=yes
 else
@@ -2113,10 +2124,10 @@ rm -f conftest*
 
   # Check for more sophisticated diagnostic control.
   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
-echo "configure:2117: checking for g++ that supports -fdiagnostics-show-location=once" >&5
+echo "configure:2128: checking for g++ that supports -fdiagnostics-show-location=once" >&5
   CXXFLAGS='-fdiagnostics-show-location=once'
   cat > conftest.$ac_ext <<EOF
-#line 2120 "configure"
+#line 2131 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -2124,7 +2135,7 @@ int foo;
   
 ; return 0; }
 EOF
-if { (eval echo configure:2128: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2139: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_gabydiags=yes
 else
@@ -2157,7 +2168,7 @@ cross_compiling=$ac_cv_prog_cc_cross
 
 
     echo $ac_n "checking for cpu primitives directory""... $ac_c" 1>&6
-echo "configure:2161: checking for cpu primitives directory" >&5
+echo "configure:2172: checking for cpu primitives directory" >&5
     CPUFLAGS=			
     case "$target_cpu" in
       alpha*)
@@ -2214,7 +2225,7 @@ esac
 
 
 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
-echo "configure:2218: checking how to run the C preprocessor" >&5
+echo "configure:2229: checking how to run the C preprocessor" >&5
 # On Suns, sometimes $CPP names a directory.
 if test -n "$CPP" && test -d "$CPP"; then
   CPP=
@@ -2229,13 +2240,13 @@ else
   # On the NeXT, cc -E runs the code through the compiler's parser,
   # not just through cpp.
   cat > conftest.$ac_ext <<EOF
-#line 2233 "configure"
+#line 2244 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2239: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2250: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -2246,13 +2257,13 @@ else
   rm -rf conftest*
   CPP="${CC-cc} -E -traditional-cpp"
   cat > conftest.$ac_ext <<EOF
-#line 2250 "configure"
+#line 2261 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2256: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2267: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -2263,13 +2274,13 @@ else
   rm -rf conftest*
   CPP="${CC-cc} -nologo -E"
   cat > conftest.$ac_ext <<EOF
-#line 2267 "configure"
+#line 2278 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2273: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2284: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -2295,7 +2306,7 @@ echo "$ac_t""$CPP" 1>&6
 
 
   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
-echo "configure:2299: checking for cstdio to use" >&5
+echo "configure:2310: checking for cstdio to use" >&5
   # Check whether --enable-cstdio or --disable-cstdio was given.
 if test "${enable_cstdio+set}" = set; then
   enableval="$enable_cstdio"
@@ -2319,17 +2330,17 @@ fi
 		# see if we are on a system with libio native (ie, linux)
   		ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
-echo "configure:2323: checking for libio.h" >&5
+echo "configure:2334: checking for libio.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2328 "configure"
+#line 2339 "configure"
 #include "confdefs.h"
 #include <libio.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2333: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2344: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2364,17 +2375,17 @@ fi
 		# NB: This replaces the _G_CONFIG_H machinery in libio-v2
 		ac_safe=`echo "_G_config.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for _G_config.h""... $ac_c" 1>&6
-echo "configure:2368: checking for _G_config.h" >&5
+echo "configure:2379: checking for _G_config.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2373 "configure"
+#line 2384 "configure"
 #include "confdefs.h"
 #include <_G_config.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2378: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2389: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2447,12 +2458,12 @@ fi
 
   # Check for the existance of functions used if long long is enabled.
   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
-echo "configure:2451: checking for strtoll" >&5
+echo "configure:2462: checking for strtoll" >&5
 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2456 "configure"
+#line 2467 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char strtoll(); below.  */
@@ -2475,7 +2486,7 @@ strtoll();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2479: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2490: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_strtoll=yes"
 else
@@ -2496,12 +2507,12 @@ ac_strtoll=no
 fi
 
   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
-echo "configure:2500: checking for strtoull" >&5
+echo "configure:2511: checking for strtoull" >&5
 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2505 "configure"
+#line 2516 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char strtoull(); below.  */
@@ -2524,7 +2535,7 @@ strtoull();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2528: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2539: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_strtoull=yes"
 else
@@ -2546,7 +2557,7 @@ fi
 
 
   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
-echo "configure:2550: checking for enabled long long" >&5
+echo "configure:2561: checking for enabled long long" >&5
   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then 
     enable_long_long=no; 
   fi; 
@@ -2561,7 +2572,7 @@ EOF
   esac
 
 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
-echo "configure:2565: checking for enabled cshadow headers" >&5
+echo "configure:2576: checking for enabled cshadow headers" >&5
 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
 if test "${enable_cshadow_headers+set}" = set; then
   enableval="$enable_cshadow_headers"
@@ -2602,7 +2613,7 @@ fi
 
 
       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
-echo "configure:2606: checking for threads package to use" >&5
+echo "configure:2617: checking for threads package to use" >&5
   # Check whether --enable-threads or --disable-threads was given.
 if test "${enable_threads+set}" = set; then
   enableval="$enable_threads"
@@ -2665,17 +2676,17 @@ fi
     posix)
       ac_safe=`echo "pthread.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for pthread.h""... $ac_c" 1>&6
-echo "configure:2669: checking for pthread.h" >&5
+echo "configure:2680: checking for pthread.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2674 "configure"
+#line 2685 "configure"
 #include "confdefs.h"
 #include <pthread.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2679: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2690: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2864,17 +2875,17 @@ else
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2868: checking for $ac_hdr" >&5
+echo "configure:2879: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2873 "configure"
+#line 2884 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2878: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2889: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2904,7 +2915,7 @@ done
   
   
   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
-echo "configure:2908: checking for GNU C++ __complex__ support" >&5
+echo "configure:2919: checking for GNU C++ __complex__ support" >&5
   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2918,7 +2929,7 @@ ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftes
 cross_compiling=$ac_cv_prog_cxx_cross
 
     cat > conftest.$ac_ext <<EOF
-#line 2922 "configure"
+#line 2933 "configure"
 #include "confdefs.h"
 struct dcomplex { __complex__ double x; }; \
 		    dcomplex f(const dcomplex& x) { return dcomplex(x); }
@@ -2927,7 +2938,7 @@ int main() {
 		     dcomplex x; f(x); 
 ; return 0; }
 EOF
-if { (eval echo configure:2931: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2942: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   glibcpp_cv_complex=ok
 else
@@ -2959,7 +2970,7 @@ EOF
   
   
   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
-echo "configure:2963: checking for GNU C++ __complex__ float support" >&5
+echo "configure:2974: checking for GNU C++ __complex__ float support" >&5
   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2992,14 +3003,14 @@ cross_compiling=$ac_cv_prog_cxx_cross
       };
 EOB
     cat > conftest.$ac_ext <<EOF
-#line 2996 "configure"
+#line 3007 "configure"
 #include "confdefs.h"
 #include "conftest.h"
 int main() {
 
 ; return 0; }
 EOF
-if { (eval echo configure:3003: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3014: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   glibcpp_cv_float_complex=ok
 else
@@ -3029,45 +3040,457 @@ EOF
   fi
 
   
-    echo $ac_n "checking for __builtin_sinf""... $ac_c" 1>&6
-echo "configure:3034: checking for __builtin_sinf" >&5
+    
+  ac_ext=C
+# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cxx_cross
+
+  echo $ac_n "checking for __builtin_acos""... $ac_c" 1>&6
+echo "configure:3053: checking for __builtin_acos" >&5
   cat > conftest.$ac_ext <<EOF
-#line 3036 "configure"
+#line 3055 "configure"
 #include "confdefs.h"
 #include <math.h>
 int main() {
-float foo(void) { __builtin_sinf(0.0); }
+ __builtin_acos(0.0);
 ; return 0; }
 EOF
-if { (eval echo configure:3043: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3062: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
-  use_builtin_sinf=yes
+  use_builtin_acos=yes
 else
   echo "configure: failed program was:" >&5
   cat conftest.$ac_ext >&5
   rm -rf conftest*
-  use_builtin_sinf=no
+  use_builtin_acos=no
 fi
 rm -f conftest*
-  echo "$ac_t""$use_builtin_sinf" 1>&6
-  if test $use_builtin_sinf = "yes"; then
+  echo "$ac_t""$use_builtin_acos" 1>&6
+  if test $use_builtin_acos = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ACOS 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_acosf""... $ac_c" 1>&6
+echo "configure:3080: checking for __builtin_acosf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3082 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_acosf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3089: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_acosf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_acosf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_acosf" 1>&6
+  if test $use_builtin_acosf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ACOSF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_acosl""... $ac_c" 1>&6
+echo "configure:3107: checking for __builtin_acosl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3109 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_acosl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3116: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_acosl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_acosl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_acosl" 1>&6
+  if test $use_builtin_acosl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ACOSL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_asin""... $ac_c" 1>&6
+echo "configure:3134: checking for __builtin_asin" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3136 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_asin(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3143: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_asin=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_asin=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_asin" 1>&6
+  if test $use_builtin_asin = "yes"; then
     cat >> confdefs.h <<\EOF
-#define _GLIBCPP_HAS_BUILTIN_SINF 1
+#define HAVE_BUILTIN_ASIN 1
 EOF
 
   fi
+  echo $ac_n "checking for __builtin_asinf""... $ac_c" 1>&6
+echo "configure:3161: checking for __builtin_asinf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3163 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_asinf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3170: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_asinf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_asinf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_asinf" 1>&6
+  if test $use_builtin_asinf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ASINF 1
+EOF
 
+  fi
+  echo $ac_n "checking for __builtin_asinl""... $ac_c" 1>&6
+echo "configure:3188: checking for __builtin_asinl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3190 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_asinl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3197: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_asinl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_asinl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_asinl" 1>&6
+  if test $use_builtin_asinl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ASINL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_atan""... $ac_c" 1>&6
+echo "configure:3215: checking for __builtin_atan" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3217 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_atan(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3224: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_atan=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_atan=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_atan" 1>&6
+  if test $use_builtin_atan = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ATAN 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_atanf""... $ac_c" 1>&6
+echo "configure:3242: checking for __builtin_atanf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3244 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_atanf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3251: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_atanf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_atanf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_atanf" 1>&6
+  if test $use_builtin_atanf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ATANF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_atanl""... $ac_c" 1>&6
+echo "configure:3269: checking for __builtin_atanl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3271 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_atanl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3278: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_atanl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_atanl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_atanl" 1>&6
+  if test $use_builtin_atanl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ATANL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_atan2""... $ac_c" 1>&6
+echo "configure:3296: checking for __builtin_atan2" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3298 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_atan2(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3305: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_atan2=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_atan2=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_atan2" 1>&6
+  if test $use_builtin_atan2 = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ATAN2 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_atan2f""... $ac_c" 1>&6
+echo "configure:3323: checking for __builtin_atan2f" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3325 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_atan2f(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3332: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_atan2f=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_atan2f=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_atan2f" 1>&6
+  if test $use_builtin_atan2f = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ATAN2F 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_atan2l""... $ac_c" 1>&6
+echo "configure:3350: checking for __builtin_atan2l" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3352 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_atan2l(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3359: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_atan2l=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_atan2l=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_atan2l" 1>&6
+  if test $use_builtin_atan2l = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_ATAN2L 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_ceil""... $ac_c" 1>&6
+echo "configure:3377: checking for __builtin_ceil" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3379 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_fceil(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3386: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_ceil=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_ceil=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_ceil" 1>&6
+  if test $use_builtin_ceil = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_CEIL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_ceilf""... $ac_c" 1>&6
+echo "configure:3404: checking for __builtin_ceilf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3406 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_ceilf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3413: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_ceilf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_ceilf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_ceilf" 1>&6
+  if test $use_builtin_ceilf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_CEILF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_ceill""... $ac_c" 1>&6
+echo "configure:3431: checking for __builtin_ceill" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3433 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_ceill(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3440: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_ceill=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_ceill=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_ceill" 1>&6
+  if test $use_builtin_ceill = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_CEILL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_cos""... $ac_c" 1>&6
+echo "configure:3458: checking for __builtin_cos" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3460 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_cos(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3467: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_cos=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_cos=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_cos" 1>&6
+  if test $use_builtin_cos = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_COS 1
+EOF
+
+  fi
   echo $ac_n "checking for __builtin_cosf""... $ac_c" 1>&6
-echo "configure:3062: checking for __builtin_cosf" >&5
+echo "configure:3485: checking for __builtin_cosf" >&5
   cat > conftest.$ac_ext <<EOF
-#line 3064 "configure"
+#line 3487 "configure"
 #include "confdefs.h"
 #include <math.h>
 int main() {
-float foo(void) { __builtin_cosf(0.0); }
+ __builtin_cosf(0.0);
 ; return 0; }
 EOF
-if { (eval echo configure:3071: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3494: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   use_builtin_cosf=yes
 else
@@ -3080,22 +3503,237 @@ rm -f conftest*
   echo "$ac_t""$use_builtin_cosf" 1>&6
   if test $use_builtin_cosf = "yes"; then
     cat >> confdefs.h <<\EOF
-#define _GLIBCPP_HAS_BUILTIN_COSF 1
+#define HAVE_BUILTIN_COSF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_cosl""... $ac_c" 1>&6
+echo "configure:3512: checking for __builtin_cosl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3514 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_cosl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3521: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_cosl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_cosl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_cosl" 1>&6
+  if test $use_builtin_cosl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_COSL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_cosh""... $ac_c" 1>&6
+echo "configure:3539: checking for __builtin_cosh" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3541 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_cosh(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3548: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_cosh=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_cosh=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_cosh" 1>&6
+  if test $use_builtin_cosh = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_COSH 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_coshf""... $ac_c" 1>&6
+echo "configure:3566: checking for __builtin_coshf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3568 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_coshf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3575: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_coshf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_coshf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_coshf" 1>&6
+  if test $use_builtin_coshf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_COSHF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_coshl""... $ac_c" 1>&6
+echo "configure:3593: checking for __builtin_coshl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3595 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_coshl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3602: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_coshl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_coshl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_coshl" 1>&6
+  if test $use_builtin_coshl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_COSHL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_exp""... $ac_c" 1>&6
+echo "configure:3620: checking for __builtin_exp" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3622 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_exp(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3629: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_exp=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_exp=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_exp" 1>&6
+  if test $use_builtin_exp = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_EXP 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_expf""... $ac_c" 1>&6
+echo "configure:3647: checking for __builtin_expf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3649 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_expf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3656: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_expf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_expf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_expf" 1>&6
+  if test $use_builtin_expf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_EXPF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_expl""... $ac_c" 1>&6
+echo "configure:3674: checking for __builtin_expl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3676 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_expl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3683: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_expl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_expl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_expl" 1>&6
+  if test $use_builtin_expl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_EXPL 1
 EOF
 
   fi
+  echo $ac_n "checking for __builtin_fabs""... $ac_c" 1>&6
+echo "configure:3701: checking for __builtin_fabs" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3703 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_fabs(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3710: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_fabs=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_fabs=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_fabs" 1>&6
+  if test $use_builtin_fabs = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_FABS 1
+EOF
 
+  fi
   echo $ac_n "checking for __builtin_fabsf""... $ac_c" 1>&6
-echo "configure:3090: checking for __builtin_fabsf" >&5
+echo "configure:3728: checking for __builtin_fabsf" >&5
   cat > conftest.$ac_ext <<EOF
-#line 3092 "configure"
+#line 3730 "configure"
 #include "confdefs.h"
 #include <math.h>
 int main() {
-float foo(void) { __builtin_fabsf(0.0); }
+ __builtin_fabsf(0.0);
 ; return 0; }
 EOF
-if { (eval echo configure:3099: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3737: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   use_builtin_fabsf=yes
 else
@@ -3108,22 +3746,804 @@ rm -f conftest*
   echo "$ac_t""$use_builtin_fabsf" 1>&6
   if test $use_builtin_fabsf = "yes"; then
     cat >> confdefs.h <<\EOF
-#define _GLIBCPP_HAS_BUILTIN_FABSF 1
+#define HAVE_BUILTIN_FABSF 1
 EOF
 
   fi
+  echo $ac_n "checking for __builtin_fabsl""... $ac_c" 1>&6
+echo "configure:3755: checking for __builtin_fabsl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3757 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_fabsl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3764: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_fabsl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_fabsl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_fabsl" 1>&6
+  if test $use_builtin_fabsl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_FABSL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_floor""... $ac_c" 1>&6
+echo "configure:3782: checking for __builtin_floor" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3784 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_ffloor(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3791: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_floor=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_floor=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_floor" 1>&6
+  if test $use_builtin_floor = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_FLOOR 1
+EOF
 
+  fi
+  echo $ac_n "checking for __builtin_floorf""... $ac_c" 1>&6
+echo "configure:3809: checking for __builtin_floorf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3811 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_floorf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3818: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_floorf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_floorf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_floorf" 1>&6
+  if test $use_builtin_floorf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_FLOORF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_floorl""... $ac_c" 1>&6
+echo "configure:3836: checking for __builtin_floorl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3838 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_floorl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3845: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_floorl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_floorl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_floorl" 1>&6
+  if test $use_builtin_floorl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_FLOORL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_frexp""... $ac_c" 1>&6
+echo "configure:3863: checking for __builtin_frexp" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3865 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_frexp(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3872: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_frexp=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_frexp=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_frexp" 1>&6
+  if test $use_builtin_frexp = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_FREXP 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_frexpf""... $ac_c" 1>&6
+echo "configure:3890: checking for __builtin_frexpf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3892 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_frexpf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3899: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_frexpf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_frexpf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_frexpf" 1>&6
+  if test $use_builtin_frexpf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_FREXPF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_frexpl""... $ac_c" 1>&6
+echo "configure:3917: checking for __builtin_frexpl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3919 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_frexpl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3926: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_frexpl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_frexpl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_frexpl" 1>&6
+  if test $use_builtin_frexpl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_FREXPL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_ldexp""... $ac_c" 1>&6
+echo "configure:3944: checking for __builtin_ldexp" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3946 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_ldexp(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3953: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_ldexp=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_ldexp=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_ldexp" 1>&6
+  if test $use_builtin_ldexp = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_LDEXP 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_ldexpf""... $ac_c" 1>&6
+echo "configure:3971: checking for __builtin_ldexpf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 3973 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_ldexpf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:3980: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_ldexpf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_ldexpf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_ldexpf" 1>&6
+  if test $use_builtin_ldexpf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_LDEXPF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_ldexpl""... $ac_c" 1>&6
+echo "configure:3998: checking for __builtin_ldexpl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4000 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_ldexpl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4007: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_ldexpl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_ldexpl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_ldexpl" 1>&6
+  if test $use_builtin_ldexpl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_LDEXPL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_log""... $ac_c" 1>&6
+echo "configure:4025: checking for __builtin_log" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4027 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_log(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4034: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_log=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_log=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_log" 1>&6
+  if test $use_builtin_log = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_LOG 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_logf""... $ac_c" 1>&6
+echo "configure:4052: checking for __builtin_logf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4054 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_logf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4061: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_logf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_logf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_logf" 1>&6
+  if test $use_builtin_logf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_LOGF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_logl""... $ac_c" 1>&6
+echo "configure:4079: checking for __builtin_logl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4081 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_logl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4088: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_logl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_logl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_logl" 1>&6
+  if test $use_builtin_logl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_LOGL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_log10""... $ac_c" 1>&6
+echo "configure:4106: checking for __builtin_log10" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4108 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_log10(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4115: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_log10=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_log10=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_log10" 1>&6
+  if test $use_builtin_log10 = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_LOG10 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_log10f""... $ac_c" 1>&6
+echo "configure:4133: checking for __builtin_log10f" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4135 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_log10f(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4142: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_log10f=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_log10f=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_log10f" 1>&6
+  if test $use_builtin_log10f = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_LOG10F 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_log10l""... $ac_c" 1>&6
+echo "configure:4160: checking for __builtin_log10l" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4162 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_log10l(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4169: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_log10l=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_log10l=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_log10l" 1>&6
+  if test $use_builtin_log10l = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_LOG10L 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_modf""... $ac_c" 1>&6
+echo "configure:4187: checking for __builtin_modf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4189 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_modf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4196: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_modf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_modf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_modf" 1>&6
+  if test $use_builtin_modf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_MODF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_modff""... $ac_c" 1>&6
+echo "configure:4214: checking for __builtin_modff" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4216 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_modff(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4223: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_modff=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_modff=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_modff" 1>&6
+  if test $use_builtin_modff = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_MODFF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_modfl""... $ac_c" 1>&6
+echo "configure:4241: checking for __builtin_modfl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4243 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_modfl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4250: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_modfl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_modfl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_modfl" 1>&6
+  if test $use_builtin_modfl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_MODFL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_pow""... $ac_c" 1>&6
+echo "configure:4268: checking for __builtin_pow" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4270 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_pow(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4277: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_pow=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_pow=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_pow" 1>&6
+  if test $use_builtin_pow = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_POW 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_powf""... $ac_c" 1>&6
+echo "configure:4295: checking for __builtin_powf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4297 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_powf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4304: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_powf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_powf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_powf" 1>&6
+  if test $use_builtin_powf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_POWF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_powl""... $ac_c" 1>&6
+echo "configure:4322: checking for __builtin_powl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4324 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_powl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4331: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_powl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_powl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_powl" 1>&6
+  if test $use_builtin_powl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_POWL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_sin""... $ac_c" 1>&6
+echo "configure:4349: checking for __builtin_sin" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4351 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_sin(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4358: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_sin=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_sin=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_sin" 1>&6
+  if test $use_builtin_sin = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_SIN 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_sinf""... $ac_c" 1>&6
+echo "configure:4376: checking for __builtin_sinf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4378 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_sinf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4385: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_sinf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_sinf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_sinf" 1>&6
+  if test $use_builtin_sinf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_SINF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_sinl""... $ac_c" 1>&6
+echo "configure:4403: checking for __builtin_sinl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4405 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_sinl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4412: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_sinl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_sinl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_sinl" 1>&6
+  if test $use_builtin_sinl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_SINL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_sinh""... $ac_c" 1>&6
+echo "configure:4430: checking for __builtin_sinh" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4432 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_sinh(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4439: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_sinh=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_sinh=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_sinh" 1>&6
+  if test $use_builtin_sinh = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_SINH 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_sinhf""... $ac_c" 1>&6
+echo "configure:4457: checking for __builtin_sinhf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4459 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_sinhf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4466: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_sinhf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_sinhf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_sinhf" 1>&6
+  if test $use_builtin_sinhf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_SINHF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_sinhl""... $ac_c" 1>&6
+echo "configure:4484: checking for __builtin_sinhl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4486 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_sinhl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4493: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_sinhl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_sinhl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_sinhl" 1>&6
+  if test $use_builtin_sinhl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_SINHL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_sqrt""... $ac_c" 1>&6
+echo "configure:4511: checking for __builtin_sqrt" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4513 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_fsqrt(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4520: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_sqrt=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_sqrt=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_sqrt" 1>&6
+  if test $use_builtin_sqrt = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_SQRT 1
+EOF
+
+  fi
   echo $ac_n "checking for __builtin_sqrtf""... $ac_c" 1>&6
-echo "configure:3118: checking for __builtin_sqrtf" >&5
+echo "configure:4538: checking for __builtin_sqrtf" >&5
   cat > conftest.$ac_ext <<EOF
-#line 3120 "configure"
+#line 4540 "configure"
 #include "confdefs.h"
 #include <math.h>
 int main() {
-float foo(void) { __builtin_sqrtf(0.0); }
+ __builtin_sqrtf(0.0);
 ; return 0; }
 EOF
-if { (eval echo configure:3127: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4547: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   use_builtin_sqrtf=yes
 else
@@ -3136,14 +4556,210 @@ rm -f conftest*
   echo "$ac_t""$use_builtin_sqrtf" 1>&6
   if test $use_builtin_sqrtf = "yes"; then
     cat >> confdefs.h <<\EOF
-#define _GLIBCPP_HAS_BUILTIN_SQRTF 1
+#define HAVE_BUILTIN_SQRTF 1
 EOF
 
   fi
+  echo $ac_n "checking for __builtin_sqrtl""... $ac_c" 1>&6
+echo "configure:4565: checking for __builtin_sqrtl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4567 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_sqrtl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4574: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_sqrtl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_sqrtl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_sqrtl" 1>&6
+  if test $use_builtin_sqrtl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_SQRTL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_tan""... $ac_c" 1>&6
+echo "configure:4592: checking for __builtin_tan" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4594 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_tan(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4601: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_tan=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_tan=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_tan" 1>&6
+  if test $use_builtin_tan = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_TAN 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_tanf""... $ac_c" 1>&6
+echo "configure:4619: checking for __builtin_tanf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4621 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_tanf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4628: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_tanf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_tanf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_tanf" 1>&6
+  if test $use_builtin_tanf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_TANF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_tanl""... $ac_c" 1>&6
+echo "configure:4646: checking for __builtin_tanl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4648 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_tanl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4655: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_tanl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_tanl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_tanl" 1>&6
+  if test $use_builtin_tanl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_TANL 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_tanh""... $ac_c" 1>&6
+echo "configure:4673: checking for __builtin_tanh" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4675 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_tanh(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4682: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_tanh=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_tanh=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_tanh" 1>&6
+  if test $use_builtin_tanh = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_TANH 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_tanhf""... $ac_c" 1>&6
+echo "configure:4700: checking for __builtin_tanhf" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4702 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_tanhf(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4709: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_tanhf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_tanhf=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_tanhf" 1>&6
+  if test $use_builtin_tanhf = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_TANHF 1
+EOF
+
+  fi
+  echo $ac_n "checking for __builtin_tanhl""... $ac_c" 1>&6
+echo "configure:4727: checking for __builtin_tanhl" >&5
+  cat > conftest.$ac_ext <<EOF
+#line 4729 "configure"
+#include "confdefs.h"
+#include <math.h>
+int main() {
+ __builtin_tanhl(0.0);
+; return 0; }
+EOF
+if { (eval echo configure:4736: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  use_builtin_tanhl=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  use_builtin_tanhl=no
+fi
+rm -f conftest*
+  echo "$ac_t""$use_builtin_tanhl" 1>&6
+  if test $use_builtin_tanhl = "yes"; then
+    cat >> confdefs.h <<\EOF
+#define HAVE_BUILTIN_TANHL 1
+EOF
+
+  fi
+  ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
+
 
   
   echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
-echo "configure:3147: checking for sin in -lm" >&5
+echo "configure:4763: checking for sin in -lm" >&5
 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -3151,7 +4767,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lm  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 3155 "configure"
+#line 4771 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -3162,7 +4778,7 @@ int main() {
 sin()
 ; return 0; }
 EOF
-if { (eval echo configure:3166: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4782: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -3189,17 +4805,17 @@ fi
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:3193: checking for $ac_hdr" >&5
+echo "configure:4809: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3198 "configure"
+#line 4814 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3203: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:4819: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3231,12 +4847,12 @@ done
   carg cargf nan hypot hypotf atan2f expf copysignf
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3235: checking for $ac_func" >&5
+echo "configure:4851: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3240 "configure"
+#line 4856 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3259,7 +4875,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3263: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4879: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3288,12 +4904,12 @@ done
 
       USE_LONG_DOUBLE=no
   echo $ac_n "checking for copysignl""... $ac_c" 1>&6
-echo "configure:3292: checking for copysignl" >&5
+echo "configure:4908: checking for copysignl" >&5
 if eval "test \"`echo '$''{'ac_cv_func_copysignl'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3297 "configure"
+#line 4913 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char copysignl(); below.  */
@@ -3316,7 +4932,7 @@ copysignl();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3320: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4936: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_copysignl=yes"
 else
@@ -3335,12 +4951,12 @@ if eval "test \"`echo '$ac_cv_func_'copysignl`\" = yes"; then
   csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3339: checking for $ac_func" >&5
+echo "configure:4955: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3344 "configure"
+#line 4960 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3363,7 +4979,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3367: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4983: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3395,18 +5011,20 @@ fi
 
   
 
-    for ac_func in modf isnan isnanf isnanl isinf isinff isinfl copysign \
-  copysignl cosf coshf logf log10f powf sinf sinhf sqrtf tanf tanhf \
-  strtof strtold fabsf sincos sincosf sincosl finite finite fqfinite \
-  fpclass qfpclass
+    for ac_func in isnan isnanf isnanl isinf isinff isinfl copysign copysignl \
+  acosf acosl asinf asinl atanf atanl atan2f atan2l ceilf ceill cosf cosl \
+  coshf coshl expf expl fabsf fabsl floorf floorl frexpf frexpl ldexpf \
+  ldexpl logf logl log10f log10l modf modff modfl powf powl sinf sinl sinhf \
+  sinhl sqrtf sqrtl tanf tanl tanhf tanhl strtof strtold sincos sincosf \
+  sincosl finite finitef finitel fqfinite fpclass qfpclass
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3405: checking for $ac_func" >&5
+echo "configure:5023: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3410 "configure"
+#line 5028 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3429,7 +5047,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3433: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5051: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3458,18 +5076,22 @@ done
 # keep this sync'd with the one above. And if you add any new symbol,
 # please add the corresponding block in the @BOTTOM@ section of
 # acconfig.h.
-for ac_func in _modf _isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \
-_copysignl _cosf _coshf _logf _log10f _powf _sinf _sinhf _sqrtf _tanf _tanhf \
-_strtof _strtold _fabsf _sincos _sincosf _sincosl _finite _finitef _qfinite \
-_fpclass _qfpclass
+
+  for ac_func in _isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \
+  _copysignl _acosf _acosl _asinf _asinl _atanf _atanl _atan2f _atan2l \
+  _ceilf _ceill _cosf _cosl _coshf _coshl _expf _expl _fabsf _fabsl \
+  _floorf _floorl _frexpf _frexpl _ldexpf _ldexpl _logf _logl _log10f \
+  _log10l _modf _modff _modfl _powf _powl _sinf _sinl _sinhf _sinhl _sqrtf \
+  _sqrtl _tanf _tanl _tanhf _tanhl _strtof _strtold _sincos _sincosf _sincosl \
+  _finite _finitef _finitel _fqfinite _fpclass _qfpclass
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3468: checking for $ac_func" >&5
+echo "configure:5090: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3473 "configure"
+#line 5095 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3492,7 +5114,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3496: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5118: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3523,17 +5145,17 @@ LIBS="$save_LIBS"
 
     ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
-echo "configure:3527: checking for wchar.h" >&5
+echo "configure:5149: checking for wchar.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3532 "configure"
+#line 5154 "configure"
 #include "confdefs.h"
 #include <wchar.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3537: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:5159: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3557,17 +5179,17 @@ fi
 
   ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
-echo "configure:3561: checking for wctype.h" >&5
+echo "configure:5183: checking for wctype.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3566 "configure"
+#line 5188 "configure"
 #include "confdefs.h"
 #include <wctype.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3571: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:5193: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3593,16 +5215,16 @@ fi
     if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
 
         echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
-echo "configure:3597: checking for mbstate_t" >&5
+echo "configure:5219: checking for mbstate_t" >&5
     cat > conftest.$ac_ext <<EOF
-#line 3599 "configure"
+#line 5221 "configure"
 #include "confdefs.h"
 #include <wchar.h>
 int main() {
 mbstate_t teststate;
 ; return 0; }
 EOF
-if { (eval echo configure:3606: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5228: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   use_native_mbstatet=yes
 else
@@ -3621,16 +5243,16 @@ EOF
     fi
   
             echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
-echo "configure:3625: checking for WCHAR_MIN and WCHAR_MAX" >&5
+echo "configure:5247: checking for WCHAR_MIN and WCHAR_MAX" >&5
     cat > conftest.$ac_ext <<EOF
-#line 3627 "configure"
+#line 5249 "configure"
 #include "confdefs.h"
 #include <wchar.h>
 int main() {
 int i = WCHAR_MIN; int j = WCHAR_MAX;
 ; return 0; }
 EOF
-if { (eval echo configure:3634: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5256: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   has_wchar_minmax=yes
 else
@@ -3643,9 +5265,9 @@ rm -f conftest*
     echo "$ac_t""$has_wchar_minmax" 1>&6
   
             echo $ac_n "checking for WEOF""... $ac_c" 1>&6
-echo "configure:3647: checking for WEOF" >&5
+echo "configure:5269: checking for WEOF" >&5
     cat > conftest.$ac_ext <<EOF
-#line 3649 "configure"
+#line 5271 "configure"
 #include "confdefs.h"
 
       #include <wchar.h>
@@ -3654,7 +5276,7 @@ int main() {
 wint_t i = WEOF;
 ; return 0; }
 EOF
-if { (eval echo configure:3658: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5280: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   has_weof=yes
 else
@@ -3669,12 +5291,12 @@ rm -f conftest*
         for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3673: checking for $ac_func" >&5
+echo "configure:5295: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3678 "configure"
+#line 5300 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3697,7 +5319,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3701: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5323: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3724,7 +5346,7 @@ done
 
 
     echo $ac_n "checking for ISO C9X wchar_t support""... $ac_c" 1>&6
-echo "configure:3728: checking for ISO C9X wchar_t support" >&5
+echo "configure:5350: checking for ISO C9X wchar_t support" >&5
     if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes && test x"$ac_wfuncs" = xyes; then
       ac_isoC9X_wchar_t=yes
     else
@@ -3734,17 +5356,17 @@ echo "configure:3728: checking for ISO C9X wchar_t support" >&5
 
             ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
-echo "configure:3738: checking for iconv.h" >&5
+echo "configure:5360: checking for iconv.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3743 "configure"
+#line 5365 "configure"
 #include "confdefs.h"
 #include <iconv.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3748: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:5370: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3769,12 +5391,12 @@ fi
     for ac_func in iconv_open iconv_close iconv
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3773: checking for $ac_func" >&5
+echo "configure:5395: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3778 "configure"
+#line 5400 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3797,7 +5419,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3801: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5423: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3824,7 +5446,7 @@ done
 
 
     echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
-echo "configure:3828: checking for XPG2 wchar_t support" >&5
+echo "configure:5450: checking for XPG2 wchar_t support" >&5
     if test x"$ac_has_iconv_h" = xyes && test x"$ac_XPG2funcs" = xyes; then
       ac_XPG2_wchar_t=yes
     else
@@ -3833,7 +5455,7 @@ echo "configure:3828: checking for XPG2 wchar_t support" >&5
     echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
 
             echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
-echo "configure:3837: checking for enabled wchar_t specializations" >&5
+echo "configure:5459: checking for enabled wchar_t specializations" >&5
     if test x"$ac_isoC9X_wchar_t" = xyes && test x"$ac_XPG2_wchar_t" = xyes; then
       libinst_wstring_la="libinst-wstring.la"
       cat >> confdefs.h <<\EOF
@@ -3858,17 +5480,17 @@ EOF
   
   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
-echo "configure:3862: checking for ctype.h" >&5
+echo "configure:5484: checking for ctype.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3867 "configure"
+#line 5489 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3872: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:5494: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3889,9 +5511,9 @@ if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
         ctype_default=yes
 
         echo $ac_n "checking <ctype> for gnu-linux ""... $ac_c" 1>&6
-echo "configure:3893: checking <ctype> for gnu-linux " >&5
+echo "configure:5515: checking <ctype> for gnu-linux " >&5
     cat > conftest.$ac_ext <<EOF
-#line 3895 "configure"
+#line 5517 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 int main() {
@@ -3902,7 +5524,7 @@ int
 	+ __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
 ; return 0; }
 EOF
-if { (eval echo configure:3906: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5528: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   \
     ctype_linux=yes
@@ -3921,9 +5543,9 @@ rm -f conftest*
 
         if test $ctype_default = "yes"; then
     echo $ac_n "checking <ctype> for freebsd 4.0 ""... $ac_c" 1>&6
-echo "configure:3925: checking <ctype> for freebsd 4.0 " >&5
+echo "configure:5547: checking <ctype> for freebsd 4.0 " >&5
     cat > conftest.$ac_ext <<EOF
-#line 3927 "configure"
+#line 5549 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 int main() {
@@ -3933,7 +5555,7 @@ int
 	+ _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
 ; return 0; }
 EOF
-if { (eval echo configure:3937: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5559: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   \
     ctype_bsd=yes
@@ -3953,9 +5575,9 @@ rm -f conftest*
 
         if test $ctype_default = "yes"; then
     echo $ac_n "checking <ctype> for freebsd 3.4 ""... $ac_c" 1>&6
-echo "configure:3957: checking <ctype> for freebsd 3.4 " >&5
+echo "configure:5579: checking <ctype> for freebsd 3.4 " >&5
     cat > conftest.$ac_ext <<EOF
-#line 3959 "configure"
+#line 5581 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 int main() {
@@ -3965,7 +5587,7 @@ int
       + _D + _P + _X + _G + __istype (a, 0);}
 ; return 0; }
 EOF
-if { (eval echo configure:3969: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5591: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   \
     ctype_freebsd34=yes
@@ -3985,9 +5607,9 @@ rm -f conftest*
 
         if test $ctype_default = "yes"; then
     echo $ac_n "checking <ctype> for solaris 2.6,7,8 ""... $ac_c" 1>&6
-echo "configure:3989: checking <ctype> for solaris 2.6,7,8 " >&5
+echo "configure:5611: checking <ctype> for solaris 2.6,7,8 " >&5
     cat > conftest.$ac_ext <<EOF
-#line 3991 "configure"
+#line 5613 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 int main() {
@@ -3998,7 +5620,7 @@ int
 	+ __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
 ; return 0; }
 EOF
-if { (eval echo configure:4002: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5624: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   \
     ctype_solaris=yes
@@ -4013,7 +5635,7 @@ rm -f conftest*
 
     if test $ctype_solaris = "yes"; then
       echo $ac_n "checking   for version""... $ac_c" 1>&6
-echo "configure:4017: checking   for version" >&5
+echo "configure:5639: checking   for version" >&5
       ac_ext=C
 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 ac_cpp='$CXXCPP $CPPFLAGS'
@@ -4022,14 +5644,14 @@ ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftes
 cross_compiling=$ac_cv_prog_cxx_cross
  
       cat > conftest.$ac_ext <<EOF
-#line 4026 "configure"
+#line 5648 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 int main() {
 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
 ; return 0; }
 EOF
-if { (eval echo configure:4033: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5655: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   \
       ctype_solaris26=yes
@@ -4061,9 +5683,9 @@ cross_compiling=$ac_cv_prog_cc_cross
 
         if test $ctype_default = "yes"; then
     echo $ac_n "checking <ctype> for solaris 2.5.1 ""... $ac_c" 1>&6
-echo "configure:4065: checking <ctype> for solaris 2.5.1 " >&5
+echo "configure:5687: checking <ctype> for solaris 2.5.1 " >&5
     cat > conftest.$ac_ext <<EOF
-#line 4067 "configure"
+#line 5689 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 int main() {
@@ -4073,7 +5695,7 @@ int
 	+ __ctype[a];}
 ; return 0; }
 EOF
-if { (eval echo configure:4077: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5699: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   \
     ctype_solaris25=yes
@@ -4093,9 +5715,9 @@ rm -f conftest*
 
         if test $ctype_default = "yes"; then
     echo $ac_n "checking <ctype> for aix ""... $ac_c" 1>&6
-echo "configure:4097: checking <ctype> for aix " >&5
+echo "configure:5719: checking <ctype> for aix " >&5
     cat > conftest.$ac_ext <<EOF
-#line 4099 "configure"
+#line 5721 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 int main() {
@@ -4106,7 +5728,7 @@ int
 	+ _VALC('a') + _IS('c', 0);}
 ; return 0; }
 EOF
-if { (eval echo configure:4110: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5732: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   \
     ctype_aix=yes
@@ -4126,9 +5748,9 @@ rm -f conftest*
 
         if test $ctype_default = "yes"; then
     echo $ac_n "checking <ctype> for newlib ""... $ac_c" 1>&6
-echo "configure:4130: checking <ctype> for newlib " >&5
+echo "configure:5752: checking <ctype> for newlib " >&5
     cat > conftest.$ac_ext <<EOF
-#line 4132 "configure"
+#line 5754 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 int main() {
@@ -4138,7 +5760,7 @@ int
 	+ _ctype_[a];}
 ; return 0; }
 EOF
-if { (eval echo configure:4142: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:5764: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   \
     ctype_newlib=yes
@@ -4172,17 +5794,17 @@ fi
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:4176: checking for $ac_hdr" >&5
+echo "configure:5798: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 4181 "configure"
+#line 5803 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:4186: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:5808: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -4211,12 +5833,12 @@ done
 for ac_func in getpagesize
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:4215: checking for $ac_func" >&5
+echo "configure:5837: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 4220 "configure"
+#line 5842 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -4239,7 +5861,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:4243: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5865: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -4264,7 +5886,7 @@ fi
 done
 
 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
-echo "configure:4268: checking for working mmap" >&5
+echo "configure:5890: checking for working mmap" >&5
 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -4272,7 +5894,7 @@ else
   ac_cv_func_mmap_fixed_mapped=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 4276 "configure"
+#line 5898 "configure"
 #include "confdefs.h"
 
 /* Thanks to Mike Haertel and Jim Avera for this test.
@@ -4412,7 +6034,7 @@ main()
 }
 
 EOF
-if { (eval echo configure:4416: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:6038: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_func_mmap_fixed_mapped=yes
 else
@@ -4475,19 +6097,19 @@ fi
 
 if test $ac_cv_header_locale_h = yes; then
     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
-echo "configure:4479: checking for LC_MESSAGES" >&5
+echo "configure:6101: checking for LC_MESSAGES" >&5
 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 4484 "configure"
+#line 6106 "configure"
 #include "confdefs.h"
 #include <locale.h>
 int main() {
 return LC_MESSAGES
 ; return 0; }
 EOF
-if { (eval echo configure:4491: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6113: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_val_LC_MESSAGES=yes
 else
diff --git a/libstdc++-v3/libio/Makefile.in b/libstdc++-v3/libio/Makefile.in
index 1f524f97584..c82b27cbc76 100644
--- a/libstdc++-v3/libio/Makefile.in
+++ b/libstdc++-v3/libio/Makefile.in
@@ -116,19 +116,17 @@ includes =
 libio_headers = \
         libio.h libioP.h iolibio.h
 
-@GLIBCPP_NEED_LIBIO_TRUE@LIBIO_SRCS = \
-@GLIBCPP_NEED_LIBIO_TRUE@\
+@GLIBCPP_NEED_LIBIO_TRUE@LIBIO_SRCS = @GLIBCPP_NEED_LIBIO_TRUE@\
 @GLIBCPP_NEED_LIBIO_TRUE@	filedoalloc.c genops.c fileops.c stdfiles.c cleanup.c
-@GLIBCPP_NEED_LIBIO_FALSE@LIBIO_SRCS = \
+@GLIBCPP_NEED_LIBIO_FALSE@LIBIO_SRCS = 
 
 EXTRA_DIST = iostreamP.h
 
 libio_la_LIBADD = $(LIBIO_SRCS) 
 libio_la_DEPENDENCIES = $(libio_la_LIBADD)
 libio_la_SOURCES = $(LIBIO_SRCS)
-@GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@LIBIO_CONFIG_H = \
-@GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@_G_config.h
-@GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE@LIBIO_CONFIG_H = \
+@GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@LIBIO_CONFIG_H = @GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@_G_config.h
+@GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE@LIBIO_CONFIG_H = 
 mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs
 CONFIG_HEADER = ../config.h
 CONFIG_CLEAN_FILES = 
diff --git a/libstdc++-v3/math/mathconf.h b/libstdc++-v3/math/mathconf.h
index dfc59edff17..35f88d41b03 100644
--- a/libstdc++-v3/math/mathconf.h
+++ b/libstdc++-v3/math/mathconf.h
@@ -328,10 +328,10 @@ do {                                                            \
 
 
 /* Replacement for non-existing float functions.  */
-#if !defined(_GLIBCPP_HAVE_FABSF) && !defined(_GLIBCPP_HAS_BUILTIN_FABSF)
+#if !defined(_GLIBCPP_HAVE_FABSF) && !defined(_GLIBCPP_HAVE_BUILTIN_FABSF)
 # define fabsf(x) fabs (x)
 #endif
-#if !defined(_GLIBCPP_HAVE_COSF) && !defined(_GLIBCPP_HAS_BUILTIN_COSF)
+#if !defined(_GLIBCPP_HAVE_COSF) && !defined(_GLIBCPP_HAVE_BUILTIN_COSF)
 # define cosf(x) cos (x)
 #endif
 #ifndef _GLIBCPP_HAVE_COSHF
@@ -349,13 +349,13 @@ do {                                                            \
 #ifndef _GLIBCPP_HAVE_POWF
 # define powf(x, y) pow (x, y)
 #endif
-#if !defined(_GLIBCPP_HAVE_SINF) && !defined(_GLIBCPP_HAS_BUILTIN_SINF)
+#if !defined(_GLIBCPP_HAVE_SINF) && !defined(_GLIBCPP_HAVE_BUILTIN_SINF)
 # define sinf(x) sin (x)
 #endif
 #ifndef _GLIBCPP_HAVE_SINHF
 # define sinhf(x) sinh (x)
 #endif
-#if !defined(_GLIBCPP_HAVE_SQRTF) && !defined(_GLIBCPP_HAS_BUILTIN_SQRTF)
+#if !defined(_GLIBCPP_HAVE_SQRTF) && !defined(_GLIBCPP_HAVE_BUILTIN_SQRTF)
 # define sqrtf(x) sqrt (x)
 #endif
 #ifndef _GLIBCPP_HAVE_TANF
diff --git a/libstdc++-v3/shadow/bits/std_cmath.h b/libstdc++-v3/shadow/bits/std_cmath.h
index 9d61dfe7f87..d233dd151e6 100644
--- a/libstdc++-v3/shadow/bits/std_cmath.h
+++ b/libstdc++-v3/shadow/bits/std_cmath.h
@@ -34,6 +34,8 @@
 #ifndef _CPP_CMATH
 #define _CPP_CMATH 1
 
+# include <bits/c++config.h>
+
   namespace _C_legacy {
     extern "C" {
 #     define _IN_C_LEGACY_
@@ -41,137 +43,946 @@
 #     include_next <math.h>
     }
     inline double _CPP_HUGE_VAL_capture()        { return HUGE_VAL; }
-    inline double _CPP_acos_capture(double __x)  { return acos(__x); }
-    inline double _CPP_asin_capture(double __x)  { return asin(__x); }
-    inline double _CPP_atan_capture(double __x)  { return atan(__x); }
-    inline double _CPP_atan2_capture(double __y, double __x) 
-      { return atan2(__y,__x); }
-    inline double _CPP_cos_capture(double __x)   { return cos(__x); }
-    inline double _CPP_sin_capture(double __x)   { return sin(__x); }
-    inline double _CPP_tan_capture(double __x)   { return tan(__x); }
-    inline double _CPP_cosh_capture(double __x)  { return cosh(__x); }
-    inline double _CPP_sinh_capture(double __x)  { return sinh(__x); }
-    inline double _CPP_tanh_capture(double __x)  { return tanh(__x); }
-    inline double _CPP_exp_capture(double __x)   { return exp(__x); }
-    inline double _CPP_frexp_capture(double __x, int* __exp) 
+#if _GLIBCPP_HAVE_BUILTIN_ACOSF
+    inline float _CPP_acos_capture(float __x)
+      { return __builtin_acosf(__x); }
+#elif _GLIBCPP_HAVE_ACOSF
+    inline float _CPP_acos_capture(float __x)
+      { return acosf(__x); }
+#else
+    inline float _CPP_acos_capture(float __x)
+      { 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
+    inline float _CPP_asin_capture(float __x)
+      { return asinf(__x); }
+#else
+    inline float _CPP_asin_capture(float __x)
+      { 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
+    inline float _CPP_atan_capture(float __x)
+      { return atanf(__x); }
+#else
+    inline float _CPP_atan_capture(float __x)
+      { 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
+    inline float _CPP_atan2_capture(float __y, float __x)
+      { return atan2f(__y, __x); }
+#else
+    inline float _CPP_atan2_capture(float __y, float __x)
+      { 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
+    inline float _CPP_ceil_capture(float __x)
+      { return ceilf(__x); }
+#else
+    inline float _CPP_ceil_capture(float __x)
+      { return ceil(static_cast<double>(__x)); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_COSF
+    inline float _CPP_cos_capture(float __x)
+      { return __builtin_cosf(__x); }
+#elif _GLIBCPP_HAVE_COSF
+    inline float _CPP_cos_capture(float __x)
+      { return cosf(__x); }
+#else
+    inline float _CPP_cos_capture(float __x)
+      { 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
+    inline float _CPP_cosh_capture(float __x)
+      { return coshf(__x); }
+#else
+    inline float _CPP_cosh_capture(float __x)
+      { 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
+    inline float _CPP_exp_capture(float __x)
+      { return expf(__x); }
+#else
+    inline float _CPP_exp_capture(float __x)
+      { return exp(static_cast<double>(__x)); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_FABSF
+    inline float _CPP_fabs_capture(float __x)
+      { return __builtin_fabsf(__x); }
+#elif _GLIBCPP_HAVE_FABSF
+    inline float _CPP_fabs_capture(float __x)
+      { return fabsf(__x); }
+#else
+    inline float _CPP_fabs_capture(float __x)
+      { 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
+    inline float _CPP_floor_capture(float __x)
+      { return floorf(__x); }
+#else
+    inline float _CPP_floor_capture(float __x)
+      { 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
+    inline float _CPP_fmod_capture(float __x, float __y)
+      { return fmodf(__x, __y); }
+#else
+    inline float _CPP_fmod_capture(float __x, float __y)
+      { 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
+    inline float _CPP_frexp_capture(float __x, int* __exp)
+      { return frexpf(__x, __exp); }
+#else
+    inline float _CPP_frexp_capture(float __x, int* __exp)
+      { 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
+    inline float _CPP_ldexp_capture(float __x, int __exp)
+      { return ldexpf(__x, __exp); }
+#else
+    inline float _CPP_ldexp_capture(float __x, int __exp)
+      { 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
+    inline float _CPP_log_capture(float __x)
+      { return logf(__x); }
+#else
+    inline float _CPP_log_capture(float __x)
+      { 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
+    inline float _CPP_log10_capture(float __x)
+      { return log10f(__x); }
+#else
+    inline float _CPP_log10_capture(float __x)
+      { 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
+    inline float _CPP_modf_capture(float __x, float* __iptr)
+      { return modff(__x, __iptr); }
+#else
+    inline float _CPP_modf_capture(float __x, float* __iptr)
+    {
+       double __tmp;
+       double __res = _C_legacy::modf(static_cast<double>(__x), &__tmp);
+       *__iptr = static_cast<float> (__tmp);
+       return __res;
+    }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_POWF
+    inline float _CPP_pow_capture(float __x, float __y)
+      { return __builtin_powf(__x, __y); }
+#elif _GLIBCPP_HAVE_POWF
+    inline float _CPP_pow_capture(float __x, float __y)
+      { return powf(__x, __y); }
+#else
+    inline float _CPP_pow_capture(float __x, float __y)
+      { return pow(static_cast<double>(__x), static_cast<double>(__y)); }
+#endif
+
+    float pow(float, int);
+
+#if _GLIBCPP_HAVE_BUILTIN_SINF
+    inline float _CPP_sin_capture(float __x)
+      { return __builtin_sinf(__x); }
+#elif _GLIBCPP_HAVE_SINF
+    inline float _CPP_sin_capture(float __x)
+      { return sinf(__x); }
+#else
+    inline float _CPP_sin_capture(float __x)
+      { 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
+    inline float _CPP_sinh_capture(float __x)
+      { return sinhf(__x); }
+#else
+    inline float _CPP_sinh_capture(float __x)
+      { return sinh(static_cast<double>(__x)); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_SQRTF
+    inline float _CPP_sqrt_capture(float __x)
+      { return __builtin_sqrtf(__x); }
+#elif _GLIBCPP_HAVE_SQRTF
+    inline float _CPP_sqrt_capture(float __x)
+      { return sqrtf(__x); }
+#else
+    inline float _CPP_sqrt_capture(float __x)
+      { 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
+    inline float _CPP_tan_capture(float __x)
+      { return tanf(__x); }
+#else
+    inline float _CPP_tan_capture(float __x)
+      { 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
+    inline float _CPP_tanh_capture(float __x)
+      { return tanhf(__x); }
+#else
+    inline float _CPP_tanh_capture(float __x)
+      { return tanh(static_cast<double>(__x)); }
+#endif
+
+    //
+    // 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
+    inline double _CPP_cos_capture(double __x)
+      { return __builtin_cos(__x); }
+#else
+    inline double _CPP_cos_capture(double __x)
+      { 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
+    inline double _CPP_fabs_capture(double __x)
+      { return __builtin_fabs(__x); }
+#else
+    inline double _CPP_fabs_capture(double __x)
+      { 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); }
-    inline double _CPP_ldexp_capture(double __x, int __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); }
-    inline double _CPP_log_capture(double __x)   { return log(__x); }
-    inline double _CPP_log10_capture(double __x) { return log10(__x); }
-    inline double _CPP_modf_capture(double __x, double* __iptr) 
+#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); }
-    inline double _CPP_pow_capture(double __x, double __y) 
+#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); }
-    inline double _CPP_sqrt_capture(double __x)  { return sqrt(__x); }
-    inline double _CPP_ceil_capture(double __x)  { return ceil(__x); }
-    inline double _CPP_fabs_capture(double __x)  { return fabs(__x); }
-    inline double _CPP_floor_capture(double __x) { return floor(__x); }
-    inline double _CPP_fmod_capture(double __x, double __y) 
-      { return fmod(__x, __y); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_SIN
+    inline double _CPP_sin_capture(double __x)
+      { return __builtin_sin(__x); }
+#else
+    inline double _CPP_sin_capture(double __x)
+      { 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
+    inline double _CPP_sqrt_capture(double __x)
+      { return __builtin_fsqrt(__x); }
+#else
+    inline double _CPP_sqrt_capture(double __x)
+      { 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
+    inline long double _CPP_acos_capture(long double __x)
+      { return acosl(__x); }
+#else
+    inline long double _CPP_acos_capture(long double __x)
+      { 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
+    inline long double _CPP_asin_capture(long double __x)
+      { return asinl(__x); }
+#else
+    inline long double _CPP_asin_capture(long double __x)
+      { 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
+    inline long double _CPP_atan_capture(long double __x)
+      { return atanl(__x); }
+#else
+    inline long double _CPP_atan_capture(long double __x)
+      { 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
+    inline long double _CPP_atan2_capture(long double __y, long double __x)
+      { return atan2l(__y, __x); }
+#else
+    inline long double _CPP_atan2_capture(long double __y, long double __x)
+      { 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); }
+#else
+    inline long double _CPP_ceil_capture(long double __x)
+      { return ceil(static_cast<double>(__x)); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_COSL
+    inline long double _CPP_cos_capture(long double __x)
+      { return __builtin_cosl(__x); }
+#elif _GLIBCPP_HAVE_COSL
+    inline long double _CPP_cos_capture(long double __x)
+      { return cosl(__x); }
+#else
+    inline long double _CPP_cos_capture(long double __x)
+      { 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
+    inline long double _CPP_cosh_capture(long double __x)
+      { return coshl(__x); }
+#else
+    inline long double _CPP_cosh_capture(long double __x)
+      { 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
+    inline long double _CPP_exp_capture(long double __x)
+      { return expl(__x); }
+#else
+    inline long double _CPP_exp_capture(long double __x)
+      { return exp(static_cast<double>(__x)); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_FABSL
+    inline long double _CPP_fabs_capture(long double __x)
+      { return __builtin_fabsl(__x); }
+#elif _GLIBCPP_HAVE_FABSL
+    inline long double _CPP_fabs_capture(long double __x)
+      { return fabsl(__x); }
+#else
+    inline long double _CPP_fabs_capture(long double __x)
+      { 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
+    inline long double _CPP_floor_capture(long double __x)
+      { return floorl(__x); }
+#else
+    inline long double _CPP_floor_capture(long double __x)
+      { 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
+    inline long double _CPP_fmod_capture(long double __x, long double __y)
+      { return fmodl(__x, __y); }
+#else
+    inline long double _CPP_fmod_capture(long double __x, long double __y)
+      { 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
+    inline long double _CPP_frexp_capture(long double __x, int* __exp)
+      { return frexpl(__x, __exp); }
+#else
+    inline long double _CPP_frexp_capture(long double __x, int* __exp)
+      { 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
+    inline long double _CPP_ldexp_capture(long double __x, int __exp)
+      { return ldexpl(__x, __exp); }
+#else
+    inline long double _CPP_ldexp_capture(long double __x, int __exp)
+      { 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
+    inline long double _CPP_log_capture(long double __x)
+      { return logl(__x); }
+#else
+    inline long double _CPP_log_capture(long double __x)
+      { 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
+    inline long double _CPP_log10_capture(long double __x)
+      { return log10l(__x); }
+#else
+    inline long double _CPP_log10_capture(long double __x)
+      { 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
+    inline long double _CPP_modf_capture(long double __x, long double* __iptr)
+      { return modfl(__x, __iptr); }
+#else
+    inline long double _CPP_modf_capture(long double __x, long double* __iptr)
+    {
+       double __tmp;
+       double __res = _C_legacy::modf(static_cast<double>(__x), &__tmp);
+       *__iptr = static_cast<long double> (__tmp);
+       return __res;
+    }
+#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
+    inline long double _CPP_pow_capture(long double __x, long double __y)
+      { return powl(__x, __y); }
+#else
+    inline long double _CPP_pow_capture(long double __x, long double __y)
+      { return pow(static_cast<double>(__x), static_cast<double>(__y)); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_SINL
+    inline long double _CPP_sin_capture(long double __x)
+      { return __builtin_sinl(__x); }
+#elif _GLIBCPP_HAVE_SINL
+    inline long double _CPP_sin_capture(long double __x)
+      { return sinl(__x); }
+#else
+    inline long double _CPP_sin_capture(long double __x)
+      { 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
+    inline long double _CPP_sinh_capture(long double __x)
+      { return sinhl(__x); }
+#else
+    inline long double _CPP_sinh_capture(long double __x)
+      { return sinh(static_cast<double>(__x)); }
+#endif
+
+#if _GLIBCPP_HAVE_BUILTIN_SQRTL
+    inline long double _CPP_sqrt_capture(long double __x)
+      { return __builtin_sqrtl(__x); }
+#elif _GLIBCPP_HAVE_SQRTL
+    inline long double _CPP_sqrt_capture(long double __x)
+      { return sqrtl(__x); }
+#else
+    inline long double _CPP_sqrt_capture(long double __x)
+      { 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
+    inline long double _CPP_tan_capture(long double __x)
+      { return tanl(__x); }
+#else
+    inline long double _CPP_tan_capture(long double __x)
+      { 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
+    inline long double _CPP_tanh_capture(long double __x)
+      { return tanhl(__x); }
+#else
+    inline long double _CPP_tanh_capture(long double __x)
+      { return tanh(static_cast<double>(__x)); }
+#endif
+
 
     namespace _C_shadow { }
   } // close namespace ::_C_legacy::
 
 # undef HUGE_VAL
 # define HUGE_VAL ::_C_legacy::_CPP_HUGE_VAL_capture()
+# undef abs
 # undef acos
 # undef asin
 # undef atan
 # undef atan2
+# undef ceil
 # undef cos
-# undef sin
-# undef tan
 # undef cosh
-# undef sinh
-# undef tanh
 # undef exp
+# undef fabs
+# undef floor
+# undef fmod
 # undef frexp
 # undef ldexp
 # undef log
 # undef log10
 # undef modf
 # undef pow
+# undef sin
+# undef sinh
 # undef sqrt
-# undef ceil
-# undef fabs
-# undef floor
-# undef fmod
+# undef tan
+# undef tanh
 
   namespace _C_legacy {
     namespace _C_shadow {
-      inline double acos(double __x)
-        { return ::_C_legacy::_CPP_acos_capture(__x); }
-      inline double asin(double __x)
-        { return ::_C_legacy::_CPP_asin_capture(__x); }
-      inline double atan(double __x)
-        { return ::_C_legacy::_CPP_atan_capture(__x); }
-      inline double atan2(double __y, double __x)
-      	{ return ::_C_legacy::_CPP_atan2_capture(__y,__x); }
-      inline double cos(double __x)
-        { return ::_C_legacy::_CPP_cos_capture(__x); }
-      inline double sin(double __x)
-        { return ::_C_legacy::_CPP_sin_capture(__x); }
-      inline double tan(double __x)
-        { return ::_C_legacy::_CPP_tan_capture(__x); }
-      inline double cosh(double __x)
-        { return ::_C_legacy::_CPP_cosh_capture(__x); }
-      inline double sinh(double __x)
-        { return ::_C_legacy::_CPP_sinh_capture(__x); }
-      inline double tanh(double __x)
-        { return ::_C_legacy::_CPP_tanh_capture(__x); }
-      inline double exp(double __x)
-        { return ::_C_legacy::_CPP_exp_capture(__x); }
-      inline double frexp(double __x, int* __exp)
-      	{ return ::_C_legacy::_CPP_frexp_capture(__x, __exp); }
-      inline double ldexp(double __x, int __exp)
-      	{ return ::_C_legacy::_CPP_ldexp_capture(__x, __exp); }
-      inline double log(double __x)
-        { return ::_C_legacy::_CPP_log_capture(__x); }
-      inline double log10(double __x)
-        { return ::_C_legacy::_CPP_log10_capture(__x); }
-      inline double modf(double __x, double* __iptr)
-      	{ return ::_C_legacy::_CPP_modf_capture(__x, __iptr); }
-      inline double pow(double __x, double __y)
-      	{ return ::_C_legacy::_CPP_pow_capture(__x, __y); }
-      inline double sqrt(double __x)
-        { return ::_C_legacy::_CPP_sqrt_capture(__x); }
-      inline double ceil(double __x)
-        { return ::_C_legacy::_CPP_ceil_capture(__x); }
-      inline double fabs(double __x)
-        { return ::_C_legacy::_CPP_fabs_capture(__x); }
-      inline double floor(double __x)
-        { return ::_C_legacy::_CPP_floor_capture(__x); }
-      inline double fmod(double __x, double __y)
-      	{ return ::_C_legacy::_CPP_fmod_capture(__x, __y); }
-
     }
   }
   namespace std {
 
-    // Adopt C names into std::
-    using ::_C_legacy::_C_shadow::acos;
-    using ::_C_legacy::_C_shadow::asin;
-    using ::_C_legacy::_C_shadow::atan;
-    using ::_C_legacy::_C_shadow::atan2;
-    using ::_C_legacy::_C_shadow::cos;
-    using ::_C_legacy::_C_shadow::sin;
-    using ::_C_legacy::_C_shadow::tan;
-    using ::_C_legacy::_C_shadow::cosh;
-    using ::_C_legacy::_C_shadow::sinh;
-    using ::_C_legacy::_C_shadow::tanh;
-    using ::_C_legacy::_C_shadow::exp;
-    using ::_C_legacy::_C_shadow::frexp;
-    using ::_C_legacy::_C_shadow::ldexp;
-    using ::_C_legacy::_C_shadow::log;
-    using ::_C_legacy::_C_shadow::log10;
-    using ::_C_legacy::_C_shadow::modf;
-    using ::_C_legacy::_C_shadow::pow;
-    using ::_C_legacy::_C_shadow::sqrt;
-    using ::_C_legacy::_C_shadow::ceil;
-    using ::_C_legacy::_C_shadow::fabs;
-    using ::_C_legacy::_C_shadow::floor;
-    using ::_C_legacy::_C_shadow::fmod;
+    //
+    // float
+    //
+
+    inline float abs(float __x)
+      { return ::_C_legacy::_CPP_fabs_capture(__x); }
+
+    inline float acos(float __x)
+      { return ::_C_legacy::_CPP_acos_capture(__x); }
+
+    inline float asin(float __x)
+      { return ::_C_legacy::_CPP_asin_capture(__x); }
+
+    inline float atan(float __x)
+      { return ::_C_legacy::_CPP_atan_capture(__x); }
+
+    inline float atan2(float __y, float __x)
+      { return ::_C_legacy::_CPP_atan2_capture(__y, __x); }
+
+    inline float ceil(float __x)
+      { return ::_C_legacy::_CPP_ceil_capture(__x); }
+
+    inline float cos(float __x)
+      { return ::_C_legacy::_CPP_cos_capture(__x); }
+
+    inline float cosh(float __x)
+      { return ::_C_legacy::_CPP_cosh_capture(__x); }
+
+    inline float exp(float __x)
+      { return ::_C_legacy::_CPP_exp_capture(__x); }
+
+    inline float fabs(float __x)
+      { return ::_C_legacy::_CPP_fabs_capture(__x); }
+
+    inline float floor(float __x)
+      { return ::_C_legacy::_CPP_floor_capture(__x); }
+
+    inline float fmod(float __x, float __y)
+      { return ::_C_legacy::_CPP_fmod_capture(__x, __y); }
+
+    inline float frexp(float __x, int* __exp)
+      { return ::_C_legacy::_CPP_frexp_capture(__x, __exp); }
+
+    inline float ldexp(float __x, int __exp)
+      { return ::_C_legacy::_CPP_ldexp_capture(__x, __exp); }
+
+    inline float log(float __x)
+      { return ::_C_legacy::_CPP_log_capture(__x); }
+
+    inline float log10(float __x)
+      { return ::_C_legacy::_CPP_log10_capture(__x); }
+
+    inline float modf(float __x, float* __iptr)
+      { return ::_C_legacy::_CPP_modf_capture(__x, __iptr); }
+
+    inline float pow(float __x, float __y)
+      { return ::_C_legacy::_CPP_pow_capture(__x, __y); }
+
+    float pow(float, int);
+
+    inline float sin(float __x)
+      { return ::_C_legacy::_CPP_sin_capture(__x); }
+
+    inline float sinh(float __x)
+      { return ::_C_legacy::_CPP_sinh_capture(__x); }
+
+    inline float sqrt(float __x)
+      { return ::_C_legacy::_CPP_sqrt_capture(__x); }
+
+    inline float tan(float __x)
+      { return ::_C_legacy::_CPP_tan_capture(__x); }
+
+    inline float tanh(float __x)
+      { return ::_C_legacy::_CPP_tanh_capture(__x); }
+
+    //
+    // double
+    //
+
+    inline double abs(double __x)
+      { return ::_C_legacy::_CPP_fabs_capture(__x); }
+
+    inline double acos(double __x)
+      { return ::_C_legacy::_CPP_acos_capture(__x); }
+
+    inline double asin(double __x)
+      { return ::_C_legacy::_CPP_asin_capture(__x); }
+
+    inline double atan(double __x)
+      { return ::_C_legacy::_CPP_atan_capture(__x); }
+
+    inline double atan2(double __y, double __x)
+      { return ::_C_legacy::_CPP_atan2_capture(__y, __x); }
+
+    inline double ceil(double __x)
+      { return ::_C_legacy::_CPP_ceil_capture(__x); }
+
+    inline double cos(double __x)
+      { return ::_C_legacy::_CPP_cos_capture(__x); }
+
+    inline double cosh(double __x)
+      { return ::_C_legacy::_CPP_cosh_capture(__x); }
+
+    inline double exp(double __x)
+      { return ::_C_legacy::_CPP_exp_capture(__x); }
+
+    inline double fabs(double __x)
+      { return ::_C_legacy::_CPP_fabs_capture(__x); }
+
+    inline double floor(double __x)
+      { return ::_C_legacy::_CPP_floor_capture(__x); }
+
+    inline double fmod(double __x, double __y)
+      { return ::_C_legacy::_CPP_fmod_capture(__x, __y); }
+
+    inline double frexp(double __x, int* __exp)
+      { return ::_C_legacy::_CPP_frexp_capture(__x, __exp); }
+
+    inline double ldexp(double __x, int __exp)
+      { return ::_C_legacy::_CPP_ldexp_capture(__x, __exp); }
+
+    inline double log(double __x)
+      { return ::_C_legacy::_CPP_log_capture(__x); }
+
+    inline double log10(double __x)
+      { return ::_C_legacy::_CPP_log10_capture(__x); }
+
+    inline double modf(double __x, double* __iptr)
+      { return ::_C_legacy::_CPP_modf_capture(__x, __iptr); }
+
+    inline double pow(double __x, double __y)
+      { return ::_C_legacy::_CPP_pow_capture(__x, __y); }
+
+    double pow (double, int);
+
+    inline double sin(double __x)
+      { return ::_C_legacy::_CPP_sin_capture(__x); }
+
+    inline double sinh(double __x)
+      { return ::_C_legacy::_CPP_sinh_capture(__x); }
+
+    inline double sqrt(double __x)
+      { return ::_C_legacy::_CPP_sqrt_capture(__x); }
+
+    inline double tan(double __x)
+      { return ::_C_legacy::_CPP_tan_capture(__x); }
+
+    inline double tanh(double __x)
+      { return ::_C_legacy::_CPP_tanh_capture(__x); }
+
+    //
+    // long double
+    //
+    inline long double abs(long double __x)
+      { return ::_C_legacy::_CPP_fabs_capture(__x); }
+
+    inline long double acos(long double __x)
+      { return ::_C_legacy::_CPP_acos_capture(__x); }
+
+    inline long double asin(long double __x)
+      { return ::_C_legacy::_CPP_asin_capture(__x); }
+
+    inline long double atan(long double __x)
+      { return ::_C_legacy::_CPP_atan_capture(__x); }
+
+    inline long double atan2(long double __y, long double __x)
+      { return ::_C_legacy::_CPP_atan2_capture(__y, __x); }
+
+    inline long double ceil(long double __x)
+      { return ::_C_legacy::_CPP_ceil_capture(__x); }
+
+    inline long double cos(long double __x)
+      { return ::_C_legacy::_CPP_cos_capture(__x); }
+
+    inline long double cosh(long double __x)
+      { return ::_C_legacy::_CPP_cosh_capture(__x); }
+
+    inline long double exp(long double __x)
+      { return ::_C_legacy::_CPP_exp_capture(__x); }
+
+    inline long double fabs(long double __x)
+      { return ::_C_legacy::_CPP_fabs_capture(__x); }
+
+    inline long double floor(long double __x)
+      { return ::_C_legacy::_CPP_floor_capture(__x); }
+
+    inline long double fmod(long double __x, long double __y)
+      { return ::_C_legacy::_CPP_fmod_capture(__x, __y); }
+
+    inline long double frexp(long double __x, int* __exp)
+      { return ::_C_legacy::_CPP_frexp_capture(__x, __exp); }
+
+    inline long double ldexp(long double __x, int __exp)
+      { return ::_C_legacy::_CPP_ldexp_capture(__x, __exp); }
+
+    inline long double log(long double __x)
+      { return ::_C_legacy::_CPP_log_capture(__x); }
+
+    inline long double log10(long double __x)
+      { return ::_C_legacy::_CPP_log10_capture(__x); }
+
+    inline long double modf(long double __x, long double* __iptr)
+      { return ::_C_legacy::_CPP_modf_capture(__x, __iptr); }
+
+    inline long double pow(long double __x, long double __y)
+      { return ::_C_legacy::_CPP_pow_capture(__x, __y); }
+
+    long double pow (long double, int);
+
+    inline long double sin(long double __x)
+      { return ::_C_legacy::_CPP_sin_capture(__x); }
+
+    inline long double sinh(long double __x)
+      { return ::_C_legacy::_CPP_sinh_capture(__x); }
+
+    inline long double sqrt(long double __x)
+      { return ::_C_legacy::_CPP_sqrt_capture(__x); }
+
+    inline long double tan(long double __x)
+      { return ::_C_legacy::_CPP_tan_capture(__x); }
+
+    inline long double tanh(long double __x)
+      { return ::_C_legacy::_CPP_tanh_capture(__x); }
+
 
   } // close namespace std::
   
diff --git a/libstdc++-v3/src/Makefile.in b/libstdc++-v3/src/Makefile.in
index 929a153094d..c4fa9ede4a4 100644
--- a/libstdc++-v3/src/Makefile.in
+++ b/libstdc++-v3/src/Makefile.in
@@ -105,12 +105,9 @@ libinst_wstring_la = @libinst_wstring_la@
 
 AUTOMAKE_OPTIONS = 1.3 gnits
 MAINT_CHARSET = latin1
-@USE_LIBDIR_TRUE@toolexeclibdir = \
-@USE_LIBDIR_TRUE@$(libdir)$(MULTISUBDIR)
-@USE_LIBDIR_FALSE@toolexeclibdir = \
-@USE_LIBDIR_FALSE@$(toolexecdir)/lib$(MULTISUBDIR)
-@USE_LIBDIR_FALSE@toolexecdir = \
-@USE_LIBDIR_FALSE@$(exec_prefix)/$(target_alias)
+@USE_LIBDIR_TRUE@toolexeclibdir = @USE_LIBDIR_TRUE@$(libdir)$(MULTISUBDIR)
+@USE_LIBDIR_FALSE@toolexeclibdir = @USE_LIBDIR_FALSE@$(toolexecdir)/lib$(MULTISUBDIR)
+@USE_LIBDIR_FALSE@toolexecdir = @USE_LIBDIR_FALSE@$(exec_prefix)/$(target_alias)
 
 toolexeclib_LTLIBRARIES = libstdc++.la
 EXTRA_LTLIBRARIES = libinst-string.la libinst-wstring.la
@@ -256,10 +253,9 @@ std_headers = \
 	map memory new numeric ostream queue set sstream stack stdexcept \
 	streambuf string strstream typeinfo utility valarray vector 
 
-@GLIBCPP_NEED_LIBIO_TRUE@libio_headers = \
-@GLIBCPP_NEED_LIBIO_TRUE@\
+@GLIBCPP_NEED_LIBIO_TRUE@libio_headers = @GLIBCPP_NEED_LIBIO_TRUE@\
 @GLIBCPP_NEED_LIBIO_TRUE@	$(top_builddir)/libio/_G_config.h $(top_srcdir)/libio/libio.h
-@GLIBCPP_NEED_LIBIO_FALSE@libio_headers = \
+@GLIBCPP_NEED_LIBIO_FALSE@libio_headers = 
 
 generated_headers = \
 	 $(top_builddir)/bits/std_limits.h $(top_builddir)/bits/c++config.h \
@@ -338,9 +334,8 @@ libstdc___la_LIBADD = \
 libstdc___la_LDFLAGS = -version-info 3:0:0 -lm
 
 libstdc___la_DEPENDENCIES = $(libstdc___la_LIBADD)
-@GLIBCPP_USE_CSHADOW_TRUE@CSHADOW_H = \
-@GLIBCPP_USE_CSHADOW_TRUE@$(top_builddir)/stamp-cshadow
-@GLIBCPP_USE_CSHADOW_FALSE@CSHADOW_H = \
+@GLIBCPP_USE_CSHADOW_TRUE@CSHADOW_H = @GLIBCPP_USE_CSHADOW_TRUE@$(top_builddir)/stamp-cshadow
+@GLIBCPP_USE_CSHADOW_FALSE@CSHADOW_H = 
 
 # We cannot use the default rules to install headers since we cannot
 # statically decide which headers to install.  So we have our own special