cmath: Add C99 overloads.

2006-03-07  Paolo Carlini  <pcarlini@suse.de>

	* 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

6 files changed, 821 insertions, 12 deletions

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 09f6ca1..e6a1938 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,12 @@
+2006-03-07  Paolo Carlini  <pcarlini@suse.de>
+
+	* 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  <pcarlini@suse.de>
 
 	PR target/26532
diff --git a/libstdc++-v3/include/tr1/cmath b/libstdc++-v3/include/tr1/cmath
index 3549868..0bde057 100644
--- a/libstdc++-v3/include/tr1/cmath
+++ b/libstdc++-v3/include/tr1/cmath
@@ -36,6 +36,7 @@
 
 #include <bits/c++config.h>
 #include <cmath>
+#include <tr1/common.h>
 
 #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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp, typename _Up>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp, typename _Up>
+    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<typename _Tp, typename _Up, typename _Vp>
+    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<typename _Tp, typename _Up>
+    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<typename _Tp, typename _Up>
+    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<typename _Tp, typename _Up>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp, typename _Up>
+    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<typename _Tp>
+    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<typename _Tp, typename _Up>
+    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<typename _Tp, typename _Up>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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<typename _Tp>
+    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 ca9559e..1548af0 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<typename _Tp, typename _Up> 
+  template<typename _Tp, typename _Up>
     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<typename _Tp, typename _Up, typename _Vp>
