* include/c_std/std_cmath.h: To prevent problems overloading

	g++ builtins, use the double variants from the global namespace
	before defining float and long double variants in std::.

	PR c++/5998:
	* decl.c (cxx_init_decl_processing): Re-enable built-in functions
	in the g++ front-end.
	(duplicate_decl): Allow redefinition of anticipated built-ins.
	Fix inlining problem by over-writing the old DECL_RTL.
	(lookup_namespace_name): Fail to find an identifier in the
	specified namespace if its still anticipated.
	(builtin_function_1): New function split out from builtin_function
	to create a builtin in the current namespace with given context.
	(builtin_function): Call builtin_function_1 to define the
	appropriate builtins in both the std and global namespaces.
	(select_decl): Don't test for anticipated decls here.
	(unqualified_namespace_lookup): Instead ignore them whilst
	searching through scopes and namespaces.
	* decl2.c (do_nonmember_using_decl): If a using declaration
	specifies an anticipated built-in function, mark it as no longer
	anticipated in that scope.
	(ambiguous_decl):  Avoid resolving to an anticipated decl.
	* lex.c (do_scoped_id): Fail to find an identifier in the global
	namespace if its still anticipated.

	* g++.old-deja/g++.other/builtins5.C: New test.
	* g++.old-deja/g++.other/builtins6.C: New test.
	* g++.old-deja/g++.other/builtins7.C: New test.
	* g++.old-deja/g++.other/builtins8.C: New test.
	* g++.old-deja/g++.other/builtins9.C: New test.


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

1 files changed, 51 insertions, 51 deletions

diff --git a/libstdc++-v3/include/c_std/std_cmath.h b/libstdc++-v3/include/c_std/std_cmath.h
index e0fffeab930..9e05900b180 100644
--- a/libstdc++-v3/include/c_std/std_cmath.h
+++ b/libstdc++-v3/include/c_std/std_cmath.h
@@ -89,14 +89,14 @@ namespace std
       return __x < _Tp() ? -__x : __x;
     }
 
-  inline float
-  abs(float __x)
-  { return __builtin_fabsf(__x); }
-
   inline double
   abs(double __x)
   { return __builtin_fabs(__x); }
 
+  inline float
+  abs(float __x)
+  { return __builtin_fabsf(__x); }
+
   inline long double
   abs(long double __x)
   { return __builtin_fabsl(__x); }
@@ -119,6 +119,8 @@ namespace std
   acos(long double __x) { return ::acos(static_cast<double>(__x)); }
 #endif
 
+  using ::asin;
+
 #if _GLIBCPP_HAVE_ASINF
   inline float 
   asin(float __x) { return ::asinf(__x); }
@@ -127,8 +129,6 @@ namespace std
   asin(float __x) { return ::asin(static_cast<double>(__x)); }
 #endif
 
-  using ::asin;
-
 #if _GLIBCPP_HAVE_ASINL
   inline long double 
   asin(long double __x) { return ::asinl(__x); }
@@ -137,6 +137,8 @@ namespace std
   asin(long double __x) { return ::asin(static_cast<double>(__x)); }
 #endif
 
+  using ::atan;
+
 #if _GLIBCPP_HAVE_ATANF
   inline float 
   atan(float __x) { return ::atanf(__x); }
@@ -145,8 +147,6 @@ namespace std
   atan(float __x) { return ::atan(static_cast<double>(__x)); }
 #endif
 
-  using ::atan;
-
 #if _GLIBCPP_HAVE_ATANL
   inline long double 
   atan(long double __x) { return ::atanl(__x); }
@@ -155,6 +155,8 @@ namespace std
   atan(long double __x) { return ::atan(static_cast<double>(__x)); }
 #endif
 
+  using ::atan2;
+
 #if _GLIBCPP_HAVE_ATAN2F
   inline float 
   atan2(float __y, float __x) { return ::atan2f(__y, __x); }
