From 3577e3eafb31634991312288e56581ba021f5b58 Mon Sep 17 00:00:00 2001 From: Paolo Carlini Date: Tue, 7 Mar 2006 16:53:44 +0000 Subject: [PATCH] cmath: Add C99 overloads. 2006-03-07 Paolo Carlini * include/tr1/cmath: Add C99 overloads. * include/tr1/common.h (struct __promote_3): Add. * testsuite/tr1/8_c_compatibility/cmath/overloads.cc: New. * testsuite/tr1/8_c_compatibility/cmath/functions.cc: Tweak. * testsuite/tr1/8_c_compatibility/complex/overloads_float.cc: Likewise. From-SVN: r111813 --- libstdc++-v3/ChangeLog | 9 + libstdc++-v3/include/tr1/cmath | 551 ++++++++++++++++++ libstdc++-v3/include/tr1/common.h | 20 +- .../tr1/8_c_compatibility/cmath/functions.cc | 4 +- .../tr1/8_c_compatibility/cmath/overloads.cc | 241 ++++++++ .../complex/overloads_float.cc | 8 +- 6 files changed, 821 insertions(+), 12 deletions(-) create mode 100644 libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/overloads.cc diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 09f6ca1a6253..e6a19380c041 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,12 @@ +2006-03-07 Paolo Carlini + + * include/tr1/cmath: Add C99 overloads. + * include/tr1/common.h (struct __promote_3): Add. + * testsuite/tr1/8_c_compatibility/cmath/overloads.cc: New. + + * testsuite/tr1/8_c_compatibility/cmath/functions.cc: Tweak. + * testsuite/tr1/8_c_compatibility/complex/overloads_float.cc: Likewise. + 2006-03-06 Paolo Carlini PR target/26532 diff --git a/libstdc++-v3/include/tr1/cmath b/libstdc++-v3/include/tr1/cmath index 3549868cd4d9..0bde0570175e 100644 --- a/libstdc++-v3/include/tr1/cmath +++ b/libstdc++-v3/include/tr1/cmath @@ -36,6 +36,7 @@ #include #include +#include #if _GLIBCXX_USE_C99_MATH_TR1 @@ -320,6 +321,556 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1) #endif #endif +#if _GLIBCXX_USE_C99_MATH_TR1 + + /// @brief Additional overloads [8.16.4]. + // + inline float + acosh(float __x) + { return __builtin_acoshf(__x); } + + inline long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + template + inline typename __promote<_Tp>::__type + acosh(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return acosh(__type(__x)); + } + + inline float + asinh(float __x) + { return __builtin_asinhf(__x); } + + inline long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + template + inline typename __promote<_Tp>::__type + asinh(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return asinh(__type(__x)); + } + + inline float + atanh(float __x) + { return __builtin_atanhf(__x); } + + inline long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + template + inline typename __promote<_Tp>::__type + atanh(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return atanh(__type(__x)); + } + + inline float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + inline long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + template + inline typename __promote<_Tp>::__type + cbrt(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return cbrt(__type(__x)); + } + + 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 + inline typename __promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + inline float + erf(float __x) + { return __builtin_erff(__x); } + + inline long double + erf(long double __x) + { return __builtin_erfl(__x); } + + template + inline typename __promote<_Tp>::__type + erf(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return erf(__type(__x)); + } + + inline float + erfc(float __x) + { return __builtin_erfcf(__x); } + + inline long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + template + inline typename __promote<_Tp>::__type + erfc(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return erfc(__type(__x)); + } + + inline float + exp2(float __x) + { return __builtin_exp2f(__x); } + + inline long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + template + inline typename __promote<_Tp>::__type + exp2(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return exp2(__type(__x)); + } + + inline float + expm1(float __x) + { return __builtin_expm1f(__x); } + + inline long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + template + inline typename __promote<_Tp>::__type + expm1(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return expm1(__type(__x)); + } + + 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 + inline typename __promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + 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 + inline typename __promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __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 + inline typename __promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __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 + inline typename __promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + 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 + inline typename __promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + inline int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + inline int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + template + inline int + ilogb(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return ilogb(__type(__x)); + } + + inline float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + inline long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + template + inline typename __promote<_Tp>::__type + lgamma(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return lgamma(__type(__x)); + } + + inline long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + inline long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + template + inline long long + llrint(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return llrint(__type(__x)); + } + + inline long long + llround(float __x) + { return __builtin_llroundf(__x); } + + inline long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + template + inline long long + llround(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return llround(__type(__x)); + } + + inline float + log1p(float __x) + { return __builtin_log1pf(__x); } + + inline long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + template + inline typename __promote<_Tp>::__type + log1p(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return log1p(__type(__x)); + } + + inline float + log2(float __x) + { return __builtin_log2f(__x); } + + inline long double + log2(long double __x) + { return __builtin_log2l(__x); } + + template + inline typename __promote<_Tp>::__type + log2(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return log2(__type(__x)); + } + + inline float + logb(float __x) + { return __builtin_logbf(__x); } + + inline long double + logb(long double __x) + { return __builtin_logbl(__x); } + + template + inline typename __promote<_Tp>::__type + logb(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return logb(__type(__x)); + } + + inline long + lrint(float __x) + { return __builtin_lrintf(__x); } + + inline long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + template + inline long + lrint(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return lrint(__type(__x)); + } + + inline long + lround(float __x) + { return __builtin_lroundf(__x); } + + inline long + lround(long double __x) + { return __builtin_lroundl(__x); } + + template + inline long + lround(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return lround(__type(__x)); + } + + inline float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + inline long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + template + inline typename __promote<_Tp>::__type + nearbyint(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return nearbyint(__type(__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 + inline typename __promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + inline float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + inline long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + template + inline typename __promote<_Tp>::__type + nexttoward(_Tp __x, long double __y) + { + typedef typename __promote<_Tp>::__type __type; + return nexttoward(__type(__x), __y); + } + + inline float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + inline long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + template + inline typename __promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + template + inline typename __promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + inline float + rint(float __x) + { return __builtin_rintf(__x); } + + inline long double + rint(long double __x) + { return __builtin_rintl(__x); } + + template + inline typename __promote<_Tp>::__type + rint(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return rint(__type(__x)); + } + + inline float + round(float __x) + { return __builtin_roundf(__x); } + + inline long double + round(long double __x) + { return __builtin_roundl(__x); } + + template + inline typename __promote<_Tp>::__type + round(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return round(__type(__x)); + } + + inline float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + inline long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + template + inline typename __promote<_Tp>::__type + scalbln(_Tp __x, long __ex) + { + typedef typename __promote<_Tp>::__type __type; + return scalbln(__type(__x), __ex); + } + + inline float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + inline long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + template + inline typename __promote<_Tp>::__type + scalbn(_Tp __x, int __ex) + { + typedef typename __promote<_Tp>::__type __type; + return scalbn(__type(__x), __ex); + } + + inline float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + inline long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + template + inline typename __promote<_Tp>::__type + tgamma(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return tgamma(__type(__x)); + } + + inline float + trunc(float __x) + { return __builtin_truncf(__x); } + + inline long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + template + inline typename __promote<_Tp>::__type + trunc(_Tp __x) + { + typedef typename __promote<_Tp>::__type __type; + return trunc(__type(__x)); + } + +#endif + _GLIBCXX_END_NAMESPACE } diff --git a/libstdc++-v3/include/tr1/common.h b/libstdc++-v3/include/tr1/common.h index ca9559e463a6..1548af02efc5 100644 --- a/libstdc++-v3/include/tr1/common.h +++ b/libstdc++-v3/include/tr1/common.h @@ -49,15 +49,27 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1) struct __promote<_Tp, false> { typedef _Tp __type; }; - template + template struct __promote_2 { private: typedef typename __promote<_Tp>::__type __type1; - typedef typename __promote<_Up>::__type __type2; - + typedef typename __promote<_Up>::__type __type2; + + public: + typedef __typeof__(__type1() + __type2()) __type; + }; + + template + struct __promote_3 + { + private: + typedef typename __promote<_Tp>::__type __type1; + typedef typename __promote<_Up>::__type __type2; + typedef typename __promote<_Vp>::__type __type3; + public: - typedef __typeof__(__type1() + __type2()) __type; + typedef __typeof__(__type1() + __type2() + __type3()) __type; }; _GLIBCXX_END_NAMESPACE diff --git a/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/functions.cc b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/functions.cc index f97cd8a7dd98..a0949fad088c 100644 --- a/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/functions.cc +++ b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/functions.cc @@ -147,8 +147,8 @@ void test01() fret = nextafterf(f0, f0); ldret = nextafterl(ld0, ld0); - ret = nexttoward(d0, d0); - fret = nexttowardf(f0, f0); + ret = nexttoward(d0, ld0); + fret = nexttowardf(f0, ld0); ldret = nexttowardl(ld0, ld0); ret = remainder(d0, d0); diff --git a/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/overloads.cc b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/overloads.cc new file mode 100644 index 000000000000..e54a8e322de2 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/overloads.cc @@ -0,0 +1,241 @@ +// { dg-do compile } + +// 2006-03-07 Paolo Carlini +// +// Copyright (C) 2006 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 2, 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. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// 8.16.4 Additional overloads + +#include +#include + +void test01() +{ +#if _GLIBCXX_USE_C99_MATH_TR1 + + using namespace std::tr1; + using namespace __gnu_test; + + double d0 = 0.0; + float f0 = 0.0f; + long double ld0 = 0.0l; + int i0 = 0; + int* pquo = 0; + long lex = 0l; + int ex = 0; + + check_ret_type(acosh(d0)); + check_ret_type(acosh(f0)); + check_ret_type(acosh(ld0)); + check_ret_type(acosh(i0)); + + check_ret_type(asinh(d0)); + check_ret_type(asinh(f0)); + check_ret_type(asinh(ld0)); + check_ret_type(asinh(i0)); + + check_ret_type(atanh(d0)); + check_ret_type(atanh(f0)); + check_ret_type(atanh(ld0)); + check_ret_type(atanh(i0)); + + check_ret_type(cbrt(d0)); + check_ret_type(cbrt(f0)); + check_ret_type(cbrt(ld0)); + check_ret_type(cbrt(i0)); + + check_ret_type(copysign(d0, d0)); + check_ret_type(copysign(d0, f0)); + check_ret_type(copysign(f0, f0)); + check_ret_type(copysign(ld0, ld0)); + check_ret_type(copysign(ld0, d0)); + check_ret_type(copysign(i0, i0)); + check_ret_type(copysign(d0, i0)); + + check_ret_type(erf(d0)); + check_ret_type(erf(f0)); + check_ret_type(erf(ld0)); + check_ret_type(erf(i0)); + + check_ret_type(erfc(d0)); + check_ret_type(erfc(f0)); + check_ret_type(erfc(ld0)); + check_ret_type(erfc(i0)); + + check_ret_type(exp2(d0)); + check_ret_type(exp2(f0)); + check_ret_type(exp2(ld0)); + check_ret_type(exp2(i0)); + + check_ret_type(expm1(d0)); + check_ret_type(expm1(f0)); + check_ret_type(expm1(ld0)); + check_ret_type(expm1(i0)); + + check_ret_type(fdim(d0, d0)); + check_ret_type(fdim(d0, f0)); + check_ret_type(fdim(f0, f0)); + check_ret_type(fdim(ld0, ld0)); + check_ret_type(fdim(ld0, d0)); + check_ret_type(fdim(i0, i0)); + check_ret_type(fdim(d0, i0)); + + check_ret_type(fma(d0, d0, d0)); + check_ret_type(fma(d0, f0, d0)); + check_ret_type(fma(f0, f0, f0)); + check_ret_type(fma(ld0, ld0, ld0)); + check_ret_type(fma(ld0, d0, f0)); + check_ret_type(fma(i0, i0, i0)); + check_ret_type(fma(d0, i0, f0)); + + check_ret_type(fmax(d0, d0)); + check_ret_type(fmax(d0, f0)); + check_ret_type(fmax(f0, f0)); + check_ret_type(fmax(ld0, ld0)); + check_ret_type(fmax(ld0, d0)); + check_ret_type(fmax(i0, i0)); + check_ret_type(fmax(d0, i0)); + + check_ret_type(fmin(d0, d0)); + check_ret_type(fmin(d0, f0)); + check_ret_type(fmin(f0, f0)); + check_ret_type(fmin(ld0, ld0)); + check_ret_type(fmin(ld0, d0)); + check_ret_type(fmin(i0, i0)); + check_ret_type(fmin(d0, i0)); + + check_ret_type(hypot(d0, d0)); + check_ret_type(hypot(d0, f0)); + check_ret_type(hypot(f0, f0)); + check_ret_type(hypot(ld0, ld0)); + check_ret_type(hypot(ld0, d0)); + check_ret_type(hypot(i0, i0)); + check_ret_type(hypot(d0, i0)); + + check_ret_type(ilogb(d0)); + check_ret_type(ilogb(f0)); + check_ret_type(ilogb(ld0)); + check_ret_type(ilogb(i0)); + + check_ret_type(lgamma(d0)); + check_ret_type(lgamma(f0)); + check_ret_type(lgamma(ld0)); + check_ret_type(lgamma(i0)); + + check_ret_type(llrint(d0)); + check_ret_type(llrint(f0)); + check_ret_type(llrint(ld0)); + check_ret_type(llrint(i0)); + + check_ret_type(llround(d0)); + check_ret_type(llround(f0)); + check_ret_type(llround(ld0)); + check_ret_type(llround(i0)); + + check_ret_type(log1p(d0)); + check_ret_type(log1p(f0)); + check_ret_type(log1p(ld0)); + check_ret_type(log1p(i0)); + + check_ret_type(log2(d0)); + check_ret_type(log2(f0)); + check_ret_type(log2(ld0)); + check_ret_type(log2(i0)); + + check_ret_type(logb(d0)); + check_ret_type(logb(f0)); + check_ret_type(logb(ld0)); + check_ret_type(logb(i0)); + + check_ret_type(lrint(d0)); + check_ret_type(lrint(f0)); + check_ret_type(lrint(ld0)); + check_ret_type(lrint(i0)); + + check_ret_type(lround(d0)); + check_ret_type(lround(f0)); + check_ret_type(lround(ld0)); + check_ret_type(lround(i0)); + + check_ret_type(nearbyint(d0)); + check_ret_type(nearbyint(f0)); + check_ret_type(nearbyint(ld0)); + check_ret_type(nearbyint(i0)); + + check_ret_type(nextafter(d0, d0)); + check_ret_type(nextafter(d0, f0)); + check_ret_type(nextafter(f0, f0)); + check_ret_type(nextafter(ld0, ld0)); + check_ret_type(nextafter(ld0, d0)); + check_ret_type(nextafter(i0, i0)); + check_ret_type(nextafter(d0, i0)); + + check_ret_type(nexttoward(d0, ld0)); + check_ret_type(nexttoward(f0, ld0)); + check_ret_type(nexttoward(ld0, ld0)); + check_ret_type(nexttoward(i0, ld0)); + + check_ret_type(remainder(d0, d0)); + check_ret_type(remainder(d0, f0)); + check_ret_type(remainder(f0, f0)); + check_ret_type(remainder(ld0, ld0)); + check_ret_type(remainder(ld0, d0)); + check_ret_type(remainder(i0, i0)); + check_ret_type(remainder(d0, i0)); + + check_ret_type(remquo(d0, d0, pquo)); + check_ret_type(remquo(d0, f0, pquo)); + check_ret_type(remquo(f0, f0, pquo)); + check_ret_type(remquo(ld0, ld0, pquo)); + check_ret_type(remquo(ld0, d0, pquo)); + check_ret_type(remquo(i0, i0, pquo)); + check_ret_type(remquo(d0, i0, pquo)); + + check_ret_type(rint(d0)); + check_ret_type(rint(f0)); + check_ret_type(rint(ld0)); + check_ret_type(rint(i0)); + + check_ret_type(round(d0)); + check_ret_type(round(f0)); + check_ret_type(round(ld0)); + check_ret_type(round(i0)); + + check_ret_type(scalbln(d0, lex)); + check_ret_type(scalbln(f0, lex)); + check_ret_type(scalbln(ld0, lex)); + check_ret_type(scalbln(i0, lex)); + + check_ret_type(scalbn(d0, ex)); + check_ret_type(scalbn(f0, ex)); + check_ret_type(scalbn(ld0, ex)); + check_ret_type(scalbn(i0, ex)); + + check_ret_type(tgamma(d0)); + check_ret_type(tgamma(f0)); + check_ret_type(tgamma(ld0)); + check_ret_type(tgamma(i0)); + + check_ret_type(trunc(d0)); + check_ret_type(trunc(f0)); + check_ret_type(trunc(ld0)); + check_ret_type(trunc(i0)); + +#endif +} diff --git a/libstdc++-v3/testsuite/tr1/8_c_compatibility/complex/overloads_float.cc b/libstdc++-v3/testsuite/tr1/8_c_compatibility/complex/overloads_float.cc index d03075a6a4bd..21f2d759b990 100644 --- a/libstdc++-v3/testsuite/tr1/8_c_compatibility/complex/overloads_float.cc +++ b/libstdc++-v3/testsuite/tr1/8_c_compatibility/complex/overloads_float.cc @@ -1,3 +1,5 @@ +// { dg-do compile } + // 2006-01-12 Paolo Carlini // // Copyright (C) 2006 Free Software Foundation, Inc. @@ -101,9 +103,3 @@ void test01() check_ret_type(real(d1)); check_ret_type(real(ld1)); } - -int main() -{ - test01(); - return 0; -} -- 2.39.2