From ae8cbbc840e99bad6daf843f557d9e0c0452833b Mon Sep 17 00:00:00 2001 From: mmitchel Date: Fri, 29 Mar 2002 20:41:53 +0000 Subject: [PATCH] * 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 --- gcc/cp/ChangeLog | 23 +++++ gcc/cp/decl.c | 108 +++++++++++++++-------- gcc/cp/decl2.c | 14 +++ gcc/cp/lex.c | 3 +- gcc/testsuite/ChangeLog | 8 ++ gcc/testsuite/g++.old-deja/g++.other/builtins5.C | 16 ++++ gcc/testsuite/g++.old-deja/g++.other/builtins6.C | 18 ++++ gcc/testsuite/g++.old-deja/g++.other/builtins7.C | 20 +++++ gcc/testsuite/g++.old-deja/g++.other/builtins8.C | 24 +++++ gcc/testsuite/g++.old-deja/g++.other/builtins9.C | 13 +++ libstdc++-v3/ChangeLog | 6 ++ libstdc++-v3/include/c_std/std_cmath.h | 102 ++++++++++----------- 12 files changed, 267 insertions(+), 88 deletions(-) create mode 100644 gcc/testsuite/g++.old-deja/g++.other/builtins5.C create mode 100644 gcc/testsuite/g++.old-deja/g++.other/builtins6.C create mode 100644 gcc/testsuite/g++.old-deja/g++.other/builtins7.C create mode 100644 gcc/testsuite/g++.old-deja/g++.other/builtins8.C create mode 100644 gcc/testsuite/g++.old-deja/g++.other/builtins9.C diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 6a69a7a8b53..b7f8cb2cc78 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,26 @@ +2002-03-28 Roger Sayle + + 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. + 2002-03-29 Neil Booth * cp-lang.c (LANG_HOOKS_MAKE_TYPE): Redefine. diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 7dbb55bdfbd..1739771debf 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -87,6 +87,8 @@ static tree lookup_tag PARAMS ((enum tree_code, tree, static void set_identifier_type_value_with_scope PARAMS ((tree, tree, struct binding_level *)); static void record_unknown_type PARAMS ((tree, const char *)); +static tree builtin_function_1 PARAMS ((const char *, tree, tree, int, + enum built_in_class, const char *)); static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree)); static int member_function_or_else PARAMS ((tree, tree, enum overload_flags)); static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int, @@ -3145,6 +3147,10 @@ duplicate_decls (newdecl, olddecl) { if (TREE_CODE (newdecl) != FUNCTION_DECL) { + /* Avoid warnings redeclaring anticipated built-ins. */ + if (DECL_ANTICIPATED (olddecl)) + return 0; + /* If you declare a built-in or predefined function name as static, the old definition is overridden, but optionally warn this was a bad choice of name. */ @@ -3172,7 +3178,10 @@ duplicate_decls (newdecl, olddecl) } else if (!types_match) { - if ((DECL_EXTERN_C_P (newdecl) + /* Avoid warnings redeclaring anticipated built-ins. */ + if (DECL_ANTICIPATED (olddecl)) + ; /* Do nothing yet. */ + else if ((DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl)) || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), TYPE_ARG_TYPES (TREE_TYPE (olddecl)))) @@ -3614,6 +3623,7 @@ duplicate_decls (newdecl, olddecl) TREE_READONLY (olddecl) = TREE_READONLY (newdecl); TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl); TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl); + COPY_DECL_RTL (newdecl, olddecl); } /* Merge the storage class information. */ @@ -5507,7 +5517,12 @@ lookup_namespace_name (namespace, name) /* If we have a single function from a using decl, pull it out. */ if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val)) val = OVL_FUNCTION (val); - return val; + + /* Ignore built-in functions that haven't been prototyped yet. */ + if (!val || !DECL_P(val) + || !DECL_LANG_SPECIFIC(val) + || !DECL_ANTICIPATED (val)) + return val; } error ("`%D' undeclared in namespace `%D'", name, namespace); @@ -5786,14 +5801,6 @@ select_decl (binding, flags) tree val; val = BINDING_VALUE (binding); - /* When we implicitly declare some builtin entity, we mark it - DECL_ANTICIPATED, so that we know to ignore it until it is - really declared. */ - if (val && DECL_P (val) - && DECL_LANG_SPECIFIC (val) - && DECL_ANTICIPATED (val)) - return NULL_TREE; - if (LOOKUP_NAMESPACES_ONLY (flags)) { /* We are not interested in types. */ @@ -5843,9 +5850,21 @@ unqualified_namespace_lookup (name, flags, spacesp) *spacesp = tree_cons (scope, NULL_TREE, *spacesp); val = binding_for_name (name, scope); - /* Initialize binding for this context. */ - BINDING_VALUE (b) = BINDING_VALUE (val); - BINDING_TYPE (b) = BINDING_TYPE (val); + /* Ignore anticipated built-in functions. */ + if (val && BINDING_VALUE (val) + && DECL_P (BINDING_VALUE (val)) + && DECL_LANG_SPECIFIC (BINDING_VALUE (val)) + && DECL_ANTICIPATED (BINDING_VALUE (val))) + { + BINDING_VALUE (b) = NULL_TREE; + BINDING_TYPE (b) = NULL_TREE; + } + else + { + /* Initialize binding for this context. */ + BINDING_VALUE (b) = BINDING_VALUE (val); + BINDING_TYPE (b) = BINDING_TYPE (val); + } /* Add all _DECLs seen through local using-directives. */ for (level = current_binding_level; @@ -6435,12 +6454,6 @@ cxx_init_decl_processing () flag_inline_functions = 0; } - /* In C++, we never create builtin functions whose name does not - begin with `__'. Users should be using headers to get prototypes - in C++. It would be nice if we could warn when `-fbuiltin' is - used explicitly, but we do not have that information. */ - flag_no_builtin = 1; - /* Initially, C. */ current_lang_name = lang_name_c; @@ -6704,10 +6717,9 @@ cp_make_fname_decl (id, type_dep) return decl; } -/* Entry point for the benefit of c_common_nodes_and_builtins. - - Make a definition for a builtin function named NAME and whose data type - is TYPE. TYPE should be a function type with argument types. +/* Make a definition for a builtin function named NAME in the current + namespace, whose data type is TYPE and whose context is CONTEXT. + TYPE should be a function type with argument types. CLASS and CODE tell later passes how to compile calls to this function. See tree.h for possible values. @@ -6715,10 +6727,11 @@ cp_make_fname_decl (id, type_dep) If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME, the name to be called if we can't opencode the function. */ -tree -builtin_function (name, type, code, class, libname) +static tree +builtin_function_1 (name, type, context, code, class, libname) const char *name; tree type; + tree context; int code; enum built_in_class class; const char *libname; @@ -6726,23 +6739,13 @@ builtin_function (name, type, code, class, libname) tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type); DECL_BUILT_IN_CLASS (decl) = class; DECL_FUNCTION_CODE (decl) = code; + DECL_CONTEXT (decl) = context; /* The return builtins leave the current function. */ if (code == BUILT_IN_RETURN || code == BUILT_IN_EH_RETURN) TREE_THIS_VOLATILE (decl) = 1; - my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392); - - /* All builtins that don't begin with an `_' should go in the `std' - namespace. */ - if (name[0] != '_') - { - push_namespace (std_identifier); - DECL_CONTEXT (decl) = std_node; - } pushdecl (decl); - if (name[0] != '_') - pop_namespace (); /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME, we cannot change DECL_ASSEMBLER_NAME until we have installed this @@ -6762,6 +6765,39 @@ builtin_function (name, type, code, class, libname) return decl; } +/* Entry point for the benefit of c_common_nodes_and_builtins. + + Make a defintion for a builtin function named NAME and whose data type + is TYPE. TYPE should be a function type with argument types. This + function places the anticipated declaration in the global namespace + and additionally in the std namespace if appropriate. + + CLASS and CODE tell later passes how to compile calls to this function. + See tree.h for possible values. + + If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME, + the name to be called if we can't opencode the function. */ + +tree +builtin_function (name, type, code, class, libname) + const char *name; + tree type; + int code; + enum built_in_class class; + const char *libname; +{ + /* All builtins that don't begin with an '_' should additionally + go in the 'std' namespace. */ + if (name[0] != '_') + { + push_namespace (std_identifier); + builtin_function_1 (name, type, std_node, code, class, libname); + pop_namespace (); + } + + return builtin_function_1 (name, type, NULL_TREE, code, class, libname); +} + /* Generate a FUNCTION_DECL with the typical flags for a runtime library function. Not called directly. */ diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 6763b4591ac..95dc8e023db 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -4178,6 +4178,11 @@ ambiguous_decl (name, old, new, flags) if (LOOKUP_TYPES_ONLY (flags)) val = NULL_TREE; break; + case FUNCTION_DECL: + /* Ignore built-in functions that are still anticipated. */ + if (LOOKUP_QUALIFIERS_ONLY (flags) || DECL_ANTICIPATED (val)) + val = NULL_TREE; + break; default: if (LOOKUP_QUALIFIERS_ONLY (flags)) val = NULL_TREE; @@ -4930,6 +4935,15 @@ do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype) else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)), TYPE_ARG_TYPES (TREE_TYPE (old_fn)))) { + /* If this using declaration introduces a function + recognized as a built-in, no longer mark it as + anticipated in this scope. */ + if (DECL_ANTICIPATED (old_fn)) + { + DECL_ANTICIPATED (old_fn) = 0; + break; + } + /* There was already a non-using declaration in this scope with the same parameter types. If both are the same extern "C" functions, that's ok. */ diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c index 8ab072ed07a..e9e660dc972 100644 --- a/gcc/cp/lex.c +++ b/gcc/cp/lex.c @@ -1326,7 +1326,8 @@ do_scoped_id (token, parsing) id = IDENTIFIER_GLOBAL_VALUE (token); if (parsing && yychar == YYEMPTY) yychar = yylex (); - if (! id) + if (!id || (TREE_CODE (id) == FUNCTION_DECL + && DECL_ANTICIPATED (id))) { if (processing_template_decl) { diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index fec72b83aa3..606df339541 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,11 @@ +2002-03-28 Roger Sayle + + * 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. + 2002-03-29 Jakub Jelinek * g++.dg/opt/static1.C: New test. diff --git a/gcc/testsuite/g++.old-deja/g++.other/builtins5.C b/gcc/testsuite/g++.old-deja/g++.other/builtins5.C new file mode 100644 index 00000000000..9a2cdaf289f --- /dev/null +++ b/gcc/testsuite/g++.old-deja/g++.other/builtins5.C @@ -0,0 +1,16 @@ +// Build don't link: +// Test that built-in functions aren't recognized without a prototype. +// Origin: Roger Sayle Mar 20, 2002 +// Copyright (C) 2002 Free Software Foundation. + +int +foo () +{ + return (int) ::strlen ("foo"); // ERROR - undeclared +} + +int +bar () +{ + return (int) std::strlen ("bar"); // ERROR - undeclared +} diff --git a/gcc/testsuite/g++.old-deja/g++.other/builtins6.C b/gcc/testsuite/g++.old-deja/g++.other/builtins6.C new file mode 100644 index 00000000000..347f4adda6d --- /dev/null +++ b/gcc/testsuite/g++.old-deja/g++.other/builtins6.C @@ -0,0 +1,18 @@ +// Test that built-in functions are recognized with a prototype. +// Origin: Roger Sayle Mar 20, 2002 +// Copyright (C) 2002 Free Software Foundation. +// +// Special g++ Options: -O2 + +typedef __SIZE_TYPE__ size_t; +extern "C" size_t strlen (const char*); +extern "C" void link_error (void); + +int +main () +{ + if (strlen ("foo") != 3) + link_error (); + return 0; +} + diff --git a/gcc/testsuite/g++.old-deja/g++.other/builtins7.C b/gcc/testsuite/g++.old-deja/g++.other/builtins7.C new file mode 100644 index 00000000000..9d4cb747487 --- /dev/null +++ b/gcc/testsuite/g++.old-deja/g++.other/builtins7.C @@ -0,0 +1,20 @@ +// Test that built-in functions are recognized with a prototype. +// Origin: Roger Sayle Mar 20, 2002 +// Copyright (C) 2002 Free Software Foundation. +// +// Special g++ Options: -O2 + +extern "C" void link_error (void); + +namespace std { +typedef __SIZE_TYPE__ size_t; +extern "C" size_t strlen (const char*); +} + +int +main () +{ + if (std::strlen ("foo") != 3) + link_error (); + return 0; +} diff --git a/gcc/testsuite/g++.old-deja/g++.other/builtins8.C b/gcc/testsuite/g++.old-deja/g++.other/builtins8.C new file mode 100644 index 00000000000..4eaa56ef262 --- /dev/null +++ b/gcc/testsuite/g++.old-deja/g++.other/builtins8.C @@ -0,0 +1,24 @@ +// Test that built-in functions are recognized with a prototype. +// Origin: Roger Sayle Mar 20, 2002 +// Copyright (C) 2002 Free Software Foundation. +// +// Special g++ Options: -O2 + + +extern "C" void link_error (void); + +namespace std { +typedef __SIZE_TYPE__ size_t; +extern "C" size_t strlen (const char*); +} + +using namespace std; + +int +main () +{ + if (strlen ("foo") != 3) + link_error (); + return 0; +} + diff --git a/gcc/testsuite/g++.old-deja/g++.other/builtins9.C b/gcc/testsuite/g++.old-deja/g++.other/builtins9.C new file mode 100644 index 00000000000..8f32c9fdb07 --- /dev/null +++ b/gcc/testsuite/g++.old-deja/g++.other/builtins9.C @@ -0,0 +1,13 @@ +// Test that inline redeclarations of builtins are emitted. +// Origin: Roger Sayle Mar 28, 2002 +// Copyright (C) 2002 Free Software Foundation. + +namespace std { + inline int fabs (void) { return 0; } +} + + +int main () +{ + return std::fabs (); +} diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 00015d4aad0..f280238833f 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,9 @@ +2002-03-27 Roger Sayle + + * 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::. + 2002-03-28 Loren J. Rittle * testsuite/18_support/numeric_limits.cc (test_extrema): Fix typo. 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(__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(__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(__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(__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(__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(__y), static_cast(__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(__y), static_cast(__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(__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(__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(__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(__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(__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(__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(__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(__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(__x), static_cast(__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(__x), static_cast(__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(__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(__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(__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(__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(__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(__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(__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(__x), static_cast(__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(__x), static_cast(__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(__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(__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(__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(__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(__x)); } #endif - using ::tanh; - #if _GLIBCPP_HAVE_TANHL inline long double tanh(long double __x) { return ::tanhl(__x); } -- 2.11.0