@@ -164,8 +166,6 @@ namespace std
   { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
 #endif
 
-  using ::atan2;
-
 #if _GLIBCPP_HAVE_ATAN2L
   inline long double 
   atan2(long double __y, long double __x) { return ::atan2l(__y, __x); }
@@ -175,6 +175,8 @@ namespace std
   { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
 #endif
 
+  using ::ceil;
+
 #if _GLIBCPP_HAVE_CEILF
   inline float 
   ceil(float __x) { return ::ceilf(__x); }
@@ -183,8 +185,6 @@ namespace std
   ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
 #endif
 
-  using ::ceil;
-
 #if _GLIBCPP_HAVE_CEILL
   inline long double 
   ceil(long double __x) { return ::ceill(__x); }
@@ -193,16 +193,18 @@ namespace std
   ceil(long double __x) { return ::ceil(static_cast<double>(__x)); }
 #endif
 
+  using ::cos;
+
   inline float
   cos(float __x)
   { return __builtin_cosf(__x); }
 
-  using ::cos;
-
   inline long double
   cos(long double __x)
   { return __builtin_cosl(__x); }
 
+  using ::cosh;
+
 #if _GLIBCPP_HAVE_COSHF
   inline float 
   cosh(float __x) { return ::coshf(__x); }
@@ -211,8 +213,6 @@ namespace std
   cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
 #endif
 
-  using ::cosh;
-
 #if _GLIBCPP_HAVE_COSHL
   inline long double 
   cosh(long double __x) { return ::coshl(__x); }
@@ -221,6 +221,8 @@ namespace std
   cosh(long double __x) { return ::cosh(static_cast<double>(__x)); }
 #endif
 
+  using ::exp;
+
 #if _GLIBCPP_HAVE_EXPF
   inline float 
   exp(float __x) { return ::expf(__x); }
@@ -229,8 +231,6 @@ namespace std
   exp(float __x) { return ::exp(static_cast<double>(__x)); }
 #endif
 
-  using ::exp;
-
 #if _GLIBCPP_HAVE_EXPL
   inline long double 
   exp(long double __x) { return ::expl(__x); }
@@ -239,16 +239,18 @@ namespace std
   exp(long double __x) { return ::exp(static_cast<double>(__x)); }
 #endif
 
+  using ::fabs;
+
   inline float
   fabs(float __x)
   { return __builtin_fabsf(__x); }
 
-  using ::fabs;
-
   inline long double
   fabs(long double __x)
   { return __builtin_fabsl(__x); }
 
+  using ::floor;
+
 #if _GLIBCPP_HAVE_FLOORF
   inline float 
   floor(float __x) { return ::floorf(__x); }
@@ -257,8 +259,6 @@ namespace std
   floor(float __x) { return ::floor(static_cast<double>(__x)); }
 #endif
 
-  using ::floor;
-
 #if _GLIBCPP_HAVE_FLOORL
   inline long double 
   floor(long double __x) { return ::floorl(__x); }
@@ -267,6 +267,8 @@ namespace std
   floor(long double __x) { return ::floor(static_cast<double>(__x)); }
 #endif
 
+  using ::fmod;
+
 #if _GLIBCPP_HAVE_FMODF
   inline float 
   fmod(float __x, float __y) { return ::fmodf(__x, __y); }
@@ -276,8 +278,6 @@ namespace std
   { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
 #endif
 
-  using ::fmod;
-
 #if _GLIBCPP_HAVE_FMODL
   inline long double 
   fmod(long double __x, long double __y) { return ::fmodl(__x, __y); }
@@ -287,6 +287,8 @@ namespace std
   { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
 #endif
 
+  using ::frexp;
+
 #if _GLIBCPP_HAVE_FREXPF
   inline float 
   frexp(float __x, int* __exp) { return ::frexpf(__x, __exp); }
@@ -295,8 +297,6 @@ namespace std
   frexp(float __x, int* __exp) { return ::frexp(__x, __exp); }
 #endif
 
-  using ::frexp;
-
 #if _GLIBCPP_HAVE_FREXPL
   inline long double 
   frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); }
@@ -306,6 +306,8 @@ namespace std
   { return ::frexp(static_cast<double>(__x), __exp); }
 #endif
 
+  using ::ldexp;
+
 #if _GLIBCPP_HAVE_LDEXPF
   inline float 
   ldexp(float __x, int __exp) { return ::ldexpf(__x, __exp); }
@@ -315,8 +317,6 @@ namespace std
   { return ::ldexp(static_cast<double>(__x), __exp); }
 #endif
 
-  using ::ldexp;
-
 #if _GLIBCPP_HAVE_LDEXPL
   inline long double 
   ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); }
@@ -326,6 +326,8 @@ namespace std
   { return ::ldexp(static_cast<double>(__x), __exp); }
 #endif
 
+  using ::log;
+
 #if _GLIBCPP_HAVE_LOGF
   inline float 
   log(float __x) { return ::logf(__x); }
