diff options
| author | Waldemar Brodkorb <wbx@openadk.org> | 2014-07-28 15:43:34 +0200 |
|---|---|---|
| committer | Waldemar Brodkorb <wbx@openadk.org> | 2014-07-28 15:43:59 +0200 |
| commit | 50dad34d870d75ad047f35527c118d2c76cb6907 (patch) | |
| tree | 302b325f365f251019737dcbf3a7b1b3ac26f4eb /toolchain/gcc | |
| parent | 8d848563e88c4b8f444204669a8618c3f579b30b (diff) | |
use bamboo board emulation as default, ppc 44x without FPU. networking works here.
Diffstat (limited to 'toolchain/gcc')
| -rw-r--r-- | toolchain/gcc/Makefile | 3 | ||||
| -rw-r--r-- | toolchain/gcc/patches/4.8.3/uclibc-cmath.ppc | 1878 |
2 files changed, 1881 insertions, 0 deletions
diff --git a/toolchain/gcc/Makefile b/toolchain/gcc/Makefile index 7dcf79e0a..cdf9221fa 100644 --- a/toolchain/gcc/Makefile +++ b/toolchain/gcc/Makefile @@ -99,6 +99,9 @@ endif ifeq ($(ADK_LINUX_PPC),y) GCC_CONFOPTS+= --with-long-double-64 --enable-secureplt +ifneq ($(ADK_TARGET_CPU_WITH_FPU),y) +GCC_CONFOPTS+= --with-float=soft +endif endif ifeq ($(ADK_TARGET_ARCH),arm) diff --git a/toolchain/gcc/patches/4.8.3/uclibc-cmath.ppc b/toolchain/gcc/patches/4.8.3/uclibc-cmath.ppc new file mode 100644 index 000000000..81bd123fc --- /dev/null +++ b/toolchain/gcc/patches/4.8.3/uclibc-cmath.ppc @@ -0,0 +1,1878 @@ +diff -Nur gcc-4.8.3.orig/libstdc++-v3/include/c_global/cmath gcc-4.8.3/libstdc++-v3/include/c_global/cmath +--- gcc-4.8.3.orig/libstdc++-v3/include/c_global/cmath 2013-02-03 18:54:05.000000000 +0100 ++++ gcc-4.8.3/libstdc++-v3/include/c_global/cmath 2014-07-27 07:24:43.600272987 +0200 +@@ -1040,143 +1040,213 @@ + // functions + using ::acosh; + using ::acoshf; ++#ifdef __LONG_DOUBLE_128__ + using ::acoshl; ++#endif + + using ::asinh; + using ::asinhf; ++#ifdef __LONG_DOUBLE_128__ + using ::asinhl; ++#endif + + using ::atanh; + using ::atanhf; ++#ifdef __LONG_DOUBLE_128__ + using ::atanhl; ++#endif + + using ::cbrt; + using ::cbrtf; ++#ifdef __LONG_DOUBLE_128__ + using ::cbrtl; ++#endif + + using ::copysign; + using ::copysignf; ++#ifdef __LONG_DOUBLE_128__ + using ::copysignl; ++#endif + + using ::erf; + using ::erff; ++#ifdef __LONG_DOUBLE_128__ + using ::erfl; ++#endif + + using ::erfc; + using ::erfcf; ++#ifdef __LONG_DOUBLE_128__ + using ::erfcl; ++#endif + + using ::exp2; + using ::exp2f; ++#ifdef __LONG_DOUBLE_128__ + using ::exp2l; ++#endif + + using ::expm1; + using ::expm1f; ++#ifdef __LONG_DOUBLE_128__ + using ::expm1l; ++#endif + + using ::fdim; + using ::fdimf; ++#ifdef __LONG_DOUBLE_128__ + using ::fdiml; ++#endif + + using ::fma; + using ::fmaf; ++#ifdef __LONG_DOUBLE_128__ + using ::fmal; ++#endif + + using ::fmax; + using ::fmaxf; ++#ifdef __LONG_DOUBLE_128__ + using ::fmaxl; ++#endif + + using ::fmin; + using ::fminf; ++#ifdef __LONG_DOUBLE_128__ + using ::fminl; ++#endif + + using ::hypot; + using ::hypotf; ++#ifdef __LONG_DOUBLE_128__ + using ::hypotl; ++#endif + + using ::ilogb; + using ::ilogbf; ++#ifdef __LONG_DOUBLE_128__ + using ::ilogbl; ++#endif + + using ::lgamma; + using ::lgammaf; ++#ifdef __LONG_DOUBLE_128__ + using ::lgammal; ++#endif + + using ::llrint; + using ::llrintf; ++#ifdef __LONG_DOUBLE_128__ + using ::llrintl; ++#endif + + using ::llround; + using ::llroundf; ++#ifdef __LONG_DOUBLE_128__ + using ::llroundl; ++#endif + + using ::log1p; + using ::log1pf; ++#ifdef __LONG_DOUBLE_128__ + using ::log1pl; ++#endif + + using ::log2; + using ::log2f; ++#ifdef __LONG_DOUBLE_128__ + using ::log2l; ++#endif + + using ::logb; + using ::logbf; ++#ifdef __LONG_DOUBLE_128__ + using ::logbl; ++#endif + + using ::lrint; + using ::lrintf; ++#ifdef __LONG_DOUBLE_128__ + using ::lrintl; ++#endif + + using ::lround; + using ::lroundf; ++#ifdef __LONG_DOUBLE_128__ + using ::lroundl; ++#endif + + using ::nan; + using ::nanf; ++#ifdef __LONG_DOUBLE_128__ + using ::nanl; ++#endif + + using ::nearbyint; + using ::nearbyintf; ++#ifdef __LONG_DOUBLE_128__ + using ::nearbyintl; ++#endif + + using ::nextafter; + using ::nextafterf; ++#ifdef __LONG_DOUBLE_128__ + using ::nextafterl; ++#endif + + using ::nexttoward; + using ::nexttowardf; ++#ifdef __LONG_DOUBLE_128__ + using ::nexttowardl; ++#endif + + using ::remainder; + using ::remainderf; ++#ifdef __LONG_DOUBLE_128__ + using ::remainderl; ++#endif + + using ::remquo; + using ::remquof; ++#ifdef __LONG_DOUBLE_128__ + using ::remquol; ++#endif + + using ::rint; + using ::rintf; ++#ifdef __LONG_DOUBLE_128__ + using ::rintl; ++#endif + + using ::round; + using ::roundf; ++#ifdef __LONG_DOUBLE_128__ + using ::roundl; ++#endif + + using ::scalbln; + using ::scalblnf; ++#ifdef __LONG_DOUBLE_128__ + using ::scalblnl; ++#endif + + using ::scalbn; + using ::scalbnf; ++#ifdef __LONG_DOUBLE_128__ + using ::scalbnl; ++#endif + + using ::tgamma; + using ::tgammaf; ++#ifdef __LONG_DOUBLE_128__ + using ::tgammal; ++#endif + + using ::trunc; + using ::truncf; ++#ifdef __LONG_DOUBLE_128__ + using ::truncl; ++#endif + + /// Additional overloads. + constexpr float +diff -Nur gcc-4.8.3.orig/libstdc++-v3/include/tr1/cmath gcc-4.8.3/libstdc++-v3/include/tr1/cmath +--- gcc-4.8.3.orig/libstdc++-v3/include/tr1/cmath 2013-02-03 18:54:05.000000000 +0100 ++++ gcc-4.8.3/libstdc++-v3/include/tr1/cmath 2014-07-26 12:58:43.652151897 +0200 +@@ -158,143 +158,213 @@ + // functions + using ::acosh; + using ::acoshf; ++#ifdef __LONG_DOUBLE_128__ + using ::acoshl; ++#endif + + using ::asinh; + using ::asinhf; ++#ifdef __LONG_DOUBLE_128__ + using ::asinhl; ++#endif + + using ::atanh; + using ::atanhf; ++#ifdef __LONG_DOUBLE_128__ + using ::atanhl; ++#endif + + using ::cbrt; + using ::cbrtf; ++#ifdef __LONG_DOUBLE_128__ + using ::cbrtl; ++#endif + + using ::copysign; + using ::copysignf; ++#ifdef __LONG_DOUBLE_128__ + using ::copysignl; ++#endif + + using ::erf; + using ::erff; ++#ifdef __LONG_DOUBLE_128__ + using ::erfl; ++#endif + + using ::erfc; + using ::erfcf; ++#ifdef __LONG_DOUBLE_128__ + using ::erfcl; ++#endif + + using ::exp2; + using ::exp2f; ++#ifdef __LONG_DOUBLE_128__ + using ::exp2l; ++#endif + + using ::expm1; + using ::expm1f; ++#ifdef __LONG_DOUBLE_128__ + using ::expm1l; ++#endif + + using ::fdim; + using ::fdimf; ++#ifdef __LONG_DOUBLE_128__ + using ::fdiml; ++#endif + + using ::fma; + using ::fmaf; ++#ifdef __LONG_DOUBLE_128__ + using ::fmal; ++#endif + + using ::fmax; + using ::fmaxf; ++#ifdef __LONG_DOUBLE_128__ + using ::fmaxl; ++#endif + + using ::fmin; + using ::fminf; ++#ifdef __LONG_DOUBLE_128__ + using ::fminl; ++#endif + + using ::hypot; + using ::hypotf; ++#ifdef __LONG_DOUBLE_128__ + using ::hypotl; ++#endif + + using ::ilogb; + using ::ilogbf; ++#ifdef __LONG_DOUBLE_128__ + using ::ilogbl; ++#endif + + using ::lgamma; + using ::lgammaf; ++#ifdef __LONG_DOUBLE_128__ + using ::lgammal; ++#endif + + using ::llrint; + using ::llrintf; ++#ifdef __LONG_DOUBLE_128__ + using ::llrintl; ++#endif + + using ::llround; + using ::llroundf; ++#ifdef __LONG_DOUBLE_128__ + using ::llroundl; ++#endif + + using ::log1p; + using ::log1pf; ++#ifdef __LONG_DOUBLE_128__ + using ::log1pl; ++#endif + + using ::log2; + using ::log2f; ++#ifdef __LONG_DOUBLE_128__ + using ::log2l; ++#endif + + using ::logb; + using ::logbf; ++#ifdef __LONG_DOUBLE_128__ + using ::logbl; ++#endif + + using ::lrint; + using ::lrintf; ++#ifdef __LONG_DOUBLE_128__ + using ::lrintl; ++#endif + + using ::lround; + using ::lroundf; ++#ifdef __LONG_DOUBLE_128__ + using ::lroundl; ++#endif + + using ::nan; + using ::nanf; ++#ifdef __LONG_DOUBLE_128__ + using ::nanl; ++#endif + + using ::nearbyint; + using ::nearbyintf; ++#ifdef __LONG_DOUBLE_128__ + using ::nearbyintl; ++#endif + + using ::nextafter; + using ::nextafterf; ++#ifdef __LONG_DOUBLE_128__ + using ::nextafterl; ++#endif + + using ::nexttoward; + using ::nexttowardf; ++#ifdef __LONG_DOUBLE_128__ + using ::nexttowardl; ++#endif + + using ::remainder; + using ::remainderf; ++#ifdef __LONG_DOUBLE_128__ + using ::remainderl; ++#endif + + using ::remquo; + using ::remquof; ++#ifdef __LONG_DOUBLE_128__ + using ::remquol; ++#endif + + using ::rint; + using ::rintf; ++#ifdef __LONG_DOUBLE_128__ + using ::rintl; ++#endif + + using ::round; + using ::roundf; ++#ifdef __LONG_DOUBLE_128__ + using ::roundl; ++#endif + + using ::scalbln; + using ::scalblnf; ++#ifdef __LONG_DOUBLE_128__ + using ::scalblnl; ++#endif + + using ::scalbn; + using ::scalbnf; ++#ifdef __LONG_DOUBLE_128__ + using ::scalbnl; ++#endif + + using ::tgamma; + using ::tgammaf; ++#ifdef __LONG_DOUBLE_128__ + using ::tgammal; ++#endif + + using ::trunc; + using ::truncf; ++#ifdef __LONG_DOUBLE_128__ + using ::truncl; ++#endif + + #endif + +diff -Nur gcc-4.8.3.orig/libstdc++-v3/include/tr1/cmath.orig gcc-4.8.3/libstdc++-v3/include/tr1/cmath.orig +--- gcc-4.8.3.orig/libstdc++-v3/include/tr1/cmath.orig 1970-01-01 01:00:00.000000000 +0100 ++++ gcc-4.8.3/libstdc++-v3/include/tr1/cmath.orig 2013-02-03 18:54:05.000000000 +0100 +@@ -0,0 +1,1440 @@ ++// TR1 cmath -*- C++ -*- ++ ++// Copyright (C) 2006-2013 Free Software Foundation, Inc. ++// ++// This file is part of the GNU ISO C++ Library. This library is free ++// software; you can redistribute it and/or modify it under the ++// terms of the GNU General Public License as published by the ++// Free Software Foundation; either version 3, or (at your option) ++// any later version. ++ ++// This library is distributed in the hope that it will be useful, ++// but WITHOUT ANY WARRANTY; without even the implied warranty of ++// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++// GNU General Public License for more details. ++ ++// Under Section 7 of GPL version 3, you are granted additional ++// permissions described in the GCC Runtime Library Exception, version ++// 3.1, as published by the Free Software Foundation. ++ ++// You should have received a copy of the GNU General Public License and ++// a copy of the GCC Runtime Library Exception along with this program; ++// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see ++// <http://www.gnu.org/licenses/>. ++ ++/** @file tr1/cmath ++ * This is a TR1 C++ Library header. ++ */ ++ ++#ifndef _GLIBCXX_TR1_CMATH ++#define _GLIBCXX_TR1_CMATH 1 ++ ++#pragma GCC system_header ++ ++#include <cmath> ++ ++#ifdef _GLIBCXX_USE_C99_MATH_TR1 ++ ++#undef acosh ++#undef acoshf ++#undef acoshl ++#undef asinh ++#undef asinhf ++#undef asinhl ++#undef atanh ++#undef atanhf ++#undef atanhl ++#undef cbrt ++#undef cbrtf ++#undef cbrtl ++#undef copysign ++#undef copysignf ++#undef copysignl ++#undef erf ++#undef erff ++#undef erfl ++#undef erfc ++#undef erfcf ++#undef erfcl ++#undef exp2 ++#undef exp2f ++#undef exp2l ++#undef expm1 ++#undef expm1f ++#undef expm1l ++#undef fdim ++#undef fdimf ++#undef fdiml ++#undef fma ++#undef fmaf ++#undef fmal ++#undef fmax ++#undef fmaxf ++#undef fmaxl ++#undef fmin ++#undef fminf ++#undef fminl ++#undef hypot ++#undef hypotf ++#undef hypotl ++#undef ilogb ++#undef ilogbf ++#undef ilogbl ++#undef lgamma ++#undef lgammaf ++#undef lgammal ++#undef llrint ++#undef llrintf ++#undef llrintl ++#undef llround ++#undef llroundf ++#undef llroundl ++#undef log1p ++#undef log1pf ++#undef log1pl ++#undef log2 ++#undef log2f ++#undef log2l ++#undef logb ++#undef logbf ++#undef logbl ++#undef lrint ++#undef lrintf ++#undef lrintl ++#undef lround ++#undef lroundf ++#undef lroundl ++#undef nan ++#undef nanf ++#undef nanl ++#undef nearbyint ++#undef nearbyintf ++#undef nearbyintl ++#undef nextafter ++#undef nextafterf ++#undef nextafterl ++#undef nexttoward ++#undef nexttowardf ++#undef nexttowardl ++#undef remainder ++#undef remainderf ++#undef remainderl ++#undef remquo ++#undef remquof ++#undef remquol ++#undef rint ++#undef rintf ++#undef rintl ++#undef round ++#undef roundf ++#undef roundl ++#undef scalbln ++#undef scalblnf ++#undef scalblnl ++#undef scalbn ++#undef scalbnf ++#undef scalbnl ++#undef tgamma ++#undef tgammaf ++#undef tgammal ++#undef trunc ++#undef truncf ++#undef truncl ++ ++#endif ++ ++namespace std _GLIBCXX_VISIBILITY(default) ++{ ++namespace tr1 ++{ ++_GLIBCXX_BEGIN_NAMESPACE_VERSION ++ ++#if _GLIBCXX_USE_C99_MATH_TR1 ++ ++ // types ++ using ::double_t; ++ using ::float_t; ++ ++ // functions ++ using ::acosh; ++ using ::acoshf; ++ using ::acoshl; ++ ++ using ::asinh; ++ using ::asinhf; ++ using ::asinhl; ++ ++ using ::atanh; ++ using ::atanhf; ++ using ::atanhl; ++ ++ using ::cbrt; ++ using ::cbrtf; ++ using ::cbrtl; ++ ++ using ::copysign; ++ using ::copysignf; ++ using ::copysignl; ++ ++ using ::erf; ++ using ::erff; ++ using ::erfl; ++ ++ using ::erfc; ++ using ::erfcf; ++ using ::erfcl; ++ ++ using ::exp2; ++ using ::exp2f; ++ using ::exp2l; ++ ++ using ::expm1; ++ using ::expm1f; ++ using ::expm1l; ++ ++ using ::fdim; ++ using ::fdimf; ++ using ::fdiml; ++ ++ using ::fma; ++ using ::fmaf; ++ using ::fmal; ++ ++ using ::fmax; ++ using ::fmaxf; ++ using ::fmaxl; ++ ++ using ::fmin; ++ using ::fminf; ++ using ::fminl; ++ ++ using ::hypot; ++ using ::hypotf; ++ using ::hypotl; ++ ++ using ::ilogb; ++ using ::ilogbf; ++ using ::ilogbl; ++ ++ using ::lgamma; ++ using ::lgammaf; ++ using ::lgammal; ++ ++ using ::llrint; ++ using ::llrintf; ++ using ::llrintl; ++ ++ using ::llround; ++ using ::llroundf; ++ using ::llroundl; ++ ++ using ::log1p; ++ using ::log1pf; ++ using ::log1pl; ++ ++ using ::log2; ++ using ::log2f; ++ using ::log2l; ++ ++ using ::logb; ++ using ::logbf; ++ using ::logbl; ++ ++ using ::lrint; ++ using ::lrintf; ++ using ::lrintl; ++ ++ using ::lround; ++ using ::lroundf; ++ using ::lroundl; ++ ++ using ::nan; ++ using ::nanf; ++ using ::nanl; ++ ++ using ::nearbyint; ++ using ::nearbyintf; ++ using ::nearbyintl; ++ ++ using ::nextafter; ++ using ::nextafterf; ++ using ::nextafterl; ++ ++ using ::nexttoward; ++ using ::nexttowardf; ++ using ::nexttowardl; ++ ++ using ::remainder; ++ using ::remainderf; ++ using ::remainderl; ++ ++ using ::remquo; ++ using ::remquof; ++ using ::remquol; ++ ++ using ::rint; ++ using ::rintf; ++ using ::rintl; ++ ++ using ::round; ++ using ::roundf; ++ using ::roundl; ++ ++ using ::scalbln; ++ using ::scalblnf; ++ using ::scalblnl; ++ ++ using ::scalbn; ++ using ::scalbnf; ++ using ::scalbnl; ++ ++ using ::tgamma; ++ using ::tgammaf; ++ using ::tgammal; ++ ++ using ::trunc; ++ using ::truncf; ++ using ::truncl; ++ ++#endif ++ ++#if _GLIBCXX_USE_C99_MATH ++#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC ++ ++ /// Function template definitions [8.16.3]. ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ fpclassify(_Tp __f) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, ++ FP_SUBNORMAL, FP_ZERO, __type(__f)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ isfinite(_Tp __f) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_isfinite(__type(__f)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ isinf(_Tp __f) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_isinf(__type(__f)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ isnan(_Tp __f) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_isnan(__type(__f)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ isnormal(_Tp __f) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_isnormal(__type(__f)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ signbit(_Tp __f) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_signbit(__type(__f)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ isgreater(_Tp __f1, _Tp __f2) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_isgreater(__type(__f1), __type(__f2)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ isgreaterequal(_Tp __f1, _Tp __f2) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_isgreaterequal(__type(__f1), __type(__f2)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ isless(_Tp __f1, _Tp __f2) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_isless(__type(__f1), __type(__f2)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ islessequal(_Tp __f1, _Tp __f2) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_islessequal(__type(__f1), __type(__f2)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ islessgreater(_Tp __f1, _Tp __f2) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_islessgreater(__type(__f1), __type(__f2)); ++ } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, ++ int>::__type ++ isunordered(_Tp __f1, _Tp __f2) ++ { ++ typedef typename __gnu_cxx::__promote<_Tp>::__type __type; ++ return __builtin_isunordered(__type(__f1), __type(__f2)); ++ } ++ ++#endif ++#endif ++ ++#if _GLIBCXX_USE_C99_MATH_TR1 ++ ++ /// Additional overloads [8.16.4]. ++ using std::acos; ++ ++ inline float ++ acosh(float __x) ++ { return __builtin_acoshf(__x); } ++ ++ inline long double ++ acosh(long double __x) ++ { return __builtin_acoshl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ acosh(_Tp __x) ++ { return __builtin_acosh(__x); } ++ ++ using std::asin; ++ ++ inline float ++ asinh(float __x) ++ { return __builtin_asinhf(__x); } ++ ++ inline long double ++ asinh(long double __x) ++ { return __builtin_asinhl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ asinh(_Tp __x) ++ { return __builtin_asinh(__x); } ++ ++ using std::atan; ++ using std::atan2; ++ ++ inline float ++ atanh(float __x) ++ { return __builtin_atanhf(__x); } ++ ++ inline long double ++ atanh(long double __x) ++ { return __builtin_atanhl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ atanh(_Tp __x) ++ { return __builtin_atanh(__x); } ++ ++ inline float ++ cbrt(float __x) ++ { return __builtin_cbrtf(__x); } ++ ++ inline long double ++ cbrt(long double __x) ++ { return __builtin_cbrtl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ cbrt(_Tp __x) ++ { return __builtin_cbrt(__x); } ++ ++ using std::ceil; ++ ++ inline float ++ copysign(float __x, float __y) ++ { return __builtin_copysignf(__x, __y); } ++ ++ inline long double ++ copysign(long double __x, long double __y) ++ { return __builtin_copysignl(__x, __y); } ++ ++ template<typename _Tp, typename _Up> ++ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type ++ copysign(_Tp __x, _Up __y) ++ { ++ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; ++ return copysign(__type(__x), __type(__y)); ++ } ++ ++ using std::cos; ++ using std::cosh; ++ ++ inline float ++ erf(float __x) ++ { return __builtin_erff(__x); } ++ ++ inline long double ++ erf(long double __x) ++ { return __builtin_erfl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ erf(_Tp __x) ++ { return __builtin_erf(__x); } ++ ++ inline float ++ erfc(float __x) ++ { return __builtin_erfcf(__x); } ++ ++ inline long double ++ erfc(long double __x) ++ { return __builtin_erfcl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ erfc(_Tp __x) ++ { return __builtin_erfc(__x); } ++ ++ using std::exp; ++ ++ inline float ++ exp2(float __x) ++ { return __builtin_exp2f(__x); } ++ ++ inline long double ++ exp2(long double __x) ++ { return __builtin_exp2l(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ exp2(_Tp __x) ++ { return __builtin_exp2(__x); } ++ ++ inline float ++ expm1(float __x) ++ { return __builtin_expm1f(__x); } ++ ++ inline long double ++ expm1(long double __x) ++ { return __builtin_expm1l(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ expm1(_Tp __x) ++ { return __builtin_expm1(__x); } ++ ++ // Note: we deal with fabs in a special way, because an using std::fabs ++ // would bring in also the overloads for complex types, which in C++0x ++ // mode have a different return type. ++ // With __CORRECT_ISO_CPP_MATH_H_PROTO, math.h imports std::fabs in the ++ // global namespace after the declarations of the float / double / long ++ // double overloads but before the std::complex overloads. ++ using ::fabs; ++ ++#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO ++ inline float ++ fabs(float __x) ++ { return __builtin_fabsf(__x); } ++ ++ inline long double ++ fabs(long double __x) ++ { return __builtin_fabsl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ fabs(_Tp __x) ++ { return __builtin_fabs(__x); } ++#endif ++ ++ inline float ++ fdim(float __x, float __y) ++ { return __builtin_fdimf(__x, __y); } ++ ++ inline long double ++ fdim(long double __x, long double __y) ++ { return __builtin_fdiml(__x, __y); } ++ ++ template<typename _Tp, typename _Up> ++ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type ++ fdim(_Tp __x, _Up __y) ++ { ++ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; ++ return fdim(__type(__x), __type(__y)); ++ } ++ ++ using std::floor; ++ ++ inline float ++ fma(float __x, float __y, float __z) ++ { return __builtin_fmaf(__x, __y, __z); } ++ ++ inline long double ++ fma(long double __x, long double __y, long double __z) ++ { return __builtin_fmal(__x, __y, __z); } ++ ++ template<typename _Tp, typename _Up, typename _Vp> ++ inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type ++ fma(_Tp __x, _Up __y, _Vp __z) ++ { ++ typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; ++ return fma(__type(__x), __type(__y), __type(__z)); ++ } ++ ++ inline float ++ fmax(float __x, float __y) ++ { return __builtin_fmaxf(__x, __y); } ++ ++ inline long double ++ fmax(long double __x, long double __y) ++ { return __builtin_fmaxl(__x, __y); } ++ ++ template<typename _Tp, typename _Up> ++ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type ++ fmax(_Tp __x, _Up __y) ++ { ++ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; ++ return fmax(__type(__x), __type(__y)); ++ } ++ ++ inline float ++ fmin(float __x, float __y) ++ { return __builtin_fminf(__x, __y); } ++ ++ inline long double ++ fmin(long double __x, long double __y) ++ { return __builtin_fminl(__x, __y); } ++ ++ template<typename _Tp, typename _Up> ++ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type ++ fmin(_Tp __x, _Up __y) ++ { ++ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; ++ return fmin(__type(__x), __type(__y)); ++ } ++ ++ using std::fmod; ++ using std::frexp; ++ ++ inline float ++ hypot(float __x, float __y) ++ { return __builtin_hypotf(__x, __y); } ++ ++ inline long double ++ hypot(long double __x, long double __y) ++ { return __builtin_hypotl(__x, __y); } ++ ++ template<typename _Tp, typename _Up> ++ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type ++ hypot(_Tp __y, _Up __x) ++ { ++ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; ++ return hypot(__type(__y), __type(__x)); ++ } ++ ++ inline int ++ ilogb(float __x) ++ { return __builtin_ilogbf(__x); } ++ ++ inline int ++ ilogb(long double __x) ++ { return __builtin_ilogbl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ int>::__type ++ ilogb(_Tp __x) ++ { return __builtin_ilogb(__x); } ++ ++ using std::ldexp; ++ ++ inline float ++ lgamma(float __x) ++ { return __builtin_lgammaf(__x); } ++ ++ inline long double ++ lgamma(long double __x) ++ { return __builtin_lgammal(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ lgamma(_Tp __x) ++ { return __builtin_lgamma(__x); } ++ ++ inline long long ++ llrint(float __x) ++ { return __builtin_llrintf(__x); } ++ ++ inline long long ++ llrint(long double __x) ++ { return __builtin_llrintl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ long long>::__type ++ llrint(_Tp __x) ++ { return __builtin_llrint(__x); } ++ ++ inline long long ++ llround(float __x) ++ { return __builtin_llroundf(__x); } ++ ++ inline long long ++ llround(long double __x) ++ { return __builtin_llroundl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ long long>::__type ++ llround(_Tp __x) ++ { return __builtin_llround(__x); } ++ ++ using std::log; ++ using std::log10; ++ ++ inline float ++ log1p(float __x) ++ { return __builtin_log1pf(__x); } ++ ++ inline long double ++ log1p(long double __x) ++ { return __builtin_log1pl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ log1p(_Tp __x) ++ { return __builtin_log1p(__x); } ++ ++ // DR 568. ++ inline float ++ log2(float __x) ++ { return __builtin_log2f(__x); } ++ ++ inline long double ++ log2(long double __x) ++ { return __builtin_log2l(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ log2(_Tp __x) ++ { return __builtin_log2(__x); } ++ ++ inline float ++ logb(float __x) ++ { return __builtin_logbf(__x); } ++ ++ inline long double ++ logb(long double __x) ++ { return __builtin_logbl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ logb(_Tp __x) ++ { ++ return __builtin_logb(__x); ++ } ++ ++ inline long ++ lrint(float __x) ++ { return __builtin_lrintf(__x); } ++ ++ inline long ++ lrint(long double __x) ++ { return __builtin_lrintl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ long>::__type ++ lrint(_Tp __x) ++ { return __builtin_lrint(__x); } ++ ++ inline long ++ lround(float __x) ++ { return __builtin_lroundf(__x); } ++ ++ inline long ++ lround(long double __x) ++ { return __builtin_lroundl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ long>::__type ++ lround(_Tp __x) ++ { return __builtin_lround(__x); } ++ ++ inline float ++ nearbyint(float __x) ++ { return __builtin_nearbyintf(__x); } ++ ++ inline long double ++ nearbyint(long double __x) ++ { return __builtin_nearbyintl(__x); } ++ ++ template<typename _Tp> ++ inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, ++ double>::__type ++ nearbyint(_Tp __x) ++ { return __builtin_nearbyint(__x); } ++ ++ inline float ++ nextafter(float __x, float __y) ++ { return __builtin_nextafterf(__x, __y); } ++ ++ inline long double ++ nextafter(long double __x, long double __y) ++ { return __builtin_nextafterl(__x, __y); } ++ ++ template<typename _Tp, typename _Up> ++ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type ++ nextafter(_Tp __x, _Up __y) ++ { ++ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; ++ return nextafter(__type(__x), __type(__y)); ++ } ++ ++ inline float ++ nexttoward(float __x, long double __y) ++ |