C identifier lookup speedups, 1/2
Zack Weinberg
zack@codesourcery.com
Fri Apr 11 04:27:00 GMT 2003
This is a revised version of the patch I sent last week, which revises
the way C identifier lookup works. This chunk addresses symbol
lookups. It's been bootstrapped on i686-linux with no regressions and
(now) a slight performance improvement visible in a bootstrap; I will
commit it simultaneously with the other half, which does tag lookup.
The basic idea is that we don't need IDENTIFIER_LIMBO_VALUE and
IDENTIFIER_IMPLICIT_DECL if we manage external decls correctly. When
possible, they are inserted into the global binding contour but made
invisible outside the context in which they were declared; when this
is not possible (e.g. if there is a TYPE_DECL with the same name at
file scope) they are put on a lookaside list, which normally should
have length 0.
There's a few more complications to deal with error recovery, but
that's the gist.
This patch introduces IDENTIFIER_TAG_VALUE but does not use it. The
second half will use it.
zw
* c-tree.h (struct lang_identifier): Replace global_value,
local_value members with symbol_value, tag_value. Kill
implicit_decl and limbo_value.
(IDENTIFIER_GLOBAL_VALUE, IDENTIFIER_LOCAL_VALUE,
IDENTIFIER_LIMBO_VALUE, IDENTIFIER_IMPLICIT_DECL,
C_MISSING_PROTOTYPE_WARNED): Kill.
(IDENTIFIER_SYMBOL_VALUE, IDENTIFIER_TAG_VALUE,
C_DECL_IMPLICIT, C_DECL_ISNT_PROTOTYPE): New.
(C_DECL_ANTICIPATED): Rename to C_DECL_INVISIBLE.
(implicit_decl_warning, lookup_name_current_level,
record_function_scope_shadow): Don't prototype.
(pushdecl_function_level): Prototype.
* c-decl.c (truly_local_externals): New variable.
(struct binding_level): Adjust commentary.
(get_function_binding_level, clear_limbo_values,
record_function_scope_shadow): Kill.
(lookup_name_current_level, implicit_decl_warning): Are now static.
(any_external_decl, record_external_decl): New static functions.
(clone_underlying type): Split out of pushdecl.
(c_print_identifier): Update to match changes to struct
lang_identifier.
(poplevel): Delete #if 0 block. Make externals invisible
instead of clearing their IDENTIFIER_SYMBOL_VALUEs. Don't
call clear_limbo_values. Refer to IDENTIFIER_SYMBOL_VALUE not
IDENTIFIER_GLOBAL_VALUE or IDENTIFIER_LOCAL_VALUE.
(duplicate-decls): For real parm decl after a forward decl,
set TREE_ASM_WRITTEN here. Allow void foo(...) followed by
foo(...) { } with only a warning. Say whether a previous
declaration was implicit.
(warn_if_shadowing): Now handles all shadowing, not just
local-over-local. Clarify comments.
(pushdecl): Rewritten. There is no longer a distinction
between global and local symbol values; they're all
IDENTIFIER_SYMBOL_VALUE. Call record_external_decl on all
DECL_EXTERNAL decls, and use any_external_decl to check
against previous externals. Kill #if 0 blocks. Don't
tolerate error_mark_node being NULL.
(pushdecl_top_level): Handle only those cases which Objective
C (the only user) needs.
(pushdecl_function_level): New function.
(implicitly_declare): Create ordinary decls with
C_DECL_IMPLICIT set. Recycle old decls, however they got
created.
(lookup_name): It's always IDENTIFIER_SYMBOL_VALUE. Return 0
for C_DECL_INVISIBLE symbols.
(lookup_name_current_level): Likewise. Use chain_member.
(c_make_fname_decl): Don't muck with DECL_CONTEXT. Use
pushdecl_function_level.
(builtin_function): Use C_DECL_INVISIBLE.
(start_function): Don't muck with IDENTIFIER_IMPLICIT_DECL.
Use C_DECL_ISNT_PROTOTYPE and C_DECL_IMPLICIT.
(store_parm_decls): It's IDENTIFIER_SYMBOL_VALUE now.
(identifier_global_value): Same. Must scan
global_binding_level in extremis.
* c-typeck.c (undeclared_variable): New static function, split
from build_external_ref.
(build_external_ref): Use DECL_CONTEXT, not
IDENTIFIER_LOCAL_VALUE, to decide whether a local hides
an instance variable. Restructure for clarity.
* objc/objc-act.c: Use identifier_global_value, not
IDENTIFIER_GLOBAL_VALUE.
testsuite:
* gcc.c-torture/execute/builtin-noret-2.c: New.
* gcc.c-torture/execute/builtin-noret-2.x: New.
XFAIL builtin-noret-2.c at -O1 and above.
* gcc.dg/redecl.c: New.
===================================================================
Index: c-decl.c
--- c-decl.c 3 Apr 2003 18:23:01 -0000 1.375
+++ c-decl.c 11 Apr 2003 02:23:00 -0000
@@ -1,6 +1,6 @@
/* Process declarations and variables for C compiler.
Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002 Free Software Foundation, Inc.
+ 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
@@ -122,6 +122,10 @@ static GTY(()) tree named_labels;
static GTY(()) tree shadowed_labels;
+/* A list of external DECLs that appeared at block scope when there was
+ some other global meaning for that identifier. */
+static GTY(()) tree truly_local_externals;
+
/* Set to 0 at beginning of a function definition, set to 1 if
a return statement that specifies a return value is seen. */
@@ -159,9 +163,6 @@ static int current_extern_inline;
* the current one out to the global one.
*/
-/* Note that the information in the `names' component of the global contour
- is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
-
struct binding_level GTY(())
{
/* A chain of _DECL nodes for all variables, constants, functions,
@@ -177,7 +178,7 @@ struct binding_level GTY(())
*/
tree tags;
- /* For each level, a list of shadowed outer-level local definitions
+ /* For each level, a list of shadowed outer-level definitions
to be restored when this level is popped.
Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
@@ -269,23 +270,26 @@ tree static_ctors, static_dtors;
/* Forward declarations. */
static struct binding_level *make_binding_level PARAMS ((void));
-static struct binding_level *get_function_binding_level PARAMS ((void));
static void pop_binding_level PARAMS ((struct binding_level **));
-static void clear_limbo_values PARAMS ((tree));
static int duplicate_decls PARAMS ((tree, tree, int));
static int redeclaration_error_message PARAMS ((tree, tree));
+static void implicit_decl_warning PARAMS ((tree));
static void storedecls PARAMS ((tree));
static void storetags PARAMS ((tree));
static tree lookup_tag PARAMS ((enum tree_code, tree,
struct binding_level *, int));
static tree lookup_tag_reverse PARAMS ((tree));
+static tree lookup_name_current_level PARAMS ((tree));
static tree grokdeclarator PARAMS ((tree, tree, enum decl_context,
int));
static tree grokparms PARAMS ((tree, int));
static void layout_array_type PARAMS ((tree));
static tree c_make_fname_decl PARAMS ((tree, int));
static void c_expand_body_1 PARAMS ((tree, int));
+static tree any_external_decl PARAMS ((tree));
+static void record_external_decl PARAMS ((tree));
static void warn_if_shadowing PARAMS ((tree, tree));
+static void clone_underlying_type PARAMS ((tree));
static bool flexible_array_type_p PARAMS ((tree));
/* States indicating how grokdeclarator() should handle declspecs marked
@@ -306,11 +310,9 @@ c_print_identifier (file, node, indent)
tree node;
int indent;
{
- print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
- print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
+ print_node (file, "symbol", IDENTIFIER_SYMBOL_VALUE (node), indent + 4);
+ print_node (file, "tag", IDENTIFIER_TAG_VALUE (node), indent + 4);
print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
- print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
- print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
if (C_IS_RESERVED_WORD (node))
{
tree rid = ridpointers[C_RID_CODE (node)];
@@ -360,17 +362,6 @@ make_binding_level ()
return (struct binding_level *) ggc_alloc (sizeof (struct binding_level));
}
-/* Return the outermost binding level for the current function. */
-static struct binding_level *
-get_function_binding_level ()
-{
- struct binding_level *b = current_binding_level;
-
- while (b->level_chain->parm_flag == 0)
- b = b->level_chain;
- return b;
-}
-
/* Remove a binding level from a list and add it to the level chain. */
static void
@@ -469,22 +460,6 @@ pushlevel (tag_transparent)
keep_next_if_subblocks = 0;
}
-/* Clear the limbo values of all identifiers defined in BLOCK or a subblock. */
-
-static void
-clear_limbo_values (block)
- tree block;
-{
- tree tem;
-
- for (tem = BLOCK_VARS (block); tem; tem = TREE_CHAIN (tem))
- if (DECL_NAME (tem) != 0)
- IDENTIFIER_LIMBO_VALUE (DECL_NAME (tem)) = 0;
-
- for (tem = BLOCK_SUBBLOCKS (block); tem; tem = TREE_CHAIN (tem))
- clear_limbo_values (tem);
-}
-
/* Exit a binding level.
Pop the level off, and restore the state of the identifier-decl mappings
that were in effect when this level was entered.
@@ -518,33 +493,6 @@ poplevel (keep, reverse, functionbody)
keep |= current_binding_level->keep;
- /* This warning is turned off because it causes warnings for
- declarations like `extern struct foo *x'. */
-#if 0
- /* Warn about incomplete structure types in this level. */
- for (link = tags; link; link = TREE_CHAIN (link))
- if (!COMPLETE_TYPE_P (TREE_VALUE (link)))
- {
- tree type = TREE_VALUE (link);
- tree type_name = TYPE_NAME (type);
- char *id = IDENTIFIER_POINTER (TREE_CODE (type_name) == IDENTIFIER_NODE
- ? type_name
- : DECL_NAME (type_name));
- switch (TREE_CODE (type))
- {
- case RECORD_TYPE:
- error ("`struct %s' incomplete in scope ending here", id);
- break;
- case UNION_TYPE:
- error ("`union %s' incomplete in scope ending here", id);
- break;
- case ENUMERAL_TYPE:
- error ("`enum %s' incomplete in scope ending here", id);
- break;
- }
- }
-#endif /* 0 */
-
/* Get the decls in the order they were written.
Usually current_binding_level->names is in reverse order.
But parameter decls were previously put in forward order. */
@@ -609,16 +557,12 @@ poplevel (keep, reverse, functionbody)
{
if (DECL_NAME (link) != 0)
{
- /* If the ident. was used or addressed via a local extern decl,
- don't forget that fact. */
if (DECL_EXTERNAL (link))
- {
- if (TREE_USED (link))
- TREE_USED (DECL_NAME (link)) = 1;
- if (TREE_ADDRESSABLE (link))
- TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
- }
- IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
+ /* External decls stay in the symbol-value slot but are
+ inaccessible. */
+ C_DECL_INVISIBLE (link) = 1;
+ else
+ IDENTIFIER_SYMBOL_VALUE (DECL_NAME (link)) = 0;
}
}
@@ -626,7 +570,7 @@ poplevel (keep, reverse, functionbody)
that were shadowed by this level. */
for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
- IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
+ IDENTIFIER_SYMBOL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
/* If the level being exited is the top level of a function,
check over all the labels, and clear out the current
@@ -634,8 +578,6 @@ poplevel (keep, reverse, functionbody)
if (functionbody)
{
- clear_limbo_values (block);
-
/* If this is the top level block of a function,
the vars are the function's parameters.
Don't leave them in the BLOCK because they are
@@ -966,11 +908,14 @@ duplicate_decls (newdecl, olddecl, diffe
return 0;
}
- /* For real parm decl following a forward decl,
- return 1 so old decl will be reused. */
+ /* For real parm decl following a forward decl, return 1 so old decl
+ will be reused. Only allow this to happen once. */
if (types_match && TREE_CODE (newdecl) == PARM_DECL
&& TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
- return 1;
+ {
+ TREE_ASM_WRITTEN (olddecl) = 0;
+ return 1;
+ }
/* The new declaration is the same kind of object as the old one.
The declarations may partially match. Print warnings if they don't
@@ -1107,6 +1052,20 @@ duplicate_decls (newdecl, olddecl, diffe
we will come back here again. */
DECL_IN_SYSTEM_HEADER (newdecl) = 1;
}
+ /* Permit void foo (...) to match int foo (...) if the latter is the
+ definition and implicit int was used. See c-torture/compile/920625-2.c. */
+ else if (!types_match && new_is_definition
+ && TREE_CODE (olddecl) == FUNCTION_DECL
+ && TREE_CODE (newdecl) == FUNCTION_DECL
+ && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
+ && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
+ && C_FUNCTION_IMPLICIT_INT (newdecl))
+ {
+ pedwarn_with_decl (newdecl, "conflicting types for `%s'");
+ /* Make sure we keep void as the return type. */
+ TREE_TYPE (newdecl) = newtype = oldtype;
+ C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
+ }
else if (!types_match
/* Permit char *foo (int, ...); followed by char *foo ();
if not pedantic. */
@@ -1151,7 +1110,10 @@ duplicate_decls (newdecl, olddecl, diffe
}
}
}
- error_with_decl (olddecl, "previous declaration of `%s'");
+ if (C_DECL_IMPLICIT (olddecl))
+ error_with_decl (olddecl, "previous implicit declaration of `%s'");
+ else
+ error_with_decl (olddecl, "previous declaration of `%s'");
/* This is safer because the initializer might contain references
to variables that were declared between olddecl and newdecl. This
@@ -1592,58 +1554,152 @@ duplicate_decls (newdecl, olddecl, diffe
return 1;
}
+/* Return any external DECL associated with ID, whether or not it is
+ currently in scope. */
+static tree
+any_external_decl (id)
+ tree id;
+{
+ tree decl = IDENTIFIER_SYMBOL_VALUE (id);
+ tree t;
+
+ if (decl && TREE_CODE (decl) != TYPE_DECL && DECL_EXTERNAL (decl))
+ return decl;
+
+ t = purpose_member (id, truly_local_externals);
+ if (t)
+ return TREE_VALUE (t);
+
+ return 0;
+}
+
+/* Record an external decl DECL. This only does something if a
+ shadowing decl already exists. */
+static void
+record_external_decl (decl)
+ tree decl;
+{
+ tree name = DECL_NAME (decl);
+ if (!IDENTIFIER_SYMBOL_VALUE (name))
+ return;
+
+ truly_local_externals = tree_cons (name, decl, truly_local_externals);
+}
+
/* Check whether decl-node X shadows an existing declaration.
- OLDLOCAL is the old IDENTIFIER_LOCAL_VALUE of the DECL_NAME of X,
+ OLD is the old IDENTIFIER_SYMBOL_VALUE of the DECL_NAME of X,
which might be a NULL_TREE. */
static void
-warn_if_shadowing (x, oldlocal)
- tree x, oldlocal;
+warn_if_shadowing (x, old)
+ tree x, old;
{
- tree sym;
const char *name;
- if (DECL_EXTERNAL (x))
+ if (old == 0)
+ /* Nothing to shadow. */
return;
- sym = DECL_NAME (x);
- name = IDENTIFIER_POINTER (sym);
+ name = IDENTIFIER_POINTER (DECL_NAME (x));
- /* Warn if shadowing an argument at the top level of the body. */
- if (oldlocal != 0
- /* This warning doesn't apply to the parms of a nested fcn. */
- && ! current_binding_level->parm_flag
+ /* Warn unconditionally (constraint violation, C99 6.7p3 - params
+ and locals declared at the outermost block scope of a function
+ have the same scope, even though we give them different binding
+ contours) if shadowing an argument at the top level of the body.
+ This warning doesn't apply to the parms of a nested fcn. */
+ if (! current_binding_level->parm_flag
/* Check that this is one level down from the parms. */
+ && current_binding_level->level_chain
&& current_binding_level->level_chain->parm_flag
/* Check that the decl being shadowed
comes from the parm level, one level up. */
- && chain_member (oldlocal, current_binding_level->level_chain->names))
- shadow_warning (SW_PARAM, true, name, oldlocal);
- /* Maybe warn if shadowing something else. */
+ && chain_member (old, current_binding_level->level_chain->names))
+ shadow_warning (SW_PARAM, true, name, old);
+ /* Warnings for other cases of shadowing are optional. */
else if (warn_shadow
/* No shadow warnings for internally generated vars. */
&& DECL_SOURCE_LINE (x) != 0
/* No shadow warnings for vars made for inlining. */
- && ! DECL_FROM_INLINE (x))
+ && ! DECL_FROM_INLINE (x)
+ /* Don't warn about the parm names in function declarator
+ within a function declarator.
+ It would be nice to avoid warning in any function
+ declarator in a declaration, as opposed to a definition,
+ but there is no way to tell it's not a definition. */
+ && !(TREE_CODE (x) == PARM_DECL
+ && current_binding_level->level_chain->parm_flag))
+ {
+ if (TREE_CODE (old) == PARM_DECL)
+ shadow_warning (SW_PARAM, false, name, old);
+ else if (DECL_CONTEXT (old) == 0)
+ shadow_warning (SW_GLOBAL, false, name, old);
+ else
+ shadow_warning (SW_LOCAL, false, name, old);
+ }
+}
+
+
+/* Subroutine of pushdecl.
+
+ X is a TYPE_DECL for a typedef statement. Create a brand new
+ ..._TYPE node (which will be just a variant of the existing
+ ..._TYPE node with identical properties) and then install X
+ as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
+
+ The whole point here is to end up with a situation where each
+ and every ..._TYPE node the compiler creates will be uniquely
+ associated with AT MOST one node representing a typedef name.
+ This way, even though the compiler substitutes corresponding
+ ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
+ early on, later parts of the compiler can always do the reverse
+ translation and get back the corresponding typedef name. For
+ example, given:
+
+ typedef struct S MY_TYPE;
+ MY_TYPE object;
+
+ Later parts of the compiler might only know that `object' was of
+ type `struct S' if it were not for code just below. With this
+ code however, later parts of the compiler see something like:
+
+ struct S' == struct S
+ typedef struct S' MY_TYPE;
+ struct S' object;
+
+ And they can then deduce (from the node for type struct S') that
+ the original object declaration was:
+
+ MY_TYPE object;
+
+ Being able to do this is important for proper support of protoize,
+ and also for generating precise symbolic debugging information
+ which takes full account of the programmer's (typedef) vocabulary.
+
+ Obviously, we don't want to generate a duplicate ..._TYPE node if
+ the TYPE_DECL node that we are now processing really represents a
+ standard built-in type.
+
+ Since all standard types are effectively declared at line zero
+ in the source file, we can easily check to see if we are working
+ on a standard type by checking the current value of lineno. */
+
+static void
+clone_underlying_type (x)
+ tree x;
+{
+ if (DECL_SOURCE_LINE (x) == 0)
{
- if (TREE_CODE (x) == PARM_DECL
- && current_binding_level->level_chain->parm_flag)
- /* Don't warn about the parm names in function declarator
- within a function declarator.
- It would be nice to avoid warning in any function
- declarator in a declaration, as opposed to a definition,
- but there is no way to tell it's not a definition. */
- ;
- else if (oldlocal)
- {
- if (TREE_CODE (oldlocal) == PARM_DECL)
- shadow_warning (SW_PARAM, false, name, oldlocal);
- else
- shadow_warning (SW_LOCAL, false, name, oldlocal);
- }
- else if (IDENTIFIER_GLOBAL_VALUE (sym) != 0
- && IDENTIFIER_GLOBAL_VALUE (sym) != error_mark_node)
- shadow_warning (SW_GLOBAL, false, name,
- IDENTIFIER_GLOBAL_VALUE (sym));
+ if (TYPE_NAME (TREE_TYPE (x)) == 0)
+ TYPE_NAME (TREE_TYPE (x)) = x;
+ }
+ else if (TREE_TYPE (x) != error_mark_node
+ && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
+ {
+ tree tt = TREE_TYPE (x);
+ DECL_ORIGINAL_TYPE (x) = tt;
+ tt = build_type_copy (tt);
+ TYPE_NAME (tt) = x;
+ TREE_USED (tt) = TREE_USED (x);
+ TREE_TYPE (x) = tt;
}
}
@@ -1659,343 +1715,75 @@ tree
pushdecl (x)
tree x;
{
- tree t;
tree name = DECL_NAME (x);
- struct binding_level *b = current_binding_level;
+ struct binding_level *scope = current_binding_level;
+
+#ifdef ENABLE_CHECKING
+ if (error_mark_node == 0)
+ /* Called too early. */
+ abort ();
+#endif
/* Functions need the lang_decl data. */
if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_LANG_SPECIFIC (x))
DECL_LANG_SPECIFIC (x) = (struct lang_decl *)
ggc_alloc_cleared (sizeof (struct lang_decl));
- DECL_CONTEXT (x) = current_function_decl;
/* A local extern declaration for a function doesn't constitute nesting.
A local auto declaration does, since it's a forward decl
for a nested function coming later. */
if ((TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
&& DECL_INITIAL (x) == 0 && DECL_EXTERNAL (x))
DECL_CONTEXT (x) = 0;
+ else
+ DECL_CONTEXT (x) = current_function_decl;
if (name)
{
- int different_binding_level = 0;
+ tree old;
if (warn_nested_externs
+ && scope != global_binding_level
&& DECL_EXTERNAL (x)
- && b != global_binding_level
- && x != IDENTIFIER_IMPLICIT_DECL (name)
- /* No error messages for __FUNCTION__ and __PRETTY_FUNCTION__. */
&& !DECL_IN_SYSTEM_HEADER (x))
warning ("nested extern declaration of `%s'",
IDENTIFIER_POINTER (name));
- t = lookup_name_current_level (name);
- if (! t && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
- {
- t = IDENTIFIER_GLOBAL_VALUE (name);
- /* Type decls at global scope don't conflict with externs declared
- inside lexical blocks. */
- if (! t || TREE_CODE (t) == TYPE_DECL)
- /* If there's no visible global declaration, try for an
- invisible one. */
- t = IDENTIFIER_LIMBO_VALUE (name);
- different_binding_level = 1;
- }
- if (t != 0 && t == error_mark_node)
- /* error_mark_node is 0 for a while during initialization! */
- {
- t = 0;
- error_with_decl (x, "`%s' used prior to declaration");
- }
-
- /* If this decl is `static' and an implicit decl was seen previously,
- warn. */
- if (TREE_PUBLIC (name)
- /* Don't test for DECL_EXTERNAL, because grokdeclarator
- sets this for all functions. */
- && ! TREE_PUBLIC (x)
- && (TREE_CODE (x) == FUNCTION_DECL || b == global_binding_level)
- /* We used to warn also for explicit extern followed by static,
- but sometimes you need to do it that way. */
- && IDENTIFIER_IMPLICIT_DECL (name) != 0)
- {
- pedwarn ("`%s' was declared implicitly `extern' and later `static'",
- IDENTIFIER_POINTER (name));
- pedwarn_with_file_and_line
- (DECL_SOURCE_FILE (IDENTIFIER_IMPLICIT_DECL (name)),
- DECL_SOURCE_LINE (IDENTIFIER_IMPLICIT_DECL (name)),
- "previous declaration of `%s'",
- IDENTIFIER_POINTER (name));
- TREE_THIS_VOLATILE (name) = 1;
- }
-
- if (t != 0 && duplicate_decls (x, t, different_binding_level))
- {
- if (TREE_CODE (t) == PARM_DECL)
- {
- /* Don't allow more than one "real" duplicate
- of a forward parm decl. */
- TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
- return t;
- }
- return t;
- }
-
- /* If we are processing a typedef statement, generate a whole new
- ..._TYPE node (which will be just a variant of the existing
- ..._TYPE node with identical properties) and then install the
- TYPE_DECL node generated to represent the typedef name as the
- TYPE_NAME of this brand new (duplicate) ..._TYPE node.
-
- The whole point here is to end up with a situation where each
- and every ..._TYPE node the compiler creates will be uniquely
- associated with AT MOST one node representing a typedef name.
- This way, even though the compiler substitutes corresponding
- ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
- early on, later parts of the compiler can always do the reverse
- translation and get back the corresponding typedef name. For
- example, given:
-
- typedef struct S MY_TYPE;
- MY_TYPE object;
-
- Later parts of the compiler might only know that `object' was of
- type `struct S' if it were not for code just below. With this
- code however, later parts of the compiler see something like:
-
- struct S' == struct S
- typedef struct S' MY_TYPE;
- struct S' object;
-
- And they can then deduce (from the node for type struct S') that
- the original object declaration was:
-
- MY_TYPE object;
-
- Being able to do this is important for proper support of protoize,
- and also for generating precise symbolic debugging information
- which takes full account of the programmer's (typedef) vocabulary.
-
- Obviously, we don't want to generate a duplicate ..._TYPE node if
- the TYPE_DECL node that we are now processing really represents a
- standard built-in type.
-
- Since all standard types are effectively declared at line zero
- in the source file, we can easily check to see if we are working
- on a standard type by checking the current value of lineno. */
-
- if (TREE_CODE (x) == TYPE_DECL)
- {
- if (DECL_SOURCE_LINE (x) == 0)
- {
- if (TYPE_NAME (TREE_TYPE (x)) == 0)
- TYPE_NAME (TREE_TYPE (x)) = x;
- }
- else if (TREE_TYPE (x) != error_mark_node
- && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
+ old = lookup_name_current_level (name);
+ if (old && duplicate_decls (x, old, 0))
+ return old;
+ if (DECL_EXTERNAL (x) || scope == global_binding_level)
+ {
+ /* Find and check against a previous, not-in-scope, external
+ decl for this identifier. (C99 s???: If two declarations
+ with external linkage, referring to the same object, have
+ incompatible types, the behavior is undefined). */
+ tree ext = any_external_decl (name);
+ if (ext)
{
- tree tt = TREE_TYPE (x);
- DECL_ORIGINAL_TYPE (x) = tt;
- tt = build_type_copy (tt);
- TYPE_NAME (tt) = x;
- TREE_USED (tt) = TREE_USED (x);
- TREE_TYPE (x) = tt;
+ if (duplicate_decls (x, ext, scope != global_binding_level))
+ x = copy_node (ext);
}
- }
-
- /* Multiple external decls of the same identifier ought to match.
- We get warnings about inline functions where they are defined.
- Avoid duplicate warnings where they are used. */
- if (TREE_PUBLIC (x)
- && ! (TREE_CODE (x) == FUNCTION_DECL && DECL_INLINE (x)))
- {
- tree decl;
-
- if (IDENTIFIER_LIMBO_VALUE (name) != 0)
- /* Decls in limbo are always extern, so no need to check that. */
- decl = IDENTIFIER_LIMBO_VALUE (name);
else
- decl = 0;
-
- if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
- /* If old decl is built-in, we already warned if we should. */
- && !DECL_BUILT_IN (decl))
- {
- pedwarn_with_decl (x,
- "type mismatch with previous external decl");
- pedwarn_with_decl (decl, "previous external decl of `%s'");
- }
- }
-
- /* If a function has had an implicit declaration, and then is defined,
- make sure they are compatible. */
-
- if (IDENTIFIER_IMPLICIT_DECL (name) != 0
- && IDENTIFIER_GLOBAL_VALUE (name) == 0
- && TREE_CODE (x) == FUNCTION_DECL
- && ! comptypes (TREE_TYPE (x),
- TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
- {
- warning_with_decl (x, "type mismatch with previous implicit declaration");
- warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
- "previous implicit declaration of `%s'");
+ record_external_decl (x);
}
+
+ if (TREE_CODE (x) == TYPE_DECL)
+ clone_underlying_type (x);
- /* This name is new in its binding level.
- Install the new declaration and return it. */
- if (b == global_binding_level)
+ old = IDENTIFIER_SYMBOL_VALUE (name);
+ if (scope != global_binding_level && old)
{
- /* Install a global value. */
-
- /* If the first global decl has external linkage,
- warn if we later see static one. */
- if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
- TREE_PUBLIC (name) = 1;
-
- IDENTIFIER_GLOBAL_VALUE (name) = x;
-
- /* We no longer care about any previous block level declarations. */
- IDENTIFIER_LIMBO_VALUE (name) = 0;
-
- /* Don't forget if the function was used via an implicit decl. */
- if (IDENTIFIER_IMPLICIT_DECL (name)
- && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
- TREE_USED (x) = 1, TREE_USED (name) = 1;
-
- /* Don't forget if its address was taken in that way. */
- if (IDENTIFIER_IMPLICIT_DECL (name)
- && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
- TREE_ADDRESSABLE (x) = 1;
-
- /* Warn about mismatches against previous implicit decl. */
- if (IDENTIFIER_IMPLICIT_DECL (name) != 0
- /* If this real decl matches the implicit, don't complain. */
- && ! (TREE_CODE (x) == FUNCTION_DECL
- && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
- == integer_type_node)))
- pedwarn ("`%s' was previously implicitly declared to return `int'",
- IDENTIFIER_POINTER (name));
-
- /* If this decl is `static' and an `extern' was seen previously,
- that is erroneous. */
- if (TREE_PUBLIC (name)
- && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
- {
- /* Okay to redeclare an ANSI built-in as static. */
- if (t != 0 && DECL_BUILT_IN (t))
- ;
- /* Okay to declare a non-ANSI built-in as anything. */
- else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
- ;
- /* Okay to have global type decl after an earlier extern
- declaration inside a lexical block. */
- else if (TREE_CODE (x) == TYPE_DECL)
- ;
- else if (IDENTIFIER_IMPLICIT_DECL (name))
- {
- if (! TREE_THIS_VOLATILE (name))
- pedwarn ("`%s' was declared implicitly `extern' and later `static'",
- IDENTIFIER_POINTER (name));
- }
- else
- pedwarn ("`%s' was declared `extern' and later `static'",
- IDENTIFIER_POINTER (name));
- }
+ /* If storing a local value, there may already be one
+ (inherited). If so, record it for restoration when this
+ binding level ends. */
+ warn_if_shadowing (x, old);
+ scope->shadowed = tree_cons (name, old, scope->shadowed);
}
- else
- {
- /* Here to install a non-global value. */
- tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
- tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
-
- IDENTIFIER_LOCAL_VALUE (name) = x;
-
- /* If this is an extern function declaration, see if we
- have a global definition or declaration for the function. */
- if (oldlocal == 0
- && oldglobal != 0
- && TREE_CODE (x) == FUNCTION_DECL
- && TREE_CODE (oldglobal) == FUNCTION_DECL
- && DECL_EXTERNAL (x)
- && ! DECL_DECLARED_INLINE_P (x))
- {
- /* We have one. Their types must agree. */
- if (! comptypes (TREE_TYPE (x),
- TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
- pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
- else
- {
- /* Inner extern decl is inline if global one is.
- Copy enough to really inline it. */
- if (DECL_DECLARED_INLINE_P (oldglobal))
- {
- DECL_DECLARED_INLINE_P (x)
- = DECL_DECLARED_INLINE_P (oldglobal);
- DECL_INLINE (x) = DECL_INLINE (oldglobal);
- DECL_INITIAL (x) = (current_function_decl == oldglobal
- ? 0 : DECL_INITIAL (oldglobal));
- DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
- DECL_NUM_STMTS (x) = DECL_NUM_STMTS (oldglobal);
- DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
- DECL_RESULT (x) = DECL_RESULT (oldglobal);
- TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
- DECL_ABSTRACT_ORIGIN (x)
- = DECL_ABSTRACT_ORIGIN (oldglobal);
- }
- /* Inner extern decl is built-in if global one is. */
- if (DECL_BUILT_IN (oldglobal))
- {
- DECL_BUILT_IN_CLASS (x) = DECL_BUILT_IN_CLASS (oldglobal);
- DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal);
- }
- /* Keep the arg types from a file-scope fcn defn. */
- if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
- && DECL_INITIAL (oldglobal)
- && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
- TREE_TYPE (x) = TREE_TYPE (oldglobal);
- }
- }
-#if 0
- /* This case is probably sometimes the right thing to do. */
- /* If we have a local external declaration,
- then any file-scope declaration should not
- have been static. */
- if (oldlocal == 0 && oldglobal != 0
- && !TREE_PUBLIC (oldglobal)
- && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
- warning ("`%s' locally external but globally static",
- IDENTIFIER_POINTER (name));
-#endif
-
- /* If we have a local external declaration,
- and no file-scope declaration has yet been seen,
- then if we later have a file-scope decl it must not be static. */
- if (oldlocal == 0
- && DECL_EXTERNAL (x)
- && TREE_PUBLIC (x))
- {
- if (oldglobal == 0)
- TREE_PUBLIC (name) = 1;
-
- /* Save this decl, so that we can do type checking against
- other decls after it falls out of scope.
-
- Only save it once. This prevents temporary decls created in
- expand_inline_function from being used here, since this
- will have been set when the inline function was parsed.
- It also helps give slightly better warnings. */
- if (IDENTIFIER_LIMBO_VALUE (name) == 0)
- IDENTIFIER_LIMBO_VALUE (name) = x;
- }
-
- warn_if_shadowing (x, oldlocal);
-
- /* If storing a local value, there may already be one (inherited).
- If so, record it for restoration when this binding level ends. */
- if (oldlocal != 0)
- b->shadowed = tree_cons (name, oldlocal, b->shadowed);
- }
+ /* Install the new declaration in the requested binding level. */
+ IDENTIFIER_SYMBOL_VALUE (name) = x;
+ C_DECL_INVISIBLE (x) = 0;
/* Keep list of variables in this level with incomplete type.
If the input is erroneous, we can have error_mark in the type
@@ -2010,96 +1798,129 @@ pushdecl (x)
element = TREE_TYPE (element);
if (TREE_CODE (element) == RECORD_TYPE
|| TREE_CODE (element) == UNION_TYPE)
- b->incomplete_list = tree_cons (NULL_TREE, x, b->incomplete_list);
+ scope->incomplete_list = tree_cons (NULL_TREE, x,
+ scope->incomplete_list);
}
}
/* Put decls on list in reverse order.
We will reverse them later if necessary. */
- TREE_CHAIN (x) = b->names;
- b->names = x;
+ TREE_CHAIN (x) = scope->names;
+ scope->names = x;
return x;
}
-/* Record that the local value of NAME is shadowed at function scope.
- This is used by build_external_ref in c-typeck.c. */
-void
-record_function_scope_shadow (name)
- tree name;
+/* Record X as belonging to the global scope (C99 "file scope").
+ This is used only internally by the Objective C front end,
+ and is limited to its needs. It will hork if there is _any_
+ visible binding for X (not just a global one). */
+tree
+pushdecl_top_level (x)
+ tree x;
{
- struct binding_level *b = get_function_binding_level ();
- b->shadowed = tree_cons (name, IDENTIFIER_LOCAL_VALUE (name),
- b->shadowed);
-}
+ tree name, old;
+
+ if (TREE_CODE (x) != VAR_DECL)
+ abort ();
+
+ name = DECL_NAME (x);
+ old = IDENTIFIER_SYMBOL_VALUE (name);
-/* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
+ if (old)
+ {
+ if (DECL_CONTEXT (old))
+ abort ();
+
+ if (!duplicate_decls (x, old, 0))
+ abort ();
+ return old;
+ }
+
+ DECL_CONTEXT (x) = 0;
+ IDENTIFIER_SYMBOL_VALUE (name) = x;
+ TREE_CHAIN (x) = global_binding_level->names;
+ global_binding_level->names = x;
+ return x;
+}
+
+/* Record X as belonging to the outermost scope of the current
+ function. This is used only internally, by c_make_fname_decl and
+ build_external_ref, and is limited to their needs. The NAME is
+ provided as a separate argument because build_external_ref wants to
+ use error_mark_node for X. For VAR_DECLs, duplicate_decls is not
+ called; if there is any preexisting decl for this identifier, it is
+ an ICE. */
tree
-pushdecl_top_level (x)
+pushdecl_function_level (x, name)
tree x;
+ tree name;
{
- tree t;
- struct binding_level *b = current_binding_level;
+ struct binding_level *scope;
- current_binding_level = global_binding_level;
- t = pushdecl (x);
- current_binding_level = b;
- return t;
+ scope = current_binding_level;
+ while (scope->level_chain->parm_flag == 0)
+ scope = scope->level_chain;
+
+ if (x == error_mark_node)
+ scope->shadowed = tree_cons (name, IDENTIFIER_SYMBOL_VALUE (name),
+ scope->shadowed);
+ else if (TREE_CODE (x) == VAR_DECL)
+ {
+ if (name != DECL_NAME (x))
+ abort ();
+ if (IDENTIFIER_SYMBOL_VALUE (name))
+ abort ();
+
+ DECL_CONTEXT (x) = current_function_decl;
+ TREE_CHAIN (x) = scope->names;
+ scope->names = x;
+ }
+
+ IDENTIFIER_SYMBOL_VALUE (name) = x;
+ return x;
}
-/* Generate an implicit declaration for identifier FUNCTIONID
- as a function of type int (). Print a warning if appropriate. */
+/* Generate an implicit declaration for identifier FUNCTIONID as a
+ function of type int (). */
tree
implicitly_declare (functionid)
tree functionid;
{
- tree decl;
- int traditional_warning = 0;
- /* Only one "implicit declaration" warning per identifier. */
- int implicit_warning;
-
- /* We used to reuse an old implicit decl here,
- but this loses with inline functions because it can clobber
- the saved decl chains. */
-#if 0
- if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
- decl = IDENTIFIER_IMPLICIT_DECL (functionid);
- else
-#endif
- decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
+ tree decl = any_external_decl (functionid);
- /* Warn of implicit decl following explicit local extern decl.
- This is probably a program designed for traditional C. */
- if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
- traditional_warning = 1;
-
- /* Warn once of an implicit declaration. */
- implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
+ if (decl && decl != error_mark_node)
+ {
+ /* Implicit declaration of a function already declared
+ (somehow) in a different scope, or as a built-in.
+ If this is the first time this has happened, warn;
+ then recycle the old declaration. */
+ if (!C_DECL_IMPLICIT (decl))
+ {
+ implicit_decl_warning (DECL_NAME (decl));
+ if (DECL_CONTEXT (decl))
+ warning_with_decl (decl, "previous declaration of `%s'");
+ C_DECL_IMPLICIT (decl) = 1;
+ }
+ return pushdecl (decl);
+ }
+ /* Not seen before. */
+ decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
-
- /* Record that we have an implicit decl and this is it. */
- IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
+ C_DECL_IMPLICIT (decl) = 1;
+ implicit_decl_warning (functionid);
/* ANSI standard says implicit declarations are in the innermost block.
So we record the decl in the standard fashion. */
- pushdecl (decl);
-
- /* This is a no-op in c-lang.c or something real in objc-act.c. */
- if (flag_objc)
- objc_check_decl (decl);
+ decl = pushdecl (decl);
+ /* No need to call objc_check_decl here - it's a function type. */
rest_of_decl_compilation (decl, NULL, 0, 0);
- if (implicit_warning)
- implicit_decl_warning (functionid);
- else if (warn_traditional && traditional_warning)
- warning ("function `%s' was previously declared within a block",
- IDENTIFIER_POINTER (functionid));
-
/* Write a record describing this implicit function declaration to the
prototypes file (if requested). */
@@ -2111,7 +1932,7 @@ implicitly_declare (functionid)
return decl;
}
-void
+static void
implicit_decl_warning (id)
tree id;
{
@@ -2450,35 +2271,33 @@ tree
lookup_name (name)
tree name;
{
- tree val;
-
- if (current_binding_level != global_binding_level
- && IDENTIFIER_LOCAL_VALUE (name))
- val = IDENTIFIER_LOCAL_VALUE (name);
- else
- val = IDENTIFIER_GLOBAL_VALUE (name);
- return val;
+ tree decl = IDENTIFIER_SYMBOL_VALUE (name);
+ if (decl == 0 || decl == error_mark_node)
+ return decl;
+ if (C_DECL_INVISIBLE (decl))
+ return 0;
+ return decl;
}
-/* Similar to `lookup_name' but look only at current binding level. */
+/* Similar to `lookup_name' but look only at the current binding level. */
-tree
+static tree
lookup_name_current_level (name)
tree name;
{
- tree t;
+ tree decl = IDENTIFIER_SYMBOL_VALUE (name);
- if (current_binding_level == global_binding_level)
- return IDENTIFIER_GLOBAL_VALUE (name);
-
- if (IDENTIFIER_LOCAL_VALUE (name) == 0)
+ if (decl == 0 || decl == error_mark_node || C_DECL_INVISIBLE (decl))
return 0;
- for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
- if (DECL_NAME (t) == name)
- break;
+ if (current_binding_level == global_binding_level)
+ return decl;
+
+ /* Scan the current scope for a decl with name NAME. */
+ if (chain_member (decl, current_binding_level->names))
+ return decl;
- return t;
+ return 0;
}
/* Create the predefined scalar types of C,
@@ -2558,8 +2377,6 @@ c_make_fname_decl (id, type_dep)
build_index_type (size_int (length)));
decl = build_decl (VAR_DECL, id, type);
- /* We don't push the decl, so have to set its context here. */
- DECL_CONTEXT (decl) = current_function_decl;
TREE_STATIC (decl) = 1;
TREE_READONLY (decl) = 1;
@@ -2572,14 +2389,8 @@ c_make_fname_decl (id, type_dep)
TREE_USED (decl) = 1;
if (current_function_decl)
- {
- /* Add the decls to the outermost block. */
- struct binding_level *old = current_binding_level;
- current_binding_level = get_function_binding_level ();
- pushdecl (decl);
- current_binding_level = old;
- }
-
+ pushdecl_function_level (decl, DECL_NAME (decl));
+
finish_decl (decl, init, NULL_TREE);
return decl;
@@ -2616,7 +2427,7 @@ builtin_function (name, type, function_c
/* Warn if a function in the namespace for users
is used without an occasion to consider it declared. */
if (name[0] != '_' || name[1] != '_')
- C_DECL_ANTICIPATED (decl) = 1;
+ C_DECL_INVISIBLE (decl) = 1;
/* Possibly apply some default attributes to this built-in function. */
if (attrs)
@@ -5750,27 +5561,16 @@ start_function (declspecs, declarator, a
current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
}
- /* If there is no explicit declaration, look for any out-of-scope implicit
- declarations. */
- if (old_decl == 0)
- old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
-
/* Optionally warn of old-fashioned def with no previous prototype. */
if (warn_strict_prototypes
&& TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
- && !(old_decl != 0
- && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
- || (DECL_BUILT_IN (old_decl)
- && ! C_DECL_ANTICIPATED (old_decl)))))
+ && C_DECL_ISNT_PROTOTYPE (old_decl))
warning ("function declaration isn't a prototype");
/* Optionally warn of any global def with no previous prototype. */
else if (warn_missing_prototypes
&& TREE_PUBLIC (decl1)
- && !(old_decl != 0
- && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
- || (DECL_BUILT_IN (old_decl)
- && ! C_DECL_ANTICIPATED (old_decl))))
- && ! MAIN_NAME_P (DECL_NAME (decl1)))
+ && ! MAIN_NAME_P (DECL_NAME (decl1))
+ && C_DECL_ISNT_PROTOTYPE (old_decl))
warning_with_decl (decl1, "no previous prototype for `%s'");
/* Optionally warn of any def with no previous prototype
if the function has already been used. */
@@ -5789,7 +5589,7 @@ start_function (declspecs, declarator, a
if the function has already been used. */
else if (warn_missing_declarations
&& old_decl != 0 && TREE_USED (old_decl)
- && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
+ && C_DECL_IMPLICIT (old_decl))
warning_with_decl (decl1,
"`%s' was used with no declaration before its definition");
@@ -5965,10 +5765,10 @@ store_parm_decls ()
for (decl = current_binding_level->names;
decl; decl = TREE_CHAIN (decl))
if (DECL_NAME (decl))
- IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
+ IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl)) = 0;
for (link = current_binding_level->shadowed;
link; link = TREE_CHAIN (link))
- IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
+ IDENTIFIER_SYMBOL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
current_binding_level->names = 0;
current_binding_level->shadowed = 0;
}
@@ -6918,14 +6718,23 @@ c_expand_decl_stmt (t)
c_expand_body_1 (decl, 1);
}
-/* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
- the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
+/* Return the global value of T as a symbol. */
tree
identifier_global_value (t)
tree t;
{
- return IDENTIFIER_GLOBAL_VALUE (t);
+ tree decl = IDENTIFIER_SYMBOL_VALUE (t);
+ if (decl == 0 || DECL_CONTEXT (decl) == 0)
+ return decl;
+
+ /* Shadowed by something else; find the true global value. */
+ for (decl = global_binding_level->names; decl; decl = TREE_CHAIN (decl))
+ if (DECL_NAME (decl) == t)
+ return decl;
+
+ /* Only local values for this decl. */
+ return 0;
}
/* Record a builtin type for C. If NAME is non-NULL, it is the name used;
===================================================================
Index: c-tree.h
--- c-tree.h 17 Mar 2003 21:16:06 -0000 1.112
+++ c-tree.h 11 Apr 2003 02:23:00 -0000
@@ -1,6 +1,6 @@
/* Definitions for C parsing and type checking.
Copyright (C) 1987, 1993, 1994, 1995, 1997, 1998,
- 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
@@ -37,11 +37,9 @@ Software Foundation, 59 Temple Place - S
struct lang_identifier GTY(())
{
struct c_common_identifier common_id;
- tree global_value;
- tree local_value;
+ tree symbol_value;
+ tree tag_value;
tree label_value;
- tree implicit_decl;
- tree limbo_value;
};
/* The resulting tree type. */
@@ -70,26 +68,17 @@ struct lang_decl GTY(())
/* Macros for access to language-specific slots in an identifier. */
/* Each of these slots contains a DECL node or null. */
-/* This represents the value which the identifier has in the
- file-scope namespace. */
-#define IDENTIFIER_GLOBAL_VALUE(NODE) \
- (((struct lang_identifier *) (NODE))->global_value)
-/* This represents the value which the identifier has in the current
- scope. */
-#define IDENTIFIER_LOCAL_VALUE(NODE) \
- (((struct lang_identifier *) (NODE))->local_value)
-/* This represents the value which the identifier has as a label in
- the current label scope. */
+/* The value of the identifier in the namespace of "ordinary identifiers"
+ (data objects, enum constants, functions, typedefs). */
+#define IDENTIFIER_SYMBOL_VALUE(NODE) \
+ (((struct lang_identifier *) (NODE))->symbol_value)
+/* The value of the identifier in the namespace of struct, union,
+ and enum tags. */
+#define IDENTIFIER_TAG_VALUE(NODE) \
+ (((struct lang_identifier *) (NODE))->tag_value)
+/* The value of the identifier in the namespace of labels. */
#define IDENTIFIER_LABEL_VALUE(NODE) \
(((struct lang_identifier *) (NODE))->label_value)
-/* This records the extern decl of this identifier, if it has had one
- at any point in this compilation. */
-#define IDENTIFIER_LIMBO_VALUE(NODE) \
- (((struct lang_identifier *) (NODE))->limbo_value)
-/* This records the implicit function decl of this identifier, if it
- has had one at any point in this compilation. */
-#define IDENTIFIER_IMPLICIT_DECL(NODE) \
- (((struct lang_identifier *) (NODE))->implicit_decl)
/* In identifiers, C uses the following fields in a special way:
TREE_PUBLIC to record that there was a previous local extern decl.
@@ -129,13 +118,6 @@ struct lang_type GTY(())
#define C_TYPE_VARIABLE_SIZE(TYPE) TYPE_LANG_FLAG_1 (TYPE)
#define C_DECL_VARIABLE_SIZE(TYPE) DECL_LANG_FLAG_0 (TYPE)
-#if 0 /* Not used. */
-/* Record whether a decl for a function or function pointer has
- already been mentioned (in a warning) because it was called
- but didn't have a prototype. */
-#define C_MISSING_PROTOTYPE_WARNED(DECL) DECL_LANG_FLAG_2 (DECL)
-#endif
-
/* Store a value in that field. */
#define C_SET_EXP_ORIGINAL_CODE(EXP, CODE) \
(TREE_COMPLEXITY (EXP) = (int) (CODE))
@@ -147,10 +129,22 @@ struct lang_type GTY(())
return type. */
#define C_FUNCTION_IMPLICIT_INT(EXP) DECL_LANG_FLAG_1 (EXP)
-/* Nonzero for a declaration of a built in function if there has been no
- occasion that would declare the function in ordinary C.
- Using the function draws a pedantic warning in this case. */
-#define C_DECL_ANTICIPATED(EXP) DECL_LANG_FLAG_3 (EXP)
+/* For a FUNCTION_DECL, nonzero if it was an implicit declaration. */
+#define C_DECL_IMPLICIT(EXP) DECL_LANG_FLAG_2 (EXP)
+
+/* Nonzero for a declaration of an external object which is not
+ currently in scope. This is either a built-in declaration of
+ a library function, before a real declaration has been seen,
+ or a declaration that appeared in an inner scope that has ended. */
+#define C_DECL_INVISIBLE(EXP) DECL_LANG_FLAG_3 (EXP)
+
+/* Nonzero for a decl which either doesn't exist or isn't a prototype.
+ N.B. Could be simplified if all built-in decls had complete prototypes
+ (but this is presently difficult because some of them need FILE*). */
+#define C_DECL_ISNT_PROTOTYPE(EXP) \
+ (EXP == 0 \
+ || (TYPE_ARG_TYPES (TREE_TYPE (EXP)) == 0 \
+ && !DECL_BUILT_IN (EXP)))
/* For FUNCTION_TYPE, a hidden list of types of arguments. The same as
TYPE_ARG_TYPES for functions with prototypes, but created for functions
@@ -207,11 +201,9 @@ extern tree grokfield
extern tree groktypename PARAMS ((tree));
extern tree groktypename_in_parm_context PARAMS ((tree));
extern tree implicitly_declare PARAMS ((tree));
-extern void implicit_decl_warning PARAMS ((tree));
extern int in_parm_level_p PARAMS ((void));
extern void keep_next_level PARAMS ((void));
extern tree lookup_name PARAMS ((tree));
-extern tree lookup_name_current_level PARAMS ((tree));
extern void parmlist_tags_warning PARAMS ((void));
extern void pending_xref_error PARAMS ((void));
extern void c_push_function_context PARAMS ((struct function *));
@@ -220,8 +212,8 @@ extern void pop_label_level
extern void push_label_level PARAMS ((void));
extern void push_parm_decl PARAMS ((tree));
extern tree pushdecl_top_level PARAMS ((tree));
+extern tree pushdecl_function_level PARAMS ((tree, tree));
extern void pushtag PARAMS ((tree, tree));
-extern void record_function_scope_shadow PARAMS ((tree));
extern tree set_array_declarator_type PARAMS ((tree, tree, int));
extern tree shadow_label PARAMS ((tree));
extern void shadow_tag PARAMS ((tree));
===================================================================
Index: c-typeck.c
--- c-typeck.c 7 Apr 2003 11:55:25 -0000 1.229
+++ c-typeck.c 11 Apr 2003 02:23:01 -0000
@@ -1,6 +1,6 @@
/* Build expressions with type checking for C compiler.
Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
- 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
@@ -59,6 +59,7 @@ static int type_lists_compatible_p PARAM
static tree decl_constant_value_for_broken_optimization PARAMS ((tree));
static tree default_function_array_conversion PARAMS ((tree));
static tree lookup_field PARAMS ((tree, tree));
+static void undeclared_variable PARAMS ((tree));
static tree convert_arguments PARAMS ((tree, tree, tree, tree));
static tree pointer_diff PARAMS ((tree, tree));
static tree unary_complex_lvalue PARAMS ((enum tree_code, tree, int));
@@ -1375,6 +1376,38 @@ build_array_ref (array, index)
}
}
+/* Issue an error message for a reference to an undeclared variable ID,
+ including a reference to a builtin outside of function-call context.
+ Arrange to suppress further errors for the same identifier. */
+static void
+undeclared_variable (id)
+ tree id;
+{
+ if (current_function_decl == 0)
+ {
+ error ("`%s' undeclared here (not in a function)",
+ IDENTIFIER_POINTER (id));
+ IDENTIFIER_SYMBOL_VALUE (id) = error_mark_node;
+ }
+ else
+ {
+ error ("`%s' undeclared (first use in this function)",
+ IDENTIFIER_POINTER (id));
+
+ if (! undeclared_variable_notice)
+ {
+ error ("(Each undeclared identifier is reported only once");
+ error ("for each function it appears in.)");
+ undeclared_variable_notice = 1;
+ }
+
+ /* Set IDENTIFIER_SYMBOL_VALUE (id) to error_mark_node
+ at function scope. This suppresses further warnings
+ about this undeclared identifier in this function. */
+ pushdecl_function_level (error_mark_node, id);
+ }
+}
+
/* Build an external reference to identifier ID. FUN indicates
whether this will be used for a function call. */
tree
@@ -1386,70 +1419,12 @@ build_external_ref (id, fun)
tree decl = lookup_name (id);
tree objc_ivar = lookup_objc_ivar (id);
- if (decl && TREE_DEPRECATED (decl))
- warn_deprecated_use (decl);
-
- if (!decl || decl == error_mark_node || C_DECL_ANTICIPATED (decl))
- {
- if (objc_ivar)
- ref = objc_ivar;
- else if (fun)
- {
- if (!decl || decl == error_mark_node)
- /* Ordinary implicit function declaration. */
- ref = implicitly_declare (id);
- else
- {
- /* Implicit declaration of built-in function. Don't
- change the built-in declaration, but don't let this
- go by silently, either. */
- implicit_decl_warning (id);
-
- /* only issue this warning once */
- C_DECL_ANTICIPATED (decl) = 0;
- ref = decl;
- }
- }
- else
- {
- /* Don't complain about something that's already been
- complained about. */
- if (decl == error_mark_node)
- return error_mark_node;
-
- /* Reference to undeclared variable, including reference to
- builtin outside of function-call context. */
- if (current_function_decl == 0)
- error ("`%s' undeclared here (not in a function)",
- IDENTIFIER_POINTER (id));
- else
- {
- error ("`%s' undeclared (first use in this function)",
- IDENTIFIER_POINTER (id));
-
- if (! undeclared_variable_notice)
- {
- error ("(Each undeclared identifier is reported only once");
- error ("for each function it appears in.)");
- undeclared_variable_notice = 1;
- }
-
- /* Set IDENTIFIER_LOCAL_VALUE (id) to error_mark_node and
- add a function-scope shadow entry which will undo that.
- This suppresses further warnings about this undeclared
- identifier in this function. */
- record_function_scope_shadow (id);
- IDENTIFIER_LOCAL_VALUE (id) = error_mark_node;
- }
- return error_mark_node;
- }
- }
- else
+ if (decl && decl != error_mark_node)
{
/* Properly declared variable or function reference. */
if (!objc_ivar)
ref = decl;
- else if (decl != objc_ivar && IDENTIFIER_LOCAL_VALUE (id))
+ else if (decl != objc_ivar && DECL_CONTEXT (decl) != 0)
{
warning ("local declaration of `%s' hides instance variable",
IDENTIFIER_POINTER (id));
@@ -1458,9 +1433,26 @@ build_external_ref (id, fun)
else
ref = objc_ivar;
}
+ else if (objc_ivar)
+ ref = objc_ivar;
+ else if (fun)
+ /* Implicit function declaration. */
+ ref = implicitly_declare (id);
+ else if (decl == error_mark_node)
+ /* Don't complain about something that's already been
+ complained about. */
+ return error_mark_node;
+ else
+ {
+ undeclared_variable (id);
+ return error_mark_node;
+ }
if (TREE_TYPE (ref) == error_mark_node)
return error_mark_node;
+
+ if (TREE_DEPRECATED (ref))
+ warn_deprecated_use (ref);
if (!skip_evaluation)
assemble_external (ref);
===================================================================
Index: objc/objc-act.c
--- objc/objc-act.c 8 Mar 2003 21:12:26 -0000 1.168
+++ objc/objc-act.c 11 Apr 2003 02:23:07 -0000
@@ -5298,8 +5298,8 @@ build_protocol_reference (p)
objc_protocol_template),
NULL_TREE));
- if (IDENTIFIER_GLOBAL_VALUE (ident))
- decl = IDENTIFIER_GLOBAL_VALUE (ident); /* Set by pushdecl. */
+ if (identifier_global_value (ident))
+ decl = identifier_global_value (ident); /* Set by pushdecl. */
else
{
decl = build_decl (VAR_DECL, ident, ptype);
===================================================================
Index: testsuite/gcc.c-torture/execute/builtin-noret-2.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ testsuite/gcc.c-torture/execute/builtin-noret-2.c 11 Apr 2003 02:23:11 -0000
@@ -0,0 +1,84 @@
+/* Test for builtin noreturn attributes when the visible declarations
+ are function-local. Doesn't presently work. Modified from
+ builtin-noret-1.c by Zack Weinberg <zack@codesourcery.com>. */
+
+extern void tabort (void);
+extern void texit (void);
+extern void t_exit (void);
+extern void t_Exit (void);
+
+extern void link_failure (void);
+
+int
+main (void)
+{
+ volatile int i = 0;
+ /* The real test here is that the program links. */
+ if (i)
+ tabort ();
+ if (i)
+ texit ();
+ if (i)
+ t_exit ();
+ if (i)
+ t_Exit ();
+ exit (0);
+}
+
+void
+tabort (void)
+{
+ extern void abort (void);
+ abort ();
+ link_failure ();
+}
+
+void
+texit (void)
+{
+ extern void exit (int);
+ exit (1);
+ link_failure ();
+}
+
+void
+t_exit (void)
+{
+ extern void _exit (int);
+ _exit (1);
+ link_failure ();
+}
+
+/* Some non-Unix libcs might not have _exit. This version should never
+ get called. */
+static void
+_exit (int i)
+{
+ abort ();
+}
+
+void
+t_Exit (void)
+{
+ extern void _Exit (int);
+ _Exit (1);
+ link_failure ();
+}
+
+/* Some libcs might not have _Exit. This version should never get called. */
+static void
+_Exit (int i)
+{
+ abort ();
+}
+
+/* When optimizing, no calls to link_failure should remain. In any case,
+ link_failure should not be called. */
+
+#ifndef __OPTIMIZE__
+void
+link_failure (void)
+{
+ abort ();
+}
+#endif
===================================================================
Index: testsuite/gcc.c-torture/execute/builtin-noret-2.x
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ testsuite/gcc.c-torture/execute/builtin-noret-2.x 11 Apr 2003 02:23:11 -0000
@@ -0,0 +1,12 @@
+# This test fails at -O1 and higher.
+set torture_eval_before_compile {
+ global compiler_conditional_xfail_data
+ set compiler_conditional_xfail_data {
+ "Fails at all optimization levels but -O0, see PR10375." \
+ { "*-*-*" } \
+ { "-O*" } \
+ { "-O0" }
+ }
+}
+
+return 0
===================================================================
Index: testsuite/gcc.dg/redecl-1.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ testsuite/gcc.dg/redecl-1.c 11 Apr 2003 02:23:11 -0000
@@ -0,0 +1,101 @@
+/* Test for various situations where a new declaration of an
+ identifier conflicts with an earlier declaration which isn't in the
+ same scope. These are all undefined behavior per C89 sections
+ 6.1.2.2p7, 6.1.2.6p2, and 6.3.2.2p2/footnote 38 (C99 6.2.2p7 and
+ 6.2.7p2 - implicit declarations are invalid in C99). */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -pedantic -Wall -Wno-unused" } */
+
+/* Extern at function scope, clashing with extern at file scope */
+
+extern int foo1; /* { dg-error "previous" } */
+extern int bar1(int); /* { dg-error "previous" } */
+
+void test1(void)
+{
+ extern double foo1; /* { dg-error "conflict" } */
+ extern double bar1(double); /* { dg-error "conflict" } */
+}
+
+/* Extern at file scope, clashing with extern at function scope */
+
+void test2(void)
+{
+ extern double foo2; /* { dg-error "previous" } */
+ extern double bar2(double); /* { dg-error "previous" } */
+}
+
+extern int foo2; /* { dg-error "conflict" } */
+extern int bar2(int); /* { dg-error "conflict" } */
+
+/* Extern at function scope, clashing with extern at earlier function
+ scope. Also, don't be fooled by a typedef at file scope. */
+
+typedef float baz3; /* { dg-bogus } */
+
+void prime3(void)
+{
+ extern int foo3; /* { dg-error "previous" } */
+ extern int bar3(int); /* { dg-error "previous" } */
+ extern int baz3; /* { dg-error "previous" } */
+}
+
+void test3(void)
+{
+ extern double foo3; /* { dg-error "conflict" } */
+ extern double bar3(double); /* { dg-error "conflict" } */
+ extern double baz3; /* { dg-error "conflict" } */
+}
+
+/* Extern at function scope, clashing with previous implicit decl. */
+
+void prime4(void)
+{
+ bar4(); /* { dg-error "previous|implicit" } */
+}
+
+void test4(void)
+{
+ extern double bar4(double); /* { dg-error "conflict" } */
+}
+
+/* Implicit decl, clashing with extern at previous function scope. */
+
+void prime5(void)
+{
+ extern double bar5(double); /* { dg-error "previous" "" { xfail *-*-* } } */
+}
+
+void test5(void)
+{
+ bar5(1); /* { dg-error "implicit" } */
+}
+
+/* Extern then static, both at file scope. */
+
+extern int test6(int); /* { dg-warning "previous" "" { xfail *-*-* } } */
+static int test6(int x)
+{ return x; } /* { dg-warning "follows non-static" } */
+
+
+/* Extern then static, extern at previous function scope. */
+
+void prime7(void)
+{
+ extern int test7(int); /* { dg-warning "previous" "" { xfail *-*-* } } */
+}
+
+static int test7(int x)
+{ return x; } /* { dg-warning "follows non-static" } */
+
+/* Implicit decl then static. */
+
+void prime8(void)
+{
+ test8(); /* { dg-warning "previous" "" { xfail *-*-* } } */
+ /* { dg-warning "implicit" "" { target *-*-* } 96 } */
+}
+
+static int test8(int x)
+{ return x; } /* { dg-warning "follows non-static" } */
More information about the Gcc-patches
mailing list