+2002-03-28 Roger Sayle <roger@eyesopen.com>
+
+ 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 <neil@daikokuya.demon.co.uk>
* cp-lang.c (LANG_HOOKS_MAKE_TYPE): Redefine.
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,
{
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. */
}
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))))
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. */
/* 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);
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. */
*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;
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;
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.
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;
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
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. */
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;
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. */
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)
{
+2002-03-28 Roger Sayle <roger@eyesopen.com>
+
+ * 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 <jakub@redhat.com>
* g++.dg/opt/static1.C: New test.
--- /dev/null
+// 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
+}
--- /dev/null
+// 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;
+}
+
--- /dev/null
+// 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;
+}
--- /dev/null
+// 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;
+}
+
--- /dev/null
+// 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 ();
+}
+2002-03-27 Roger Sayle <roger@eyesopen.com>
+
+ * 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 <ljrittle@acm.org>
* testsuite/18_support/numeric_limits.cc (test_extrema): Fix typo.
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); }
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); }
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); }
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); }
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); }
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); }
{ 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); }
{ 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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
{ 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); }
{ 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); }
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); }
{ 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); }
{ 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); }
{ return ::ldexp(static_cast<double>(__x), __exp); }
#endif
+ using ::log;
+
#if _GLIBCPP_HAVE_LOGF
inline float
log(float __x) { return ::logf(__x); }
{ return ::log(static_cast<double>(__x)); }
#endif
- using ::log;
-
#if _GLIBCPP_HAVE_LOGL
inline long double
log(long double __x) { return ::logl(__x); }
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); }
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); }
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); }
}
#endif
- using ::modf;
-
#if _GLIBCPP_HAVE_MODFL
inline long double
modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
? _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); }
{ 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); }
{ 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); }
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); }
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); }
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); }
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); }
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); }
OSDN Git Service