+    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 f97cd8a..a0949fa 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 0000000..e54a8e3
--- /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  <pcarlini@suse.de>
+//
+// 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 <tr1/cmath>
+#include <testsuite_tr1.h>
+
+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<double>(acosh(d0));
+  check_ret_type<float>(acosh(f0));
+  check_ret_type<long double>(acosh(ld0));
+  check_ret_type<double>(acosh(i0));
+
+  check_ret_type<double>(asinh(d0));
+  check_ret_type<float>(asinh(f0));
+  check_ret_type<long double>(asinh(ld0));
+  check_ret_type<double>(asinh(i0));
+
+  check_ret_type<double>(atanh(d0));
+  check_ret_type<float>(atanh(f0));
+  check_ret_type<long double>(atanh(ld0));
+  check_ret_type<double>(atanh(i0));
+
+  check_ret_type<double>(cbrt(d0));
+  check_ret_type<float>(cbrt(f0));
+  check_ret_type<long double>(cbrt(ld0));
+  check_ret_type<double>(cbrt(i0));
+
+  check_ret_type<double>(copysign(d0, d0));
+  check_ret_type<double>(copysign(d0, f0));
+  check_ret_type<float>(copysign(f0, f0));
+  check_ret_type<long double>(copysign(ld0, ld0));
+  check_ret_type<long double>(copysign(ld0, d0));
+  check_ret_type<double>(copysign(i0, i0));  
+  check_ret_type<double>(copysign(d0, i0));
+
+  check_ret_type<double>(erf(d0));
+  check_ret_type<float>(erf(f0));
+  check_ret_type<long double>(erf(ld0));
+  check_ret_type<double>(erf(i0));
+
+  check_ret_type<double>(erfc(d0));
+  check_ret_type<float>(erfc(f0));
+  check_ret_type<long double>(erfc(ld0));
+  check_ret_type<double>(erfc(i0));
+
+  check_ret_type<double>(exp2(d0));
+  check_ret_type<float>(exp2(f0));
+  check_ret_type<long double>(exp2(ld0));
+  check_ret_type<double>(exp2(i0));
+
+  check_ret_type<double>(expm1(d0));
+  check_ret_type<float>(expm1(f0));
+  check_ret_type<long double>(expm1(ld0));
+  check_ret_type<double>(expm1(i0));
+
+  check_ret_type<double>(fdim(d0, d0));
+  check_ret_type<double>(fdim(d0, f0));
+  check_ret_type<float>(fdim(f0, f0));
+  check_ret_type<long double>(fdim(ld0, ld0));
+  check_ret_type<long double>(fdim(ld0, d0));
+  check_ret_type<double>(fdim(i0, i0));
+  check_ret_type<double>(fdim(d0, i0));
+
+  check_ret_type<double>(fma(d0, d0, d0));
+  check_ret_type<double>(fma(d0, f0, d0));
+  check_ret_type<float>(fma(f0, f0, f0));
+  check_ret_type<long double>(fma(ld0, ld0, ld0));
+  check_ret_type<long double>(fma(ld0, d0, f0));
+  check_ret_type<double>(fma(i0, i0, i0));
+  check_ret_type<double>(fma(d0, i0, f0));
+
+  check_ret_type<double>(fmax(d0, d0));
+  check_ret_type<double>(fmax(d0, f0));
+  check_ret_type<float>(fmax(f0, f0));
+  check_ret_type<long double>(fmax(ld0, ld0));
+  check_ret_type<long double>(fmax(ld0, d0));
+  check_ret_type<double>(fmax(i0, i0));
+  check_ret_type<double>(fmax(d0, i0));
+
+  check_ret_type<double>(fmin(d0, d0));
+  check_ret_type<double>(fmin(d0, f0));
+  check_ret_type<float>(fmin(f0, f0));
+  check_ret_type<long double>(fmin(ld0, ld0));
+  check_ret_type<long double>(fmin(ld0, d0));
+  check_ret_type<double>(fmin(i0, i0));
+  check_ret_type<double>(fmin(d0, i0));
+
+  check_ret_type<double>(hypot(d0, d0));
+  check_ret_type<double>(hypot(d0, f0));
+  check_ret_type<float>(hypot(f0, f0));
+  check_ret_type<long double>(hypot(ld0, ld0));
+  check_ret_type<long double>(hypot(ld0, d0));
+  check_ret_type<double>(hypot(i0, i0));
+  check_ret_type<double>(hypot(d0, i0));
+
+  check_ret_type<int>(ilogb(d0));
+  check_ret_type<int>(ilogb(f0));
+  check_ret_type<int>(ilogb(ld0));
+  check_ret_type<int>(ilogb(i0));
+
+  check_ret_type<double>(lgamma(d0));
+  check_ret_type<float>(lgamma(f0));
+  check_ret_type<long double>(lgamma(ld0));
+  check_ret_type<double>(lgamma(i0));
+
+  check_ret_type<long long>(llrint(d0));
+  check_ret_type<long long>(llrint(f0));
+  check_ret_type<long long>(llrint(ld0));
+  check_ret_type<long long>(llrint(i0));
+
+  check_ret_type<long long>(llround(d0));
+  check_ret_type<long long>(llround(f0));
+  check_ret_type<long long>(llround(ld0));
+  check_ret_type<long long>(llround(i0));
+
+  check_ret_type<double>(log1p(d0));
+  check_ret_type<float>(log1p(f0));
+  check_ret_type<long double>(log1p(ld0));
+  check_ret_type<double>(log1p(i0));
+
+  check_ret_type<double>(log2(d0));
+  check_ret_type<float>(log2(f0));
+  check_ret_type<long double>(log2(ld0));
+  check_ret_type<double>(log2(i0));
+
+  check_ret_type<double>(logb(d0));
+  check_ret_type<float>(logb(f0));
+  check_ret_type<long double>(logb(ld0));
+  check_ret_type<double>(logb(i0));
+
+  check_ret_type<long>(lrint(d0));
+  check_ret_type<long>(lrint(f0));
+  check_ret_type<long>(lrint(ld0));
+  check_ret_type<long>(lrint(i0));
+
+  check_ret_type<long>(lround(d0));
+  check_ret_type<long>(lround(f0));
+  check_ret_type<long>(lround(ld0));
+  check_ret_type<long>(lround(i0));
+
+  check_ret_type<double>(nearbyint(d0));
+  check_ret_type<float>(nearbyint(f0));
+  check_ret_type<long double>(nearbyint(ld0));
+  check_ret_type<double>(nearbyint(i0));
+
+  check_ret_type<double>(nextafter(d0, d0));
+  check_ret_type<double>(nextafter(d0, f0));
+  check_ret_type<float>(nextafter(f0, f0));
+  check_ret_type<long double>(nextafter(ld0, ld0));
+  check_ret_type<long double>(nextafter(ld0, d0));
+  check_ret_type<double>(nextafter(i0, i0));
+  check_ret_type<double>(nextafter(d0, i0));
+
+  check_ret_type<double>(nexttoward(d0, ld0));
+  check_ret_type<float>(nexttoward(f0, ld0));
+  check_ret_type<long double>(nexttoward(ld0, ld0));
+  check_ret_type<double>(nexttoward(i0, ld0));
+
+  check_ret_type<double>(remainder(d0, d0));
+  check_ret_type<double>(remainder(d0, f0));
+  check_ret_type<float>(remainder(f0, f0));
+  check_ret_type<long double>(remainder(ld0, ld0));
+  check_ret_type<long double>(remainder(ld0, d0));
+  check_ret_type<double>(remainder(i0, i0));
+  check_ret_type<double>(remainder(d0, i0));
+
+  check_ret_type<double>(remquo(d0, d0, pquo));
+  check_ret_type<double>(remquo(d0, f0, pquo));
+  check_ret_type<float>(remquo(f0, f0, pquo));
+  check_ret_type<long double>(remquo(ld0, ld0, pquo));
+  check_ret_type<long double>(remquo(ld0, d0, pquo));
+  check_ret_type<double>(remquo(i0, i0, pquo));
+  check_ret_type<double>(remquo(d0, i0, pquo));
+
+  check_ret_type<double>(rint(d0));
+  check_ret_type<float>(rint(f0));
+  check_ret_type<long double>(rint(ld0));
+  check_ret_type<double>(rint(i0));
+
+  check_ret_type<double>(round(d0));
+  check_ret_type<float>(round(f0));
+  check_ret_type<long double>(round(ld0));
+  check_ret_type<double>(round(i0));
+
+  check_ret_type<double>(scalbln(d0, lex));
+  check_ret_type<float>(scalbln(f0, lex));
+  check_ret_type<long double>(scalbln(ld0, lex));
+  check_ret_type<double>(scalbln(i0, lex));
+
+  check_ret_type<double>(scalbn(d0, ex));
+  check_ret_type<float>(scalbn(f0, ex));
+  check_ret_type<long double>(scalbn(ld0, ex));
+  check_ret_type<double>(scalbn(i0, ex));
+
+  check_ret_type<double>(tgamma(d0));
+  check_ret_type<float>(tgamma(f0));
+  check_ret_type<long double>(tgamma(ld0));
+  check_ret_type<double>(tgamma(i0));
+
+  check_ret_type<double>(trunc(d0));
+  check_ret_type<float>(trunc(f0));
+  check_ret_type<long double>(trunc(ld0));
+  check_ret_type<double>(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 d03075a..21f2d75 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  <pcarlini@suse.de>
 //
 // Copyright (C) 2006 Free Software Foundation, Inc.
@@ -101,9 +103,3 @@ void test01()
   check_ret_type<double>(real(d1));
   check_ret_type<long double>(real(ld1));
 }
-    
-int main()
-{
-  test01();
-  return 0;
-}