@@ -334,8 +336,6 @@ namespace std
   { return ::log(static_cast<double>(__x)); }
 #endif
 
-  using ::log;
-
 #if _GLIBCPP_HAVE_LOGL
   inline long double 
   log(long double __x) { return ::logl(__x); }
@@ -344,6 +344,8 @@ namespace std
   log(long double __x) { return ::log(static_cast<double>(__x)); }
 #endif
 
+  using ::log10;
+
 #if _GLIBCPP_HAVE_LOG10F
   inline float 
   log10(float __x) { return ::log10f(__x); }
@@ -352,8 +354,6 @@ namespace std
   log10(float __x) { return ::log10(static_cast<double>(__x)); }
 #endif
 
-  using ::log10;
-
 #if _GLIBCPP_HAVE_LOG10L
   inline long double 
   log10(long double __x) { return ::log10l(__x); }
@@ -362,6 +362,8 @@ namespace std
   log10(long double __x) { return ::log10(static_cast<double>(__x)); }
 #endif
 
+  using ::modf;
+
 #if _GLIBCPP_HAVE_MODFF
   inline float 
   modf(float __x, float* __iptr) { return ::modff(__x, __iptr); }
@@ -376,8 +378,6 @@ namespace std
   }
 #endif
 
-  using ::modf;
-
 #if _GLIBCPP_HAVE_MODFL
   inline long double 
   modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
@@ -400,7 +400,9 @@ namespace std
         ? _Tp(1)/__cmath_power(__x, -__n)
         : __cmath_power(__x, __n);
     }
-  
+
+  using ::pow;
+
 #if _GLIBCPP_HAVE_POWF
   inline float 
   pow(float __x, float __y) { return ::powf(__x, __y); }
@@ -410,8 +412,6 @@ namespace std
   { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
 #endif
 
-  using ::pow;
-
 #if _GLIBCPP_HAVE_POWL
   inline long double 
   pow(long double __x, long double __y) { return ::powl(__x, __y); }
@@ -421,28 +421,30 @@ namespace std
   { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
 #endif
 
-  inline float 
-  pow(float __x, int __n)
-  { return __pow_helper(__x, __n); }
-
   inline double 
   pow(double __x, int __i)
   { return __pow_helper(__x, __i); }
 
+  inline float 
+  pow(float __x, int __n)
+  { return __pow_helper(__x, __n); }
+
   inline long double 
   pow(long double __x, int __n)
   { return __pow_helper(__x, __n); }
 
+  using ::sin;
+
   inline float
   sin(float __x)
   { return __builtin_sinf(__x); }
 
-  using ::sin;
-
   inline long double
   sin(long double __x)
   { return __builtin_sinl(__x); }
 
+  using ::sinh;
+
 #if _GLIBCPP_HAVE_SINHF
   inline float 
   sinh(float __x) { return ::sinhf(__x); }
@@ -451,8 +453,6 @@ namespace std
   sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
 #endif
 
-  using ::sinh;
-
 #if _GLIBCPP_HAVE_SINHL
   inline long double 
   sinh(long double __x) { return ::sinhl(__x); }
@@ -461,16 +461,18 @@ namespace std
   sinh(long double __x) { return ::sinh(static_cast<double>(__x)); }
 #endif
 
+  using ::sqrt;
+
   inline float
   sqrt(float __x)
   { return __builtin_sqrtf(__x); }
 
-  using ::sqrt;
-
   inline long double
   sqrt(long double __x)
   { return __builtin_sqrtl(__x); }
 
+  using ::tan;
+
 #if _GLIBCPP_HAVE_TANF
   inline float 
   tan(float __x) { return ::tanf(__x); }
@@ -479,8 +481,6 @@ namespace std
   tan(float __x) { return ::tan(static_cast<double>(__x)); }
 #endif
 
-  using ::tan;
-
 #if _GLIBCPP_HAVE_TANL
   inline long double 
   tan(long double __x) { return ::tanl(__x); }
@@ -489,6 +489,8 @@ namespace std
   tan(long double __x) { return ::tan(static_cast<double>(__x)); }
 #endif
 
+  using ::tanh;
+
 #if _GLIBCPP_HAVE_TANHF
   inline float 
   tanh(float __x) { return ::tanhf(__x); }
@@ -497,8 +499,6 @@ namespace std
   tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
 #endif
 
-  using ::tanh;
-
 #if _GLIBCPP_HAVE_TANHL
   inline long double 
   tanh(long double __x) { return ::tanhl(__x); }