/* Process declarations and variables for C compiler.
|
/* Process declarations and variables for C compiler.
|
Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
|
Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
|
2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
/* Process declarations and symbol lookup for C front end.
|
/* Process declarations and symbol lookup for C front end.
|
Also constructs types; the standard scalar types at initialization,
|
Also constructs types; the standard scalar types at initialization,
|
and structure, union, array and enum types when they are declared. */
|
and structure, union, array and enum types when they are declared. */
|
|
|
/* ??? not all decl nodes are given the most useful possible
|
/* ??? not all decl nodes are given the most useful possible
|
line numbers. For example, the CONST_DECLs for enum values. */
|
line numbers. For example, the CONST_DECLs for enum values. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "input.h"
|
#include "input.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "intl.h"
|
#include "intl.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "tree-inline.h"
|
#include "tree-inline.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "function.h"
|
#include "function.h"
|
#include "output.h"
|
#include "output.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "c-tree.h"
|
#include "c-tree.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "cpplib.h"
|
#include "cpplib.h"
|
#include "target.h"
|
#include "target.h"
|
#include "debug.h"
|
#include "debug.h"
|
#include "opts.h"
|
#include "opts.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "c-common.h"
|
#include "c-common.h"
|
#include "c-pragma.h"
|
#include "c-pragma.h"
|
#include "c-lang.h"
|
#include "c-lang.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "tree-mudflap.h"
|
#include "tree-mudflap.h"
|
#include "gimple.h"
|
#include "gimple.h"
|
#include "tree-iterator.h"
|
#include "tree-iterator.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "tree-dump.h"
|
#include "tree-dump.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "libfuncs.h"
|
#include "libfuncs.h"
|
#include "except.h"
|
#include "except.h"
|
#include "langhooks-def.h"
|
#include "langhooks-def.h"
|
#include "pointer-set.h"
|
#include "pointer-set.h"
|
#include "gimple.h"
|
#include "gimple.h"
|
#include "plugin.h"
|
#include "plugin.h"
|
|
|
/* In grokdeclarator, distinguish syntactic contexts of declarators. */
|
/* In grokdeclarator, distinguish syntactic contexts of declarators. */
|
enum decl_context
|
enum decl_context
|
{ NORMAL, /* Ordinary declaration */
|
{ NORMAL, /* Ordinary declaration */
|
FUNCDEF, /* Function definition */
|
FUNCDEF, /* Function definition */
|
PARM, /* Declaration of parm before function body */
|
PARM, /* Declaration of parm before function body */
|
FIELD, /* Declaration inside struct or union */
|
FIELD, /* Declaration inside struct or union */
|
TYPENAME}; /* Typename (inside cast or sizeof) */
|
TYPENAME}; /* Typename (inside cast or sizeof) */
|
|
|
/* States indicating how grokdeclarator() should handle declspecs marked
|
/* States indicating how grokdeclarator() should handle declspecs marked
|
with __attribute__((deprecated)). An object declared as
|
with __attribute__((deprecated)). An object declared as
|
__attribute__((deprecated)) suppresses warnings of uses of other
|
__attribute__((deprecated)) suppresses warnings of uses of other
|
deprecated items. */
|
deprecated items. */
|
|
|
enum deprecated_states {
|
enum deprecated_states {
|
DEPRECATED_NORMAL,
|
DEPRECATED_NORMAL,
|
DEPRECATED_SUPPRESS
|
DEPRECATED_SUPPRESS
|
};
|
};
|
|
|
|
|
/* Nonzero if we have seen an invalid cross reference
|
/* Nonzero if we have seen an invalid cross reference
|
to a struct, union, or enum, but not yet printed the message. */
|
to a struct, union, or enum, but not yet printed the message. */
|
tree pending_invalid_xref;
|
tree pending_invalid_xref;
|
|
|
/* File and line to appear in the eventual error message. */
|
/* File and line to appear in the eventual error message. */
|
location_t pending_invalid_xref_location;
|
location_t pending_invalid_xref_location;
|
|
|
/* The file and line that the prototype came from if this is an
|
/* The file and line that the prototype came from if this is an
|
old-style definition; used for diagnostics in
|
old-style definition; used for diagnostics in
|
store_parm_decls_oldstyle. */
|
store_parm_decls_oldstyle. */
|
|
|
static location_t current_function_prototype_locus;
|
static location_t current_function_prototype_locus;
|
|
|
/* Whether this prototype was built-in. */
|
/* Whether this prototype was built-in. */
|
|
|
static bool current_function_prototype_built_in;
|
static bool current_function_prototype_built_in;
|
|
|
/* The argument type information of this prototype. */
|
/* The argument type information of this prototype. */
|
|
|
static tree current_function_prototype_arg_types;
|
static tree current_function_prototype_arg_types;
|
|
|
/* The argument information structure for the function currently being
|
/* The argument information structure for the function currently being
|
defined. */
|
defined. */
|
|
|
static struct c_arg_info *current_function_arg_info;
|
static struct c_arg_info *current_function_arg_info;
|
|
|
/* The obstack on which parser and related data structures, which are
|
/* The obstack on which parser and related data structures, which are
|
not live beyond their top-level declaration or definition, are
|
not live beyond their top-level declaration or definition, are
|
allocated. */
|
allocated. */
|
struct obstack parser_obstack;
|
struct obstack parser_obstack;
|
|
|
/* The current statement tree. */
|
/* The current statement tree. */
|
|
|
static GTY(()) struct stmt_tree_s c_stmt_tree;
|
static GTY(()) struct stmt_tree_s c_stmt_tree;
|
|
|
/* State saving variables. */
|
/* State saving variables. */
|
tree c_break_label;
|
tree c_break_label;
|
tree c_cont_label;
|
tree c_cont_label;
|
|
|
/* Linked list of TRANSLATION_UNIT_DECLS for the translation units
|
/* Linked list of TRANSLATION_UNIT_DECLS for the translation units
|
included in this invocation. Note that the current translation
|
included in this invocation. Note that the current translation
|
unit is not included in this list. */
|
unit is not included in this list. */
|
|
|
static GTY(()) tree all_translation_units;
|
static GTY(()) tree all_translation_units;
|
|
|
/* A list of decls to be made automatically visible in each file scope. */
|
/* A list of decls to be made automatically visible in each file scope. */
|
static GTY(()) tree visible_builtins;
|
static GTY(()) tree visible_builtins;
|
|
|
/* Set to 0 at beginning of a function definition, set to 1 if
|
/* Set to 0 at beginning of a function definition, set to 1 if
|
a return statement that specifies a return value is seen. */
|
a return statement that specifies a return value is seen. */
|
|
|
int current_function_returns_value;
|
int current_function_returns_value;
|
|
|
/* Set to 0 at beginning of a function definition, set to 1 if
|
/* Set to 0 at beginning of a function definition, set to 1 if
|
a return statement with no argument is seen. */
|
a return statement with no argument is seen. */
|
|
|
int current_function_returns_null;
|
int current_function_returns_null;
|
|
|
/* Set to 0 at beginning of a function definition, set to 1 if
|
/* Set to 0 at beginning of a function definition, set to 1 if
|
a call to a noreturn function is seen. */
|
a call to a noreturn function is seen. */
|
|
|
int current_function_returns_abnormally;
|
int current_function_returns_abnormally;
|
|
|
/* Set to nonzero by `grokdeclarator' for a function
|
/* Set to nonzero by `grokdeclarator' for a function
|
whose return type is defaulted, if warnings for this are desired. */
|
whose return type is defaulted, if warnings for this are desired. */
|
|
|
static int warn_about_return_type;
|
static int warn_about_return_type;
|
|
|
/* Nonzero when the current toplevel function contains a declaration
|
/* Nonzero when the current toplevel function contains a declaration
|
of a nested function which is never defined. */
|
of a nested function which is never defined. */
|
|
|
static bool undef_nested_function;
|
static bool undef_nested_function;
|
|
|
/* True means global_bindings_p should return false even if the scope stack
|
/* True means global_bindings_p should return false even if the scope stack
|
says we are in file scope. */
|
says we are in file scope. */
|
bool c_override_global_bindings_to_false;
|
bool c_override_global_bindings_to_false;
|
|
|
|
|
/* Each c_binding structure describes one binding of an identifier to
|
/* Each c_binding structure describes one binding of an identifier to
|
a decl. All the decls in a scope - irrespective of namespace - are
|
a decl. All the decls in a scope - irrespective of namespace - are
|
chained together by the ->prev field, which (as the name implies)
|
chained together by the ->prev field, which (as the name implies)
|
runs in reverse order. All the decls in a given namespace bound to
|
runs in reverse order. All the decls in a given namespace bound to
|
a given identifier are chained by the ->shadowed field, which runs
|
a given identifier are chained by the ->shadowed field, which runs
|
from inner to outer scopes.
|
from inner to outer scopes.
|
|
|
The ->decl field usually points to a DECL node, but there are two
|
The ->decl field usually points to a DECL node, but there are two
|
exceptions. In the namespace of type tags, the bound entity is a
|
exceptions. In the namespace of type tags, the bound entity is a
|
RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
|
RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
|
identifier is encountered, it is bound to error_mark_node to
|
identifier is encountered, it is bound to error_mark_node to
|
suppress further errors about that identifier in the current
|
suppress further errors about that identifier in the current
|
function.
|
function.
|
|
|
The ->u.type field stores the type of the declaration in this scope;
|
The ->u.type field stores the type of the declaration in this scope;
|
if NULL, the type is the type of the ->decl field. This is only of
|
if NULL, the type is the type of the ->decl field. This is only of
|
relevance for objects with external or internal linkage which may
|
relevance for objects with external or internal linkage which may
|
be redeclared in inner scopes, forming composite types that only
|
be redeclared in inner scopes, forming composite types that only
|
persist for the duration of those scopes. In the external scope,
|
persist for the duration of those scopes. In the external scope,
|
this stores the composite of all the types declared for this
|
this stores the composite of all the types declared for this
|
object, visible or not. The ->inner_comp field (used only at file
|
object, visible or not. The ->inner_comp field (used only at file
|
scope) stores whether an incomplete array type at file scope was
|
scope) stores whether an incomplete array type at file scope was
|
completed at an inner scope to an array size other than 1.
|
completed at an inner scope to an array size other than 1.
|
|
|
The ->u.label field is used for labels. It points to a structure
|
The ->u.label field is used for labels. It points to a structure
|
which stores additional information used for warnings.
|
which stores additional information used for warnings.
|
|
|
The depth field is copied from the scope structure that holds this
|
The depth field is copied from the scope structure that holds this
|
decl. It is used to preserve the proper ordering of the ->shadowed
|
decl. It is used to preserve the proper ordering of the ->shadowed
|
field (see bind()) and also for a handful of special-case checks.
|
field (see bind()) and also for a handful of special-case checks.
|
Finally, the invisible bit is true for a decl which should be
|
Finally, the invisible bit is true for a decl which should be
|
ignored for purposes of normal name lookup, and the nested bit is
|
ignored for purposes of normal name lookup, and the nested bit is
|
true for a decl that's been bound a second time in an inner scope;
|
true for a decl that's been bound a second time in an inner scope;
|
in all such cases, the binding in the outer scope will have its
|
in all such cases, the binding in the outer scope will have its
|
invisible bit true. */
|
invisible bit true. */
|
|
|
struct GTY((chain_next ("%h.prev"))) c_binding {
|
struct GTY((chain_next ("%h.prev"))) c_binding {
|
union GTY(()) { /* first so GTY desc can use decl */
|
union GTY(()) { /* first so GTY desc can use decl */
|
tree GTY((tag ("0"))) type; /* the type in this scope */
|
tree GTY((tag ("0"))) type; /* the type in this scope */
|
struct c_label_vars * GTY((tag ("1"))) label; /* for warnings */
|
struct c_label_vars * GTY((tag ("1"))) label; /* for warnings */
|
} GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u;
|
} GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u;
|
tree decl; /* the decl bound */
|
tree decl; /* the decl bound */
|
tree id; /* the identifier it's bound to */
|
tree id; /* the identifier it's bound to */
|
struct c_binding *prev; /* the previous decl in this scope */
|
struct c_binding *prev; /* the previous decl in this scope */
|
struct c_binding *shadowed; /* the innermost decl shadowed by this one */
|
struct c_binding *shadowed; /* the innermost decl shadowed by this one */
|
unsigned int depth : 28; /* depth of this scope */
|
unsigned int depth : 28; /* depth of this scope */
|
BOOL_BITFIELD invisible : 1; /* normal lookup should ignore this binding */
|
BOOL_BITFIELD invisible : 1; /* normal lookup should ignore this binding */
|
BOOL_BITFIELD nested : 1; /* do not set DECL_CONTEXT when popping */
|
BOOL_BITFIELD nested : 1; /* do not set DECL_CONTEXT when popping */
|
BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
|
BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
|
BOOL_BITFIELD in_struct : 1; /* currently defined as struct field */
|
BOOL_BITFIELD in_struct : 1; /* currently defined as struct field */
|
location_t locus; /* location for nested bindings */
|
location_t locus; /* location for nested bindings */
|
};
|
};
|
#define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
|
#define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
|
#define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
|
#define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
|
#define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
|
#define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
|
#define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
|
#define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
|
|
|
#define I_SYMBOL_BINDING(node) \
|
#define I_SYMBOL_BINDING(node) \
|
(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
|
(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
|
#define I_SYMBOL_DECL(node) \
|
#define I_SYMBOL_DECL(node) \
|
(I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
|
(I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
|
|
|
#define I_TAG_BINDING(node) \
|
#define I_TAG_BINDING(node) \
|
(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
|
(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
|
#define I_TAG_DECL(node) \
|
#define I_TAG_DECL(node) \
|
(I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
|
(I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
|
|
|
#define I_LABEL_BINDING(node) \
|
#define I_LABEL_BINDING(node) \
|
(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
|
(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
|
#define I_LABEL_DECL(node) \
|
#define I_LABEL_DECL(node) \
|
(I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
|
(I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
|
|
|
/* Each C symbol points to three linked lists of c_binding structures.
|
/* Each C symbol points to three linked lists of c_binding structures.
|
These describe the values of the identifier in the three different
|
These describe the values of the identifier in the three different
|
namespaces defined by the language. */
|
namespaces defined by the language. */
|
|
|
struct GTY(()) lang_identifier {
|
struct GTY(()) lang_identifier {
|
struct c_common_identifier common_id;
|
struct c_common_identifier common_id;
|
struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
|
struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
|
struct c_binding *tag_binding; /* struct/union/enum tags */
|
struct c_binding *tag_binding; /* struct/union/enum tags */
|
struct c_binding *label_binding; /* labels */
|
struct c_binding *label_binding; /* labels */
|
};
|
};
|
|
|
/* Validate c-lang.c's assumptions. */
|
/* Validate c-lang.c's assumptions. */
|
extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
|
extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
|
[(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
|
[(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
|
|
|
/* The resulting tree type. */
|
/* The resulting tree type. */
|
|
|
union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
|
union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
|
chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : ((union lang_tree_node *) TREE_CHAIN (&%h.generic))"))) lang_tree_node
|
chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : ((union lang_tree_node *) TREE_CHAIN (&%h.generic))"))) lang_tree_node
|
{
|
{
|
union tree_node GTY ((tag ("0"),
|
union tree_node GTY ((tag ("0"),
|
desc ("tree_node_structure (&%h)")))
|
desc ("tree_node_structure (&%h)")))
|
generic;
|
generic;
|
struct lang_identifier GTY ((tag ("1"))) identifier;
|
struct lang_identifier GTY ((tag ("1"))) identifier;
|
};
|
};
|
|
|
/* Track bindings and other things that matter for goto warnings. For
|
/* Track bindings and other things that matter for goto warnings. For
|
efficiency, we do not gather all the decls at the point of
|
efficiency, we do not gather all the decls at the point of
|
definition. Instead, we point into the bindings structure. As
|
definition. Instead, we point into the bindings structure. As
|
scopes are popped, we update these structures and gather the decls
|
scopes are popped, we update these structures and gather the decls
|
that matter at that time. */
|
that matter at that time. */
|
|
|
struct GTY(()) c_spot_bindings {
|
struct GTY(()) c_spot_bindings {
|
/* The currently open scope which holds bindings defined when the
|
/* The currently open scope which holds bindings defined when the
|
label was defined or the goto statement was found. */
|
label was defined or the goto statement was found. */
|
struct c_scope *scope;
|
struct c_scope *scope;
|
/* The bindings in the scope field which were defined at the point
|
/* The bindings in the scope field which were defined at the point
|
of the label or goto. This lets us look at older or newer
|
of the label or goto. This lets us look at older or newer
|
bindings in the scope, as appropriate. */
|
bindings in the scope, as appropriate. */
|
struct c_binding *bindings_in_scope;
|
struct c_binding *bindings_in_scope;
|
/* The number of statement expressions that have started since this
|
/* The number of statement expressions that have started since this
|
label or goto statement was defined. This is zero if we are at
|
label or goto statement was defined. This is zero if we are at
|
the same statement expression level. It is positive if we are in
|
the same statement expression level. It is positive if we are in
|
a statement expression started since this spot. It is negative
|
a statement expression started since this spot. It is negative
|
if this spot was in a statement expression and we have left
|
if this spot was in a statement expression and we have left
|
it. */
|
it. */
|
int stmt_exprs;
|
int stmt_exprs;
|
/* Whether we started in a statement expression but are no longer in
|
/* Whether we started in a statement expression but are no longer in
|
it. This is set to true if stmt_exprs ever goes negative. */
|
it. This is set to true if stmt_exprs ever goes negative. */
|
bool left_stmt_expr;
|
bool left_stmt_expr;
|
};
|
};
|
|
|
/* This structure is used to keep track of bindings seen when a goto
|
/* This structure is used to keep track of bindings seen when a goto
|
statement is defined. This is only used if we see the goto
|
statement is defined. This is only used if we see the goto
|
statement before we see the label. */
|
statement before we see the label. */
|
|
|
struct GTY(()) c_goto_bindings {
|
struct GTY(()) c_goto_bindings {
|
/* The location of the goto statement. */
|
/* The location of the goto statement. */
|
location_t loc;
|
location_t loc;
|
/* The bindings of the goto statement. */
|
/* The bindings of the goto statement. */
|
struct c_spot_bindings goto_bindings;
|
struct c_spot_bindings goto_bindings;
|
};
|
};
|
|
|
typedef struct c_goto_bindings *c_goto_bindings_p;
|
typedef struct c_goto_bindings *c_goto_bindings_p;
|
DEF_VEC_P(c_goto_bindings_p);
|
DEF_VEC_P(c_goto_bindings_p);
|
DEF_VEC_ALLOC_P(c_goto_bindings_p,gc);
|
DEF_VEC_ALLOC_P(c_goto_bindings_p,gc);
|
|
|
/* The additional information we keep track of for a label binding.
|
/* The additional information we keep track of for a label binding.
|
These fields are updated as scopes are popped. */
|
These fields are updated as scopes are popped. */
|
|
|
struct GTY(()) c_label_vars {
|
struct GTY(()) c_label_vars {
|
/* The shadowed c_label_vars, when one label shadows another (which
|
/* The shadowed c_label_vars, when one label shadows another (which
|
can only happen using a __label__ declaration). */
|
can only happen using a __label__ declaration). */
|
struct c_label_vars *shadowed;
|
struct c_label_vars *shadowed;
|
/* The bindings when the label was defined. */
|
/* The bindings when the label was defined. */
|
struct c_spot_bindings label_bindings;
|
struct c_spot_bindings label_bindings;
|
/* A list of decls that we care about: decls about which we should
|
/* A list of decls that we care about: decls about which we should
|
warn if a goto branches to this label from later in the function.
|
warn if a goto branches to this label from later in the function.
|
Decls are added to this list as scopes are popped. We only add
|
Decls are added to this list as scopes are popped. We only add
|
the decls that matter. */
|
the decls that matter. */
|
VEC(tree,gc) *decls_in_scope;
|
VEC(tree,gc) *decls_in_scope;
|
/* A list of goto statements to this label. This is only used for
|
/* A list of goto statements to this label. This is only used for
|
goto statements seen before the label was defined, so that we can
|
goto statements seen before the label was defined, so that we can
|
issue appropriate warnings for them. */
|
issue appropriate warnings for them. */
|
VEC(c_goto_bindings_p,gc) *gotos;
|
VEC(c_goto_bindings_p,gc) *gotos;
|
};
|
};
|
|
|
/* Each c_scope structure describes the complete contents of one
|
/* Each c_scope structure describes the complete contents of one
|
scope. Four scopes are distinguished specially: the innermost or
|
scope. Four scopes are distinguished specially: the innermost or
|
current scope, the innermost function scope, the file scope (always
|
current scope, the innermost function scope, the file scope (always
|
the second to outermost) and the outermost or external scope.
|
the second to outermost) and the outermost or external scope.
|
|
|
Most declarations are recorded in the current scope.
|
Most declarations are recorded in the current scope.
|
|
|
All normal label declarations are recorded in the innermost
|
All normal label declarations are recorded in the innermost
|
function scope, as are bindings of undeclared identifiers to
|
function scope, as are bindings of undeclared identifiers to
|
error_mark_node. (GCC permits nested functions as an extension,
|
error_mark_node. (GCC permits nested functions as an extension,
|
hence the 'innermost' qualifier.) Explicitly declared labels
|
hence the 'innermost' qualifier.) Explicitly declared labels
|
(using the __label__ extension) appear in the current scope.
|
(using the __label__ extension) appear in the current scope.
|
|
|
Being in the file scope (current_scope == file_scope) causes
|
Being in the file scope (current_scope == file_scope) causes
|
special behavior in several places below. Also, under some
|
special behavior in several places below. Also, under some
|
conditions the Objective-C front end records declarations in the
|
conditions the Objective-C front end records declarations in the
|
file scope even though that isn't the current scope.
|
file scope even though that isn't the current scope.
|
|
|
All declarations with external linkage are recorded in the external
|
All declarations with external linkage are recorded in the external
|
scope, even if they aren't visible there; this models the fact that
|
scope, even if they aren't visible there; this models the fact that
|
such declarations are visible to the entire program, and (with a
|
such declarations are visible to the entire program, and (with a
|
bit of cleverness, see pushdecl) allows diagnosis of some violations
|
bit of cleverness, see pushdecl) allows diagnosis of some violations
|
of C99 6.2.2p7 and 6.2.7p2:
|
of C99 6.2.2p7 and 6.2.7p2:
|
|
|
If, within the same translation unit, the same identifier appears
|
If, within the same translation unit, the same identifier appears
|
with both internal and external linkage, the behavior is
|
with both internal and external linkage, the behavior is
|
undefined.
|
undefined.
|
|
|
All declarations that refer to the same object or function shall
|
All declarations that refer to the same object or function shall
|
have compatible type; otherwise, the behavior is undefined.
|
have compatible type; otherwise, the behavior is undefined.
|
|
|
Initially only the built-in declarations, which describe compiler
|
Initially only the built-in declarations, which describe compiler
|
intrinsic functions plus a subset of the standard library, are in
|
intrinsic functions plus a subset of the standard library, are in
|
this scope.
|
this scope.
|
|
|
The order of the blocks list matters, and it is frequently appended
|
The order of the blocks list matters, and it is frequently appended
|
to. To avoid having to walk all the way to the end of the list on
|
to. To avoid having to walk all the way to the end of the list on
|
each insertion, or reverse the list later, we maintain a pointer to
|
each insertion, or reverse the list later, we maintain a pointer to
|
the last list entry. (FIXME: It should be feasible to use a reversed
|
the last list entry. (FIXME: It should be feasible to use a reversed
|
list here.)
|
list here.)
|
|
|
The bindings list is strictly in reverse order of declarations;
|
The bindings list is strictly in reverse order of declarations;
|
pop_scope relies on this. */
|
pop_scope relies on this. */
|
|
|
|
|
struct GTY((chain_next ("%h.outer"))) c_scope {
|
struct GTY((chain_next ("%h.outer"))) c_scope {
|
/* The scope containing this one. */
|
/* The scope containing this one. */
|
struct c_scope *outer;
|
struct c_scope *outer;
|
|
|
/* The next outermost function scope. */
|
/* The next outermost function scope. */
|
struct c_scope *outer_function;
|
struct c_scope *outer_function;
|
|
|
/* All bindings in this scope. */
|
/* All bindings in this scope. */
|
struct c_binding *bindings;
|
struct c_binding *bindings;
|
|
|
/* For each scope (except the global one), a chain of BLOCK nodes
|
/* For each scope (except the global one), a chain of BLOCK nodes
|
for all the scopes that were entered and exited one level down. */
|
for all the scopes that were entered and exited one level down. */
|
tree blocks;
|
tree blocks;
|
tree blocks_last;
|
tree blocks_last;
|
|
|
/* The depth of this scope. Used to keep the ->shadowed chain of
|
/* The depth of this scope. Used to keep the ->shadowed chain of
|
bindings sorted innermost to outermost. */
|
bindings sorted innermost to outermost. */
|
unsigned int depth : 28;
|
unsigned int depth : 28;
|
|
|
/* True if we are currently filling this scope with parameter
|
/* True if we are currently filling this scope with parameter
|
declarations. */
|
declarations. */
|
BOOL_BITFIELD parm_flag : 1;
|
BOOL_BITFIELD parm_flag : 1;
|
|
|
/* True if we saw [*] in this scope. Used to give an error messages
|
/* True if we saw [*] in this scope. Used to give an error messages
|
if these appears in a function definition. */
|
if these appears in a function definition. */
|
BOOL_BITFIELD had_vla_unspec : 1;
|
BOOL_BITFIELD had_vla_unspec : 1;
|
|
|
/* True if we already complained about forward parameter decls
|
/* True if we already complained about forward parameter decls
|
in this scope. This prevents double warnings on
|
in this scope. This prevents double warnings on
|
foo (int a; int b; ...) */
|
foo (int a; int b; ...) */
|
BOOL_BITFIELD warned_forward_parm_decls : 1;
|
BOOL_BITFIELD warned_forward_parm_decls : 1;
|
|
|
/* True if this is the outermost block scope of a function body.
|
/* True if this is the outermost block scope of a function body.
|
This scope contains the parameters, the local variables declared
|
This scope contains the parameters, the local variables declared
|
in the outermost block, and all the labels (except those in
|
in the outermost block, and all the labels (except those in
|
nested functions, or declared at block scope with __label__). */
|
nested functions, or declared at block scope with __label__). */
|
BOOL_BITFIELD function_body : 1;
|
BOOL_BITFIELD function_body : 1;
|
|
|
/* True means make a BLOCK for this scope no matter what. */
|
/* True means make a BLOCK for this scope no matter what. */
|
BOOL_BITFIELD keep : 1;
|
BOOL_BITFIELD keep : 1;
|
|
|
/* True means that an unsuffixed float constant is _Decimal64. */
|
/* True means that an unsuffixed float constant is _Decimal64. */
|
BOOL_BITFIELD float_const_decimal64 : 1;
|
BOOL_BITFIELD float_const_decimal64 : 1;
|
|
|
/* True if this scope has any label bindings. This is used to speed
|
/* True if this scope has any label bindings. This is used to speed
|
up searching for labels when popping scopes, particularly since
|
up searching for labels when popping scopes, particularly since
|
labels are normally only found at function scope. */
|
labels are normally only found at function scope. */
|
BOOL_BITFIELD has_label_bindings : 1;
|
BOOL_BITFIELD has_label_bindings : 1;
|
};
|
};
|
|
|
/* The scope currently in effect. */
|
/* The scope currently in effect. */
|
|
|
static GTY(()) struct c_scope *current_scope;
|
static GTY(()) struct c_scope *current_scope;
|
|
|
/* The innermost function scope. Ordinary (not explicitly declared)
|
/* The innermost function scope. Ordinary (not explicitly declared)
|
labels, bindings to error_mark_node, and the lazily-created
|
labels, bindings to error_mark_node, and the lazily-created
|
bindings of __func__ and its friends get this scope. */
|
bindings of __func__ and its friends get this scope. */
|
|
|
static GTY(()) struct c_scope *current_function_scope;
|
static GTY(()) struct c_scope *current_function_scope;
|
|
|
/* The C file scope. This is reset for each input translation unit. */
|
/* The C file scope. This is reset for each input translation unit. */
|
|
|
static GTY(()) struct c_scope *file_scope;
|
static GTY(()) struct c_scope *file_scope;
|
|
|
/* The outermost scope. This is used for all declarations with
|
/* The outermost scope. This is used for all declarations with
|
external linkage, and only these, hence the name. */
|
external linkage, and only these, hence the name. */
|
|
|
static GTY(()) struct c_scope *external_scope;
|
static GTY(()) struct c_scope *external_scope;
|
|
|
/* A chain of c_scope structures awaiting reuse. */
|
/* A chain of c_scope structures awaiting reuse. */
|
|
|
static GTY((deletable)) struct c_scope *scope_freelist;
|
static GTY((deletable)) struct c_scope *scope_freelist;
|
|
|
/* A chain of c_binding structures awaiting reuse. */
|
/* A chain of c_binding structures awaiting reuse. */
|
|
|
static GTY((deletable)) struct c_binding *binding_freelist;
|
static GTY((deletable)) struct c_binding *binding_freelist;
|
|
|
/* Append VAR to LIST in scope SCOPE. */
|
/* Append VAR to LIST in scope SCOPE. */
|
#define SCOPE_LIST_APPEND(scope, list, decl) do { \
|
#define SCOPE_LIST_APPEND(scope, list, decl) do { \
|
struct c_scope *s_ = (scope); \
|
struct c_scope *s_ = (scope); \
|
tree d_ = (decl); \
|
tree d_ = (decl); \
|
if (s_->list##_last) \
|
if (s_->list##_last) \
|
BLOCK_CHAIN (s_->list##_last) = d_; \
|
BLOCK_CHAIN (s_->list##_last) = d_; \
|
else \
|
else \
|
s_->list = d_; \
|
s_->list = d_; \
|
s_->list##_last = d_; \
|
s_->list##_last = d_; \
|
} while (0)
|
} while (0)
|
|
|
/* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
|
/* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
|
#define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
|
#define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
|
struct c_scope *t_ = (tscope); \
|
struct c_scope *t_ = (tscope); \
|
struct c_scope *f_ = (fscope); \
|
struct c_scope *f_ = (fscope); \
|
if (t_->to##_last) \
|
if (t_->to##_last) \
|
BLOCK_CHAIN (t_->to##_last) = f_->from; \
|
BLOCK_CHAIN (t_->to##_last) = f_->from; \
|
else \
|
else \
|
t_->to = f_->from; \
|
t_->to = f_->from; \
|
t_->to##_last = f_->from##_last; \
|
t_->to##_last = f_->from##_last; \
|
} while (0)
|
} while (0)
|
|
|
/* A c_inline_static structure stores details of a static identifier
|
/* A c_inline_static structure stores details of a static identifier
|
referenced in a definition of a function that may be an inline
|
referenced in a definition of a function that may be an inline
|
definition if no subsequent declaration of that function uses
|
definition if no subsequent declaration of that function uses
|
"extern" or does not use "inline". */
|
"extern" or does not use "inline". */
|
|
|
struct GTY((chain_next ("%h.next"))) c_inline_static {
|
struct GTY((chain_next ("%h.next"))) c_inline_static {
|
/* The location for a diagnostic. */
|
/* The location for a diagnostic. */
|
location_t location;
|
location_t location;
|
|
|
/* The function that may be an inline definition. */
|
/* The function that may be an inline definition. */
|
tree function;
|
tree function;
|
|
|
/* The object or function referenced. */
|
/* The object or function referenced. */
|
tree static_decl;
|
tree static_decl;
|
|
|
/* What sort of reference this is. */
|
/* What sort of reference this is. */
|
enum c_inline_static_type type;
|
enum c_inline_static_type type;
|
|
|
/* The next such structure or NULL. */
|
/* The next such structure or NULL. */
|
struct c_inline_static *next;
|
struct c_inline_static *next;
|
};
|
};
|
|
|
/* List of static identifiers used or referenced in functions that may
|
/* List of static identifiers used or referenced in functions that may
|
be inline definitions. */
|
be inline definitions. */
|
static GTY(()) struct c_inline_static *c_inline_statics;
|
static GTY(()) struct c_inline_static *c_inline_statics;
|
|
|
/* True means unconditionally make a BLOCK for the next scope pushed. */
|
/* True means unconditionally make a BLOCK for the next scope pushed. */
|
|
|
static bool keep_next_level_flag;
|
static bool keep_next_level_flag;
|
|
|
/* True means the next call to push_scope will be the outermost scope
|
/* True means the next call to push_scope will be the outermost scope
|
of a function body, so do not push a new scope, merely cease
|
of a function body, so do not push a new scope, merely cease
|
expecting parameter decls. */
|
expecting parameter decls. */
|
|
|
static bool next_is_function_body;
|
static bool next_is_function_body;
|
|
|
/* A VEC of pointers to c_binding structures. */
|
/* A VEC of pointers to c_binding structures. */
|
|
|
typedef struct c_binding *c_binding_ptr;
|
typedef struct c_binding *c_binding_ptr;
|
DEF_VEC_P(c_binding_ptr);
|
DEF_VEC_P(c_binding_ptr);
|
DEF_VEC_ALLOC_P(c_binding_ptr,heap);
|
DEF_VEC_ALLOC_P(c_binding_ptr,heap);
|
|
|
/* Information that we keep for a struct or union while it is being
|
/* Information that we keep for a struct or union while it is being
|
parsed. */
|
parsed. */
|
|
|
struct c_struct_parse_info
|
struct c_struct_parse_info
|
{
|
{
|
/* If warn_cxx_compat, a list of types defined within this
|
/* If warn_cxx_compat, a list of types defined within this
|
struct. */
|
struct. */
|
VEC(tree,heap) *struct_types;
|
VEC(tree,heap) *struct_types;
|
/* If warn_cxx_compat, a list of field names which have bindings,
|
/* If warn_cxx_compat, a list of field names which have bindings,
|
and which are defined in this struct, but which are not defined
|
and which are defined in this struct, but which are not defined
|
in any enclosing struct. This is used to clear the in_struct
|
in any enclosing struct. This is used to clear the in_struct
|
field of the c_bindings structure. */
|
field of the c_bindings structure. */
|
VEC(c_binding_ptr,heap) *fields;
|
VEC(c_binding_ptr,heap) *fields;
|
/* If warn_cxx_compat, a list of typedef names used when defining
|
/* If warn_cxx_compat, a list of typedef names used when defining
|
fields in this struct. */
|
fields in this struct. */
|
VEC(tree,heap) *typedefs_seen;
|
VEC(tree,heap) *typedefs_seen;
|
};
|
};
|
|
|
/* Information for the struct or union currently being parsed, or
|
/* Information for the struct or union currently being parsed, or
|
NULL if not parsing a struct or union. */
|
NULL if not parsing a struct or union. */
|
static struct c_struct_parse_info *struct_parse_info;
|
static struct c_struct_parse_info *struct_parse_info;
|
|
|
/* Forward declarations. */
|
/* Forward declarations. */
|
static tree lookup_name_in_scope (tree, struct c_scope *);
|
static tree lookup_name_in_scope (tree, struct c_scope *);
|
static tree c_make_fname_decl (location_t, tree, int);
|
static tree c_make_fname_decl (location_t, tree, int);
|
static tree grokdeclarator (const struct c_declarator *,
|
static tree grokdeclarator (const struct c_declarator *,
|
struct c_declspecs *,
|
struct c_declspecs *,
|
enum decl_context, bool, tree *, tree *, tree *,
|
enum decl_context, bool, tree *, tree *, tree *,
|
bool *, enum deprecated_states);
|
bool *, enum deprecated_states);
|
static tree grokparms (struct c_arg_info *, bool);
|
static tree grokparms (struct c_arg_info *, bool);
|
static void layout_array_type (tree);
|
static void layout_array_type (tree);
|
|
|
/* T is a statement. Add it to the statement-tree. This is the
|
/* T is a statement. Add it to the statement-tree. This is the
|
C/ObjC version--C++ has a slightly different version of this
|
C/ObjC version--C++ has a slightly different version of this
|
function. */
|
function. */
|
|
|
tree
|
tree
|
add_stmt (tree t)
|
add_stmt (tree t)
|
{
|
{
|
enum tree_code code = TREE_CODE (t);
|
enum tree_code code = TREE_CODE (t);
|
|
|
if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)
|
if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)
|
{
|
{
|
if (!EXPR_HAS_LOCATION (t))
|
if (!EXPR_HAS_LOCATION (t))
|
SET_EXPR_LOCATION (t, input_location);
|
SET_EXPR_LOCATION (t, input_location);
|
}
|
}
|
|
|
if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
|
if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
|
STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
|
STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
|
|
|
/* Add T to the statement-tree. Non-side-effect statements need to be
|
/* Add T to the statement-tree. Non-side-effect statements need to be
|
recorded during statement expressions. */
|
recorded during statement expressions. */
|
append_to_statement_list_force (t, &cur_stmt_list);
|
append_to_statement_list_force (t, &cur_stmt_list);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
|
|
void
|
void
|
c_print_identifier (FILE *file, tree node, int indent)
|
c_print_identifier (FILE *file, tree node, int indent)
|
{
|
{
|
print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
|
print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
|
print_node (file, "tag", I_TAG_DECL (node), indent + 4);
|
print_node (file, "tag", I_TAG_DECL (node), indent + 4);
|
print_node (file, "label", I_LABEL_DECL (node), indent + 4);
|
print_node (file, "label", I_LABEL_DECL (node), indent + 4);
|
if (C_IS_RESERVED_WORD (node) && C_RID_CODE (node) != RID_CXX_COMPAT_WARN)
|
if (C_IS_RESERVED_WORD (node) && C_RID_CODE (node) != RID_CXX_COMPAT_WARN)
|
{
|
{
|
tree rid = ridpointers[C_RID_CODE (node)];
|
tree rid = ridpointers[C_RID_CODE (node)];
|
indent_to (file, indent + 4);
|
indent_to (file, indent + 4);
|
fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",
|
fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",
|
(void *) rid, IDENTIFIER_POINTER (rid));
|
(void *) rid, IDENTIFIER_POINTER (rid));
|
}
|
}
|
}
|
}
|
|
|
/* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
|
/* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
|
which may be any of several kinds of DECL or TYPE or error_mark_node,
|
which may be any of several kinds of DECL or TYPE or error_mark_node,
|
in the scope SCOPE. */
|
in the scope SCOPE. */
|
static void
|
static void
|
bind (tree name, tree decl, struct c_scope *scope, bool invisible,
|
bind (tree name, tree decl, struct c_scope *scope, bool invisible,
|
bool nested, location_t locus)
|
bool nested, location_t locus)
|
{
|
{
|
struct c_binding *b, **here;
|
struct c_binding *b, **here;
|
|
|
if (binding_freelist)
|
if (binding_freelist)
|
{
|
{
|
b = binding_freelist;
|
b = binding_freelist;
|
binding_freelist = b->prev;
|
binding_freelist = b->prev;
|
}
|
}
|
else
|
else
|
b = GGC_NEW (struct c_binding);
|
b = GGC_NEW (struct c_binding);
|
|
|
b->shadowed = 0;
|
b->shadowed = 0;
|
b->decl = decl;
|
b->decl = decl;
|
b->id = name;
|
b->id = name;
|
b->depth = scope->depth;
|
b->depth = scope->depth;
|
b->invisible = invisible;
|
b->invisible = invisible;
|
b->nested = nested;
|
b->nested = nested;
|
b->inner_comp = 0;
|
b->inner_comp = 0;
|
b->in_struct = 0;
|
b->in_struct = 0;
|
b->locus = locus;
|
b->locus = locus;
|
|
|
b->u.type = NULL;
|
b->u.type = NULL;
|
|
|
b->prev = scope->bindings;
|
b->prev = scope->bindings;
|
scope->bindings = b;
|
scope->bindings = b;
|
|
|
if (!name)
|
if (!name)
|
return;
|
return;
|
|
|
switch (TREE_CODE (decl))
|
switch (TREE_CODE (decl))
|
{
|
{
|
case LABEL_DECL: here = &I_LABEL_BINDING (name); break;
|
case LABEL_DECL: here = &I_LABEL_BINDING (name); break;
|
case ENUMERAL_TYPE:
|
case ENUMERAL_TYPE:
|
case UNION_TYPE:
|
case UNION_TYPE:
|
case RECORD_TYPE: here = &I_TAG_BINDING (name); break;
|
case RECORD_TYPE: here = &I_TAG_BINDING (name); break;
|
case VAR_DECL:
|
case VAR_DECL:
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
case TYPE_DECL:
|
case TYPE_DECL:
|
case CONST_DECL:
|
case CONST_DECL:
|
case PARM_DECL:
|
case PARM_DECL:
|
case ERROR_MARK: here = &I_SYMBOL_BINDING (name); break;
|
case ERROR_MARK: here = &I_SYMBOL_BINDING (name); break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* Locate the appropriate place in the chain of shadowed decls
|
/* Locate the appropriate place in the chain of shadowed decls
|
to insert this binding. Normally, scope == current_scope and
|
to insert this binding. Normally, scope == current_scope and
|
this does nothing. */
|
this does nothing. */
|
while (*here && (*here)->depth > scope->depth)
|
while (*here && (*here)->depth > scope->depth)
|
here = &(*here)->shadowed;
|
here = &(*here)->shadowed;
|
|
|
b->shadowed = *here;
|
b->shadowed = *here;
|
*here = b;
|
*here = b;
|
}
|
}
|
|
|
/* Clear the binding structure B, stick it on the binding_freelist,
|
/* Clear the binding structure B, stick it on the binding_freelist,
|
and return the former value of b->prev. This is used by pop_scope
|
and return the former value of b->prev. This is used by pop_scope
|
and get_parm_info to iterate destructively over all the bindings
|
and get_parm_info to iterate destructively over all the bindings
|
from a given scope. */
|
from a given scope. */
|
static struct c_binding *
|
static struct c_binding *
|
free_binding_and_advance (struct c_binding *b)
|
free_binding_and_advance (struct c_binding *b)
|
{
|
{
|
struct c_binding *prev = b->prev;
|
struct c_binding *prev = b->prev;
|
|
|
memset (b, 0, sizeof (struct c_binding));
|
memset (b, 0, sizeof (struct c_binding));
|
b->prev = binding_freelist;
|
b->prev = binding_freelist;
|
binding_freelist = b;
|
binding_freelist = b;
|
|
|
return prev;
|
return prev;
|
}
|
}
|
|
|
/* Bind a label. Like bind, but skip fields which aren't used for
|
/* Bind a label. Like bind, but skip fields which aren't used for
|
labels, and add the LABEL_VARS value. */
|
labels, and add the LABEL_VARS value. */
|
static void
|
static void
|
bind_label (tree name, tree label, struct c_scope *scope,
|
bind_label (tree name, tree label, struct c_scope *scope,
|
struct c_label_vars *label_vars)
|
struct c_label_vars *label_vars)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
bind (name, label, scope, /*invisible=*/false, /*nested=*/false,
|
bind (name, label, scope, /*invisible=*/false, /*nested=*/false,
|
UNKNOWN_LOCATION);
|
UNKNOWN_LOCATION);
|
|
|
scope->has_label_bindings = true;
|
scope->has_label_bindings = true;
|
|
|
b = scope->bindings;
|
b = scope->bindings;
|
gcc_assert (b->decl == label);
|
gcc_assert (b->decl == label);
|
label_vars->shadowed = b->u.label;
|
label_vars->shadowed = b->u.label;
|
b->u.label = label_vars;
|
b->u.label = label_vars;
|
}
|
}
|
|
|
/* Hook called at end of compilation to assume 1 elt
|
/* Hook called at end of compilation to assume 1 elt
|
for a file-scope tentative array defn that wasn't complete before. */
|
for a file-scope tentative array defn that wasn't complete before. */
|
|
|
void
|
void
|
c_finish_incomplete_decl (tree decl)
|
c_finish_incomplete_decl (tree decl)
|
{
|
{
|
if (TREE_CODE (decl) == VAR_DECL)
|
if (TREE_CODE (decl) == VAR_DECL)
|
{
|
{
|
tree type = TREE_TYPE (decl);
|
tree type = TREE_TYPE (decl);
|
if (type != error_mark_node
|
if (type != error_mark_node
|
&& TREE_CODE (type) == ARRAY_TYPE
|
&& TREE_CODE (type) == ARRAY_TYPE
|
&& !DECL_EXTERNAL (decl)
|
&& !DECL_EXTERNAL (decl)
|
&& TYPE_DOMAIN (type) == 0)
|
&& TYPE_DOMAIN (type) == 0)
|
{
|
{
|
warning_at (DECL_SOURCE_LOCATION (decl),
|
warning_at (DECL_SOURCE_LOCATION (decl),
|
0, "array %q+D assumed to have one element", decl);
|
0, "array %q+D assumed to have one element", decl);
|
|
|
complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
|
complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
|
|
|
layout_decl (decl, 0);
|
layout_decl (decl, 0);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Record that inline function FUNC contains a reference (location
|
/* Record that inline function FUNC contains a reference (location
|
LOC) to static DECL (file-scope or function-local according to
|
LOC) to static DECL (file-scope or function-local according to
|
TYPE). */
|
TYPE). */
|
|
|
void
|
void
|
record_inline_static (location_t loc, tree func, tree decl,
|
record_inline_static (location_t loc, tree func, tree decl,
|
enum c_inline_static_type type)
|
enum c_inline_static_type type)
|
{
|
{
|
struct c_inline_static *csi = GGC_NEW (struct c_inline_static);
|
struct c_inline_static *csi = GGC_NEW (struct c_inline_static);
|
csi->location = loc;
|
csi->location = loc;
|
csi->function = func;
|
csi->function = func;
|
csi->static_decl = decl;
|
csi->static_decl = decl;
|
csi->type = type;
|
csi->type = type;
|
csi->next = c_inline_statics;
|
csi->next = c_inline_statics;
|
c_inline_statics = csi;
|
c_inline_statics = csi;
|
}
|
}
|
|
|
/* Check for references to static declarations in inline functions at
|
/* Check for references to static declarations in inline functions at
|
the end of the translation unit and diagnose them if the functions
|
the end of the translation unit and diagnose them if the functions
|
are still inline definitions. */
|
are still inline definitions. */
|
|
|
static void
|
static void
|
check_inline_statics (void)
|
check_inline_statics (void)
|
{
|
{
|
struct c_inline_static *csi;
|
struct c_inline_static *csi;
|
for (csi = c_inline_statics; csi; csi = csi->next)
|
for (csi = c_inline_statics; csi; csi = csi->next)
|
{
|
{
|
if (DECL_EXTERNAL (csi->function))
|
if (DECL_EXTERNAL (csi->function))
|
switch (csi->type)
|
switch (csi->type)
|
{
|
{
|
case csi_internal:
|
case csi_internal:
|
pedwarn (csi->location, 0,
|
pedwarn (csi->location, 0,
|
"%qD is static but used in inline function %qD "
|
"%qD is static but used in inline function %qD "
|
"which is not static", csi->static_decl, csi->function);
|
"which is not static", csi->static_decl, csi->function);
|
break;
|
break;
|
case csi_modifiable:
|
case csi_modifiable:
|
pedwarn (csi->location, 0,
|
pedwarn (csi->location, 0,
|
"%q+D is static but declared in inline function %qD "
|
"%q+D is static but declared in inline function %qD "
|
"which is not static", csi->static_decl, csi->function);
|
"which is not static", csi->static_decl, csi->function);
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
c_inline_statics = NULL;
|
c_inline_statics = NULL;
|
}
|
}
|
|
|
/* Fill in a c_spot_bindings structure. If DEFINING is true, set it
|
/* Fill in a c_spot_bindings structure. If DEFINING is true, set it
|
for the current state, otherwise set it to uninitialized. */
|
for the current state, otherwise set it to uninitialized. */
|
|
|
static void
|
static void
|
set_spot_bindings (struct c_spot_bindings *p, bool defining)
|
set_spot_bindings (struct c_spot_bindings *p, bool defining)
|
{
|
{
|
if (defining)
|
if (defining)
|
{
|
{
|
p->scope = current_scope;
|
p->scope = current_scope;
|
p->bindings_in_scope = current_scope->bindings;
|
p->bindings_in_scope = current_scope->bindings;
|
}
|
}
|
else
|
else
|
{
|
{
|
p->scope = NULL;
|
p->scope = NULL;
|
p->bindings_in_scope = NULL;
|
p->bindings_in_scope = NULL;
|
}
|
}
|
p->stmt_exprs = 0;
|
p->stmt_exprs = 0;
|
p->left_stmt_expr = false;
|
p->left_stmt_expr = false;
|
}
|
}
|
|
|
/* Return true if we will want to say something if a goto statement
|
/* Return true if we will want to say something if a goto statement
|
crosses DECL. */
|
crosses DECL. */
|
|
|
static bool
|
static bool
|
decl_jump_unsafe (tree decl)
|
decl_jump_unsafe (tree decl)
|
{
|
{
|
if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
|
if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
|
return false;
|
return false;
|
|
|
/* Always warn about crossing variably modified types. */
|
/* Always warn about crossing variably modified types. */
|
if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == TYPE_DECL)
|
if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == TYPE_DECL)
|
&& variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
|
&& variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
|
return true;
|
return true;
|
|
|
/* Otherwise, only warn if -Wgoto-misses-init and this is an
|
/* Otherwise, only warn if -Wgoto-misses-init and this is an
|
initialized automatic decl. */
|
initialized automatic decl. */
|
if (warn_jump_misses_init
|
if (warn_jump_misses_init
|
&& TREE_CODE (decl) == VAR_DECL
|
&& TREE_CODE (decl) == VAR_DECL
|
&& !TREE_STATIC (decl)
|
&& !TREE_STATIC (decl)
|
&& DECL_INITIAL (decl) != NULL_TREE)
|
&& DECL_INITIAL (decl) != NULL_TREE)
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Update spot bindings P as we pop out of SCOPE. Return true if we
|
/* Update spot bindings P as we pop out of SCOPE. Return true if we
|
should push decls for a label. */
|
should push decls for a label. */
|
|
|
static bool
|
static bool
|
update_spot_bindings (struct c_scope *scope, struct c_spot_bindings *p)
|
update_spot_bindings (struct c_scope *scope, struct c_spot_bindings *p)
|
{
|
{
|
if (p->scope != scope)
|
if (p->scope != scope)
|
{
|
{
|
/* This label or goto is defined in some other scope, or it is a
|
/* This label or goto is defined in some other scope, or it is a
|
label which is not yet defined. There is nothing to
|
label which is not yet defined. There is nothing to
|
update. */
|
update. */
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Adjust the spot bindings to refer to the bindings already defined
|
/* Adjust the spot bindings to refer to the bindings already defined
|
in the enclosing scope. */
|
in the enclosing scope. */
|
p->scope = scope->outer;
|
p->scope = scope->outer;
|
p->bindings_in_scope = p->scope->bindings;
|
p->bindings_in_scope = p->scope->bindings;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* The Objective-C front-end often needs to determine the current scope. */
|
/* The Objective-C front-end often needs to determine the current scope. */
|
|
|
void *
|
void *
|
objc_get_current_scope (void)
|
objc_get_current_scope (void)
|
{
|
{
|
return current_scope;
|
return current_scope;
|
}
|
}
|
|
|
/* The following function is used only by Objective-C. It needs to live here
|
/* The following function is used only by Objective-C. It needs to live here
|
because it accesses the innards of c_scope. */
|
because it accesses the innards of c_scope. */
|
|
|
void
|
void
|
objc_mark_locals_volatile (void *enclosing_blk)
|
objc_mark_locals_volatile (void *enclosing_blk)
|
{
|
{
|
struct c_scope *scope;
|
struct c_scope *scope;
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
for (scope = current_scope;
|
for (scope = current_scope;
|
scope && scope != enclosing_blk;
|
scope && scope != enclosing_blk;
|
scope = scope->outer)
|
scope = scope->outer)
|
{
|
{
|
for (b = scope->bindings; b; b = b->prev)
|
for (b = scope->bindings; b; b = b->prev)
|
objc_volatilize_decl (b->decl);
|
objc_volatilize_decl (b->decl);
|
|
|
/* Do not climb up past the current function. */
|
/* Do not climb up past the current function. */
|
if (scope->function_body)
|
if (scope->function_body)
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Nonzero if we are currently in file scope. */
|
/* Nonzero if we are currently in file scope. */
|
|
|
int
|
int
|
global_bindings_p (void)
|
global_bindings_p (void)
|
{
|
{
|
return (current_scope == file_scope && !c_override_global_bindings_to_false
|
return (current_scope == file_scope && !c_override_global_bindings_to_false
|
? -1
|
? -1
|
: 0);
|
: 0);
|
}
|
}
|
|
|
void
|
void
|
keep_next_level (void)
|
keep_next_level (void)
|
{
|
{
|
keep_next_level_flag = true;
|
keep_next_level_flag = true;
|
}
|
}
|
|
|
/* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
|
/* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
|
|
|
void
|
void
|
set_float_const_decimal64 (void)
|
set_float_const_decimal64 (void)
|
{
|
{
|
current_scope->float_const_decimal64 = true;
|
current_scope->float_const_decimal64 = true;
|
}
|
}
|
|
|
/* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
|
/* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
|
|
|
void
|
void
|
clear_float_const_decimal64 (void)
|
clear_float_const_decimal64 (void)
|
{
|
{
|
current_scope->float_const_decimal64 = false;
|
current_scope->float_const_decimal64 = false;
|
}
|
}
|
|
|
/* Return nonzero if an unsuffixed float constant is _Decimal64. */
|
/* Return nonzero if an unsuffixed float constant is _Decimal64. */
|
|
|
bool
|
bool
|
float_const_decimal64_p (void)
|
float_const_decimal64_p (void)
|
{
|
{
|
return current_scope->float_const_decimal64;
|
return current_scope->float_const_decimal64;
|
}
|
}
|
|
|
/* Identify this scope as currently being filled with parameters. */
|
/* Identify this scope as currently being filled with parameters. */
|
|
|
void
|
void
|
declare_parm_level (void)
|
declare_parm_level (void)
|
{
|
{
|
current_scope->parm_flag = true;
|
current_scope->parm_flag = true;
|
}
|
}
|
|
|
void
|
void
|
push_scope (void)
|
push_scope (void)
|
{
|
{
|
if (next_is_function_body)
|
if (next_is_function_body)
|
{
|
{
|
/* This is the transition from the parameters to the top level
|
/* This is the transition from the parameters to the top level
|
of the function body. These are the same scope
|
of the function body. These are the same scope
|
(C99 6.2.1p4,6) so we do not push another scope structure.
|
(C99 6.2.1p4,6) so we do not push another scope structure.
|
next_is_function_body is set only by store_parm_decls, which
|
next_is_function_body is set only by store_parm_decls, which
|
in turn is called when and only when we are about to
|
in turn is called when and only when we are about to
|
encounter the opening curly brace for the function body.
|
encounter the opening curly brace for the function body.
|
|
|
The outermost block of a function always gets a BLOCK node,
|
The outermost block of a function always gets a BLOCK node,
|
because the debugging output routines expect that each
|
because the debugging output routines expect that each
|
function has at least one BLOCK. */
|
function has at least one BLOCK. */
|
current_scope->parm_flag = false;
|
current_scope->parm_flag = false;
|
current_scope->function_body = true;
|
current_scope->function_body = true;
|
current_scope->keep = true;
|
current_scope->keep = true;
|
current_scope->outer_function = current_function_scope;
|
current_scope->outer_function = current_function_scope;
|
current_function_scope = current_scope;
|
current_function_scope = current_scope;
|
|
|
keep_next_level_flag = false;
|
keep_next_level_flag = false;
|
next_is_function_body = false;
|
next_is_function_body = false;
|
|
|
/* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
|
/* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
|
if (current_scope->outer)
|
if (current_scope->outer)
|
current_scope->float_const_decimal64
|
current_scope->float_const_decimal64
|
= current_scope->outer->float_const_decimal64;
|
= current_scope->outer->float_const_decimal64;
|
else
|
else
|
current_scope->float_const_decimal64 = false;
|
current_scope->float_const_decimal64 = false;
|
}
|
}
|
else
|
else
|
{
|
{
|
struct c_scope *scope;
|
struct c_scope *scope;
|
if (scope_freelist)
|
if (scope_freelist)
|
{
|
{
|
scope = scope_freelist;
|
scope = scope_freelist;
|
scope_freelist = scope->outer;
|
scope_freelist = scope->outer;
|
}
|
}
|
else
|
else
|
scope = GGC_CNEW (struct c_scope);
|
scope = GGC_CNEW (struct c_scope);
|
|
|
/* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
|
/* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
|
if (current_scope)
|
if (current_scope)
|
scope->float_const_decimal64 = current_scope->float_const_decimal64;
|
scope->float_const_decimal64 = current_scope->float_const_decimal64;
|
else
|
else
|
scope->float_const_decimal64 = false;
|
scope->float_const_decimal64 = false;
|
|
|
scope->keep = keep_next_level_flag;
|
scope->keep = keep_next_level_flag;
|
scope->outer = current_scope;
|
scope->outer = current_scope;
|
scope->depth = current_scope ? (current_scope->depth + 1) : 0;
|
scope->depth = current_scope ? (current_scope->depth + 1) : 0;
|
|
|
/* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
|
/* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
|
possible. */
|
possible. */
|
if (current_scope && scope->depth == 0)
|
if (current_scope && scope->depth == 0)
|
{
|
{
|
scope->depth--;
|
scope->depth--;
|
sorry ("GCC supports only %u nested scopes", scope->depth);
|
sorry ("GCC supports only %u nested scopes", scope->depth);
|
}
|
}
|
|
|
current_scope = scope;
|
current_scope = scope;
|
keep_next_level_flag = false;
|
keep_next_level_flag = false;
|
}
|
}
|
}
|
}
|
|
|
/* This is called when we are leaving SCOPE. For each label defined
|
/* This is called when we are leaving SCOPE. For each label defined
|
in SCOPE, add any appropriate decls to its decls_in_scope fields.
|
in SCOPE, add any appropriate decls to its decls_in_scope fields.
|
These are the decls whose initialization will be skipped by a goto
|
These are the decls whose initialization will be skipped by a goto
|
later in the function. */
|
later in the function. */
|
|
|
static void
|
static void
|
update_label_decls (struct c_scope *scope)
|
update_label_decls (struct c_scope *scope)
|
{
|
{
|
struct c_scope *s;
|
struct c_scope *s;
|
|
|
s = scope;
|
s = scope;
|
while (s != NULL)
|
while (s != NULL)
|
{
|
{
|
if (s->has_label_bindings)
|
if (s->has_label_bindings)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
for (b = s->bindings; b != NULL; b = b->prev)
|
for (b = s->bindings; b != NULL; b = b->prev)
|
{
|
{
|
struct c_label_vars *label_vars;
|
struct c_label_vars *label_vars;
|
struct c_binding *b1;
|
struct c_binding *b1;
|
unsigned int ix;
|
unsigned int ix;
|
struct c_goto_bindings *g;
|
struct c_goto_bindings *g;
|
|
|
if (TREE_CODE (b->decl) != LABEL_DECL)
|
if (TREE_CODE (b->decl) != LABEL_DECL)
|
continue;
|
continue;
|
label_vars = b->u.label;
|
label_vars = b->u.label;
|
|
|
b1 = label_vars->label_bindings.bindings_in_scope;
|
b1 = label_vars->label_bindings.bindings_in_scope;
|
if (update_spot_bindings (scope, &label_vars->label_bindings))
|
if (update_spot_bindings (scope, &label_vars->label_bindings))
|
{
|
{
|
/* This label is defined in this scope. */
|
/* This label is defined in this scope. */
|
for (; b1 != NULL; b1 = b1->prev)
|
for (; b1 != NULL; b1 = b1->prev)
|
{
|
{
|
/* A goto from later in the function to this
|
/* A goto from later in the function to this
|
label will never see the initialization of
|
label will never see the initialization of
|
B1, if any. Save it to issue a warning if
|
B1, if any. Save it to issue a warning if
|
needed. */
|
needed. */
|
if (decl_jump_unsafe (b1->decl))
|
if (decl_jump_unsafe (b1->decl))
|
VEC_safe_push (tree, gc, label_vars->decls_in_scope,
|
VEC_safe_push (tree, gc, label_vars->decls_in_scope,
|
b1->decl);
|
b1->decl);
|
}
|
}
|
}
|
}
|
|
|
/* Update the bindings of any goto statements associated
|
/* Update the bindings of any goto statements associated
|
with this label. */
|
with this label. */
|
for (ix = 0;
|
for (ix = 0;
|
VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
|
VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
|
++ix)
|
++ix)
|
update_spot_bindings (scope, &g->goto_bindings);
|
update_spot_bindings (scope, &g->goto_bindings);
|
}
|
}
|
}
|
}
|
|
|
/* Don't search beyond the current function. */
|
/* Don't search beyond the current function. */
|
if (s == current_function_scope)
|
if (s == current_function_scope)
|
break;
|
break;
|
|
|
s = s->outer;
|
s = s->outer;
|
}
|
}
|
}
|
}
|
|
|
/* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
|
/* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
|
|
|
static void
|
static void
|
set_type_context (tree type, tree context)
|
set_type_context (tree type, tree context)
|
{
|
{
|
for (type = TYPE_MAIN_VARIANT (type); type;
|
for (type = TYPE_MAIN_VARIANT (type); type;
|
type = TYPE_NEXT_VARIANT (type))
|
type = TYPE_NEXT_VARIANT (type))
|
TYPE_CONTEXT (type) = context;
|
TYPE_CONTEXT (type) = context;
|
}
|
}
|
|
|
/* Exit a scope. Restore the state of the identifier-decl mappings
|
/* Exit a scope. Restore the state of the identifier-decl mappings
|
that were in effect when this scope was entered. Return a BLOCK
|
that were in effect when this scope was entered. Return a BLOCK
|
node containing all the DECLs in this scope that are of interest
|
node containing all the DECLs in this scope that are of interest
|
to debug info generation. */
|
to debug info generation. */
|
|
|
tree
|
tree
|
pop_scope (void)
|
pop_scope (void)
|
{
|
{
|
struct c_scope *scope = current_scope;
|
struct c_scope *scope = current_scope;
|
tree block, context, p;
|
tree block, context, p;
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
bool functionbody = scope->function_body;
|
bool functionbody = scope->function_body;
|
bool keep = functionbody || scope->keep || scope->bindings;
|
bool keep = functionbody || scope->keep || scope->bindings;
|
|
|
update_label_decls (scope);
|
update_label_decls (scope);
|
|
|
/* If appropriate, create a BLOCK to record the decls for the life
|
/* If appropriate, create a BLOCK to record the decls for the life
|
of this function. */
|
of this function. */
|
block = 0;
|
block = 0;
|
if (keep)
|
if (keep)
|
{
|
{
|
block = make_node (BLOCK);
|
block = make_node (BLOCK);
|
BLOCK_SUBBLOCKS (block) = scope->blocks;
|
BLOCK_SUBBLOCKS (block) = scope->blocks;
|
TREE_USED (block) = 1;
|
TREE_USED (block) = 1;
|
|
|
/* In each subblock, record that this is its superior. */
|
/* In each subblock, record that this is its superior. */
|
for (p = scope->blocks; p; p = BLOCK_CHAIN (p))
|
for (p = scope->blocks; p; p = BLOCK_CHAIN (p))
|
BLOCK_SUPERCONTEXT (p) = block;
|
BLOCK_SUPERCONTEXT (p) = block;
|
|
|
BLOCK_VARS (block) = 0;
|
BLOCK_VARS (block) = 0;
|
}
|
}
|
|
|
/* The TYPE_CONTEXTs for all of the tagged types belonging to this
|
/* The TYPE_CONTEXTs for all of the tagged types belonging to this
|
scope must be set so that they point to the appropriate
|
scope must be set so that they point to the appropriate
|
construct, i.e. either to the current FUNCTION_DECL node, or
|
construct, i.e. either to the current FUNCTION_DECL node, or
|
else to the BLOCK node we just constructed.
|
else to the BLOCK node we just constructed.
|
|
|
Note that for tagged types whose scope is just the formal
|
Note that for tagged types whose scope is just the formal
|
parameter list for some function type specification, we can't
|
parameter list for some function type specification, we can't
|
properly set their TYPE_CONTEXTs here, because we don't have a
|
properly set their TYPE_CONTEXTs here, because we don't have a
|
pointer to the appropriate FUNCTION_TYPE node readily available
|
pointer to the appropriate FUNCTION_TYPE node readily available
|
to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
|
to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
|
type nodes get set in `grokdeclarator' as soon as we have created
|
type nodes get set in `grokdeclarator' as soon as we have created
|
the FUNCTION_TYPE node which will represent the "scope" for these
|
the FUNCTION_TYPE node which will represent the "scope" for these
|
"parameter list local" tagged types. */
|
"parameter list local" tagged types. */
|
if (scope->function_body)
|
if (scope->function_body)
|
context = current_function_decl;
|
context = current_function_decl;
|
else if (scope == file_scope)
|
else if (scope == file_scope)
|
{
|
{
|
tree file_decl = build_decl (UNKNOWN_LOCATION,
|
tree file_decl = build_decl (UNKNOWN_LOCATION,
|
TRANSLATION_UNIT_DECL, 0, 0);
|
TRANSLATION_UNIT_DECL, 0, 0);
|
TREE_CHAIN (file_decl) = all_translation_units;
|
TREE_CHAIN (file_decl) = all_translation_units;
|
all_translation_units = file_decl;
|
all_translation_units = file_decl;
|
context = file_decl;
|
context = file_decl;
|
}
|
}
|
else
|
else
|
context = block;
|
context = block;
|
|
|
/* Clear all bindings in this scope. */
|
/* Clear all bindings in this scope. */
|
for (b = scope->bindings; b; b = free_binding_and_advance (b))
|
for (b = scope->bindings; b; b = free_binding_and_advance (b))
|
{
|
{
|
p = b->decl;
|
p = b->decl;
|
switch (TREE_CODE (p))
|
switch (TREE_CODE (p))
|
{
|
{
|
case LABEL_DECL:
|
case LABEL_DECL:
|
/* Warnings for unused labels, errors for undefined labels. */
|
/* Warnings for unused labels, errors for undefined labels. */
|
if (TREE_USED (p) && !DECL_INITIAL (p))
|
if (TREE_USED (p) && !DECL_INITIAL (p))
|
{
|
{
|
error ("label %q+D used but not defined", p);
|
error ("label %q+D used but not defined", p);
|
DECL_INITIAL (p) = error_mark_node;
|
DECL_INITIAL (p) = error_mark_node;
|
}
|
}
|
else
|
else
|
warn_for_unused_label (p);
|
warn_for_unused_label (p);
|
|
|
/* Labels go in BLOCK_VARS. */
|
/* Labels go in BLOCK_VARS. */
|
TREE_CHAIN (p) = BLOCK_VARS (block);
|
TREE_CHAIN (p) = BLOCK_VARS (block);
|
BLOCK_VARS (block) = p;
|
BLOCK_VARS (block) = p;
|
gcc_assert (I_LABEL_BINDING (b->id) == b);
|
gcc_assert (I_LABEL_BINDING (b->id) == b);
|
I_LABEL_BINDING (b->id) = b->shadowed;
|
I_LABEL_BINDING (b->id) = b->shadowed;
|
|
|
/* Also pop back to the shadowed label_vars. */
|
/* Also pop back to the shadowed label_vars. */
|
release_tree_vector (b->u.label->decls_in_scope);
|
release_tree_vector (b->u.label->decls_in_scope);
|
b->u.label = b->u.label->shadowed;
|
b->u.label = b->u.label->shadowed;
|
break;
|
break;
|
|
|
case ENUMERAL_TYPE:
|
case ENUMERAL_TYPE:
|
case UNION_TYPE:
|
case UNION_TYPE:
|
case RECORD_TYPE:
|
case RECORD_TYPE:
|
set_type_context (p, context);
|
set_type_context (p, context);
|
|
|
/* Types may not have tag-names, in which case the type
|
/* Types may not have tag-names, in which case the type
|
appears in the bindings list with b->id NULL. */
|
appears in the bindings list with b->id NULL. */
|
if (b->id)
|
if (b->id)
|
{
|
{
|
gcc_assert (I_TAG_BINDING (b->id) == b);
|
gcc_assert (I_TAG_BINDING (b->id) == b);
|
I_TAG_BINDING (b->id) = b->shadowed;
|
I_TAG_BINDING (b->id) = b->shadowed;
|
}
|
}
|
break;
|
break;
|
|
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
/* Propagate TREE_ADDRESSABLE from nested functions to their
|
/* Propagate TREE_ADDRESSABLE from nested functions to their
|
containing functions. */
|
containing functions. */
|
if (!TREE_ASM_WRITTEN (p)
|
if (!TREE_ASM_WRITTEN (p)
|
&& DECL_INITIAL (p) != 0
|
&& DECL_INITIAL (p) != 0
|
&& TREE_ADDRESSABLE (p)
|
&& TREE_ADDRESSABLE (p)
|
&& DECL_ABSTRACT_ORIGIN (p) != 0
|
&& DECL_ABSTRACT_ORIGIN (p) != 0
|
&& DECL_ABSTRACT_ORIGIN (p) != p)
|
&& DECL_ABSTRACT_ORIGIN (p) != p)
|
TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
|
TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
|
if (!DECL_EXTERNAL (p)
|
if (!DECL_EXTERNAL (p)
|
&& !DECL_INITIAL (p)
|
&& !DECL_INITIAL (p)
|
&& scope != file_scope
|
&& scope != file_scope
|
&& scope != external_scope)
|
&& scope != external_scope)
|
{
|
{
|
error ("nested function %q+D declared but never defined", p);
|
error ("nested function %q+D declared but never defined", p);
|
undef_nested_function = true;
|
undef_nested_function = true;
|
}
|
}
|
else if (DECL_DECLARED_INLINE_P (p)
|
else if (DECL_DECLARED_INLINE_P (p)
|
&& TREE_PUBLIC (p)
|
&& TREE_PUBLIC (p)
|
&& !DECL_INITIAL (p))
|
&& !DECL_INITIAL (p))
|
{
|
{
|
/* C99 6.7.4p6: "a function with external linkage... declared
|
/* C99 6.7.4p6: "a function with external linkage... declared
|
with an inline function specifier ... shall also be defined
|
with an inline function specifier ... shall also be defined
|
in the same translation unit." */
|
in the same translation unit." */
|
if (!flag_gnu89_inline)
|
if (!flag_gnu89_inline)
|
pedwarn (input_location, 0,
|
pedwarn (input_location, 0,
|
"inline function %q+D declared but never defined", p);
|
"inline function %q+D declared but never defined", p);
|
DECL_EXTERNAL (p) = 1;
|
DECL_EXTERNAL (p) = 1;
|
}
|
}
|
|
|
goto common_symbol;
|
goto common_symbol;
|
|
|
case VAR_DECL:
|
case VAR_DECL:
|
/* Warnings for unused variables. */
|
/* Warnings for unused variables. */
|
if (!TREE_USED (p)
|
if (!TREE_USED (p)
|
&& !TREE_NO_WARNING (p)
|
&& !TREE_NO_WARNING (p)
|
&& !DECL_IN_SYSTEM_HEADER (p)
|
&& !DECL_IN_SYSTEM_HEADER (p)
|
&& DECL_NAME (p)
|
&& DECL_NAME (p)
|
&& !DECL_ARTIFICIAL (p)
|
&& !DECL_ARTIFICIAL (p)
|
&& scope != file_scope
|
&& scope != file_scope
|
&& scope != external_scope)
|
&& scope != external_scope)
|
warning (OPT_Wunused_variable, "unused variable %q+D", p);
|
warning (OPT_Wunused_variable, "unused variable %q+D", p);
|
|
|
if (b->inner_comp)
|
if (b->inner_comp)
|
{
|
{
|
error ("type of array %q+D completed incompatibly with"
|
error ("type of array %q+D completed incompatibly with"
|
" implicit initialization", p);
|
" implicit initialization", p);
|
}
|
}
|
|
|
/* Fall through. */
|
/* Fall through. */
|
case TYPE_DECL:
|
case TYPE_DECL:
|
case CONST_DECL:
|
case CONST_DECL:
|
common_symbol:
|
common_symbol:
|
/* All of these go in BLOCK_VARS, but only if this is the
|
/* All of these go in BLOCK_VARS, but only if this is the
|
binding in the home scope. */
|
binding in the home scope. */
|
if (!b->nested)
|
if (!b->nested)
|
{
|
{
|
TREE_CHAIN (p) = BLOCK_VARS (block);
|
TREE_CHAIN (p) = BLOCK_VARS (block);
|
BLOCK_VARS (block) = p;
|
BLOCK_VARS (block) = p;
|
}
|
}
|
else if (VAR_OR_FUNCTION_DECL_P (p))
|
else if (VAR_OR_FUNCTION_DECL_P (p))
|
{
|
{
|
/* For block local externs add a special
|
/* For block local externs add a special
|
DECL_EXTERNAL decl for debug info generation. */
|
DECL_EXTERNAL decl for debug info generation. */
|
tree extp = copy_node (p);
|
tree extp = copy_node (p);
|
|
|
DECL_EXTERNAL (extp) = 1;
|
DECL_EXTERNAL (extp) = 1;
|
TREE_STATIC (extp) = 0;
|
TREE_STATIC (extp) = 0;
|
TREE_PUBLIC (extp) = 1;
|
TREE_PUBLIC (extp) = 1;
|
DECL_INITIAL (extp) = NULL_TREE;
|
DECL_INITIAL (extp) = NULL_TREE;
|
DECL_LANG_SPECIFIC (extp) = NULL;
|
DECL_LANG_SPECIFIC (extp) = NULL;
|
DECL_CONTEXT (extp) = current_function_decl;
|
DECL_CONTEXT (extp) = current_function_decl;
|
if (TREE_CODE (p) == FUNCTION_DECL)
|
if (TREE_CODE (p) == FUNCTION_DECL)
|
{
|
{
|
DECL_RESULT (extp) = NULL_TREE;
|
DECL_RESULT (extp) = NULL_TREE;
|
DECL_SAVED_TREE (extp) = NULL_TREE;
|
DECL_SAVED_TREE (extp) = NULL_TREE;
|
DECL_STRUCT_FUNCTION (extp) = NULL;
|
DECL_STRUCT_FUNCTION (extp) = NULL;
|
}
|
}
|
if (b->locus != UNKNOWN_LOCATION)
|
if (b->locus != UNKNOWN_LOCATION)
|
DECL_SOURCE_LOCATION (extp) = b->locus;
|
DECL_SOURCE_LOCATION (extp) = b->locus;
|
TREE_CHAIN (extp) = BLOCK_VARS (block);
|
TREE_CHAIN (extp) = BLOCK_VARS (block);
|
BLOCK_VARS (block) = extp;
|
BLOCK_VARS (block) = extp;
|
}
|
}
|
/* If this is the file scope, and we are processing more
|
/* If this is the file scope, and we are processing more
|
than one translation unit in this compilation, set
|
than one translation unit in this compilation, set
|
DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
|
DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
|
This makes same_translation_unit_p work, and causes
|
This makes same_translation_unit_p work, and causes
|
static declarations to be given disambiguating suffixes. */
|
static declarations to be given disambiguating suffixes. */
|
if (scope == file_scope && num_in_fnames > 1)
|
if (scope == file_scope && num_in_fnames > 1)
|
{
|
{
|
DECL_CONTEXT (p) = context;
|
DECL_CONTEXT (p) = context;
|
if (TREE_CODE (p) == TYPE_DECL)
|
if (TREE_CODE (p) == TYPE_DECL)
|
set_type_context (TREE_TYPE (p), context);
|
set_type_context (TREE_TYPE (p), context);
|
}
|
}
|
|
|
/* Fall through. */
|
/* Fall through. */
|
/* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
|
/* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
|
already been put there by store_parm_decls. Unused-
|
already been put there by store_parm_decls. Unused-
|
parameter warnings are handled by function.c.
|
parameter warnings are handled by function.c.
|
error_mark_node obviously does not go in BLOCK_VARS and
|
error_mark_node obviously does not go in BLOCK_VARS and
|
does not get unused-variable warnings. */
|
does not get unused-variable warnings. */
|
case PARM_DECL:
|
case PARM_DECL:
|
case ERROR_MARK:
|
case ERROR_MARK:
|
/* It is possible for a decl not to have a name. We get
|
/* It is possible for a decl not to have a name. We get
|
here with b->id NULL in this case. */
|
here with b->id NULL in this case. */
|
if (b->id)
|
if (b->id)
|
{
|
{
|
gcc_assert (I_SYMBOL_BINDING (b->id) == b);
|
gcc_assert (I_SYMBOL_BINDING (b->id) == b);
|
I_SYMBOL_BINDING (b->id) = b->shadowed;
|
I_SYMBOL_BINDING (b->id) = b->shadowed;
|
if (b->shadowed && b->shadowed->u.type)
|
if (b->shadowed && b->shadowed->u.type)
|
TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
|
TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Dispose of the block that we just made inside some higher level. */
|
/* Dispose of the block that we just made inside some higher level. */
|
if ((scope->function_body || scope == file_scope) && context)
|
if ((scope->function_body || scope == file_scope) && context)
|
{
|
{
|
DECL_INITIAL (context) = block;
|
DECL_INITIAL (context) = block;
|
BLOCK_SUPERCONTEXT (block) = context;
|
BLOCK_SUPERCONTEXT (block) = context;
|
}
|
}
|
else if (scope->outer)
|
else if (scope->outer)
|
{
|
{
|
if (block)
|
if (block)
|
SCOPE_LIST_APPEND (scope->outer, blocks, block);
|
SCOPE_LIST_APPEND (scope->outer, blocks, block);
|
/* If we did not make a block for the scope just exited, any
|
/* If we did not make a block for the scope just exited, any
|
blocks made for inner scopes must be carried forward so they
|
blocks made for inner scopes must be carried forward so they
|
will later become subblocks of something else. */
|
will later become subblocks of something else. */
|
else if (scope->blocks)
|
else if (scope->blocks)
|
SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
|
SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
|
}
|
}
|
|
|
/* Pop the current scope, and free the structure for reuse. */
|
/* Pop the current scope, and free the structure for reuse. */
|
current_scope = scope->outer;
|
current_scope = scope->outer;
|
if (scope->function_body)
|
if (scope->function_body)
|
current_function_scope = scope->outer_function;
|
current_function_scope = scope->outer_function;
|
|
|
memset (scope, 0, sizeof (struct c_scope));
|
memset (scope, 0, sizeof (struct c_scope));
|
scope->outer = scope_freelist;
|
scope->outer = scope_freelist;
|
scope_freelist = scope;
|
scope_freelist = scope;
|
|
|
return block;
|
return block;
|
}
|
}
|
|
|
void
|
void
|
push_file_scope (void)
|
push_file_scope (void)
|
{
|
{
|
tree decl;
|
tree decl;
|
|
|
if (file_scope)
|
if (file_scope)
|
return;
|
return;
|
|
|
push_scope ();
|
push_scope ();
|
file_scope = current_scope;
|
file_scope = current_scope;
|
|
|
start_fname_decls ();
|
start_fname_decls ();
|
|
|
for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
|
for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
|
bind (DECL_NAME (decl), decl, file_scope,
|
bind (DECL_NAME (decl), decl, file_scope,
|
/*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
|
/*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
|
}
|
}
|
|
|
void
|
void
|
pop_file_scope (void)
|
pop_file_scope (void)
|
{
|
{
|
/* In case there were missing closebraces, get us back to the global
|
/* In case there were missing closebraces, get us back to the global
|
binding level. */
|
binding level. */
|
while (current_scope != file_scope)
|
while (current_scope != file_scope)
|
pop_scope ();
|
pop_scope ();
|
|
|
/* __FUNCTION__ is defined at file scope (""). This
|
/* __FUNCTION__ is defined at file scope (""). This
|
call may not be necessary as my tests indicate it
|
call may not be necessary as my tests indicate it
|
still works without it. */
|
still works without it. */
|
finish_fname_decls ();
|
finish_fname_decls ();
|
|
|
check_inline_statics ();
|
check_inline_statics ();
|
|
|
/* This is the point to write out a PCH if we're doing that.
|
/* This is the point to write out a PCH if we're doing that.
|
In that case we do not want to do anything else. */
|
In that case we do not want to do anything else. */
|
if (pch_file)
|
if (pch_file)
|
{
|
{
|
c_common_write_pch ();
|
c_common_write_pch ();
|
return;
|
return;
|
}
|
}
|
|
|
/* Pop off the file scope and close this translation unit. */
|
/* Pop off the file scope and close this translation unit. */
|
pop_scope ();
|
pop_scope ();
|
file_scope = 0;
|
file_scope = 0;
|
|
|
maybe_apply_pending_pragma_weaks ();
|
maybe_apply_pending_pragma_weaks ();
|
}
|
}
|
|
|
/* Adjust the bindings for the start of a statement expression. */
|
/* Adjust the bindings for the start of a statement expression. */
|
|
|
void
|
void
|
c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
|
c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
|
{
|
{
|
struct c_scope *scope;
|
struct c_scope *scope;
|
|
|
for (scope = current_scope; scope != NULL; scope = scope->outer)
|
for (scope = current_scope; scope != NULL; scope = scope->outer)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
if (!scope->has_label_bindings)
|
if (!scope->has_label_bindings)
|
continue;
|
continue;
|
|
|
for (b = scope->bindings; b != NULL; b = b->prev)
|
for (b = scope->bindings; b != NULL; b = b->prev)
|
{
|
{
|
struct c_label_vars *label_vars;
|
struct c_label_vars *label_vars;
|
unsigned int ix;
|
unsigned int ix;
|
struct c_goto_bindings *g;
|
struct c_goto_bindings *g;
|
|
|
if (TREE_CODE (b->decl) != LABEL_DECL)
|
if (TREE_CODE (b->decl) != LABEL_DECL)
|
continue;
|
continue;
|
label_vars = b->u.label;
|
label_vars = b->u.label;
|
++label_vars->label_bindings.stmt_exprs;
|
++label_vars->label_bindings.stmt_exprs;
|
for (ix = 0;
|
for (ix = 0;
|
VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
|
VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
|
++ix)
|
++ix)
|
++g->goto_bindings.stmt_exprs;
|
++g->goto_bindings.stmt_exprs;
|
}
|
}
|
}
|
}
|
|
|
if (switch_bindings != NULL)
|
if (switch_bindings != NULL)
|
++switch_bindings->stmt_exprs;
|
++switch_bindings->stmt_exprs;
|
}
|
}
|
|
|
/* Adjust the bindings for the end of a statement expression. */
|
/* Adjust the bindings for the end of a statement expression. */
|
|
|
void
|
void
|
c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
|
c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
|
{
|
{
|
struct c_scope *scope;
|
struct c_scope *scope;
|
|
|
for (scope = current_scope; scope != NULL; scope = scope->outer)
|
for (scope = current_scope; scope != NULL; scope = scope->outer)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
if (!scope->has_label_bindings)
|
if (!scope->has_label_bindings)
|
continue;
|
continue;
|
|
|
for (b = scope->bindings; b != NULL; b = b->prev)
|
for (b = scope->bindings; b != NULL; b = b->prev)
|
{
|
{
|
struct c_label_vars *label_vars;
|
struct c_label_vars *label_vars;
|
unsigned int ix;
|
unsigned int ix;
|
struct c_goto_bindings *g;
|
struct c_goto_bindings *g;
|
|
|
if (TREE_CODE (b->decl) != LABEL_DECL)
|
if (TREE_CODE (b->decl) != LABEL_DECL)
|
continue;
|
continue;
|
label_vars = b->u.label;
|
label_vars = b->u.label;
|
--label_vars->label_bindings.stmt_exprs;
|
--label_vars->label_bindings.stmt_exprs;
|
if (label_vars->label_bindings.stmt_exprs < 0)
|
if (label_vars->label_bindings.stmt_exprs < 0)
|
{
|
{
|
label_vars->label_bindings.left_stmt_expr = true;
|
label_vars->label_bindings.left_stmt_expr = true;
|
label_vars->label_bindings.stmt_exprs = 0;
|
label_vars->label_bindings.stmt_exprs = 0;
|
}
|
}
|
for (ix = 0;
|
for (ix = 0;
|
VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
|
VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
|
++ix)
|
++ix)
|
{
|
{
|
--g->goto_bindings.stmt_exprs;
|
--g->goto_bindings.stmt_exprs;
|
if (g->goto_bindings.stmt_exprs < 0)
|
if (g->goto_bindings.stmt_exprs < 0)
|
{
|
{
|
g->goto_bindings.left_stmt_expr = true;
|
g->goto_bindings.left_stmt_expr = true;
|
g->goto_bindings.stmt_exprs = 0;
|
g->goto_bindings.stmt_exprs = 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (switch_bindings != NULL)
|
if (switch_bindings != NULL)
|
{
|
{
|
--switch_bindings->stmt_exprs;
|
--switch_bindings->stmt_exprs;
|
gcc_assert (switch_bindings->stmt_exprs >= 0);
|
gcc_assert (switch_bindings->stmt_exprs >= 0);
|
}
|
}
|
}
|
}
|
|
|
/* Push a definition or a declaration of struct, union or enum tag "name".
|
/* Push a definition or a declaration of struct, union or enum tag "name".
|
"type" should be the type node.
|
"type" should be the type node.
|
We assume that the tag "name" is not already defined, and has a location
|
We assume that the tag "name" is not already defined, and has a location
|
of LOC.
|
of LOC.
|
|
|
Note that the definition may really be just a forward reference.
|
Note that the definition may really be just a forward reference.
|
In that case, the TYPE_SIZE will be zero. */
|
In that case, the TYPE_SIZE will be zero. */
|
|
|
static void
|
static void
|
pushtag (location_t loc, tree name, tree type)
|
pushtag (location_t loc, tree name, tree type)
|
{
|
{
|
/* Record the identifier as the type's name if it has none. */
|
/* Record the identifier as the type's name if it has none. */
|
if (name && !TYPE_NAME (type))
|
if (name && !TYPE_NAME (type))
|
TYPE_NAME (type) = name;
|
TYPE_NAME (type) = name;
|
bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc);
|
bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc);
|
|
|
/* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
|
/* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
|
tagged type we just added to the current scope. This fake
|
tagged type we just added to the current scope. This fake
|
NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
|
NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
|
to output a representation of a tagged type, and it also gives
|
to output a representation of a tagged type, and it also gives
|
us a convenient place to record the "scope start" address for the
|
us a convenient place to record the "scope start" address for the
|
tagged type. */
|
tagged type. */
|
|
|
TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
|
TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
|
TYPE_DECL, NULL_TREE, type));
|
TYPE_DECL, NULL_TREE, type));
|
|
|
/* An approximation for now, so we can tell this is a function-scope tag.
|
/* An approximation for now, so we can tell this is a function-scope tag.
|
This will be updated in pop_scope. */
|
This will be updated in pop_scope. */
|
TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
|
TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
|
|
|
if (warn_cxx_compat && name != NULL_TREE)
|
if (warn_cxx_compat && name != NULL_TREE)
|
{
|
{
|
struct c_binding *b = I_SYMBOL_BINDING (name);
|
struct c_binding *b = I_SYMBOL_BINDING (name);
|
|
|
if (b != NULL
|
if (b != NULL
|
&& b->decl != NULL_TREE
|
&& b->decl != NULL_TREE
|
&& TREE_CODE (b->decl) == TYPE_DECL
|
&& TREE_CODE (b->decl) == TYPE_DECL
|
&& (B_IN_CURRENT_SCOPE (b)
|
&& (B_IN_CURRENT_SCOPE (b)
|
|| (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
|
|| (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
|
&& (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
|
&& (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
|
!= TYPE_MAIN_VARIANT (type)))
|
!= TYPE_MAIN_VARIANT (type)))
|
{
|
{
|
warning_at (loc, OPT_Wc___compat,
|
warning_at (loc, OPT_Wc___compat,
|
("using %qD as both a typedef and a tag is "
|
("using %qD as both a typedef and a tag is "
|
"invalid in C++"),
|
"invalid in C++"),
|
b->decl);
|
b->decl);
|
if (b->locus != UNKNOWN_LOCATION)
|
if (b->locus != UNKNOWN_LOCATION)
|
inform (b->locus, "originally defined here");
|
inform (b->locus, "originally defined here");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Subroutine of compare_decls. Allow harmless mismatches in return
|
/* Subroutine of compare_decls. Allow harmless mismatches in return
|
and argument types provided that the type modes match. This function
|
and argument types provided that the type modes match. This function
|
return a unified type given a suitable match, and 0 otherwise. */
|
return a unified type given a suitable match, and 0 otherwise. */
|
|
|
static tree
|
static tree
|
match_builtin_function_types (tree newtype, tree oldtype)
|
match_builtin_function_types (tree newtype, tree oldtype)
|
{
|
{
|
tree newrettype, oldrettype;
|
tree newrettype, oldrettype;
|
tree newargs, oldargs;
|
tree newargs, oldargs;
|
tree trytype, tryargs;
|
tree trytype, tryargs;
|
|
|
/* Accept the return type of the new declaration if same modes. */
|
/* Accept the return type of the new declaration if same modes. */
|
oldrettype = TREE_TYPE (oldtype);
|
oldrettype = TREE_TYPE (oldtype);
|
newrettype = TREE_TYPE (newtype);
|
newrettype = TREE_TYPE (newtype);
|
|
|
if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
|
if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
|
return 0;
|
return 0;
|
|
|
oldargs = TYPE_ARG_TYPES (oldtype);
|
oldargs = TYPE_ARG_TYPES (oldtype);
|
newargs = TYPE_ARG_TYPES (newtype);
|
newargs = TYPE_ARG_TYPES (newtype);
|
tryargs = newargs;
|
tryargs = newargs;
|
|
|
while (oldargs || newargs)
|
while (oldargs || newargs)
|
{
|
{
|
if (!oldargs
|
if (!oldargs
|
|| !newargs
|
|| !newargs
|
|| !TREE_VALUE (oldargs)
|
|| !TREE_VALUE (oldargs)
|
|| !TREE_VALUE (newargs)
|
|| !TREE_VALUE (newargs)
|
|| TYPE_MODE (TREE_VALUE (oldargs))
|
|| TYPE_MODE (TREE_VALUE (oldargs))
|
!= TYPE_MODE (TREE_VALUE (newargs)))
|
!= TYPE_MODE (TREE_VALUE (newargs)))
|
return 0;
|
return 0;
|
|
|
oldargs = TREE_CHAIN (oldargs);
|
oldargs = TREE_CHAIN (oldargs);
|
newargs = TREE_CHAIN (newargs);
|
newargs = TREE_CHAIN (newargs);
|
}
|
}
|
|
|
trytype = build_function_type (newrettype, tryargs);
|
trytype = build_function_type (newrettype, tryargs);
|
return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
|
return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
|
}
|
}
|
|
|
/* Subroutine of diagnose_mismatched_decls. Check for function type
|
/* Subroutine of diagnose_mismatched_decls. Check for function type
|
mismatch involving an empty arglist vs a nonempty one and give clearer
|
mismatch involving an empty arglist vs a nonempty one and give clearer
|
diagnostics. */
|
diagnostics. */
|
static void
|
static void
|
diagnose_arglist_conflict (tree newdecl, tree olddecl,
|
diagnose_arglist_conflict (tree newdecl, tree olddecl,
|
tree newtype, tree oldtype)
|
tree newtype, tree oldtype)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
if (TREE_CODE (olddecl) != FUNCTION_DECL
|
if (TREE_CODE (olddecl) != FUNCTION_DECL
|
|| !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
|
|| !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
|
|| !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
|
|| !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
|
||
|
||
|
(TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
|
(TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
|
return;
|
return;
|
|
|
t = TYPE_ARG_TYPES (oldtype);
|
t = TYPE_ARG_TYPES (oldtype);
|
if (t == 0)
|
if (t == 0)
|
t = TYPE_ARG_TYPES (newtype);
|
t = TYPE_ARG_TYPES (newtype);
|
for (; t; t = TREE_CHAIN (t))
|
for (; t; t = TREE_CHAIN (t))
|
{
|
{
|
tree type = TREE_VALUE (t);
|
tree type = TREE_VALUE (t);
|
|
|
if (TREE_CHAIN (t) == 0
|
if (TREE_CHAIN (t) == 0
|
&& TYPE_MAIN_VARIANT (type) != void_type_node)
|
&& TYPE_MAIN_VARIANT (type) != void_type_node)
|
{
|
{
|
inform (input_location, "a parameter list with an ellipsis can%'t match "
|
inform (input_location, "a parameter list with an ellipsis can%'t match "
|
"an empty parameter name list declaration");
|
"an empty parameter name list declaration");
|
break;
|
break;
|
}
|
}
|
|
|
if (c_type_promotes_to (type) != type)
|
if (c_type_promotes_to (type) != type)
|
{
|
{
|
inform (input_location, "an argument type that has a default promotion can%'t match "
|
inform (input_location, "an argument type that has a default promotion can%'t match "
|
"an empty parameter name list declaration");
|
"an empty parameter name list declaration");
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
|
/* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
|
old-style function definition, NEWDECL is a prototype declaration.
|
old-style function definition, NEWDECL is a prototype declaration.
|
Diagnose inconsistencies in the argument list. Returns TRUE if
|
Diagnose inconsistencies in the argument list. Returns TRUE if
|
the prototype is compatible, FALSE if not. */
|
the prototype is compatible, FALSE if not. */
|
static bool
|
static bool
|
validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
|
validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
|
{
|
{
|
tree newargs, oldargs;
|
tree newargs, oldargs;
|
int i;
|
int i;
|
|
|
#define END_OF_ARGLIST(t) ((t) == void_type_node)
|
#define END_OF_ARGLIST(t) ((t) == void_type_node)
|
|
|
oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
|
oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
|
newargs = TYPE_ARG_TYPES (newtype);
|
newargs = TYPE_ARG_TYPES (newtype);
|
i = 1;
|
i = 1;
|
|
|
for (;;)
|
for (;;)
|
{
|
{
|
tree oldargtype = TREE_VALUE (oldargs);
|
tree oldargtype = TREE_VALUE (oldargs);
|
tree newargtype = TREE_VALUE (newargs);
|
tree newargtype = TREE_VALUE (newargs);
|
|
|
if (oldargtype == error_mark_node || newargtype == error_mark_node)
|
if (oldargtype == error_mark_node || newargtype == error_mark_node)
|
return false;
|
return false;
|
|
|
oldargtype = TYPE_MAIN_VARIANT (oldargtype);
|
oldargtype = TYPE_MAIN_VARIANT (oldargtype);
|
newargtype = TYPE_MAIN_VARIANT (newargtype);
|
newargtype = TYPE_MAIN_VARIANT (newargtype);
|
|
|
if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
|
if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
|
break;
|
break;
|
|
|
/* Reaching the end of just one list means the two decls don't
|
/* Reaching the end of just one list means the two decls don't
|
agree on the number of arguments. */
|
agree on the number of arguments. */
|
if (END_OF_ARGLIST (oldargtype))
|
if (END_OF_ARGLIST (oldargtype))
|
{
|
{
|
error ("prototype for %q+D declares more arguments "
|
error ("prototype for %q+D declares more arguments "
|
"than previous old-style definition", newdecl);
|
"than previous old-style definition", newdecl);
|
return false;
|
return false;
|
}
|
}
|
else if (END_OF_ARGLIST (newargtype))
|
else if (END_OF_ARGLIST (newargtype))
|
{
|
{
|
error ("prototype for %q+D declares fewer arguments "
|
error ("prototype for %q+D declares fewer arguments "
|
"than previous old-style definition", newdecl);
|
"than previous old-style definition", newdecl);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Type for passing arg must be consistent with that declared
|
/* Type for passing arg must be consistent with that declared
|
for the arg. */
|
for the arg. */
|
else if (!comptypes (oldargtype, newargtype))
|
else if (!comptypes (oldargtype, newargtype))
|
{
|
{
|
error ("prototype for %q+D declares argument %d"
|
error ("prototype for %q+D declares argument %d"
|
" with incompatible type",
|
" with incompatible type",
|
newdecl, i);
|
newdecl, i);
|
return false;
|
return false;
|
}
|
}
|
|
|
oldargs = TREE_CHAIN (oldargs);
|
oldargs = TREE_CHAIN (oldargs);
|
newargs = TREE_CHAIN (newargs);
|
newargs = TREE_CHAIN (newargs);
|
i++;
|
i++;
|
}
|
}
|
|
|
/* If we get here, no errors were found, but do issue a warning
|
/* If we get here, no errors were found, but do issue a warning
|
for this poor-style construct. */
|
for this poor-style construct. */
|
warning (0, "prototype for %q+D follows non-prototype definition",
|
warning (0, "prototype for %q+D follows non-prototype definition",
|
newdecl);
|
newdecl);
|
return true;
|
return true;
|
#undef END_OF_ARGLIST
|
#undef END_OF_ARGLIST
|
}
|
}
|
|
|
/* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
|
/* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
|
first in a pair of mismatched declarations, using the diagnostic
|
first in a pair of mismatched declarations, using the diagnostic
|
function DIAG. */
|
function DIAG. */
|
static void
|
static void
|
locate_old_decl (tree decl)
|
locate_old_decl (tree decl)
|
{
|
{
|
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
|
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
|
;
|
;
|
else if (DECL_INITIAL (decl))
|
else if (DECL_INITIAL (decl))
|
inform (input_location, "previous definition of %q+D was here", decl);
|
inform (input_location, "previous definition of %q+D was here", decl);
|
else if (C_DECL_IMPLICIT (decl))
|
else if (C_DECL_IMPLICIT (decl))
|
inform (input_location, "previous implicit declaration of %q+D was here", decl);
|
inform (input_location, "previous implicit declaration of %q+D was here", decl);
|
else
|
else
|
inform (input_location, "previous declaration of %q+D was here", decl);
|
inform (input_location, "previous declaration of %q+D was here", decl);
|
}
|
}
|
|
|
/* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
|
/* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
|
Returns true if the caller should proceed to merge the two, false
|
Returns true if the caller should proceed to merge the two, false
|
if OLDDECL should simply be discarded. As a side effect, issues
|
if OLDDECL should simply be discarded. As a side effect, issues
|
all necessary diagnostics for invalid or poor-style combinations.
|
all necessary diagnostics for invalid or poor-style combinations.
|
If it returns true, writes the types of NEWDECL and OLDDECL to
|
If it returns true, writes the types of NEWDECL and OLDDECL to
|
*NEWTYPEP and *OLDTYPEP - these may have been adjusted from
|
*NEWTYPEP and *OLDTYPEP - these may have been adjusted from
|
TREE_TYPE (NEWDECL, OLDDECL) respectively. */
|
TREE_TYPE (NEWDECL, OLDDECL) respectively. */
|
|
|
static bool
|
static bool
|
diagnose_mismatched_decls (tree newdecl, tree olddecl,
|
diagnose_mismatched_decls (tree newdecl, tree olddecl,
|
tree *newtypep, tree *oldtypep)
|
tree *newtypep, tree *oldtypep)
|
{
|
{
|
tree newtype, oldtype;
|
tree newtype, oldtype;
|
bool pedwarned = false;
|
bool pedwarned = false;
|
bool warned = false;
|
bool warned = false;
|
bool retval = true;
|
bool retval = true;
|
|
|
#define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
|
#define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
|
&& DECL_EXTERNAL (DECL))
|
&& DECL_EXTERNAL (DECL))
|
|
|
/* If we have error_mark_node for either decl or type, just discard
|
/* If we have error_mark_node for either decl or type, just discard
|
the previous decl - we're in an error cascade already. */
|
the previous decl - we're in an error cascade already. */
|
if (olddecl == error_mark_node || newdecl == error_mark_node)
|
if (olddecl == error_mark_node || newdecl == error_mark_node)
|
return false;
|
return false;
|
*oldtypep = oldtype = TREE_TYPE (olddecl);
|
*oldtypep = oldtype = TREE_TYPE (olddecl);
|
*newtypep = newtype = TREE_TYPE (newdecl);
|
*newtypep = newtype = TREE_TYPE (newdecl);
|
if (oldtype == error_mark_node || newtype == error_mark_node)
|
if (oldtype == error_mark_node || newtype == error_mark_node)
|
return false;
|
return false;
|
|
|
/* Two different categories of symbol altogether. This is an error
|
/* Two different categories of symbol altogether. This is an error
|
unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
|
unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
|
if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
|
if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
|
{
|
{
|
if (!(TREE_CODE (olddecl) == FUNCTION_DECL
|
if (!(TREE_CODE (olddecl) == FUNCTION_DECL
|
&& DECL_BUILT_IN (olddecl)
|
&& DECL_BUILT_IN (olddecl)
|
&& !C_DECL_DECLARED_BUILTIN (olddecl)))
|
&& !C_DECL_DECLARED_BUILTIN (olddecl)))
|
{
|
{
|
error ("%q+D redeclared as different kind of symbol", newdecl);
|
error ("%q+D redeclared as different kind of symbol", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
}
|
}
|
else if (TREE_PUBLIC (newdecl))
|
else if (TREE_PUBLIC (newdecl))
|
warning (0, "built-in function %q+D declared as non-function",
|
warning (0, "built-in function %q+D declared as non-function",
|
newdecl);
|
newdecl);
|
else
|
else
|
warning (OPT_Wshadow, "declaration of %q+D shadows "
|
warning (OPT_Wshadow, "declaration of %q+D shadows "
|
"a built-in function", newdecl);
|
"a built-in function", newdecl);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Enumerators have no linkage, so may only be declared once in a
|
/* Enumerators have no linkage, so may only be declared once in a
|
given scope. */
|
given scope. */
|
if (TREE_CODE (olddecl) == CONST_DECL)
|
if (TREE_CODE (olddecl) == CONST_DECL)
|
{
|
{
|
error ("redeclaration of enumerator %q+D", newdecl);
|
error ("redeclaration of enumerator %q+D", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
|
|
if (!comptypes (oldtype, newtype))
|
if (!comptypes (oldtype, newtype))
|
{
|
{
|
if (TREE_CODE (olddecl) == FUNCTION_DECL
|
if (TREE_CODE (olddecl) == FUNCTION_DECL
|
&& DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
|
&& DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
|
{
|
{
|
/* Accept harmless mismatch in function types.
|
/* Accept harmless mismatch in function types.
|
This is for the ffs and fprintf builtins. */
|
This is for the ffs and fprintf builtins. */
|
tree trytype = match_builtin_function_types (newtype, oldtype);
|
tree trytype = match_builtin_function_types (newtype, oldtype);
|
|
|
if (trytype && comptypes (newtype, trytype))
|
if (trytype && comptypes (newtype, trytype))
|
*oldtypep = oldtype = trytype;
|
*oldtypep = oldtype = trytype;
|
else
|
else
|
{
|
{
|
/* If types don't match for a built-in, throw away the
|
/* If types don't match for a built-in, throw away the
|
built-in. No point in calling locate_old_decl here, it
|
built-in. No point in calling locate_old_decl here, it
|
won't print anything. */
|
won't print anything. */
|
warning (0, "conflicting types for built-in function %q+D",
|
warning (0, "conflicting types for built-in function %q+D",
|
newdecl);
|
newdecl);
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
else if (TREE_CODE (olddecl) == FUNCTION_DECL
|
else if (TREE_CODE (olddecl) == FUNCTION_DECL
|
&& DECL_IS_BUILTIN (olddecl))
|
&& DECL_IS_BUILTIN (olddecl))
|
{
|
{
|
/* A conflicting function declaration for a predeclared
|
/* A conflicting function declaration for a predeclared
|
function that isn't actually built in. Objective C uses
|
function that isn't actually built in. Objective C uses
|
these. The new declaration silently overrides everything
|
these. The new declaration silently overrides everything
|
but the volatility (i.e. noreturn) indication. See also
|
but the volatility (i.e. noreturn) indication. See also
|
below. FIXME: Make Objective C use normal builtins. */
|
below. FIXME: Make Objective C use normal builtins. */
|
TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
|
TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
|
return false;
|
return false;
|
}
|
}
|
/* Permit void foo (...) to match int foo (...) if the latter is
|
/* Permit void foo (...) to match int foo (...) if the latter is
|
the definition and implicit int was used. See
|
the definition and implicit int was used. See
|
c-torture/compile/920625-2.c. */
|
c-torture/compile/920625-2.c. */
|
else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
|
else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
|
&& C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
|
&& C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
|
{
|
{
|
pedwarned = pedwarn (input_location, 0,
|
pedwarned = pedwarn (input_location, 0,
|
"conflicting types for %q+D", newdecl);
|
"conflicting types for %q+D", newdecl);
|
/* Make sure we keep void as the return type. */
|
/* Make sure we keep void as the return type. */
|
TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
|
TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
|
C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
|
C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
|
}
|
}
|
/* Permit void foo (...) to match an earlier call to foo (...) with
|
/* Permit void foo (...) to match an earlier call to foo (...) with
|
no declared type (thus, implicitly int). */
|
no declared type (thus, implicitly int). */
|
else if (TREE_CODE (newdecl) == FUNCTION_DECL
|
else if (TREE_CODE (newdecl) == FUNCTION_DECL
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
|
&& C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
|
&& C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
|
{
|
{
|
pedwarned = pedwarn (input_location, 0,
|
pedwarned = pedwarn (input_location, 0,
|
"conflicting types for %q+D", newdecl);
|
"conflicting types for %q+D", newdecl);
|
/* Make sure we keep void as the return type. */
|
/* Make sure we keep void as the return type. */
|
TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
|
TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
|
}
|
}
|
else
|
else
|
{
|
{
|
int new_quals = TYPE_QUALS (newtype);
|
int new_quals = TYPE_QUALS (newtype);
|
int old_quals = TYPE_QUALS (oldtype);
|
int old_quals = TYPE_QUALS (oldtype);
|
|
|
if (new_quals != old_quals)
|
if (new_quals != old_quals)
|
{
|
{
|
addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals);
|
addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals);
|
addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals);
|
addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals);
|
if (new_addr != old_addr)
|
if (new_addr != old_addr)
|
{
|
{
|
if (ADDR_SPACE_GENERIC_P (new_addr))
|
if (ADDR_SPACE_GENERIC_P (new_addr))
|
error ("conflicting named address spaces (generic vs %s) "
|
error ("conflicting named address spaces (generic vs %s) "
|
"for %q+D",
|
"for %q+D",
|
c_addr_space_name (old_addr), newdecl);
|
c_addr_space_name (old_addr), newdecl);
|
else if (ADDR_SPACE_GENERIC_P (old_addr))
|
else if (ADDR_SPACE_GENERIC_P (old_addr))
|
error ("conflicting named address spaces (%s vs generic) "
|
error ("conflicting named address spaces (%s vs generic) "
|
"for %q+D",
|
"for %q+D",
|
c_addr_space_name (new_addr), newdecl);
|
c_addr_space_name (new_addr), newdecl);
|
else
|
else
|
error ("conflicting named address spaces (%s vs %s) "
|
error ("conflicting named address spaces (%s vs %s) "
|
"for %q+D",
|
"for %q+D",
|
c_addr_space_name (new_addr),
|
c_addr_space_name (new_addr),
|
c_addr_space_name (old_addr),
|
c_addr_space_name (old_addr),
|
newdecl);
|
newdecl);
|
}
|
}
|
|
|
if (CLEAR_QUAL_ADDR_SPACE (new_quals)
|
if (CLEAR_QUAL_ADDR_SPACE (new_quals)
|
!= CLEAR_QUAL_ADDR_SPACE (old_quals))
|
!= CLEAR_QUAL_ADDR_SPACE (old_quals))
|
error ("conflicting type qualifiers for %q+D", newdecl);
|
error ("conflicting type qualifiers for %q+D", newdecl);
|
}
|
}
|
else
|
else
|
error ("conflicting types for %q+D", newdecl);
|
error ("conflicting types for %q+D", newdecl);
|
diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
|
diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
/* Redeclaration of a type is a constraint violation (6.7.2.3p1),
|
/* Redeclaration of a type is a constraint violation (6.7.2.3p1),
|
but silently ignore the redeclaration if either is in a system
|
but silently ignore the redeclaration if either is in a system
|
header. (Conflicting redeclarations were handled above.) */
|
header. (Conflicting redeclarations were handled above.) */
|
if (TREE_CODE (newdecl) == TYPE_DECL)
|
if (TREE_CODE (newdecl) == TYPE_DECL)
|
{
|
{
|
if (DECL_IN_SYSTEM_HEADER (newdecl)
|
if (DECL_IN_SYSTEM_HEADER (newdecl)
|
|| DECL_IN_SYSTEM_HEADER (olddecl)
|
|| DECL_IN_SYSTEM_HEADER (olddecl)
|
|| TREE_NO_WARNING (newdecl)
|
|| TREE_NO_WARNING (newdecl)
|
|| TREE_NO_WARNING (olddecl))
|
|| TREE_NO_WARNING (olddecl))
|
return true; /* Allow OLDDECL to continue in use. */
|
return true; /* Allow OLDDECL to continue in use. */
|
|
|
error ("redefinition of typedef %q+D", newdecl);
|
error ("redefinition of typedef %q+D", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Function declarations can either be 'static' or 'extern' (no
|
/* Function declarations can either be 'static' or 'extern' (no
|
qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
|
qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
|
can never conflict with each other on account of linkage
|
can never conflict with each other on account of linkage
|
(6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
|
(6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
|
gnu89 mode permits two definitions if one is 'extern inline' and
|
gnu89 mode permits two definitions if one is 'extern inline' and
|
one is not. The non- extern-inline definition supersedes the
|
one is not. The non- extern-inline definition supersedes the
|
extern-inline definition. */
|
extern-inline definition. */
|
|
|
else if (TREE_CODE (newdecl) == FUNCTION_DECL)
|
else if (TREE_CODE (newdecl) == FUNCTION_DECL)
|
{
|
{
|
/* If you declare a built-in function name as static, or
|
/* If you declare a built-in function name as static, or
|
define the built-in with an old-style definition (so we
|
define the built-in with an old-style definition (so we
|
can't validate the argument list) the built-in definition is
|
can't validate the argument list) the built-in definition is
|
overridden, but optionally warn this was a bad choice of name. */
|
overridden, but optionally warn this was a bad choice of name. */
|
if (DECL_BUILT_IN (olddecl)
|
if (DECL_BUILT_IN (olddecl)
|
&& !C_DECL_DECLARED_BUILTIN (olddecl)
|
&& !C_DECL_DECLARED_BUILTIN (olddecl)
|
&& (!TREE_PUBLIC (newdecl)
|
&& (!TREE_PUBLIC (newdecl)
|
|| (DECL_INITIAL (newdecl)
|
|| (DECL_INITIAL (newdecl)
|
&& !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
|
&& !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
|
{
|
{
|
warning (OPT_Wshadow, "declaration of %q+D shadows "
|
warning (OPT_Wshadow, "declaration of %q+D shadows "
|
"a built-in function", newdecl);
|
"a built-in function", newdecl);
|
/* Discard the old built-in function. */
|
/* Discard the old built-in function. */
|
return false;
|
return false;
|
}
|
}
|
|
|
if (DECL_INITIAL (newdecl))
|
if (DECL_INITIAL (newdecl))
|
{
|
{
|
if (DECL_INITIAL (olddecl))
|
if (DECL_INITIAL (olddecl))
|
{
|
{
|
/* If both decls are in the same TU and the new declaration
|
/* If both decls are in the same TU and the new declaration
|
isn't overriding an extern inline reject the new decl.
|
isn't overriding an extern inline reject the new decl.
|
In c99, no overriding is allowed in the same translation
|
In c99, no overriding is allowed in the same translation
|
unit. */
|
unit. */
|
if ((!DECL_EXTERN_INLINE (olddecl)
|
if ((!DECL_EXTERN_INLINE (olddecl)
|
|| DECL_EXTERN_INLINE (newdecl)
|
|| DECL_EXTERN_INLINE (newdecl)
|
|| (!flag_gnu89_inline
|
|| (!flag_gnu89_inline
|
&& (!DECL_DECLARED_INLINE_P (olddecl)
|
&& (!DECL_DECLARED_INLINE_P (olddecl)
|
|| !lookup_attribute ("gnu_inline",
|
|| !lookup_attribute ("gnu_inline",
|
DECL_ATTRIBUTES (olddecl)))
|
DECL_ATTRIBUTES (olddecl)))
|
&& (!DECL_DECLARED_INLINE_P (newdecl)
|
&& (!DECL_DECLARED_INLINE_P (newdecl)
|
|| !lookup_attribute ("gnu_inline",
|
|| !lookup_attribute ("gnu_inline",
|
DECL_ATTRIBUTES (newdecl))))
|
DECL_ATTRIBUTES (newdecl))))
|
)
|
)
|
&& same_translation_unit_p (newdecl, olddecl))
|
&& same_translation_unit_p (newdecl, olddecl))
|
{
|
{
|
error ("redefinition of %q+D", newdecl);
|
error ("redefinition of %q+D", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
}
|
}
|
/* If we have a prototype after an old-style function definition,
|
/* If we have a prototype after an old-style function definition,
|
the argument types must be checked specially. */
|
the argument types must be checked specially. */
|
else if (DECL_INITIAL (olddecl)
|
else if (DECL_INITIAL (olddecl)
|
&& !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
|
&& !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
|
&& TYPE_ACTUAL_ARG_TYPES (oldtype)
|
&& TYPE_ACTUAL_ARG_TYPES (oldtype)
|
&& !validate_proto_after_old_defn (newdecl, newtype, oldtype))
|
&& !validate_proto_after_old_defn (newdecl, newtype, oldtype))
|
{
|
{
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
/* A non-static declaration (even an "extern") followed by a
|
/* A non-static declaration (even an "extern") followed by a
|
static declaration is undefined behavior per C99 6.2.2p3-5,7.
|
static declaration is undefined behavior per C99 6.2.2p3-5,7.
|
The same is true for a static forward declaration at block
|
The same is true for a static forward declaration at block
|
scope followed by a non-static declaration/definition at file
|
scope followed by a non-static declaration/definition at file
|
scope. Static followed by non-static at the same scope is
|
scope. Static followed by non-static at the same scope is
|
not undefined behavior, and is the most convenient way to get
|
not undefined behavior, and is the most convenient way to get
|
some effects (see e.g. what unwind-dw2-fde-glibc.c does to
|
some effects (see e.g. what unwind-dw2-fde-glibc.c does to
|
the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
|
the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
|
we do diagnose it if -Wtraditional. */
|
we do diagnose it if -Wtraditional. */
|
if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
|
if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
|
{
|
{
|
/* Two exceptions to the rule. If olddecl is an extern
|
/* Two exceptions to the rule. If olddecl is an extern
|
inline, or a predeclared function that isn't actually
|
inline, or a predeclared function that isn't actually
|
built in, newdecl silently overrides olddecl. The latter
|
built in, newdecl silently overrides olddecl. The latter
|
occur only in Objective C; see also above. (FIXME: Make
|
occur only in Objective C; see also above. (FIXME: Make
|
Objective C use normal builtins.) */
|
Objective C use normal builtins.) */
|
if (!DECL_IS_BUILTIN (olddecl)
|
if (!DECL_IS_BUILTIN (olddecl)
|
&& !DECL_EXTERN_INLINE (olddecl))
|
&& !DECL_EXTERN_INLINE (olddecl))
|
{
|
{
|
error ("static declaration of %q+D follows "
|
error ("static declaration of %q+D follows "
|
"non-static declaration", newdecl);
|
"non-static declaration", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
|
else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
|
{
|
{
|
if (DECL_CONTEXT (olddecl))
|
if (DECL_CONTEXT (olddecl))
|
{
|
{
|
error ("non-static declaration of %q+D follows "
|
error ("non-static declaration of %q+D follows "
|
"static declaration", newdecl);
|
"static declaration", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
else if (warn_traditional)
|
else if (warn_traditional)
|
{
|
{
|
warned |= warning (OPT_Wtraditional,
|
warned |= warning (OPT_Wtraditional,
|
"non-static declaration of %q+D "
|
"non-static declaration of %q+D "
|
"follows static declaration", newdecl);
|
"follows static declaration", newdecl);
|
}
|
}
|
}
|
}
|
|
|
/* Make sure gnu_inline attribute is either not present, or
|
/* Make sure gnu_inline attribute is either not present, or
|
present on all inline decls. */
|
present on all inline decls. */
|
if (DECL_DECLARED_INLINE_P (olddecl)
|
if (DECL_DECLARED_INLINE_P (olddecl)
|
&& DECL_DECLARED_INLINE_P (newdecl))
|
&& DECL_DECLARED_INLINE_P (newdecl))
|
{
|
{
|
bool newa = lookup_attribute ("gnu_inline",
|
bool newa = lookup_attribute ("gnu_inline",
|
DECL_ATTRIBUTES (newdecl)) != NULL;
|
DECL_ATTRIBUTES (newdecl)) != NULL;
|
bool olda = lookup_attribute ("gnu_inline",
|
bool olda = lookup_attribute ("gnu_inline",
|
DECL_ATTRIBUTES (olddecl)) != NULL;
|
DECL_ATTRIBUTES (olddecl)) != NULL;
|
if (newa != olda)
|
if (newa != olda)
|
{
|
{
|
error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
|
error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
|
newa ? newdecl : olddecl);
|
newa ? newdecl : olddecl);
|
error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl),
|
error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl),
|
"but not here");
|
"but not here");
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (TREE_CODE (newdecl) == VAR_DECL)
|
else if (TREE_CODE (newdecl) == VAR_DECL)
|
{
|
{
|
/* Only variables can be thread-local, and all declarations must
|
/* Only variables can be thread-local, and all declarations must
|
agree on this property. */
|
agree on this property. */
|
if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
|
if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
|
{
|
{
|
/* Nothing to check. Since OLDDECL is marked threadprivate
|
/* Nothing to check. Since OLDDECL is marked threadprivate
|
and NEWDECL does not have a thread-local attribute, we
|
and NEWDECL does not have a thread-local attribute, we
|
will merge the threadprivate attribute into NEWDECL. */
|
will merge the threadprivate attribute into NEWDECL. */
|
;
|
;
|
}
|
}
|
else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
|
else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
|
{
|
{
|
if (DECL_THREAD_LOCAL_P (newdecl))
|
if (DECL_THREAD_LOCAL_P (newdecl))
|
error ("thread-local declaration of %q+D follows "
|
error ("thread-local declaration of %q+D follows "
|
"non-thread-local declaration", newdecl);
|
"non-thread-local declaration", newdecl);
|
else
|
else
|
error ("non-thread-local declaration of %q+D follows "
|
error ("non-thread-local declaration of %q+D follows "
|
"thread-local declaration", newdecl);
|
"thread-local declaration", newdecl);
|
|
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Multiple initialized definitions are not allowed (6.9p3,5). */
|
/* Multiple initialized definitions are not allowed (6.9p3,5). */
|
if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
|
if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
|
{
|
{
|
error ("redefinition of %q+D", newdecl);
|
error ("redefinition of %q+D", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Objects declared at file scope: if the first declaration had
|
/* Objects declared at file scope: if the first declaration had
|
external linkage (even if it was an external reference) the
|
external linkage (even if it was an external reference) the
|
second must have external linkage as well, or the behavior is
|
second must have external linkage as well, or the behavior is
|
undefined. If the first declaration had internal linkage, then
|
undefined. If the first declaration had internal linkage, then
|
the second must too, or else be an external reference (in which
|
the second must too, or else be an external reference (in which
|
case the composite declaration still has internal linkage).
|
case the composite declaration still has internal linkage).
|
As for function declarations, we warn about the static-then-
|
As for function declarations, we warn about the static-then-
|
extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
|
extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
|
if (DECL_FILE_SCOPE_P (newdecl)
|
if (DECL_FILE_SCOPE_P (newdecl)
|
&& TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
|
&& TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
|
{
|
{
|
if (DECL_EXTERNAL (newdecl))
|
if (DECL_EXTERNAL (newdecl))
|
{
|
{
|
if (!DECL_FILE_SCOPE_P (olddecl))
|
if (!DECL_FILE_SCOPE_P (olddecl))
|
{
|
{
|
error ("extern declaration of %q+D follows "
|
error ("extern declaration of %q+D follows "
|
"declaration with no linkage", newdecl);
|
"declaration with no linkage", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
else if (warn_traditional)
|
else if (warn_traditional)
|
{
|
{
|
warned |= warning (OPT_Wtraditional,
|
warned |= warning (OPT_Wtraditional,
|
"non-static declaration of %q+D "
|
"non-static declaration of %q+D "
|
"follows static declaration", newdecl);
|
"follows static declaration", newdecl);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (TREE_PUBLIC (newdecl))
|
if (TREE_PUBLIC (newdecl))
|
error ("non-static declaration of %q+D follows "
|
error ("non-static declaration of %q+D follows "
|
"static declaration", newdecl);
|
"static declaration", newdecl);
|
else
|
else
|
error ("static declaration of %q+D follows "
|
error ("static declaration of %q+D follows "
|
"non-static declaration", newdecl);
|
"non-static declaration", newdecl);
|
|
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
/* Two objects with the same name declared at the same block
|
/* Two objects with the same name declared at the same block
|
scope must both be external references (6.7p3). */
|
scope must both be external references (6.7p3). */
|
else if (!DECL_FILE_SCOPE_P (newdecl))
|
else if (!DECL_FILE_SCOPE_P (newdecl))
|
{
|
{
|
if (DECL_EXTERNAL (newdecl))
|
if (DECL_EXTERNAL (newdecl))
|
{
|
{
|
/* Extern with initializer at block scope, which will
|
/* Extern with initializer at block scope, which will
|
already have received an error. */
|
already have received an error. */
|
}
|
}
|
else if (DECL_EXTERNAL (olddecl))
|
else if (DECL_EXTERNAL (olddecl))
|
{
|
{
|
error ("declaration of %q+D with no linkage follows "
|
error ("declaration of %q+D with no linkage follows "
|
"extern declaration", newdecl);
|
"extern declaration", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
}
|
}
|
else
|
else
|
{
|
{
|
error ("redeclaration of %q+D with no linkage", newdecl);
|
error ("redeclaration of %q+D with no linkage", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* C++ does not permit a decl to appear multiple times at file
|
/* C++ does not permit a decl to appear multiple times at file
|
scope. */
|
scope. */
|
if (warn_cxx_compat
|
if (warn_cxx_compat
|
&& DECL_FILE_SCOPE_P (newdecl)
|
&& DECL_FILE_SCOPE_P (newdecl)
|
&& !DECL_EXTERNAL (newdecl)
|
&& !DECL_EXTERNAL (newdecl)
|
&& !DECL_EXTERNAL (olddecl))
|
&& !DECL_EXTERNAL (olddecl))
|
warned |= warning_at (DECL_SOURCE_LOCATION (newdecl),
|
warned |= warning_at (DECL_SOURCE_LOCATION (newdecl),
|
OPT_Wc___compat,
|
OPT_Wc___compat,
|
("duplicate declaration of %qD is "
|
("duplicate declaration of %qD is "
|
"invalid in C++"),
|
"invalid in C++"),
|
newdecl);
|
newdecl);
|
}
|
}
|
|
|
/* warnings */
|
/* warnings */
|
/* All decls must agree on a visibility. */
|
/* All decls must agree on a visibility. */
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
|
&& DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
|
&& DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
|
&& DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
|
&& DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
|
{
|
{
|
warned |= warning (0, "redeclaration of %q+D with different visibility "
|
warned |= warning (0, "redeclaration of %q+D with different visibility "
|
"(old visibility preserved)", newdecl);
|
"(old visibility preserved)", newdecl);
|
}
|
}
|
|
|
if (TREE_CODE (newdecl) == FUNCTION_DECL)
|
if (TREE_CODE (newdecl) == FUNCTION_DECL)
|
{
|
{
|
/* Diagnose inline __attribute__ ((noinline)) which is silly. */
|
/* Diagnose inline __attribute__ ((noinline)) which is silly. */
|
if (DECL_DECLARED_INLINE_P (newdecl)
|
if (DECL_DECLARED_INLINE_P (newdecl)
|
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
|
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
|
{
|
{
|
warned |= warning (OPT_Wattributes,
|
warned |= warning (OPT_Wattributes,
|
"inline declaration of %qD follows "
|
"inline declaration of %qD follows "
|
"declaration with attribute noinline", newdecl);
|
"declaration with attribute noinline", newdecl);
|
}
|
}
|
else if (DECL_DECLARED_INLINE_P (olddecl)
|
else if (DECL_DECLARED_INLINE_P (olddecl)
|
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
|
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
|
{
|
{
|
warned |= warning (OPT_Wattributes,
|
warned |= warning (OPT_Wattributes,
|
"declaration of %q+D with attribute "
|
"declaration of %q+D with attribute "
|
"noinline follows inline declaration ", newdecl);
|
"noinline follows inline declaration ", newdecl);
|
}
|
}
|
}
|
}
|
else /* PARM_DECL, VAR_DECL */
|
else /* PARM_DECL, VAR_DECL */
|
{
|
{
|
/* Redeclaration of a parameter is a constraint violation (this is
|
/* Redeclaration of a parameter is a constraint violation (this is
|
not explicitly stated, but follows from C99 6.7p3 [no more than
|
not explicitly stated, but follows from C99 6.7p3 [no more than
|
one declaration of the same identifier with no linkage in the
|
one declaration of the same identifier with no linkage in the
|
same scope, except type tags] and 6.2.2p6 [parameters have no
|
same scope, except type tags] and 6.2.2p6 [parameters have no
|
linkage]). We must check for a forward parameter declaration,
|
linkage]). We must check for a forward parameter declaration,
|
indicated by TREE_ASM_WRITTEN on the old declaration - this is
|
indicated by TREE_ASM_WRITTEN on the old declaration - this is
|
an extension, the mandatory diagnostic for which is handled by
|
an extension, the mandatory diagnostic for which is handled by
|
mark_forward_parm_decls. */
|
mark_forward_parm_decls. */
|
|
|
if (TREE_CODE (newdecl) == PARM_DECL
|
if (TREE_CODE (newdecl) == PARM_DECL
|
&& (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
|
&& (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
|
{
|
{
|
error ("redefinition of parameter %q+D", newdecl);
|
error ("redefinition of parameter %q+D", newdecl);
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
/* Optional warning for completely redundant decls. */
|
/* Optional warning for completely redundant decls. */
|
if (!warned && !pedwarned
|
if (!warned && !pedwarned
|
&& warn_redundant_decls
|
&& warn_redundant_decls
|
/* Don't warn about a function declaration followed by a
|
/* Don't warn about a function declaration followed by a
|
definition. */
|
definition. */
|
&& !(TREE_CODE (newdecl) == FUNCTION_DECL
|
&& !(TREE_CODE (newdecl) == FUNCTION_DECL
|
&& DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
|
&& DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
|
/* Don't warn about redundant redeclarations of builtins. */
|
/* Don't warn about redundant redeclarations of builtins. */
|
&& !(TREE_CODE (newdecl) == FUNCTION_DECL
|
&& !(TREE_CODE (newdecl) == FUNCTION_DECL
|
&& !DECL_BUILT_IN (newdecl)
|
&& !DECL_BUILT_IN (newdecl)
|
&& DECL_BUILT_IN (olddecl)
|
&& DECL_BUILT_IN (olddecl)
|
&& !C_DECL_DECLARED_BUILTIN (olddecl))
|
&& !C_DECL_DECLARED_BUILTIN (olddecl))
|
/* Don't warn about an extern followed by a definition. */
|
/* Don't warn about an extern followed by a definition. */
|
&& !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
|
&& !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
|
/* Don't warn about forward parameter decls. */
|
/* Don't warn about forward parameter decls. */
|
&& !(TREE_CODE (newdecl) == PARM_DECL
|
&& !(TREE_CODE (newdecl) == PARM_DECL
|
&& TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
|
&& TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
|
/* Don't warn about a variable definition following a declaration. */
|
/* Don't warn about a variable definition following a declaration. */
|
&& !(TREE_CODE (newdecl) == VAR_DECL
|
&& !(TREE_CODE (newdecl) == VAR_DECL
|
&& DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
|
&& DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
|
{
|
{
|
warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
|
warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
|
newdecl);
|
newdecl);
|
}
|
}
|
|
|
/* Report location of previous decl/defn. */
|
/* Report location of previous decl/defn. */
|
if (warned || pedwarned)
|
if (warned || pedwarned)
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
|
|
#undef DECL_EXTERN_INLINE
|
#undef DECL_EXTERN_INLINE
|
|
|
return retval;
|
return retval;
|
}
|
}
|
|
|
/* Subroutine of duplicate_decls. NEWDECL has been found to be
|
/* Subroutine of duplicate_decls. NEWDECL has been found to be
|
consistent with OLDDECL, but carries new information. Merge the
|
consistent with OLDDECL, but carries new information. Merge the
|
new information into OLDDECL. This function issues no
|
new information into OLDDECL. This function issues no
|
diagnostics. */
|
diagnostics. */
|
|
|
static void
|
static void
|
merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
|
merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
|
{
|
{
|
bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
|
bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
|
&& DECL_INITIAL (newdecl) != 0);
|
&& DECL_INITIAL (newdecl) != 0);
|
bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
|
bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
|
&& TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
|
&& TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
|
bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
|
bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
|
&& TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
|
&& TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
|
bool extern_changed = false;
|
bool extern_changed = false;
|
|
|
/* For real parm decl following a forward decl, rechain the old decl
|
/* For real parm decl following a forward decl, rechain the old decl
|
in its new location and clear TREE_ASM_WRITTEN (it's not a
|
in its new location and clear TREE_ASM_WRITTEN (it's not a
|
forward decl anymore). */
|
forward decl anymore). */
|
if (TREE_CODE (newdecl) == PARM_DECL
|
if (TREE_CODE (newdecl) == PARM_DECL
|
&& TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
|
&& TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
|
{
|
{
|
struct c_binding *b, **here;
|
struct c_binding *b, **here;
|
|
|
for (here = ¤t_scope->bindings; *here; here = &(*here)->prev)
|
for (here = ¤t_scope->bindings; *here; here = &(*here)->prev)
|
if ((*here)->decl == olddecl)
|
if ((*here)->decl == olddecl)
|
goto found;
|
goto found;
|
gcc_unreachable ();
|
gcc_unreachable ();
|
|
|
found:
|
found:
|
b = *here;
|
b = *here;
|
*here = b->prev;
|
*here = b->prev;
|
b->prev = current_scope->bindings;
|
b->prev = current_scope->bindings;
|
current_scope->bindings = b;
|
current_scope->bindings = b;
|
|
|
TREE_ASM_WRITTEN (olddecl) = 0;
|
TREE_ASM_WRITTEN (olddecl) = 0;
|
}
|
}
|
|
|
DECL_ATTRIBUTES (newdecl)
|
DECL_ATTRIBUTES (newdecl)
|
= targetm.merge_decl_attributes (olddecl, newdecl);
|
= targetm.merge_decl_attributes (olddecl, newdecl);
|
|
|
/* Merge the data types specified in the two decls. */
|
/* Merge the data types specified in the two decls. */
|
TREE_TYPE (newdecl)
|
TREE_TYPE (newdecl)
|
= TREE_TYPE (olddecl)
|
= TREE_TYPE (olddecl)
|
= composite_type (newtype, oldtype);
|
= composite_type (newtype, oldtype);
|
|
|
/* Lay the type out, unless already done. */
|
/* Lay the type out, unless already done. */
|
if (!comptypes (oldtype, TREE_TYPE (newdecl)))
|
if (!comptypes (oldtype, TREE_TYPE (newdecl)))
|
{
|
{
|
if (TREE_TYPE (newdecl) != error_mark_node)
|
if (TREE_TYPE (newdecl) != error_mark_node)
|
layout_type (TREE_TYPE (newdecl));
|
layout_type (TREE_TYPE (newdecl));
|
if (TREE_CODE (newdecl) != FUNCTION_DECL
|
if (TREE_CODE (newdecl) != FUNCTION_DECL
|
&& TREE_CODE (newdecl) != TYPE_DECL
|
&& TREE_CODE (newdecl) != TYPE_DECL
|
&& TREE_CODE (newdecl) != CONST_DECL)
|
&& TREE_CODE (newdecl) != CONST_DECL)
|
layout_decl (newdecl, 0);
|
layout_decl (newdecl, 0);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Since the type is OLDDECL's, make OLDDECL's size go with. */
|
/* Since the type is OLDDECL's, make OLDDECL's size go with. */
|
DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
|
DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
|
DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
|
DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
|
DECL_MODE (newdecl) = DECL_MODE (olddecl);
|
DECL_MODE (newdecl) = DECL_MODE (olddecl);
|
if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
|
if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
|
{
|
{
|
DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
|
DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
|
DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
|
DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
|
}
|
}
|
}
|
}
|
|
|
/* Keep the old rtl since we can safely use it. */
|
/* Keep the old rtl since we can safely use it. */
|
if (HAS_RTL_P (olddecl))
|
if (HAS_RTL_P (olddecl))
|
COPY_DECL_RTL (olddecl, newdecl);
|
COPY_DECL_RTL (olddecl, newdecl);
|
|
|
/* Merge the type qualifiers. */
|
/* Merge the type qualifiers. */
|
if (TREE_READONLY (newdecl))
|
if (TREE_READONLY (newdecl))
|
TREE_READONLY (olddecl) = 1;
|
TREE_READONLY (olddecl) = 1;
|
|
|
if (TREE_THIS_VOLATILE (newdecl))
|
if (TREE_THIS_VOLATILE (newdecl))
|
TREE_THIS_VOLATILE (olddecl) = 1;
|
TREE_THIS_VOLATILE (olddecl) = 1;
|
|
|
/* Merge deprecatedness. */
|
/* Merge deprecatedness. */
|
if (TREE_DEPRECATED (newdecl))
|
if (TREE_DEPRECATED (newdecl))
|
TREE_DEPRECATED (olddecl) = 1;
|
TREE_DEPRECATED (olddecl) = 1;
|
|
|
/* If a decl is in a system header and the other isn't, keep the one on the
|
/* If a decl is in a system header and the other isn't, keep the one on the
|
system header. Otherwise, keep source location of definition rather than
|
system header. Otherwise, keep source location of definition rather than
|
declaration and of prototype rather than non-prototype unless that
|
declaration and of prototype rather than non-prototype unless that
|
prototype is built-in. */
|
prototype is built-in. */
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
|
&& DECL_IN_SYSTEM_HEADER (olddecl)
|
&& DECL_IN_SYSTEM_HEADER (olddecl)
|
&& !DECL_IN_SYSTEM_HEADER (newdecl) )
|
&& !DECL_IN_SYSTEM_HEADER (newdecl) )
|
DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
|
DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
|
else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
|
else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
|
&& DECL_IN_SYSTEM_HEADER (newdecl)
|
&& DECL_IN_SYSTEM_HEADER (newdecl)
|
&& !DECL_IN_SYSTEM_HEADER (olddecl))
|
&& !DECL_IN_SYSTEM_HEADER (olddecl))
|
DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
|
DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
|
else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
|
else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
|
|| (old_is_prototype && !new_is_prototype
|
|| (old_is_prototype && !new_is_prototype
|
&& !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
|
&& !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
|
DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
|
DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
|
|
|
/* Merge the initialization information. */
|
/* Merge the initialization information. */
|
if (DECL_INITIAL (newdecl) == 0)
|
if (DECL_INITIAL (newdecl) == 0)
|
DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
|
DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
|
|
|
/* Merge the threadprivate attribute. */
|
/* Merge the threadprivate attribute. */
|
if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
|
if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
|
{
|
{
|
DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
|
DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
|
C_DECL_THREADPRIVATE_P (newdecl) = 1;
|
C_DECL_THREADPRIVATE_P (newdecl) = 1;
|
}
|
}
|
|
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
|
{
|
{
|
/* Merge the section attribute.
|
/* Merge the section attribute.
|
We want to issue an error if the sections conflict but that
|
We want to issue an error if the sections conflict but that
|
must be done later in decl_attributes since we are called
|
must be done later in decl_attributes since we are called
|
before attributes are assigned. */
|
before attributes are assigned. */
|
if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
|
if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
|
DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
|
DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
|
|
|
/* Copy the assembler name.
|
/* Copy the assembler name.
|
Currently, it can only be defined in the prototype. */
|
Currently, it can only be defined in the prototype. */
|
COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
|
COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
|
|
|
/* Use visibility of whichever declaration had it specified */
|
/* Use visibility of whichever declaration had it specified */
|
if (DECL_VISIBILITY_SPECIFIED (olddecl))
|
if (DECL_VISIBILITY_SPECIFIED (olddecl))
|
{
|
{
|
DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
|
DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
|
DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
|
DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
|
}
|
}
|
|
|
if (TREE_CODE (newdecl) == FUNCTION_DECL)
|
if (TREE_CODE (newdecl) == FUNCTION_DECL)
|
{
|
{
|
DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
|
DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
|
DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
|
DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
|
DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
|
DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
|
DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
|
DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
|
|= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
|
|= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
|
TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
|
TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
|
DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
|
DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
|
DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
|
DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
|
TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
|
TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
|
DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
|
DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
|
DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
|
DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
|
}
|
}
|
|
|
/* Merge the storage class information. */
|
/* Merge the storage class information. */
|
merge_weak (newdecl, olddecl);
|
merge_weak (newdecl, olddecl);
|
|
|
/* For functions, static overrides non-static. */
|
/* For functions, static overrides non-static. */
|
if (TREE_CODE (newdecl) == FUNCTION_DECL)
|
if (TREE_CODE (newdecl) == FUNCTION_DECL)
|
{
|
{
|
TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
|
TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
|
/* This is since we don't automatically
|
/* This is since we don't automatically
|
copy the attributes of NEWDECL into OLDDECL. */
|
copy the attributes of NEWDECL into OLDDECL. */
|
TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
|
TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
|
/* If this clears `static', clear it in the identifier too. */
|
/* If this clears `static', clear it in the identifier too. */
|
if (!TREE_PUBLIC (olddecl))
|
if (!TREE_PUBLIC (olddecl))
|
TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
|
TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
|
}
|
}
|
}
|
}
|
|
|
/* In c99, 'extern' declaration before (or after) 'inline' means this
|
/* In c99, 'extern' declaration before (or after) 'inline' means this
|
function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
|
function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
|
is present. */
|
is present. */
|
if (TREE_CODE (newdecl) == FUNCTION_DECL
|
if (TREE_CODE (newdecl) == FUNCTION_DECL
|
&& !flag_gnu89_inline
|
&& !flag_gnu89_inline
|
&& (DECL_DECLARED_INLINE_P (newdecl)
|
&& (DECL_DECLARED_INLINE_P (newdecl)
|
|| DECL_DECLARED_INLINE_P (olddecl))
|
|| DECL_DECLARED_INLINE_P (olddecl))
|
&& (!DECL_DECLARED_INLINE_P (newdecl)
|
&& (!DECL_DECLARED_INLINE_P (newdecl)
|
|| !DECL_DECLARED_INLINE_P (olddecl)
|
|| !DECL_DECLARED_INLINE_P (olddecl)
|
|| !DECL_EXTERNAL (olddecl))
|
|| !DECL_EXTERNAL (olddecl))
|
&& DECL_EXTERNAL (newdecl)
|
&& DECL_EXTERNAL (newdecl)
|
&& !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))
|
&& !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))
|
&& !current_function_decl)
|
&& !current_function_decl)
|
DECL_EXTERNAL (newdecl) = 0;
|
DECL_EXTERNAL (newdecl) = 0;
|
|
|
if (DECL_EXTERNAL (newdecl))
|
if (DECL_EXTERNAL (newdecl))
|
{
|
{
|
TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
|
TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
|
DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
|
DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
|
|
|
/* An extern decl does not override previous storage class. */
|
/* An extern decl does not override previous storage class. */
|
TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
|
TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
|
if (!DECL_EXTERNAL (newdecl))
|
if (!DECL_EXTERNAL (newdecl))
|
{
|
{
|
DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
|
DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
|
DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
|
DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
|
TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
|
TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
|
TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
|
}
|
}
|
|
|
if (TREE_CODE (newdecl) == FUNCTION_DECL)
|
if (TREE_CODE (newdecl) == FUNCTION_DECL)
|
{
|
{
|
/* If we're redefining a function previously defined as extern
|
/* If we're redefining a function previously defined as extern
|
inline, make sure we emit debug info for the inline before we
|
inline, make sure we emit debug info for the inline before we
|
throw it away, in case it was inlined into a function that
|
throw it away, in case it was inlined into a function that
|
hasn't been written out yet. */
|
hasn't been written out yet. */
|
if (new_is_definition && DECL_INITIAL (olddecl))
|
if (new_is_definition && DECL_INITIAL (olddecl))
|
/* The new defn must not be inline. */
|
/* The new defn must not be inline. */
|
DECL_UNINLINABLE (newdecl) = 1;
|
DECL_UNINLINABLE (newdecl) = 1;
|
else
|
else
|
{
|
{
|
/* If either decl says `inline', this fn is inline, unless
|
/* If either decl says `inline', this fn is inline, unless
|
its definition was passed already. */
|
its definition was passed already. */
|
if (DECL_DECLARED_INLINE_P (newdecl)
|
if (DECL_DECLARED_INLINE_P (newdecl)
|
|| DECL_DECLARED_INLINE_P (olddecl))
|
|| DECL_DECLARED_INLINE_P (olddecl))
|
DECL_DECLARED_INLINE_P (newdecl) = 1;
|
DECL_DECLARED_INLINE_P (newdecl) = 1;
|
|
|
DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
|
DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
|
= (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
|
= (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
|
|
|
DECL_DISREGARD_INLINE_LIMITS (newdecl)
|
DECL_DISREGARD_INLINE_LIMITS (newdecl)
|
= DECL_DISREGARD_INLINE_LIMITS (olddecl)
|
= DECL_DISREGARD_INLINE_LIMITS (olddecl)
|
= (DECL_DISREGARD_INLINE_LIMITS (newdecl)
|
= (DECL_DISREGARD_INLINE_LIMITS (newdecl)
|
|| DECL_DISREGARD_INLINE_LIMITS (olddecl));
|
|| DECL_DISREGARD_INLINE_LIMITS (olddecl));
|
}
|
}
|
|
|
if (DECL_BUILT_IN (olddecl))
|
if (DECL_BUILT_IN (olddecl))
|
{
|
{
|
/* If redeclaring a builtin function, it stays built in.
|
/* If redeclaring a builtin function, it stays built in.
|
But it gets tagged as having been declared. */
|
But it gets tagged as having been declared. */
|
DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
|
DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
|
DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
|
DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
|
C_DECL_DECLARED_BUILTIN (newdecl) = 1;
|
C_DECL_DECLARED_BUILTIN (newdecl) = 1;
|
if (new_is_prototype)
|
if (new_is_prototype)
|
C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
|
C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
|
else
|
else
|
C_DECL_BUILTIN_PROTOTYPE (newdecl)
|
C_DECL_BUILTIN_PROTOTYPE (newdecl)
|
= C_DECL_BUILTIN_PROTOTYPE (olddecl);
|
= C_DECL_BUILTIN_PROTOTYPE (olddecl);
|
}
|
}
|
|
|
/* Preserve function specific target and optimization options */
|
/* Preserve function specific target and optimization options */
|
if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
|
if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
|
&& !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
|
&& !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
|
DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
|
DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
|
= DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
|
= DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
|
|
|
if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
|
if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
|
&& !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
|
&& !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
|
DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
|
DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
|
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
|
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
|
|
|
/* Also preserve various other info from the definition. */
|
/* Also preserve various other info from the definition. */
|
if (!new_is_definition)
|
if (!new_is_definition)
|
{
|
{
|
tree t;
|
tree t;
|
DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
|
DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
|
DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
|
DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
|
DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
|
DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
|
DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
|
DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
|
gimple_set_body (newdecl, gimple_body (olddecl));
|
gimple_set_body (newdecl, gimple_body (olddecl));
|
DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
|
DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
|
for (t = DECL_ARGUMENTS (newdecl); t ; t = TREE_CHAIN (t))
|
for (t = DECL_ARGUMENTS (newdecl); t ; t = TREE_CHAIN (t))
|
DECL_CONTEXT (t) = newdecl;
|
DECL_CONTEXT (t) = newdecl;
|
|
|
/* See if we've got a function to instantiate from. */
|
/* See if we've got a function to instantiate from. */
|
if (DECL_SAVED_TREE (olddecl))
|
if (DECL_SAVED_TREE (olddecl))
|
DECL_ABSTRACT_ORIGIN (newdecl)
|
DECL_ABSTRACT_ORIGIN (newdecl)
|
= DECL_ABSTRACT_ORIGIN (olddecl);
|
= DECL_ABSTRACT_ORIGIN (olddecl);
|
}
|
}
|
}
|
}
|
|
|
extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
|
extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
|
|
|
/* Merge the USED information. */
|
/* Merge the USED information. */
|
if (TREE_USED (olddecl))
|
if (TREE_USED (olddecl))
|
TREE_USED (newdecl) = 1;
|
TREE_USED (newdecl) = 1;
|
else if (TREE_USED (newdecl))
|
else if (TREE_USED (newdecl))
|
TREE_USED (olddecl) = 1;
|
TREE_USED (olddecl) = 1;
|
if (DECL_PRESERVE_P (olddecl))
|
if (DECL_PRESERVE_P (olddecl))
|
DECL_PRESERVE_P (newdecl) = 1;
|
DECL_PRESERVE_P (newdecl) = 1;
|
else if (DECL_PRESERVE_P (newdecl))
|
else if (DECL_PRESERVE_P (newdecl))
|
DECL_PRESERVE_P (olddecl) = 1;
|
DECL_PRESERVE_P (olddecl) = 1;
|
|
|
/* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
|
/* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
|
But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
|
But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
|
DECL_ARGUMENTS (if appropriate). */
|
DECL_ARGUMENTS (if appropriate). */
|
{
|
{
|
unsigned olddecl_uid = DECL_UID (olddecl);
|
unsigned olddecl_uid = DECL_UID (olddecl);
|
tree olddecl_context = DECL_CONTEXT (olddecl);
|
tree olddecl_context = DECL_CONTEXT (olddecl);
|
tree olddecl_arguments = NULL;
|
tree olddecl_arguments = NULL;
|
if (TREE_CODE (olddecl) == FUNCTION_DECL)
|
if (TREE_CODE (olddecl) == FUNCTION_DECL)
|
olddecl_arguments = DECL_ARGUMENTS (olddecl);
|
olddecl_arguments = DECL_ARGUMENTS (olddecl);
|
|
|
memcpy ((char *) olddecl + sizeof (struct tree_common),
|
memcpy ((char *) olddecl + sizeof (struct tree_common),
|
(char *) newdecl + sizeof (struct tree_common),
|
(char *) newdecl + sizeof (struct tree_common),
|
sizeof (struct tree_decl_common) - sizeof (struct tree_common));
|
sizeof (struct tree_decl_common) - sizeof (struct tree_common));
|
switch (TREE_CODE (olddecl))
|
switch (TREE_CODE (olddecl))
|
{
|
{
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
gimple_set_body (olddecl, gimple_body (newdecl));
|
gimple_set_body (olddecl, gimple_body (newdecl));
|
/* fall through */
|
/* fall through */
|
|
|
case FIELD_DECL:
|
case FIELD_DECL:
|
case VAR_DECL:
|
case VAR_DECL:
|
case PARM_DECL:
|
case PARM_DECL:
|
case LABEL_DECL:
|
case LABEL_DECL:
|
case RESULT_DECL:
|
case RESULT_DECL:
|
case CONST_DECL:
|
case CONST_DECL:
|
case TYPE_DECL:
|
case TYPE_DECL:
|
memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
|
memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
|
(char *) newdecl + sizeof (struct tree_decl_common),
|
(char *) newdecl + sizeof (struct tree_decl_common),
|
tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
|
tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
|
break;
|
break;
|
|
|
default:
|
default:
|
|
|
memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
|
memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
|
(char *) newdecl + sizeof (struct tree_decl_common),
|
(char *) newdecl + sizeof (struct tree_decl_common),
|
sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
|
sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
|
}
|
}
|
DECL_UID (olddecl) = olddecl_uid;
|
DECL_UID (olddecl) = olddecl_uid;
|
DECL_CONTEXT (olddecl) = olddecl_context;
|
DECL_CONTEXT (olddecl) = olddecl_context;
|
if (TREE_CODE (olddecl) == FUNCTION_DECL)
|
if (TREE_CODE (olddecl) == FUNCTION_DECL)
|
DECL_ARGUMENTS (olddecl) = olddecl_arguments;
|
DECL_ARGUMENTS (olddecl) = olddecl_arguments;
|
}
|
}
|
|
|
/* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
|
/* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
|
so that encode_section_info has a chance to look at the new decl
|
so that encode_section_info has a chance to look at the new decl
|
flags and attributes. */
|
flags and attributes. */
|
if (DECL_RTL_SET_P (olddecl)
|
if (DECL_RTL_SET_P (olddecl)
|
&& (TREE_CODE (olddecl) == FUNCTION_DECL
|
&& (TREE_CODE (olddecl) == FUNCTION_DECL
|
|| (TREE_CODE (olddecl) == VAR_DECL
|
|| (TREE_CODE (olddecl) == VAR_DECL
|
&& TREE_STATIC (olddecl))))
|
&& TREE_STATIC (olddecl))))
|
make_decl_rtl (olddecl);
|
make_decl_rtl (olddecl);
|
|
|
/* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
|
/* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
|
and the definition is coming from the old version, cgraph needs
|
and the definition is coming from the old version, cgraph needs
|
to be called again. */
|
to be called again. */
|
if (extern_changed && !new_is_definition
|
if (extern_changed && !new_is_definition
|
&& TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
|
&& TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
|
cgraph_mark_if_needed (olddecl);
|
cgraph_mark_if_needed (olddecl);
|
}
|
}
|
|
|
/* Handle when a new declaration NEWDECL has the same name as an old
|
/* Handle when a new declaration NEWDECL has the same name as an old
|
one OLDDECL in the same binding contour. Prints an error message
|
one OLDDECL in the same binding contour. Prints an error message
|
if appropriate.
|
if appropriate.
|
|
|
If safely possible, alter OLDDECL to look like NEWDECL, and return
|
If safely possible, alter OLDDECL to look like NEWDECL, and return
|
true. Otherwise, return false. */
|
true. Otherwise, return false. */
|
|
|
static bool
|
static bool
|
duplicate_decls (tree newdecl, tree olddecl)
|
duplicate_decls (tree newdecl, tree olddecl)
|
{
|
{
|
tree newtype = NULL, oldtype = NULL;
|
tree newtype = NULL, oldtype = NULL;
|
|
|
if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
|
if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
|
{
|
{
|
/* Avoid `unused variable' and other warnings for OLDDECL. */
|
/* Avoid `unused variable' and other warnings for OLDDECL. */
|
TREE_NO_WARNING (olddecl) = 1;
|
TREE_NO_WARNING (olddecl) = 1;
|
return false;
|
return false;
|
}
|
}
|
|
|
merge_decls (newdecl, olddecl, newtype, oldtype);
|
merge_decls (newdecl, olddecl, newtype, oldtype);
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* Check whether decl-node NEW_DECL shadows an existing declaration. */
|
/* Check whether decl-node NEW_DECL shadows an existing declaration. */
|
static void
|
static void
|
warn_if_shadowing (tree new_decl)
|
warn_if_shadowing (tree new_decl)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
/* Shadow warnings wanted? */
|
/* Shadow warnings wanted? */
|
if (!warn_shadow
|
if (!warn_shadow
|
/* No shadow warnings for internally generated vars. */
|
/* No shadow warnings for internally generated vars. */
|
|| DECL_IS_BUILTIN (new_decl)
|
|| DECL_IS_BUILTIN (new_decl)
|
/* No shadow warnings for vars made for inlining. */
|
/* No shadow warnings for vars made for inlining. */
|
|| DECL_FROM_INLINE (new_decl))
|
|| DECL_FROM_INLINE (new_decl))
|
return;
|
return;
|
|
|
/* Is anything being shadowed? Invisible decls do not count. */
|
/* Is anything being shadowed? Invisible decls do not count. */
|
for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
|
for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
|
if (b->decl && b->decl != new_decl && !b->invisible)
|
if (b->decl && b->decl != new_decl && !b->invisible)
|
{
|
{
|
tree old_decl = b->decl;
|
tree old_decl = b->decl;
|
|
|
if (old_decl == error_mark_node)
|
if (old_decl == error_mark_node)
|
{
|
{
|
warning (OPT_Wshadow, "declaration of %q+D shadows previous "
|
warning (OPT_Wshadow, "declaration of %q+D shadows previous "
|
"non-variable", new_decl);
|
"non-variable", new_decl);
|
break;
|
break;
|
}
|
}
|
else if (TREE_CODE (old_decl) == PARM_DECL)
|
else if (TREE_CODE (old_decl) == PARM_DECL)
|
warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
|
warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
|
new_decl);
|
new_decl);
|
else if (DECL_FILE_SCOPE_P (old_decl))
|
else if (DECL_FILE_SCOPE_P (old_decl))
|
warning (OPT_Wshadow, "declaration of %q+D shadows a global "
|
warning (OPT_Wshadow, "declaration of %q+D shadows a global "
|
"declaration", new_decl);
|
"declaration", new_decl);
|
else if (TREE_CODE (old_decl) == FUNCTION_DECL
|
else if (TREE_CODE (old_decl) == FUNCTION_DECL
|
&& DECL_BUILT_IN (old_decl))
|
&& DECL_BUILT_IN (old_decl))
|
{
|
{
|
warning (OPT_Wshadow, "declaration of %q+D shadows "
|
warning (OPT_Wshadow, "declaration of %q+D shadows "
|
"a built-in function", new_decl);
|
"a built-in function", new_decl);
|
break;
|
break;
|
}
|
}
|
else
|
else
|
warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
|
warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
|
new_decl);
|
new_decl);
|
|
|
warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
|
warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
|
"shadowed declaration is here");
|
"shadowed declaration is here");
|
|
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Record a decl-node X as belonging to the current lexical scope.
|
/* Record a decl-node X as belonging to the current lexical scope.
|
Check for errors (such as an incompatible declaration for the same
|
Check for errors (such as an incompatible declaration for the same
|
name already seen in the same scope).
|
name already seen in the same scope).
|
|
|
Returns either X or an old decl for the same name.
|
Returns either X or an old decl for the same name.
|
If an old decl is returned, it may have been smashed
|
If an old decl is returned, it may have been smashed
|
to agree with what X says. */
|
to agree with what X says. */
|
|
|
tree
|
tree
|
pushdecl (tree x)
|
pushdecl (tree x)
|
{
|
{
|
tree name = DECL_NAME (x);
|
tree name = DECL_NAME (x);
|
struct c_scope *scope = current_scope;
|
struct c_scope *scope = current_scope;
|
struct c_binding *b;
|
struct c_binding *b;
|
bool nested = false;
|
bool nested = false;
|
location_t locus = DECL_SOURCE_LOCATION (x);
|
location_t locus = DECL_SOURCE_LOCATION (x);
|
|
|
/* Must set DECL_CONTEXT for everything not at file scope or
|
/* Must set DECL_CONTEXT for everything not at file scope or
|
DECL_FILE_SCOPE_P won't work. Local externs don't count
|
DECL_FILE_SCOPE_P won't work. Local externs don't count
|
unless they have initializers (which generate code). */
|
unless they have initializers (which generate code). */
|
if (current_function_decl
|
if (current_function_decl
|
&& ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
|
&& ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
|
|| DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
|
|| DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
|
DECL_CONTEXT (x) = current_function_decl;
|
DECL_CONTEXT (x) = current_function_decl;
|
|
|
/* Anonymous decls are just inserted in the scope. */
|
/* Anonymous decls are just inserted in the scope. */
|
if (!name)
|
if (!name)
|
{
|
{
|
bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
|
bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
|
locus);
|
locus);
|
return x;
|
return x;
|
}
|
}
|
|
|
/* First, see if there is another declaration with the same name in
|
/* First, see if there is another declaration with the same name in
|
the current scope. If there is, duplicate_decls may do all the
|
the current scope. If there is, duplicate_decls may do all the
|
work for us. If duplicate_decls returns false, that indicates
|
work for us. If duplicate_decls returns false, that indicates
|
two incompatible decls in the same scope; we are to silently
|
two incompatible decls in the same scope; we are to silently
|
replace the old one (duplicate_decls has issued all appropriate
|
replace the old one (duplicate_decls has issued all appropriate
|
diagnostics). In particular, we should not consider possible
|
diagnostics). In particular, we should not consider possible
|
duplicates in the external scope, or shadowing. */
|
duplicates in the external scope, or shadowing. */
|
b = I_SYMBOL_BINDING (name);
|
b = I_SYMBOL_BINDING (name);
|
if (b && B_IN_SCOPE (b, scope))
|
if (b && B_IN_SCOPE (b, scope))
|
{
|
{
|
struct c_binding *b_ext, *b_use;
|
struct c_binding *b_ext, *b_use;
|
tree type = TREE_TYPE (x);
|
tree type = TREE_TYPE (x);
|
tree visdecl = b->decl;
|
tree visdecl = b->decl;
|
tree vistype = TREE_TYPE (visdecl);
|
tree vistype = TREE_TYPE (visdecl);
|
if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
|
if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
|
&& COMPLETE_TYPE_P (TREE_TYPE (x)))
|
&& COMPLETE_TYPE_P (TREE_TYPE (x)))
|
b->inner_comp = false;
|
b->inner_comp = false;
|
b_use = b;
|
b_use = b;
|
b_ext = b;
|
b_ext = b;
|
/* If this is an external linkage declaration, we should check
|
/* If this is an external linkage declaration, we should check
|
for compatibility with the type in the external scope before
|
for compatibility with the type in the external scope before
|
setting the type at this scope based on the visible
|
setting the type at this scope based on the visible
|
information only. */
|
information only. */
|
if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
|
if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
|
{
|
{
|
while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
|
while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
|
b_ext = b_ext->shadowed;
|
b_ext = b_ext->shadowed;
|
if (b_ext)
|
if (b_ext)
|
{
|
{
|
b_use = b_ext;
|
b_use = b_ext;
|
if (b_use->u.type)
|
if (b_use->u.type)
|
TREE_TYPE (b_use->decl) = b_use->u.type;
|
TREE_TYPE (b_use->decl) = b_use->u.type;
|
}
|
}
|
}
|
}
|
if (duplicate_decls (x, b_use->decl))
|
if (duplicate_decls (x, b_use->decl))
|
{
|
{
|
if (b_use != b)
|
if (b_use != b)
|
{
|
{
|
/* Save the updated type in the external scope and
|
/* Save the updated type in the external scope and
|
restore the proper type for this scope. */
|
restore the proper type for this scope. */
|
tree thistype;
|
tree thistype;
|
if (comptypes (vistype, type))
|
if (comptypes (vistype, type))
|
thistype = composite_type (vistype, type);
|
thistype = composite_type (vistype, type);
|
else
|
else
|
thistype = TREE_TYPE (b_use->decl);
|
thistype = TREE_TYPE (b_use->decl);
|
b_use->u.type = TREE_TYPE (b_use->decl);
|
b_use->u.type = TREE_TYPE (b_use->decl);
|
if (TREE_CODE (b_use->decl) == FUNCTION_DECL
|
if (TREE_CODE (b_use->decl) == FUNCTION_DECL
|
&& DECL_BUILT_IN (b_use->decl))
|
&& DECL_BUILT_IN (b_use->decl))
|
thistype
|
thistype
|
= build_type_attribute_variant (thistype,
|
= build_type_attribute_variant (thistype,
|
TYPE_ATTRIBUTES
|
TYPE_ATTRIBUTES
|
(b_use->u.type));
|
(b_use->u.type));
|
TREE_TYPE (b_use->decl) = thistype;
|
TREE_TYPE (b_use->decl) = thistype;
|
}
|
}
|
return b_use->decl;
|
return b_use->decl;
|
}
|
}
|
else
|
else
|
goto skip_external_and_shadow_checks;
|
goto skip_external_and_shadow_checks;
|
}
|
}
|
|
|
/* All declarations with external linkage, and all external
|
/* All declarations with external linkage, and all external
|
references, go in the external scope, no matter what scope is
|
references, go in the external scope, no matter what scope is
|
current. However, the binding in that scope is ignored for
|
current. However, the binding in that scope is ignored for
|
purposes of normal name lookup. A separate binding structure is
|
purposes of normal name lookup. A separate binding structure is
|
created in the requested scope; this governs the normal
|
created in the requested scope; this governs the normal
|
visibility of the symbol.
|
visibility of the symbol.
|
|
|
The binding in the externals scope is used exclusively for
|
The binding in the externals scope is used exclusively for
|
detecting duplicate declarations of the same object, no matter
|
detecting duplicate declarations of the same object, no matter
|
what scope they are in; this is what we do here. (C99 6.2.7p2:
|
what scope they are in; this is what we do here. (C99 6.2.7p2:
|
All declarations that refer to the same object or function shall
|
All declarations that refer to the same object or function shall
|
have compatible type; otherwise, the behavior is undefined.) */
|
have compatible type; otherwise, the behavior is undefined.) */
|
if (DECL_EXTERNAL (x) || scope == file_scope)
|
if (DECL_EXTERNAL (x) || scope == file_scope)
|
{
|
{
|
tree type = TREE_TYPE (x);
|
tree type = TREE_TYPE (x);
|
tree vistype = 0;
|
tree vistype = 0;
|
tree visdecl = 0;
|
tree visdecl = 0;
|
bool type_saved = false;
|
bool type_saved = false;
|
if (b && !B_IN_EXTERNAL_SCOPE (b)
|
if (b && !B_IN_EXTERNAL_SCOPE (b)
|
&& (TREE_CODE (b->decl) == FUNCTION_DECL
|
&& (TREE_CODE (b->decl) == FUNCTION_DECL
|
|| TREE_CODE (b->decl) == VAR_DECL)
|
|| TREE_CODE (b->decl) == VAR_DECL)
|
&& DECL_FILE_SCOPE_P (b->decl))
|
&& DECL_FILE_SCOPE_P (b->decl))
|
{
|
{
|
visdecl = b->decl;
|
visdecl = b->decl;
|
vistype = TREE_TYPE (visdecl);
|
vistype = TREE_TYPE (visdecl);
|
}
|
}
|
if (scope != file_scope
|
if (scope != file_scope
|
&& !DECL_IN_SYSTEM_HEADER (x))
|
&& !DECL_IN_SYSTEM_HEADER (x))
|
warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
|
warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
|
|
|
while (b && !B_IN_EXTERNAL_SCOPE (b))
|
while (b && !B_IN_EXTERNAL_SCOPE (b))
|
{
|
{
|
/* If this decl might be modified, save its type. This is
|
/* If this decl might be modified, save its type. This is
|
done here rather than when the decl is first bound
|
done here rather than when the decl is first bound
|
because the type may change after first binding, through
|
because the type may change after first binding, through
|
being completed or through attributes being added. If we
|
being completed or through attributes being added. If we
|
encounter multiple such decls, only the first should have
|
encounter multiple such decls, only the first should have
|
its type saved; the others will already have had their
|
its type saved; the others will already have had their
|
proper types saved and the types will not have changed as
|
proper types saved and the types will not have changed as
|
their scopes will not have been re-entered. */
|
their scopes will not have been re-entered. */
|
if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
|
if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
|
{
|
{
|
b->u.type = TREE_TYPE (b->decl);
|
b->u.type = TREE_TYPE (b->decl);
|
type_saved = true;
|
type_saved = true;
|
}
|
}
|
if (B_IN_FILE_SCOPE (b)
|
if (B_IN_FILE_SCOPE (b)
|
&& TREE_CODE (b->decl) == VAR_DECL
|
&& TREE_CODE (b->decl) == VAR_DECL
|
&& TREE_STATIC (b->decl)
|
&& TREE_STATIC (b->decl)
|
&& TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
|
&& TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
|
&& !TYPE_DOMAIN (TREE_TYPE (b->decl))
|
&& !TYPE_DOMAIN (TREE_TYPE (b->decl))
|
&& TREE_CODE (type) == ARRAY_TYPE
|
&& TREE_CODE (type) == ARRAY_TYPE
|
&& TYPE_DOMAIN (type)
|
&& TYPE_DOMAIN (type)
|
&& TYPE_MAX_VALUE (TYPE_DOMAIN (type))
|
&& TYPE_MAX_VALUE (TYPE_DOMAIN (type))
|
&& !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
|
&& !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
|
{
|
{
|
/* Array type completed in inner scope, which should be
|
/* Array type completed in inner scope, which should be
|
diagnosed if the completion does not have size 1 and
|
diagnosed if the completion does not have size 1 and
|
it does not get completed in the file scope. */
|
it does not get completed in the file scope. */
|
b->inner_comp = true;
|
b->inner_comp = true;
|
}
|
}
|
b = b->shadowed;
|
b = b->shadowed;
|
}
|
}
|
|
|
/* If a matching external declaration has been found, set its
|
/* If a matching external declaration has been found, set its
|
type to the composite of all the types of that declaration.
|
type to the composite of all the types of that declaration.
|
After the consistency checks, it will be reset to the
|
After the consistency checks, it will be reset to the
|
composite of the visible types only. */
|
composite of the visible types only. */
|
if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
|
if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
|
&& b->u.type)
|
&& b->u.type)
|
TREE_TYPE (b->decl) = b->u.type;
|
TREE_TYPE (b->decl) = b->u.type;
|
|
|
/* The point of the same_translation_unit_p check here is,
|
/* The point of the same_translation_unit_p check here is,
|
we want to detect a duplicate decl for a construct like
|
we want to detect a duplicate decl for a construct like
|
foo() { extern bar(); } ... static bar(); but not if
|
foo() { extern bar(); } ... static bar(); but not if
|
they are in different translation units. In any case,
|
they are in different translation units. In any case,
|
the static does not go in the externals scope. */
|
the static does not go in the externals scope. */
|
if (b
|
if (b
|
&& (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
|
&& (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
|
&& duplicate_decls (x, b->decl))
|
&& duplicate_decls (x, b->decl))
|
{
|
{
|
tree thistype;
|
tree thistype;
|
if (vistype)
|
if (vistype)
|
{
|
{
|
if (comptypes (vistype, type))
|
if (comptypes (vistype, type))
|
thistype = composite_type (vistype, type);
|
thistype = composite_type (vistype, type);
|
else
|
else
|
thistype = TREE_TYPE (b->decl);
|
thistype = TREE_TYPE (b->decl);
|
}
|
}
|
else
|
else
|
thistype = type;
|
thistype = type;
|
b->u.type = TREE_TYPE (b->decl);
|
b->u.type = TREE_TYPE (b->decl);
|
if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
|
if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
|
thistype
|
thistype
|
= build_type_attribute_variant (thistype,
|
= build_type_attribute_variant (thistype,
|
TYPE_ATTRIBUTES (b->u.type));
|
TYPE_ATTRIBUTES (b->u.type));
|
TREE_TYPE (b->decl) = thistype;
|
TREE_TYPE (b->decl) = thistype;
|
bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
|
bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
|
locus);
|
locus);
|
return b->decl;
|
return b->decl;
|
}
|
}
|
else if (TREE_PUBLIC (x))
|
else if (TREE_PUBLIC (x))
|
{
|
{
|
if (visdecl && !b && duplicate_decls (x, visdecl))
|
if (visdecl && !b && duplicate_decls (x, visdecl))
|
{
|
{
|
/* An external declaration at block scope referring to a
|
/* An external declaration at block scope referring to a
|
visible entity with internal linkage. The composite
|
visible entity with internal linkage. The composite
|
type will already be correct for this scope, so we
|
type will already be correct for this scope, so we
|
just need to fall through to make the declaration in
|
just need to fall through to make the declaration in
|
this scope. */
|
this scope. */
|
nested = true;
|
nested = true;
|
x = visdecl;
|
x = visdecl;
|
}
|
}
|
else
|
else
|
{
|
{
|
bind (name, x, external_scope, /*invisible=*/true,
|
bind (name, x, external_scope, /*invisible=*/true,
|
/*nested=*/false, locus);
|
/*nested=*/false, locus);
|
nested = true;
|
nested = true;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (TREE_CODE (x) != PARM_DECL)
|
if (TREE_CODE (x) != PARM_DECL)
|
warn_if_shadowing (x);
|
warn_if_shadowing (x);
|
|
|
skip_external_and_shadow_checks:
|
skip_external_and_shadow_checks:
|
if (TREE_CODE (x) == TYPE_DECL)
|
if (TREE_CODE (x) == TYPE_DECL)
|
set_underlying_type (x);
|
set_underlying_type (x);
|
|
|
bind (name, x, scope, /*invisible=*/false, nested, locus);
|
bind (name, x, scope, /*invisible=*/false, nested, locus);
|
|
|
/* If x's type is incomplete because it's based on a
|
/* If x's type is incomplete because it's based on a
|
structure or union which has not yet been fully declared,
|
structure or union which has not yet been fully declared,
|
attach it to that structure or union type, so we can go
|
attach it to that structure or union type, so we can go
|
back and complete the variable declaration later, if the
|
back and complete the variable declaration later, if the
|
structure or union gets fully declared.
|
structure or union gets fully declared.
|
|
|
If the input is erroneous, we can have error_mark in the type
|
If the input is erroneous, we can have error_mark in the type
|
slot (e.g. "f(void a, ...)") - that doesn't count as an
|
slot (e.g. "f(void a, ...)") - that doesn't count as an
|
incomplete type. */
|
incomplete type. */
|
if (TREE_TYPE (x) != error_mark_node
|
if (TREE_TYPE (x) != error_mark_node
|
&& !COMPLETE_TYPE_P (TREE_TYPE (x)))
|
&& !COMPLETE_TYPE_P (TREE_TYPE (x)))
|
{
|
{
|
tree element = TREE_TYPE (x);
|
tree element = TREE_TYPE (x);
|
|
|
while (TREE_CODE (element) == ARRAY_TYPE)
|
while (TREE_CODE (element) == ARRAY_TYPE)
|
element = TREE_TYPE (element);
|
element = TREE_TYPE (element);
|
element = TYPE_MAIN_VARIANT (element);
|
element = TYPE_MAIN_VARIANT (element);
|
|
|
if ((TREE_CODE (element) == RECORD_TYPE
|
if ((TREE_CODE (element) == RECORD_TYPE
|
|| TREE_CODE (element) == UNION_TYPE)
|
|| TREE_CODE (element) == UNION_TYPE)
|
&& (TREE_CODE (x) != TYPE_DECL
|
&& (TREE_CODE (x) != TYPE_DECL
|
|| TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
|
|| TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
|
&& !COMPLETE_TYPE_P (element))
|
&& !COMPLETE_TYPE_P (element))
|
C_TYPE_INCOMPLETE_VARS (element)
|
C_TYPE_INCOMPLETE_VARS (element)
|
= tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
|
= tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
|
}
|
}
|
return x;
|
return x;
|
}
|
}
|
|
|
/* Record X as belonging to file scope.
|
/* Record X as belonging to file scope.
|
This is used only internally by the Objective-C front end,
|
This is used only internally by the Objective-C front end,
|
and is limited to its needs. duplicate_decls is not called;
|
and is limited to its needs. duplicate_decls is not called;
|
if there is any preexisting decl for this identifier, it is an ICE. */
|
if there is any preexisting decl for this identifier, it is an ICE. */
|
|
|
tree
|
tree
|
pushdecl_top_level (tree x)
|
pushdecl_top_level (tree x)
|
{
|
{
|
tree name;
|
tree name;
|
bool nested = false;
|
bool nested = false;
|
gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
|
gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
|
|
|
name = DECL_NAME (x);
|
name = DECL_NAME (x);
|
|
|
gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
|
gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
|
|
|
if (TREE_PUBLIC (x))
|
if (TREE_PUBLIC (x))
|
{
|
{
|
bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
|
bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
|
UNKNOWN_LOCATION);
|
UNKNOWN_LOCATION);
|
nested = true;
|
nested = true;
|
}
|
}
|
if (file_scope)
|
if (file_scope)
|
bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
|
bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
|
|
|
return x;
|
return x;
|
}
|
}
|
|
|
static void
|
static void
|
implicit_decl_warning (tree id, tree olddecl)
|
implicit_decl_warning (tree id, tree olddecl)
|
{
|
{
|
if (warn_implicit_function_declaration)
|
if (warn_implicit_function_declaration)
|
{
|
{
|
bool warned;
|
bool warned;
|
|
|
if (flag_isoc99)
|
if (flag_isoc99)
|
warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
|
warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
|
"implicit declaration of function %qE", id);
|
"implicit declaration of function %qE", id);
|
else
|
else
|
warned = warning (OPT_Wimplicit_function_declaration,
|
warned = warning (OPT_Wimplicit_function_declaration,
|
G_("implicit declaration of function %qE"), id);
|
G_("implicit declaration of function %qE"), id);
|
if (olddecl && warned)
|
if (olddecl && warned)
|
locate_old_decl (olddecl);
|
locate_old_decl (olddecl);
|
}
|
}
|
}
|
}
|
|
|
/* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
|
/* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
|
function of type int (). */
|
function of type int (). */
|
|
|
tree
|
tree
|
implicitly_declare (location_t loc, tree functionid)
|
implicitly_declare (location_t loc, tree functionid)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
tree decl = 0;
|
tree decl = 0;
|
tree asmspec_tree;
|
tree asmspec_tree;
|
|
|
for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
|
for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
|
{
|
{
|
if (B_IN_SCOPE (b, external_scope))
|
if (B_IN_SCOPE (b, external_scope))
|
{
|
{
|
decl = b->decl;
|
decl = b->decl;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (decl)
|
if (decl)
|
{
|
{
|
if (decl == error_mark_node)
|
if (decl == error_mark_node)
|
return decl;
|
return decl;
|
|
|
/* FIXME: Objective-C has weird not-really-builtin functions
|
/* FIXME: Objective-C has weird not-really-builtin functions
|
which are supposed to be visible automatically. They wind up
|
which are supposed to be visible automatically. They wind up
|
in the external scope because they're pushed before the file
|
in the external scope because they're pushed before the file
|
scope gets created. Catch this here and rebind them into the
|
scope gets created. Catch this here and rebind them into the
|
file scope. */
|
file scope. */
|
if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
|
if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
|
{
|
{
|
bind (functionid, decl, file_scope,
|
bind (functionid, decl, file_scope,
|
/*invisible=*/false, /*nested=*/true,
|
/*invisible=*/false, /*nested=*/true,
|
DECL_SOURCE_LOCATION (decl));
|
DECL_SOURCE_LOCATION (decl));
|
return decl;
|
return decl;
|
}
|
}
|
else
|
else
|
{
|
{
|
tree newtype = default_function_type;
|
tree newtype = default_function_type;
|
if (b->u.type)
|
if (b->u.type)
|
TREE_TYPE (decl) = b->u.type;
|
TREE_TYPE (decl) = b->u.type;
|
/* Implicit declaration of a function already declared
|
/* Implicit declaration of a function already declared
|
(somehow) in a different scope, or as a built-in.
|
(somehow) in a different scope, or as a built-in.
|
If this is the first time this has happened, warn;
|
If this is the first time this has happened, warn;
|
then recycle the old declaration but with the new type. */
|
then recycle the old declaration but with the new type. */
|
if (!C_DECL_IMPLICIT (decl))
|
if (!C_DECL_IMPLICIT (decl))
|
{
|
{
|
implicit_decl_warning (functionid, decl);
|
implicit_decl_warning (functionid, decl);
|
C_DECL_IMPLICIT (decl) = 1;
|
C_DECL_IMPLICIT (decl) = 1;
|
}
|
}
|
if (DECL_BUILT_IN (decl))
|
if (DECL_BUILT_IN (decl))
|
{
|
{
|
newtype = build_type_attribute_variant (newtype,
|
newtype = build_type_attribute_variant (newtype,
|
TYPE_ATTRIBUTES
|
TYPE_ATTRIBUTES
|
(TREE_TYPE (decl)));
|
(TREE_TYPE (decl)));
|
if (!comptypes (newtype, TREE_TYPE (decl)))
|
if (!comptypes (newtype, TREE_TYPE (decl)))
|
{
|
{
|
warning_at (loc, 0, "incompatible implicit declaration of "
|
warning_at (loc, 0, "incompatible implicit declaration of "
|
"built-in function %qD", decl);
|
"built-in function %qD", decl);
|
newtype = TREE_TYPE (decl);
|
newtype = TREE_TYPE (decl);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (!comptypes (newtype, TREE_TYPE (decl)))
|
if (!comptypes (newtype, TREE_TYPE (decl)))
|
{
|
{
|
error_at (loc, "incompatible implicit declaration of function %qD", decl);
|
error_at (loc, "incompatible implicit declaration of function %qD", decl);
|
locate_old_decl (decl);
|
locate_old_decl (decl);
|
}
|
}
|
}
|
}
|
b->u.type = TREE_TYPE (decl);
|
b->u.type = TREE_TYPE (decl);
|
TREE_TYPE (decl) = newtype;
|
TREE_TYPE (decl) = newtype;
|
bind (functionid, decl, current_scope,
|
bind (functionid, decl, current_scope,
|
/*invisible=*/false, /*nested=*/true,
|
/*invisible=*/false, /*nested=*/true,
|
DECL_SOURCE_LOCATION (decl));
|
DECL_SOURCE_LOCATION (decl));
|
return decl;
|
return decl;
|
}
|
}
|
}
|
}
|
|
|
/* Not seen before. */
|
/* Not seen before. */
|
decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
|
decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
|
DECL_EXTERNAL (decl) = 1;
|
DECL_EXTERNAL (decl) = 1;
|
TREE_PUBLIC (decl) = 1;
|
TREE_PUBLIC (decl) = 1;
|
C_DECL_IMPLICIT (decl) = 1;
|
C_DECL_IMPLICIT (decl) = 1;
|
implicit_decl_warning (functionid, 0);
|
implicit_decl_warning (functionid, 0);
|
asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
|
asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
|
if (asmspec_tree)
|
if (asmspec_tree)
|
set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
|
set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
|
|
|
/* C89 says implicit declarations are in the innermost block.
|
/* C89 says implicit declarations are in the innermost block.
|
So we record the decl in the standard fashion. */
|
So we record the decl in the standard fashion. */
|
decl = pushdecl (decl);
|
decl = pushdecl (decl);
|
|
|
/* No need to call objc_check_decl here - it's a function type. */
|
/* No need to call objc_check_decl here - it's a function type. */
|
rest_of_decl_compilation (decl, 0, 0);
|
rest_of_decl_compilation (decl, 0, 0);
|
|
|
/* Write a record describing this implicit function declaration
|
/* Write a record describing this implicit function declaration
|
to the prototypes file (if requested). */
|
to the prototypes file (if requested). */
|
gen_aux_info_record (decl, 0, 1, 0);
|
gen_aux_info_record (decl, 0, 1, 0);
|
|
|
/* Possibly apply some default attributes to this implicit declaration. */
|
/* Possibly apply some default attributes to this implicit declaration. */
|
decl_attributes (&decl, NULL_TREE, 0);
|
decl_attributes (&decl, NULL_TREE, 0);
|
|
|
return decl;
|
return decl;
|
}
|
}
|
|
|
/* Issue an error message for a reference to an undeclared variable
|
/* Issue an error message for a reference to an undeclared variable
|
ID, including a reference to a builtin outside of function-call
|
ID, including a reference to a builtin outside of function-call
|
context. Establish a binding of the identifier to error_mark_node
|
context. Establish a binding of the identifier to error_mark_node
|
in an appropriate scope, which will suppress further errors for the
|
in an appropriate scope, which will suppress further errors for the
|
same identifier. The error message should be given location LOC. */
|
same identifier. The error message should be given location LOC. */
|
void
|
void
|
undeclared_variable (location_t loc, tree id)
|
undeclared_variable (location_t loc, tree id)
|
{
|
{
|
static bool already = false;
|
static bool already = false;
|
struct c_scope *scope;
|
struct c_scope *scope;
|
|
|
if (current_function_decl == 0)
|
if (current_function_decl == 0)
|
{
|
{
|
error_at (loc, "%qE undeclared here (not in a function)", id);
|
error_at (loc, "%qE undeclared here (not in a function)", id);
|
scope = current_scope;
|
scope = current_scope;
|
}
|
}
|
else
|
else
|
{
|
{
|
error_at (loc, "%qE undeclared (first use in this function)", id);
|
error_at (loc, "%qE undeclared (first use in this function)", id);
|
if (!already)
|
if (!already)
|
{
|
{
|
inform (loc, "each undeclared identifier is reported only"
|
inform (loc, "each undeclared identifier is reported only"
|
" once for each function it appears in");
|
" once for each function it appears in");
|
already = true;
|
already = true;
|
}
|
}
|
|
|
/* If we are parsing old-style parameter decls, current_function_decl
|
/* If we are parsing old-style parameter decls, current_function_decl
|
will be nonnull but current_function_scope will be null. */
|
will be nonnull but current_function_scope will be null. */
|
scope = current_function_scope ? current_function_scope : current_scope;
|
scope = current_function_scope ? current_function_scope : current_scope;
|
}
|
}
|
bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
|
bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
|
UNKNOWN_LOCATION);
|
UNKNOWN_LOCATION);
|
}
|
}
|
|
|
/* Subroutine of lookup_label, declare_label, define_label: construct a
|
/* Subroutine of lookup_label, declare_label, define_label: construct a
|
LABEL_DECL with all the proper frills. Also create a struct
|
LABEL_DECL with all the proper frills. Also create a struct
|
c_label_vars initialized for the current scope. */
|
c_label_vars initialized for the current scope. */
|
|
|
static tree
|
static tree
|
make_label (location_t location, tree name, bool defining,
|
make_label (location_t location, tree name, bool defining,
|
struct c_label_vars **p_label_vars)
|
struct c_label_vars **p_label_vars)
|
{
|
{
|
tree label = build_decl (location, LABEL_DECL, name, void_type_node);
|
tree label = build_decl (location, LABEL_DECL, name, void_type_node);
|
struct c_label_vars *label_vars;
|
struct c_label_vars *label_vars;
|
|
|
DECL_CONTEXT (label) = current_function_decl;
|
DECL_CONTEXT (label) = current_function_decl;
|
DECL_MODE (label) = VOIDmode;
|
DECL_MODE (label) = VOIDmode;
|
|
|
label_vars = GGC_NEW (struct c_label_vars);
|
label_vars = GGC_NEW (struct c_label_vars);
|
label_vars->shadowed = NULL;
|
label_vars->shadowed = NULL;
|
set_spot_bindings (&label_vars->label_bindings, defining);
|
set_spot_bindings (&label_vars->label_bindings, defining);
|
label_vars->decls_in_scope = make_tree_vector ();
|
label_vars->decls_in_scope = make_tree_vector ();
|
label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
|
label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
|
*p_label_vars = label_vars;
|
*p_label_vars = label_vars;
|
|
|
return label;
|
return label;
|
}
|
}
|
|
|
/* Get the LABEL_DECL corresponding to identifier NAME as a label.
|
/* Get the LABEL_DECL corresponding to identifier NAME as a label.
|
Create one if none exists so far for the current function.
|
Create one if none exists so far for the current function.
|
This is called when a label is used in a goto expression or
|
This is called when a label is used in a goto expression or
|
has its address taken. */
|
has its address taken. */
|
|
|
tree
|
tree
|
lookup_label (tree name)
|
lookup_label (tree name)
|
{
|
{
|
tree label;
|
tree label;
|
struct c_label_vars *label_vars;
|
struct c_label_vars *label_vars;
|
|
|
if (current_function_decl == 0)
|
if (current_function_decl == 0)
|
{
|
{
|
error ("label %qE referenced outside of any function", name);
|
error ("label %qE referenced outside of any function", name);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Use a label already defined or ref'd with this name, but not if
|
/* Use a label already defined or ref'd with this name, but not if
|
it is inherited from a containing function and wasn't declared
|
it is inherited from a containing function and wasn't declared
|
using __label__. */
|
using __label__. */
|
label = I_LABEL_DECL (name);
|
label = I_LABEL_DECL (name);
|
if (label && (DECL_CONTEXT (label) == current_function_decl
|
if (label && (DECL_CONTEXT (label) == current_function_decl
|
|| C_DECLARED_LABEL_FLAG (label)))
|
|| C_DECLARED_LABEL_FLAG (label)))
|
{
|
{
|
/* If the label has only been declared, update its apparent
|
/* If the label has only been declared, update its apparent
|
location to point here, for better diagnostics if it
|
location to point here, for better diagnostics if it
|
turns out not to have been defined. */
|
turns out not to have been defined. */
|
if (DECL_INITIAL (label) == NULL_TREE)
|
if (DECL_INITIAL (label) == NULL_TREE)
|
DECL_SOURCE_LOCATION (label) = input_location;
|
DECL_SOURCE_LOCATION (label) = input_location;
|
return label;
|
return label;
|
}
|
}
|
|
|
/* No label binding for that identifier; make one. */
|
/* No label binding for that identifier; make one. */
|
label = make_label (input_location, name, false, &label_vars);
|
label = make_label (input_location, name, false, &label_vars);
|
|
|
/* Ordinary labels go in the current function scope. */
|
/* Ordinary labels go in the current function scope. */
|
bind_label (name, label, current_function_scope, label_vars);
|
bind_label (name, label, current_function_scope, label_vars);
|
|
|
return label;
|
return label;
|
}
|
}
|
|
|
/* Issue a warning about DECL for a goto statement at GOTO_LOC going
|
/* Issue a warning about DECL for a goto statement at GOTO_LOC going
|
to LABEL. */
|
to LABEL. */
|
|
|
static void
|
static void
|
warn_about_goto (location_t goto_loc, tree label, tree decl)
|
warn_about_goto (location_t goto_loc, tree label, tree decl)
|
{
|
{
|
if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
|
if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
|
error_at (goto_loc,
|
error_at (goto_loc,
|
"jump into scope of identifier with variably modified type");
|
"jump into scope of identifier with variably modified type");
|
else
|
else
|
warning_at (goto_loc, OPT_Wjump_misses_init,
|
warning_at (goto_loc, OPT_Wjump_misses_init,
|
"jump skips variable initialization");
|
"jump skips variable initialization");
|
inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
|
inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
|
inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
|
inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
|
}
|
}
|
|
|
/* Look up a label because of a goto statement. This is like
|
/* Look up a label because of a goto statement. This is like
|
lookup_label, but also issues any appropriate warnings. */
|
lookup_label, but also issues any appropriate warnings. */
|
|
|
tree
|
tree
|
lookup_label_for_goto (location_t loc, tree name)
|
lookup_label_for_goto (location_t loc, tree name)
|
{
|
{
|
tree label;
|
tree label;
|
struct c_label_vars *label_vars;
|
struct c_label_vars *label_vars;
|
unsigned int ix;
|
unsigned int ix;
|
tree decl;
|
tree decl;
|
|
|
label = lookup_label (name);
|
label = lookup_label (name);
|
if (label == NULL_TREE)
|
if (label == NULL_TREE)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* If we are jumping to a different function, we can't issue any
|
/* If we are jumping to a different function, we can't issue any
|
useful warnings. */
|
useful warnings. */
|
if (DECL_CONTEXT (label) != current_function_decl)
|
if (DECL_CONTEXT (label) != current_function_decl)
|
{
|
{
|
gcc_assert (C_DECLARED_LABEL_FLAG (label));
|
gcc_assert (C_DECLARED_LABEL_FLAG (label));
|
return label;
|
return label;
|
}
|
}
|
|
|
label_vars = I_LABEL_BINDING (name)->u.label;
|
label_vars = I_LABEL_BINDING (name)->u.label;
|
|
|
/* If the label has not yet been defined, then push this goto on a
|
/* If the label has not yet been defined, then push this goto on a
|
list for possible later warnings. */
|
list for possible later warnings. */
|
if (label_vars->label_bindings.scope == NULL)
|
if (label_vars->label_bindings.scope == NULL)
|
{
|
{
|
struct c_goto_bindings *g;
|
struct c_goto_bindings *g;
|
|
|
g = GGC_NEW (struct c_goto_bindings);
|
g = GGC_NEW (struct c_goto_bindings);
|
g->loc = loc;
|
g->loc = loc;
|
set_spot_bindings (&g->goto_bindings, true);
|
set_spot_bindings (&g->goto_bindings, true);
|
VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
|
VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
|
return label;
|
return label;
|
}
|
}
|
|
|
/* If there are any decls in label_vars->decls_in_scope, then this
|
/* If there are any decls in label_vars->decls_in_scope, then this
|
goto has missed the declaration of the decl. This happens for a
|
goto has missed the declaration of the decl. This happens for a
|
case like
|
case like
|
int i = 1;
|
int i = 1;
|
lab:
|
lab:
|
...
|
...
|
goto lab;
|
goto lab;
|
Issue a warning or error. */
|
Issue a warning or error. */
|
for (ix = 0; VEC_iterate (tree, label_vars->decls_in_scope, ix, decl); ++ix)
|
for (ix = 0; VEC_iterate (tree, label_vars->decls_in_scope, ix, decl); ++ix)
|
warn_about_goto (loc, label, decl);
|
warn_about_goto (loc, label, decl);
|
|
|
if (label_vars->label_bindings.left_stmt_expr)
|
if (label_vars->label_bindings.left_stmt_expr)
|
{
|
{
|
error_at (loc, "jump into statement expression");
|
error_at (loc, "jump into statement expression");
|
inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
|
inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
|
}
|
}
|
|
|
return label;
|
return label;
|
}
|
}
|
|
|
/* Make a label named NAME in the current function, shadowing silently
|
/* Make a label named NAME in the current function, shadowing silently
|
any that may be inherited from containing functions or containing
|
any that may be inherited from containing functions or containing
|
scopes. This is called for __label__ declarations. */
|
scopes. This is called for __label__ declarations. */
|
|
|
tree
|
tree
|
declare_label (tree name)
|
declare_label (tree name)
|
{
|
{
|
struct c_binding *b = I_LABEL_BINDING (name);
|
struct c_binding *b = I_LABEL_BINDING (name);
|
tree label;
|
tree label;
|
struct c_label_vars *label_vars;
|
struct c_label_vars *label_vars;
|
|
|
/* Check to make sure that the label hasn't already been declared
|
/* Check to make sure that the label hasn't already been declared
|
at this scope */
|
at this scope */
|
if (b && B_IN_CURRENT_SCOPE (b))
|
if (b && B_IN_CURRENT_SCOPE (b))
|
{
|
{
|
error ("duplicate label declaration %qE", name);
|
error ("duplicate label declaration %qE", name);
|
locate_old_decl (b->decl);
|
locate_old_decl (b->decl);
|
|
|
/* Just use the previous declaration. */
|
/* Just use the previous declaration. */
|
return b->decl;
|
return b->decl;
|
}
|
}
|
|
|
label = make_label (input_location, name, false, &label_vars);
|
label = make_label (input_location, name, false, &label_vars);
|
C_DECLARED_LABEL_FLAG (label) = 1;
|
C_DECLARED_LABEL_FLAG (label) = 1;
|
|
|
/* Declared labels go in the current scope. */
|
/* Declared labels go in the current scope. */
|
bind_label (name, label, current_scope, label_vars);
|
bind_label (name, label, current_scope, label_vars);
|
|
|
return label;
|
return label;
|
}
|
}
|
|
|
/* When we define a label, issue any appropriate warnings if there are
|
/* When we define a label, issue any appropriate warnings if there are
|
any gotos earlier in the function which jump to this label. */
|
any gotos earlier in the function which jump to this label. */
|
|
|
static void
|
static void
|
check_earlier_gotos (tree label, struct c_label_vars* label_vars)
|
check_earlier_gotos (tree label, struct c_label_vars* label_vars)
|
{
|
{
|
unsigned int ix;
|
unsigned int ix;
|
struct c_goto_bindings *g;
|
struct c_goto_bindings *g;
|
|
|
for (ix = 0;
|
for (ix = 0;
|
VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
|
VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
|
++ix)
|
++ix)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
struct c_scope *scope;
|
struct c_scope *scope;
|
|
|
/* We have a goto to this label. The goto is going forward. In
|
/* We have a goto to this label. The goto is going forward. In
|
g->scope, the goto is going to skip any binding which was
|
g->scope, the goto is going to skip any binding which was
|
defined after g->bindings_in_scope. */
|
defined after g->bindings_in_scope. */
|
for (b = g->goto_bindings.scope->bindings;
|
for (b = g->goto_bindings.scope->bindings;
|
b != g->goto_bindings.bindings_in_scope;
|
b != g->goto_bindings.bindings_in_scope;
|
b = b->prev)
|
b = b->prev)
|
{
|
{
|
if (decl_jump_unsafe (b->decl))
|
if (decl_jump_unsafe (b->decl))
|
warn_about_goto (g->loc, label, b->decl);
|
warn_about_goto (g->loc, label, b->decl);
|
}
|
}
|
|
|
/* We also need to warn about decls defined in any scopes
|
/* We also need to warn about decls defined in any scopes
|
between the scope of the label and the scope of the goto. */
|
between the scope of the label and the scope of the goto. */
|
for (scope = label_vars->label_bindings.scope;
|
for (scope = label_vars->label_bindings.scope;
|
scope != g->goto_bindings.scope;
|
scope != g->goto_bindings.scope;
|
scope = scope->outer)
|
scope = scope->outer)
|
{
|
{
|
gcc_assert (scope != NULL);
|
gcc_assert (scope != NULL);
|
if (scope == label_vars->label_bindings.scope)
|
if (scope == label_vars->label_bindings.scope)
|
b = label_vars->label_bindings.bindings_in_scope;
|
b = label_vars->label_bindings.bindings_in_scope;
|
else
|
else
|
b = scope->bindings;
|
b = scope->bindings;
|
for (; b != NULL; b = b->prev)
|
for (; b != NULL; b = b->prev)
|
{
|
{
|
if (decl_jump_unsafe (b->decl))
|
if (decl_jump_unsafe (b->decl))
|
warn_about_goto (g->loc, label, b->decl);
|
warn_about_goto (g->loc, label, b->decl);
|
}
|
}
|
}
|
}
|
|
|
if (g->goto_bindings.stmt_exprs > 0)
|
if (g->goto_bindings.stmt_exprs > 0)
|
{
|
{
|
error_at (g->loc, "jump into statement expression");
|
error_at (g->loc, "jump into statement expression");
|
inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
|
inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
|
label);
|
label);
|
}
|
}
|
}
|
}
|
|
|
/* Now that the label is defined, we will issue warnings about
|
/* Now that the label is defined, we will issue warnings about
|
subsequent gotos to this label when we see them. */
|
subsequent gotos to this label when we see them. */
|
VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
|
VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
|
label_vars->gotos = NULL;
|
label_vars->gotos = NULL;
|
}
|
}
|
|
|
/* Define a label, specifying the location in the source file.
|
/* Define a label, specifying the location in the source file.
|
Return the LABEL_DECL node for the label, if the definition is valid.
|
Return the LABEL_DECL node for the label, if the definition is valid.
|
Otherwise return 0. */
|
Otherwise return 0. */
|
|
|
tree
|
tree
|
define_label (location_t location, tree name)
|
define_label (location_t location, tree name)
|
{
|
{
|
/* Find any preexisting label with this name. It is an error
|
/* Find any preexisting label with this name. It is an error
|
if that label has already been defined in this function, or
|
if that label has already been defined in this function, or
|
if there is a containing function with a declared label with
|
if there is a containing function with a declared label with
|
the same name. */
|
the same name. */
|
tree label = I_LABEL_DECL (name);
|
tree label = I_LABEL_DECL (name);
|
|
|
if (label
|
if (label
|
&& ((DECL_CONTEXT (label) == current_function_decl
|
&& ((DECL_CONTEXT (label) == current_function_decl
|
&& DECL_INITIAL (label) != 0)
|
&& DECL_INITIAL (label) != 0)
|
|| (DECL_CONTEXT (label) != current_function_decl
|
|| (DECL_CONTEXT (label) != current_function_decl
|
&& C_DECLARED_LABEL_FLAG (label))))
|
&& C_DECLARED_LABEL_FLAG (label))))
|
{
|
{
|
error_at (location, "duplicate label %qD", label);
|
error_at (location, "duplicate label %qD", label);
|
locate_old_decl (label);
|
locate_old_decl (label);
|
return 0;
|
return 0;
|
}
|
}
|
else if (label && DECL_CONTEXT (label) == current_function_decl)
|
else if (label && DECL_CONTEXT (label) == current_function_decl)
|
{
|
{
|
struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
|
struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
|
|
|
/* The label has been used or declared already in this function,
|
/* The label has been used or declared already in this function,
|
but not defined. Update its location to point to this
|
but not defined. Update its location to point to this
|
definition. */
|
definition. */
|
DECL_SOURCE_LOCATION (label) = location;
|
DECL_SOURCE_LOCATION (label) = location;
|
set_spot_bindings (&label_vars->label_bindings, true);
|
set_spot_bindings (&label_vars->label_bindings, true);
|
|
|
/* Issue warnings as required about any goto statements from
|
/* Issue warnings as required about any goto statements from
|
earlier in the function. */
|
earlier in the function. */
|
check_earlier_gotos (label, label_vars);
|
check_earlier_gotos (label, label_vars);
|
}
|
}
|
else
|
else
|
{
|
{
|
struct c_label_vars *label_vars;
|
struct c_label_vars *label_vars;
|
|
|
/* No label binding for that identifier; make one. */
|
/* No label binding for that identifier; make one. */
|
label = make_label (location, name, true, &label_vars);
|
label = make_label (location, name, true, &label_vars);
|
|
|
/* Ordinary labels go in the current function scope. */
|
/* Ordinary labels go in the current function scope. */
|
bind_label (name, label, current_function_scope, label_vars);
|
bind_label (name, label, current_function_scope, label_vars);
|
}
|
}
|
|
|
if (!in_system_header && lookup_name (name))
|
if (!in_system_header && lookup_name (name))
|
warning_at (location, OPT_Wtraditional,
|
warning_at (location, OPT_Wtraditional,
|
"traditional C lacks a separate namespace "
|
"traditional C lacks a separate namespace "
|
"for labels, identifier %qE conflicts", name);
|
"for labels, identifier %qE conflicts", name);
|
|
|
/* Mark label as having been defined. */
|
/* Mark label as having been defined. */
|
DECL_INITIAL (label) = error_mark_node;
|
DECL_INITIAL (label) = error_mark_node;
|
return label;
|
return label;
|
}
|
}
|
|
|
/* Get the bindings for a new switch statement. This is used to issue
|
/* Get the bindings for a new switch statement. This is used to issue
|
warnings as appropriate for jumps from the switch to case or
|
warnings as appropriate for jumps from the switch to case or
|
default labels. */
|
default labels. */
|
|
|
struct c_spot_bindings *
|
struct c_spot_bindings *
|
c_get_switch_bindings (void)
|
c_get_switch_bindings (void)
|
{
|
{
|
struct c_spot_bindings *switch_bindings;
|
struct c_spot_bindings *switch_bindings;
|
|
|
switch_bindings = XNEW (struct c_spot_bindings);
|
switch_bindings = XNEW (struct c_spot_bindings);
|
set_spot_bindings (switch_bindings, true);
|
set_spot_bindings (switch_bindings, true);
|
return switch_bindings;
|
return switch_bindings;
|
}
|
}
|
|
|
void
|
void
|
c_release_switch_bindings (struct c_spot_bindings *bindings)
|
c_release_switch_bindings (struct c_spot_bindings *bindings)
|
{
|
{
|
gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
|
gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
|
XDELETE (bindings);
|
XDELETE (bindings);
|
}
|
}
|
|
|
/* This is called at the point of a case or default label to issue
|
/* This is called at the point of a case or default label to issue
|
warnings about decls as needed. It returns true if it found an
|
warnings about decls as needed. It returns true if it found an
|
error, not just a warning. */
|
error, not just a warning. */
|
|
|
bool
|
bool
|
c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
|
c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
|
location_t switch_loc, location_t case_loc)
|
location_t switch_loc, location_t case_loc)
|
{
|
{
|
bool saw_error;
|
bool saw_error;
|
struct c_scope *scope;
|
struct c_scope *scope;
|
|
|
saw_error = false;
|
saw_error = false;
|
for (scope = current_scope;
|
for (scope = current_scope;
|
scope != switch_bindings->scope;
|
scope != switch_bindings->scope;
|
scope = scope->outer)
|
scope = scope->outer)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
gcc_assert (scope != NULL);
|
gcc_assert (scope != NULL);
|
for (b = scope->bindings; b != NULL; b = b->prev)
|
for (b = scope->bindings; b != NULL; b = b->prev)
|
{
|
{
|
if (decl_jump_unsafe (b->decl))
|
if (decl_jump_unsafe (b->decl))
|
{
|
{
|
if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
|
if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
|
{
|
{
|
saw_error = true;
|
saw_error = true;
|
error_at (case_loc,
|
error_at (case_loc,
|
("switch jumps into scope of identifier with "
|
("switch jumps into scope of identifier with "
|
"variably modified type"));
|
"variably modified type"));
|
}
|
}
|
else
|
else
|
warning_at (case_loc, OPT_Wjump_misses_init,
|
warning_at (case_loc, OPT_Wjump_misses_init,
|
"switch jumps over variable initialization");
|
"switch jumps over variable initialization");
|
inform (switch_loc, "switch starts here");
|
inform (switch_loc, "switch starts here");
|
inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
|
inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
|
b->decl);
|
b->decl);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (switch_bindings->stmt_exprs > 0)
|
if (switch_bindings->stmt_exprs > 0)
|
{
|
{
|
saw_error = true;
|
saw_error = true;
|
error_at (case_loc, "switch jumps into statement expression");
|
error_at (case_loc, "switch jumps into statement expression");
|
inform (switch_loc, "switch starts here");
|
inform (switch_loc, "switch starts here");
|
}
|
}
|
|
|
return saw_error;
|
return saw_error;
|
}
|
}
|
|
|
/* Given NAME, an IDENTIFIER_NODE,
|
/* Given NAME, an IDENTIFIER_NODE,
|
return the structure (or union or enum) definition for that name.
|
return the structure (or union or enum) definition for that name.
|
If THISLEVEL_ONLY is nonzero, searches only the current_scope.
|
If THISLEVEL_ONLY is nonzero, searches only the current_scope.
|
CODE says which kind of type the caller wants;
|
CODE says which kind of type the caller wants;
|
it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
|
it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
|
If PLOC is not NULL and this returns non-null, it sets *PLOC to the
|
If PLOC is not NULL and this returns non-null, it sets *PLOC to the
|
location where the tag was defined.
|
location where the tag was defined.
|
If the wrong kind of type is found, an error is reported. */
|
If the wrong kind of type is found, an error is reported. */
|
|
|
static tree
|
static tree
|
lookup_tag (enum tree_code code, tree name, int thislevel_only,
|
lookup_tag (enum tree_code code, tree name, int thislevel_only,
|
location_t *ploc)
|
location_t *ploc)
|
{
|
{
|
struct c_binding *b = I_TAG_BINDING (name);
|
struct c_binding *b = I_TAG_BINDING (name);
|
int thislevel = 0;
|
int thislevel = 0;
|
|
|
if (!b || !b->decl)
|
if (!b || !b->decl)
|
return 0;
|
return 0;
|
|
|
/* We only care about whether it's in this level if
|
/* We only care about whether it's in this level if
|
thislevel_only was set or it might be a type clash. */
|
thislevel_only was set or it might be a type clash. */
|
if (thislevel_only || TREE_CODE (b->decl) != code)
|
if (thislevel_only || TREE_CODE (b->decl) != code)
|
{
|
{
|
/* For our purposes, a tag in the external scope is the same as
|
/* For our purposes, a tag in the external scope is the same as
|
a tag in the file scope. (Primarily relevant to Objective-C
|
a tag in the file scope. (Primarily relevant to Objective-C
|
and its builtin structure tags, which get pushed before the
|
and its builtin structure tags, which get pushed before the
|
file scope is created.) */
|
file scope is created.) */
|
if (B_IN_CURRENT_SCOPE (b)
|
if (B_IN_CURRENT_SCOPE (b)
|
|| (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
|
|| (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
|
thislevel = 1;
|
thislevel = 1;
|
}
|
}
|
|
|
if (thislevel_only && !thislevel)
|
if (thislevel_only && !thislevel)
|
return 0;
|
return 0;
|
|
|
if (TREE_CODE (b->decl) != code)
|
if (TREE_CODE (b->decl) != code)
|
{
|
{
|
/* Definition isn't the kind we were looking for. */
|
/* Definition isn't the kind we were looking for. */
|
pending_invalid_xref = name;
|
pending_invalid_xref = name;
|
pending_invalid_xref_location = input_location;
|
pending_invalid_xref_location = input_location;
|
|
|
/* If in the same binding level as a declaration as a tag
|
/* If in the same binding level as a declaration as a tag
|
of a different type, this must not be allowed to
|
of a different type, this must not be allowed to
|
shadow that tag, so give the error immediately.
|
shadow that tag, so give the error immediately.
|
(For example, "struct foo; union foo;" is invalid.) */
|
(For example, "struct foo; union foo;" is invalid.) */
|
if (thislevel)
|
if (thislevel)
|
pending_xref_error ();
|
pending_xref_error ();
|
}
|
}
|
|
|
if (ploc != NULL)
|
if (ploc != NULL)
|
*ploc = b->locus;
|
*ploc = b->locus;
|
|
|
return b->decl;
|
return b->decl;
|
}
|
}
|
|
|
/* Print an error message now
|
/* Print an error message now
|
for a recent invalid struct, union or enum cross reference.
|
for a recent invalid struct, union or enum cross reference.
|
We don't print them immediately because they are not invalid
|
We don't print them immediately because they are not invalid
|
when used in the `struct foo;' construct for shadowing. */
|
when used in the `struct foo;' construct for shadowing. */
|
|
|
void
|
void
|
pending_xref_error (void)
|
pending_xref_error (void)
|
{
|
{
|
if (pending_invalid_xref != 0)
|
if (pending_invalid_xref != 0)
|
error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
|
error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
|
pending_invalid_xref);
|
pending_invalid_xref);
|
pending_invalid_xref = 0;
|
pending_invalid_xref = 0;
|
}
|
}
|
|
|
|
|
/* Look up NAME in the current scope and its superiors
|
/* Look up NAME in the current scope and its superiors
|
in the namespace of variables, functions and typedefs.
|
in the namespace of variables, functions and typedefs.
|
Return a ..._DECL node of some kind representing its definition,
|
Return a ..._DECL node of some kind representing its definition,
|
or return 0 if it is undefined. */
|
or return 0 if it is undefined. */
|
|
|
tree
|
tree
|
lookup_name (tree name)
|
lookup_name (tree name)
|
{
|
{
|
struct c_binding *b = I_SYMBOL_BINDING (name);
|
struct c_binding *b = I_SYMBOL_BINDING (name);
|
if (b && !b->invisible)
|
if (b && !b->invisible)
|
return b->decl;
|
return b->decl;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Similar to `lookup_name' but look only at the indicated scope. */
|
/* Similar to `lookup_name' but look only at the indicated scope. */
|
|
|
static tree
|
static tree
|
lookup_name_in_scope (tree name, struct c_scope *scope)
|
lookup_name_in_scope (tree name, struct c_scope *scope)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
|
for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
|
if (B_IN_SCOPE (b, scope))
|
if (B_IN_SCOPE (b, scope))
|
return b->decl;
|
return b->decl;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Create the predefined scalar types of C,
|
/* Create the predefined scalar types of C,
|
and some nodes representing standard constants (0, 1, (void *) 0).
|
and some nodes representing standard constants (0, 1, (void *) 0).
|
Initialize the global scope.
|
Initialize the global scope.
|
Make definitions for built-in primitive functions. */
|
Make definitions for built-in primitive functions. */
|
|
|
void
|
void
|
c_init_decl_processing (void)
|
c_init_decl_processing (void)
|
{
|
{
|
location_t save_loc = input_location;
|
location_t save_loc = input_location;
|
|
|
/* Initialize reserved words for parser. */
|
/* Initialize reserved words for parser. */
|
c_parse_init ();
|
c_parse_init ();
|
|
|
current_function_decl = 0;
|
current_function_decl = 0;
|
|
|
gcc_obstack_init (&parser_obstack);
|
gcc_obstack_init (&parser_obstack);
|
|
|
/* Make the externals scope. */
|
/* Make the externals scope. */
|
push_scope ();
|
push_scope ();
|
external_scope = current_scope;
|
external_scope = current_scope;
|
|
|
/* Declarations from c_common_nodes_and_builtins must not be associated
|
/* Declarations from c_common_nodes_and_builtins must not be associated
|
with this input file, lest we get differences between using and not
|
with this input file, lest we get differences between using and not
|
using preprocessed headers. */
|
using preprocessed headers. */
|
input_location = BUILTINS_LOCATION;
|
input_location = BUILTINS_LOCATION;
|
|
|
build_common_tree_nodes (flag_signed_char, false);
|
build_common_tree_nodes (flag_signed_char, false);
|
|
|
c_common_nodes_and_builtins ();
|
c_common_nodes_and_builtins ();
|
|
|
/* In C, comparisons and TRUTH_* expressions have type int. */
|
/* In C, comparisons and TRUTH_* expressions have type int. */
|
truthvalue_type_node = integer_type_node;
|
truthvalue_type_node = integer_type_node;
|
truthvalue_true_node = integer_one_node;
|
truthvalue_true_node = integer_one_node;
|
truthvalue_false_node = integer_zero_node;
|
truthvalue_false_node = integer_zero_node;
|
|
|
/* Even in C99, which has a real boolean type. */
|
/* Even in C99, which has a real boolean type. */
|
pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
|
pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
|
boolean_type_node));
|
boolean_type_node));
|
|
|
input_location = save_loc;
|
input_location = save_loc;
|
|
|
pedantic_lvalues = true;
|
pedantic_lvalues = true;
|
|
|
make_fname_decl = c_make_fname_decl;
|
make_fname_decl = c_make_fname_decl;
|
start_fname_decls ();
|
start_fname_decls ();
|
}
|
}
|
|
|
/* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
|
/* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
|
give the decl, NAME is the initialization string and TYPE_DEP
|
give the decl, NAME is the initialization string and TYPE_DEP
|
indicates whether NAME depended on the type of the function. As we
|
indicates whether NAME depended on the type of the function. As we
|
don't yet implement delayed emission of static data, we mark the
|
don't yet implement delayed emission of static data, we mark the
|
decl as emitted so it is not placed in the output. Anything using
|
decl as emitted so it is not placed in the output. Anything using
|
it must therefore pull out the STRING_CST initializer directly.
|
it must therefore pull out the STRING_CST initializer directly.
|
FIXME. */
|
FIXME. */
|
|
|
static tree
|
static tree
|
c_make_fname_decl (location_t loc, tree id, int type_dep)
|
c_make_fname_decl (location_t loc, tree id, int type_dep)
|
{
|
{
|
const char *name = fname_as_string (type_dep);
|
const char *name = fname_as_string (type_dep);
|
tree decl, type, init;
|
tree decl, type, init;
|
size_t length = strlen (name);
|
size_t length = strlen (name);
|
|
|
type = build_array_type (char_type_node,
|
type = build_array_type (char_type_node,
|
build_index_type (size_int (length)));
|
build_index_type (size_int (length)));
|
type = c_build_qualified_type (type, TYPE_QUAL_CONST);
|
type = c_build_qualified_type (type, TYPE_QUAL_CONST);
|
|
|
decl = build_decl (loc, VAR_DECL, id, type);
|
decl = build_decl (loc, VAR_DECL, id, type);
|
|
|
TREE_STATIC (decl) = 1;
|
TREE_STATIC (decl) = 1;
|
TREE_READONLY (decl) = 1;
|
TREE_READONLY (decl) = 1;
|
DECL_ARTIFICIAL (decl) = 1;
|
DECL_ARTIFICIAL (decl) = 1;
|
|
|
init = build_string (length + 1, name);
|
init = build_string (length + 1, name);
|
free (CONST_CAST (char *, name));
|
free (CONST_CAST (char *, name));
|
TREE_TYPE (init) = type;
|
TREE_TYPE (init) = type;
|
DECL_INITIAL (decl) = init;
|
DECL_INITIAL (decl) = init;
|
|
|
TREE_USED (decl) = 1;
|
TREE_USED (decl) = 1;
|
|
|
if (current_function_decl
|
if (current_function_decl
|
/* For invalid programs like this:
|
/* For invalid programs like this:
|
|
|
void foo()
|
void foo()
|
const char* p = __FUNCTION__;
|
const char* p = __FUNCTION__;
|
|
|
the __FUNCTION__ is believed to appear in K&R style function
|
the __FUNCTION__ is believed to appear in K&R style function
|
parameter declarator. In that case we still don't have
|
parameter declarator. In that case we still don't have
|
function_scope. */
|
function_scope. */
|
&& (!errorcount || current_function_scope))
|
&& (!errorcount || current_function_scope))
|
{
|
{
|
DECL_CONTEXT (decl) = current_function_decl;
|
DECL_CONTEXT (decl) = current_function_decl;
|
bind (id, decl, current_function_scope,
|
bind (id, decl, current_function_scope,
|
/*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
|
/*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
|
}
|
}
|
|
|
finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
|
finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
|
|
|
return decl;
|
return decl;
|
}
|
}
|
|
|
tree
|
tree
|
c_builtin_function (tree decl)
|
c_builtin_function (tree decl)
|
{
|
{
|
tree type = TREE_TYPE (decl);
|
tree type = TREE_TYPE (decl);
|
tree id = DECL_NAME (decl);
|
tree id = DECL_NAME (decl);
|
|
|
const char *name = IDENTIFIER_POINTER (id);
|
const char *name = IDENTIFIER_POINTER (id);
|
C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
|
C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
|
|
|
/* Should never be called on a symbol with a preexisting meaning. */
|
/* Should never be called on a symbol with a preexisting meaning. */
|
gcc_assert (!I_SYMBOL_BINDING (id));
|
gcc_assert (!I_SYMBOL_BINDING (id));
|
|
|
bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
|
bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
|
UNKNOWN_LOCATION);
|
UNKNOWN_LOCATION);
|
|
|
/* Builtins in the implementation namespace are made visible without
|
/* Builtins in the implementation namespace are made visible without
|
needing to be explicitly declared. See push_file_scope. */
|
needing to be explicitly declared. See push_file_scope. */
|
if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
|
if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
|
{
|
{
|
TREE_CHAIN (decl) = visible_builtins;
|
TREE_CHAIN (decl) = visible_builtins;
|
visible_builtins = decl;
|
visible_builtins = decl;
|
}
|
}
|
|
|
return decl;
|
return decl;
|
}
|
}
|
|
|
tree
|
tree
|
c_builtin_function_ext_scope (tree decl)
|
c_builtin_function_ext_scope (tree decl)
|
{
|
{
|
tree type = TREE_TYPE (decl);
|
tree type = TREE_TYPE (decl);
|
tree id = DECL_NAME (decl);
|
tree id = DECL_NAME (decl);
|
|
|
const char *name = IDENTIFIER_POINTER (id);
|
const char *name = IDENTIFIER_POINTER (id);
|
C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
|
C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
|
|
|
/* Should never be called on a symbol with a preexisting meaning. */
|
/* Should never be called on a symbol with a preexisting meaning. */
|
gcc_assert (!I_SYMBOL_BINDING (id));
|
gcc_assert (!I_SYMBOL_BINDING (id));
|
|
|
bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
|
bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
|
UNKNOWN_LOCATION);
|
UNKNOWN_LOCATION);
|
|
|
/* Builtins in the implementation namespace are made visible without
|
/* Builtins in the implementation namespace are made visible without
|
needing to be explicitly declared. See push_file_scope. */
|
needing to be explicitly declared. See push_file_scope. */
|
if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
|
if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
|
{
|
{
|
TREE_CHAIN (decl) = visible_builtins;
|
TREE_CHAIN (decl) = visible_builtins;
|
visible_builtins = decl;
|
visible_builtins = decl;
|
}
|
}
|
|
|
return decl;
|
return decl;
|
}
|
}
|
|
|
/* Called when a declaration is seen that contains no names to declare.
|
/* Called when a declaration is seen that contains no names to declare.
|
If its type is a reference to a structure, union or enum inherited
|
If its type is a reference to a structure, union or enum inherited
|
from a containing scope, shadow that tag name for the current scope
|
from a containing scope, shadow that tag name for the current scope
|
with a forward reference.
|
with a forward reference.
|
If its type defines a new named structure or union
|
If its type defines a new named structure or union
|
or defines an enum, it is valid but we need not do anything here.
|
or defines an enum, it is valid but we need not do anything here.
|
Otherwise, it is an error. */
|
Otherwise, it is an error. */
|
|
|
void
|
void
|
shadow_tag (const struct c_declspecs *declspecs)
|
shadow_tag (const struct c_declspecs *declspecs)
|
{
|
{
|
shadow_tag_warned (declspecs, 0);
|
shadow_tag_warned (declspecs, 0);
|
}
|
}
|
|
|
/* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
|
/* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
|
but no pedwarn. */
|
but no pedwarn. */
|
void
|
void
|
shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
|
shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
|
{
|
{
|
bool found_tag = false;
|
bool found_tag = false;
|
|
|
if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
|
if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
|
{
|
{
|
tree value = declspecs->type;
|
tree value = declspecs->type;
|
enum tree_code code = TREE_CODE (value);
|
enum tree_code code = TREE_CODE (value);
|
|
|
if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
|
if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
|
/* Used to test also that TYPE_SIZE (value) != 0.
|
/* Used to test also that TYPE_SIZE (value) != 0.
|
That caused warning for `struct foo;' at top level in the file. */
|
That caused warning for `struct foo;' at top level in the file. */
|
{
|
{
|
tree name = TYPE_NAME (value);
|
tree name = TYPE_NAME (value);
|
tree t;
|
tree t;
|
|
|
found_tag = true;
|
found_tag = true;
|
|
|
if (declspecs->restrict_p)
|
if (declspecs->restrict_p)
|
{
|
{
|
error ("invalid use of %<restrict%>");
|
error ("invalid use of %<restrict%>");
|
warned = 1;
|
warned = 1;
|
}
|
}
|
|
|
if (name == 0)
|
if (name == 0)
|
{
|
{
|
if (warned != 1 && code != ENUMERAL_TYPE)
|
if (warned != 1 && code != ENUMERAL_TYPE)
|
/* Empty unnamed enum OK */
|
/* Empty unnamed enum OK */
|
{
|
{
|
pedwarn (input_location, 0,
|
pedwarn (input_location, 0,
|
"unnamed struct/union that defines no instances");
|
"unnamed struct/union that defines no instances");
|
warned = 1;
|
warned = 1;
|
}
|
}
|
}
|
}
|
else if (!declspecs->tag_defined_p
|
else if (!declspecs->tag_defined_p
|
&& declspecs->storage_class != csc_none)
|
&& declspecs->storage_class != csc_none)
|
{
|
{
|
if (warned != 1)
|
if (warned != 1)
|
pedwarn (input_location, 0,
|
pedwarn (input_location, 0,
|
"empty declaration with storage class specifier "
|
"empty declaration with storage class specifier "
|
"does not redeclare tag");
|
"does not redeclare tag");
|
warned = 1;
|
warned = 1;
|
pending_xref_error ();
|
pending_xref_error ();
|
}
|
}
|
else if (!declspecs->tag_defined_p
|
else if (!declspecs->tag_defined_p
|
&& (declspecs->const_p
|
&& (declspecs->const_p
|
|| declspecs->volatile_p
|
|| declspecs->volatile_p
|
|| declspecs->restrict_p
|
|| declspecs->restrict_p
|
|| declspecs->address_space))
|
|| declspecs->address_space))
|
{
|
{
|
if (warned != 1)
|
if (warned != 1)
|
pedwarn (input_location, 0,
|
pedwarn (input_location, 0,
|
"empty declaration with type qualifier "
|
"empty declaration with type qualifier "
|
"does not redeclare tag");
|
"does not redeclare tag");
|
warned = 1;
|
warned = 1;
|
pending_xref_error ();
|
pending_xref_error ();
|
}
|
}
|
else
|
else
|
{
|
{
|
pending_invalid_xref = 0;
|
pending_invalid_xref = 0;
|
t = lookup_tag (code, name, 1, NULL);
|
t = lookup_tag (code, name, 1, NULL);
|
|
|
if (t == 0)
|
if (t == 0)
|
{
|
{
|
t = make_node (code);
|
t = make_node (code);
|
pushtag (input_location, name, t);
|
pushtag (input_location, name, t);
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (warned != 1 && !in_system_header)
|
if (warned != 1 && !in_system_header)
|
{
|
{
|
pedwarn (input_location, 0,
|
pedwarn (input_location, 0,
|
"useless type name in empty declaration");
|
"useless type name in empty declaration");
|
warned = 1;
|
warned = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (warned != 1 && !in_system_header && declspecs->typedef_p)
|
else if (warned != 1 && !in_system_header && declspecs->typedef_p)
|
{
|
{
|
pedwarn (input_location, 0, "useless type name in empty declaration");
|
pedwarn (input_location, 0, "useless type name in empty declaration");
|
warned = 1;
|
warned = 1;
|
}
|
}
|
|
|
pending_invalid_xref = 0;
|
pending_invalid_xref = 0;
|
|
|
if (declspecs->inline_p)
|
if (declspecs->inline_p)
|
{
|
{
|
error ("%<inline%> in empty declaration");
|
error ("%<inline%> in empty declaration");
|
warned = 1;
|
warned = 1;
|
}
|
}
|
|
|
if (current_scope == file_scope && declspecs->storage_class == csc_auto)
|
if (current_scope == file_scope && declspecs->storage_class == csc_auto)
|
{
|
{
|
error ("%<auto%> in file-scope empty declaration");
|
error ("%<auto%> in file-scope empty declaration");
|
warned = 1;
|
warned = 1;
|
}
|
}
|
|
|
if (current_scope == file_scope && declspecs->storage_class == csc_register)
|
if (current_scope == file_scope && declspecs->storage_class == csc_register)
|
{
|
{
|
error ("%<register%> in file-scope empty declaration");
|
error ("%<register%> in file-scope empty declaration");
|
warned = 1;
|
warned = 1;
|
}
|
}
|
|
|
if (!warned && !in_system_header && declspecs->storage_class != csc_none)
|
if (!warned && !in_system_header && declspecs->storage_class != csc_none)
|
{
|
{
|
warning (0, "useless storage class specifier in empty declaration");
|
warning (0, "useless storage class specifier in empty declaration");
|
warned = 2;
|
warned = 2;
|
}
|
}
|
|
|
if (!warned && !in_system_header && declspecs->thread_p)
|
if (!warned && !in_system_header && declspecs->thread_p)
|
{
|
{
|
warning (0, "useless %<__thread%> in empty declaration");
|
warning (0, "useless %<__thread%> in empty declaration");
|
warned = 2;
|
warned = 2;
|
}
|
}
|
|
|
if (!warned && !in_system_header && (declspecs->const_p
|
if (!warned && !in_system_header && (declspecs->const_p
|
|| declspecs->volatile_p
|
|| declspecs->volatile_p
|
|| declspecs->restrict_p
|
|| declspecs->restrict_p
|
|| declspecs->address_space))
|
|| declspecs->address_space))
|
{
|
{
|
warning (0, "useless type qualifier in empty declaration");
|
warning (0, "useless type qualifier in empty declaration");
|
warned = 2;
|
warned = 2;
|
}
|
}
|
|
|
if (warned != 1)
|
if (warned != 1)
|
{
|
{
|
if (!found_tag)
|
if (!found_tag)
|
pedwarn (input_location, 0, "empty declaration");
|
pedwarn (input_location, 0, "empty declaration");
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
|
/* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
|
bits. SPECS represents declaration specifiers that the grammar
|
bits. SPECS represents declaration specifiers that the grammar
|
only permits to contain type qualifiers and attributes. */
|
only permits to contain type qualifiers and attributes. */
|
|
|
int
|
int
|
quals_from_declspecs (const struct c_declspecs *specs)
|
quals_from_declspecs (const struct c_declspecs *specs)
|
{
|
{
|
int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
|
int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
|
| (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
|
| (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
|
| (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0)
|
| (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0)
|
| (ENCODE_QUAL_ADDR_SPACE (specs->address_space)));
|
| (ENCODE_QUAL_ADDR_SPACE (specs->address_space)));
|
gcc_assert (!specs->type
|
gcc_assert (!specs->type
|
&& !specs->decl_attr
|
&& !specs->decl_attr
|
&& specs->typespec_word == cts_none
|
&& specs->typespec_word == cts_none
|
&& specs->storage_class == csc_none
|
&& specs->storage_class == csc_none
|
&& !specs->typedef_p
|
&& !specs->typedef_p
|
&& !specs->explicit_signed_p
|
&& !specs->explicit_signed_p
|
&& !specs->deprecated_p
|
&& !specs->deprecated_p
|
&& !specs->long_p
|
&& !specs->long_p
|
&& !specs->long_long_p
|
&& !specs->long_long_p
|
&& !specs->short_p
|
&& !specs->short_p
|
&& !specs->signed_p
|
&& !specs->signed_p
|
&& !specs->unsigned_p
|
&& !specs->unsigned_p
|
&& !specs->complex_p
|
&& !specs->complex_p
|
&& !specs->inline_p
|
&& !specs->inline_p
|
&& !specs->thread_p);
|
&& !specs->thread_p);
|
return quals;
|
return quals;
|
}
|
}
|
|
|
/* Construct an array declarator. LOC is the location of the
|
/* Construct an array declarator. LOC is the location of the
|
beginning of the array (usually the opening brace). EXPR is the
|
beginning of the array (usually the opening brace). EXPR is the
|
expression inside [], or NULL_TREE. QUALS are the type qualifiers
|
expression inside [], or NULL_TREE. QUALS are the type qualifiers
|
inside the [] (to be applied to the pointer to which a parameter
|
inside the [] (to be applied to the pointer to which a parameter
|
array is converted). STATIC_P is true if "static" is inside the
|
array is converted). STATIC_P is true if "static" is inside the
|
[], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
|
[], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
|
VLA of unspecified length which is nevertheless a complete type,
|
VLA of unspecified length which is nevertheless a complete type,
|
false otherwise. The field for the contained declarator is left to
|
false otherwise. The field for the contained declarator is left to
|
be filled in by set_array_declarator_inner. */
|
be filled in by set_array_declarator_inner. */
|
|
|
struct c_declarator *
|
struct c_declarator *
|
build_array_declarator (location_t loc,
|
build_array_declarator (location_t loc,
|
tree expr, struct c_declspecs *quals, bool static_p,
|
tree expr, struct c_declspecs *quals, bool static_p,
|
bool vla_unspec_p)
|
bool vla_unspec_p)
|
{
|
{
|
struct c_declarator *declarator = XOBNEW (&parser_obstack,
|
struct c_declarator *declarator = XOBNEW (&parser_obstack,
|
struct c_declarator);
|
struct c_declarator);
|
declarator->id_loc = loc;
|
declarator->id_loc = loc;
|
declarator->kind = cdk_array;
|
declarator->kind = cdk_array;
|
declarator->declarator = 0;
|
declarator->declarator = 0;
|
declarator->u.array.dimen = expr;
|
declarator->u.array.dimen = expr;
|
if (quals)
|
if (quals)
|
{
|
{
|
declarator->u.array.attrs = quals->attrs;
|
declarator->u.array.attrs = quals->attrs;
|
declarator->u.array.quals = quals_from_declspecs (quals);
|
declarator->u.array.quals = quals_from_declspecs (quals);
|
}
|
}
|
else
|
else
|
{
|
{
|
declarator->u.array.attrs = NULL_TREE;
|
declarator->u.array.attrs = NULL_TREE;
|
declarator->u.array.quals = 0;
|
declarator->u.array.quals = 0;
|
}
|
}
|
declarator->u.array.static_p = static_p;
|
declarator->u.array.static_p = static_p;
|
declarator->u.array.vla_unspec_p = vla_unspec_p;
|
declarator->u.array.vla_unspec_p = vla_unspec_p;
|
if (!flag_isoc99)
|
if (!flag_isoc99)
|
{
|
{
|
if (static_p || quals != NULL)
|
if (static_p || quals != NULL)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C90 does not support %<static%> or type "
|
"ISO C90 does not support %<static%> or type "
|
"qualifiers in parameter array declarators");
|
"qualifiers in parameter array declarators");
|
if (vla_unspec_p)
|
if (vla_unspec_p)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C90 does not support %<[*]%> array declarators");
|
"ISO C90 does not support %<[*]%> array declarators");
|
}
|
}
|
if (vla_unspec_p)
|
if (vla_unspec_p)
|
{
|
{
|
if (!current_scope->parm_flag)
|
if (!current_scope->parm_flag)
|
{
|
{
|
/* C99 6.7.5.2p4 */
|
/* C99 6.7.5.2p4 */
|
error_at (loc, "%<[*]%> not allowed in other than "
|
error_at (loc, "%<[*]%> not allowed in other than "
|
"function prototype scope");
|
"function prototype scope");
|
declarator->u.array.vla_unspec_p = false;
|
declarator->u.array.vla_unspec_p = false;
|
return NULL;
|
return NULL;
|
}
|
}
|
current_scope->had_vla_unspec = true;
|
current_scope->had_vla_unspec = true;
|
}
|
}
|
return declarator;
|
return declarator;
|
}
|
}
|
|
|
/* Set the contained declarator of an array declarator. DECL is the
|
/* Set the contained declarator of an array declarator. DECL is the
|
declarator, as constructed by build_array_declarator; INNER is what
|
declarator, as constructed by build_array_declarator; INNER is what
|
appears on the left of the []. */
|
appears on the left of the []. */
|
|
|
struct c_declarator *
|
struct c_declarator *
|
set_array_declarator_inner (struct c_declarator *decl,
|
set_array_declarator_inner (struct c_declarator *decl,
|
struct c_declarator *inner)
|
struct c_declarator *inner)
|
{
|
{
|
decl->declarator = inner;
|
decl->declarator = inner;
|
return decl;
|
return decl;
|
}
|
}
|
|
|
/* INIT is a constructor that forms DECL's initializer. If the final
|
/* INIT is a constructor that forms DECL's initializer. If the final
|
element initializes a flexible array field, add the size of that
|
element initializes a flexible array field, add the size of that
|
initializer to DECL's size. */
|
initializer to DECL's size. */
|
|
|
static void
|
static void
|
add_flexible_array_elts_to_size (tree decl, tree init)
|
add_flexible_array_elts_to_size (tree decl, tree init)
|
{
|
{
|
tree elt, type;
|
tree elt, type;
|
|
|
if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
|
if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
|
return;
|
return;
|
|
|
elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
|
elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
|
type = TREE_TYPE (elt);
|
type = TREE_TYPE (elt);
|
if (TREE_CODE (type) == ARRAY_TYPE
|
if (TREE_CODE (type) == ARRAY_TYPE
|
&& TYPE_SIZE (type) == NULL_TREE
|
&& TYPE_SIZE (type) == NULL_TREE
|
&& TYPE_DOMAIN (type) != NULL_TREE
|
&& TYPE_DOMAIN (type) != NULL_TREE
|
&& TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
|
&& TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
|
{
|
{
|
complete_array_type (&type, elt, false);
|
complete_array_type (&type, elt, false);
|
DECL_SIZE (decl)
|
DECL_SIZE (decl)
|
= size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
|
= size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
|
DECL_SIZE_UNIT (decl)
|
DECL_SIZE_UNIT (decl)
|
= size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
|
= size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
|
}
|
}
|
}
|
}
|
|
|
/* Decode a "typename", such as "int **", returning a ..._TYPE node.
|
/* Decode a "typename", such as "int **", returning a ..._TYPE node.
|
Set *EXPR, if EXPR not NULL, to any expression to be evaluated
|
Set *EXPR, if EXPR not NULL, to any expression to be evaluated
|
before the type name, and set *EXPR_CONST_OPERANDS, if
|
before the type name, and set *EXPR_CONST_OPERANDS, if
|
EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
|
EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
|
appear in a constant expression. */
|
appear in a constant expression. */
|
|
|
tree
|
tree
|
groktypename (struct c_type_name *type_name, tree *expr,
|
groktypename (struct c_type_name *type_name, tree *expr,
|
bool *expr_const_operands)
|
bool *expr_const_operands)
|
{
|
{
|
tree type;
|
tree type;
|
tree attrs = type_name->specs->attrs;
|
tree attrs = type_name->specs->attrs;
|
|
|
type_name->specs->attrs = NULL_TREE;
|
type_name->specs->attrs = NULL_TREE;
|
|
|
type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
|
type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
|
false, NULL, &attrs, expr, expr_const_operands,
|
false, NULL, &attrs, expr, expr_const_operands,
|
DEPRECATED_NORMAL);
|
DEPRECATED_NORMAL);
|
|
|
/* Apply attributes. */
|
/* Apply attributes. */
|
decl_attributes (&type, attrs, 0);
|
decl_attributes (&type, attrs, 0);
|
|
|
return type;
|
return type;
|
}
|
}
|
|
|
/* Decode a declarator in an ordinary declaration or data definition.
|
/* Decode a declarator in an ordinary declaration or data definition.
|
This is called as soon as the type information and variable name
|
This is called as soon as the type information and variable name
|
have been parsed, before parsing the initializer if any.
|
have been parsed, before parsing the initializer if any.
|
Here we create the ..._DECL node, fill in its type,
|
Here we create the ..._DECL node, fill in its type,
|
and put it on the list of decls for the current context.
|
and put it on the list of decls for the current context.
|
The ..._DECL node is returned as the value.
|
The ..._DECL node is returned as the value.
|
|
|
Exception: for arrays where the length is not specified,
|
Exception: for arrays where the length is not specified,
|
the type is left null, to be filled in by `finish_decl'.
|
the type is left null, to be filled in by `finish_decl'.
|
|
|
Function definitions do not come here; they go to start_function
|
Function definitions do not come here; they go to start_function
|
instead. However, external and forward declarations of functions
|
instead. However, external and forward declarations of functions
|
do go through here. Structure field declarations are done by
|
do go through here. Structure field declarations are done by
|
grokfield and not through here. */
|
grokfield and not through here. */
|
|
|
tree
|
tree
|
start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
|
start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
|
bool initialized, tree attributes)
|
bool initialized, tree attributes)
|
{
|
{
|
tree decl;
|
tree decl;
|
tree tem;
|
tree tem;
|
tree expr = NULL_TREE;
|
tree expr = NULL_TREE;
|
enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
|
enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
|
|
|
/* An object declared as __attribute__((deprecated)) suppresses
|
/* An object declared as __attribute__((deprecated)) suppresses
|
warnings of uses of other deprecated items. */
|
warnings of uses of other deprecated items. */
|
if (lookup_attribute ("deprecated", attributes))
|
if (lookup_attribute ("deprecated", attributes))
|
deprecated_state = DEPRECATED_SUPPRESS;
|
deprecated_state = DEPRECATED_SUPPRESS;
|
|
|
decl = grokdeclarator (declarator, declspecs,
|
decl = grokdeclarator (declarator, declspecs,
|
NORMAL, initialized, NULL, &attributes, &expr, NULL,
|
NORMAL, initialized, NULL, &attributes, &expr, NULL,
|
deprecated_state);
|
deprecated_state);
|
if (!decl)
|
if (!decl)
|
return 0;
|
return 0;
|
|
|
if (expr)
|
if (expr)
|
add_stmt (expr);
|
add_stmt (expr);
|
|
|
if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl)))
|
if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl)))
|
warning (OPT_Wmain, "%q+D is usually a function", decl);
|
warning (OPT_Wmain, "%q+D is usually a function", decl);
|
|
|
if (initialized)
|
if (initialized)
|
/* Is it valid for this decl to have an initializer at all?
|
/* Is it valid for this decl to have an initializer at all?
|
If not, set INITIALIZED to zero, which will indirectly
|
If not, set INITIALIZED to zero, which will indirectly
|
tell 'finish_decl' to ignore the initializer once it is parsed. */
|
tell 'finish_decl' to ignore the initializer once it is parsed. */
|
switch (TREE_CODE (decl))
|
switch (TREE_CODE (decl))
|
{
|
{
|
case TYPE_DECL:
|
case TYPE_DECL:
|
error ("typedef %qD is initialized (use __typeof__ instead)", decl);
|
error ("typedef %qD is initialized (use __typeof__ instead)", decl);
|
initialized = 0;
|
initialized = 0;
|
break;
|
break;
|
|
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
error ("function %qD is initialized like a variable", decl);
|
error ("function %qD is initialized like a variable", decl);
|
initialized = 0;
|
initialized = 0;
|
break;
|
break;
|
|
|
case PARM_DECL:
|
case PARM_DECL:
|
/* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
|
/* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
|
error ("parameter %qD is initialized", decl);
|
error ("parameter %qD is initialized", decl);
|
initialized = 0;
|
initialized = 0;
|
break;
|
break;
|
|
|
default:
|
default:
|
/* Don't allow initializations for incomplete types except for
|
/* Don't allow initializations for incomplete types except for
|
arrays which might be completed by the initialization. */
|
arrays which might be completed by the initialization. */
|
|
|
/* This can happen if the array size is an undefined macro.
|
/* This can happen if the array size is an undefined macro.
|
We already gave a warning, so we don't need another one. */
|
We already gave a warning, so we don't need another one. */
|
if (TREE_TYPE (decl) == error_mark_node)
|
if (TREE_TYPE (decl) == error_mark_node)
|
initialized = 0;
|
initialized = 0;
|
else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
|
else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
|
{
|
{
|
/* A complete type is ok if size is fixed. */
|
/* A complete type is ok if size is fixed. */
|
|
|
if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
|
if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
|
|| C_DECL_VARIABLE_SIZE (decl))
|
|| C_DECL_VARIABLE_SIZE (decl))
|
{
|
{
|
error ("variable-sized object may not be initialized");
|
error ("variable-sized object may not be initialized");
|
initialized = 0;
|
initialized = 0;
|
}
|
}
|
}
|
}
|
else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
|
else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
|
{
|
{
|
error ("variable %qD has initializer but incomplete type", decl);
|
error ("variable %qD has initializer but incomplete type", decl);
|
initialized = 0;
|
initialized = 0;
|
}
|
}
|
else if (C_DECL_VARIABLE_SIZE (decl))
|
else if (C_DECL_VARIABLE_SIZE (decl))
|
{
|
{
|
/* Although C99 is unclear about whether incomplete arrays
|
/* Although C99 is unclear about whether incomplete arrays
|
of VLAs themselves count as VLAs, it does not make
|
of VLAs themselves count as VLAs, it does not make
|
sense to permit them to be initialized given that
|
sense to permit them to be initialized given that
|
ordinary VLAs may not be initialized. */
|
ordinary VLAs may not be initialized. */
|
error ("variable-sized object may not be initialized");
|
error ("variable-sized object may not be initialized");
|
initialized = 0;
|
initialized = 0;
|
}
|
}
|
}
|
}
|
|
|
if (initialized)
|
if (initialized)
|
{
|
{
|
if (current_scope == file_scope)
|
if (current_scope == file_scope)
|
TREE_STATIC (decl) = 1;
|
TREE_STATIC (decl) = 1;
|
|
|
/* Tell 'pushdecl' this is an initialized decl
|
/* Tell 'pushdecl' this is an initialized decl
|
even though we don't yet have the initializer expression.
|
even though we don't yet have the initializer expression.
|
Also tell 'finish_decl' it may store the real initializer. */
|
Also tell 'finish_decl' it may store the real initializer. */
|
DECL_INITIAL (decl) = error_mark_node;
|
DECL_INITIAL (decl) = error_mark_node;
|
}
|
}
|
|
|
/* If this is a function declaration, write a record describing it to the
|
/* If this is a function declaration, write a record describing it to the
|
prototypes file (if requested). */
|
prototypes file (if requested). */
|
|
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
|
gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
|
|
|
/* ANSI specifies that a tentative definition which is not merged with
|
/* ANSI specifies that a tentative definition which is not merged with
|
a non-tentative definition behaves exactly like a definition with an
|
a non-tentative definition behaves exactly like a definition with an
|
initializer equal to zero. (Section 3.7.2)
|
initializer equal to zero. (Section 3.7.2)
|
|
|
-fno-common gives strict ANSI behavior, though this tends to break
|
-fno-common gives strict ANSI behavior, though this tends to break
|
a large body of code that grew up without this rule.
|
a large body of code that grew up without this rule.
|
|
|
Thread-local variables are never common, since there's no entrenched
|
Thread-local variables are never common, since there's no entrenched
|
body of code to break, and it allows more efficient variable references
|
body of code to break, and it allows more efficient variable references
|
in the presence of dynamic linking. */
|
in the presence of dynamic linking. */
|
|
|
if (TREE_CODE (decl) == VAR_DECL
|
if (TREE_CODE (decl) == VAR_DECL
|
&& !initialized
|
&& !initialized
|
&& TREE_PUBLIC (decl)
|
&& TREE_PUBLIC (decl)
|
&& !DECL_THREAD_LOCAL_P (decl)
|
&& !DECL_THREAD_LOCAL_P (decl)
|
&& !flag_no_common)
|
&& !flag_no_common)
|
DECL_COMMON (decl) = 1;
|
DECL_COMMON (decl) = 1;
|
|
|
/* Set attributes here so if duplicate decl, will have proper attributes. */
|
/* Set attributes here so if duplicate decl, will have proper attributes. */
|
decl_attributes (&decl, attributes, 0);
|
decl_attributes (&decl, attributes, 0);
|
|
|
/* Handle gnu_inline attribute. */
|
/* Handle gnu_inline attribute. */
|
if (declspecs->inline_p
|
if (declspecs->inline_p
|
&& !flag_gnu89_inline
|
&& !flag_gnu89_inline
|
&& TREE_CODE (decl) == FUNCTION_DECL
|
&& TREE_CODE (decl) == FUNCTION_DECL
|
&& (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl))
|
&& (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl))
|
|| current_function_decl))
|
|| current_function_decl))
|
{
|
{
|
if (declspecs->storage_class == csc_auto && current_scope != file_scope)
|
if (declspecs->storage_class == csc_auto && current_scope != file_scope)
|
;
|
;
|
else if (declspecs->storage_class != csc_static)
|
else if (declspecs->storage_class != csc_static)
|
DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
|
DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
|
}
|
}
|
|
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
&& targetm.calls.promote_prototypes (TREE_TYPE (decl)))
|
&& targetm.calls.promote_prototypes (TREE_TYPE (decl)))
|
{
|
{
|
struct c_declarator *ce = declarator;
|
struct c_declarator *ce = declarator;
|
|
|
if (ce->kind == cdk_pointer)
|
if (ce->kind == cdk_pointer)
|
ce = declarator->declarator;
|
ce = declarator->declarator;
|
if (ce->kind == cdk_function)
|
if (ce->kind == cdk_function)
|
{
|
{
|
tree args = ce->u.arg_info->parms;
|
tree args = ce->u.arg_info->parms;
|
for (; args; args = TREE_CHAIN (args))
|
for (; args; args = TREE_CHAIN (args))
|
{
|
{
|
tree type = TREE_TYPE (args);
|
tree type = TREE_TYPE (args);
|
if (type && INTEGRAL_TYPE_P (type)
|
if (type && INTEGRAL_TYPE_P (type)
|
&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
|
&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
|
DECL_ARG_TYPE (args) = integer_type_node;
|
DECL_ARG_TYPE (args) = integer_type_node;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
&& DECL_DECLARED_INLINE_P (decl)
|
&& DECL_DECLARED_INLINE_P (decl)
|
&& DECL_UNINLINABLE (decl)
|
&& DECL_UNINLINABLE (decl)
|
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
|
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
|
warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
|
warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
|
decl);
|
decl);
|
|
|
/* C99 6.7.4p3: An inline definition of a function with external
|
/* C99 6.7.4p3: An inline definition of a function with external
|
linkage shall not contain a definition of a modifiable object
|
linkage shall not contain a definition of a modifiable object
|
with static storage duration... */
|
with static storage duration... */
|
if (TREE_CODE (decl) == VAR_DECL
|
if (TREE_CODE (decl) == VAR_DECL
|
&& current_scope != file_scope
|
&& current_scope != file_scope
|
&& TREE_STATIC (decl)
|
&& TREE_STATIC (decl)
|
&& !TREE_READONLY (decl)
|
&& !TREE_READONLY (decl)
|
&& DECL_DECLARED_INLINE_P (current_function_decl)
|
&& DECL_DECLARED_INLINE_P (current_function_decl)
|
&& DECL_EXTERNAL (current_function_decl))
|
&& DECL_EXTERNAL (current_function_decl))
|
record_inline_static (input_location, current_function_decl,
|
record_inline_static (input_location, current_function_decl,
|
decl, csi_modifiable);
|
decl, csi_modifiable);
|
|
|
/* Add this decl to the current scope.
|
/* Add this decl to the current scope.
|
TEM may equal DECL or it may be a previous decl of the same name. */
|
TEM may equal DECL or it may be a previous decl of the same name. */
|
tem = pushdecl (decl);
|
tem = pushdecl (decl);
|
|
|
if (initialized && DECL_EXTERNAL (tem))
|
if (initialized && DECL_EXTERNAL (tem))
|
{
|
{
|
DECL_EXTERNAL (tem) = 0;
|
DECL_EXTERNAL (tem) = 0;
|
TREE_STATIC (tem) = 1;
|
TREE_STATIC (tem) = 1;
|
}
|
}
|
|
|
return tem;
|
return tem;
|
}
|
}
|
|
|
/* Finish processing of a declaration;
|
/* Finish processing of a declaration;
|
install its initial value.
|
install its initial value.
|
If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
|
If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
|
If the length of an array type is not known before,
|
If the length of an array type is not known before,
|
it must be determined now, from the initial value, or it is an error.
|
it must be determined now, from the initial value, or it is an error.
|
|
|
INIT_LOC is the location of the initial value. */
|
INIT_LOC is the location of the initial value. */
|
|
|
void
|
void
|
finish_decl (tree decl, location_t init_loc, tree init,
|
finish_decl (tree decl, location_t init_loc, tree init,
|
tree origtype, tree asmspec_tree)
|
tree origtype, tree asmspec_tree)
|
{
|
{
|
tree type;
|
tree type;
|
bool was_incomplete = (DECL_SIZE (decl) == 0);
|
bool was_incomplete = (DECL_SIZE (decl) == 0);
|
const char *asmspec = 0;
|
const char *asmspec = 0;
|
|
|
/* If a name was specified, get the string. */
|
/* If a name was specified, get the string. */
|
if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
|
if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
|
&& DECL_FILE_SCOPE_P (decl))
|
&& DECL_FILE_SCOPE_P (decl))
|
asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
|
asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
|
if (asmspec_tree)
|
if (asmspec_tree)
|
asmspec = TREE_STRING_POINTER (asmspec_tree);
|
asmspec = TREE_STRING_POINTER (asmspec_tree);
|
|
|
if (TREE_CODE (decl) == VAR_DECL
|
if (TREE_CODE (decl) == VAR_DECL
|
&& TREE_STATIC (decl)
|
&& TREE_STATIC (decl)
|
&& global_bindings_p ())
|
&& global_bindings_p ())
|
/* So decl is a global variable. Record the types it uses
|
/* So decl is a global variable. Record the types it uses
|
so that we can decide later to emit debug info for them. */
|
so that we can decide later to emit debug info for them. */
|
record_types_used_by_current_var_decl (decl);
|
record_types_used_by_current_var_decl (decl);
|
|
|
/* If `start_decl' didn't like having an initialization, ignore it now. */
|
/* If `start_decl' didn't like having an initialization, ignore it now. */
|
if (init != 0 && DECL_INITIAL (decl) == 0)
|
if (init != 0 && DECL_INITIAL (decl) == 0)
|
init = 0;
|
init = 0;
|
|
|
/* Don't crash if parm is initialized. */
|
/* Don't crash if parm is initialized. */
|
if (TREE_CODE (decl) == PARM_DECL)
|
if (TREE_CODE (decl) == PARM_DECL)
|
init = 0;
|
init = 0;
|
|
|
if (init)
|
if (init)
|
store_init_value (init_loc, decl, init, origtype);
|
store_init_value (init_loc, decl, init, origtype);
|
|
|
if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
|
if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
|
|| TREE_CODE (decl) == FUNCTION_DECL
|
|| TREE_CODE (decl) == FUNCTION_DECL
|
|| TREE_CODE (decl) == FIELD_DECL))
|
|| TREE_CODE (decl) == FIELD_DECL))
|
objc_check_decl (decl);
|
objc_check_decl (decl);
|
|
|
type = TREE_TYPE (decl);
|
type = TREE_TYPE (decl);
|
|
|
/* Deduce size of array from initialization, if not already known. */
|
/* Deduce size of array from initialization, if not already known. */
|
if (TREE_CODE (type) == ARRAY_TYPE
|
if (TREE_CODE (type) == ARRAY_TYPE
|
&& TYPE_DOMAIN (type) == 0
|
&& TYPE_DOMAIN (type) == 0
|
&& TREE_CODE (decl) != TYPE_DECL)
|
&& TREE_CODE (decl) != TYPE_DECL)
|
{
|
{
|
bool do_default
|
bool do_default
|
= (TREE_STATIC (decl)
|
= (TREE_STATIC (decl)
|
/* Even if pedantic, an external linkage array
|
/* Even if pedantic, an external linkage array
|
may have incomplete type at first. */
|
may have incomplete type at first. */
|
? pedantic && !TREE_PUBLIC (decl)
|
? pedantic && !TREE_PUBLIC (decl)
|
: !DECL_EXTERNAL (decl));
|
: !DECL_EXTERNAL (decl));
|
int failure
|
int failure
|
= complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
|
= complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
|
do_default);
|
do_default);
|
|
|
/* Get the completed type made by complete_array_type. */
|
/* Get the completed type made by complete_array_type. */
|
type = TREE_TYPE (decl);
|
type = TREE_TYPE (decl);
|
|
|
switch (failure)
|
switch (failure)
|
{
|
{
|
case 1:
|
case 1:
|
error ("initializer fails to determine size of %q+D", decl);
|
error ("initializer fails to determine size of %q+D", decl);
|
break;
|
break;
|
|
|
case 2:
|
case 2:
|
if (do_default)
|
if (do_default)
|
error ("array size missing in %q+D", decl);
|
error ("array size missing in %q+D", decl);
|
/* If a `static' var's size isn't known,
|
/* If a `static' var's size isn't known,
|
make it extern as well as static, so it does not get
|
make it extern as well as static, so it does not get
|
allocated.
|
allocated.
|
If it is not `static', then do not mark extern;
|
If it is not `static', then do not mark extern;
|
finish_incomplete_decl will give it a default size
|
finish_incomplete_decl will give it a default size
|
and it will get allocated. */
|
and it will get allocated. */
|
else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
|
else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
|
DECL_EXTERNAL (decl) = 1;
|
DECL_EXTERNAL (decl) = 1;
|
break;
|
break;
|
|
|
case 3:
|
case 3:
|
error ("zero or negative size array %q+D", decl);
|
error ("zero or negative size array %q+D", decl);
|
break;
|
break;
|
|
|
case 0:
|
case 0:
|
/* For global variables, update the copy of the type that
|
/* For global variables, update the copy of the type that
|
exists in the binding. */
|
exists in the binding. */
|
if (TREE_PUBLIC (decl))
|
if (TREE_PUBLIC (decl))
|
{
|
{
|
struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
|
struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
|
while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
|
while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
|
b_ext = b_ext->shadowed;
|
b_ext = b_ext->shadowed;
|
if (b_ext)
|
if (b_ext)
|
{
|
{
|
if (b_ext->u.type)
|
if (b_ext->u.type)
|
b_ext->u.type = composite_type (b_ext->u.type, type);
|
b_ext->u.type = composite_type (b_ext->u.type, type);
|
else
|
else
|
b_ext->u.type = type;
|
b_ext->u.type = type;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
if (DECL_INITIAL (decl))
|
if (DECL_INITIAL (decl))
|
TREE_TYPE (DECL_INITIAL (decl)) = type;
|
TREE_TYPE (DECL_INITIAL (decl)) = type;
|
|
|
layout_decl (decl, 0);
|
layout_decl (decl, 0);
|
}
|
}
|
|
|
if (TREE_CODE (decl) == VAR_DECL)
|
if (TREE_CODE (decl) == VAR_DECL)
|
{
|
{
|
if (init && TREE_CODE (init) == CONSTRUCTOR)
|
if (init && TREE_CODE (init) == CONSTRUCTOR)
|
add_flexible_array_elts_to_size (decl, init);
|
add_flexible_array_elts_to_size (decl, init);
|
|
|
if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
|
if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
|
&& COMPLETE_TYPE_P (TREE_TYPE (decl)))
|
&& COMPLETE_TYPE_P (TREE_TYPE (decl)))
|
layout_decl (decl, 0);
|
layout_decl (decl, 0);
|
|
|
if (DECL_SIZE (decl) == 0
|
if (DECL_SIZE (decl) == 0
|
/* Don't give an error if we already gave one earlier. */
|
/* Don't give an error if we already gave one earlier. */
|
&& TREE_TYPE (decl) != error_mark_node
|
&& TREE_TYPE (decl) != error_mark_node
|
&& (TREE_STATIC (decl)
|
&& (TREE_STATIC (decl)
|
/* A static variable with an incomplete type
|
/* A static variable with an incomplete type
|
is an error if it is initialized.
|
is an error if it is initialized.
|
Also if it is not file scope.
|
Also if it is not file scope.
|
Otherwise, let it through, but if it is not `extern'
|
Otherwise, let it through, but if it is not `extern'
|
then it may cause an error message later. */
|
then it may cause an error message later. */
|
? (DECL_INITIAL (decl) != 0
|
? (DECL_INITIAL (decl) != 0
|
|| !DECL_FILE_SCOPE_P (decl))
|
|| !DECL_FILE_SCOPE_P (decl))
|
/* An automatic variable with an incomplete type
|
/* An automatic variable with an incomplete type
|
is an error. */
|
is an error. */
|
: !DECL_EXTERNAL (decl)))
|
: !DECL_EXTERNAL (decl)))
|
{
|
{
|
error ("storage size of %q+D isn%'t known", decl);
|
error ("storage size of %q+D isn%'t known", decl);
|
TREE_TYPE (decl) = error_mark_node;
|
TREE_TYPE (decl) = error_mark_node;
|
}
|
}
|
|
|
if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
|
if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
|
&& DECL_SIZE (decl) != 0)
|
&& DECL_SIZE (decl) != 0)
|
{
|
{
|
if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
|
if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
|
constant_expression_warning (DECL_SIZE (decl));
|
constant_expression_warning (DECL_SIZE (decl));
|
else
|
else
|
{
|
{
|
error ("storage size of %q+D isn%'t constant", decl);
|
error ("storage size of %q+D isn%'t constant", decl);
|
TREE_TYPE (decl) = error_mark_node;
|
TREE_TYPE (decl) = error_mark_node;
|
}
|
}
|
}
|
}
|
|
|
if (TREE_USED (type))
|
if (TREE_USED (type))
|
TREE_USED (decl) = 1;
|
TREE_USED (decl) = 1;
|
}
|
}
|
|
|
/* If this is a function and an assembler name is specified, reset DECL_RTL
|
/* If this is a function and an assembler name is specified, reset DECL_RTL
|
so we can give it its new name. Also, update built_in_decls if it
|
so we can give it its new name. Also, update built_in_decls if it
|
was a normal built-in. */
|
was a normal built-in. */
|
if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
|
if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
|
{
|
{
|
if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
|
if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
|
set_builtin_user_assembler_name (decl, asmspec);
|
set_builtin_user_assembler_name (decl, asmspec);
|
set_user_assembler_name (decl, asmspec);
|
set_user_assembler_name (decl, asmspec);
|
}
|
}
|
|
|
/* If #pragma weak was used, mark the decl weak now. */
|
/* If #pragma weak was used, mark the decl weak now. */
|
maybe_apply_pragma_weak (decl);
|
maybe_apply_pragma_weak (decl);
|
|
|
/* Output the assembler code and/or RTL code for variables and functions,
|
/* Output the assembler code and/or RTL code for variables and functions,
|
unless the type is an undefined structure or union.
|
unless the type is an undefined structure or union.
|
If not, it will get done when the type is completed. */
|
If not, it will get done when the type is completed. */
|
|
|
if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
|
if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
|
{
|
{
|
/* Determine the ELF visibility. */
|
/* Determine the ELF visibility. */
|
if (TREE_PUBLIC (decl))
|
if (TREE_PUBLIC (decl))
|
c_determine_visibility (decl);
|
c_determine_visibility (decl);
|
|
|
/* This is a no-op in c-lang.c or something real in objc-act.c. */
|
/* This is a no-op in c-lang.c or something real in objc-act.c. */
|
if (c_dialect_objc ())
|
if (c_dialect_objc ())
|
objc_check_decl (decl);
|
objc_check_decl (decl);
|
|
|
if (asmspec)
|
if (asmspec)
|
{
|
{
|
/* If this is not a static variable, issue a warning.
|
/* If this is not a static variable, issue a warning.
|
It doesn't make any sense to give an ASMSPEC for an
|
It doesn't make any sense to give an ASMSPEC for an
|
ordinary, non-register local variable. Historically,
|
ordinary, non-register local variable. Historically,
|
GCC has accepted -- but ignored -- the ASMSPEC in
|
GCC has accepted -- but ignored -- the ASMSPEC in
|
this case. */
|
this case. */
|
if (!DECL_FILE_SCOPE_P (decl)
|
if (!DECL_FILE_SCOPE_P (decl)
|
&& TREE_CODE (decl) == VAR_DECL
|
&& TREE_CODE (decl) == VAR_DECL
|
&& !C_DECL_REGISTER (decl)
|
&& !C_DECL_REGISTER (decl)
|
&& !TREE_STATIC (decl))
|
&& !TREE_STATIC (decl))
|
warning (0, "ignoring asm-specifier for non-static local "
|
warning (0, "ignoring asm-specifier for non-static local "
|
"variable %q+D", decl);
|
"variable %q+D", decl);
|
else
|
else
|
set_user_assembler_name (decl, asmspec);
|
set_user_assembler_name (decl, asmspec);
|
}
|
}
|
|
|
if (DECL_FILE_SCOPE_P (decl))
|
if (DECL_FILE_SCOPE_P (decl))
|
{
|
{
|
if (DECL_INITIAL (decl) == NULL_TREE
|
if (DECL_INITIAL (decl) == NULL_TREE
|
|| DECL_INITIAL (decl) == error_mark_node)
|
|| DECL_INITIAL (decl) == error_mark_node)
|
/* Don't output anything
|
/* Don't output anything
|
when a tentative file-scope definition is seen.
|
when a tentative file-scope definition is seen.
|
But at end of compilation, do output code for them. */
|
But at end of compilation, do output code for them. */
|
DECL_DEFER_OUTPUT (decl) = 1;
|
DECL_DEFER_OUTPUT (decl) = 1;
|
rest_of_decl_compilation (decl, true, 0);
|
rest_of_decl_compilation (decl, true, 0);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* In conjunction with an ASMSPEC, the `register'
|
/* In conjunction with an ASMSPEC, the `register'
|
keyword indicates that we should place the variable
|
keyword indicates that we should place the variable
|
in a particular register. */
|
in a particular register. */
|
if (asmspec && C_DECL_REGISTER (decl))
|
if (asmspec && C_DECL_REGISTER (decl))
|
{
|
{
|
DECL_HARD_REGISTER (decl) = 1;
|
DECL_HARD_REGISTER (decl) = 1;
|
/* This cannot be done for a structure with volatile
|
/* This cannot be done for a structure with volatile
|
fields, on which DECL_REGISTER will have been
|
fields, on which DECL_REGISTER will have been
|
reset. */
|
reset. */
|
if (!DECL_REGISTER (decl))
|
if (!DECL_REGISTER (decl))
|
error ("cannot put object with volatile field into register");
|
error ("cannot put object with volatile field into register");
|
}
|
}
|
|
|
if (TREE_CODE (decl) != FUNCTION_DECL)
|
if (TREE_CODE (decl) != FUNCTION_DECL)
|
{
|
{
|
/* If we're building a variable sized type, and we might be
|
/* If we're building a variable sized type, and we might be
|
reachable other than via the top of the current binding
|
reachable other than via the top of the current binding
|
level, then create a new BIND_EXPR so that we deallocate
|
level, then create a new BIND_EXPR so that we deallocate
|
the object at the right time. */
|
the object at the right time. */
|
/* Note that DECL_SIZE can be null due to errors. */
|
/* Note that DECL_SIZE can be null due to errors. */
|
if (DECL_SIZE (decl)
|
if (DECL_SIZE (decl)
|
&& !TREE_CONSTANT (DECL_SIZE (decl))
|
&& !TREE_CONSTANT (DECL_SIZE (decl))
|
&& STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
|
&& STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
|
{
|
{
|
tree bind;
|
tree bind;
|
bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
|
bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
|
TREE_SIDE_EFFECTS (bind) = 1;
|
TREE_SIDE_EFFECTS (bind) = 1;
|
add_stmt (bind);
|
add_stmt (bind);
|
BIND_EXPR_BODY (bind) = push_stmt_list ();
|
BIND_EXPR_BODY (bind) = push_stmt_list ();
|
}
|
}
|
add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl),
|
add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl),
|
DECL_EXPR, decl));
|
DECL_EXPR, decl));
|
}
|
}
|
}
|
}
|
|
|
|
|
if (!DECL_FILE_SCOPE_P (decl))
|
if (!DECL_FILE_SCOPE_P (decl))
|
{
|
{
|
/* Recompute the RTL of a local array now
|
/* Recompute the RTL of a local array now
|
if it used to be an incomplete type. */
|
if it used to be an incomplete type. */
|
if (was_incomplete
|
if (was_incomplete
|
&& !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
|
&& !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
|
{
|
{
|
/* If we used it already as memory, it must stay in memory. */
|
/* If we used it already as memory, it must stay in memory. */
|
TREE_ADDRESSABLE (decl) = TREE_USED (decl);
|
TREE_ADDRESSABLE (decl) = TREE_USED (decl);
|
/* If it's still incomplete now, no init will save it. */
|
/* If it's still incomplete now, no init will save it. */
|
if (DECL_SIZE (decl) == 0)
|
if (DECL_SIZE (decl) == 0)
|
DECL_INITIAL (decl) = 0;
|
DECL_INITIAL (decl) = 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (TREE_CODE (decl) == TYPE_DECL)
|
if (TREE_CODE (decl) == TYPE_DECL)
|
{
|
{
|
if (!DECL_FILE_SCOPE_P (decl)
|
if (!DECL_FILE_SCOPE_P (decl)
|
&& variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
|
&& variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
|
add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
|
add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
|
|
|
rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
|
rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
|
}
|
}
|
|
|
/* At the end of a declaration, throw away any variable type sizes
|
/* At the end of a declaration, throw away any variable type sizes
|
of types defined inside that declaration. There is no use
|
of types defined inside that declaration. There is no use
|
computing them in the following function definition. */
|
computing them in the following function definition. */
|
if (current_scope == file_scope)
|
if (current_scope == file_scope)
|
get_pending_sizes ();
|
get_pending_sizes ();
|
|
|
/* Install a cleanup (aka destructor) if one was given. */
|
/* Install a cleanup (aka destructor) if one was given. */
|
if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
|
if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
|
{
|
{
|
tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
|
tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
|
if (attr)
|
if (attr)
|
{
|
{
|
tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
|
tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
|
tree cleanup_decl = lookup_name (cleanup_id);
|
tree cleanup_decl = lookup_name (cleanup_id);
|
tree cleanup;
|
tree cleanup;
|
VEC(tree,gc) *vec;
|
VEC(tree,gc) *vec;
|
|
|
/* Build "cleanup(&decl)" for the destructor. */
|
/* Build "cleanup(&decl)" for the destructor. */
|
cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
|
cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
|
vec = VEC_alloc (tree, gc, 1);
|
vec = VEC_alloc (tree, gc, 1);
|
VEC_quick_push (tree, vec, cleanup);
|
VEC_quick_push (tree, vec, cleanup);
|
cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
|
cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
|
cleanup_decl, vec, NULL);
|
cleanup_decl, vec, NULL);
|
VEC_free (tree, gc, vec);
|
VEC_free (tree, gc, vec);
|
|
|
/* Don't warn about decl unused; the cleanup uses it. */
|
/* Don't warn about decl unused; the cleanup uses it. */
|
TREE_USED (decl) = 1;
|
TREE_USED (decl) = 1;
|
TREE_USED (cleanup_decl) = 1;
|
TREE_USED (cleanup_decl) = 1;
|
|
|
push_cleanup (decl, cleanup, false);
|
push_cleanup (decl, cleanup, false);
|
}
|
}
|
}
|
}
|
|
|
if (warn_cxx_compat
|
if (warn_cxx_compat
|
&& TREE_CODE (decl) == VAR_DECL
|
&& TREE_CODE (decl) == VAR_DECL
|
&& TREE_READONLY (decl)
|
&& TREE_READONLY (decl)
|
&& !DECL_EXTERNAL (decl)
|
&& !DECL_EXTERNAL (decl)
|
&& DECL_INITIAL (decl) == NULL_TREE)
|
&& DECL_INITIAL (decl) == NULL_TREE)
|
warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
|
warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
|
"uninitialized const %qD is invalid in C++", decl);
|
"uninitialized const %qD is invalid in C++", decl);
|
}
|
}
|
|
|
/* Given a parsed parameter declaration, decode it into a PARM_DECL. */
|
/* Given a parsed parameter declaration, decode it into a PARM_DECL. */
|
|
|
tree
|
tree
|
grokparm (const struct c_parm *parm)
|
grokparm (const struct c_parm *parm)
|
{
|
{
|
tree attrs = parm->attrs;
|
tree attrs = parm->attrs;
|
tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
|
tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
|
NULL, &attrs, NULL, NULL, DEPRECATED_NORMAL);
|
NULL, &attrs, NULL, NULL, DEPRECATED_NORMAL);
|
|
|
decl_attributes (&decl, attrs, 0);
|
decl_attributes (&decl, attrs, 0);
|
|
|
return decl;
|
return decl;
|
}
|
}
|
|
|
/* Given a parsed parameter declaration, decode it into a PARM_DECL
|
/* Given a parsed parameter declaration, decode it into a PARM_DECL
|
and push that on the current scope. */
|
and push that on the current scope. */
|
|
|
void
|
void
|
push_parm_decl (const struct c_parm *parm)
|
push_parm_decl (const struct c_parm *parm)
|
{
|
{
|
tree attrs = parm->attrs;
|
tree attrs = parm->attrs;
|
tree decl;
|
tree decl;
|
|
|
decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL,
|
decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL,
|
&attrs, NULL, NULL, DEPRECATED_NORMAL);
|
&attrs, NULL, NULL, DEPRECATED_NORMAL);
|
decl_attributes (&decl, attrs, 0);
|
decl_attributes (&decl, attrs, 0);
|
|
|
decl = pushdecl (decl);
|
decl = pushdecl (decl);
|
|
|
finish_decl (decl, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
|
finish_decl (decl, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
|
}
|
}
|
|
|
/* Mark all the parameter declarations to date as forward decls.
|
/* Mark all the parameter declarations to date as forward decls.
|
Also diagnose use of this extension. */
|
Also diagnose use of this extension. */
|
|
|
void
|
void
|
mark_forward_parm_decls (void)
|
mark_forward_parm_decls (void)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
if (pedantic && !current_scope->warned_forward_parm_decls)
|
if (pedantic && !current_scope->warned_forward_parm_decls)
|
{
|
{
|
pedwarn (input_location, OPT_pedantic,
|
pedwarn (input_location, OPT_pedantic,
|
"ISO C forbids forward parameter declarations");
|
"ISO C forbids forward parameter declarations");
|
current_scope->warned_forward_parm_decls = true;
|
current_scope->warned_forward_parm_decls = true;
|
}
|
}
|
|
|
for (b = current_scope->bindings; b; b = b->prev)
|
for (b = current_scope->bindings; b; b = b->prev)
|
if (TREE_CODE (b->decl) == PARM_DECL)
|
if (TREE_CODE (b->decl) == PARM_DECL)
|
TREE_ASM_WRITTEN (b->decl) = 1;
|
TREE_ASM_WRITTEN (b->decl) = 1;
|
}
|
}
|
|
|
/* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
|
/* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
|
literal, which may be an incomplete array type completed by the
|
literal, which may be an incomplete array type completed by the
|
initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
|
initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
|
literal. NON_CONST is true if the initializers contain something
|
literal. NON_CONST is true if the initializers contain something
|
that cannot occur in a constant expression. */
|
that cannot occur in a constant expression. */
|
|
|
tree
|
tree
|
build_compound_literal (location_t loc, tree type, tree init, bool non_const)
|
build_compound_literal (location_t loc, tree type, tree init, bool non_const)
|
{
|
{
|
/* We do not use start_decl here because we have a type, not a declarator;
|
/* We do not use start_decl here because we have a type, not a declarator;
|
and do not use finish_decl because the decl should be stored inside
|
and do not use finish_decl because the decl should be stored inside
|
the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
|
the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
|
tree decl;
|
tree decl;
|
tree complit;
|
tree complit;
|
tree stmt;
|
tree stmt;
|
|
|
if (type == error_mark_node
|
if (type == error_mark_node
|
|| init == error_mark_node)
|
|| init == error_mark_node)
|
return error_mark_node;
|
return error_mark_node;
|
|
|
decl = build_decl (loc, VAR_DECL, NULL_TREE, type);
|
decl = build_decl (loc, VAR_DECL, NULL_TREE, type);
|
DECL_EXTERNAL (decl) = 0;
|
DECL_EXTERNAL (decl) = 0;
|
TREE_PUBLIC (decl) = 0;
|
TREE_PUBLIC (decl) = 0;
|
TREE_STATIC (decl) = (current_scope == file_scope);
|
TREE_STATIC (decl) = (current_scope == file_scope);
|
DECL_CONTEXT (decl) = current_function_decl;
|
DECL_CONTEXT (decl) = current_function_decl;
|
TREE_USED (decl) = 1;
|
TREE_USED (decl) = 1;
|
TREE_TYPE (decl) = type;
|
TREE_TYPE (decl) = type;
|
TREE_READONLY (decl) = TYPE_READONLY (type);
|
TREE_READONLY (decl) = TYPE_READONLY (type);
|
store_init_value (loc, decl, init, NULL_TREE);
|
store_init_value (loc, decl, init, NULL_TREE);
|
|
|
if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
|
if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
|
{
|
{
|
int failure = complete_array_type (&TREE_TYPE (decl),
|
int failure = complete_array_type (&TREE_TYPE (decl),
|
DECL_INITIAL (decl), true);
|
DECL_INITIAL (decl), true);
|
gcc_assert (!failure);
|
gcc_assert (!failure);
|
|
|
type = TREE_TYPE (decl);
|
type = TREE_TYPE (decl);
|
TREE_TYPE (DECL_INITIAL (decl)) = type;
|
TREE_TYPE (DECL_INITIAL (decl)) = type;
|
}
|
}
|
|
|
if (type == error_mark_node || !COMPLETE_TYPE_P (type))
|
if (type == error_mark_node || !COMPLETE_TYPE_P (type))
|
return error_mark_node;
|
return error_mark_node;
|
|
|
stmt = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl);
|
stmt = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl);
|
complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
|
complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
|
TREE_SIDE_EFFECTS (complit) = 1;
|
TREE_SIDE_EFFECTS (complit) = 1;
|
|
|
layout_decl (decl, 0);
|
layout_decl (decl, 0);
|
|
|
if (TREE_STATIC (decl))
|
if (TREE_STATIC (decl))
|
{
|
{
|
/* This decl needs a name for the assembler output. */
|
/* This decl needs a name for the assembler output. */
|
set_compound_literal_name (decl);
|
set_compound_literal_name (decl);
|
DECL_DEFER_OUTPUT (decl) = 1;
|
DECL_DEFER_OUTPUT (decl) = 1;
|
DECL_COMDAT (decl) = 1;
|
DECL_COMDAT (decl) = 1;
|
DECL_ARTIFICIAL (decl) = 1;
|
DECL_ARTIFICIAL (decl) = 1;
|
DECL_IGNORED_P (decl) = 1;
|
DECL_IGNORED_P (decl) = 1;
|
pushdecl (decl);
|
pushdecl (decl);
|
rest_of_decl_compilation (decl, 1, 0);
|
rest_of_decl_compilation (decl, 1, 0);
|
}
|
}
|
|
|
if (non_const)
|
if (non_const)
|
{
|
{
|
complit = build2 (C_MAYBE_CONST_EXPR, type, NULL, complit);
|
complit = build2 (C_MAYBE_CONST_EXPR, type, NULL, complit);
|
C_MAYBE_CONST_EXPR_NON_CONST (complit) = 1;
|
C_MAYBE_CONST_EXPR_NON_CONST (complit) = 1;
|
}
|
}
|
|
|
return complit;
|
return complit;
|
}
|
}
|
|
|
/* Check the type of a compound literal. Here we just check that it
|
/* Check the type of a compound literal. Here we just check that it
|
is valid for C++. */
|
is valid for C++. */
|
|
|
void
|
void
|
check_compound_literal_type (location_t loc, struct c_type_name *type_name)
|
check_compound_literal_type (location_t loc, struct c_type_name *type_name)
|
{
|
{
|
if (warn_cxx_compat && type_name->specs->tag_defined_p)
|
if (warn_cxx_compat && type_name->specs->tag_defined_p)
|
warning_at (loc, OPT_Wc___compat,
|
warning_at (loc, OPT_Wc___compat,
|
"defining a type in a compound literal is invalid in C++");
|
"defining a type in a compound literal is invalid in C++");
|
}
|
}
|
|
|
/* Determine whether TYPE is a structure with a flexible array member,
|
/* Determine whether TYPE is a structure with a flexible array member,
|
or a union containing such a structure (possibly recursively). */
|
or a union containing such a structure (possibly recursively). */
|
|
|
static bool
|
static bool
|
flexible_array_type_p (tree type)
|
flexible_array_type_p (tree type)
|
{
|
{
|
tree x;
|
tree x;
|
switch (TREE_CODE (type))
|
switch (TREE_CODE (type))
|
{
|
{
|
case RECORD_TYPE:
|
case RECORD_TYPE:
|
x = TYPE_FIELDS (type);
|
x = TYPE_FIELDS (type);
|
if (x == NULL_TREE)
|
if (x == NULL_TREE)
|
return false;
|
return false;
|
while (TREE_CHAIN (x) != NULL_TREE)
|
while (TREE_CHAIN (x) != NULL_TREE)
|
x = TREE_CHAIN (x);
|
x = TREE_CHAIN (x);
|
if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
|
if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
|
&& TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
|
&& TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
|
&& TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
|
&& TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
|
&& TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
|
&& TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
|
return true;
|
return true;
|
return false;
|
return false;
|
case UNION_TYPE:
|
case UNION_TYPE:
|
for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
|
for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
|
{
|
{
|
if (flexible_array_type_p (TREE_TYPE (x)))
|
if (flexible_array_type_p (TREE_TYPE (x)))
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
/* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
|
/* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
|
replacing with appropriate values if they are invalid. */
|
replacing with appropriate values if they are invalid. */
|
static void
|
static void
|
check_bitfield_type_and_width (tree *type, tree *width, tree orig_name)
|
check_bitfield_type_and_width (tree *type, tree *width, tree orig_name)
|
{
|
{
|
tree type_mv;
|
tree type_mv;
|
unsigned int max_width;
|
unsigned int max_width;
|
unsigned HOST_WIDE_INT w;
|
unsigned HOST_WIDE_INT w;
|
const char *name = (orig_name
|
const char *name = (orig_name
|
? identifier_to_locale (IDENTIFIER_POINTER (orig_name))
|
? identifier_to_locale (IDENTIFIER_POINTER (orig_name))
|
: _("<anonymous>"));
|
: _("<anonymous>"));
|
|
|
/* Detect and ignore out of range field width and process valid
|
/* Detect and ignore out of range field width and process valid
|
field widths. */
|
field widths. */
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (*width)))
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (*width)))
|
{
|
{
|
error ("bit-field %qs width not an integer constant", name);
|
error ("bit-field %qs width not an integer constant", name);
|
*width = integer_one_node;
|
*width = integer_one_node;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (TREE_CODE (*width) != INTEGER_CST)
|
if (TREE_CODE (*width) != INTEGER_CST)
|
{
|
{
|
*width = c_fully_fold (*width, false, NULL);
|
*width = c_fully_fold (*width, false, NULL);
|
if (TREE_CODE (*width) == INTEGER_CST)
|
if (TREE_CODE (*width) == INTEGER_CST)
|
pedwarn (input_location, OPT_pedantic,
|
pedwarn (input_location, OPT_pedantic,
|
"bit-field %qs width not an integer constant expression",
|
"bit-field %qs width not an integer constant expression",
|
name);
|
name);
|
}
|
}
|
if (TREE_CODE (*width) != INTEGER_CST)
|
if (TREE_CODE (*width) != INTEGER_CST)
|
{
|
{
|
error ("bit-field %qs width not an integer constant", name);
|
error ("bit-field %qs width not an integer constant", name);
|
*width = integer_one_node;
|
*width = integer_one_node;
|
}
|
}
|
constant_expression_warning (*width);
|
constant_expression_warning (*width);
|
if (tree_int_cst_sgn (*width) < 0)
|
if (tree_int_cst_sgn (*width) < 0)
|
{
|
{
|
error ("negative width in bit-field %qs", name);
|
error ("negative width in bit-field %qs", name);
|
*width = integer_one_node;
|
*width = integer_one_node;
|
}
|
}
|
else if (integer_zerop (*width) && orig_name)
|
else if (integer_zerop (*width) && orig_name)
|
{
|
{
|
error ("zero width for bit-field %qs", name);
|
error ("zero width for bit-field %qs", name);
|
*width = integer_one_node;
|
*width = integer_one_node;
|
}
|
}
|
}
|
}
|
|
|
/* Detect invalid bit-field type. */
|
/* Detect invalid bit-field type. */
|
if (TREE_CODE (*type) != INTEGER_TYPE
|
if (TREE_CODE (*type) != INTEGER_TYPE
|
&& TREE_CODE (*type) != BOOLEAN_TYPE
|
&& TREE_CODE (*type) != BOOLEAN_TYPE
|
&& TREE_CODE (*type) != ENUMERAL_TYPE)
|
&& TREE_CODE (*type) != ENUMERAL_TYPE)
|
{
|
{
|
error ("bit-field %qs has invalid type", name);
|
error ("bit-field %qs has invalid type", name);
|
*type = unsigned_type_node;
|
*type = unsigned_type_node;
|
}
|
}
|
|
|
type_mv = TYPE_MAIN_VARIANT (*type);
|
type_mv = TYPE_MAIN_VARIANT (*type);
|
if (!in_system_header
|
if (!in_system_header
|
&& type_mv != integer_type_node
|
&& type_mv != integer_type_node
|
&& type_mv != unsigned_type_node
|
&& type_mv != unsigned_type_node
|
&& type_mv != boolean_type_node)
|
&& type_mv != boolean_type_node)
|
pedwarn (input_location, OPT_pedantic,
|
pedwarn (input_location, OPT_pedantic,
|
"type of bit-field %qs is a GCC extension", name);
|
"type of bit-field %qs is a GCC extension", name);
|
|
|
max_width = TYPE_PRECISION (*type);
|
max_width = TYPE_PRECISION (*type);
|
|
|
if (0 < compare_tree_int (*width, max_width))
|
if (0 < compare_tree_int (*width, max_width))
|
{
|
{
|
error ("width of %qs exceeds its type", name);
|
error ("width of %qs exceeds its type", name);
|
w = max_width;
|
w = max_width;
|
*width = build_int_cst (NULL_TREE, w);
|
*width = build_int_cst (NULL_TREE, w);
|
}
|
}
|
else
|
else
|
w = tree_low_cst (*width, 1);
|
w = tree_low_cst (*width, 1);
|
|
|
if (TREE_CODE (*type) == ENUMERAL_TYPE)
|
if (TREE_CODE (*type) == ENUMERAL_TYPE)
|
{
|
{
|
struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
|
struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
|
if (!lt
|
if (!lt
|
|| w < tree_int_cst_min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
|
|| w < tree_int_cst_min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
|
|| w < tree_int_cst_min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
|
|| w < tree_int_cst_min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
|
warning (0, "%qs is narrower than values of its type", name);
|
warning (0, "%qs is narrower than values of its type", name);
|
}
|
}
|
}
|
}
|
|
|
|
|
|
|
/* Print warning about variable length array if necessary. */
|
/* Print warning about variable length array if necessary. */
|
|
|
static void
|
static void
|
warn_variable_length_array (tree name, tree size)
|
warn_variable_length_array (tree name, tree size)
|
{
|
{
|
int const_size = TREE_CONSTANT (size);
|
int const_size = TREE_CONSTANT (size);
|
|
|
if (!flag_isoc99 && pedantic && warn_vla != 0)
|
if (!flag_isoc99 && pedantic && warn_vla != 0)
|
{
|
{
|
if (const_size)
|
if (const_size)
|
{
|
{
|
if (name)
|
if (name)
|
pedwarn (input_location, OPT_Wvla,
|
pedwarn (input_location, OPT_Wvla,
|
"ISO C90 forbids array %qE whose size "
|
"ISO C90 forbids array %qE whose size "
|
"can%'t be evaluated",
|
"can%'t be evaluated",
|
name);
|
name);
|
else
|
else
|
pedwarn (input_location, OPT_Wvla, "ISO C90 forbids array whose size "
|
pedwarn (input_location, OPT_Wvla, "ISO C90 forbids array whose size "
|
"can%'t be evaluated");
|
"can%'t be evaluated");
|
}
|
}
|
else
|
else
|
{
|
{
|
if (name)
|
if (name)
|
pedwarn (input_location, OPT_Wvla,
|
pedwarn (input_location, OPT_Wvla,
|
"ISO C90 forbids variable length array %qE",
|
"ISO C90 forbids variable length array %qE",
|
name);
|
name);
|
else
|
else
|
pedwarn (input_location, OPT_Wvla, "ISO C90 forbids variable length array");
|
pedwarn (input_location, OPT_Wvla, "ISO C90 forbids variable length array");
|
}
|
}
|
}
|
}
|
else if (warn_vla > 0)
|
else if (warn_vla > 0)
|
{
|
{
|
if (const_size)
|
if (const_size)
|
{
|
{
|
if (name)
|
if (name)
|
warning (OPT_Wvla,
|
warning (OPT_Wvla,
|
"the size of array %qE can"
|
"the size of array %qE can"
|
"%'t be evaluated", name);
|
"%'t be evaluated", name);
|
else
|
else
|
warning (OPT_Wvla,
|
warning (OPT_Wvla,
|
"the size of array can %'t be evaluated");
|
"the size of array can %'t be evaluated");
|
}
|
}
|
else
|
else
|
{
|
{
|
if (name)
|
if (name)
|
warning (OPT_Wvla,
|
warning (OPT_Wvla,
|
"variable length array %qE is used",
|
"variable length array %qE is used",
|
name);
|
name);
|
else
|
else
|
warning (OPT_Wvla,
|
warning (OPT_Wvla,
|
"variable length array is used");
|
"variable length array is used");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Given a size SIZE that may not be a constant, return a SAVE_EXPR to
|
/* Given a size SIZE that may not be a constant, return a SAVE_EXPR to
|
serve as the actual size-expression for a type or decl. This is
|
serve as the actual size-expression for a type or decl. This is
|
like variable_size in stor-layout.c, but we make global_bindings_p
|
like variable_size in stor-layout.c, but we make global_bindings_p
|
return negative to avoid calls to that function from outside the
|
return negative to avoid calls to that function from outside the
|
front end resulting in errors at file scope, then call this version
|
front end resulting in errors at file scope, then call this version
|
instead from front-end code. */
|
instead from front-end code. */
|
|
|
static tree
|
static tree
|
c_variable_size (tree size)
|
c_variable_size (tree size)
|
{
|
{
|
tree save;
|
tree save;
|
|
|
if (TREE_CONSTANT (size))
|
if (TREE_CONSTANT (size))
|
return size;
|
return size;
|
|
|
size = save_expr (size);
|
size = save_expr (size);
|
|
|
save = skip_simple_arithmetic (size);
|
save = skip_simple_arithmetic (size);
|
|
|
if (cfun && cfun->dont_save_pending_sizes_p)
|
if (cfun && cfun->dont_save_pending_sizes_p)
|
return size;
|
return size;
|
|
|
if (!global_bindings_p ())
|
if (!global_bindings_p ())
|
put_pending_size (save);
|
put_pending_size (save);
|
|
|
return size;
|
return size;
|
}
|
}
|
|
|
/* Given declspecs and a declarator,
|
/* Given declspecs and a declarator,
|
determine the name and type of the object declared
|
determine the name and type of the object declared
|
and construct a ..._DECL node for it.
|
and construct a ..._DECL node for it.
|
(In one case we can return a ..._TYPE node instead.
|
(In one case we can return a ..._TYPE node instead.
|
For invalid input we sometimes return 0.)
|
For invalid input we sometimes return 0.)
|
|
|
DECLSPECS is a c_declspecs structure for the declaration specifiers.
|
DECLSPECS is a c_declspecs structure for the declaration specifiers.
|
|
|
DECL_CONTEXT says which syntactic context this declaration is in:
|
DECL_CONTEXT says which syntactic context this declaration is in:
|
NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
|
NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
|
FUNCDEF for a function definition. Like NORMAL but a few different
|
FUNCDEF for a function definition. Like NORMAL but a few different
|
error messages in each case. Return value may be zero meaning
|
error messages in each case. Return value may be zero meaning
|
this definition is too screwy to try to parse.
|
this definition is too screwy to try to parse.
|
PARM for a parameter declaration (either within a function prototype
|
PARM for a parameter declaration (either within a function prototype
|
or before a function body). Make a PARM_DECL, or return void_type_node.
|
or before a function body). Make a PARM_DECL, or return void_type_node.
|
TYPENAME if for a typename (in a cast or sizeof).
|
TYPENAME if for a typename (in a cast or sizeof).
|
Don't make a DECL node; just return the ..._TYPE node.
|
Don't make a DECL node; just return the ..._TYPE node.
|
FIELD for a struct or union field; make a FIELD_DECL.
|
FIELD for a struct or union field; make a FIELD_DECL.
|
INITIALIZED is true if the decl has an initializer.
|
INITIALIZED is true if the decl has an initializer.
|
WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
|
WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
|
representing the width of the bit-field.
|
representing the width of the bit-field.
|
DECL_ATTRS points to the list of attributes that should be added to this
|
DECL_ATTRS points to the list of attributes that should be added to this
|
decl. Any nested attributes that belong on the decl itself will be
|
decl. Any nested attributes that belong on the decl itself will be
|
added to this list.
|
added to this list.
|
If EXPR is not NULL, any expressions that need to be evaluated as
|
If EXPR is not NULL, any expressions that need to be evaluated as
|
part of evaluating variably modified types will be stored in *EXPR.
|
part of evaluating variably modified types will be stored in *EXPR.
|
If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
|
If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
|
set to indicate whether operands in *EXPR can be used in constant
|
set to indicate whether operands in *EXPR can be used in constant
|
expressions.
|
expressions.
|
DEPRECATED_STATE is a deprecated_states value indicating whether
|
DEPRECATED_STATE is a deprecated_states value indicating whether
|
deprecation warnings should be suppressed.
|
deprecation warnings should be suppressed.
|
|
|
In the TYPENAME case, DECLARATOR is really an absolute declarator.
|
In the TYPENAME case, DECLARATOR is really an absolute declarator.
|
It may also be so in the PARM case, for a prototype where the
|
It may also be so in the PARM case, for a prototype where the
|
argument type is specified but not the name.
|
argument type is specified but not the name.
|
|
|
This function is where the complicated C meanings of `static'
|
This function is where the complicated C meanings of `static'
|
and `extern' are interpreted. */
|
and `extern' are interpreted. */
|
|
|
static tree
|
static tree
|
grokdeclarator (const struct c_declarator *declarator,
|
grokdeclarator (const struct c_declarator *declarator,
|
struct c_declspecs *declspecs,
|
struct c_declspecs *declspecs,
|
enum decl_context decl_context, bool initialized, tree *width,
|
enum decl_context decl_context, bool initialized, tree *width,
|
tree *decl_attrs, tree *expr, bool *expr_const_operands,
|
tree *decl_attrs, tree *expr, bool *expr_const_operands,
|
enum deprecated_states deprecated_state)
|
enum deprecated_states deprecated_state)
|
{
|
{
|
tree type = declspecs->type;
|
tree type = declspecs->type;
|
bool threadp = declspecs->thread_p;
|
bool threadp = declspecs->thread_p;
|
enum c_storage_class storage_class = declspecs->storage_class;
|
enum c_storage_class storage_class = declspecs->storage_class;
|
int constp;
|
int constp;
|
int restrictp;
|
int restrictp;
|
int volatilep;
|
int volatilep;
|
int type_quals = TYPE_UNQUALIFIED;
|
int type_quals = TYPE_UNQUALIFIED;
|
tree name = NULL_TREE;
|
tree name = NULL_TREE;
|
bool funcdef_flag = false;
|
bool funcdef_flag = false;
|
bool funcdef_syntax = false;
|
bool funcdef_syntax = false;
|
bool size_varies = false;
|
bool size_varies = false;
|
tree decl_attr = declspecs->decl_attr;
|
tree decl_attr = declspecs->decl_attr;
|
int array_ptr_quals = TYPE_UNQUALIFIED;
|
int array_ptr_quals = TYPE_UNQUALIFIED;
|
tree array_ptr_attrs = NULL_TREE;
|
tree array_ptr_attrs = NULL_TREE;
|
int array_parm_static = 0;
|
int array_parm_static = 0;
|
bool array_parm_vla_unspec_p = false;
|
bool array_parm_vla_unspec_p = false;
|
tree returned_attrs = NULL_TREE;
|
tree returned_attrs = NULL_TREE;
|
bool bitfield = width != NULL;
|
bool bitfield = width != NULL;
|
tree element_type;
|
tree element_type;
|
struct c_arg_info *arg_info = 0;
|
struct c_arg_info *arg_info = 0;
|
addr_space_t as1, as2, address_space;
|
addr_space_t as1, as2, address_space;
|
location_t loc = UNKNOWN_LOCATION;
|
location_t loc = UNKNOWN_LOCATION;
|
const char *errmsg;
|
const char *errmsg;
|
tree expr_dummy;
|
tree expr_dummy;
|
bool expr_const_operands_dummy;
|
bool expr_const_operands_dummy;
|
|
|
if (expr == NULL)
|
if (expr == NULL)
|
expr = &expr_dummy;
|
expr = &expr_dummy;
|
if (expr_const_operands == NULL)
|
if (expr_const_operands == NULL)
|
expr_const_operands = &expr_const_operands_dummy;
|
expr_const_operands = &expr_const_operands_dummy;
|
|
|
*expr = declspecs->expr;
|
*expr = declspecs->expr;
|
*expr_const_operands = declspecs->expr_const_operands;
|
*expr_const_operands = declspecs->expr_const_operands;
|
|
|
if (decl_context == FUNCDEF)
|
if (decl_context == FUNCDEF)
|
funcdef_flag = true, decl_context = NORMAL;
|
funcdef_flag = true, decl_context = NORMAL;
|
|
|
/* Look inside a declarator for the name being declared
|
/* Look inside a declarator for the name being declared
|
and get it as an IDENTIFIER_NODE, for an error message. */
|
and get it as an IDENTIFIER_NODE, for an error message. */
|
{
|
{
|
const struct c_declarator *decl = declarator;
|
const struct c_declarator *decl = declarator;
|
|
|
while (decl)
|
while (decl)
|
switch (decl->kind)
|
switch (decl->kind)
|
{
|
{
|
case cdk_array:
|
case cdk_array:
|
loc = decl->id_loc;
|
loc = decl->id_loc;
|
/* FALL THRU. */
|
/* FALL THRU. */
|
|
|
case cdk_function:
|
case cdk_function:
|
case cdk_pointer:
|
case cdk_pointer:
|
funcdef_syntax = (decl->kind == cdk_function);
|
funcdef_syntax = (decl->kind == cdk_function);
|
decl = decl->declarator;
|
decl = decl->declarator;
|
break;
|
break;
|
|
|
case cdk_attrs:
|
case cdk_attrs:
|
decl = decl->declarator;
|
decl = decl->declarator;
|
break;
|
break;
|
|
|
case cdk_id:
|
case cdk_id:
|
loc = decl->id_loc;
|
loc = decl->id_loc;
|
if (decl->u.id)
|
if (decl->u.id)
|
name = decl->u.id;
|
name = decl->u.id;
|
decl = 0;
|
decl = 0;
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
if (name == 0)
|
if (name == 0)
|
{
|
{
|
gcc_assert (decl_context == PARM
|
gcc_assert (decl_context == PARM
|
|| decl_context == TYPENAME
|
|| decl_context == TYPENAME
|
|| (decl_context == FIELD
|
|| (decl_context == FIELD
|
&& declarator->kind == cdk_id));
|
&& declarator->kind == cdk_id));
|
gcc_assert (!initialized);
|
gcc_assert (!initialized);
|
}
|
}
|
}
|
}
|
|
|
/* A function definition's declarator must have the form of
|
/* A function definition's declarator must have the form of
|
a function declarator. */
|
a function declarator. */
|
|
|
if (funcdef_flag && !funcdef_syntax)
|
if (funcdef_flag && !funcdef_syntax)
|
return 0;
|
return 0;
|
|
|
/* If this looks like a function definition, make it one,
|
/* If this looks like a function definition, make it one,
|
even if it occurs where parms are expected.
|
even if it occurs where parms are expected.
|
Then store_parm_decls will reject it and not use it as a parm. */
|
Then store_parm_decls will reject it and not use it as a parm. */
|
if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
|
if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
|
decl_context = PARM;
|
decl_context = PARM;
|
|
|
if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
|
if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
|
warn_deprecated_use (declspecs->type, declspecs->decl_attr);
|
warn_deprecated_use (declspecs->type, declspecs->decl_attr);
|
|
|
if ((decl_context == NORMAL || decl_context == FIELD)
|
if ((decl_context == NORMAL || decl_context == FIELD)
|
&& current_scope == file_scope
|
&& current_scope == file_scope
|
&& variably_modified_type_p (type, NULL_TREE))
|
&& variably_modified_type_p (type, NULL_TREE))
|
{
|
{
|
if (name)
|
if (name)
|
error_at (loc, "variably modified %qE at file scope", name);
|
error_at (loc, "variably modified %qE at file scope", name);
|
else
|
else
|
error_at (loc, "variably modified field at file scope");
|
error_at (loc, "variably modified field at file scope");
|
type = integer_type_node;
|
type = integer_type_node;
|
}
|
}
|
|
|
size_varies = C_TYPE_VARIABLE_SIZE (type) != 0;
|
size_varies = C_TYPE_VARIABLE_SIZE (type) != 0;
|
|
|
/* Diagnose defaulting to "int". */
|
/* Diagnose defaulting to "int". */
|
|
|
if (declspecs->default_int_p && !in_system_header)
|
if (declspecs->default_int_p && !in_system_header)
|
{
|
{
|
/* Issue a warning if this is an ISO C 99 program or if
|
/* Issue a warning if this is an ISO C 99 program or if
|
-Wreturn-type and this is a function, or if -Wimplicit;
|
-Wreturn-type and this is a function, or if -Wimplicit;
|
prefer the former warning since it is more explicit. */
|
prefer the former warning since it is more explicit. */
|
if ((warn_implicit_int || warn_return_type || flag_isoc99)
|
if ((warn_implicit_int || warn_return_type || flag_isoc99)
|
&& funcdef_flag)
|
&& funcdef_flag)
|
warn_about_return_type = 1;
|
warn_about_return_type = 1;
|
else
|
else
|
{
|
{
|
if (name)
|
if (name)
|
pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
|
pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
|
"type defaults to %<int%> in declaration of %qE",
|
"type defaults to %<int%> in declaration of %qE",
|
name);
|
name);
|
else
|
else
|
pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int,
|
pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int,
|
"type defaults to %<int%> in type name");
|
"type defaults to %<int%> in type name");
|
}
|
}
|
}
|
}
|
|
|
/* Adjust the type if a bit-field is being declared,
|
/* Adjust the type if a bit-field is being declared,
|
-funsigned-bitfields applied and the type is not explicitly
|
-funsigned-bitfields applied and the type is not explicitly
|
"signed". */
|
"signed". */
|
if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
|
if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
|
&& TREE_CODE (type) == INTEGER_TYPE)
|
&& TREE_CODE (type) == INTEGER_TYPE)
|
type = unsigned_type_for (type);
|
type = unsigned_type_for (type);
|
|
|
/* Figure out the type qualifiers for the declaration. There are
|
/* Figure out the type qualifiers for the declaration. There are
|
two ways a declaration can become qualified. One is something
|
two ways a declaration can become qualified. One is something
|
like `const int i' where the `const' is explicit. Another is
|
like `const int i' where the `const' is explicit. Another is
|
something like `typedef const int CI; CI i' where the type of the
|
something like `typedef const int CI; CI i' where the type of the
|
declaration contains the `const'. A third possibility is that
|
declaration contains the `const'. A third possibility is that
|
there is a type qualifier on the element type of a typedefed
|
there is a type qualifier on the element type of a typedefed
|
array type, in which case we should extract that qualifier so
|
array type, in which case we should extract that qualifier so
|
that c_apply_type_quals_to_decl receives the full list of
|
that c_apply_type_quals_to_decl receives the full list of
|
qualifiers to work with (C90 is not entirely clear about whether
|
qualifiers to work with (C90 is not entirely clear about whether
|
duplicate qualifiers should be diagnosed in this case, but it
|
duplicate qualifiers should be diagnosed in this case, but it
|
seems most appropriate to do so). */
|
seems most appropriate to do so). */
|
element_type = strip_array_types (type);
|
element_type = strip_array_types (type);
|
constp = declspecs->const_p + TYPE_READONLY (element_type);
|
constp = declspecs->const_p + TYPE_READONLY (element_type);
|
restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
|
restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
|
volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
|
volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
|
as1 = declspecs->address_space;
|
as1 = declspecs->address_space;
|
as2 = TYPE_ADDR_SPACE (element_type);
|
as2 = TYPE_ADDR_SPACE (element_type);
|
address_space = ADDR_SPACE_GENERIC_P (as1)? as2 : as1;
|
address_space = ADDR_SPACE_GENERIC_P (as1)? as2 : as1;
|
|
|
if (pedantic && !flag_isoc99)
|
if (pedantic && !flag_isoc99)
|
{
|
{
|
if (constp > 1)
|
if (constp > 1)
|
pedwarn (loc, OPT_pedantic, "duplicate %<const%>");
|
pedwarn (loc, OPT_pedantic, "duplicate %<const%>");
|
if (restrictp > 1)
|
if (restrictp > 1)
|
pedwarn (loc, OPT_pedantic, "duplicate %<restrict%>");
|
pedwarn (loc, OPT_pedantic, "duplicate %<restrict%>");
|
if (volatilep > 1)
|
if (volatilep > 1)
|
pedwarn (loc, OPT_pedantic, "duplicate %<volatile%>");
|
pedwarn (loc, OPT_pedantic, "duplicate %<volatile%>");
|
}
|
}
|
|
|
if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2) && as1 != as2)
|
if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2) && as1 != as2)
|
error_at (loc, "conflicting named address spaces (%s vs %s)",
|
error_at (loc, "conflicting named address spaces (%s vs %s)",
|
c_addr_space_name (as1), c_addr_space_name (as2));
|
c_addr_space_name (as1), c_addr_space_name (as2));
|
|
|
if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
|
if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
|
type = TYPE_MAIN_VARIANT (type);
|
type = TYPE_MAIN_VARIANT (type);
|
type_quals = ((constp ? TYPE_QUAL_CONST : 0)
|
type_quals = ((constp ? TYPE_QUAL_CONST : 0)
|
| (restrictp ? TYPE_QUAL_RESTRICT : 0)
|
| (restrictp ? TYPE_QUAL_RESTRICT : 0)
|
| (volatilep ? TYPE_QUAL_VOLATILE : 0)
|
| (volatilep ? TYPE_QUAL_VOLATILE : 0)
|
| ENCODE_QUAL_ADDR_SPACE (address_space));
|
| ENCODE_QUAL_ADDR_SPACE (address_space));
|
|
|
/* Warn about storage classes that are invalid for certain
|
/* Warn about storage classes that are invalid for certain
|
kinds of declarations (parameters, typenames, etc.). */
|
kinds of declarations (parameters, typenames, etc.). */
|
|
|
if (funcdef_flag
|
if (funcdef_flag
|
&& (threadp
|
&& (threadp
|
|| storage_class == csc_auto
|
|| storage_class == csc_auto
|
|| storage_class == csc_register
|
|| storage_class == csc_register
|
|| storage_class == csc_typedef))
|
|| storage_class == csc_typedef))
|
{
|
{
|
if (storage_class == csc_auto)
|
if (storage_class == csc_auto)
|
pedwarn (loc,
|
pedwarn (loc,
|
(current_scope == file_scope) ? 0 : OPT_pedantic,
|
(current_scope == file_scope) ? 0 : OPT_pedantic,
|
"function definition declared %<auto%>");
|
"function definition declared %<auto%>");
|
if (storage_class == csc_register)
|
if (storage_class == csc_register)
|
error_at (loc, "function definition declared %<register%>");
|
error_at (loc, "function definition declared %<register%>");
|
if (storage_class == csc_typedef)
|
if (storage_class == csc_typedef)
|
error_at (loc, "function definition declared %<typedef%>");
|
error_at (loc, "function definition declared %<typedef%>");
|
if (threadp)
|
if (threadp)
|
error_at (loc, "function definition declared %<__thread%>");
|
error_at (loc, "function definition declared %<__thread%>");
|
threadp = false;
|
threadp = false;
|
if (storage_class == csc_auto
|
if (storage_class == csc_auto
|
|| storage_class == csc_register
|
|| storage_class == csc_register
|
|| storage_class == csc_typedef)
|
|| storage_class == csc_typedef)
|
storage_class = csc_none;
|
storage_class = csc_none;
|
}
|
}
|
else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
|
else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
|
{
|
{
|
if (decl_context == PARM && storage_class == csc_register)
|
if (decl_context == PARM && storage_class == csc_register)
|
;
|
;
|
else
|
else
|
{
|
{
|
switch (decl_context)
|
switch (decl_context)
|
{
|
{
|
case FIELD:
|
case FIELD:
|
if (name)
|
if (name)
|
error_at (loc, "storage class specified for structure "
|
error_at (loc, "storage class specified for structure "
|
"field %qE", name);
|
"field %qE", name);
|
else
|
else
|
error_at (loc, "storage class specified for structure field");
|
error_at (loc, "storage class specified for structure field");
|
break;
|
break;
|
case PARM:
|
case PARM:
|
if (name)
|
if (name)
|
error_at (loc, "storage class specified for parameter %qE",
|
error_at (loc, "storage class specified for parameter %qE",
|
name);
|
name);
|
else
|
else
|
error_at (loc, "storage class specified for unnamed parameter");
|
error_at (loc, "storage class specified for unnamed parameter");
|
break;
|
break;
|
default:
|
default:
|
error_at (loc, "storage class specified for typename");
|
error_at (loc, "storage class specified for typename");
|
break;
|
break;
|
}
|
}
|
storage_class = csc_none;
|
storage_class = csc_none;
|
threadp = false;
|
threadp = false;
|
}
|
}
|
}
|
}
|
else if (storage_class == csc_extern
|
else if (storage_class == csc_extern
|
&& initialized
|
&& initialized
|
&& !funcdef_flag)
|
&& !funcdef_flag)
|
{
|
{
|
/* 'extern' with initialization is invalid if not at file scope. */
|
/* 'extern' with initialization is invalid if not at file scope. */
|
if (current_scope == file_scope)
|
if (current_scope == file_scope)
|
{
|
{
|
/* It is fine to have 'extern const' when compiling at C
|
/* It is fine to have 'extern const' when compiling at C
|
and C++ intersection. */
|
and C++ intersection. */
|
if (!(warn_cxx_compat && constp))
|
if (!(warn_cxx_compat && constp))
|
warning_at (loc, 0, "%qE initialized and declared %<extern%>",
|
warning_at (loc, 0, "%qE initialized and declared %<extern%>",
|
name);
|
name);
|
}
|
}
|
else
|
else
|
error_at (loc, "%qE has both %<extern%> and initializer", name);
|
error_at (loc, "%qE has both %<extern%> and initializer", name);
|
}
|
}
|
else if (current_scope == file_scope)
|
else if (current_scope == file_scope)
|
{
|
{
|
if (storage_class == csc_auto)
|
if (storage_class == csc_auto)
|
error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
|
error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
|
name);
|
name);
|
if (pedantic && storage_class == csc_register)
|
if (pedantic && storage_class == csc_register)
|
pedwarn (input_location, OPT_pedantic,
|
pedwarn (input_location, OPT_pedantic,
|
"file-scope declaration of %qE specifies %<register%>", name);
|
"file-scope declaration of %qE specifies %<register%>", name);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (storage_class == csc_extern && funcdef_flag)
|
if (storage_class == csc_extern && funcdef_flag)
|
error_at (loc, "nested function %qE declared %<extern%>", name);
|
error_at (loc, "nested function %qE declared %<extern%>", name);
|
else if (threadp && storage_class == csc_none)
|
else if (threadp && storage_class == csc_none)
|
{
|
{
|
error_at (loc, "function-scope %qE implicitly auto and declared "
|
error_at (loc, "function-scope %qE implicitly auto and declared "
|
"%<__thread%>",
|
"%<__thread%>",
|
name);
|
name);
|
threadp = false;
|
threadp = false;
|
}
|
}
|
}
|
}
|
|
|
/* Now figure out the structure of the declarator proper.
|
/* Now figure out the structure of the declarator proper.
|
Descend through it, creating more complex types, until we reach
|
Descend through it, creating more complex types, until we reach
|
the declared identifier (or NULL_TREE, in an absolute declarator).
|
the declared identifier (or NULL_TREE, in an absolute declarator).
|
At each stage we maintain an unqualified version of the type
|
At each stage we maintain an unqualified version of the type
|
together with any qualifiers that should be applied to it with
|
together with any qualifiers that should be applied to it with
|
c_build_qualified_type; this way, array types including
|
c_build_qualified_type; this way, array types including
|
multidimensional array types are first built up in unqualified
|
multidimensional array types are first built up in unqualified
|
form and then the qualified form is created with
|
form and then the qualified form is created with
|
TYPE_MAIN_VARIANT pointing to the unqualified form. */
|
TYPE_MAIN_VARIANT pointing to the unqualified form. */
|
|
|
while (declarator && declarator->kind != cdk_id)
|
while (declarator && declarator->kind != cdk_id)
|
{
|
{
|
if (type == error_mark_node)
|
if (type == error_mark_node)
|
{
|
{
|
declarator = declarator->declarator;
|
declarator = declarator->declarator;
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Each level of DECLARATOR is either a cdk_array (for ...[..]),
|
/* Each level of DECLARATOR is either a cdk_array (for ...[..]),
|
a cdk_pointer (for *...),
|
a cdk_pointer (for *...),
|
a cdk_function (for ...(...)),
|
a cdk_function (for ...(...)),
|
a cdk_attrs (for nested attributes),
|
a cdk_attrs (for nested attributes),
|
or a cdk_id (for the name being declared
|
or a cdk_id (for the name being declared
|
or the place in an absolute declarator
|
or the place in an absolute declarator
|
where the name was omitted).
|
where the name was omitted).
|
For the last case, we have just exited the loop.
|
For the last case, we have just exited the loop.
|
|
|
At this point, TYPE is the type of elements of an array,
|
At this point, TYPE is the type of elements of an array,
|
or for a function to return, or for a pointer to point to.
|
or for a function to return, or for a pointer to point to.
|
After this sequence of ifs, TYPE is the type of the
|
After this sequence of ifs, TYPE is the type of the
|
array or function or pointer, and DECLARATOR has had its
|
array or function or pointer, and DECLARATOR has had its
|
outermost layer removed. */
|
outermost layer removed. */
|
|
|
if (array_ptr_quals != TYPE_UNQUALIFIED
|
if (array_ptr_quals != TYPE_UNQUALIFIED
|
|| array_ptr_attrs != NULL_TREE
|
|| array_ptr_attrs != NULL_TREE
|
|| array_parm_static)
|
|| array_parm_static)
|
{
|
{
|
/* Only the innermost declarator (making a parameter be of
|
/* Only the innermost declarator (making a parameter be of
|
array type which is converted to pointer type)
|
array type which is converted to pointer type)
|
may have static or type qualifiers. */
|
may have static or type qualifiers. */
|
error_at (loc, "static or type qualifiers in non-parameter array declarator");
|
error_at (loc, "static or type qualifiers in non-parameter array declarator");
|
array_ptr_quals = TYPE_UNQUALIFIED;
|
array_ptr_quals = TYPE_UNQUALIFIED;
|
array_ptr_attrs = NULL_TREE;
|
array_ptr_attrs = NULL_TREE;
|
array_parm_static = 0;
|
array_parm_static = 0;
|
}
|
}
|
|
|
switch (declarator->kind)
|
switch (declarator->kind)
|
{
|
{
|
case cdk_attrs:
|
case cdk_attrs:
|
{
|
{
|
/* A declarator with embedded attributes. */
|
/* A declarator with embedded attributes. */
|
tree attrs = declarator->u.attrs;
|
tree attrs = declarator->u.attrs;
|
const struct c_declarator *inner_decl;
|
const struct c_declarator *inner_decl;
|
int attr_flags = 0;
|
int attr_flags = 0;
|
declarator = declarator->declarator;
|
declarator = declarator->declarator;
|
inner_decl = declarator;
|
inner_decl = declarator;
|
while (inner_decl->kind == cdk_attrs)
|
while (inner_decl->kind == cdk_attrs)
|
inner_decl = inner_decl->declarator;
|
inner_decl = inner_decl->declarator;
|
if (inner_decl->kind == cdk_id)
|
if (inner_decl->kind == cdk_id)
|
attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
|
attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
|
else if (inner_decl->kind == cdk_function)
|
else if (inner_decl->kind == cdk_function)
|
attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
|
attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
|
else if (inner_decl->kind == cdk_array)
|
else if (inner_decl->kind == cdk_array)
|
attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
|
attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
|
returned_attrs = decl_attributes (&type,
|
returned_attrs = decl_attributes (&type,
|
chainon (returned_attrs, attrs),
|
chainon (returned_attrs, attrs),
|
attr_flags);
|
attr_flags);
|
break;
|
break;
|
}
|
}
|
case cdk_array:
|
case cdk_array:
|
{
|
{
|
tree itype = NULL_TREE;
|
tree itype = NULL_TREE;
|
tree size = declarator->u.array.dimen;
|
tree size = declarator->u.array.dimen;
|
/* The index is a signed object `sizetype' bits wide. */
|
/* The index is a signed object `sizetype' bits wide. */
|
tree index_type = c_common_signed_type (sizetype);
|
tree index_type = c_common_signed_type (sizetype);
|
|
|
array_ptr_quals = declarator->u.array.quals;
|
array_ptr_quals = declarator->u.array.quals;
|
array_ptr_attrs = declarator->u.array.attrs;
|
array_ptr_attrs = declarator->u.array.attrs;
|
array_parm_static = declarator->u.array.static_p;
|
array_parm_static = declarator->u.array.static_p;
|
array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
|
array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
|
|
|
declarator = declarator->declarator;
|
declarator = declarator->declarator;
|
|
|
/* Check for some types that there cannot be arrays of. */
|
/* Check for some types that there cannot be arrays of. */
|
|
|
if (VOID_TYPE_P (type))
|
if (VOID_TYPE_P (type))
|
{
|
{
|
if (name)
|
if (name)
|
error_at (loc, "declaration of %qE as array of voids", name);
|
error_at (loc, "declaration of %qE as array of voids", name);
|
else
|
else
|
error_at (loc, "declaration of type name as array of voids");
|
error_at (loc, "declaration of type name as array of voids");
|
type = error_mark_node;
|
type = error_mark_node;
|
}
|
}
|
|
|
if (TREE_CODE (type) == FUNCTION_TYPE)
|
if (TREE_CODE (type) == FUNCTION_TYPE)
|
{
|
{
|
if (name)
|
if (name)
|
error_at (loc, "declaration of %qE as array of functions",
|
error_at (loc, "declaration of %qE as array of functions",
|
name);
|
name);
|
else
|
else
|
error_at (loc, "declaration of type name as array of "
|
error_at (loc, "declaration of type name as array of "
|
"functions");
|
"functions");
|
type = error_mark_node;
|
type = error_mark_node;
|
}
|
}
|
|
|
if (pedantic && !in_system_header && flexible_array_type_p (type))
|
if (pedantic && !in_system_header && flexible_array_type_p (type))
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"invalid use of structure with flexible array member");
|
"invalid use of structure with flexible array member");
|
|
|
if (size == error_mark_node)
|
if (size == error_mark_node)
|
type = error_mark_node;
|
type = error_mark_node;
|
|
|
if (type == error_mark_node)
|
if (type == error_mark_node)
|
continue;
|
continue;
|
|
|
/* If size was specified, set ITYPE to a range-type for
|
/* If size was specified, set ITYPE to a range-type for
|
that size. Otherwise, ITYPE remains null. finish_decl
|
that size. Otherwise, ITYPE remains null. finish_decl
|
may figure it out from an initial value. */
|
may figure it out from an initial value. */
|
|
|
if (size)
|
if (size)
|
{
|
{
|
bool size_maybe_const = true;
|
bool size_maybe_const = true;
|
bool size_int_const = (TREE_CODE (size) == INTEGER_CST
|
bool size_int_const = (TREE_CODE (size) == INTEGER_CST
|
&& !TREE_OVERFLOW (size));
|
&& !TREE_OVERFLOW (size));
|
bool this_size_varies = false;
|
bool this_size_varies = false;
|
|
|
/* Strip NON_LVALUE_EXPRs since we aren't using as an
|
/* Strip NON_LVALUE_EXPRs since we aren't using as an
|
lvalue. */
|
lvalue. */
|
STRIP_TYPE_NOPS (size);
|
STRIP_TYPE_NOPS (size);
|
|
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
|
{
|
{
|
if (name)
|
if (name)
|
error_at (loc, "size of array %qE has non-integer type",
|
error_at (loc, "size of array %qE has non-integer type",
|
name);
|
name);
|
else
|
else
|
error_at (loc,
|
error_at (loc,
|
"size of unnamed array has non-integer type");
|
"size of unnamed array has non-integer type");
|
size = integer_one_node;
|
size = integer_one_node;
|
}
|
}
|
|
|
size = c_fully_fold (size, false, &size_maybe_const);
|
size = c_fully_fold (size, false, &size_maybe_const);
|
|
|
if (pedantic && size_maybe_const && integer_zerop (size))
|
if (pedantic && size_maybe_const && integer_zerop (size))
|
{
|
{
|
if (name)
|
if (name)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C forbids zero-size array %qE", name);
|
"ISO C forbids zero-size array %qE", name);
|
else
|
else
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C forbids zero-size array");
|
"ISO C forbids zero-size array");
|
}
|
}
|
|
|
if (TREE_CODE (size) == INTEGER_CST && size_maybe_const)
|
if (TREE_CODE (size) == INTEGER_CST && size_maybe_const)
|
{
|
{
|
constant_expression_warning (size);
|
constant_expression_warning (size);
|
if (tree_int_cst_sgn (size) < 0)
|
if (tree_int_cst_sgn (size) < 0)
|
{
|
{
|
if (name)
|
if (name)
|
error_at (loc, "size of array %qE is negative", name);
|
error_at (loc, "size of array %qE is negative", name);
|
else
|
else
|
error_at (loc, "size of unnamed array is negative");
|
error_at (loc, "size of unnamed array is negative");
|
size = integer_one_node;
|
size = integer_one_node;
|
}
|
}
|
/* Handle a size folded to an integer constant but
|
/* Handle a size folded to an integer constant but
|
not an integer constant expression. */
|
not an integer constant expression. */
|
if (!size_int_const)
|
if (!size_int_const)
|
{
|
{
|
/* If this is a file scope declaration of an
|
/* If this is a file scope declaration of an
|
ordinary identifier, this is invalid code;
|
ordinary identifier, this is invalid code;
|
diagnosing it here and not subsequently
|
diagnosing it here and not subsequently
|
treating the type as variable-length avoids
|
treating the type as variable-length avoids
|
more confusing diagnostics later. */
|
more confusing diagnostics later. */
|
if ((decl_context == NORMAL || decl_context == FIELD)
|
if ((decl_context == NORMAL || decl_context == FIELD)
|
&& current_scope == file_scope)
|
&& current_scope == file_scope)
|
pedwarn (input_location, 0,
|
pedwarn (input_location, 0,
|
"variably modified %qE at file scope",
|
"variably modified %qE at file scope",
|
name);
|
name);
|
else
|
else
|
this_size_varies = size_varies = true;
|
this_size_varies = size_varies = true;
|
warn_variable_length_array (name, size);
|
warn_variable_length_array (name, size);
|
}
|
}
|
}
|
}
|
else if ((decl_context == NORMAL || decl_context == FIELD)
|
else if ((decl_context == NORMAL || decl_context == FIELD)
|
&& current_scope == file_scope)
|
&& current_scope == file_scope)
|
{
|
{
|
error_at (loc, "variably modified %qE at file scope", name);
|
error_at (loc, "variably modified %qE at file scope", name);
|
size = integer_one_node;
|
size = integer_one_node;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Make sure the array size remains visibly
|
/* Make sure the array size remains visibly
|
nonconstant even if it is (eg) a const variable
|
nonconstant even if it is (eg) a const variable
|
with known value. */
|
with known value. */
|
this_size_varies = size_varies = true;
|
this_size_varies = size_varies = true;
|
warn_variable_length_array (name, size);
|
warn_variable_length_array (name, size);
|
}
|
}
|
|
|
if (integer_zerop (size) && !this_size_varies)
|
if (integer_zerop (size) && !this_size_varies)
|
{
|
{
|
/* A zero-length array cannot be represented with
|
/* A zero-length array cannot be represented with
|
an unsigned index type, which is what we'll
|
an unsigned index type, which is what we'll
|
get with build_index_type. Create an
|
get with build_index_type. Create an
|
open-ended range instead. */
|
open-ended range instead. */
|
itype = build_range_type (sizetype, size, NULL_TREE);
|
itype = build_range_type (sizetype, size, NULL_TREE);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Arrange for the SAVE_EXPR on the inside of the
|
/* Arrange for the SAVE_EXPR on the inside of the
|
MINUS_EXPR, which allows the -1 to get folded
|
MINUS_EXPR, which allows the -1 to get folded
|
with the +1 that happens when building TYPE_SIZE. */
|
with the +1 that happens when building TYPE_SIZE. */
|
if (size_varies)
|
if (size_varies)
|
size = c_variable_size (size);
|
size = c_variable_size (size);
|
if (this_size_varies && TREE_CODE (size) == INTEGER_CST)
|
if (this_size_varies && TREE_CODE (size) == INTEGER_CST)
|
size = build2 (COMPOUND_EXPR, TREE_TYPE (size),
|
size = build2 (COMPOUND_EXPR, TREE_TYPE (size),
|
integer_zero_node, size);
|
integer_zero_node, size);
|
|
|
/* Compute the maximum valid index, that is, size
|
/* Compute the maximum valid index, that is, size
|
- 1. Do the calculation in index_type, so that
|
- 1. Do the calculation in index_type, so that
|
if it is a variable the computations will be
|
if it is a variable the computations will be
|
done in the proper mode. */
|
done in the proper mode. */
|
itype = fold_build2_loc (loc, MINUS_EXPR, index_type,
|
itype = fold_build2_loc (loc, MINUS_EXPR, index_type,
|
convert (index_type, size),
|
convert (index_type, size),
|
convert (index_type,
|
convert (index_type,
|
size_one_node));
|
size_one_node));
|
|
|
/* If that overflowed, the array is too big. ???
|
/* If that overflowed, the array is too big. ???
|
While a size of INT_MAX+1 technically shouldn't
|
While a size of INT_MAX+1 technically shouldn't
|
cause an overflow (because we subtract 1), the
|
cause an overflow (because we subtract 1), the
|
overflow is recorded during the conversion to
|
overflow is recorded during the conversion to
|
index_type, before the subtraction. Handling
|
index_type, before the subtraction. Handling
|
this case seems like an unnecessary
|
this case seems like an unnecessary
|
complication. */
|
complication. */
|
if (TREE_CODE (itype) == INTEGER_CST
|
if (TREE_CODE (itype) == INTEGER_CST
|
&& TREE_OVERFLOW (itype))
|
&& TREE_OVERFLOW (itype))
|
{
|
{
|
if (name)
|
if (name)
|
error_at (loc, "size of array %qE is too large",
|
error_at (loc, "size of array %qE is too large",
|
name);
|
name);
|
else
|
else
|
error_at (loc, "size of unnamed array is too large");
|
error_at (loc, "size of unnamed array is too large");
|
type = error_mark_node;
|
type = error_mark_node;
|
continue;
|
continue;
|
}
|
}
|
|
|
itype = build_index_type (itype);
|
itype = build_index_type (itype);
|
}
|
}
|
if (this_size_varies)
|
if (this_size_varies)
|
{
|
{
|
if (*expr)
|
if (*expr)
|
*expr = build2 (COMPOUND_EXPR, TREE_TYPE (size),
|
*expr = build2 (COMPOUND_EXPR, TREE_TYPE (size),
|
*expr, size);
|
*expr, size);
|
else
|
else
|
*expr = size;
|
*expr = size;
|
*expr_const_operands &= size_maybe_const;
|
*expr_const_operands &= size_maybe_const;
|
}
|
}
|
}
|
}
|
else if (decl_context == FIELD)
|
else if (decl_context == FIELD)
|
{
|
{
|
bool flexible_array_member = false;
|
bool flexible_array_member = false;
|
if (array_parm_vla_unspec_p)
|
if (array_parm_vla_unspec_p)
|
/* Field names can in fact have function prototype
|
/* Field names can in fact have function prototype
|
scope so [*] is disallowed here through making
|
scope so [*] is disallowed here through making
|
the field variably modified, not through being
|
the field variably modified, not through being
|
something other than a declaration with function
|
something other than a declaration with function
|
prototype scope. */
|
prototype scope. */
|
size_varies = true;
|
size_varies = true;
|
else
|
else
|
{
|
{
|
const struct c_declarator *t = declarator;
|
const struct c_declarator *t = declarator;
|
while (t->kind == cdk_attrs)
|
while (t->kind == cdk_attrs)
|
t = t->declarator;
|
t = t->declarator;
|
flexible_array_member = (t->kind == cdk_id);
|
flexible_array_member = (t->kind == cdk_id);
|
}
|
}
|
if (flexible_array_member
|
if (flexible_array_member
|
&& pedantic && !flag_isoc99 && !in_system_header)
|
&& pedantic && !flag_isoc99 && !in_system_header)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C90 does not support flexible array members");
|
"ISO C90 does not support flexible array members");
|
|
|
/* ISO C99 Flexible array members are effectively
|
/* ISO C99 Flexible array members are effectively
|
identical to GCC's zero-length array extension. */
|
identical to GCC's zero-length array extension. */
|
if (flexible_array_member || array_parm_vla_unspec_p)
|
if (flexible_array_member || array_parm_vla_unspec_p)
|
itype = build_range_type (sizetype, size_zero_node,
|
itype = build_range_type (sizetype, size_zero_node,
|
NULL_TREE);
|
NULL_TREE);
|
}
|
}
|
else if (decl_context == PARM)
|
else if (decl_context == PARM)
|
{
|
{
|
if (array_parm_vla_unspec_p)
|
if (array_parm_vla_unspec_p)
|
{
|
{
|
itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
|
itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
|
size_varies = true;
|
size_varies = true;
|
}
|
}
|
}
|
}
|
else if (decl_context == TYPENAME)
|
else if (decl_context == TYPENAME)
|
{
|
{
|
if (array_parm_vla_unspec_p)
|
if (array_parm_vla_unspec_p)
|
{
|
{
|
/* C99 6.7.5.2p4 */
|
/* C99 6.7.5.2p4 */
|
warning (0, "%<[*]%> not in a declaration");
|
warning (0, "%<[*]%> not in a declaration");
|
/* We use this to avoid messing up with incomplete
|
/* We use this to avoid messing up with incomplete
|
array types of the same type, that would
|
array types of the same type, that would
|
otherwise be modified below. */
|
otherwise be modified below. */
|
itype = build_range_type (sizetype, size_zero_node,
|
itype = build_range_type (sizetype, size_zero_node,
|
NULL_TREE);
|
NULL_TREE);
|
size_varies = true;
|
size_varies = true;
|
}
|
}
|
}
|
}
|
|
|
/* Complain about arrays of incomplete types. */
|
/* Complain about arrays of incomplete types. */
|
if (!COMPLETE_TYPE_P (type))
|
if (!COMPLETE_TYPE_P (type))
|
{
|
{
|
error_at (loc, "array type has incomplete element type");
|
error_at (loc, "array type has incomplete element type");
|
type = error_mark_node;
|
type = error_mark_node;
|
}
|
}
|
else
|
else
|
/* When itype is NULL, a shared incomplete array type is
|
/* When itype is NULL, a shared incomplete array type is
|
returned for all array of a given type. Elsewhere we
|
returned for all array of a given type. Elsewhere we
|
make sure we don't complete that type before copying
|
make sure we don't complete that type before copying
|
it, but here we want to make sure we don't ever
|
it, but here we want to make sure we don't ever
|
modify the shared type, so we gcc_assert (itype)
|
modify the shared type, so we gcc_assert (itype)
|
below. */
|
below. */
|
{
|
{
|
addr_space_t as = DECODE_QUAL_ADDR_SPACE (type_quals);
|
addr_space_t as = DECODE_QUAL_ADDR_SPACE (type_quals);
|
if (!ADDR_SPACE_GENERIC_P (as) && as != TYPE_ADDR_SPACE (type))
|
if (!ADDR_SPACE_GENERIC_P (as) && as != TYPE_ADDR_SPACE (type))
|
type = build_qualified_type (type,
|
type = build_qualified_type (type,
|
ENCODE_QUAL_ADDR_SPACE (as));
|
ENCODE_QUAL_ADDR_SPACE (as));
|
|
|
type = build_array_type (type, itype);
|
type = build_array_type (type, itype);
|
}
|
}
|
|
|
if (type != error_mark_node)
|
if (type != error_mark_node)
|
{
|
{
|
if (size_varies)
|
if (size_varies)
|
{
|
{
|
/* It is ok to modify type here even if itype is
|
/* It is ok to modify type here even if itype is
|
NULL: if size_varies, we're in a
|
NULL: if size_varies, we're in a
|
multi-dimensional array and the inner type has
|
multi-dimensional array and the inner type has
|
variable size, so the enclosing shared array type
|
variable size, so the enclosing shared array type
|
must too. */
|
must too. */
|
if (size && TREE_CODE (size) == INTEGER_CST)
|
if (size && TREE_CODE (size) == INTEGER_CST)
|
type
|
type
|
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
|
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
|
C_TYPE_VARIABLE_SIZE (type) = 1;
|
C_TYPE_VARIABLE_SIZE (type) = 1;
|
}
|
}
|
|
|
/* The GCC extension for zero-length arrays differs from
|
/* The GCC extension for zero-length arrays differs from
|
ISO flexible array members in that sizeof yields
|
ISO flexible array members in that sizeof yields
|
zero. */
|
zero. */
|
if (size && integer_zerop (size))
|
if (size && integer_zerop (size))
|
{
|
{
|
gcc_assert (itype);
|
gcc_assert (itype);
|
TYPE_SIZE (type) = bitsize_zero_node;
|
TYPE_SIZE (type) = bitsize_zero_node;
|
TYPE_SIZE_UNIT (type) = size_zero_node;
|
TYPE_SIZE_UNIT (type) = size_zero_node;
|
SET_TYPE_STRUCTURAL_EQUALITY (type);
|
SET_TYPE_STRUCTURAL_EQUALITY (type);
|
}
|
}
|
if (array_parm_vla_unspec_p)
|
if (array_parm_vla_unspec_p)
|
{
|
{
|
gcc_assert (itype);
|
gcc_assert (itype);
|
/* The type is complete. C99 6.7.5.2p4 */
|
/* The type is complete. C99 6.7.5.2p4 */
|
TYPE_SIZE (type) = bitsize_zero_node;
|
TYPE_SIZE (type) = bitsize_zero_node;
|
TYPE_SIZE_UNIT (type) = size_zero_node;
|
TYPE_SIZE_UNIT (type) = size_zero_node;
|
SET_TYPE_STRUCTURAL_EQUALITY (type);
|
SET_TYPE_STRUCTURAL_EQUALITY (type);
|
}
|
}
|
}
|
}
|
|
|
if (decl_context != PARM
|
if (decl_context != PARM
|
&& (array_ptr_quals != TYPE_UNQUALIFIED
|
&& (array_ptr_quals != TYPE_UNQUALIFIED
|
|| array_ptr_attrs != NULL_TREE
|
|| array_ptr_attrs != NULL_TREE
|
|| array_parm_static))
|
|| array_parm_static))
|
{
|
{
|
error_at (loc, "static or type qualifiers in non-parameter array declarator");
|
error_at (loc, "static or type qualifiers in non-parameter array declarator");
|
array_ptr_quals = TYPE_UNQUALIFIED;
|
array_ptr_quals = TYPE_UNQUALIFIED;
|
array_ptr_attrs = NULL_TREE;
|
array_ptr_attrs = NULL_TREE;
|
array_parm_static = 0;
|
array_parm_static = 0;
|
}
|
}
|
break;
|
break;
|
}
|
}
|
case cdk_function:
|
case cdk_function:
|
{
|
{
|
/* Say it's a definition only for the declarator closest
|
/* Say it's a definition only for the declarator closest
|
to the identifier, apart possibly from some
|
to the identifier, apart possibly from some
|
attributes. */
|
attributes. */
|
bool really_funcdef = false;
|
bool really_funcdef = false;
|
tree arg_types;
|
tree arg_types;
|
if (funcdef_flag)
|
if (funcdef_flag)
|
{
|
{
|
const struct c_declarator *t = declarator->declarator;
|
const struct c_declarator *t = declarator->declarator;
|
while (t->kind == cdk_attrs)
|
while (t->kind == cdk_attrs)
|
t = t->declarator;
|
t = t->declarator;
|
really_funcdef = (t->kind == cdk_id);
|
really_funcdef = (t->kind == cdk_id);
|
}
|
}
|
|
|
/* Declaring a function type. Make sure we have a valid
|
/* Declaring a function type. Make sure we have a valid
|
type for the function to return. */
|
type for the function to return. */
|
if (type == error_mark_node)
|
if (type == error_mark_node)
|
continue;
|
continue;
|
|
|
size_varies = false;
|
size_varies = false;
|
|
|
/* Warn about some types functions can't return. */
|
/* Warn about some types functions can't return. */
|
if (TREE_CODE (type) == FUNCTION_TYPE)
|
if (TREE_CODE (type) == FUNCTION_TYPE)
|
{
|
{
|
if (name)
|
if (name)
|
error_at (loc, "%qE declared as function returning a "
|
error_at (loc, "%qE declared as function returning a "
|
"function", name);
|
"function", name);
|
else
|
else
|
error_at (loc, "type name declared as function "
|
error_at (loc, "type name declared as function "
|
"returning a function");
|
"returning a function");
|
type = integer_type_node;
|
type = integer_type_node;
|
}
|
}
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
{
|
{
|
if (name)
|
if (name)
|
error_at (loc, "%qE declared as function returning an array",
|
error_at (loc, "%qE declared as function returning an array",
|
name);
|
name);
|
else
|
else
|
error_at (loc, "type name declared as function returning "
|
error_at (loc, "type name declared as function returning "
|
"an array");
|
"an array");
|
type = integer_type_node;
|
type = integer_type_node;
|
}
|
}
|
errmsg = targetm.invalid_return_type (type);
|
errmsg = targetm.invalid_return_type (type);
|
if (errmsg)
|
if (errmsg)
|
{
|
{
|
error (errmsg);
|
error (errmsg);
|
type = integer_type_node;
|
type = integer_type_node;
|
}
|
}
|
|
|
/* Construct the function type and go to the next
|
/* Construct the function type and go to the next
|
inner layer of declarator. */
|
inner layer of declarator. */
|
arg_info = declarator->u.arg_info;
|
arg_info = declarator->u.arg_info;
|
arg_types = grokparms (arg_info, really_funcdef);
|
arg_types = grokparms (arg_info, really_funcdef);
|
if (really_funcdef)
|
if (really_funcdef)
|
put_pending_sizes (arg_info->pending_sizes);
|
put_pending_sizes (arg_info->pending_sizes);
|
|
|
/* Type qualifiers before the return type of the function
|
/* Type qualifiers before the return type of the function
|
qualify the return type, not the function type. */
|
qualify the return type, not the function type. */
|
if (type_quals)
|
if (type_quals)
|
{
|
{
|
/* Type qualifiers on a function return type are
|
/* Type qualifiers on a function return type are
|
normally permitted by the standard but have no
|
normally permitted by the standard but have no
|
effect, so give a warning at -Wreturn-type.
|
effect, so give a warning at -Wreturn-type.
|
Qualifiers on a void return type are banned on
|
Qualifiers on a void return type are banned on
|
function definitions in ISO C; GCC used to used
|
function definitions in ISO C; GCC used to used
|
them for noreturn functions. */
|
them for noreturn functions. */
|
if (VOID_TYPE_P (type) && really_funcdef)
|
if (VOID_TYPE_P (type) && really_funcdef)
|
pedwarn (loc, 0,
|
pedwarn (loc, 0,
|
"function definition has qualified void return type");
|
"function definition has qualified void return type");
|
else
|
else
|
warning_at (loc, OPT_Wignored_qualifiers,
|
warning_at (loc, OPT_Wignored_qualifiers,
|
"type qualifiers ignored on function return type");
|
"type qualifiers ignored on function return type");
|
|
|
type = c_build_qualified_type (type, type_quals);
|
type = c_build_qualified_type (type, type_quals);
|
}
|
}
|
type_quals = TYPE_UNQUALIFIED;
|
type_quals = TYPE_UNQUALIFIED;
|
|
|
type = build_function_type (type, arg_types);
|
type = build_function_type (type, arg_types);
|
declarator = declarator->declarator;
|
declarator = declarator->declarator;
|
|
|
/* Set the TYPE_CONTEXTs for each tagged type which is local to
|
/* Set the TYPE_CONTEXTs for each tagged type which is local to
|
the formal parameter list of this FUNCTION_TYPE to point to
|
the formal parameter list of this FUNCTION_TYPE to point to
|
the FUNCTION_TYPE node itself. */
|
the FUNCTION_TYPE node itself. */
|
{
|
{
|
tree link;
|
tree link;
|
|
|
for (link = arg_info->tags;
|
for (link = arg_info->tags;
|
link;
|
link;
|
link = TREE_CHAIN (link))
|
link = TREE_CHAIN (link))
|
TYPE_CONTEXT (TREE_VALUE (link)) = type;
|
TYPE_CONTEXT (TREE_VALUE (link)) = type;
|
}
|
}
|
break;
|
break;
|
}
|
}
|
case cdk_pointer:
|
case cdk_pointer:
|
{
|
{
|
/* Merge any constancy or volatility into the target type
|
/* Merge any constancy or volatility into the target type
|
for the pointer. */
|
for the pointer. */
|
|
|
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
|
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
|
&& type_quals)
|
&& type_quals)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C forbids qualified function types");
|
"ISO C forbids qualified function types");
|
if (type_quals)
|
if (type_quals)
|
type = c_build_qualified_type (type, type_quals);
|
type = c_build_qualified_type (type, type_quals);
|
size_varies = false;
|
size_varies = false;
|
|
|
/* When the pointed-to type involves components of variable size,
|
/* When the pointed-to type involves components of variable size,
|
care must be taken to ensure that the size evaluation code is
|
care must be taken to ensure that the size evaluation code is
|
emitted early enough to dominate all the possible later uses
|
emitted early enough to dominate all the possible later uses
|
and late enough for the variables on which it depends to have
|
and late enough for the variables on which it depends to have
|
been assigned.
|
been assigned.
|
|
|
This is expected to happen automatically when the pointed-to
|
This is expected to happen automatically when the pointed-to
|
type has a name/declaration of it's own, but special attention
|
type has a name/declaration of it's own, but special attention
|
is required if the type is anonymous.
|
is required if the type is anonymous.
|
|
|
We handle the NORMAL and FIELD contexts here by attaching an
|
We handle the NORMAL and FIELD contexts here by attaching an
|
artificial TYPE_DECL to such pointed-to type. This forces the
|
artificial TYPE_DECL to such pointed-to type. This forces the
|
sizes evaluation at a safe point and ensures it is not deferred
|
sizes evaluation at a safe point and ensures it is not deferred
|
until e.g. within a deeper conditional context.
|
until e.g. within a deeper conditional context.
|
|
|
We expect nothing to be needed here for PARM or TYPENAME.
|
We expect nothing to be needed here for PARM or TYPENAME.
|
Pushing a TYPE_DECL at this point for TYPENAME would actually
|
Pushing a TYPE_DECL at this point for TYPENAME would actually
|
be incorrect, as we might be in the middle of an expression
|
be incorrect, as we might be in the middle of an expression
|
with side effects on the pointed-to type size "arguments" prior
|
with side effects on the pointed-to type size "arguments" prior
|
to the pointer declaration point and the fake TYPE_DECL in the
|
to the pointer declaration point and the fake TYPE_DECL in the
|
enclosing context would force the size evaluation prior to the
|
enclosing context would force the size evaluation prior to the
|
side effects. */
|
side effects. */
|
|
|
if (!TYPE_NAME (type)
|
if (!TYPE_NAME (type)
|
&& (decl_context == NORMAL || decl_context == FIELD)
|
&& (decl_context == NORMAL || decl_context == FIELD)
|
&& variably_modified_type_p (type, NULL_TREE))
|
&& variably_modified_type_p (type, NULL_TREE))
|
{
|
{
|
tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
|
tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
|
DECL_ARTIFICIAL (decl) = 1;
|
DECL_ARTIFICIAL (decl) = 1;
|
pushdecl (decl);
|
pushdecl (decl);
|
finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
|
finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
|
TYPE_NAME (type) = decl;
|
TYPE_NAME (type) = decl;
|
}
|
}
|
|
|
type = build_pointer_type (type);
|
type = build_pointer_type (type);
|
|
|
/* Process type qualifiers (such as const or volatile)
|
/* Process type qualifiers (such as const or volatile)
|
that were given inside the `*'. */
|
that were given inside the `*'. */
|
type_quals = declarator->u.pointer_quals;
|
type_quals = declarator->u.pointer_quals;
|
|
|
declarator = declarator->declarator;
|
declarator = declarator->declarator;
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
*decl_attrs = chainon (returned_attrs, *decl_attrs);
|
*decl_attrs = chainon (returned_attrs, *decl_attrs);
|
|
|
/* Now TYPE has the actual type, apart from any qualifiers in
|
/* Now TYPE has the actual type, apart from any qualifiers in
|
TYPE_QUALS. */
|
TYPE_QUALS. */
|
|
|
/* Warn about address space used for things other than static memory or
|
/* Warn about address space used for things other than static memory or
|
pointers. */
|
pointers. */
|
address_space = DECODE_QUAL_ADDR_SPACE (type_quals);
|
address_space = DECODE_QUAL_ADDR_SPACE (type_quals);
|
if (!ADDR_SPACE_GENERIC_P (address_space))
|
if (!ADDR_SPACE_GENERIC_P (address_space))
|
{
|
{
|
if (decl_context == NORMAL)
|
if (decl_context == NORMAL)
|
{
|
{
|
switch (storage_class)
|
switch (storage_class)
|
{
|
{
|
case csc_auto:
|
case csc_auto:
|
error ("%qs combined with %<auto%> qualifier for %qE",
|
error ("%qs combined with %<auto%> qualifier for %qE",
|
c_addr_space_name (address_space), name);
|
c_addr_space_name (address_space), name);
|
break;
|
break;
|
case csc_register:
|
case csc_register:
|
error ("%qs combined with %<register%> qualifier for %qE",
|
error ("%qs combined with %<register%> qualifier for %qE",
|
c_addr_space_name (address_space), name);
|
c_addr_space_name (address_space), name);
|
break;
|
break;
|
case csc_none:
|
case csc_none:
|
if (current_function_scope)
|
if (current_function_scope)
|
{
|
{
|
error ("%qs specified for auto variable %qE",
|
error ("%qs specified for auto variable %qE",
|
c_addr_space_name (address_space), name);
|
c_addr_space_name (address_space), name);
|
break;
|
break;
|
}
|
}
|
break;
|
break;
|
case csc_static:
|
case csc_static:
|
case csc_extern:
|
case csc_extern:
|
case csc_typedef:
|
case csc_typedef:
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
|
else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
|
{
|
{
|
if (name)
|
if (name)
|
error ("%qs specified for parameter %qE",
|
error ("%qs specified for parameter %qE",
|
c_addr_space_name (address_space), name);
|
c_addr_space_name (address_space), name);
|
else
|
else
|
error ("%qs specified for unnamed parameter",
|
error ("%qs specified for unnamed parameter",
|
c_addr_space_name (address_space));
|
c_addr_space_name (address_space));
|
}
|
}
|
else if (decl_context == FIELD)
|
else if (decl_context == FIELD)
|
{
|
{
|
if (name)
|
if (name)
|
error ("%qs specified for structure field %qE",
|
error ("%qs specified for structure field %qE",
|
c_addr_space_name (address_space), name);
|
c_addr_space_name (address_space), name);
|
else
|
else
|
error ("%qs specified for structure field",
|
error ("%qs specified for structure field",
|
c_addr_space_name (address_space));
|
c_addr_space_name (address_space));
|
}
|
}
|
}
|
}
|
|
|
/* Check the type and width of a bit-field. */
|
/* Check the type and width of a bit-field. */
|
if (bitfield)
|
if (bitfield)
|
check_bitfield_type_and_width (&type, width, name);
|
check_bitfield_type_and_width (&type, width, name);
|
|
|
/* Did array size calculations overflow? */
|
/* Did array size calculations overflow? */
|
|
|
if (TREE_CODE (type) == ARRAY_TYPE
|
if (TREE_CODE (type) == ARRAY_TYPE
|
&& COMPLETE_TYPE_P (type)
|
&& COMPLETE_TYPE_P (type)
|
&& TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
|
&& TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
|
&& TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
|
&& TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
|
{
|
{
|
if (name)
|
if (name)
|
error_at (loc, "size of array %qE is too large", name);
|
error_at (loc, "size of array %qE is too large", name);
|
else
|
else
|
error_at (loc, "size of unnamed array is too large");
|
error_at (loc, "size of unnamed array is too large");
|
/* If we proceed with the array type as it is, we'll eventually
|
/* If we proceed with the array type as it is, we'll eventually
|
crash in tree_low_cst(). */
|
crash in tree_low_cst(). */
|
type = error_mark_node;
|
type = error_mark_node;
|
}
|
}
|
|
|
/* If this is declaring a typedef name, return a TYPE_DECL. */
|
/* If this is declaring a typedef name, return a TYPE_DECL. */
|
|
|
if (storage_class == csc_typedef)
|
if (storage_class == csc_typedef)
|
{
|
{
|
tree decl;
|
tree decl;
|
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
|
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
|
&& type_quals)
|
&& type_quals)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C forbids qualified function types");
|
"ISO C forbids qualified function types");
|
if (type_quals)
|
if (type_quals)
|
type = c_build_qualified_type (type, type_quals);
|
type = c_build_qualified_type (type, type_quals);
|
decl = build_decl (declarator->id_loc,
|
decl = build_decl (declarator->id_loc,
|
TYPE_DECL, declarator->u.id, type);
|
TYPE_DECL, declarator->u.id, type);
|
if (declspecs->explicit_signed_p)
|
if (declspecs->explicit_signed_p)
|
C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
|
C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
|
if (declspecs->inline_p)
|
if (declspecs->inline_p)
|
pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl);
|
pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl);
|
|
|
if (warn_cxx_compat && declarator->u.id != NULL_TREE)
|
if (warn_cxx_compat && declarator->u.id != NULL_TREE)
|
{
|
{
|
struct c_binding *b = I_TAG_BINDING (declarator->u.id);
|
struct c_binding *b = I_TAG_BINDING (declarator->u.id);
|
|
|
if (b != NULL
|
if (b != NULL
|
&& b->decl != NULL_TREE
|
&& b->decl != NULL_TREE
|
&& (B_IN_CURRENT_SCOPE (b)
|
&& (B_IN_CURRENT_SCOPE (b)
|
|| (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
|
|| (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
|
&& TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
|
&& TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
|
{
|
{
|
warning_at (declarator->id_loc, OPT_Wc___compat,
|
warning_at (declarator->id_loc, OPT_Wc___compat,
|
("using %qD as both a typedef and a tag is "
|
("using %qD as both a typedef and a tag is "
|
"invalid in C++"),
|
"invalid in C++"),
|
decl);
|
decl);
|
if (b->locus != UNKNOWN_LOCATION)
|
if (b->locus != UNKNOWN_LOCATION)
|
inform (b->locus, "originally defined here");
|
inform (b->locus, "originally defined here");
|
}
|
}
|
}
|
}
|
|
|
return decl;
|
return decl;
|
}
|
}
|
|
|
/* If this is a type name (such as, in a cast or sizeof),
|
/* If this is a type name (such as, in a cast or sizeof),
|
compute the type and return it now. */
|
compute the type and return it now. */
|
|
|
if (decl_context == TYPENAME)
|
if (decl_context == TYPENAME)
|
{
|
{
|
/* Note that the grammar rejects storage classes in typenames
|
/* Note that the grammar rejects storage classes in typenames
|
and fields. */
|
and fields. */
|
gcc_assert (storage_class == csc_none && !threadp
|
gcc_assert (storage_class == csc_none && !threadp
|
&& !declspecs->inline_p);
|
&& !declspecs->inline_p);
|
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
|
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
|
&& type_quals)
|
&& type_quals)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C forbids const or volatile function types");
|
"ISO C forbids const or volatile function types");
|
if (type_quals)
|
if (type_quals)
|
type = c_build_qualified_type (type, type_quals);
|
type = c_build_qualified_type (type, type_quals);
|
return type;
|
return type;
|
}
|
}
|
|
|
if (pedantic && decl_context == FIELD
|
if (pedantic && decl_context == FIELD
|
&& variably_modified_type_p (type, NULL_TREE))
|
&& variably_modified_type_p (type, NULL_TREE))
|
{
|
{
|
/* C99 6.7.2.1p8 */
|
/* C99 6.7.2.1p8 */
|
pedwarn (loc, OPT_pedantic, "a member of a structure or union cannot "
|
pedwarn (loc, OPT_pedantic, "a member of a structure or union cannot "
|
"have a variably modified type");
|
"have a variably modified type");
|
}
|
}
|
|
|
/* Aside from typedefs and type names (handle above),
|
/* Aside from typedefs and type names (handle above),
|
`void' at top level (not within pointer)
|
`void' at top level (not within pointer)
|
is allowed only in public variables.
|
is allowed only in public variables.
|
We don't complain about parms either, but that is because
|
We don't complain about parms either, but that is because
|
a better error message can be made later. */
|
a better error message can be made later. */
|
|
|
if (VOID_TYPE_P (type) && decl_context != PARM
|
if (VOID_TYPE_P (type) && decl_context != PARM
|
&& !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
|
&& !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
|
&& (storage_class == csc_extern
|
&& (storage_class == csc_extern
|
|| (current_scope == file_scope
|
|| (current_scope == file_scope
|
&& !(storage_class == csc_static
|
&& !(storage_class == csc_static
|
|| storage_class == csc_register)))))
|
|| storage_class == csc_register)))))
|
{
|
{
|
error_at (loc, "variable or field %qE declared void", name);
|
error_at (loc, "variable or field %qE declared void", name);
|
type = integer_type_node;
|
type = integer_type_node;
|
}
|
}
|
|
|
/* Now create the decl, which may be a VAR_DECL, a PARM_DECL
|
/* Now create the decl, which may be a VAR_DECL, a PARM_DECL
|
or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
|
or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
|
|
|
{
|
{
|
tree decl;
|
tree decl;
|
|
|
if (decl_context == PARM)
|
if (decl_context == PARM)
|
{
|
{
|
tree promoted_type;
|
tree promoted_type;
|
|
|
/* A parameter declared as an array of T is really a pointer to T.
|
/* A parameter declared as an array of T is really a pointer to T.
|
One declared as a function is really a pointer to a function. */
|
One declared as a function is really a pointer to a function. */
|
|
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
{
|
{
|
/* Transfer const-ness of array into that of type pointed to. */
|
/* Transfer const-ness of array into that of type pointed to. */
|
type = TREE_TYPE (type);
|
type = TREE_TYPE (type);
|
if (type_quals)
|
if (type_quals)
|
type = c_build_qualified_type (type, type_quals);
|
type = c_build_qualified_type (type, type_quals);
|
type = build_pointer_type (type);
|
type = build_pointer_type (type);
|
type_quals = array_ptr_quals;
|
type_quals = array_ptr_quals;
|
if (type_quals)
|
if (type_quals)
|
type = c_build_qualified_type (type, type_quals);
|
type = c_build_qualified_type (type, type_quals);
|
|
|
/* We don't yet implement attributes in this context. */
|
/* We don't yet implement attributes in this context. */
|
if (array_ptr_attrs != NULL_TREE)
|
if (array_ptr_attrs != NULL_TREE)
|
warning_at (loc, OPT_Wattributes,
|
warning_at (loc, OPT_Wattributes,
|
"attributes in parameter array declarator ignored");
|
"attributes in parameter array declarator ignored");
|
|
|
size_varies = false;
|
size_varies = false;
|
}
|
}
|
else if (TREE_CODE (type) == FUNCTION_TYPE)
|
else if (TREE_CODE (type) == FUNCTION_TYPE)
|
{
|
{
|
if (type_quals)
|
if (type_quals)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C forbids qualified function types");
|
"ISO C forbids qualified function types");
|
if (type_quals)
|
if (type_quals)
|
type = c_build_qualified_type (type, type_quals);
|
type = c_build_qualified_type (type, type_quals);
|
type = build_pointer_type (type);
|
type = build_pointer_type (type);
|
type_quals = TYPE_UNQUALIFIED;
|
type_quals = TYPE_UNQUALIFIED;
|
}
|
}
|
else if (type_quals)
|
else if (type_quals)
|
type = c_build_qualified_type (type, type_quals);
|
type = c_build_qualified_type (type, type_quals);
|
|
|
decl = build_decl (declarator->id_loc,
|
decl = build_decl (declarator->id_loc,
|
PARM_DECL, declarator->u.id, type);
|
PARM_DECL, declarator->u.id, type);
|
if (size_varies)
|
if (size_varies)
|
C_DECL_VARIABLE_SIZE (decl) = 1;
|
C_DECL_VARIABLE_SIZE (decl) = 1;
|
|
|
/* Compute the type actually passed in the parmlist,
|
/* Compute the type actually passed in the parmlist,
|
for the case where there is no prototype.
|
for the case where there is no prototype.
|
(For example, shorts and chars are passed as ints.)
|
(For example, shorts and chars are passed as ints.)
|
When there is a prototype, this is overridden later. */
|
When there is a prototype, this is overridden later. */
|
|
|
if (type == error_mark_node)
|
if (type == error_mark_node)
|
promoted_type = type;
|
promoted_type = type;
|
else
|
else
|
promoted_type = c_type_promotes_to (type);
|
promoted_type = c_type_promotes_to (type);
|
|
|
DECL_ARG_TYPE (decl) = promoted_type;
|
DECL_ARG_TYPE (decl) = promoted_type;
|
if (declspecs->inline_p)
|
if (declspecs->inline_p)
|
pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl);
|
pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl);
|
}
|
}
|
else if (decl_context == FIELD)
|
else if (decl_context == FIELD)
|
{
|
{
|
/* Note that the grammar rejects storage classes in typenames
|
/* Note that the grammar rejects storage classes in typenames
|
and fields. */
|
and fields. */
|
gcc_assert (storage_class == csc_none && !threadp
|
gcc_assert (storage_class == csc_none && !threadp
|
&& !declspecs->inline_p);
|
&& !declspecs->inline_p);
|
|
|
/* Structure field. It may not be a function. */
|
/* Structure field. It may not be a function. */
|
|
|
if (TREE_CODE (type) == FUNCTION_TYPE)
|
if (TREE_CODE (type) == FUNCTION_TYPE)
|
{
|
{
|
error_at (loc, "field %qE declared as a function", name);
|
error_at (loc, "field %qE declared as a function", name);
|
type = build_pointer_type (type);
|
type = build_pointer_type (type);
|
}
|
}
|
else if (TREE_CODE (type) != ERROR_MARK
|
else if (TREE_CODE (type) != ERROR_MARK
|
&& !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
|
&& !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
|
{
|
{
|
if (name)
|
if (name)
|
error_at (loc, "field %qE has incomplete type", name);
|
error_at (loc, "field %qE has incomplete type", name);
|
else
|
else
|
error_at (loc, "unnamed field has incomplete type");
|
error_at (loc, "unnamed field has incomplete type");
|
type = error_mark_node;
|
type = error_mark_node;
|
}
|
}
|
type = c_build_qualified_type (type, type_quals);
|
type = c_build_qualified_type (type, type_quals);
|
decl = build_decl (declarator->id_loc,
|
decl = build_decl (declarator->id_loc,
|
FIELD_DECL, declarator->u.id, type);
|
FIELD_DECL, declarator->u.id, type);
|
DECL_NONADDRESSABLE_P (decl) = bitfield;
|
DECL_NONADDRESSABLE_P (decl) = bitfield;
|
if (bitfield && !declarator->u.id)
|
if (bitfield && !declarator->u.id)
|
TREE_NO_WARNING (decl) = 1;
|
TREE_NO_WARNING (decl) = 1;
|
|
|
if (size_varies)
|
if (size_varies)
|
C_DECL_VARIABLE_SIZE (decl) = 1;
|
C_DECL_VARIABLE_SIZE (decl) = 1;
|
}
|
}
|
else if (TREE_CODE (type) == FUNCTION_TYPE)
|
else if (TREE_CODE (type) == FUNCTION_TYPE)
|
{
|
{
|
if (storage_class == csc_register || threadp)
|
if (storage_class == csc_register || threadp)
|
{
|
{
|
error_at (loc, "invalid storage class for function %qE", name);
|
error_at (loc, "invalid storage class for function %qE", name);
|
}
|
}
|
else if (current_scope != file_scope)
|
else if (current_scope != file_scope)
|
{
|
{
|
/* Function declaration not at file scope. Storage
|
/* Function declaration not at file scope. Storage
|
classes other than `extern' are not allowed, C99
|
classes other than `extern' are not allowed, C99
|
6.7.1p5, and `extern' makes no difference. However,
|
6.7.1p5, and `extern' makes no difference. However,
|
GCC allows 'auto', perhaps with 'inline', to support
|
GCC allows 'auto', perhaps with 'inline', to support
|
nested functions. */
|
nested functions. */
|
if (storage_class == csc_auto)
|
if (storage_class == csc_auto)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"invalid storage class for function %qE", name);
|
"invalid storage class for function %qE", name);
|
else if (storage_class == csc_static)
|
else if (storage_class == csc_static)
|
{
|
{
|
error_at (loc, "invalid storage class for function %qE", name);
|
error_at (loc, "invalid storage class for function %qE", name);
|
if (funcdef_flag)
|
if (funcdef_flag)
|
storage_class = declspecs->storage_class = csc_none;
|
storage_class = declspecs->storage_class = csc_none;
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
decl = build_decl (declarator->id_loc,
|
decl = build_decl (declarator->id_loc,
|
FUNCTION_DECL, declarator->u.id, type);
|
FUNCTION_DECL, declarator->u.id, type);
|
decl = build_decl_attribute_variant (decl, decl_attr);
|
decl = build_decl_attribute_variant (decl, decl_attr);
|
|
|
if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
|
if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C forbids qualified function types");
|
"ISO C forbids qualified function types");
|
|
|
/* GNU C interprets a volatile-qualified function type to indicate
|
/* GNU C interprets a volatile-qualified function type to indicate
|
that the function does not return. */
|
that the function does not return. */
|
if ((type_quals & TYPE_QUAL_VOLATILE)
|
if ((type_quals & TYPE_QUAL_VOLATILE)
|
&& !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
|
&& !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
|
warning_at (loc, 0, "%<noreturn%> function returns non-void value");
|
warning_at (loc, 0, "%<noreturn%> function returns non-void value");
|
|
|
/* Every function declaration is an external reference
|
/* Every function declaration is an external reference
|
(DECL_EXTERNAL) except for those which are not at file
|
(DECL_EXTERNAL) except for those which are not at file
|
scope and are explicitly declared "auto". This is
|
scope and are explicitly declared "auto". This is
|
forbidden by standard C (C99 6.7.1p5) and is interpreted by
|
forbidden by standard C (C99 6.7.1p5) and is interpreted by
|
GCC to signify a forward declaration of a nested function. */
|
GCC to signify a forward declaration of a nested function. */
|
if (storage_class == csc_auto && current_scope != file_scope)
|
if (storage_class == csc_auto && current_scope != file_scope)
|
DECL_EXTERNAL (decl) = 0;
|
DECL_EXTERNAL (decl) = 0;
|
/* In C99, a function which is declared 'inline' with 'extern'
|
/* In C99, a function which is declared 'inline' with 'extern'
|
is not an external reference (which is confusing). It
|
is not an external reference (which is confusing). It
|
means that the later definition of the function must be output
|
means that the later definition of the function must be output
|
in this file, C99 6.7.4p6. In GNU C89, a function declared
|
in this file, C99 6.7.4p6. In GNU C89, a function declared
|
'extern inline' is an external reference. */
|
'extern inline' is an external reference. */
|
else if (declspecs->inline_p && storage_class != csc_static)
|
else if (declspecs->inline_p && storage_class != csc_static)
|
DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
|
DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
|
== flag_gnu89_inline);
|
== flag_gnu89_inline);
|
else
|
else
|
DECL_EXTERNAL (decl) = !initialized;
|
DECL_EXTERNAL (decl) = !initialized;
|
|
|
/* Record absence of global scope for `static' or `auto'. */
|
/* Record absence of global scope for `static' or `auto'. */
|
TREE_PUBLIC (decl)
|
TREE_PUBLIC (decl)
|
= !(storage_class == csc_static || storage_class == csc_auto);
|
= !(storage_class == csc_static || storage_class == csc_auto);
|
|
|
/* For a function definition, record the argument information
|
/* For a function definition, record the argument information
|
block where store_parm_decls will look for it. */
|
block where store_parm_decls will look for it. */
|
if (funcdef_flag)
|
if (funcdef_flag)
|
current_function_arg_info = arg_info;
|
current_function_arg_info = arg_info;
|
|
|
if (declspecs->default_int_p)
|
if (declspecs->default_int_p)
|
C_FUNCTION_IMPLICIT_INT (decl) = 1;
|
C_FUNCTION_IMPLICIT_INT (decl) = 1;
|
|
|
/* Record presence of `inline', if it is reasonable. */
|
/* Record presence of `inline', if it is reasonable. */
|
if (flag_hosted && MAIN_NAME_P (declarator->u.id))
|
if (flag_hosted && MAIN_NAME_P (declarator->u.id))
|
{
|
{
|
if (declspecs->inline_p)
|
if (declspecs->inline_p)
|
pedwarn (loc, 0, "cannot inline function %<main%>");
|
pedwarn (loc, 0, "cannot inline function %<main%>");
|
}
|
}
|
else if (declspecs->inline_p)
|
else if (declspecs->inline_p)
|
/* Record that the function is declared `inline'. */
|
/* Record that the function is declared `inline'. */
|
DECL_DECLARED_INLINE_P (decl) = 1;
|
DECL_DECLARED_INLINE_P (decl) = 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* It's a variable. */
|
/* It's a variable. */
|
/* An uninitialized decl with `extern' is a reference. */
|
/* An uninitialized decl with `extern' is a reference. */
|
int extern_ref = !initialized && storage_class == csc_extern;
|
int extern_ref = !initialized && storage_class == csc_extern;
|
|
|
type = c_build_qualified_type (type, type_quals);
|
type = c_build_qualified_type (type, type_quals);
|
|
|
/* C99 6.2.2p7: It is invalid (compile-time undefined
|
/* C99 6.2.2p7: It is invalid (compile-time undefined
|
behavior) to create an 'extern' declaration for a
|
behavior) to create an 'extern' declaration for a
|
variable if there is a global declaration that is
|
variable if there is a global declaration that is
|
'static' and the global declaration is not visible.
|
'static' and the global declaration is not visible.
|
(If the static declaration _is_ currently visible,
|
(If the static declaration _is_ currently visible,
|
the 'extern' declaration is taken to refer to that decl.) */
|
the 'extern' declaration is taken to refer to that decl.) */
|
if (extern_ref && current_scope != file_scope)
|
if (extern_ref && current_scope != file_scope)
|
{
|
{
|
tree global_decl = identifier_global_value (declarator->u.id);
|
tree global_decl = identifier_global_value (declarator->u.id);
|
tree visible_decl = lookup_name (declarator->u.id);
|
tree visible_decl = lookup_name (declarator->u.id);
|
|
|
if (global_decl
|
if (global_decl
|
&& global_decl != visible_decl
|
&& global_decl != visible_decl
|
&& TREE_CODE (global_decl) == VAR_DECL
|
&& TREE_CODE (global_decl) == VAR_DECL
|
&& !TREE_PUBLIC (global_decl))
|
&& !TREE_PUBLIC (global_decl))
|
error_at (loc, "variable previously declared %<static%> "
|
error_at (loc, "variable previously declared %<static%> "
|
"redeclared %<extern%>");
|
"redeclared %<extern%>");
|
}
|
}
|
|
|
decl = build_decl (declarator->id_loc,
|
decl = build_decl (declarator->id_loc,
|
VAR_DECL, declarator->u.id, type);
|
VAR_DECL, declarator->u.id, type);
|
if (size_varies)
|
if (size_varies)
|
C_DECL_VARIABLE_SIZE (decl) = 1;
|
C_DECL_VARIABLE_SIZE (decl) = 1;
|
|
|
if (declspecs->inline_p)
|
if (declspecs->inline_p)
|
pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl);
|
pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl);
|
|
|
/* At file scope, an initialized extern declaration may follow
|
/* At file scope, an initialized extern declaration may follow
|
a static declaration. In that case, DECL_EXTERNAL will be
|
a static declaration. In that case, DECL_EXTERNAL will be
|
reset later in start_decl. */
|
reset later in start_decl. */
|
DECL_EXTERNAL (decl) = (storage_class == csc_extern);
|
DECL_EXTERNAL (decl) = (storage_class == csc_extern);
|
|
|
/* At file scope, the presence of a `static' or `register' storage
|
/* At file scope, the presence of a `static' or `register' storage
|
class specifier, or the absence of all storage class specifiers
|
class specifier, or the absence of all storage class specifiers
|
makes this declaration a definition (perhaps tentative). Also,
|
makes this declaration a definition (perhaps tentative). Also,
|
the absence of `static' makes it public. */
|
the absence of `static' makes it public. */
|
if (current_scope == file_scope)
|
if (current_scope == file_scope)
|
{
|
{
|
TREE_PUBLIC (decl) = storage_class != csc_static;
|
TREE_PUBLIC (decl) = storage_class != csc_static;
|
TREE_STATIC (decl) = !extern_ref;
|
TREE_STATIC (decl) = !extern_ref;
|
}
|
}
|
/* Not at file scope, only `static' makes a static definition. */
|
/* Not at file scope, only `static' makes a static definition. */
|
else
|
else
|
{
|
{
|
TREE_STATIC (decl) = (storage_class == csc_static);
|
TREE_STATIC (decl) = (storage_class == csc_static);
|
TREE_PUBLIC (decl) = extern_ref;
|
TREE_PUBLIC (decl) = extern_ref;
|
}
|
}
|
|
|
if (threadp)
|
if (threadp)
|
DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
|
DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
|
}
|
}
|
|
|
if ((storage_class == csc_extern
|
if ((storage_class == csc_extern
|
|| (storage_class == csc_none
|
|| (storage_class == csc_none
|
&& TREE_CODE (type) == FUNCTION_TYPE
|
&& TREE_CODE (type) == FUNCTION_TYPE
|
&& !funcdef_flag))
|
&& !funcdef_flag))
|
&& variably_modified_type_p (type, NULL_TREE))
|
&& variably_modified_type_p (type, NULL_TREE))
|
{
|
{
|
/* C99 6.7.5.2p2 */
|
/* C99 6.7.5.2p2 */
|
if (TREE_CODE (type) == FUNCTION_TYPE)
|
if (TREE_CODE (type) == FUNCTION_TYPE)
|
error_at (loc, "non-nested function with variably modified type");
|
error_at (loc, "non-nested function with variably modified type");
|
else
|
else
|
error_at (loc, "object with variably modified type must have "
|
error_at (loc, "object with variably modified type must have "
|
"no linkage");
|
"no linkage");
|
}
|
}
|
|
|
/* Record `register' declaration for warnings on &
|
/* Record `register' declaration for warnings on &
|
and in case doing stupid register allocation. */
|
and in case doing stupid register allocation. */
|
|
|
if (storage_class == csc_register)
|
if (storage_class == csc_register)
|
{
|
{
|
C_DECL_REGISTER (decl) = 1;
|
C_DECL_REGISTER (decl) = 1;
|
DECL_REGISTER (decl) = 1;
|
DECL_REGISTER (decl) = 1;
|
}
|
}
|
|
|
/* Record constancy and volatility. */
|
/* Record constancy and volatility. */
|
c_apply_type_quals_to_decl (type_quals, decl);
|
c_apply_type_quals_to_decl (type_quals, decl);
|
|
|
/* If a type has volatile components, it should be stored in memory.
|
/* If a type has volatile components, it should be stored in memory.
|
Otherwise, the fact that those components are volatile
|
Otherwise, the fact that those components are volatile
|
will be ignored, and would even crash the compiler.
|
will be ignored, and would even crash the compiler.
|
Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
|
Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
|
if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
|
if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
|
&& (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
|
&& (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
|
|| TREE_CODE (decl) == RESULT_DECL))
|
|| TREE_CODE (decl) == RESULT_DECL))
|
{
|
{
|
/* It is not an error for a structure with volatile fields to
|
/* It is not an error for a structure with volatile fields to
|
be declared register, but reset DECL_REGISTER since it
|
be declared register, but reset DECL_REGISTER since it
|
cannot actually go in a register. */
|
cannot actually go in a register. */
|
int was_reg = C_DECL_REGISTER (decl);
|
int was_reg = C_DECL_REGISTER (decl);
|
C_DECL_REGISTER (decl) = 0;
|
C_DECL_REGISTER (decl) = 0;
|
DECL_REGISTER (decl) = 0;
|
DECL_REGISTER (decl) = 0;
|
c_mark_addressable (decl);
|
c_mark_addressable (decl);
|
C_DECL_REGISTER (decl) = was_reg;
|
C_DECL_REGISTER (decl) = was_reg;
|
}
|
}
|
|
|
/* This is the earliest point at which we might know the assembler
|
/* This is the earliest point at which we might know the assembler
|
name of a variable. Thus, if it's known before this, die horribly. */
|
name of a variable. Thus, if it's known before this, die horribly. */
|
gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
|
gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
|
|
|
if (warn_cxx_compat
|
if (warn_cxx_compat
|
&& TREE_CODE (decl) == VAR_DECL
|
&& TREE_CODE (decl) == VAR_DECL
|
&& TREE_PUBLIC (decl)
|
&& TREE_PUBLIC (decl)
|
&& TREE_STATIC (decl)
|
&& TREE_STATIC (decl)
|
&& (TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
|
&& (TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
|
|| TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
|
|| TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
|
|| TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
|
|| TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
|
&& TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE)
|
&& TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE)
|
warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
|
warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
|
("non-local variable %qD with anonymous type is "
|
("non-local variable %qD with anonymous type is "
|
"questionable in C++"),
|
"questionable in C++"),
|
decl);
|
decl);
|
|
|
return decl;
|
return decl;
|
}
|
}
|
}
|
}
|
|
|
/* Decode the parameter-list info for a function type or function definition.
|
/* Decode the parameter-list info for a function type or function definition.
|
The argument is the value returned by `get_parm_info' (or made in c-parse.c
|
The argument is the value returned by `get_parm_info' (or made in c-parse.c
|
if there is an identifier list instead of a parameter decl list).
|
if there is an identifier list instead of a parameter decl list).
|
These two functions are separate because when a function returns
|
These two functions are separate because when a function returns
|
or receives functions then each is called multiple times but the order
|
or receives functions then each is called multiple times but the order
|
of calls is different. The last call to `grokparms' is always the one
|
of calls is different. The last call to `grokparms' is always the one
|
that contains the formal parameter names of a function definition.
|
that contains the formal parameter names of a function definition.
|
|
|
Return a list of arg types to use in the FUNCTION_TYPE for this function.
|
Return a list of arg types to use in the FUNCTION_TYPE for this function.
|
|
|
FUNCDEF_FLAG is true for a function definition, false for
|
FUNCDEF_FLAG is true for a function definition, false for
|
a mere declaration. A nonempty identifier-list gets an error message
|
a mere declaration. A nonempty identifier-list gets an error message
|
when FUNCDEF_FLAG is false. */
|
when FUNCDEF_FLAG is false. */
|
|
|
static tree
|
static tree
|
grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
|
grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
|
{
|
{
|
tree arg_types = arg_info->types;
|
tree arg_types = arg_info->types;
|
|
|
if (funcdef_flag && arg_info->had_vla_unspec)
|
if (funcdef_flag && arg_info->had_vla_unspec)
|
{
|
{
|
/* A function definition isn't function prototype scope C99 6.2.1p4. */
|
/* A function definition isn't function prototype scope C99 6.2.1p4. */
|
/* C99 6.7.5.2p4 */
|
/* C99 6.7.5.2p4 */
|
error ("%<[*]%> not allowed in other than function prototype scope");
|
error ("%<[*]%> not allowed in other than function prototype scope");
|
}
|
}
|
|
|
if (arg_types == 0 && !funcdef_flag && !in_system_header)
|
if (arg_types == 0 && !funcdef_flag && !in_system_header)
|
warning (OPT_Wstrict_prototypes,
|
warning (OPT_Wstrict_prototypes,
|
"function declaration isn%'t a prototype");
|
"function declaration isn%'t a prototype");
|
|
|
if (arg_types == error_mark_node)
|
if (arg_types == error_mark_node)
|
return 0; /* don't set TYPE_ARG_TYPES in this case */
|
return 0; /* don't set TYPE_ARG_TYPES in this case */
|
|
|
else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
|
else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
|
{
|
{
|
if (!funcdef_flag)
|
if (!funcdef_flag)
|
pedwarn (input_location, 0, "parameter names (without types) in function declaration");
|
pedwarn (input_location, 0, "parameter names (without types) in function declaration");
|
|
|
arg_info->parms = arg_info->types;
|
arg_info->parms = arg_info->types;
|
arg_info->types = 0;
|
arg_info->types = 0;
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
tree parm, type, typelt;
|
tree parm, type, typelt;
|
unsigned int parmno;
|
unsigned int parmno;
|
const char *errmsg;
|
const char *errmsg;
|
|
|
/* If there is a parameter of incomplete type in a definition,
|
/* If there is a parameter of incomplete type in a definition,
|
this is an error. In a declaration this is valid, and a
|
this is an error. In a declaration this is valid, and a
|
struct or union type may be completed later, before any calls
|
struct or union type may be completed later, before any calls
|
or definition of the function. In the case where the tag was
|
or definition of the function. In the case where the tag was
|
first declared within the parameter list, a warning has
|
first declared within the parameter list, a warning has
|
already been given. If a parameter has void type, then
|
already been given. If a parameter has void type, then
|
however the function cannot be defined or called, so
|
however the function cannot be defined or called, so
|
warn. */
|
warn. */
|
|
|
for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
|
for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
|
parm;
|
parm;
|
parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
|
parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
|
{
|
{
|
type = TREE_VALUE (typelt);
|
type = TREE_VALUE (typelt);
|
if (type == error_mark_node)
|
if (type == error_mark_node)
|
continue;
|
continue;
|
|
|
if (!COMPLETE_TYPE_P (type))
|
if (!COMPLETE_TYPE_P (type))
|
{
|
{
|
if (funcdef_flag)
|
if (funcdef_flag)
|
{
|
{
|
if (DECL_NAME (parm))
|
if (DECL_NAME (parm))
|
error_at (input_location,
|
error_at (input_location,
|
"parameter %u (%q+D) has incomplete type",
|
"parameter %u (%q+D) has incomplete type",
|
parmno, parm);
|
parmno, parm);
|
else
|
else
|
error_at (DECL_SOURCE_LOCATION (parm),
|
error_at (DECL_SOURCE_LOCATION (parm),
|
"parameter %u has incomplete type",
|
"parameter %u has incomplete type",
|
parmno);
|
parmno);
|
|
|
TREE_VALUE (typelt) = error_mark_node;
|
TREE_VALUE (typelt) = error_mark_node;
|
TREE_TYPE (parm) = error_mark_node;
|
TREE_TYPE (parm) = error_mark_node;
|
arg_types = NULL_TREE;
|
arg_types = NULL_TREE;
|
}
|
}
|
else if (VOID_TYPE_P (type))
|
else if (VOID_TYPE_P (type))
|
{
|
{
|
if (DECL_NAME (parm))
|
if (DECL_NAME (parm))
|
warning_at (input_location, 0,
|
warning_at (input_location, 0,
|
"parameter %u (%q+D) has void type",
|
"parameter %u (%q+D) has void type",
|
parmno, parm);
|
parmno, parm);
|
else
|
else
|
warning_at (DECL_SOURCE_LOCATION (parm), 0,
|
warning_at (DECL_SOURCE_LOCATION (parm), 0,
|
"parameter %u has void type",
|
"parameter %u has void type",
|
parmno);
|
parmno);
|
}
|
}
|
}
|
}
|
|
|
errmsg = targetm.invalid_parameter_type (type);
|
errmsg = targetm.invalid_parameter_type (type);
|
if (errmsg)
|
if (errmsg)
|
{
|
{
|
error (errmsg);
|
error (errmsg);
|
TREE_VALUE (typelt) = error_mark_node;
|
TREE_VALUE (typelt) = error_mark_node;
|
TREE_TYPE (parm) = error_mark_node;
|
TREE_TYPE (parm) = error_mark_node;
|
arg_types = NULL_TREE;
|
arg_types = NULL_TREE;
|
}
|
}
|
|
|
if (DECL_NAME (parm) && TREE_USED (parm))
|
if (DECL_NAME (parm) && TREE_USED (parm))
|
warn_if_shadowing (parm);
|
warn_if_shadowing (parm);
|
}
|
}
|
return arg_types;
|
return arg_types;
|
}
|
}
|
}
|
}
|
|
|
/* Take apart the current scope and return a c_arg_info structure with
|
/* Take apart the current scope and return a c_arg_info structure with
|
info on a parameter list just parsed.
|
info on a parameter list just parsed.
|
|
|
This structure is later fed to 'grokparms' and 'store_parm_decls'.
|
This structure is later fed to 'grokparms' and 'store_parm_decls'.
|
|
|
ELLIPSIS being true means the argument list ended in '...' so don't
|
ELLIPSIS being true means the argument list ended in '...' so don't
|
append a sentinel (void_list_node) to the end of the type-list. */
|
append a sentinel (void_list_node) to the end of the type-list. */
|
|
|
struct c_arg_info *
|
struct c_arg_info *
|
get_parm_info (bool ellipsis)
|
get_parm_info (bool ellipsis)
|
{
|
{
|
struct c_binding *b = current_scope->bindings;
|
struct c_binding *b = current_scope->bindings;
|
struct c_arg_info *arg_info = XOBNEW (&parser_obstack,
|
struct c_arg_info *arg_info = XOBNEW (&parser_obstack,
|
struct c_arg_info);
|
struct c_arg_info);
|
tree parms = 0;
|
tree parms = 0;
|
tree tags = 0;
|
tree tags = 0;
|
tree types = 0;
|
tree types = 0;
|
tree others = 0;
|
tree others = 0;
|
|
|
static bool explained_incomplete_types = false;
|
static bool explained_incomplete_types = false;
|
bool gave_void_only_once_err = false;
|
bool gave_void_only_once_err = false;
|
|
|
arg_info->parms = 0;
|
arg_info->parms = 0;
|
arg_info->tags = 0;
|
arg_info->tags = 0;
|
arg_info->types = 0;
|
arg_info->types = 0;
|
arg_info->others = 0;
|
arg_info->others = 0;
|
arg_info->pending_sizes = 0;
|
arg_info->pending_sizes = 0;
|
arg_info->had_vla_unspec = current_scope->had_vla_unspec;
|
arg_info->had_vla_unspec = current_scope->had_vla_unspec;
|
|
|
/* The bindings in this scope must not get put into a block.
|
/* The bindings in this scope must not get put into a block.
|
We will take care of deleting the binding nodes. */
|
We will take care of deleting the binding nodes. */
|
current_scope->bindings = 0;
|
current_scope->bindings = 0;
|
|
|
/* This function is only called if there was *something* on the
|
/* This function is only called if there was *something* on the
|
parameter list. */
|
parameter list. */
|
gcc_assert (b);
|
gcc_assert (b);
|
|
|
/* A parameter list consisting solely of 'void' indicates that the
|
/* A parameter list consisting solely of 'void' indicates that the
|
function takes no arguments. But if the 'void' is qualified
|
function takes no arguments. But if the 'void' is qualified
|
(by 'const' or 'volatile'), or has a storage class specifier
|
(by 'const' or 'volatile'), or has a storage class specifier
|
('register'), then the behavior is undefined; issue an error.
|
('register'), then the behavior is undefined; issue an error.
|
Typedefs for 'void' are OK (see DR#157). */
|
Typedefs for 'void' are OK (see DR#157). */
|
if (b->prev == 0 /* one binding */
|
if (b->prev == 0 /* one binding */
|
&& TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
|
&& TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
|
&& !DECL_NAME (b->decl) /* anonymous */
|
&& !DECL_NAME (b->decl) /* anonymous */
|
&& VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
|
&& VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
|
{
|
{
|
if (TREE_THIS_VOLATILE (b->decl)
|
if (TREE_THIS_VOLATILE (b->decl)
|
|| TREE_READONLY (b->decl)
|
|| TREE_READONLY (b->decl)
|
|| C_DECL_REGISTER (b->decl))
|
|| C_DECL_REGISTER (b->decl))
|
error ("%<void%> as only parameter may not be qualified");
|
error ("%<void%> as only parameter may not be qualified");
|
|
|
/* There cannot be an ellipsis. */
|
/* There cannot be an ellipsis. */
|
if (ellipsis)
|
if (ellipsis)
|
error ("%<void%> must be the only parameter");
|
error ("%<void%> must be the only parameter");
|
|
|
arg_info->types = void_list_node;
|
arg_info->types = void_list_node;
|
return arg_info;
|
return arg_info;
|
}
|
}
|
|
|
if (!ellipsis)
|
if (!ellipsis)
|
types = void_list_node;
|
types = void_list_node;
|
|
|
/* Break up the bindings list into parms, tags, types, and others;
|
/* Break up the bindings list into parms, tags, types, and others;
|
apply sanity checks; purge the name-to-decl bindings. */
|
apply sanity checks; purge the name-to-decl bindings. */
|
while (b)
|
while (b)
|
{
|
{
|
tree decl = b->decl;
|
tree decl = b->decl;
|
tree type = TREE_TYPE (decl);
|
tree type = TREE_TYPE (decl);
|
const char *keyword;
|
const char *keyword;
|
|
|
switch (TREE_CODE (decl))
|
switch (TREE_CODE (decl))
|
{
|
{
|
case PARM_DECL:
|
case PARM_DECL:
|
if (b->id)
|
if (b->id)
|
{
|
{
|
gcc_assert (I_SYMBOL_BINDING (b->id) == b);
|
gcc_assert (I_SYMBOL_BINDING (b->id) == b);
|
I_SYMBOL_BINDING (b->id) = b->shadowed;
|
I_SYMBOL_BINDING (b->id) = b->shadowed;
|
}
|
}
|
|
|
/* Check for forward decls that never got their actual decl. */
|
/* Check for forward decls that never got their actual decl. */
|
if (TREE_ASM_WRITTEN (decl))
|
if (TREE_ASM_WRITTEN (decl))
|
error ("parameter %q+D has just a forward declaration", decl);
|
error ("parameter %q+D has just a forward declaration", decl);
|
/* Check for (..., void, ...) and issue an error. */
|
/* Check for (..., void, ...) and issue an error. */
|
else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
|
else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
|
{
|
{
|
if (!gave_void_only_once_err)
|
if (!gave_void_only_once_err)
|
{
|
{
|
error ("%<void%> must be the only parameter");
|
error ("%<void%> must be the only parameter");
|
gave_void_only_once_err = true;
|
gave_void_only_once_err = true;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Valid parameter, add it to the list. */
|
/* Valid parameter, add it to the list. */
|
TREE_CHAIN (decl) = parms;
|
TREE_CHAIN (decl) = parms;
|
parms = decl;
|
parms = decl;
|
|
|
/* Since there is a prototype, args are passed in their
|
/* Since there is a prototype, args are passed in their
|
declared types. The back end may override this later. */
|
declared types. The back end may override this later. */
|
DECL_ARG_TYPE (decl) = type;
|
DECL_ARG_TYPE (decl) = type;
|
types = tree_cons (0, type, types);
|
types = tree_cons (0, type, types);
|
}
|
}
|
break;
|
break;
|
|
|
case ENUMERAL_TYPE: keyword = "enum"; goto tag;
|
case ENUMERAL_TYPE: keyword = "enum"; goto tag;
|
case UNION_TYPE: keyword = "union"; goto tag;
|
case UNION_TYPE: keyword = "union"; goto tag;
|
case RECORD_TYPE: keyword = "struct"; goto tag;
|
case RECORD_TYPE: keyword = "struct"; goto tag;
|
tag:
|
tag:
|
/* Types may not have tag-names, in which case the type
|
/* Types may not have tag-names, in which case the type
|
appears in the bindings list with b->id NULL. */
|
appears in the bindings list with b->id NULL. */
|
if (b->id)
|
if (b->id)
|
{
|
{
|
gcc_assert (I_TAG_BINDING (b->id) == b);
|
gcc_assert (I_TAG_BINDING (b->id) == b);
|
I_TAG_BINDING (b->id) = b->shadowed;
|
I_TAG_BINDING (b->id) = b->shadowed;
|
}
|
}
|
|
|
/* Warn about any struct, union or enum tags defined in a
|
/* Warn about any struct, union or enum tags defined in a
|
parameter list. The scope of such types is limited to
|
parameter list. The scope of such types is limited to
|
the parameter list, which is rarely if ever desirable
|
the parameter list, which is rarely if ever desirable
|
(it's impossible to call such a function with type-
|
(it's impossible to call such a function with type-
|
correct arguments). An anonymous union parm type is
|
correct arguments). An anonymous union parm type is
|
meaningful as a GNU extension, so don't warn for that. */
|
meaningful as a GNU extension, so don't warn for that. */
|
if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
|
if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
|
{
|
{
|
if (b->id)
|
if (b->id)
|
/* The %s will be one of 'struct', 'union', or 'enum'. */
|
/* The %s will be one of 'struct', 'union', or 'enum'. */
|
warning (0, "%<%s %E%> declared inside parameter list",
|
warning (0, "%<%s %E%> declared inside parameter list",
|
keyword, b->id);
|
keyword, b->id);
|
else
|
else
|
/* The %s will be one of 'struct', 'union', or 'enum'. */
|
/* The %s will be one of 'struct', 'union', or 'enum'. */
|
warning (0, "anonymous %s declared inside parameter list",
|
warning (0, "anonymous %s declared inside parameter list",
|
keyword);
|
keyword);
|
|
|
if (!explained_incomplete_types)
|
if (!explained_incomplete_types)
|
{
|
{
|
warning (0, "its scope is only this definition or declaration,"
|
warning (0, "its scope is only this definition or declaration,"
|
" which is probably not what you want");
|
" which is probably not what you want");
|
explained_incomplete_types = true;
|
explained_incomplete_types = true;
|
}
|
}
|
}
|
}
|
|
|
tags = tree_cons (b->id, decl, tags);
|
tags = tree_cons (b->id, decl, tags);
|
break;
|
break;
|
|
|
case CONST_DECL:
|
case CONST_DECL:
|
case TYPE_DECL:
|
case TYPE_DECL:
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
/* CONST_DECLs appear here when we have an embedded enum,
|
/* CONST_DECLs appear here when we have an embedded enum,
|
and TYPE_DECLs appear here when we have an embedded struct
|
and TYPE_DECLs appear here when we have an embedded struct
|
or union. No warnings for this - we already warned about the
|
or union. No warnings for this - we already warned about the
|
type itself. FUNCTION_DECLs appear when there is an implicit
|
type itself. FUNCTION_DECLs appear when there is an implicit
|
function declaration in the parameter list. */
|
function declaration in the parameter list. */
|
|
|
/* When we reinsert this decl in the function body, we need
|
/* When we reinsert this decl in the function body, we need
|
to reconstruct whether it was marked as nested. */
|
to reconstruct whether it was marked as nested. */
|
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
|
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
|
? b->nested
|
? b->nested
|
: !b->nested);
|
: !b->nested);
|
TREE_CHAIN (decl) = others;
|
TREE_CHAIN (decl) = others;
|
others = decl;
|
others = decl;
|
/* fall through */
|
/* fall through */
|
|
|
case ERROR_MARK:
|
case ERROR_MARK:
|
/* error_mark_node appears here when we have an undeclared
|
/* error_mark_node appears here when we have an undeclared
|
variable. Just throw it away. */
|
variable. Just throw it away. */
|
if (b->id)
|
if (b->id)
|
{
|
{
|
gcc_assert (I_SYMBOL_BINDING (b->id) == b);
|
gcc_assert (I_SYMBOL_BINDING (b->id) == b);
|
I_SYMBOL_BINDING (b->id) = b->shadowed;
|
I_SYMBOL_BINDING (b->id) = b->shadowed;
|
}
|
}
|
break;
|
break;
|
|
|
/* Other things that might be encountered. */
|
/* Other things that might be encountered. */
|
case LABEL_DECL:
|
case LABEL_DECL:
|
case VAR_DECL:
|
case VAR_DECL:
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
b = free_binding_and_advance (b);
|
b = free_binding_and_advance (b);
|
}
|
}
|
|
|
arg_info->parms = parms;
|
arg_info->parms = parms;
|
arg_info->tags = tags;
|
arg_info->tags = tags;
|
arg_info->types = types;
|
arg_info->types = types;
|
arg_info->others = others;
|
arg_info->others = others;
|
arg_info->pending_sizes = get_pending_sizes ();
|
arg_info->pending_sizes = get_pending_sizes ();
|
return arg_info;
|
return arg_info;
|
}
|
}
|
|
|
/* Get the struct, enum or union (CODE says which) with tag NAME.
|
/* Get the struct, enum or union (CODE says which) with tag NAME.
|
Define the tag as a forward-reference with location LOC if it is
|
Define the tag as a forward-reference with location LOC if it is
|
not defined. Return a c_typespec structure for the type
|
not defined. Return a c_typespec structure for the type
|
specifier. */
|
specifier. */
|
|
|
struct c_typespec
|
struct c_typespec
|
parser_xref_tag (location_t loc, enum tree_code code, tree name)
|
parser_xref_tag (location_t loc, enum tree_code code, tree name)
|
{
|
{
|
struct c_typespec ret;
|
struct c_typespec ret;
|
tree ref;
|
tree ref;
|
location_t refloc;
|
location_t refloc;
|
|
|
ret.expr = NULL_TREE;
|
ret.expr = NULL_TREE;
|
ret.expr_const_operands = true;
|
ret.expr_const_operands = true;
|
|
|
/* If a cross reference is requested, look up the type
|
/* If a cross reference is requested, look up the type
|
already defined for this tag and return it. */
|
already defined for this tag and return it. */
|
|
|
ref = lookup_tag (code, name, 0, &refloc);
|
ref = lookup_tag (code, name, 0, &refloc);
|
/* If this is the right type of tag, return what we found.
|
/* If this is the right type of tag, return what we found.
|
(This reference will be shadowed by shadow_tag later if appropriate.)
|
(This reference will be shadowed by shadow_tag later if appropriate.)
|
If this is the wrong type of tag, do not return it. If it was the
|
If this is the wrong type of tag, do not return it. If it was the
|
wrong type in the same scope, we will have had an error
|
wrong type in the same scope, we will have had an error
|
message already; if in a different scope and declaring
|
message already; if in a different scope and declaring
|
a name, pending_xref_error will give an error message; but if in a
|
a name, pending_xref_error will give an error message; but if in a
|
different scope and not declaring a name, this tag should
|
different scope and not declaring a name, this tag should
|
shadow the previous declaration of a different type of tag, and
|
shadow the previous declaration of a different type of tag, and
|
this would not work properly if we return the reference found.
|
this would not work properly if we return the reference found.
|
(For example, with "struct foo" in an outer scope, "union foo;"
|
(For example, with "struct foo" in an outer scope, "union foo;"
|
must shadow that tag with a new one of union type.) */
|
must shadow that tag with a new one of union type.) */
|
ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
|
ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
|
if (ref && TREE_CODE (ref) == code)
|
if (ref && TREE_CODE (ref) == code)
|
{
|
{
|
if (C_TYPE_DEFINED_IN_STRUCT (ref)
|
if (C_TYPE_DEFINED_IN_STRUCT (ref)
|
&& loc != UNKNOWN_LOCATION
|
&& loc != UNKNOWN_LOCATION
|
&& warn_cxx_compat)
|
&& warn_cxx_compat)
|
{
|
{
|
switch (code)
|
switch (code)
|
{
|
{
|
case ENUMERAL_TYPE:
|
case ENUMERAL_TYPE:
|
warning_at (loc, OPT_Wc___compat,
|
warning_at (loc, OPT_Wc___compat,
|
("enum type defined in struct or union "
|
("enum type defined in struct or union "
|
"is not visible in C++"));
|
"is not visible in C++"));
|
inform (refloc, "enum type defined here");
|
inform (refloc, "enum type defined here");
|
break;
|
break;
|
case RECORD_TYPE:
|
case RECORD_TYPE:
|
warning_at (loc, OPT_Wc___compat,
|
warning_at (loc, OPT_Wc___compat,
|
("struct defined in struct or union "
|
("struct defined in struct or union "
|
"is not visible in C++"));
|
"is not visible in C++"));
|
inform (refloc, "struct defined here");
|
inform (refloc, "struct defined here");
|
break;
|
break;
|
case UNION_TYPE:
|
case UNION_TYPE:
|
warning_at (loc, OPT_Wc___compat,
|
warning_at (loc, OPT_Wc___compat,
|
("union defined in struct or union "
|
("union defined in struct or union "
|
"is not visible in C++"));
|
"is not visible in C++"));
|
inform (refloc, "union defined here");
|
inform (refloc, "union defined here");
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable();
|
gcc_unreachable();
|
}
|
}
|
}
|
}
|
|
|
ret.spec = ref;
|
ret.spec = ref;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* If no such tag is yet defined, create a forward-reference node
|
/* If no such tag is yet defined, create a forward-reference node
|
and record it as the "definition".
|
and record it as the "definition".
|
When a real declaration of this type is found,
|
When a real declaration of this type is found,
|
the forward-reference will be altered into a real type. */
|
the forward-reference will be altered into a real type. */
|
|
|
ref = make_node (code);
|
ref = make_node (code);
|
if (code == ENUMERAL_TYPE)
|
if (code == ENUMERAL_TYPE)
|
{
|
{
|
/* Give the type a default layout like unsigned int
|
/* Give the type a default layout like unsigned int
|
to avoid crashing if it does not get defined. */
|
to avoid crashing if it does not get defined. */
|
SET_TYPE_MODE (ref, TYPE_MODE (unsigned_type_node));
|
SET_TYPE_MODE (ref, TYPE_MODE (unsigned_type_node));
|
TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
|
TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
|
TYPE_USER_ALIGN (ref) = 0;
|
TYPE_USER_ALIGN (ref) = 0;
|
TYPE_UNSIGNED (ref) = 1;
|
TYPE_UNSIGNED (ref) = 1;
|
TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
|
TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
|
TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
|
TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
|
TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
|
TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
|
}
|
}
|
|
|
pushtag (loc, name, ref);
|
pushtag (loc, name, ref);
|
|
|
ret.spec = ref;
|
ret.spec = ref;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Get the struct, enum or union (CODE says which) with tag NAME.
|
/* Get the struct, enum or union (CODE says which) with tag NAME.
|
Define the tag as a forward-reference if it is not defined.
|
Define the tag as a forward-reference if it is not defined.
|
Return a tree for the type. */
|
Return a tree for the type. */
|
|
|
tree
|
tree
|
xref_tag (enum tree_code code, tree name)
|
xref_tag (enum tree_code code, tree name)
|
{
|
{
|
return parser_xref_tag (input_location, code, name).spec;
|
return parser_xref_tag (input_location, code, name).spec;
|
}
|
}
|
|
|
/* Make sure that the tag NAME is defined *in the current scope*
|
/* Make sure that the tag NAME is defined *in the current scope*
|
at least as a forward reference.
|
at least as a forward reference.
|
LOC is the location of the struct's definition.
|
LOC is the location of the struct's definition.
|
CODE says which kind of tag NAME ought to be.
|
CODE says which kind of tag NAME ought to be.
|
|
|
This stores the current value of the file static STRUCT_PARSE_INFO
|
This stores the current value of the file static STRUCT_PARSE_INFO
|
in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
|
in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
|
new c_struct_parse_info structure. The old value of
|
new c_struct_parse_info structure. The old value of
|
STRUCT_PARSE_INFO is restored in finish_struct. */
|
STRUCT_PARSE_INFO is restored in finish_struct. */
|
|
|
tree
|
tree
|
start_struct (location_t loc, enum tree_code code, tree name,
|
start_struct (location_t loc, enum tree_code code, tree name,
|
struct c_struct_parse_info **enclosing_struct_parse_info)
|
struct c_struct_parse_info **enclosing_struct_parse_info)
|
{
|
{
|
/* If there is already a tag defined at this scope
|
/* If there is already a tag defined at this scope
|
(as a forward reference), just return it. */
|
(as a forward reference), just return it. */
|
|
|
tree ref = NULL_TREE;
|
tree ref = NULL_TREE;
|
location_t refloc = UNKNOWN_LOCATION;
|
location_t refloc = UNKNOWN_LOCATION;
|
|
|
if (name != NULL_TREE)
|
if (name != NULL_TREE)
|
ref = lookup_tag (code, name, 1, &refloc);
|
ref = lookup_tag (code, name, 1, &refloc);
|
if (ref && TREE_CODE (ref) == code)
|
if (ref && TREE_CODE (ref) == code)
|
{
|
{
|
if (TYPE_SIZE (ref))
|
if (TYPE_SIZE (ref))
|
{
|
{
|
if (code == UNION_TYPE)
|
if (code == UNION_TYPE)
|
error_at (loc, "redefinition of %<union %E%>", name);
|
error_at (loc, "redefinition of %<union %E%>", name);
|
else
|
else
|
error_at (loc, "redefinition of %<struct %E%>", name);
|
error_at (loc, "redefinition of %<struct %E%>", name);
|
if (refloc != UNKNOWN_LOCATION)
|
if (refloc != UNKNOWN_LOCATION)
|
inform (refloc, "originally defined here");
|
inform (refloc, "originally defined here");
|
/* Don't create structures using a name already in use. */
|
/* Don't create structures using a name already in use. */
|
ref = NULL_TREE;
|
ref = NULL_TREE;
|
}
|
}
|
else if (C_TYPE_BEING_DEFINED (ref))
|
else if (C_TYPE_BEING_DEFINED (ref))
|
{
|
{
|
if (code == UNION_TYPE)
|
if (code == UNION_TYPE)
|
error_at (loc, "nested redefinition of %<union %E%>", name);
|
error_at (loc, "nested redefinition of %<union %E%>", name);
|
else
|
else
|
error_at (loc, "nested redefinition of %<struct %E%>", name);
|
error_at (loc, "nested redefinition of %<struct %E%>", name);
|
/* Don't bother to report "originally defined here" for a
|
/* Don't bother to report "originally defined here" for a
|
nested redefinition; the original definition should be
|
nested redefinition; the original definition should be
|
obvious. */
|
obvious. */
|
/* Don't create structures that contain themselves. */
|
/* Don't create structures that contain themselves. */
|
ref = NULL_TREE;
|
ref = NULL_TREE;
|
}
|
}
|
}
|
}
|
|
|
/* Otherwise create a forward-reference just so the tag is in scope. */
|
/* Otherwise create a forward-reference just so the tag is in scope. */
|
|
|
if (ref == NULL_TREE || TREE_CODE (ref) != code)
|
if (ref == NULL_TREE || TREE_CODE (ref) != code)
|
{
|
{
|
ref = make_node (code);
|
ref = make_node (code);
|
pushtag (loc, name, ref);
|
pushtag (loc, name, ref);
|
}
|
}
|
|
|
C_TYPE_BEING_DEFINED (ref) = 1;
|
C_TYPE_BEING_DEFINED (ref) = 1;
|
TYPE_PACKED (ref) = flag_pack_struct;
|
TYPE_PACKED (ref) = flag_pack_struct;
|
|
|
*enclosing_struct_parse_info = struct_parse_info;
|
*enclosing_struct_parse_info = struct_parse_info;
|
struct_parse_info = XNEW (struct c_struct_parse_info);
|
struct_parse_info = XNEW (struct c_struct_parse_info);
|
struct_parse_info->struct_types = VEC_alloc (tree, heap, 0);
|
struct_parse_info->struct_types = VEC_alloc (tree, heap, 0);
|
struct_parse_info->fields = VEC_alloc (c_binding_ptr, heap, 0);
|
struct_parse_info->fields = VEC_alloc (c_binding_ptr, heap, 0);
|
struct_parse_info->typedefs_seen = VEC_alloc (tree, heap, 0);
|
struct_parse_info->typedefs_seen = VEC_alloc (tree, heap, 0);
|
|
|
/* FIXME: This will issue a warning for a use of a type defined
|
/* FIXME: This will issue a warning for a use of a type defined
|
within a statement expr used within sizeof, et. al. This is not
|
within a statement expr used within sizeof, et. al. This is not
|
terribly serious as C++ doesn't permit statement exprs within
|
terribly serious as C++ doesn't permit statement exprs within
|
sizeof anyhow. */
|
sizeof anyhow. */
|
if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
|
if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
|
warning_at (loc, OPT_Wc___compat,
|
warning_at (loc, OPT_Wc___compat,
|
"defining type in %qs expression is invalid in C++",
|
"defining type in %qs expression is invalid in C++",
|
(in_sizeof
|
(in_sizeof
|
? "sizeof"
|
? "sizeof"
|
: (in_typeof ? "typeof" : "alignof")));
|
: (in_typeof ? "typeof" : "alignof")));
|
|
|
return ref;
|
return ref;
|
}
|
}
|
|
|
/* Process the specs, declarator and width (NULL if omitted)
|
/* Process the specs, declarator and width (NULL if omitted)
|
of a structure component, returning a FIELD_DECL node.
|
of a structure component, returning a FIELD_DECL node.
|
WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
|
WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
|
DECL_ATTRS is as for grokdeclarator.
|
DECL_ATTRS is as for grokdeclarator.
|
|
|
LOC is the location of the structure component.
|
LOC is the location of the structure component.
|
|
|
This is done during the parsing of the struct declaration.
|
This is done during the parsing of the struct declaration.
|
The FIELD_DECL nodes are chained together and the lot of them
|
The FIELD_DECL nodes are chained together and the lot of them
|
are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
|
are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
|
|
|
tree
|
tree
|
grokfield (location_t loc,
|
grokfield (location_t loc,
|
struct c_declarator *declarator, struct c_declspecs *declspecs,
|
struct c_declarator *declarator, struct c_declspecs *declspecs,
|
tree width, tree *decl_attrs)
|
tree width, tree *decl_attrs)
|
{
|
{
|
tree value;
|
tree value;
|
|
|
if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
|
if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
|
&& width == NULL_TREE)
|
&& width == NULL_TREE)
|
{
|
{
|
/* This is an unnamed decl.
|
/* This is an unnamed decl.
|
|
|
If we have something of the form "union { list } ;" then this
|
If we have something of the form "union { list } ;" then this
|
is the anonymous union extension. Similarly for struct.
|
is the anonymous union extension. Similarly for struct.
|
|
|
If this is something of the form "struct foo;", then
|
If this is something of the form "struct foo;", then
|
If MS extensions are enabled, this is handled as an
|
If MS extensions are enabled, this is handled as an
|
anonymous struct.
|
anonymous struct.
|
Otherwise this is a forward declaration of a structure tag.
|
Otherwise this is a forward declaration of a structure tag.
|
|
|
If this is something of the form "foo;" and foo is a TYPE_DECL, then
|
If this is something of the form "foo;" and foo is a TYPE_DECL, then
|
If MS extensions are enabled and foo names a structure, then
|
If MS extensions are enabled and foo names a structure, then
|
again this is an anonymous struct.
|
again this is an anonymous struct.
|
Otherwise this is an error.
|
Otherwise this is an error.
|
|
|
Oh what a horrid tangled web we weave. I wonder if MS consciously
|
Oh what a horrid tangled web we weave. I wonder if MS consciously
|
took this from Plan 9 or if it was an accident of implementation
|
took this from Plan 9 or if it was an accident of implementation
|
that took root before someone noticed the bug... */
|
that took root before someone noticed the bug... */
|
|
|
tree type = declspecs->type;
|
tree type = declspecs->type;
|
bool type_ok = (TREE_CODE (type) == RECORD_TYPE
|
bool type_ok = (TREE_CODE (type) == RECORD_TYPE
|
|| TREE_CODE (type) == UNION_TYPE);
|
|| TREE_CODE (type) == UNION_TYPE);
|
bool ok = false;
|
bool ok = false;
|
|
|
if (type_ok
|
if (type_ok
|
&& (flag_ms_extensions || !declspecs->typedef_p))
|
&& (flag_ms_extensions || !declspecs->typedef_p))
|
{
|
{
|
if (flag_ms_extensions)
|
if (flag_ms_extensions)
|
ok = true;
|
ok = true;
|
else if (flag_iso)
|
else if (flag_iso)
|
ok = false;
|
ok = false;
|
else if (TYPE_NAME (type) == NULL)
|
else if (TYPE_NAME (type) == NULL)
|
ok = true;
|
ok = true;
|
else
|
else
|
ok = false;
|
ok = false;
|
}
|
}
|
if (!ok)
|
if (!ok)
|
{
|
{
|
pedwarn (loc, 0, "declaration does not declare anything");
|
pedwarn (loc, 0, "declaration does not declare anything");
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
pedwarn (loc, OPT_pedantic, "ISO C doesn%'t support unnamed structs/unions");
|
pedwarn (loc, OPT_pedantic, "ISO C doesn%'t support unnamed structs/unions");
|
}
|
}
|
|
|
value = grokdeclarator (declarator, declspecs, FIELD, false,
|
value = grokdeclarator (declarator, declspecs, FIELD, false,
|
width ? &width : NULL, decl_attrs, NULL, NULL,
|
width ? &width : NULL, decl_attrs, NULL, NULL,
|
DEPRECATED_NORMAL);
|
DEPRECATED_NORMAL);
|
|
|
finish_decl (value, loc, NULL_TREE, NULL_TREE, NULL_TREE);
|
finish_decl (value, loc, NULL_TREE, NULL_TREE, NULL_TREE);
|
DECL_INITIAL (value) = width;
|
DECL_INITIAL (value) = width;
|
|
|
if (warn_cxx_compat && DECL_NAME (value) != NULL_TREE)
|
if (warn_cxx_compat && DECL_NAME (value) != NULL_TREE)
|
{
|
{
|
/* If we currently have a binding for this field, set the
|
/* If we currently have a binding for this field, set the
|
in_struct field in the binding, so that we warn about lookups
|
in_struct field in the binding, so that we warn about lookups
|
which find it. */
|
which find it. */
|
struct c_binding *b = I_SYMBOL_BINDING (DECL_NAME (value));
|
struct c_binding *b = I_SYMBOL_BINDING (DECL_NAME (value));
|
if (b != NULL)
|
if (b != NULL)
|
{
|
{
|
/* If the in_struct field is not yet set, push it on a list
|
/* If the in_struct field is not yet set, push it on a list
|
to be cleared when this struct is finished. */
|
to be cleared when this struct is finished. */
|
if (!b->in_struct)
|
if (!b->in_struct)
|
{
|
{
|
VEC_safe_push (c_binding_ptr, heap,
|
VEC_safe_push (c_binding_ptr, heap,
|
struct_parse_info->fields, b);
|
struct_parse_info->fields, b);
|
b->in_struct = 1;
|
b->in_struct = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
return value;
|
return value;
|
}
|
}
|
|
|
/* Generate an error for any duplicate field names in FIELDLIST. Munge
|
/* Generate an error for any duplicate field names in FIELDLIST. Munge
|
the list such that this does not present a problem later. */
|
the list such that this does not present a problem later. */
|
|
|
static void
|
static void
|
detect_field_duplicates (tree fieldlist)
|
detect_field_duplicates (tree fieldlist)
|
{
|
{
|
tree x, y;
|
tree x, y;
|
int timeout = 10;
|
int timeout = 10;
|
|
|
/* First, see if there are more than "a few" fields.
|
/* First, see if there are more than "a few" fields.
|
This is trivially true if there are zero or one fields. */
|
This is trivially true if there are zero or one fields. */
|
if (!fieldlist)
|
if (!fieldlist)
|
return;
|
return;
|
x = TREE_CHAIN (fieldlist);
|
x = TREE_CHAIN (fieldlist);
|
if (!x)
|
if (!x)
|
return;
|
return;
|
do {
|
do {
|
timeout--;
|
timeout--;
|
x = TREE_CHAIN (x);
|
x = TREE_CHAIN (x);
|
} while (timeout > 0 && x);
|
} while (timeout > 0 && x);
|
|
|
/* If there were "few" fields, avoid the overhead of allocating
|
/* If there were "few" fields, avoid the overhead of allocating
|
a hash table. Instead just do the nested traversal thing. */
|
a hash table. Instead just do the nested traversal thing. */
|
if (timeout > 0)
|
if (timeout > 0)
|
{
|
{
|
for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
|
for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
|
if (DECL_NAME (x))
|
if (DECL_NAME (x))
|
{
|
{
|
for (y = fieldlist; y != x; y = TREE_CHAIN (y))
|
for (y = fieldlist; y != x; y = TREE_CHAIN (y))
|
if (DECL_NAME (y) == DECL_NAME (x))
|
if (DECL_NAME (y) == DECL_NAME (x))
|
{
|
{
|
error ("duplicate member %q+D", x);
|
error ("duplicate member %q+D", x);
|
DECL_NAME (x) = NULL_TREE;
|
DECL_NAME (x) = NULL_TREE;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
|
htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
|
void **slot;
|
void **slot;
|
|
|
for (x = fieldlist; x ; x = TREE_CHAIN (x))
|
for (x = fieldlist; x ; x = TREE_CHAIN (x))
|
if ((y = DECL_NAME (x)) != 0)
|
if ((y = DECL_NAME (x)) != 0)
|
{
|
{
|
slot = htab_find_slot (htab, y, INSERT);
|
slot = htab_find_slot (htab, y, INSERT);
|
if (*slot)
|
if (*slot)
|
{
|
{
|
error ("duplicate member %q+D", x);
|
error ("duplicate member %q+D", x);
|
DECL_NAME (x) = NULL_TREE;
|
DECL_NAME (x) = NULL_TREE;
|
}
|
}
|
*slot = y;
|
*slot = y;
|
}
|
}
|
|
|
htab_delete (htab);
|
htab_delete (htab);
|
}
|
}
|
}
|
}
|
|
|
/* Finish up struct info used by -Wc++-compat. */
|
/* Finish up struct info used by -Wc++-compat. */
|
|
|
static void
|
static void
|
warn_cxx_compat_finish_struct (tree fieldlist)
|
warn_cxx_compat_finish_struct (tree fieldlist)
|
{
|
{
|
unsigned int ix;
|
unsigned int ix;
|
tree x;
|
tree x;
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
/* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
|
/* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
|
the current struct. We do this now at the end of the struct
|
the current struct. We do this now at the end of the struct
|
because the flag is used to issue visibility warnings, and we
|
because the flag is used to issue visibility warnings, and we
|
only want to issue those warnings if the type is referenced
|
only want to issue those warnings if the type is referenced
|
outside of the struct declaration. */
|
outside of the struct declaration. */
|
for (ix = 0; VEC_iterate (tree, struct_parse_info->struct_types, ix, x); ++ix)
|
for (ix = 0; VEC_iterate (tree, struct_parse_info->struct_types, ix, x); ++ix)
|
C_TYPE_DEFINED_IN_STRUCT (x) = 1;
|
C_TYPE_DEFINED_IN_STRUCT (x) = 1;
|
|
|
/* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
|
/* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
|
typedefs used when declaring fields in this struct. If the name
|
typedefs used when declaring fields in this struct. If the name
|
of any of the fields is also a typedef name then the struct would
|
of any of the fields is also a typedef name then the struct would
|
not parse in C++, because the C++ lookup rules say that the
|
not parse in C++, because the C++ lookup rules say that the
|
typedef name would be looked up in the context of the struct, and
|
typedef name would be looked up in the context of the struct, and
|
would thus be the field rather than the typedef. */
|
would thus be the field rather than the typedef. */
|
if (!VEC_empty (tree, struct_parse_info->typedefs_seen)
|
if (!VEC_empty (tree, struct_parse_info->typedefs_seen)
|
&& fieldlist != NULL_TREE)
|
&& fieldlist != NULL_TREE)
|
{
|
{
|
/* Use a pointer_set using the name of the typedef. We can use
|
/* Use a pointer_set using the name of the typedef. We can use
|
a pointer_set because identifiers are interned. */
|
a pointer_set because identifiers are interned. */
|
struct pointer_set_t *tset = pointer_set_create ();
|
struct pointer_set_t *tset = pointer_set_create ();
|
|
|
for (ix = 0;
|
for (ix = 0;
|
VEC_iterate (tree, struct_parse_info->typedefs_seen, ix, x);
|
VEC_iterate (tree, struct_parse_info->typedefs_seen, ix, x);
|
++ix)
|
++ix)
|
pointer_set_insert (tset, DECL_NAME (x));
|
pointer_set_insert (tset, DECL_NAME (x));
|
|
|
for (x = fieldlist; x != NULL_TREE; x = TREE_CHAIN (x))
|
for (x = fieldlist; x != NULL_TREE; x = TREE_CHAIN (x))
|
{
|
{
|
if (pointer_set_contains (tset, DECL_NAME (x)))
|
if (pointer_set_contains (tset, DECL_NAME (x)))
|
{
|
{
|
warning_at (DECL_SOURCE_LOCATION (x), OPT_Wc___compat,
|
warning_at (DECL_SOURCE_LOCATION (x), OPT_Wc___compat,
|
("using %qD as both field and typedef name is "
|
("using %qD as both field and typedef name is "
|
"invalid in C++"),
|
"invalid in C++"),
|
x);
|
x);
|
/* FIXME: It would be nice to report the location where
|
/* FIXME: It would be nice to report the location where
|
the typedef name is used. */
|
the typedef name is used. */
|
}
|
}
|
}
|
}
|
|
|
pointer_set_destroy (tset);
|
pointer_set_destroy (tset);
|
}
|
}
|
|
|
/* For each field which has a binding and which was not defined in
|
/* For each field which has a binding and which was not defined in
|
an enclosing struct, clear the in_struct field. */
|
an enclosing struct, clear the in_struct field. */
|
for (ix = 0;
|
for (ix = 0;
|
VEC_iterate (c_binding_ptr, struct_parse_info->fields, ix, b);
|
VEC_iterate (c_binding_ptr, struct_parse_info->fields, ix, b);
|
++ix)
|
++ix)
|
b->in_struct = 0;
|
b->in_struct = 0;
|
}
|
}
|
|
|
/* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
|
/* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
|
LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
|
LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
|
FIELDLIST is a chain of FIELD_DECL nodes for the fields.
|
FIELDLIST is a chain of FIELD_DECL nodes for the fields.
|
ATTRIBUTES are attributes to be applied to the structure.
|
ATTRIBUTES are attributes to be applied to the structure.
|
|
|
ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
|
ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
|
the struct was started. */
|
the struct was started. */
|
|
|
tree
|
tree
|
finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
|
finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
|
struct c_struct_parse_info *enclosing_struct_parse_info)
|
struct c_struct_parse_info *enclosing_struct_parse_info)
|
{
|
{
|
tree x;
|
tree x;
|
bool toplevel = file_scope == current_scope;
|
bool toplevel = file_scope == current_scope;
|
int saw_named_field;
|
int saw_named_field;
|
|
|
/* If this type was previously laid out as a forward reference,
|
/* If this type was previously laid out as a forward reference,
|
make sure we lay it out again. */
|
make sure we lay it out again. */
|
|
|
TYPE_SIZE (t) = 0;
|
TYPE_SIZE (t) = 0;
|
|
|
decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
|
decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
|
|
|
if (pedantic)
|
if (pedantic)
|
{
|
{
|
for (x = fieldlist; x; x = TREE_CHAIN (x))
|
for (x = fieldlist; x; x = TREE_CHAIN (x))
|
if (DECL_NAME (x) != 0)
|
if (DECL_NAME (x) != 0)
|
break;
|
break;
|
|
|
if (x == 0)
|
if (x == 0)
|
{
|
{
|
if (TREE_CODE (t) == UNION_TYPE)
|
if (TREE_CODE (t) == UNION_TYPE)
|
{
|
{
|
if (fieldlist)
|
if (fieldlist)
|
pedwarn (loc, OPT_pedantic, "union has no named members");
|
pedwarn (loc, OPT_pedantic, "union has no named members");
|
else
|
else
|
pedwarn (loc, OPT_pedantic, "union has no members");
|
pedwarn (loc, OPT_pedantic, "union has no members");
|
}
|
}
|
else
|
else
|
{
|
{
|
if (fieldlist)
|
if (fieldlist)
|
pedwarn (loc, OPT_pedantic, "struct has no named members");
|
pedwarn (loc, OPT_pedantic, "struct has no named members");
|
else
|
else
|
pedwarn (loc, OPT_pedantic, "struct has no members");
|
pedwarn (loc, OPT_pedantic, "struct has no members");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Install struct as DECL_CONTEXT of each field decl.
|
/* Install struct as DECL_CONTEXT of each field decl.
|
Also process specified field sizes, found in the DECL_INITIAL,
|
Also process specified field sizes, found in the DECL_INITIAL,
|
storing 0 there after the type has been changed to precision equal
|
storing 0 there after the type has been changed to precision equal
|
to its width, rather than the precision of the specified standard
|
to its width, rather than the precision of the specified standard
|
type. (Correct layout requires the original type to have been preserved
|
type. (Correct layout requires the original type to have been preserved
|
until now.) */
|
until now.) */
|
|
|
saw_named_field = 0;
|
saw_named_field = 0;
|
for (x = fieldlist; x; x = TREE_CHAIN (x))
|
for (x = fieldlist; x; x = TREE_CHAIN (x))
|
{
|
{
|
if (TREE_TYPE (x) == error_mark_node)
|
if (TREE_TYPE (x) == error_mark_node)
|
continue;
|
continue;
|
|
|
DECL_CONTEXT (x) = t;
|
DECL_CONTEXT (x) = t;
|
|
|
/* If any field is const, the structure type is pseudo-const. */
|
/* If any field is const, the structure type is pseudo-const. */
|
if (TREE_READONLY (x))
|
if (TREE_READONLY (x))
|
C_TYPE_FIELDS_READONLY (t) = 1;
|
C_TYPE_FIELDS_READONLY (t) = 1;
|
else
|
else
|
{
|
{
|
/* A field that is pseudo-const makes the structure likewise. */
|
/* A field that is pseudo-const makes the structure likewise. */
|
tree t1 = TREE_TYPE (x);
|
tree t1 = TREE_TYPE (x);
|
while (TREE_CODE (t1) == ARRAY_TYPE)
|
while (TREE_CODE (t1) == ARRAY_TYPE)
|
t1 = TREE_TYPE (t1);
|
t1 = TREE_TYPE (t1);
|
if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
|
if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
|
&& C_TYPE_FIELDS_READONLY (t1))
|
&& C_TYPE_FIELDS_READONLY (t1))
|
C_TYPE_FIELDS_READONLY (t) = 1;
|
C_TYPE_FIELDS_READONLY (t) = 1;
|
}
|
}
|
|
|
/* Any field that is volatile means variables of this type must be
|
/* Any field that is volatile means variables of this type must be
|
treated in some ways as volatile. */
|
treated in some ways as volatile. */
|
if (TREE_THIS_VOLATILE (x))
|
if (TREE_THIS_VOLATILE (x))
|
C_TYPE_FIELDS_VOLATILE (t) = 1;
|
C_TYPE_FIELDS_VOLATILE (t) = 1;
|
|
|
/* Any field of nominal variable size implies structure is too. */
|
/* Any field of nominal variable size implies structure is too. */
|
if (C_DECL_VARIABLE_SIZE (x))
|
if (C_DECL_VARIABLE_SIZE (x))
|
C_TYPE_VARIABLE_SIZE (t) = 1;
|
C_TYPE_VARIABLE_SIZE (t) = 1;
|
|
|
if (DECL_INITIAL (x))
|
if (DECL_INITIAL (x))
|
{
|
{
|
unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
|
unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
|
DECL_SIZE (x) = bitsize_int (width);
|
DECL_SIZE (x) = bitsize_int (width);
|
DECL_BIT_FIELD (x) = 1;
|
DECL_BIT_FIELD (x) = 1;
|
SET_DECL_C_BIT_FIELD (x);
|
SET_DECL_C_BIT_FIELD (x);
|
}
|
}
|
|
|
if (TYPE_PACKED (t)
|
if (TYPE_PACKED (t)
|
&& (DECL_BIT_FIELD (x)
|
&& (DECL_BIT_FIELD (x)
|
|| TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT))
|
|| TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT))
|
DECL_PACKED (x) = 1;
|
DECL_PACKED (x) = 1;
|
|
|
/* Detect flexible array member in an invalid context. */
|
/* Detect flexible array member in an invalid context. */
|
if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
|
if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
|
&& TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
|
&& TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
|
&& TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
|
&& TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
|
&& TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
|
&& TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
|
{
|
{
|
if (TREE_CODE (t) == UNION_TYPE)
|
if (TREE_CODE (t) == UNION_TYPE)
|
{
|
{
|
error_at (DECL_SOURCE_LOCATION (x),
|
error_at (DECL_SOURCE_LOCATION (x),
|
"flexible array member in union");
|
"flexible array member in union");
|
TREE_TYPE (x) = error_mark_node;
|
TREE_TYPE (x) = error_mark_node;
|
}
|
}
|
else if (TREE_CHAIN (x) != NULL_TREE)
|
else if (TREE_CHAIN (x) != NULL_TREE)
|
{
|
{
|
error_at (DECL_SOURCE_LOCATION (x),
|
error_at (DECL_SOURCE_LOCATION (x),
|
"flexible array member not at end of struct");
|
"flexible array member not at end of struct");
|
TREE_TYPE (x) = error_mark_node;
|
TREE_TYPE (x) = error_mark_node;
|
}
|
}
|
else if (!saw_named_field)
|
else if (!saw_named_field)
|
{
|
{
|
error_at (DECL_SOURCE_LOCATION (x),
|
error_at (DECL_SOURCE_LOCATION (x),
|
"flexible array member in otherwise empty struct");
|
"flexible array member in otherwise empty struct");
|
TREE_TYPE (x) = error_mark_node;
|
TREE_TYPE (x) = error_mark_node;
|
}
|
}
|
}
|
}
|
|
|
if (pedantic && TREE_CODE (t) == RECORD_TYPE
|
if (pedantic && TREE_CODE (t) == RECORD_TYPE
|
&& flexible_array_type_p (TREE_TYPE (x)))
|
&& flexible_array_type_p (TREE_TYPE (x)))
|
pedwarn (DECL_SOURCE_LOCATION (x), OPT_pedantic,
|
pedwarn (DECL_SOURCE_LOCATION (x), OPT_pedantic,
|
"invalid use of structure with flexible array member");
|
"invalid use of structure with flexible array member");
|
|
|
if (DECL_NAME (x))
|
if (DECL_NAME (x))
|
saw_named_field = 1;
|
saw_named_field = 1;
|
}
|
}
|
|
|
detect_field_duplicates (fieldlist);
|
detect_field_duplicates (fieldlist);
|
|
|
/* Now we have the nearly final fieldlist. Record it,
|
/* Now we have the nearly final fieldlist. Record it,
|
then lay out the structure or union (including the fields). */
|
then lay out the structure or union (including the fields). */
|
|
|
TYPE_FIELDS (t) = fieldlist;
|
TYPE_FIELDS (t) = fieldlist;
|
|
|
layout_type (t);
|
layout_type (t);
|
|
|
/* Give bit-fields their proper types. */
|
/* Give bit-fields their proper types. */
|
{
|
{
|
tree *fieldlistp = &fieldlist;
|
tree *fieldlistp = &fieldlist;
|
while (*fieldlistp)
|
while (*fieldlistp)
|
if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
|
if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
|
&& TREE_TYPE (*fieldlistp) != error_mark_node)
|
&& TREE_TYPE (*fieldlistp) != error_mark_node)
|
{
|
{
|
unsigned HOST_WIDE_INT width
|
unsigned HOST_WIDE_INT width
|
= tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
|
= tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
|
tree type = TREE_TYPE (*fieldlistp);
|
tree type = TREE_TYPE (*fieldlistp);
|
if (width != TYPE_PRECISION (type))
|
if (width != TYPE_PRECISION (type))
|
{
|
{
|
TREE_TYPE (*fieldlistp)
|
TREE_TYPE (*fieldlistp)
|
= c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
|
= c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
|
DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
|
DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
|
}
|
}
|
DECL_INITIAL (*fieldlistp) = 0;
|
DECL_INITIAL (*fieldlistp) = 0;
|
}
|
}
|
else
|
else
|
fieldlistp = &TREE_CHAIN (*fieldlistp);
|
fieldlistp = &TREE_CHAIN (*fieldlistp);
|
}
|
}
|
|
|
/* Now we have the truly final field list.
|
/* Now we have the truly final field list.
|
Store it in this type and in the variants. */
|
Store it in this type and in the variants. */
|
|
|
TYPE_FIELDS (t) = fieldlist;
|
TYPE_FIELDS (t) = fieldlist;
|
|
|
/* If there are lots of fields, sort so we can look through them fast.
|
/* If there are lots of fields, sort so we can look through them fast.
|
We arbitrarily consider 16 or more elts to be "a lot". */
|
We arbitrarily consider 16 or more elts to be "a lot". */
|
|
|
{
|
{
|
int len = 0;
|
int len = 0;
|
|
|
for (x = fieldlist; x; x = TREE_CHAIN (x))
|
for (x = fieldlist; x; x = TREE_CHAIN (x))
|
{
|
{
|
if (len > 15 || DECL_NAME (x) == NULL)
|
if (len > 15 || DECL_NAME (x) == NULL)
|
break;
|
break;
|
len += 1;
|
len += 1;
|
}
|
}
|
|
|
if (len > 15)
|
if (len > 15)
|
{
|
{
|
tree *field_array;
|
tree *field_array;
|
struct lang_type *space;
|
struct lang_type *space;
|
struct sorted_fields_type *space2;
|
struct sorted_fields_type *space2;
|
|
|
len += list_length (x);
|
len += list_length (x);
|
|
|
/* Use the same allocation policy here that make_node uses, to
|
/* Use the same allocation policy here that make_node uses, to
|
ensure that this lives as long as the rest of the struct decl.
|
ensure that this lives as long as the rest of the struct decl.
|
All decls in an inline function need to be saved. */
|
All decls in an inline function need to be saved. */
|
|
|
space = GGC_CNEW (struct lang_type);
|
space = GGC_CNEW (struct lang_type);
|
space2 = GGC_NEWVAR (struct sorted_fields_type,
|
space2 = GGC_NEWVAR (struct sorted_fields_type,
|
sizeof (struct sorted_fields_type) + len * sizeof (tree));
|
sizeof (struct sorted_fields_type) + len * sizeof (tree));
|
|
|
len = 0;
|
len = 0;
|
space->s = space2;
|
space->s = space2;
|
field_array = &space2->elts[0];
|
field_array = &space2->elts[0];
|
for (x = fieldlist; x; x = TREE_CHAIN (x))
|
for (x = fieldlist; x; x = TREE_CHAIN (x))
|
{
|
{
|
field_array[len++] = x;
|
field_array[len++] = x;
|
|
|
/* If there is anonymous struct or union, break out of the loop. */
|
/* If there is anonymous struct or union, break out of the loop. */
|
if (DECL_NAME (x) == NULL)
|
if (DECL_NAME (x) == NULL)
|
break;
|
break;
|
}
|
}
|
/* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
|
/* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
|
if (x == NULL)
|
if (x == NULL)
|
{
|
{
|
TYPE_LANG_SPECIFIC (t) = space;
|
TYPE_LANG_SPECIFIC (t) = space;
|
TYPE_LANG_SPECIFIC (t)->s->len = len;
|
TYPE_LANG_SPECIFIC (t)->s->len = len;
|
field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
|
field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
|
qsort (field_array, len, sizeof (tree), field_decl_cmp);
|
qsort (field_array, len, sizeof (tree), field_decl_cmp);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
|
for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
|
{
|
{
|
TYPE_FIELDS (x) = TYPE_FIELDS (t);
|
TYPE_FIELDS (x) = TYPE_FIELDS (t);
|
TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
|
TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
|
C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
|
C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
|
C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
|
C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
|
C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
|
C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
|
}
|
}
|
|
|
/* If this was supposed to be a transparent union, but we can't
|
/* If this was supposed to be a transparent union, but we can't
|
make it one, warn and turn off the flag. */
|
make it one, warn and turn off the flag. */
|
if (TREE_CODE (t) == UNION_TYPE
|
if (TREE_CODE (t) == UNION_TYPE
|
&& TYPE_TRANSPARENT_AGGR (t)
|
&& TYPE_TRANSPARENT_AGGR (t)
|
&& (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
|
&& (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
|
{
|
{
|
TYPE_TRANSPARENT_AGGR (t) = 0;
|
TYPE_TRANSPARENT_AGGR (t) = 0;
|
warning_at (loc, 0, "union cannot be made transparent");
|
warning_at (loc, 0, "union cannot be made transparent");
|
}
|
}
|
|
|
/* If this structure or union completes the type of any previous
|
/* If this structure or union completes the type of any previous
|
variable declaration, lay it out and output its rtl. */
|
variable declaration, lay it out and output its rtl. */
|
for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
|
for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
|
x;
|
x;
|
x = TREE_CHAIN (x))
|
x = TREE_CHAIN (x))
|
{
|
{
|
tree decl = TREE_VALUE (x);
|
tree decl = TREE_VALUE (x);
|
if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
|
if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
|
layout_array_type (TREE_TYPE (decl));
|
layout_array_type (TREE_TYPE (decl));
|
if (TREE_CODE (decl) != TYPE_DECL)
|
if (TREE_CODE (decl) != TYPE_DECL)
|
{
|
{
|
layout_decl (decl, 0);
|
layout_decl (decl, 0);
|
if (c_dialect_objc ())
|
if (c_dialect_objc ())
|
objc_check_decl (decl);
|
objc_check_decl (decl);
|
rest_of_decl_compilation (decl, toplevel, 0);
|
rest_of_decl_compilation (decl, toplevel, 0);
|
if (!toplevel)
|
if (!toplevel)
|
expand_decl (decl);
|
expand_decl (decl);
|
}
|
}
|
}
|
}
|
C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
|
C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
|
|
|
/* Update type location to the one of the definition, instead of e.g.
|
/* Update type location to the one of the definition, instead of e.g.
|
a forward declaration. */
|
a forward declaration. */
|
if (TYPE_STUB_DECL (t))
|
if (TYPE_STUB_DECL (t))
|
DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t)) = loc;
|
DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t)) = loc;
|
|
|
/* Finish debugging output for this type. */
|
/* Finish debugging output for this type. */
|
rest_of_type_compilation (t, toplevel);
|
rest_of_type_compilation (t, toplevel);
|
|
|
/* If we're inside a function proper, i.e. not file-scope and not still
|
/* If we're inside a function proper, i.e. not file-scope and not still
|
parsing parameters, then arrange for the size of a variable sized type
|
parsing parameters, then arrange for the size of a variable sized type
|
to be bound now. */
|
to be bound now. */
|
if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
|
if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
|
add_stmt (build_stmt (loc,
|
add_stmt (build_stmt (loc,
|
DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t)));
|
DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t)));
|
|
|
if (warn_cxx_compat)
|
if (warn_cxx_compat)
|
warn_cxx_compat_finish_struct (fieldlist);
|
warn_cxx_compat_finish_struct (fieldlist);
|
|
|
VEC_free (tree, heap, struct_parse_info->struct_types);
|
VEC_free (tree, heap, struct_parse_info->struct_types);
|
VEC_free (c_binding_ptr, heap, struct_parse_info->fields);
|
VEC_free (c_binding_ptr, heap, struct_parse_info->fields);
|
VEC_free (tree, heap, struct_parse_info->typedefs_seen);
|
VEC_free (tree, heap, struct_parse_info->typedefs_seen);
|
XDELETE (struct_parse_info);
|
XDELETE (struct_parse_info);
|
|
|
struct_parse_info = enclosing_struct_parse_info;
|
struct_parse_info = enclosing_struct_parse_info;
|
|
|
/* If this struct is defined inside a struct, add it to
|
/* If this struct is defined inside a struct, add it to
|
struct_types. */
|
struct_types. */
|
if (warn_cxx_compat
|
if (warn_cxx_compat
|
&& struct_parse_info != NULL
|
&& struct_parse_info != NULL
|
&& !in_sizeof && !in_typeof && !in_alignof)
|
&& !in_sizeof && !in_typeof && !in_alignof)
|
VEC_safe_push (tree, heap, struct_parse_info->struct_types, t);
|
VEC_safe_push (tree, heap, struct_parse_info->struct_types, t);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Lay out the type T, and its element type, and so on. */
|
/* Lay out the type T, and its element type, and so on. */
|
|
|
static void
|
static void
|
layout_array_type (tree t)
|
layout_array_type (tree t)
|
{
|
{
|
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
|
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
|
layout_array_type (TREE_TYPE (t));
|
layout_array_type (TREE_TYPE (t));
|
layout_type (t);
|
layout_type (t);
|
}
|
}
|
|
|
/* Begin compiling the definition of an enumeration type.
|
/* Begin compiling the definition of an enumeration type.
|
NAME is its name (or null if anonymous).
|
NAME is its name (or null if anonymous).
|
LOC is the enum's location.
|
LOC is the enum's location.
|
Returns the type object, as yet incomplete.
|
Returns the type object, as yet incomplete.
|
Also records info about it so that build_enumerator
|
Also records info about it so that build_enumerator
|
may be used to declare the individual values as they are read. */
|
may be used to declare the individual values as they are read. */
|
|
|
tree
|
tree
|
start_enum (location_t loc, struct c_enum_contents *the_enum, tree name)
|
start_enum (location_t loc, struct c_enum_contents *the_enum, tree name)
|
{
|
{
|
tree enumtype = NULL_TREE;
|
tree enumtype = NULL_TREE;
|
location_t enumloc = UNKNOWN_LOCATION;
|
location_t enumloc = UNKNOWN_LOCATION;
|
|
|
/* If this is the real definition for a previous forward reference,
|
/* If this is the real definition for a previous forward reference,
|
fill in the contents in the same object that used to be the
|
fill in the contents in the same object that used to be the
|
forward reference. */
|
forward reference. */
|
|
|
if (name != NULL_TREE)
|
if (name != NULL_TREE)
|
enumtype = lookup_tag (ENUMERAL_TYPE, name, 1, &enumloc);
|
enumtype = lookup_tag (ENUMERAL_TYPE, name, 1, &enumloc);
|
|
|
if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
|
if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
|
{
|
{
|
enumtype = make_node (ENUMERAL_TYPE);
|
enumtype = make_node (ENUMERAL_TYPE);
|
pushtag (loc, name, enumtype);
|
pushtag (loc, name, enumtype);
|
}
|
}
|
|
|
if (C_TYPE_BEING_DEFINED (enumtype))
|
if (C_TYPE_BEING_DEFINED (enumtype))
|
error_at (loc, "nested redefinition of %<enum %E%>", name);
|
error_at (loc, "nested redefinition of %<enum %E%>", name);
|
|
|
C_TYPE_BEING_DEFINED (enumtype) = 1;
|
C_TYPE_BEING_DEFINED (enumtype) = 1;
|
|
|
if (TYPE_VALUES (enumtype) != 0)
|
if (TYPE_VALUES (enumtype) != 0)
|
{
|
{
|
/* This enum is a named one that has been declared already. */
|
/* This enum is a named one that has been declared already. */
|
error_at (loc, "redeclaration of %<enum %E%>", name);
|
error_at (loc, "redeclaration of %<enum %E%>", name);
|
if (enumloc != UNKNOWN_LOCATION)
|
if (enumloc != UNKNOWN_LOCATION)
|
inform (enumloc, "originally defined here");
|
inform (enumloc, "originally defined here");
|
|
|
/* Completely replace its old definition.
|
/* Completely replace its old definition.
|
The old enumerators remain defined, however. */
|
The old enumerators remain defined, however. */
|
TYPE_VALUES (enumtype) = 0;
|
TYPE_VALUES (enumtype) = 0;
|
}
|
}
|
|
|
the_enum->enum_next_value = integer_zero_node;
|
the_enum->enum_next_value = integer_zero_node;
|
the_enum->enum_overflow = 0;
|
the_enum->enum_overflow = 0;
|
|
|
if (flag_short_enums)
|
if (flag_short_enums)
|
TYPE_PACKED (enumtype) = 1;
|
TYPE_PACKED (enumtype) = 1;
|
|
|
/* FIXME: This will issue a warning for a use of a type defined
|
/* FIXME: This will issue a warning for a use of a type defined
|
within sizeof in a statement expr. This is not terribly serious
|
within sizeof in a statement expr. This is not terribly serious
|
as C++ doesn't permit statement exprs within sizeof anyhow. */
|
as C++ doesn't permit statement exprs within sizeof anyhow. */
|
if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
|
if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
|
warning_at (loc, OPT_Wc___compat,
|
warning_at (loc, OPT_Wc___compat,
|
"defining type in %qs expression is invalid in C++",
|
"defining type in %qs expression is invalid in C++",
|
(in_sizeof
|
(in_sizeof
|
? "sizeof"
|
? "sizeof"
|
: (in_typeof ? "typeof" : "alignof")));
|
: (in_typeof ? "typeof" : "alignof")));
|
|
|
return enumtype;
|
return enumtype;
|
}
|
}
|
|
|
/* After processing and defining all the values of an enumeration type,
|
/* After processing and defining all the values of an enumeration type,
|
install their decls in the enumeration type and finish it off.
|
install their decls in the enumeration type and finish it off.
|
ENUMTYPE is the type object, VALUES a list of decl-value pairs,
|
ENUMTYPE is the type object, VALUES a list of decl-value pairs,
|
and ATTRIBUTES are the specified attributes.
|
and ATTRIBUTES are the specified attributes.
|
Returns ENUMTYPE. */
|
Returns ENUMTYPE. */
|
|
|
tree
|
tree
|
finish_enum (tree enumtype, tree values, tree attributes)
|
finish_enum (tree enumtype, tree values, tree attributes)
|
{
|
{
|
tree pair, tem;
|
tree pair, tem;
|
tree minnode = 0, maxnode = 0;
|
tree minnode = 0, maxnode = 0;
|
int precision, unsign;
|
int precision, unsign;
|
bool toplevel = (file_scope == current_scope);
|
bool toplevel = (file_scope == current_scope);
|
struct lang_type *lt;
|
struct lang_type *lt;
|
|
|
decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
|
decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
|
|
|
/* Calculate the maximum value of any enumerator in this type. */
|
/* Calculate the maximum value of any enumerator in this type. */
|
|
|
if (values == error_mark_node)
|
if (values == error_mark_node)
|
minnode = maxnode = integer_zero_node;
|
minnode = maxnode = integer_zero_node;
|
else
|
else
|
{
|
{
|
minnode = maxnode = TREE_VALUE (values);
|
minnode = maxnode = TREE_VALUE (values);
|
for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
|
for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
|
{
|
{
|
tree value = TREE_VALUE (pair);
|
tree value = TREE_VALUE (pair);
|
if (tree_int_cst_lt (maxnode, value))
|
if (tree_int_cst_lt (maxnode, value))
|
maxnode = value;
|
maxnode = value;
|
if (tree_int_cst_lt (value, minnode))
|
if (tree_int_cst_lt (value, minnode))
|
minnode = value;
|
minnode = value;
|
}
|
}
|
}
|
}
|
|
|
/* Construct the final type of this enumeration. It is the same
|
/* Construct the final type of this enumeration. It is the same
|
as one of the integral types - the narrowest one that fits, except
|
as one of the integral types - the narrowest one that fits, except
|
that normally we only go as narrow as int - and signed iff any of
|
that normally we only go as narrow as int - and signed iff any of
|
the values are negative. */
|
the values are negative. */
|
unsign = (tree_int_cst_sgn (minnode) >= 0);
|
unsign = (tree_int_cst_sgn (minnode) >= 0);
|
precision = MAX (tree_int_cst_min_precision (minnode, unsign),
|
precision = MAX (tree_int_cst_min_precision (minnode, unsign),
|
tree_int_cst_min_precision (maxnode, unsign));
|
tree_int_cst_min_precision (maxnode, unsign));
|
|
|
if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
|
if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
|
{
|
{
|
tem = c_common_type_for_size (precision, unsign);
|
tem = c_common_type_for_size (precision, unsign);
|
if (tem == NULL)
|
if (tem == NULL)
|
{
|
{
|
warning (0, "enumeration values exceed range of largest integer");
|
warning (0, "enumeration values exceed range of largest integer");
|
tem = long_long_integer_type_node;
|
tem = long_long_integer_type_node;
|
}
|
}
|
}
|
}
|
else
|
else
|
tem = unsign ? unsigned_type_node : integer_type_node;
|
tem = unsign ? unsigned_type_node : integer_type_node;
|
|
|
TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
|
TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
|
TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
|
TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
|
TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
|
TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
|
TYPE_SIZE (enumtype) = 0;
|
TYPE_SIZE (enumtype) = 0;
|
|
|
/* If the precision of the type was specific with an attribute and it
|
/* If the precision of the type was specific with an attribute and it
|
was too small, give an error. Otherwise, use it. */
|
was too small, give an error. Otherwise, use it. */
|
if (TYPE_PRECISION (enumtype))
|
if (TYPE_PRECISION (enumtype))
|
{
|
{
|
if (precision > TYPE_PRECISION (enumtype))
|
if (precision > TYPE_PRECISION (enumtype))
|
error ("specified mode too small for enumeral values");
|
error ("specified mode too small for enumeral values");
|
}
|
}
|
else
|
else
|
TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
|
TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
|
|
|
layout_type (enumtype);
|
layout_type (enumtype);
|
|
|
if (values != error_mark_node)
|
if (values != error_mark_node)
|
{
|
{
|
/* Change the type of the enumerators to be the enum type. We
|
/* Change the type of the enumerators to be the enum type. We
|
need to do this irrespective of the size of the enum, for
|
need to do this irrespective of the size of the enum, for
|
proper type checking. Replace the DECL_INITIALs of the
|
proper type checking. Replace the DECL_INITIALs of the
|
enumerators, and the value slots of the list, with copies
|
enumerators, and the value slots of the list, with copies
|
that have the enum type; they cannot be modified in place
|
that have the enum type; they cannot be modified in place
|
because they may be shared (e.g. integer_zero_node) Finally,
|
because they may be shared (e.g. integer_zero_node) Finally,
|
change the purpose slots to point to the names of the decls. */
|
change the purpose slots to point to the names of the decls. */
|
for (pair = values; pair; pair = TREE_CHAIN (pair))
|
for (pair = values; pair; pair = TREE_CHAIN (pair))
|
{
|
{
|
tree enu = TREE_PURPOSE (pair);
|
tree enu = TREE_PURPOSE (pair);
|
tree ini = DECL_INITIAL (enu);
|
tree ini = DECL_INITIAL (enu);
|
|
|
TREE_TYPE (enu) = enumtype;
|
TREE_TYPE (enu) = enumtype;
|
|
|
/* The ISO C Standard mandates enumerators to have type int,
|
/* The ISO C Standard mandates enumerators to have type int,
|
even though the underlying type of an enum type is
|
even though the underlying type of an enum type is
|
unspecified. However, GCC allows enumerators of any
|
unspecified. However, GCC allows enumerators of any
|
integer type as an extensions. build_enumerator()
|
integer type as an extensions. build_enumerator()
|
converts any enumerators that fit in an int to type int,
|
converts any enumerators that fit in an int to type int,
|
to avoid promotions to unsigned types when comparing
|
to avoid promotions to unsigned types when comparing
|
integers with enumerators that fit in the int range.
|
integers with enumerators that fit in the int range.
|
When -pedantic is given, build_enumerator() would have
|
When -pedantic is given, build_enumerator() would have
|
already warned about those that don't fit. Here we
|
already warned about those that don't fit. Here we
|
convert the rest to the enumerator type. */
|
convert the rest to the enumerator type. */
|
if (TREE_TYPE (ini) != integer_type_node)
|
if (TREE_TYPE (ini) != integer_type_node)
|
ini = convert (enumtype, ini);
|
ini = convert (enumtype, ini);
|
|
|
DECL_INITIAL (enu) = ini;
|
DECL_INITIAL (enu) = ini;
|
TREE_PURPOSE (pair) = DECL_NAME (enu);
|
TREE_PURPOSE (pair) = DECL_NAME (enu);
|
TREE_VALUE (pair) = ini;
|
TREE_VALUE (pair) = ini;
|
}
|
}
|
|
|
TYPE_VALUES (enumtype) = values;
|
TYPE_VALUES (enumtype) = values;
|
}
|
}
|
|
|
/* Record the min/max values so that we can warn about bit-field
|
/* Record the min/max values so that we can warn about bit-field
|
enumerations that are too small for the values. */
|
enumerations that are too small for the values. */
|
lt = GGC_CNEW (struct lang_type);
|
lt = GGC_CNEW (struct lang_type);
|
lt->enum_min = minnode;
|
lt->enum_min = minnode;
|
lt->enum_max = maxnode;
|
lt->enum_max = maxnode;
|
TYPE_LANG_SPECIFIC (enumtype) = lt;
|
TYPE_LANG_SPECIFIC (enumtype) = lt;
|
|
|
/* Fix up all variant types of this enum type. */
|
/* Fix up all variant types of this enum type. */
|
for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
|
for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
|
{
|
{
|
if (tem == enumtype)
|
if (tem == enumtype)
|
continue;
|
continue;
|
TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
|
TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
|
TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
|
TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
|
TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
|
TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
|
TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
|
TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
|
TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
|
TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
|
SET_TYPE_MODE (tem, TYPE_MODE (enumtype));
|
SET_TYPE_MODE (tem, TYPE_MODE (enumtype));
|
TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
|
TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
|
TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
|
TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
|
TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
|
TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
|
TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
|
TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
|
TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
|
TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
|
}
|
}
|
|
|
/* Finish debugging output for this type. */
|
/* Finish debugging output for this type. */
|
rest_of_type_compilation (enumtype, toplevel);
|
rest_of_type_compilation (enumtype, toplevel);
|
|
|
/* If this enum is defined inside a struct, add it to
|
/* If this enum is defined inside a struct, add it to
|
struct_types. */
|
struct_types. */
|
if (warn_cxx_compat
|
if (warn_cxx_compat
|
&& struct_parse_info != NULL
|
&& struct_parse_info != NULL
|
&& !in_sizeof && !in_typeof && !in_alignof)
|
&& !in_sizeof && !in_typeof && !in_alignof)
|
VEC_safe_push (tree, heap, struct_parse_info->struct_types, enumtype);
|
VEC_safe_push (tree, heap, struct_parse_info->struct_types, enumtype);
|
|
|
return enumtype;
|
return enumtype;
|
}
|
}
|
|
|
/* Build and install a CONST_DECL for one value of the
|
/* Build and install a CONST_DECL for one value of the
|
current enumeration type (one that was begun with start_enum).
|
current enumeration type (one that was begun with start_enum).
|
LOC is the location of the enumerator.
|
LOC is the location of the enumerator.
|
Return a tree-list containing the CONST_DECL and its value.
|
Return a tree-list containing the CONST_DECL and its value.
|
Assignment of sequential values by default is handled here. */
|
Assignment of sequential values by default is handled here. */
|
|
|
tree
|
tree
|
build_enumerator (location_t loc,
|
build_enumerator (location_t loc,
|
struct c_enum_contents *the_enum, tree name, tree value)
|
struct c_enum_contents *the_enum, tree name, tree value)
|
{
|
{
|
tree decl, type;
|
tree decl, type;
|
|
|
/* Validate and default VALUE. */
|
/* Validate and default VALUE. */
|
|
|
if (value != 0)
|
if (value != 0)
|
{
|
{
|
/* Don't issue more errors for error_mark_node (i.e. an
|
/* Don't issue more errors for error_mark_node (i.e. an
|
undeclared identifier) - just ignore the value expression. */
|
undeclared identifier) - just ignore the value expression. */
|
if (value == error_mark_node)
|
if (value == error_mark_node)
|
value = 0;
|
value = 0;
|
else if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
|
else if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
|
{
|
{
|
error_at (loc, "enumerator value for %qE is not an integer constant",
|
error_at (loc, "enumerator value for %qE is not an integer constant",
|
name);
|
name);
|
value = 0;
|
value = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (TREE_CODE (value) != INTEGER_CST)
|
if (TREE_CODE (value) != INTEGER_CST)
|
{
|
{
|
value = c_fully_fold (value, false, NULL);
|
value = c_fully_fold (value, false, NULL);
|
if (TREE_CODE (value) == INTEGER_CST)
|
if (TREE_CODE (value) == INTEGER_CST)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"enumerator value for %qE is not an integer "
|
"enumerator value for %qE is not an integer "
|
"constant expression", name);
|
"constant expression", name);
|
}
|
}
|
if (TREE_CODE (value) != INTEGER_CST)
|
if (TREE_CODE (value) != INTEGER_CST)
|
{
|
{
|
error ("enumerator value for %qE is not an integer constant",
|
error ("enumerator value for %qE is not an integer constant",
|
name);
|
name);
|
value = 0;
|
value = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
value = default_conversion (value);
|
value = default_conversion (value);
|
constant_expression_warning (value);
|
constant_expression_warning (value);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Default based on previous value. */
|
/* Default based on previous value. */
|
/* It should no longer be possible to have NON_LVALUE_EXPR
|
/* It should no longer be possible to have NON_LVALUE_EXPR
|
in the default. */
|
in the default. */
|
if (value == 0)
|
if (value == 0)
|
{
|
{
|
value = the_enum->enum_next_value;
|
value = the_enum->enum_next_value;
|
if (the_enum->enum_overflow)
|
if (the_enum->enum_overflow)
|
error_at (loc, "overflow in enumeration values");
|
error_at (loc, "overflow in enumeration values");
|
}
|
}
|
/* Even though the underlying type of an enum is unspecified, the
|
/* Even though the underlying type of an enum is unspecified, the
|
type of enumeration constants is explicitly defined as int
|
type of enumeration constants is explicitly defined as int
|
(6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
|
(6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
|
an extension. */
|
an extension. */
|
else if (!int_fits_type_p (value, integer_type_node))
|
else if (!int_fits_type_p (value, integer_type_node))
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C restricts enumerator values to range of %<int%>");
|
"ISO C restricts enumerator values to range of %<int%>");
|
|
|
/* The ISO C Standard mandates enumerators to have type int, even
|
/* The ISO C Standard mandates enumerators to have type int, even
|
though the underlying type of an enum type is unspecified.
|
though the underlying type of an enum type is unspecified.
|
However, GCC allows enumerators of any integer type as an
|
However, GCC allows enumerators of any integer type as an
|
extensions. Here we convert any enumerators that fit in an int
|
extensions. Here we convert any enumerators that fit in an int
|
to type int, to avoid promotions to unsigned types when comparing
|
to type int, to avoid promotions to unsigned types when comparing
|
integers with enumerators that fit in the int range. When
|
integers with enumerators that fit in the int range. When
|
-pedantic is given, we would have already warned about those that
|
-pedantic is given, we would have already warned about those that
|
don't fit. We have to do this here rather than in finish_enum
|
don't fit. We have to do this here rather than in finish_enum
|
because this value may be used to define more enumerators. */
|
because this value may be used to define more enumerators. */
|
if (int_fits_type_p (value, integer_type_node))
|
if (int_fits_type_p (value, integer_type_node))
|
value = convert (integer_type_node, value);
|
value = convert (integer_type_node, value);
|
|
|
/* Set basis for default for next value. */
|
/* Set basis for default for next value. */
|
the_enum->enum_next_value
|
the_enum->enum_next_value
|
= build_binary_op
|
= build_binary_op
|
(EXPR_HAS_LOCATION (value) ? EXPR_LOCATION (value) : input_location,
|
(EXPR_HAS_LOCATION (value) ? EXPR_LOCATION (value) : input_location,
|
PLUS_EXPR, value, integer_one_node, 0);
|
PLUS_EXPR, value, integer_one_node, 0);
|
the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value);
|
the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value);
|
|
|
/* Now create a declaration for the enum value name. */
|
/* Now create a declaration for the enum value name. */
|
|
|
type = TREE_TYPE (value);
|
type = TREE_TYPE (value);
|
type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
|
type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
|
TYPE_PRECISION (integer_type_node)),
|
TYPE_PRECISION (integer_type_node)),
|
(TYPE_PRECISION (type)
|
(TYPE_PRECISION (type)
|
>= TYPE_PRECISION (integer_type_node)
|
>= TYPE_PRECISION (integer_type_node)
|
&& TYPE_UNSIGNED (type)));
|
&& TYPE_UNSIGNED (type)));
|
|
|
decl = build_decl (loc, CONST_DECL, name, type);
|
decl = build_decl (loc, CONST_DECL, name, type);
|
DECL_INITIAL (decl) = convert (type, value);
|
DECL_INITIAL (decl) = convert (type, value);
|
pushdecl (decl);
|
pushdecl (decl);
|
|
|
return tree_cons (decl, value, NULL_TREE);
|
return tree_cons (decl, value, NULL_TREE);
|
}
|
}
|
|
|
|
|
/* Create the FUNCTION_DECL for a function definition.
|
/* Create the FUNCTION_DECL for a function definition.
|
DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
|
DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
|
the declaration; they describe the function's name and the type it returns,
|
the declaration; they describe the function's name and the type it returns,
|
but twisted together in a fashion that parallels the syntax of C.
|
but twisted together in a fashion that parallels the syntax of C.
|
|
|
This function creates a binding context for the function body
|
This function creates a binding context for the function body
|
as well as setting up the FUNCTION_DECL in current_function_decl.
|
as well as setting up the FUNCTION_DECL in current_function_decl.
|
|
|
Returns 1 on success. If the DECLARATOR is not suitable for a function
|
Returns 1 on success. If the DECLARATOR is not suitable for a function
|
(it defines a datum instead), we return 0, which tells
|
(it defines a datum instead), we return 0, which tells
|
yyparse to report a parse error. */
|
yyparse to report a parse error. */
|
|
|
int
|
int
|
start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
|
start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
|
tree attributes)
|
tree attributes)
|
{
|
{
|
tree decl1, old_decl;
|
tree decl1, old_decl;
|
tree restype, resdecl;
|
tree restype, resdecl;
|
location_t loc;
|
location_t loc;
|
|
|
current_function_returns_value = 0; /* Assume, until we see it does. */
|
current_function_returns_value = 0; /* Assume, until we see it does. */
|
current_function_returns_null = 0;
|
current_function_returns_null = 0;
|
current_function_returns_abnormally = 0;
|
current_function_returns_abnormally = 0;
|
warn_about_return_type = 0;
|
warn_about_return_type = 0;
|
c_switch_stack = NULL;
|
c_switch_stack = NULL;
|
|
|
/* Indicate no valid break/continue context by setting these variables
|
/* Indicate no valid break/continue context by setting these variables
|
to some non-null, non-label value. We'll notice and emit the proper
|
to some non-null, non-label value. We'll notice and emit the proper
|
error message in c_finish_bc_stmt. */
|
error message in c_finish_bc_stmt. */
|
c_break_label = c_cont_label = size_zero_node;
|
c_break_label = c_cont_label = size_zero_node;
|
|
|
decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL,
|
decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL,
|
&attributes, NULL, NULL, DEPRECATED_NORMAL);
|
&attributes, NULL, NULL, DEPRECATED_NORMAL);
|
|
|
/* If the declarator is not suitable for a function definition,
|
/* If the declarator is not suitable for a function definition,
|
cause a syntax error. */
|
cause a syntax error. */
|
if (decl1 == 0)
|
if (decl1 == 0)
|
return 0;
|
return 0;
|
|
|
loc = DECL_SOURCE_LOCATION (decl1);
|
loc = DECL_SOURCE_LOCATION (decl1);
|
|
|
decl_attributes (&decl1, attributes, 0);
|
decl_attributes (&decl1, attributes, 0);
|
|
|
if (DECL_DECLARED_INLINE_P (decl1)
|
if (DECL_DECLARED_INLINE_P (decl1)
|
&& DECL_UNINLINABLE (decl1)
|
&& DECL_UNINLINABLE (decl1)
|
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
|
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
|
warning_at (loc, OPT_Wattributes,
|
warning_at (loc, OPT_Wattributes,
|
"inline function %qD given attribute noinline",
|
"inline function %qD given attribute noinline",
|
decl1);
|
decl1);
|
|
|
/* Handle gnu_inline attribute. */
|
/* Handle gnu_inline attribute. */
|
if (declspecs->inline_p
|
if (declspecs->inline_p
|
&& !flag_gnu89_inline
|
&& !flag_gnu89_inline
|
&& TREE_CODE (decl1) == FUNCTION_DECL
|
&& TREE_CODE (decl1) == FUNCTION_DECL
|
&& (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1))
|
&& (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1))
|
|| current_function_decl))
|
|| current_function_decl))
|
{
|
{
|
if (declspecs->storage_class != csc_static)
|
if (declspecs->storage_class != csc_static)
|
DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
|
DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
|
}
|
}
|
|
|
announce_function (decl1);
|
announce_function (decl1);
|
|
|
if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
|
if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
|
{
|
{
|
error_at (loc, "return type is an incomplete type");
|
error_at (loc, "return type is an incomplete type");
|
/* Make it return void instead. */
|
/* Make it return void instead. */
|
TREE_TYPE (decl1)
|
TREE_TYPE (decl1)
|
= build_function_type (void_type_node,
|
= build_function_type (void_type_node,
|
TYPE_ARG_TYPES (TREE_TYPE (decl1)));
|
TYPE_ARG_TYPES (TREE_TYPE (decl1)));
|
}
|
}
|
|
|
if (warn_about_return_type)
|
if (warn_about_return_type)
|
pedwarn_c99 (loc, flag_isoc99 ? 0
|
pedwarn_c99 (loc, flag_isoc99 ? 0
|
: (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
|
: (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
|
"return type defaults to %<int%>");
|
"return type defaults to %<int%>");
|
|
|
/* Make the init_value nonzero so pushdecl knows this is not tentative.
|
/* Make the init_value nonzero so pushdecl knows this is not tentative.
|
error_mark_node is replaced below (in pop_scope) with the BLOCK. */
|
error_mark_node is replaced below (in pop_scope) with the BLOCK. */
|
DECL_INITIAL (decl1) = error_mark_node;
|
DECL_INITIAL (decl1) = error_mark_node;
|
|
|
/* If this definition isn't a prototype and we had a prototype declaration
|
/* If this definition isn't a prototype and we had a prototype declaration
|
before, copy the arg type info from that prototype. */
|
before, copy the arg type info from that prototype. */
|
old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
|
old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
|
if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
|
if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
|
old_decl = 0;
|
old_decl = 0;
|
current_function_prototype_locus = UNKNOWN_LOCATION;
|
current_function_prototype_locus = UNKNOWN_LOCATION;
|
current_function_prototype_built_in = false;
|
current_function_prototype_built_in = false;
|
current_function_prototype_arg_types = NULL_TREE;
|
current_function_prototype_arg_types = NULL_TREE;
|
if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
|
if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
|
{
|
{
|
if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
|
if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
|
&& comptypes (TREE_TYPE (TREE_TYPE (decl1)),
|
&& comptypes (TREE_TYPE (TREE_TYPE (decl1)),
|
TREE_TYPE (TREE_TYPE (old_decl))))
|
TREE_TYPE (TREE_TYPE (old_decl))))
|
{
|
{
|
TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
|
TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
|
TREE_TYPE (decl1));
|
TREE_TYPE (decl1));
|
current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
|
current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
|
current_function_prototype_built_in
|
current_function_prototype_built_in
|
= C_DECL_BUILTIN_PROTOTYPE (old_decl);
|
= C_DECL_BUILTIN_PROTOTYPE (old_decl);
|
current_function_prototype_arg_types
|
current_function_prototype_arg_types
|
= TYPE_ARG_TYPES (TREE_TYPE (decl1));
|
= TYPE_ARG_TYPES (TREE_TYPE (decl1));
|
}
|
}
|
if (TREE_PUBLIC (decl1))
|
if (TREE_PUBLIC (decl1))
|
{
|
{
|
/* If there is an external prototype declaration of this
|
/* If there is an external prototype declaration of this
|
function, record its location but do not copy information
|
function, record its location but do not copy information
|
to this decl. This may be an invisible declaration
|
to this decl. This may be an invisible declaration
|
(built-in or in a scope which has finished) or simply
|
(built-in or in a scope which has finished) or simply
|
have more refined argument types than any declaration
|
have more refined argument types than any declaration
|
found above. */
|
found above. */
|
struct c_binding *b;
|
struct c_binding *b;
|
for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
|
for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
|
if (B_IN_SCOPE (b, external_scope))
|
if (B_IN_SCOPE (b, external_scope))
|
break;
|
break;
|
if (b)
|
if (b)
|
{
|
{
|
tree ext_decl, ext_type;
|
tree ext_decl, ext_type;
|
ext_decl = b->decl;
|
ext_decl = b->decl;
|
ext_type = b->u.type ? b->u.type : TREE_TYPE (ext_decl);
|
ext_type = b->u.type ? b->u.type : TREE_TYPE (ext_decl);
|
if (TREE_CODE (ext_type) == FUNCTION_TYPE
|
if (TREE_CODE (ext_type) == FUNCTION_TYPE
|
&& comptypes (TREE_TYPE (TREE_TYPE (decl1)),
|
&& comptypes (TREE_TYPE (TREE_TYPE (decl1)),
|
TREE_TYPE (ext_type)))
|
TREE_TYPE (ext_type)))
|
{
|
{
|
current_function_prototype_locus
|
current_function_prototype_locus
|
= DECL_SOURCE_LOCATION (ext_decl);
|
= DECL_SOURCE_LOCATION (ext_decl);
|
current_function_prototype_built_in
|
current_function_prototype_built_in
|
= C_DECL_BUILTIN_PROTOTYPE (ext_decl);
|
= C_DECL_BUILTIN_PROTOTYPE (ext_decl);
|
current_function_prototype_arg_types
|
current_function_prototype_arg_types
|
= TYPE_ARG_TYPES (ext_type);
|
= TYPE_ARG_TYPES (ext_type);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Optionally warn of old-fashioned def with no previous prototype. */
|
/* Optionally warn of old-fashioned def with no previous prototype. */
|
if (warn_strict_prototypes
|
if (warn_strict_prototypes
|
&& old_decl != error_mark_node
|
&& old_decl != error_mark_node
|
&& TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
|
&& TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
|
&& C_DECL_ISNT_PROTOTYPE (old_decl))
|
&& C_DECL_ISNT_PROTOTYPE (old_decl))
|
warning_at (loc, OPT_Wstrict_prototypes,
|
warning_at (loc, OPT_Wstrict_prototypes,
|
"function declaration isn%'t a prototype");
|
"function declaration isn%'t a prototype");
|
/* Optionally warn of any global def with no previous prototype. */
|
/* Optionally warn of any global def with no previous prototype. */
|
else if (warn_missing_prototypes
|
else if (warn_missing_prototypes
|
&& old_decl != error_mark_node
|
&& old_decl != error_mark_node
|
&& TREE_PUBLIC (decl1)
|
&& TREE_PUBLIC (decl1)
|
&& !MAIN_NAME_P (DECL_NAME (decl1))
|
&& !MAIN_NAME_P (DECL_NAME (decl1))
|
&& C_DECL_ISNT_PROTOTYPE (old_decl))
|
&& C_DECL_ISNT_PROTOTYPE (old_decl))
|
warning_at (loc, OPT_Wmissing_prototypes,
|
warning_at (loc, OPT_Wmissing_prototypes,
|
"no previous prototype for %qD", decl1);
|
"no previous prototype for %qD", decl1);
|
/* Optionally warn of any def with no previous prototype
|
/* Optionally warn of any def with no previous prototype
|
if the function has already been used. */
|
if the function has already been used. */
|
else if (warn_missing_prototypes
|
else if (warn_missing_prototypes
|
&& old_decl != 0
|
&& old_decl != 0
|
&& old_decl != error_mark_node
|
&& old_decl != error_mark_node
|
&& TREE_USED (old_decl)
|
&& TREE_USED (old_decl)
|
&& TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
|
&& TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
|
warning_at (loc, OPT_Wmissing_prototypes,
|
warning_at (loc, OPT_Wmissing_prototypes,
|
"%qD was used with no prototype before its definition", decl1);
|
"%qD was used with no prototype before its definition", decl1);
|
/* Optionally warn of any global def with no previous declaration. */
|
/* Optionally warn of any global def with no previous declaration. */
|
else if (warn_missing_declarations
|
else if (warn_missing_declarations
|
&& TREE_PUBLIC (decl1)
|
&& TREE_PUBLIC (decl1)
|
&& old_decl == 0
|
&& old_decl == 0
|
&& !MAIN_NAME_P (DECL_NAME (decl1)))
|
&& !MAIN_NAME_P (DECL_NAME (decl1)))
|
warning_at (loc, OPT_Wmissing_declarations,
|
warning_at (loc, OPT_Wmissing_declarations,
|
"no previous declaration for %qD",
|
"no previous declaration for %qD",
|
decl1);
|
decl1);
|
/* Optionally warn of any def with no previous declaration
|
/* Optionally warn of any def with no previous declaration
|
if the function has already been used. */
|
if the function has already been used. */
|
else if (warn_missing_declarations
|
else if (warn_missing_declarations
|
&& old_decl != 0
|
&& old_decl != 0
|
&& old_decl != error_mark_node
|
&& old_decl != error_mark_node
|
&& TREE_USED (old_decl)
|
&& TREE_USED (old_decl)
|
&& C_DECL_IMPLICIT (old_decl))
|
&& C_DECL_IMPLICIT (old_decl))
|
warning_at (loc, OPT_Wmissing_declarations,
|
warning_at (loc, OPT_Wmissing_declarations,
|
"%qD was used with no declaration before its definition", decl1);
|
"%qD was used with no declaration before its definition", decl1);
|
|
|
/* This function exists in static storage.
|
/* This function exists in static storage.
|
(This does not mean `static' in the C sense!) */
|
(This does not mean `static' in the C sense!) */
|
TREE_STATIC (decl1) = 1;
|
TREE_STATIC (decl1) = 1;
|
|
|
/* A nested function is not global. */
|
/* A nested function is not global. */
|
if (current_function_decl != 0)
|
if (current_function_decl != 0)
|
TREE_PUBLIC (decl1) = 0;
|
TREE_PUBLIC (decl1) = 0;
|
|
|
/* This is the earliest point at which we might know the assembler
|
/* This is the earliest point at which we might know the assembler
|
name of the function. Thus, if it's set before this, die horribly. */
|
name of the function. Thus, if it's set before this, die horribly. */
|
gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
|
gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
|
|
|
/* If #pragma weak was used, mark the decl weak now. */
|
/* If #pragma weak was used, mark the decl weak now. */
|
if (current_scope == file_scope)
|
if (current_scope == file_scope)
|
maybe_apply_pragma_weak (decl1);
|
maybe_apply_pragma_weak (decl1);
|
|
|
/* Warn for unlikely, improbable, or stupid declarations of `main'. */
|
/* Warn for unlikely, improbable, or stupid declarations of `main'. */
|
if (warn_main && MAIN_NAME_P (DECL_NAME (decl1)))
|
if (warn_main && MAIN_NAME_P (DECL_NAME (decl1)))
|
{
|
{
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
|
!= integer_type_node)
|
!= integer_type_node)
|
pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1);
|
pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1);
|
|
|
check_main_parameter_types (decl1);
|
check_main_parameter_types (decl1);
|
|
|
if (!TREE_PUBLIC (decl1))
|
if (!TREE_PUBLIC (decl1))
|
pedwarn (loc, OPT_Wmain,
|
pedwarn (loc, OPT_Wmain,
|
"%qD is normally a non-static function", decl1);
|
"%qD is normally a non-static function", decl1);
|
}
|
}
|
|
|
/* Record the decl so that the function name is defined.
|
/* Record the decl so that the function name is defined.
|
If we already have a decl for this name, and it is a FUNCTION_DECL,
|
If we already have a decl for this name, and it is a FUNCTION_DECL,
|
use the old decl. */
|
use the old decl. */
|
|
|
current_function_decl = pushdecl (decl1);
|
current_function_decl = pushdecl (decl1);
|
|
|
push_scope ();
|
push_scope ();
|
declare_parm_level ();
|
declare_parm_level ();
|
|
|
restype = TREE_TYPE (TREE_TYPE (current_function_decl));
|
restype = TREE_TYPE (TREE_TYPE (current_function_decl));
|
resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype);
|
resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype);
|
DECL_ARTIFICIAL (resdecl) = 1;
|
DECL_ARTIFICIAL (resdecl) = 1;
|
DECL_IGNORED_P (resdecl) = 1;
|
DECL_IGNORED_P (resdecl) = 1;
|
DECL_RESULT (current_function_decl) = resdecl;
|
DECL_RESULT (current_function_decl) = resdecl;
|
|
|
start_fname_decls ();
|
start_fname_decls ();
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Subroutine of store_parm_decls which handles new-style function
|
/* Subroutine of store_parm_decls which handles new-style function
|
definitions (prototype format). The parms already have decls, so we
|
definitions (prototype format). The parms already have decls, so we
|
need only record them as in effect and complain if any redundant
|
need only record them as in effect and complain if any redundant
|
old-style parm decls were written. */
|
old-style parm decls were written. */
|
static void
|
static void
|
store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
|
store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
|
{
|
{
|
tree decl;
|
tree decl;
|
|
|
if (current_scope->bindings)
|
if (current_scope->bindings)
|
{
|
{
|
error_at (DECL_SOURCE_LOCATION (fndecl),
|
error_at (DECL_SOURCE_LOCATION (fndecl),
|
"old-style parameter declarations in prototyped "
|
"old-style parameter declarations in prototyped "
|
"function definition");
|
"function definition");
|
|
|
/* Get rid of the old-style declarations. */
|
/* Get rid of the old-style declarations. */
|
pop_scope ();
|
pop_scope ();
|
push_scope ();
|
push_scope ();
|
}
|
}
|
/* Don't issue this warning for nested functions, and don't issue this
|
/* Don't issue this warning for nested functions, and don't issue this
|
warning if we got here because ARG_INFO_TYPES was error_mark_node
|
warning if we got here because ARG_INFO_TYPES was error_mark_node
|
(this happens when a function definition has just an ellipsis in
|
(this happens when a function definition has just an ellipsis in
|
its parameter list). */
|
its parameter list). */
|
else if (!in_system_header && !current_function_scope
|
else if (!in_system_header && !current_function_scope
|
&& arg_info->types != error_mark_node)
|
&& arg_info->types != error_mark_node)
|
warning_at (DECL_SOURCE_LOCATION (fndecl), OPT_Wtraditional,
|
warning_at (DECL_SOURCE_LOCATION (fndecl), OPT_Wtraditional,
|
"traditional C rejects ISO C style function definitions");
|
"traditional C rejects ISO C style function definitions");
|
|
|
/* Now make all the parameter declarations visible in the function body.
|
/* Now make all the parameter declarations visible in the function body.
|
We can bypass most of the grunt work of pushdecl. */
|
We can bypass most of the grunt work of pushdecl. */
|
for (decl = arg_info->parms; decl; decl = TREE_CHAIN (decl))
|
for (decl = arg_info->parms; decl; decl = TREE_CHAIN (decl))
|
{
|
{
|
DECL_CONTEXT (decl) = current_function_decl;
|
DECL_CONTEXT (decl) = current_function_decl;
|
if (DECL_NAME (decl))
|
if (DECL_NAME (decl))
|
{
|
{
|
bind (DECL_NAME (decl), decl, current_scope,
|
bind (DECL_NAME (decl), decl, current_scope,
|
/*invisible=*/false, /*nested=*/false,
|
/*invisible=*/false, /*nested=*/false,
|
UNKNOWN_LOCATION);
|
UNKNOWN_LOCATION);
|
if (!TREE_USED (decl))
|
if (!TREE_USED (decl))
|
warn_if_shadowing (decl);
|
warn_if_shadowing (decl);
|
}
|
}
|
else
|
else
|
error_at (DECL_SOURCE_LOCATION (decl), "parameter name omitted");
|
error_at (DECL_SOURCE_LOCATION (decl), "parameter name omitted");
|
}
|
}
|
|
|
/* Record the parameter list in the function declaration. */
|
/* Record the parameter list in the function declaration. */
|
DECL_ARGUMENTS (fndecl) = arg_info->parms;
|
DECL_ARGUMENTS (fndecl) = arg_info->parms;
|
|
|
/* Now make all the ancillary declarations visible, likewise. */
|
/* Now make all the ancillary declarations visible, likewise. */
|
for (decl = arg_info->others; decl; decl = TREE_CHAIN (decl))
|
for (decl = arg_info->others; decl; decl = TREE_CHAIN (decl))
|
{
|
{
|
DECL_CONTEXT (decl) = current_function_decl;
|
DECL_CONTEXT (decl) = current_function_decl;
|
if (DECL_NAME (decl))
|
if (DECL_NAME (decl))
|
bind (DECL_NAME (decl), decl, current_scope,
|
bind (DECL_NAME (decl), decl, current_scope,
|
/*invisible=*/false,
|
/*invisible=*/false,
|
/*nested=*/(TREE_CODE (decl) == FUNCTION_DECL),
|
/*nested=*/(TREE_CODE (decl) == FUNCTION_DECL),
|
UNKNOWN_LOCATION);
|
UNKNOWN_LOCATION);
|
}
|
}
|
|
|
/* And all the tag declarations. */
|
/* And all the tag declarations. */
|
for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl))
|
for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl))
|
if (TREE_PURPOSE (decl))
|
if (TREE_PURPOSE (decl))
|
bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope,
|
bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope,
|
/*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
|
/*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
|
}
|
}
|
|
|
/* Subroutine of store_parm_decls which handles old-style function
|
/* Subroutine of store_parm_decls which handles old-style function
|
definitions (separate parameter list and declarations). */
|
definitions (separate parameter list and declarations). */
|
|
|
static void
|
static void
|
store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
|
store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
tree parm, decl, last;
|
tree parm, decl, last;
|
tree parmids = arg_info->parms;
|
tree parmids = arg_info->parms;
|
struct pointer_set_t *seen_args = pointer_set_create ();
|
struct pointer_set_t *seen_args = pointer_set_create ();
|
|
|
if (!in_system_header)
|
if (!in_system_header)
|
warning_at (DECL_SOURCE_LOCATION (fndecl),
|
warning_at (DECL_SOURCE_LOCATION (fndecl),
|
OPT_Wold_style_definition, "old-style function definition");
|
OPT_Wold_style_definition, "old-style function definition");
|
|
|
/* Match each formal parameter name with its declaration. Save each
|
/* Match each formal parameter name with its declaration. Save each
|
decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
|
decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
|
for (parm = parmids; parm; parm = TREE_CHAIN (parm))
|
for (parm = parmids; parm; parm = TREE_CHAIN (parm))
|
{
|
{
|
if (TREE_VALUE (parm) == 0)
|
if (TREE_VALUE (parm) == 0)
|
{
|
{
|
error_at (DECL_SOURCE_LOCATION (fndecl),
|
error_at (DECL_SOURCE_LOCATION (fndecl),
|
"parameter name missing from parameter list");
|
"parameter name missing from parameter list");
|
TREE_PURPOSE (parm) = 0;
|
TREE_PURPOSE (parm) = 0;
|
continue;
|
continue;
|
}
|
}
|
|
|
b = I_SYMBOL_BINDING (TREE_VALUE (parm));
|
b = I_SYMBOL_BINDING (TREE_VALUE (parm));
|
if (b && B_IN_CURRENT_SCOPE (b))
|
if (b && B_IN_CURRENT_SCOPE (b))
|
{
|
{
|
decl = b->decl;
|
decl = b->decl;
|
/* If we got something other than a PARM_DECL it is an error. */
|
/* If we got something other than a PARM_DECL it is an error. */
|
if (TREE_CODE (decl) != PARM_DECL)
|
if (TREE_CODE (decl) != PARM_DECL)
|
error_at (DECL_SOURCE_LOCATION (decl),
|
error_at (DECL_SOURCE_LOCATION (decl),
|
"%qD declared as a non-parameter", decl);
|
"%qD declared as a non-parameter", decl);
|
/* If the declaration is already marked, we have a duplicate
|
/* If the declaration is already marked, we have a duplicate
|
name. Complain and ignore the duplicate. */
|
name. Complain and ignore the duplicate. */
|
else if (pointer_set_contains (seen_args, decl))
|
else if (pointer_set_contains (seen_args, decl))
|
{
|
{
|
error_at (DECL_SOURCE_LOCATION (decl),
|
error_at (DECL_SOURCE_LOCATION (decl),
|
"multiple parameters named %qD", decl);
|
"multiple parameters named %qD", decl);
|
TREE_PURPOSE (parm) = 0;
|
TREE_PURPOSE (parm) = 0;
|
continue;
|
continue;
|
}
|
}
|
/* If the declaration says "void", complain and turn it into
|
/* If the declaration says "void", complain and turn it into
|
an int. */
|
an int. */
|
else if (VOID_TYPE_P (TREE_TYPE (decl)))
|
else if (VOID_TYPE_P (TREE_TYPE (decl)))
|
{
|
{
|
error_at (DECL_SOURCE_LOCATION (decl),
|
error_at (DECL_SOURCE_LOCATION (decl),
|
"parameter %qD declared with void type", decl);
|
"parameter %qD declared with void type", decl);
|
TREE_TYPE (decl) = integer_type_node;
|
TREE_TYPE (decl) = integer_type_node;
|
DECL_ARG_TYPE (decl) = integer_type_node;
|
DECL_ARG_TYPE (decl) = integer_type_node;
|
layout_decl (decl, 0);
|
layout_decl (decl, 0);
|
}
|
}
|
warn_if_shadowing (decl);
|
warn_if_shadowing (decl);
|
}
|
}
|
/* If no declaration found, default to int. */
|
/* If no declaration found, default to int. */
|
else
|
else
|
{
|
{
|
/* FIXME diagnostics: This should be the location of the argument,
|
/* FIXME diagnostics: This should be the location of the argument,
|
not the FNDECL. E.g., for an old-style declaration
|
not the FNDECL. E.g., for an old-style declaration
|
|
|
int f10(v) { blah; }
|
int f10(v) { blah; }
|
|
|
We should use the location of the V, not the F10.
|
We should use the location of the V, not the F10.
|
Unfortunately, the V is an IDENTIFIER_NODE which has no
|
Unfortunately, the V is an IDENTIFIER_NODE which has no
|
location. In the future we need locations for c_arg_info
|
location. In the future we need locations for c_arg_info
|
entries.
|
entries.
|
|
|
See gcc.dg/Wshadow-3.c for an example of this problem. */
|
See gcc.dg/Wshadow-3.c for an example of this problem. */
|
decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
|
decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
|
PARM_DECL, TREE_VALUE (parm), integer_type_node);
|
PARM_DECL, TREE_VALUE (parm), integer_type_node);
|
DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
|
DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
|
pushdecl (decl);
|
pushdecl (decl);
|
warn_if_shadowing (decl);
|
warn_if_shadowing (decl);
|
|
|
if (flag_isoc99)
|
if (flag_isoc99)
|
pedwarn (DECL_SOURCE_LOCATION (decl),
|
pedwarn (DECL_SOURCE_LOCATION (decl),
|
0, "type of %qD defaults to %<int%>", decl);
|
0, "type of %qD defaults to %<int%>", decl);
|
else
|
else
|
warning_at (DECL_SOURCE_LOCATION (decl),
|
warning_at (DECL_SOURCE_LOCATION (decl),
|
OPT_Wmissing_parameter_type,
|
OPT_Wmissing_parameter_type,
|
"type of %qD defaults to %<int%>", decl);
|
"type of %qD defaults to %<int%>", decl);
|
}
|
}
|
|
|
TREE_PURPOSE (parm) = decl;
|
TREE_PURPOSE (parm) = decl;
|
pointer_set_insert (seen_args, decl);
|
pointer_set_insert (seen_args, decl);
|
}
|
}
|
|
|
/* Now examine the parms chain for incomplete declarations
|
/* Now examine the parms chain for incomplete declarations
|
and declarations with no corresponding names. */
|
and declarations with no corresponding names. */
|
|
|
for (b = current_scope->bindings; b; b = b->prev)
|
for (b = current_scope->bindings; b; b = b->prev)
|
{
|
{
|
parm = b->decl;
|
parm = b->decl;
|
if (TREE_CODE (parm) != PARM_DECL)
|
if (TREE_CODE (parm) != PARM_DECL)
|
continue;
|
continue;
|
|
|
if (TREE_TYPE (parm) != error_mark_node
|
if (TREE_TYPE (parm) != error_mark_node
|
&& !COMPLETE_TYPE_P (TREE_TYPE (parm)))
|
&& !COMPLETE_TYPE_P (TREE_TYPE (parm)))
|
{
|
{
|
error_at (DECL_SOURCE_LOCATION (parm),
|
error_at (DECL_SOURCE_LOCATION (parm),
|
"parameter %qD has incomplete type", parm);
|
"parameter %qD has incomplete type", parm);
|
TREE_TYPE (parm) = error_mark_node;
|
TREE_TYPE (parm) = error_mark_node;
|
}
|
}
|
|
|
if (!pointer_set_contains (seen_args, parm))
|
if (!pointer_set_contains (seen_args, parm))
|
{
|
{
|
error_at (DECL_SOURCE_LOCATION (parm),
|
error_at (DECL_SOURCE_LOCATION (parm),
|
"declaration for parameter %qD but no such parameter",
|
"declaration for parameter %qD but no such parameter",
|
parm);
|
parm);
|
|
|
/* Pretend the parameter was not missing.
|
/* Pretend the parameter was not missing.
|
This gets us to a standard state and minimizes
|
This gets us to a standard state and minimizes
|
further error messages. */
|
further error messages. */
|
parmids = chainon (parmids, tree_cons (parm, 0, 0));
|
parmids = chainon (parmids, tree_cons (parm, 0, 0));
|
}
|
}
|
}
|
}
|
|
|
/* Chain the declarations together in the order of the list of
|
/* Chain the declarations together in the order of the list of
|
names. Store that chain in the function decl, replacing the
|
names. Store that chain in the function decl, replacing the
|
list of names. Update the current scope to match. */
|
list of names. Update the current scope to match. */
|
DECL_ARGUMENTS (fndecl) = 0;
|
DECL_ARGUMENTS (fndecl) = 0;
|
|
|
for (parm = parmids; parm; parm = TREE_CHAIN (parm))
|
for (parm = parmids; parm; parm = TREE_CHAIN (parm))
|
if (TREE_PURPOSE (parm))
|
if (TREE_PURPOSE (parm))
|
break;
|
break;
|
if (parm && TREE_PURPOSE (parm))
|
if (parm && TREE_PURPOSE (parm))
|
{
|
{
|
last = TREE_PURPOSE (parm);
|
last = TREE_PURPOSE (parm);
|
DECL_ARGUMENTS (fndecl) = last;
|
DECL_ARGUMENTS (fndecl) = last;
|
|
|
for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
|
for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
|
if (TREE_PURPOSE (parm))
|
if (TREE_PURPOSE (parm))
|
{
|
{
|
TREE_CHAIN (last) = TREE_PURPOSE (parm);
|
TREE_CHAIN (last) = TREE_PURPOSE (parm);
|
last = TREE_PURPOSE (parm);
|
last = TREE_PURPOSE (parm);
|
}
|
}
|
TREE_CHAIN (last) = 0;
|
TREE_CHAIN (last) = 0;
|
}
|
}
|
|
|
pointer_set_destroy (seen_args);
|
pointer_set_destroy (seen_args);
|
|
|
/* If there was a previous prototype,
|
/* If there was a previous prototype,
|
set the DECL_ARG_TYPE of each argument according to
|
set the DECL_ARG_TYPE of each argument according to
|
the type previously specified, and report any mismatches. */
|
the type previously specified, and report any mismatches. */
|
|
|
if (current_function_prototype_arg_types)
|
if (current_function_prototype_arg_types)
|
{
|
{
|
tree type;
|
tree type;
|
for (parm = DECL_ARGUMENTS (fndecl),
|
for (parm = DECL_ARGUMENTS (fndecl),
|
type = current_function_prototype_arg_types;
|
type = current_function_prototype_arg_types;
|
parm || (type && TREE_VALUE (type) != error_mark_node
|
parm || (type && TREE_VALUE (type) != error_mark_node
|
&& (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node));
|
&& (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node));
|
parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
|
parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
|
{
|
{
|
if (parm == 0 || type == 0
|
if (parm == 0 || type == 0
|
|| TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
|
|| TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
|
{
|
{
|
if (current_function_prototype_built_in)
|
if (current_function_prototype_built_in)
|
warning_at (DECL_SOURCE_LOCATION (fndecl),
|
warning_at (DECL_SOURCE_LOCATION (fndecl),
|
0, "number of arguments doesn%'t match "
|
0, "number of arguments doesn%'t match "
|
"built-in prototype");
|
"built-in prototype");
|
else
|
else
|
{
|
{
|
/* FIXME diagnostics: This should be the location of
|
/* FIXME diagnostics: This should be the location of
|
FNDECL, but there is bug when a prototype is
|
FNDECL, but there is bug when a prototype is
|
declared inside function context, but defined
|
declared inside function context, but defined
|
outside of it (e.g., gcc.dg/pr15698-2.c). In
|
outside of it (e.g., gcc.dg/pr15698-2.c). In
|
which case FNDECL gets the location of the
|
which case FNDECL gets the location of the
|
prototype, not the definition. */
|
prototype, not the definition. */
|
error_at (input_location,
|
error_at (input_location,
|
"number of arguments doesn%'t match prototype");
|
"number of arguments doesn%'t match prototype");
|
|
|
error_at (current_function_prototype_locus,
|
error_at (current_function_prototype_locus,
|
"prototype declaration");
|
"prototype declaration");
|
}
|
}
|
break;
|
break;
|
}
|
}
|
/* Type for passing arg must be consistent with that
|
/* Type for passing arg must be consistent with that
|
declared for the arg. ISO C says we take the unqualified
|
declared for the arg. ISO C says we take the unqualified
|
type for parameters declared with qualified type. */
|
type for parameters declared with qualified type. */
|
if (TREE_TYPE (parm) != error_mark_node
|
if (TREE_TYPE (parm) != error_mark_node
|
&& TREE_TYPE (type) != error_mark_node
|
&& TREE_TYPE (type) != error_mark_node
|
&& !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
|
&& !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
|
TYPE_MAIN_VARIANT (TREE_VALUE (type))))
|
TYPE_MAIN_VARIANT (TREE_VALUE (type))))
|
{
|
{
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
|
== TYPE_MAIN_VARIANT (TREE_VALUE (type)))
|
== TYPE_MAIN_VARIANT (TREE_VALUE (type)))
|
{
|
{
|
/* Adjust argument to match prototype. E.g. a previous
|
/* Adjust argument to match prototype. E.g. a previous
|
`int foo(float);' prototype causes
|
`int foo(float);' prototype causes
|
`int foo(x) float x; {...}' to be treated like
|
`int foo(x) float x; {...}' to be treated like
|
`int foo(float x) {...}'. This is particularly
|
`int foo(float x) {...}'. This is particularly
|
useful for argument types like uid_t. */
|
useful for argument types like uid_t. */
|
DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
|
DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
|
|
|
if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
|
if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (parm))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (parm))
|
&& TYPE_PRECISION (TREE_TYPE (parm))
|
&& TYPE_PRECISION (TREE_TYPE (parm))
|
< TYPE_PRECISION (integer_type_node))
|
< TYPE_PRECISION (integer_type_node))
|
DECL_ARG_TYPE (parm) = integer_type_node;
|
DECL_ARG_TYPE (parm) = integer_type_node;
|
|
|
/* ??? Is it possible to get here with a
|
/* ??? Is it possible to get here with a
|
built-in prototype or will it always have
|
built-in prototype or will it always have
|
been diagnosed as conflicting with an
|
been diagnosed as conflicting with an
|
old-style definition and discarded? */
|
old-style definition and discarded? */
|
if (current_function_prototype_built_in)
|
if (current_function_prototype_built_in)
|
warning_at (DECL_SOURCE_LOCATION (parm),
|
warning_at (DECL_SOURCE_LOCATION (parm),
|
OPT_pedantic, "promoted argument %qD "
|
OPT_pedantic, "promoted argument %qD "
|
"doesn%'t match built-in prototype", parm);
|
"doesn%'t match built-in prototype", parm);
|
else
|
else
|
{
|
{
|
pedwarn (DECL_SOURCE_LOCATION (parm),
|
pedwarn (DECL_SOURCE_LOCATION (parm),
|
OPT_pedantic, "promoted argument %qD "
|
OPT_pedantic, "promoted argument %qD "
|
"doesn%'t match prototype", parm);
|
"doesn%'t match prototype", parm);
|
pedwarn (current_function_prototype_locus, OPT_pedantic,
|
pedwarn (current_function_prototype_locus, OPT_pedantic,
|
"prototype declaration");
|
"prototype declaration");
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (current_function_prototype_built_in)
|
if (current_function_prototype_built_in)
|
warning_at (DECL_SOURCE_LOCATION (parm),
|
warning_at (DECL_SOURCE_LOCATION (parm),
|
0, "argument %qD doesn%'t match "
|
0, "argument %qD doesn%'t match "
|
"built-in prototype", parm);
|
"built-in prototype", parm);
|
else
|
else
|
{
|
{
|
error_at (DECL_SOURCE_LOCATION (parm),
|
error_at (DECL_SOURCE_LOCATION (parm),
|
"argument %qD doesn%'t match prototype", parm);
|
"argument %qD doesn%'t match prototype", parm);
|
error_at (current_function_prototype_locus,
|
error_at (current_function_prototype_locus,
|
"prototype declaration");
|
"prototype declaration");
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
|
TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
|
}
|
}
|
|
|
/* Otherwise, create a prototype that would match. */
|
/* Otherwise, create a prototype that would match. */
|
|
|
else
|
else
|
{
|
{
|
tree actual = 0, last = 0, type;
|
tree actual = 0, last = 0, type;
|
|
|
for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
|
for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
|
{
|
{
|
type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
|
type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
|
if (last)
|
if (last)
|
TREE_CHAIN (last) = type;
|
TREE_CHAIN (last) = type;
|
else
|
else
|
actual = type;
|
actual = type;
|
last = type;
|
last = type;
|
}
|
}
|
type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
|
type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
|
if (last)
|
if (last)
|
TREE_CHAIN (last) = type;
|
TREE_CHAIN (last) = type;
|
else
|
else
|
actual = type;
|
actual = type;
|
|
|
/* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
|
/* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
|
of the type of this function, but we need to avoid having this
|
of the type of this function, but we need to avoid having this
|
affect the types of other similarly-typed functions, so we must
|
affect the types of other similarly-typed functions, so we must
|
first force the generation of an identical (but separate) type
|
first force the generation of an identical (but separate) type
|
node for the relevant function type. The new node we create
|
node for the relevant function type. The new node we create
|
will be a variant of the main variant of the original function
|
will be a variant of the main variant of the original function
|
type. */
|
type. */
|
|
|
TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
|
TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
|
|
|
TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
|
TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
|
}
|
}
|
}
|
}
|
|
|
/* Store parameter declarations passed in ARG_INFO into the current
|
/* Store parameter declarations passed in ARG_INFO into the current
|
function declaration. */
|
function declaration. */
|
|
|
void
|
void
|
store_parm_decls_from (struct c_arg_info *arg_info)
|
store_parm_decls_from (struct c_arg_info *arg_info)
|
{
|
{
|
current_function_arg_info = arg_info;
|
current_function_arg_info = arg_info;
|
store_parm_decls ();
|
store_parm_decls ();
|
}
|
}
|
|
|
/* Store the parameter declarations into the current function declaration.
|
/* Store the parameter declarations into the current function declaration.
|
This is called after parsing the parameter declarations, before
|
This is called after parsing the parameter declarations, before
|
digesting the body of the function.
|
digesting the body of the function.
|
|
|
For an old-style definition, construct a prototype out of the old-style
|
For an old-style definition, construct a prototype out of the old-style
|
parameter declarations and inject it into the function's type. */
|
parameter declarations and inject it into the function's type. */
|
|
|
void
|
void
|
store_parm_decls (void)
|
store_parm_decls (void)
|
{
|
{
|
tree fndecl = current_function_decl;
|
tree fndecl = current_function_decl;
|
bool proto;
|
bool proto;
|
|
|
/* The argument information block for FNDECL. */
|
/* The argument information block for FNDECL. */
|
struct c_arg_info *arg_info = current_function_arg_info;
|
struct c_arg_info *arg_info = current_function_arg_info;
|
current_function_arg_info = 0;
|
current_function_arg_info = 0;
|
|
|
/* True if this definition is written with a prototype. Note:
|
/* True if this definition is written with a prototype. Note:
|
despite C99 6.7.5.3p14, we can *not* treat an empty argument
|
despite C99 6.7.5.3p14, we can *not* treat an empty argument
|
list in a function definition as equivalent to (void) -- an
|
list in a function definition as equivalent to (void) -- an
|
empty argument list specifies the function has no parameters,
|
empty argument list specifies the function has no parameters,
|
but only (void) sets up a prototype for future calls. */
|
but only (void) sets up a prototype for future calls. */
|
proto = arg_info->types != 0;
|
proto = arg_info->types != 0;
|
|
|
if (proto)
|
if (proto)
|
store_parm_decls_newstyle (fndecl, arg_info);
|
store_parm_decls_newstyle (fndecl, arg_info);
|
else
|
else
|
store_parm_decls_oldstyle (fndecl, arg_info);
|
store_parm_decls_oldstyle (fndecl, arg_info);
|
|
|
/* The next call to push_scope will be a function body. */
|
/* The next call to push_scope will be a function body. */
|
|
|
next_is_function_body = true;
|
next_is_function_body = true;
|
|
|
/* Write a record describing this function definition to the prototypes
|
/* Write a record describing this function definition to the prototypes
|
file (if requested). */
|
file (if requested). */
|
|
|
gen_aux_info_record (fndecl, 1, 0, proto);
|
gen_aux_info_record (fndecl, 1, 0, proto);
|
|
|
/* Initialize the RTL code for the function. */
|
/* Initialize the RTL code for the function. */
|
allocate_struct_function (fndecl, false);
|
allocate_struct_function (fndecl, false);
|
|
|
/* Begin the statement tree for this function. */
|
/* Begin the statement tree for this function. */
|
DECL_SAVED_TREE (fndecl) = push_stmt_list ();
|
DECL_SAVED_TREE (fndecl) = push_stmt_list ();
|
|
|
/* ??? Insert the contents of the pending sizes list into the function
|
/* ??? Insert the contents of the pending sizes list into the function
|
to be evaluated. The only reason left to have this is
|
to be evaluated. The only reason left to have this is
|
void foo(int n, int array[n++])
|
void foo(int n, int array[n++])
|
because we throw away the array type in favor of a pointer type, and
|
because we throw away the array type in favor of a pointer type, and
|
thus won't naturally see the SAVE_EXPR containing the increment. All
|
thus won't naturally see the SAVE_EXPR containing the increment. All
|
other pending sizes would be handled by gimplify_parameters. */
|
other pending sizes would be handled by gimplify_parameters. */
|
{
|
{
|
tree t;
|
tree t;
|
for (t = nreverse (get_pending_sizes ()); t ; t = TREE_CHAIN (t))
|
for (t = nreverse (get_pending_sizes ()); t ; t = TREE_CHAIN (t))
|
add_stmt (TREE_VALUE (t));
|
add_stmt (TREE_VALUE (t));
|
}
|
}
|
|
|
/* Even though we're inside a function body, we still don't want to
|
/* Even though we're inside a function body, we still don't want to
|
call expand_expr to calculate the size of a variable-sized array.
|
call expand_expr to calculate the size of a variable-sized array.
|
We haven't necessarily assigned RTL to all variables yet, so it's
|
We haven't necessarily assigned RTL to all variables yet, so it's
|
not safe to try to expand expressions involving them. */
|
not safe to try to expand expressions involving them. */
|
cfun->dont_save_pending_sizes_p = 1;
|
cfun->dont_save_pending_sizes_p = 1;
|
}
|
}
|
|
|
|
|
/* Finish up a function declaration and compile that function
|
/* Finish up a function declaration and compile that function
|
all the way to assembler language output. The free the storage
|
all the way to assembler language output. The free the storage
|
for the function definition.
|
for the function definition.
|
|
|
This is called after parsing the body of the function definition. */
|
This is called after parsing the body of the function definition. */
|
|
|
void
|
void
|
finish_function (void)
|
finish_function (void)
|
{
|
{
|
tree fndecl = current_function_decl;
|
tree fndecl = current_function_decl;
|
|
|
if (TREE_CODE (fndecl) == FUNCTION_DECL
|
if (TREE_CODE (fndecl) == FUNCTION_DECL
|
&& targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
|
&& targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
|
{
|
{
|
tree args = DECL_ARGUMENTS (fndecl);
|
tree args = DECL_ARGUMENTS (fndecl);
|
for (; args; args = TREE_CHAIN (args))
|
for (; args; args = TREE_CHAIN (args))
|
{
|
{
|
tree type = TREE_TYPE (args);
|
tree type = TREE_TYPE (args);
|
if (INTEGRAL_TYPE_P (type)
|
if (INTEGRAL_TYPE_P (type)
|
&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
|
&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
|
DECL_ARG_TYPE (args) = integer_type_node;
|
DECL_ARG_TYPE (args) = integer_type_node;
|
}
|
}
|
}
|
}
|
|
|
if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
|
if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
|
BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
|
BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
|
|
|
/* Must mark the RESULT_DECL as being in this function. */
|
/* Must mark the RESULT_DECL as being in this function. */
|
|
|
if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
|
if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
|
DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
|
DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
|
|
|
if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted
|
if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
|
== integer_type_node && flag_isoc99)
|
== integer_type_node && flag_isoc99)
|
{
|
{
|
/* Hack. We don't want the middle-end to warn that this return
|
/* Hack. We don't want the middle-end to warn that this return
|
is unreachable, so we mark its location as special. Using
|
is unreachable, so we mark its location as special. Using
|
UNKNOWN_LOCATION has the problem that it gets clobbered in
|
UNKNOWN_LOCATION has the problem that it gets clobbered in
|
annotate_one_with_locus. A cleaner solution might be to
|
annotate_one_with_locus. A cleaner solution might be to
|
ensure ! should_carry_locus_p (stmt), but that needs a flag.
|
ensure ! should_carry_locus_p (stmt), but that needs a flag.
|
*/
|
*/
|
c_finish_return (BUILTINS_LOCATION, integer_zero_node, NULL_TREE);
|
c_finish_return (BUILTINS_LOCATION, integer_zero_node, NULL_TREE);
|
}
|
}
|
|
|
/* Tie off the statement tree for this function. */
|
/* Tie off the statement tree for this function. */
|
DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
|
DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
|
|
|
finish_fname_decls ();
|
finish_fname_decls ();
|
|
|
/* Complain if there's just no return statement. */
|
/* Complain if there's just no return statement. */
|
if (warn_return_type
|
if (warn_return_type
|
&& TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
|
&& TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
|
&& !current_function_returns_value && !current_function_returns_null
|
&& !current_function_returns_value && !current_function_returns_null
|
/* Don't complain if we are no-return. */
|
/* Don't complain if we are no-return. */
|
&& !current_function_returns_abnormally
|
&& !current_function_returns_abnormally
|
/* Don't complain if we are declared noreturn. */
|
/* Don't complain if we are declared noreturn. */
|
&& !TREE_THIS_VOLATILE (fndecl)
|
&& !TREE_THIS_VOLATILE (fndecl)
|
/* Don't warn for main(). */
|
/* Don't warn for main(). */
|
&& !MAIN_NAME_P (DECL_NAME (fndecl))
|
&& !MAIN_NAME_P (DECL_NAME (fndecl))
|
/* Or if they didn't actually specify a return type. */
|
/* Or if they didn't actually specify a return type. */
|
&& !C_FUNCTION_IMPLICIT_INT (fndecl)
|
&& !C_FUNCTION_IMPLICIT_INT (fndecl)
|
/* Normally, with -Wreturn-type, flow will complain, but we might
|
/* Normally, with -Wreturn-type, flow will complain, but we might
|
optimize out static functions. */
|
optimize out static functions. */
|
&& !TREE_PUBLIC (fndecl))
|
&& !TREE_PUBLIC (fndecl))
|
{
|
{
|
warning (OPT_Wreturn_type,
|
warning (OPT_Wreturn_type,
|
"no return statement in function returning non-void");
|
"no return statement in function returning non-void");
|
TREE_NO_WARNING (fndecl) = 1;
|
TREE_NO_WARNING (fndecl) = 1;
|
}
|
}
|
|
|
/* Store the end of the function, so that we get good line number
|
/* Store the end of the function, so that we get good line number
|
info for the epilogue. */
|
info for the epilogue. */
|
cfun->function_end_locus = input_location;
|
cfun->function_end_locus = input_location;
|
|
|
/* Finalize the ELF visibility for the function. */
|
/* Finalize the ELF visibility for the function. */
|
c_determine_visibility (fndecl);
|
c_determine_visibility (fndecl);
|
|
|
/* For GNU C extern inline functions disregard inline limits. */
|
/* For GNU C extern inline functions disregard inline limits. */
|
if (DECL_EXTERNAL (fndecl)
|
if (DECL_EXTERNAL (fndecl)
|
&& DECL_DECLARED_INLINE_P (fndecl))
|
&& DECL_DECLARED_INLINE_P (fndecl))
|
DECL_DISREGARD_INLINE_LIMITS (fndecl) = 1;
|
DECL_DISREGARD_INLINE_LIMITS (fndecl) = 1;
|
|
|
/* Genericize before inlining. Delay genericizing nested functions
|
/* Genericize before inlining. Delay genericizing nested functions
|
until their parent function is genericized. Since finalizing
|
until their parent function is genericized. Since finalizing
|
requires GENERIC, delay that as well. */
|
requires GENERIC, delay that as well. */
|
|
|
if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
|
if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
|
&& !undef_nested_function)
|
&& !undef_nested_function)
|
{
|
{
|
if (!decl_function_context (fndecl))
|
if (!decl_function_context (fndecl))
|
{
|
{
|
invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
|
invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
|
c_genericize (fndecl);
|
c_genericize (fndecl);
|
|
|
/* ??? Objc emits functions after finalizing the compilation unit.
|
/* ??? Objc emits functions after finalizing the compilation unit.
|
This should be cleaned up later and this conditional removed. */
|
This should be cleaned up later and this conditional removed. */
|
if (cgraph_global_info_ready)
|
if (cgraph_global_info_ready)
|
{
|
{
|
cgraph_add_new_function (fndecl, false);
|
cgraph_add_new_function (fndecl, false);
|
return;
|
return;
|
}
|
}
|
cgraph_finalize_function (fndecl, false);
|
cgraph_finalize_function (fndecl, false);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Register this function with cgraph just far enough to get it
|
/* Register this function with cgraph just far enough to get it
|
added to our parent's nested function list. Handy, since the
|
added to our parent's nested function list. Handy, since the
|
C front end doesn't have such a list. */
|
C front end doesn't have such a list. */
|
(void) cgraph_node (fndecl);
|
(void) cgraph_node (fndecl);
|
}
|
}
|
}
|
}
|
|
|
if (!decl_function_context (fndecl))
|
if (!decl_function_context (fndecl))
|
undef_nested_function = false;
|
undef_nested_function = false;
|
|
|
/* We're leaving the context of this function, so zap cfun.
|
/* We're leaving the context of this function, so zap cfun.
|
It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
|
It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
|
tree_rest_of_compilation. */
|
tree_rest_of_compilation. */
|
set_cfun (NULL);
|
set_cfun (NULL);
|
current_function_decl = NULL;
|
current_function_decl = NULL;
|
}
|
}
|
|
|
/* Check the declarations given in a for-loop for satisfying the C99
|
/* Check the declarations given in a for-loop for satisfying the C99
|
constraints. If exactly one such decl is found, return it. LOC is
|
constraints. If exactly one such decl is found, return it. LOC is
|
the location of the opening parenthesis of the for loop. */
|
the location of the opening parenthesis of the for loop. */
|
|
|
tree
|
tree
|
check_for_loop_decls (location_t loc)
|
check_for_loop_decls (location_t loc)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
tree one_decl = NULL_TREE;
|
tree one_decl = NULL_TREE;
|
int n_decls = 0;
|
int n_decls = 0;
|
|
|
if (!flag_isoc99)
|
if (!flag_isoc99)
|
{
|
{
|
static bool hint = true;
|
static bool hint = true;
|
/* If we get here, declarations have been used in a for loop without
|
/* If we get here, declarations have been used in a for loop without
|
the C99 for loop scope. This doesn't make much sense, so don't
|
the C99 for loop scope. This doesn't make much sense, so don't
|
allow it. */
|
allow it. */
|
error_at (loc, "%<for%> loop initial declarations "
|
error_at (loc, "%<for%> loop initial declarations "
|
"are only allowed in C99 mode");
|
"are only allowed in C99 mode");
|
if (hint)
|
if (hint)
|
{
|
{
|
inform (loc,
|
inform (loc,
|
"use option -std=c99 or -std=gnu99 to compile your code");
|
"use option -std=c99 or -std=gnu99 to compile your code");
|
hint = false;
|
hint = false;
|
}
|
}
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
/* C99 subclause 6.8.5 paragraph 3:
|
/* C99 subclause 6.8.5 paragraph 3:
|
|
|
[#3] The declaration part of a for statement shall only
|
[#3] The declaration part of a for statement shall only
|
declare identifiers for objects having storage class auto or
|
declare identifiers for objects having storage class auto or
|
register.
|
register.
|
|
|
It isn't clear whether, in this sentence, "identifiers" binds to
|
It isn't clear whether, in this sentence, "identifiers" binds to
|
"shall only declare" or to "objects" - that is, whether all identifiers
|
"shall only declare" or to "objects" - that is, whether all identifiers
|
declared must be identifiers for objects, or whether the restriction
|
declared must be identifiers for objects, or whether the restriction
|
only applies to those that are. (A question on this in comp.std.c
|
only applies to those that are. (A question on this in comp.std.c
|
in November 2000 received no answer.) We implement the strictest
|
in November 2000 received no answer.) We implement the strictest
|
interpretation, to avoid creating an extension which later causes
|
interpretation, to avoid creating an extension which later causes
|
problems. */
|
problems. */
|
|
|
for (b = current_scope->bindings; b; b = b->prev)
|
for (b = current_scope->bindings; b; b = b->prev)
|
{
|
{
|
tree id = b->id;
|
tree id = b->id;
|
tree decl = b->decl;
|
tree decl = b->decl;
|
|
|
if (!id)
|
if (!id)
|
continue;
|
continue;
|
|
|
switch (TREE_CODE (decl))
|
switch (TREE_CODE (decl))
|
{
|
{
|
case VAR_DECL:
|
case VAR_DECL:
|
{
|
{
|
location_t decl_loc = DECL_SOURCE_LOCATION (decl);
|
location_t decl_loc = DECL_SOURCE_LOCATION (decl);
|
if (TREE_STATIC (decl))
|
if (TREE_STATIC (decl))
|
error_at (decl_loc,
|
error_at (decl_loc,
|
"declaration of static variable %qD in %<for%> loop "
|
"declaration of static variable %qD in %<for%> loop "
|
"initial declaration", decl);
|
"initial declaration", decl);
|
else if (DECL_EXTERNAL (decl))
|
else if (DECL_EXTERNAL (decl))
|
error_at (decl_loc,
|
error_at (decl_loc,
|
"declaration of %<extern%> variable %qD in %<for%> loop "
|
"declaration of %<extern%> variable %qD in %<for%> loop "
|
"initial declaration", decl);
|
"initial declaration", decl);
|
}
|
}
|
break;
|
break;
|
|
|
case RECORD_TYPE:
|
case RECORD_TYPE:
|
error_at (loc,
|
error_at (loc,
|
"%<struct %E%> declared in %<for%> loop initial "
|
"%<struct %E%> declared in %<for%> loop initial "
|
"declaration", id);
|
"declaration", id);
|
break;
|
break;
|
case UNION_TYPE:
|
case UNION_TYPE:
|
error_at (loc,
|
error_at (loc,
|
"%<union %E%> declared in %<for%> loop initial declaration",
|
"%<union %E%> declared in %<for%> loop initial declaration",
|
id);
|
id);
|
break;
|
break;
|
case ENUMERAL_TYPE:
|
case ENUMERAL_TYPE:
|
error_at (loc, "%<enum %E%> declared in %<for%> loop "
|
error_at (loc, "%<enum %E%> declared in %<for%> loop "
|
"initial declaration", id);
|
"initial declaration", id);
|
break;
|
break;
|
default:
|
default:
|
error_at (loc, "declaration of non-variable "
|
error_at (loc, "declaration of non-variable "
|
"%qD in %<for%> loop initial declaration", decl);
|
"%qD in %<for%> loop initial declaration", decl);
|
}
|
}
|
|
|
n_decls++;
|
n_decls++;
|
one_decl = decl;
|
one_decl = decl;
|
}
|
}
|
|
|
return n_decls == 1 ? one_decl : NULL_TREE;
|
return n_decls == 1 ? one_decl : NULL_TREE;
|
}
|
}
|
|
|
/* Save and reinitialize the variables
|
/* Save and reinitialize the variables
|
used during compilation of a C function. */
|
used during compilation of a C function. */
|
|
|
void
|
void
|
c_push_function_context (void)
|
c_push_function_context (void)
|
{
|
{
|
struct language_function *p;
|
struct language_function *p;
|
p = GGC_NEW (struct language_function);
|
p = GGC_NEW (struct language_function);
|
cfun->language = p;
|
cfun->language = p;
|
|
|
p->base.x_stmt_tree = c_stmt_tree;
|
p->base.x_stmt_tree = c_stmt_tree;
|
p->x_break_label = c_break_label;
|
p->x_break_label = c_break_label;
|
p->x_cont_label = c_cont_label;
|
p->x_cont_label = c_cont_label;
|
p->x_switch_stack = c_switch_stack;
|
p->x_switch_stack = c_switch_stack;
|
p->arg_info = current_function_arg_info;
|
p->arg_info = current_function_arg_info;
|
p->returns_value = current_function_returns_value;
|
p->returns_value = current_function_returns_value;
|
p->returns_null = current_function_returns_null;
|
p->returns_null = current_function_returns_null;
|
p->returns_abnormally = current_function_returns_abnormally;
|
p->returns_abnormally = current_function_returns_abnormally;
|
p->warn_about_return_type = warn_about_return_type;
|
p->warn_about_return_type = warn_about_return_type;
|
|
|
push_function_context ();
|
push_function_context ();
|
}
|
}
|
|
|
/* Restore the variables used during compilation of a C function. */
|
/* Restore the variables used during compilation of a C function. */
|
|
|
void
|
void
|
c_pop_function_context (void)
|
c_pop_function_context (void)
|
{
|
{
|
struct language_function *p;
|
struct language_function *p;
|
|
|
pop_function_context ();
|
pop_function_context ();
|
p = cfun->language;
|
p = cfun->language;
|
cfun->language = NULL;
|
cfun->language = NULL;
|
|
|
if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
|
if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
|
&& DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
|
&& DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
|
{
|
{
|
/* Stop pointing to the local nodes about to be freed. */
|
/* Stop pointing to the local nodes about to be freed. */
|
/* But DECL_INITIAL must remain nonzero so we know this
|
/* But DECL_INITIAL must remain nonzero so we know this
|
was an actual function definition. */
|
was an actual function definition. */
|
DECL_INITIAL (current_function_decl) = error_mark_node;
|
DECL_INITIAL (current_function_decl) = error_mark_node;
|
DECL_ARGUMENTS (current_function_decl) = 0;
|
DECL_ARGUMENTS (current_function_decl) = 0;
|
}
|
}
|
|
|
c_stmt_tree = p->base.x_stmt_tree;
|
c_stmt_tree = p->base.x_stmt_tree;
|
c_break_label = p->x_break_label;
|
c_break_label = p->x_break_label;
|
c_cont_label = p->x_cont_label;
|
c_cont_label = p->x_cont_label;
|
c_switch_stack = p->x_switch_stack;
|
c_switch_stack = p->x_switch_stack;
|
current_function_arg_info = p->arg_info;
|
current_function_arg_info = p->arg_info;
|
current_function_returns_value = p->returns_value;
|
current_function_returns_value = p->returns_value;
|
current_function_returns_null = p->returns_null;
|
current_function_returns_null = p->returns_null;
|
current_function_returns_abnormally = p->returns_abnormally;
|
current_function_returns_abnormally = p->returns_abnormally;
|
warn_about_return_type = p->warn_about_return_type;
|
warn_about_return_type = p->warn_about_return_type;
|
}
|
}
|
|
|
/* The functions below are required for functionality of doing
|
/* The functions below are required for functionality of doing
|
function at once processing in the C front end. Currently these
|
function at once processing in the C front end. Currently these
|
functions are not called from anywhere in the C front end, but as
|
functions are not called from anywhere in the C front end, but as
|
these changes continue, that will change. */
|
these changes continue, that will change. */
|
|
|
/* Returns the stmt_tree (if any) to which statements are currently
|
/* Returns the stmt_tree (if any) to which statements are currently
|
being added. If there is no active statement-tree, NULL is
|
being added. If there is no active statement-tree, NULL is
|
returned. */
|
returned. */
|
|
|
stmt_tree
|
stmt_tree
|
current_stmt_tree (void)
|
current_stmt_tree (void)
|
{
|
{
|
return &c_stmt_tree;
|
return &c_stmt_tree;
|
}
|
}
|
|
|
/* Return the global value of T as a symbol. */
|
/* Return the global value of T as a symbol. */
|
|
|
tree
|
tree
|
identifier_global_value (tree t)
|
identifier_global_value (tree t)
|
{
|
{
|
struct c_binding *b;
|
struct c_binding *b;
|
|
|
for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
|
for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
|
if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
|
if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
|
return b->decl;
|
return b->decl;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Record a builtin type for C. If NAME is non-NULL, it is the name used;
|
/* Record a builtin type for C. If NAME is non-NULL, it is the name used;
|
otherwise the name is found in ridpointers from RID_INDEX. */
|
otherwise the name is found in ridpointers from RID_INDEX. */
|
|
|
void
|
void
|
record_builtin_type (enum rid rid_index, const char *name, tree type)
|
record_builtin_type (enum rid rid_index, const char *name, tree type)
|
{
|
{
|
tree id, decl;
|
tree id, decl;
|
if (name == 0)
|
if (name == 0)
|
id = ridpointers[(int) rid_index];
|
id = ridpointers[(int) rid_index];
|
else
|
else
|
id = get_identifier (name);
|
id = get_identifier (name);
|
decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, id, type);
|
decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, id, type);
|
pushdecl (decl);
|
pushdecl (decl);
|
if (debug_hooks->type_decl)
|
if (debug_hooks->type_decl)
|
debug_hooks->type_decl (decl, false);
|
debug_hooks->type_decl (decl, false);
|
}
|
}
|
|
|
/* Build the void_list_node (void_type_node having been created). */
|
/* Build the void_list_node (void_type_node having been created). */
|
tree
|
tree
|
build_void_list_node (void)
|
build_void_list_node (void)
|
{
|
{
|
tree t = build_tree_list (NULL_TREE, void_type_node);
|
tree t = build_tree_list (NULL_TREE, void_type_node);
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
|
/* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
|
|
|
struct c_parm *
|
struct c_parm *
|
build_c_parm (struct c_declspecs *specs, tree attrs,
|
build_c_parm (struct c_declspecs *specs, tree attrs,
|
struct c_declarator *declarator)
|
struct c_declarator *declarator)
|
{
|
{
|
struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
|
struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
|
ret->specs = specs;
|
ret->specs = specs;
|
ret->attrs = attrs;
|
ret->attrs = attrs;
|
ret->declarator = declarator;
|
ret->declarator = declarator;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Return a declarator with nested attributes. TARGET is the inner
|
/* Return a declarator with nested attributes. TARGET is the inner
|
declarator to which these attributes apply. ATTRS are the
|
declarator to which these attributes apply. ATTRS are the
|
attributes. */
|
attributes. */
|
|
|
struct c_declarator *
|
struct c_declarator *
|
build_attrs_declarator (tree attrs, struct c_declarator *target)
|
build_attrs_declarator (tree attrs, struct c_declarator *target)
|
{
|
{
|
struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
|
struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
|
ret->kind = cdk_attrs;
|
ret->kind = cdk_attrs;
|
ret->declarator = target;
|
ret->declarator = target;
|
ret->u.attrs = attrs;
|
ret->u.attrs = attrs;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Return a declarator for a function with arguments specified by ARGS
|
/* Return a declarator for a function with arguments specified by ARGS
|
and return type specified by TARGET. */
|
and return type specified by TARGET. */
|
|
|
struct c_declarator *
|
struct c_declarator *
|
build_function_declarator (struct c_arg_info *args,
|
build_function_declarator (struct c_arg_info *args,
|
struct c_declarator *target)
|
struct c_declarator *target)
|
{
|
{
|
struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
|
struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
|
ret->kind = cdk_function;
|
ret->kind = cdk_function;
|
ret->declarator = target;
|
ret->declarator = target;
|
ret->u.arg_info = args;
|
ret->u.arg_info = args;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Return a declarator for the identifier IDENT (which may be
|
/* Return a declarator for the identifier IDENT (which may be
|
NULL_TREE for an abstract declarator). */
|
NULL_TREE for an abstract declarator). */
|
|
|
struct c_declarator *
|
struct c_declarator *
|
build_id_declarator (tree ident)
|
build_id_declarator (tree ident)
|
{
|
{
|
struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
|
struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
|
ret->kind = cdk_id;
|
ret->kind = cdk_id;
|
ret->declarator = 0;
|
ret->declarator = 0;
|
ret->u.id = ident;
|
ret->u.id = ident;
|
/* Default value - may get reset to a more precise location. */
|
/* Default value - may get reset to a more precise location. */
|
ret->id_loc = input_location;
|
ret->id_loc = input_location;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Return something to represent absolute declarators containing a *.
|
/* Return something to represent absolute declarators containing a *.
|
TARGET is the absolute declarator that the * contains.
|
TARGET is the absolute declarator that the * contains.
|
TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
|
TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
|
to apply to the pointer type. */
|
to apply to the pointer type. */
|
|
|
struct c_declarator *
|
struct c_declarator *
|
make_pointer_declarator (struct c_declspecs *type_quals_attrs,
|
make_pointer_declarator (struct c_declspecs *type_quals_attrs,
|
struct c_declarator *target)
|
struct c_declarator *target)
|
{
|
{
|
tree attrs;
|
tree attrs;
|
int quals = 0;
|
int quals = 0;
|
struct c_declarator *itarget = target;
|
struct c_declarator *itarget = target;
|
struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
|
struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
|
if (type_quals_attrs)
|
if (type_quals_attrs)
|
{
|
{
|
attrs = type_quals_attrs->attrs;
|
attrs = type_quals_attrs->attrs;
|
quals = quals_from_declspecs (type_quals_attrs);
|
quals = quals_from_declspecs (type_quals_attrs);
|
if (attrs != NULL_TREE)
|
if (attrs != NULL_TREE)
|
itarget = build_attrs_declarator (attrs, target);
|
itarget = build_attrs_declarator (attrs, target);
|
}
|
}
|
ret->kind = cdk_pointer;
|
ret->kind = cdk_pointer;
|
ret->declarator = itarget;
|
ret->declarator = itarget;
|
ret->u.pointer_quals = quals;
|
ret->u.pointer_quals = quals;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Return a pointer to a structure for an empty list of declaration
|
/* Return a pointer to a structure for an empty list of declaration
|
specifiers. */
|
specifiers. */
|
|
|
struct c_declspecs *
|
struct c_declspecs *
|
build_null_declspecs (void)
|
build_null_declspecs (void)
|
{
|
{
|
struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
|
struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
|
ret->type = 0;
|
ret->type = 0;
|
ret->expr = 0;
|
ret->expr = 0;
|
ret->decl_attr = 0;
|
ret->decl_attr = 0;
|
ret->attrs = 0;
|
ret->attrs = 0;
|
ret->typespec_word = cts_none;
|
ret->typespec_word = cts_none;
|
ret->storage_class = csc_none;
|
ret->storage_class = csc_none;
|
ret->expr_const_operands = true;
|
ret->expr_const_operands = true;
|
ret->declspecs_seen_p = false;
|
ret->declspecs_seen_p = false;
|
ret->type_seen_p = false;
|
ret->type_seen_p = false;
|
ret->non_sc_seen_p = false;
|
ret->non_sc_seen_p = false;
|
ret->typedef_p = false;
|
ret->typedef_p = false;
|
ret->tag_defined_p = false;
|
ret->tag_defined_p = false;
|
ret->explicit_signed_p = false;
|
ret->explicit_signed_p = false;
|
ret->deprecated_p = false;
|
ret->deprecated_p = false;
|
ret->default_int_p = false;
|
ret->default_int_p = false;
|
ret->long_p = false;
|
ret->long_p = false;
|
ret->long_long_p = false;
|
ret->long_long_p = false;
|
ret->short_p = false;
|
ret->short_p = false;
|
ret->signed_p = false;
|
ret->signed_p = false;
|
ret->unsigned_p = false;
|
ret->unsigned_p = false;
|
ret->complex_p = false;
|
ret->complex_p = false;
|
ret->inline_p = false;
|
ret->inline_p = false;
|
ret->thread_p = false;
|
ret->thread_p = false;
|
ret->const_p = false;
|
ret->const_p = false;
|
ret->volatile_p = false;
|
ret->volatile_p = false;
|
ret->restrict_p = false;
|
ret->restrict_p = false;
|
ret->saturating_p = false;
|
ret->saturating_p = false;
|
ret->address_space = ADDR_SPACE_GENERIC;
|
ret->address_space = ADDR_SPACE_GENERIC;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Add the address space ADDRSPACE to the declaration specifiers
|
/* Add the address space ADDRSPACE to the declaration specifiers
|
SPECS, returning SPECS. */
|
SPECS, returning SPECS. */
|
|
|
struct c_declspecs *
|
struct c_declspecs *
|
declspecs_add_addrspace (struct c_declspecs *specs, addr_space_t as)
|
declspecs_add_addrspace (struct c_declspecs *specs, addr_space_t as)
|
{
|
{
|
specs->non_sc_seen_p = true;
|
specs->non_sc_seen_p = true;
|
specs->declspecs_seen_p = true;
|
specs->declspecs_seen_p = true;
|
|
|
if (!ADDR_SPACE_GENERIC_P (specs->address_space)
|
if (!ADDR_SPACE_GENERIC_P (specs->address_space)
|
&& specs->address_space != as)
|
&& specs->address_space != as)
|
error ("incompatible address space qualifiers %qs and %qs",
|
error ("incompatible address space qualifiers %qs and %qs",
|
c_addr_space_name (as),
|
c_addr_space_name (as),
|
c_addr_space_name (specs->address_space));
|
c_addr_space_name (specs->address_space));
|
else
|
else
|
specs->address_space = as;
|
specs->address_space = as;
|
return specs;
|
return specs;
|
}
|
}
|
|
|
/* Add the type qualifier QUAL to the declaration specifiers SPECS,
|
/* Add the type qualifier QUAL to the declaration specifiers SPECS,
|
returning SPECS. */
|
returning SPECS. */
|
|
|
struct c_declspecs *
|
struct c_declspecs *
|
declspecs_add_qual (struct c_declspecs *specs, tree qual)
|
declspecs_add_qual (struct c_declspecs *specs, tree qual)
|
{
|
{
|
enum rid i;
|
enum rid i;
|
bool dupe = false;
|
bool dupe = false;
|
specs->non_sc_seen_p = true;
|
specs->non_sc_seen_p = true;
|
specs->declspecs_seen_p = true;
|
specs->declspecs_seen_p = true;
|
gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
|
gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
|
&& C_IS_RESERVED_WORD (qual));
|
&& C_IS_RESERVED_WORD (qual));
|
i = C_RID_CODE (qual);
|
i = C_RID_CODE (qual);
|
switch (i)
|
switch (i)
|
{
|
{
|
case RID_CONST:
|
case RID_CONST:
|
dupe = specs->const_p;
|
dupe = specs->const_p;
|
specs->const_p = true;
|
specs->const_p = true;
|
break;
|
break;
|
case RID_VOLATILE:
|
case RID_VOLATILE:
|
dupe = specs->volatile_p;
|
dupe = specs->volatile_p;
|
specs->volatile_p = true;
|
specs->volatile_p = true;
|
break;
|
break;
|
case RID_RESTRICT:
|
case RID_RESTRICT:
|
dupe = specs->restrict_p;
|
dupe = specs->restrict_p;
|
specs->restrict_p = true;
|
specs->restrict_p = true;
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
if (dupe && !flag_isoc99)
|
if (dupe && !flag_isoc99)
|
pedwarn (input_location, OPT_pedantic, "duplicate %qE", qual);
|
pedwarn (input_location, OPT_pedantic, "duplicate %qE", qual);
|
return specs;
|
return specs;
|
}
|
}
|
|
|
/* Add the type specifier TYPE to the declaration specifiers SPECS,
|
/* Add the type specifier TYPE to the declaration specifiers SPECS,
|
returning SPECS. */
|
returning SPECS. */
|
|
|
struct c_declspecs *
|
struct c_declspecs *
|
declspecs_add_type (location_t loc, struct c_declspecs *specs,
|
declspecs_add_type (location_t loc, struct c_declspecs *specs,
|
struct c_typespec spec)
|
struct c_typespec spec)
|
{
|
{
|
tree type = spec.spec;
|
tree type = spec.spec;
|
specs->non_sc_seen_p = true;
|
specs->non_sc_seen_p = true;
|
specs->declspecs_seen_p = true;
|
specs->declspecs_seen_p = true;
|
specs->type_seen_p = true;
|
specs->type_seen_p = true;
|
if (TREE_DEPRECATED (type))
|
if (TREE_DEPRECATED (type))
|
specs->deprecated_p = true;
|
specs->deprecated_p = true;
|
|
|
/* Handle type specifier keywords. */
|
/* Handle type specifier keywords. */
|
if (TREE_CODE (type) == IDENTIFIER_NODE
|
if (TREE_CODE (type) == IDENTIFIER_NODE
|
&& C_IS_RESERVED_WORD (type)
|
&& C_IS_RESERVED_WORD (type)
|
&& C_RID_CODE (type) != RID_CXX_COMPAT_WARN)
|
&& C_RID_CODE (type) != RID_CXX_COMPAT_WARN)
|
{
|
{
|
enum rid i = C_RID_CODE (type);
|
enum rid i = C_RID_CODE (type);
|
if (specs->type)
|
if (specs->type)
|
{
|
{
|
error_at (loc, "two or more data types in declaration specifiers");
|
error_at (loc, "two or more data types in declaration specifiers");
|
return specs;
|
return specs;
|
}
|
}
|
if ((int) i <= (int) RID_LAST_MODIFIER)
|
if ((int) i <= (int) RID_LAST_MODIFIER)
|
{
|
{
|
/* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
|
/* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
|
bool dupe = false;
|
bool dupe = false;
|
switch (i)
|
switch (i)
|
{
|
{
|
case RID_LONG:
|
case RID_LONG:
|
if (specs->long_long_p)
|
if (specs->long_long_p)
|
{
|
{
|
error_at (loc, "%<long long long%> is too long for GCC");
|
error_at (loc, "%<long long long%> is too long for GCC");
|
break;
|
break;
|
}
|
}
|
if (specs->long_p)
|
if (specs->long_p)
|
{
|
{
|
if (specs->typespec_word == cts_double)
|
if (specs->typespec_word == cts_double)
|
{
|
{
|
error_at (loc,
|
error_at (loc,
|
("both %<long long%> and %<double%> in "
|
("both %<long long%> and %<double%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
break;
|
break;
|
}
|
}
|
pedwarn_c90 (loc, OPT_Wlong_long,
|
pedwarn_c90 (loc, OPT_Wlong_long,
|
"ISO C90 does not support %<long long%>");
|
"ISO C90 does not support %<long long%>");
|
specs->long_long_p = 1;
|
specs->long_long_p = 1;
|
break;
|
break;
|
}
|
}
|
if (specs->short_p)
|
if (specs->short_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<short%> in "
|
("both %<long%> and %<short%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_void)
|
else if (specs->typespec_word == cts_void)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<void%> in "
|
("both %<long%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_bool)
|
else if (specs->typespec_word == cts_bool)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<_Bool%> in "
|
("both %<long%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_char)
|
else if (specs->typespec_word == cts_char)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<char%> in "
|
("both %<long%> and %<char%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_float)
|
else if (specs->typespec_word == cts_float)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<float%> in "
|
("both %<long%> and %<float%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat32)
|
else if (specs->typespec_word == cts_dfloat32)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<_Decimal32%> in "
|
("both %<long%> and %<_Decimal32%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat64)
|
else if (specs->typespec_word == cts_dfloat64)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<_Decimal64%> in "
|
("both %<long%> and %<_Decimal64%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat128)
|
else if (specs->typespec_word == cts_dfloat128)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<_Decimal128%> in "
|
("both %<long%> and %<_Decimal128%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->long_p = true;
|
specs->long_p = true;
|
break;
|
break;
|
case RID_SHORT:
|
case RID_SHORT:
|
dupe = specs->short_p;
|
dupe = specs->short_p;
|
if (specs->long_p)
|
if (specs->long_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<short%> in "
|
("both %<long%> and %<short%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_void)
|
else if (specs->typespec_word == cts_void)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<void%> in "
|
("both %<short%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_bool)
|
else if (specs->typespec_word == cts_bool)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<_Bool%> in "
|
("both %<short%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_char)
|
else if (specs->typespec_word == cts_char)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<char%> in "
|
("both %<short%> and %<char%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_float)
|
else if (specs->typespec_word == cts_float)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<float%> in "
|
("both %<short%> and %<float%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_double)
|
else if (specs->typespec_word == cts_double)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<double%> in "
|
("both %<short%> and %<double%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat32)
|
else if (specs->typespec_word == cts_dfloat32)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<_Decimal32%> in "
|
("both %<short%> and %<_Decimal32%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat64)
|
else if (specs->typespec_word == cts_dfloat64)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<_Decimal64%> in "
|
("both %<short%> and %<_Decimal64%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat128)
|
else if (specs->typespec_word == cts_dfloat128)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<_Decimal128%> in "
|
("both %<short%> and %<_Decimal128%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->short_p = true;
|
specs->short_p = true;
|
break;
|
break;
|
case RID_SIGNED:
|
case RID_SIGNED:
|
dupe = specs->signed_p;
|
dupe = specs->signed_p;
|
if (specs->unsigned_p)
|
if (specs->unsigned_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<unsigned%> in "
|
("both %<signed%> and %<unsigned%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_void)
|
else if (specs->typespec_word == cts_void)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<void%> in "
|
("both %<signed%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_bool)
|
else if (specs->typespec_word == cts_bool)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<_Bool%> in "
|
("both %<signed%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_float)
|
else if (specs->typespec_word == cts_float)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<float%> in "
|
("both %<signed%> and %<float%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_double)
|
else if (specs->typespec_word == cts_double)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<double%> in "
|
("both %<signed%> and %<double%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat32)
|
else if (specs->typespec_word == cts_dfloat32)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<_Decimal32%> in "
|
("both %<signed%> and %<_Decimal32%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat64)
|
else if (specs->typespec_word == cts_dfloat64)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<_Decimal64%> in "
|
("both %<signed%> and %<_Decimal64%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat128)
|
else if (specs->typespec_word == cts_dfloat128)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<_Decimal128%> in "
|
("both %<signed%> and %<_Decimal128%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->signed_p = true;
|
specs->signed_p = true;
|
break;
|
break;
|
case RID_UNSIGNED:
|
case RID_UNSIGNED:
|
dupe = specs->unsigned_p;
|
dupe = specs->unsigned_p;
|
if (specs->signed_p)
|
if (specs->signed_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<unsigned%> in "
|
("both %<signed%> and %<unsigned%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_void)
|
else if (specs->typespec_word == cts_void)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<void%> in "
|
("both %<unsigned%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_bool)
|
else if (specs->typespec_word == cts_bool)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<_Bool%> in "
|
("both %<unsigned%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_float)
|
else if (specs->typespec_word == cts_float)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<float%> in "
|
("both %<unsigned%> and %<float%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_double)
|
else if (specs->typespec_word == cts_double)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<double%> in "
|
("both %<unsigned%> and %<double%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat32)
|
else if (specs->typespec_word == cts_dfloat32)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<_Decimal32%> in "
|
("both %<unsigned%> and %<_Decimal32%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat64)
|
else if (specs->typespec_word == cts_dfloat64)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<_Decimal64%> in "
|
("both %<unsigned%> and %<_Decimal64%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat128)
|
else if (specs->typespec_word == cts_dfloat128)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<_Decimal128%> in "
|
("both %<unsigned%> and %<_Decimal128%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->unsigned_p = true;
|
specs->unsigned_p = true;
|
break;
|
break;
|
case RID_COMPLEX:
|
case RID_COMPLEX:
|
dupe = specs->complex_p;
|
dupe = specs->complex_p;
|
if (!flag_isoc99 && !in_system_header)
|
if (!flag_isoc99 && !in_system_header)
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C90 does not support complex types");
|
"ISO C90 does not support complex types");
|
if (specs->typespec_word == cts_void)
|
if (specs->typespec_word == cts_void)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<void%> in "
|
("both %<complex%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_bool)
|
else if (specs->typespec_word == cts_bool)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<_Bool%> in "
|
("both %<complex%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat32)
|
else if (specs->typespec_word == cts_dfloat32)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<_Decimal32%> in "
|
("both %<complex%> and %<_Decimal32%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat64)
|
else if (specs->typespec_word == cts_dfloat64)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<_Decimal64%> in "
|
("both %<complex%> and %<_Decimal64%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat128)
|
else if (specs->typespec_word == cts_dfloat128)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<_Decimal128%> in "
|
("both %<complex%> and %<_Decimal128%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_fract)
|
else if (specs->typespec_word == cts_fract)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<_Fract%> in "
|
("both %<complex%> and %<_Fract%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_accum)
|
else if (specs->typespec_word == cts_accum)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<_Accum%> in "
|
("both %<complex%> and %<_Accum%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->saturating_p)
|
else if (specs->saturating_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<_Sat%> in "
|
("both %<complex%> and %<_Sat%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->complex_p = true;
|
specs->complex_p = true;
|
break;
|
break;
|
case RID_SAT:
|
case RID_SAT:
|
dupe = specs->saturating_p;
|
dupe = specs->saturating_p;
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C does not support saturating types");
|
"ISO C does not support saturating types");
|
if (specs->typespec_word == cts_void)
|
if (specs->typespec_word == cts_void)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<void%> in "
|
("both %<_Sat%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_bool)
|
else if (specs->typespec_word == cts_bool)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<_Bool%> in "
|
("both %<_Sat%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_char)
|
else if (specs->typespec_word == cts_char)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<char%> in "
|
("both %<_Sat%> and %<char%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_int)
|
else if (specs->typespec_word == cts_int)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<int%> in "
|
("both %<_Sat%> and %<int%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_float)
|
else if (specs->typespec_word == cts_float)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<float%> in "
|
("both %<_Sat%> and %<float%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_double)
|
else if (specs->typespec_word == cts_double)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<double%> in "
|
("both %<_Sat%> and %<double%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat32)
|
else if (specs->typespec_word == cts_dfloat32)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<_Decimal32%> in "
|
("both %<_Sat%> and %<_Decimal32%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat64)
|
else if (specs->typespec_word == cts_dfloat64)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<_Decimal64%> in "
|
("both %<_Sat%> and %<_Decimal64%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->typespec_word == cts_dfloat128)
|
else if (specs->typespec_word == cts_dfloat128)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<_Decimal128%> in "
|
("both %<_Sat%> and %<_Decimal128%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->complex_p)
|
else if (specs->complex_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<complex%> in "
|
("both %<_Sat%> and %<complex%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->saturating_p = true;
|
specs->saturating_p = true;
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
if (dupe)
|
if (dupe)
|
error_at (loc, "duplicate %qE", type);
|
error_at (loc, "duplicate %qE", type);
|
|
|
return specs;
|
return specs;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
|
/* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
|
"_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
|
"_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
|
if (specs->typespec_word != cts_none)
|
if (specs->typespec_word != cts_none)
|
{
|
{
|
error_at (loc,
|
error_at (loc,
|
"two or more data types in declaration specifiers");
|
"two or more data types in declaration specifiers");
|
return specs;
|
return specs;
|
}
|
}
|
switch (i)
|
switch (i)
|
{
|
{
|
case RID_VOID:
|
case RID_VOID:
|
if (specs->long_p)
|
if (specs->long_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<void%> in "
|
("both %<long%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->short_p)
|
else if (specs->short_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<void%> in "
|
("both %<short%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->signed_p)
|
else if (specs->signed_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<void%> in "
|
("both %<signed%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->unsigned_p)
|
else if (specs->unsigned_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<void%> in "
|
("both %<unsigned%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->complex_p)
|
else if (specs->complex_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<void%> in "
|
("both %<complex%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->saturating_p)
|
else if (specs->saturating_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<void%> in "
|
("both %<_Sat%> and %<void%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->typespec_word = cts_void;
|
specs->typespec_word = cts_void;
|
return specs;
|
return specs;
|
case RID_BOOL:
|
case RID_BOOL:
|
if (specs->long_p)
|
if (specs->long_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<_Bool%> in "
|
("both %<long%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->short_p)
|
else if (specs->short_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<_Bool%> in "
|
("both %<short%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->signed_p)
|
else if (specs->signed_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<_Bool%> in "
|
("both %<signed%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->unsigned_p)
|
else if (specs->unsigned_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<_Bool%> in "
|
("both %<unsigned%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->complex_p)
|
else if (specs->complex_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<_Bool%> in "
|
("both %<complex%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->saturating_p)
|
else if (specs->saturating_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<_Bool%> in "
|
("both %<_Sat%> and %<_Bool%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->typespec_word = cts_bool;
|
specs->typespec_word = cts_bool;
|
return specs;
|
return specs;
|
case RID_CHAR:
|
case RID_CHAR:
|
if (specs->long_p)
|
if (specs->long_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<char%> in "
|
("both %<long%> and %<char%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->short_p)
|
else if (specs->short_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<char%> in "
|
("both %<short%> and %<char%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->saturating_p)
|
else if (specs->saturating_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<char%> in "
|
("both %<_Sat%> and %<char%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->typespec_word = cts_char;
|
specs->typespec_word = cts_char;
|
return specs;
|
return specs;
|
case RID_INT:
|
case RID_INT:
|
if (specs->saturating_p)
|
if (specs->saturating_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<int%> in "
|
("both %<_Sat%> and %<int%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->typespec_word = cts_int;
|
specs->typespec_word = cts_int;
|
return specs;
|
return specs;
|
case RID_FLOAT:
|
case RID_FLOAT:
|
if (specs->long_p)
|
if (specs->long_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<float%> in "
|
("both %<long%> and %<float%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->short_p)
|
else if (specs->short_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<float%> in "
|
("both %<short%> and %<float%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->signed_p)
|
else if (specs->signed_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<float%> in "
|
("both %<signed%> and %<float%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->unsigned_p)
|
else if (specs->unsigned_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<float%> in "
|
("both %<unsigned%> and %<float%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->saturating_p)
|
else if (specs->saturating_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<float%> in "
|
("both %<_Sat%> and %<float%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->typespec_word = cts_float;
|
specs->typespec_word = cts_float;
|
return specs;
|
return specs;
|
case RID_DOUBLE:
|
case RID_DOUBLE:
|
if (specs->long_long_p)
|
if (specs->long_long_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<long long%> and %<double%> in "
|
("both %<long long%> and %<double%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->short_p)
|
else if (specs->short_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<double%> in "
|
("both %<short%> and %<double%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->signed_p)
|
else if (specs->signed_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<double%> in "
|
("both %<signed%> and %<double%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->unsigned_p)
|
else if (specs->unsigned_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<double%> in "
|
("both %<unsigned%> and %<double%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else if (specs->saturating_p)
|
else if (specs->saturating_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<double%> in "
|
("both %<_Sat%> and %<double%> in "
|
"declaration specifiers"));
|
"declaration specifiers"));
|
else
|
else
|
specs->typespec_word = cts_double;
|
specs->typespec_word = cts_double;
|
return specs;
|
return specs;
|
case RID_DFLOAT32:
|
case RID_DFLOAT32:
|
case RID_DFLOAT64:
|
case RID_DFLOAT64:
|
case RID_DFLOAT128:
|
case RID_DFLOAT128:
|
{
|
{
|
const char *str;
|
const char *str;
|
if (i == RID_DFLOAT32)
|
if (i == RID_DFLOAT32)
|
str = "_Decimal32";
|
str = "_Decimal32";
|
else if (i == RID_DFLOAT64)
|
else if (i == RID_DFLOAT64)
|
str = "_Decimal64";
|
str = "_Decimal64";
|
else
|
else
|
str = "_Decimal128";
|
str = "_Decimal128";
|
if (specs->long_long_p)
|
if (specs->long_long_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<long long%> and %<%s%> in "
|
("both %<long long%> and %<%s%> in "
|
"declaration specifiers"),
|
"declaration specifiers"),
|
str);
|
str);
|
if (specs->long_p)
|
if (specs->long_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<long%> and %<%s%> in "
|
("both %<long%> and %<%s%> in "
|
"declaration specifiers"),
|
"declaration specifiers"),
|
str);
|
str);
|
else if (specs->short_p)
|
else if (specs->short_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<short%> and %<%s%> in "
|
("both %<short%> and %<%s%> in "
|
"declaration specifiers"),
|
"declaration specifiers"),
|
str);
|
str);
|
else if (specs->signed_p)
|
else if (specs->signed_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<signed%> and %<%s%> in "
|
("both %<signed%> and %<%s%> in "
|
"declaration specifiers"),
|
"declaration specifiers"),
|
str);
|
str);
|
else if (specs->unsigned_p)
|
else if (specs->unsigned_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<unsigned%> and %<%s%> in "
|
("both %<unsigned%> and %<%s%> in "
|
"declaration specifiers"),
|
"declaration specifiers"),
|
str);
|
str);
|
else if (specs->complex_p)
|
else if (specs->complex_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<%s%> in "
|
("both %<complex%> and %<%s%> in "
|
"declaration specifiers"),
|
"declaration specifiers"),
|
str);
|
str);
|
else if (specs->saturating_p)
|
else if (specs->saturating_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<_Sat%> and %<%s%> in "
|
("both %<_Sat%> and %<%s%> in "
|
"declaration specifiers"),
|
"declaration specifiers"),
|
str);
|
str);
|
else if (i == RID_DFLOAT32)
|
else if (i == RID_DFLOAT32)
|
specs->typespec_word = cts_dfloat32;
|
specs->typespec_word = cts_dfloat32;
|
else if (i == RID_DFLOAT64)
|
else if (i == RID_DFLOAT64)
|
specs->typespec_word = cts_dfloat64;
|
specs->typespec_word = cts_dfloat64;
|
else
|
else
|
specs->typespec_word = cts_dfloat128;
|
specs->typespec_word = cts_dfloat128;
|
}
|
}
|
if (!targetm.decimal_float_supported_p ())
|
if (!targetm.decimal_float_supported_p ())
|
error_at (loc,
|
error_at (loc,
|
("decimal floating point not supported "
|
("decimal floating point not supported "
|
"for this target"));
|
"for this target"));
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C does not support decimal floating point");
|
"ISO C does not support decimal floating point");
|
return specs;
|
return specs;
|
case RID_FRACT:
|
case RID_FRACT:
|
case RID_ACCUM:
|
case RID_ACCUM:
|
{
|
{
|
const char *str;
|
const char *str;
|
if (i == RID_FRACT)
|
if (i == RID_FRACT)
|
str = "_Fract";
|
str = "_Fract";
|
else
|
else
|
str = "_Accum";
|
str = "_Accum";
|
if (specs->complex_p)
|
if (specs->complex_p)
|
error_at (loc,
|
error_at (loc,
|
("both %<complex%> and %<%s%> in "
|
("both %<complex%> and %<%s%> in "
|
"declaration specifiers"),
|
"declaration specifiers"),
|
str);
|
str);
|
else if (i == RID_FRACT)
|
else if (i == RID_FRACT)
|
specs->typespec_word = cts_fract;
|
specs->typespec_word = cts_fract;
|
else
|
else
|
specs->typespec_word = cts_accum;
|
specs->typespec_word = cts_accum;
|
}
|
}
|
if (!targetm.fixed_point_supported_p ())
|
if (!targetm.fixed_point_supported_p ())
|
error_at (loc,
|
error_at (loc,
|
"fixed-point types not supported for this target");
|
"fixed-point types not supported for this target");
|
pedwarn (loc, OPT_pedantic,
|
pedwarn (loc, OPT_pedantic,
|
"ISO C does not support fixed-point types");
|
"ISO C does not support fixed-point types");
|
return specs;
|
return specs;
|
default:
|
default:
|
/* ObjC reserved word "id", handled below. */
|
/* ObjC reserved word "id", handled below. */
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Now we have a typedef (a TYPE_DECL node), an identifier (some
|
/* Now we have a typedef (a TYPE_DECL node), an identifier (some
|
form of ObjC type, cases such as "int" and "long" being handled
|
form of ObjC type, cases such as "int" and "long" being handled
|
above), a TYPE (struct, union, enum and typeof specifiers) or an
|
above), a TYPE (struct, union, enum and typeof specifiers) or an
|
ERROR_MARK. In none of these cases may there have previously
|
ERROR_MARK. In none of these cases may there have previously
|
been any type specifiers. */
|
been any type specifiers. */
|
if (specs->type || specs->typespec_word != cts_none
|
if (specs->type || specs->typespec_word != cts_none
|
|| specs->long_p || specs->short_p || specs->signed_p
|
|| specs->long_p || specs->short_p || specs->signed_p
|
|| specs->unsigned_p || specs->complex_p)
|
|| specs->unsigned_p || specs->complex_p)
|
error_at (loc, "two or more data types in declaration specifiers");
|
error_at (loc, "two or more data types in declaration specifiers");
|
else if (TREE_CODE (type) == TYPE_DECL)
|
else if (TREE_CODE (type) == TYPE_DECL)
|
{
|
{
|
if (TREE_TYPE (type) == error_mark_node)
|
if (TREE_TYPE (type) == error_mark_node)
|
; /* Allow the type to default to int to avoid cascading errors. */
|
; /* Allow the type to default to int to avoid cascading errors. */
|
else
|
else
|
{
|
{
|
specs->type = TREE_TYPE (type);
|
specs->type = TREE_TYPE (type);
|
specs->decl_attr = DECL_ATTRIBUTES (type);
|
specs->decl_attr = DECL_ATTRIBUTES (type);
|
specs->typedef_p = true;
|
specs->typedef_p = true;
|
specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
|
specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
|
|
|
/* If this typedef name is defined in a struct, then a C++
|
/* If this typedef name is defined in a struct, then a C++
|
lookup would return a different value. */
|
lookup would return a different value. */
|
if (warn_cxx_compat
|
if (warn_cxx_compat
|
&& I_SYMBOL_BINDING (DECL_NAME (type))->in_struct)
|
&& I_SYMBOL_BINDING (DECL_NAME (type))->in_struct)
|
warning_at (loc, OPT_Wc___compat,
|
warning_at (loc, OPT_Wc___compat,
|
"C++ lookup of %qD would return a field, not a type",
|
"C++ lookup of %qD would return a field, not a type",
|
type);
|
type);
|
|
|
/* If we are parsing a struct, record that a struct field
|
/* If we are parsing a struct, record that a struct field
|
used a typedef. */
|
used a typedef. */
|
if (warn_cxx_compat && struct_parse_info != NULL)
|
if (warn_cxx_compat && struct_parse_info != NULL)
|
VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
|
VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
|
}
|
}
|
}
|
}
|
else if (TREE_CODE (type) == IDENTIFIER_NODE)
|
else if (TREE_CODE (type) == IDENTIFIER_NODE)
|
{
|
{
|
tree t = lookup_name (type);
|
tree t = lookup_name (type);
|
if (!t || TREE_CODE (t) != TYPE_DECL)
|
if (!t || TREE_CODE (t) != TYPE_DECL)
|
error_at (loc, "%qE fails to be a typedef or built in type", type);
|
error_at (loc, "%qE fails to be a typedef or built in type", type);
|
else if (TREE_TYPE (t) == error_mark_node)
|
else if (TREE_TYPE (t) == error_mark_node)
|
;
|
;
|
else
|
else
|
specs->type = TREE_TYPE (t);
|
specs->type = TREE_TYPE (t);
|
}
|
}
|
else if (TREE_CODE (type) != ERROR_MARK)
|
else if (TREE_CODE (type) != ERROR_MARK)
|
{
|
{
|
if (spec.kind == ctsk_tagdef || spec.kind == ctsk_tagfirstref)
|
if (spec.kind == ctsk_tagdef || spec.kind == ctsk_tagfirstref)
|
specs->tag_defined_p = true;
|
specs->tag_defined_p = true;
|
if (spec.kind == ctsk_typeof)
|
if (spec.kind == ctsk_typeof)
|
{
|
{
|
specs->typedef_p = true;
|
specs->typedef_p = true;
|
if (spec.expr)
|
if (spec.expr)
|
{
|
{
|
if (specs->expr)
|
if (specs->expr)
|
specs->expr = build2 (COMPOUND_EXPR, TREE_TYPE (spec.expr),
|
specs->expr = build2 (COMPOUND_EXPR, TREE_TYPE (spec.expr),
|
specs->expr, spec.expr);
|
specs->expr, spec.expr);
|
else
|
else
|
specs->expr = spec.expr;
|
specs->expr = spec.expr;
|
specs->expr_const_operands &= spec.expr_const_operands;
|
specs->expr_const_operands &= spec.expr_const_operands;
|
}
|
}
|
}
|
}
|
specs->type = type;
|
specs->type = type;
|
}
|
}
|
|
|
return specs;
|
return specs;
|
}
|
}
|
|
|
/* Add the storage class specifier or function specifier SCSPEC to the
|
/* Add the storage class specifier or function specifier SCSPEC to the
|
declaration specifiers SPECS, returning SPECS. */
|
declaration specifiers SPECS, returning SPECS. */
|
|
|
struct c_declspecs *
|
struct c_declspecs *
|
declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
|
declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
|
{
|
{
|
enum rid i;
|
enum rid i;
|
enum c_storage_class n = csc_none;
|
enum c_storage_class n = csc_none;
|
bool dupe = false;
|
bool dupe = false;
|
specs->declspecs_seen_p = true;
|
specs->declspecs_seen_p = true;
|
gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
|
gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
|
&& C_IS_RESERVED_WORD (scspec));
|
&& C_IS_RESERVED_WORD (scspec));
|
i = C_RID_CODE (scspec);
|
i = C_RID_CODE (scspec);
|
if (specs->non_sc_seen_p)
|
if (specs->non_sc_seen_p)
|
warning (OPT_Wold_style_declaration,
|
warning (OPT_Wold_style_declaration,
|
"%qE is not at beginning of declaration", scspec);
|
"%qE is not at beginning of declaration", scspec);
|
switch (i)
|
switch (i)
|
{
|
{
|
case RID_INLINE:
|
case RID_INLINE:
|
/* C99 permits duplicate inline. Although of doubtful utility,
|
/* C99 permits duplicate inline. Although of doubtful utility,
|
it seems simplest to permit it in gnu89 mode as well, as
|
it seems simplest to permit it in gnu89 mode as well, as
|
there is also little utility in maintaining this as a
|
there is also little utility in maintaining this as a
|
difference between gnu89 and C99 inline. */
|
difference between gnu89 and C99 inline. */
|
dupe = false;
|
dupe = false;
|
specs->inline_p = true;
|
specs->inline_p = true;
|
break;
|
break;
|
case RID_THREAD:
|
case RID_THREAD:
|
dupe = specs->thread_p;
|
dupe = specs->thread_p;
|
if (specs->storage_class == csc_auto)
|
if (specs->storage_class == csc_auto)
|
error ("%<__thread%> used with %<auto%>");
|
error ("%<__thread%> used with %<auto%>");
|
else if (specs->storage_class == csc_register)
|
else if (specs->storage_class == csc_register)
|
error ("%<__thread%> used with %<register%>");
|
error ("%<__thread%> used with %<register%>");
|
else if (specs->storage_class == csc_typedef)
|
else if (specs->storage_class == csc_typedef)
|
error ("%<__thread%> used with %<typedef%>");
|
error ("%<__thread%> used with %<typedef%>");
|
else
|
else
|
specs->thread_p = true;
|
specs->thread_p = true;
|
break;
|
break;
|
case RID_AUTO:
|
case RID_AUTO:
|
n = csc_auto;
|
n = csc_auto;
|
break;
|
break;
|
case RID_EXTERN:
|
case RID_EXTERN:
|
n = csc_extern;
|
n = csc_extern;
|
/* Diagnose "__thread extern". */
|
/* Diagnose "__thread extern". */
|
if (specs->thread_p)
|
if (specs->thread_p)
|
error ("%<__thread%> before %<extern%>");
|
error ("%<__thread%> before %<extern%>");
|
break;
|
break;
|
case RID_REGISTER:
|
case RID_REGISTER:
|
n = csc_register;
|
n = csc_register;
|
break;
|
break;
|
case RID_STATIC:
|
case RID_STATIC:
|
n = csc_static;
|
n = csc_static;
|
/* Diagnose "__thread static". */
|
/* Diagnose "__thread static". */
|
if (specs->thread_p)
|
if (specs->thread_p)
|
error ("%<__thread%> before %<static%>");
|
error ("%<__thread%> before %<static%>");
|
break;
|
break;
|
case RID_TYPEDEF:
|
case RID_TYPEDEF:
|
n = csc_typedef;
|
n = csc_typedef;
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
if (n != csc_none && n == specs->storage_class)
|
if (n != csc_none && n == specs->storage_class)
|
dupe = true;
|
dupe = true;
|
if (dupe)
|
if (dupe)
|
error ("duplicate %qE", scspec);
|
error ("duplicate %qE", scspec);
|
if (n != csc_none)
|
if (n != csc_none)
|
{
|
{
|
if (specs->storage_class != csc_none && n != specs->storage_class)
|
if (specs->storage_class != csc_none && n != specs->storage_class)
|
{
|
{
|
error ("multiple storage classes in declaration specifiers");
|
error ("multiple storage classes in declaration specifiers");
|
}
|
}
|
else
|
else
|
{
|
{
|
specs->storage_class = n;
|
specs->storage_class = n;
|
if (n != csc_extern && n != csc_static && specs->thread_p)
|
if (n != csc_extern && n != csc_static && specs->thread_p)
|
{
|
{
|
error ("%<__thread%> used with %qE", scspec);
|
error ("%<__thread%> used with %qE", scspec);
|
specs->thread_p = false;
|
specs->thread_p = false;
|
}
|
}
|
}
|
}
|
}
|
}
|
return specs;
|
return specs;
|
}
|
}
|
|
|
/* Add the attributes ATTRS to the declaration specifiers SPECS,
|
/* Add the attributes ATTRS to the declaration specifiers SPECS,
|
returning SPECS. */
|
returning SPECS. */
|
|
|
struct c_declspecs *
|
struct c_declspecs *
|
declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
|
declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
|
{
|
{
|
specs->attrs = chainon (attrs, specs->attrs);
|
specs->attrs = chainon (attrs, specs->attrs);
|
specs->declspecs_seen_p = true;
|
specs->declspecs_seen_p = true;
|
return specs;
|
return specs;
|
}
|
}
|
|
|
/* Combine "long", "short", "signed", "unsigned" and "_Complex" type
|
/* Combine "long", "short", "signed", "unsigned" and "_Complex" type
|
specifiers with any other type specifier to determine the resulting
|
specifiers with any other type specifier to determine the resulting
|
type. This is where ISO C checks on complex types are made, since
|
type. This is where ISO C checks on complex types are made, since
|
"_Complex long" is a prefix of the valid ISO C type "_Complex long
|
"_Complex long" is a prefix of the valid ISO C type "_Complex long
|
double". */
|
double". */
|
|
|
struct c_declspecs *
|
struct c_declspecs *
|
finish_declspecs (struct c_declspecs *specs)
|
finish_declspecs (struct c_declspecs *specs)
|
{
|
{
|
/* If a type was specified as a whole, we have no modifiers and are
|
/* If a type was specified as a whole, we have no modifiers and are
|
done. */
|
done. */
|
if (specs->type != NULL_TREE)
|
if (specs->type != NULL_TREE)
|
{
|
{
|
gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
|
gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
|
&& !specs->signed_p && !specs->unsigned_p
|
&& !specs->signed_p && !specs->unsigned_p
|
&& !specs->complex_p);
|
&& !specs->complex_p);
|
return specs;
|
return specs;
|
}
|
}
|
|
|
/* If none of "void", "_Bool", "char", "int", "float" or "double"
|
/* If none of "void", "_Bool", "char", "int", "float" or "double"
|
has been specified, treat it as "int" unless "_Complex" is
|
has been specified, treat it as "int" unless "_Complex" is
|
present and there are no other specifiers. If we just have
|
present and there are no other specifiers. If we just have
|
"_Complex", it is equivalent to "_Complex double", but e.g.
|
"_Complex", it is equivalent to "_Complex double", but e.g.
|
"_Complex short" is equivalent to "_Complex short int". */
|
"_Complex short" is equivalent to "_Complex short int". */
|
if (specs->typespec_word == cts_none)
|
if (specs->typespec_word == cts_none)
|
{
|
{
|
if (specs->saturating_p)
|
if (specs->saturating_p)
|
{
|
{
|
error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
|
error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
|
if (!targetm.fixed_point_supported_p ())
|
if (!targetm.fixed_point_supported_p ())
|
error ("fixed-point types not supported for this target");
|
error ("fixed-point types not supported for this target");
|
specs->typespec_word = cts_fract;
|
specs->typespec_word = cts_fract;
|
}
|
}
|
else if (specs->long_p || specs->short_p
|
else if (specs->long_p || specs->short_p
|
|| specs->signed_p || specs->unsigned_p)
|
|| specs->signed_p || specs->unsigned_p)
|
{
|
{
|
specs->typespec_word = cts_int;
|
specs->typespec_word = cts_int;
|
}
|
}
|
else if (specs->complex_p)
|
else if (specs->complex_p)
|
{
|
{
|
specs->typespec_word = cts_double;
|
specs->typespec_word = cts_double;
|
pedwarn (input_location, OPT_pedantic,
|
pedwarn (input_location, OPT_pedantic,
|
"ISO C does not support plain %<complex%> meaning "
|
"ISO C does not support plain %<complex%> meaning "
|
"%<double complex%>");
|
"%<double complex%>");
|
}
|
}
|
else
|
else
|
{
|
{
|
specs->typespec_word = cts_int;
|
specs->typespec_word = cts_int;
|
specs->default_int_p = true;
|
specs->default_int_p = true;
|
/* We don't diagnose this here because grokdeclarator will
|
/* We don't diagnose this here because grokdeclarator will
|
give more specific diagnostics according to whether it is
|
give more specific diagnostics according to whether it is
|
a function definition. */
|
a function definition. */
|
}
|
}
|
}
|
}
|
|
|
/* If "signed" was specified, record this to distinguish "int" and
|
/* If "signed" was specified, record this to distinguish "int" and
|
"signed int" in the case of a bit-field with
|
"signed int" in the case of a bit-field with
|
-funsigned-bitfields. */
|
-funsigned-bitfields. */
|
specs->explicit_signed_p = specs->signed_p;
|
specs->explicit_signed_p = specs->signed_p;
|
|
|
/* Now compute the actual type. */
|
/* Now compute the actual type. */
|
switch (specs->typespec_word)
|
switch (specs->typespec_word)
|
{
|
{
|
case cts_void:
|
case cts_void:
|
gcc_assert (!specs->long_p && !specs->short_p
|
gcc_assert (!specs->long_p && !specs->short_p
|
&& !specs->signed_p && !specs->unsigned_p
|
&& !specs->signed_p && !specs->unsigned_p
|
&& !specs->complex_p);
|
&& !specs->complex_p);
|
specs->type = void_type_node;
|
specs->type = void_type_node;
|
break;
|
break;
|
case cts_bool:
|
case cts_bool:
|
gcc_assert (!specs->long_p && !specs->short_p
|
gcc_assert (!specs->long_p && !specs->short_p
|
&& !specs->signed_p && !specs->unsigned_p
|
&& !specs->signed_p && !specs->unsigned_p
|
&& !specs->complex_p);
|
&& !specs->complex_p);
|
specs->type = boolean_type_node;
|
specs->type = boolean_type_node;
|
break;
|
break;
|
case cts_char:
|
case cts_char:
|
gcc_assert (!specs->long_p && !specs->short_p);
|
gcc_assert (!specs->long_p && !specs->short_p);
|
gcc_assert (!(specs->signed_p && specs->unsigned_p));
|
gcc_assert (!(specs->signed_p && specs->unsigned_p));
|
if (specs->signed_p)
|
if (specs->signed_p)
|
specs->type = signed_char_type_node;
|
specs->type = signed_char_type_node;
|
else if (specs->unsigned_p)
|
else if (specs->unsigned_p)
|
specs->type = unsigned_char_type_node;
|
specs->type = unsigned_char_type_node;
|
else
|
else
|
specs->type = char_type_node;
|
specs->type = char_type_node;
|
if (specs->complex_p)
|
if (specs->complex_p)
|
{
|
{
|
pedwarn (input_location, OPT_pedantic,
|
pedwarn (input_location, OPT_pedantic,
|
"ISO C does not support complex integer types");
|
"ISO C does not support complex integer types");
|
specs->type = build_complex_type (specs->type);
|
specs->type = build_complex_type (specs->type);
|
}
|
}
|
break;
|
break;
|
case cts_int:
|
case cts_int:
|
gcc_assert (!(specs->long_p && specs->short_p));
|
gcc_assert (!(specs->long_p && specs->short_p));
|
gcc_assert (!(specs->signed_p && specs->unsigned_p));
|
gcc_assert (!(specs->signed_p && specs->unsigned_p));
|
if (specs->long_long_p)
|
if (specs->long_long_p)
|
specs->type = (specs->unsigned_p
|
specs->type = (specs->unsigned_p
|
? long_long_unsigned_type_node
|
? long_long_unsigned_type_node
|
: long_long_integer_type_node);
|
: long_long_integer_type_node);
|
else if (specs->long_p)
|
else if (specs->long_p)
|
specs->type = (specs->unsigned_p
|
specs->type = (specs->unsigned_p
|
? long_unsigned_type_node
|
? long_unsigned_type_node
|
: long_integer_type_node);
|
: long_integer_type_node);
|
else if (specs->short_p)
|
else if (specs->short_p)
|
specs->type = (specs->unsigned_p
|
specs->type = (specs->unsigned_p
|
? short_unsigned_type_node
|
? short_unsigned_type_node
|
: short_integer_type_node);
|
: short_integer_type_node);
|
else
|
else
|
specs->type = (specs->unsigned_p
|
specs->type = (specs->unsigned_p
|
? unsigned_type_node
|
? unsigned_type_node
|
: integer_type_node);
|
: integer_type_node);
|
if (specs->complex_p)
|
if (specs->complex_p)
|
{
|
{
|
pedwarn (input_location, OPT_pedantic,
|
pedwarn (input_location, OPT_pedantic,
|
"ISO C does not support complex integer types");
|
"ISO C does not support complex integer types");
|
specs->type = build_complex_type (specs->type);
|
specs->type = build_complex_type (specs->type);
|
}
|
}
|
break;
|
break;
|
case cts_float:
|
case cts_float:
|
gcc_assert (!specs->long_p && !specs->short_p
|
gcc_assert (!specs->long_p && !specs->short_p
|
&& !specs->signed_p && !specs->unsigned_p);
|
&& !specs->signed_p && !specs->unsigned_p);
|
specs->type = (specs->complex_p
|
specs->type = (specs->complex_p
|
? complex_float_type_node
|
? complex_float_type_node
|
: float_type_node);
|
: float_type_node);
|
break;
|
break;
|
case cts_double:
|
case cts_double:
|
gcc_assert (!specs->long_long_p && !specs->short_p
|
gcc_assert (!specs->long_long_p && !specs->short_p
|
&& !specs->signed_p && !specs->unsigned_p);
|
&& !specs->signed_p && !specs->unsigned_p);
|
if (specs->long_p)
|
if (specs->long_p)
|
{
|
{
|
specs->type = (specs->complex_p
|
specs->type = (specs->complex_p
|
? complex_long_double_type_node
|
? complex_long_double_type_node
|
: long_double_type_node);
|
: long_double_type_node);
|
}
|
}
|
else
|
else
|
{
|
{
|
specs->type = (specs->complex_p
|
specs->type = (specs->complex_p
|
? complex_double_type_node
|
? complex_double_type_node
|
: double_type_node);
|
: double_type_node);
|
}
|
}
|
break;
|
break;
|
case cts_dfloat32:
|
case cts_dfloat32:
|
case cts_dfloat64:
|
case cts_dfloat64:
|
case cts_dfloat128:
|
case cts_dfloat128:
|
gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
|
gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
|
&& !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
|
&& !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
|
if (specs->typespec_word == cts_dfloat32)
|
if (specs->typespec_word == cts_dfloat32)
|
specs->type = dfloat32_type_node;
|
specs->type = dfloat32_type_node;
|
else if (specs->typespec_word == cts_dfloat64)
|
else if (specs->typespec_word == cts_dfloat64)
|
specs->type = dfloat64_type_node;
|
specs->type = dfloat64_type_node;
|
else
|
else
|
specs->type = dfloat128_type_node;
|
specs->type = dfloat128_type_node;
|
break;
|
break;
|
case cts_fract:
|
case cts_fract:
|
gcc_assert (!specs->complex_p);
|
gcc_assert (!specs->complex_p);
|
if (!targetm.fixed_point_supported_p ())
|
if (!targetm.fixed_point_supported_p ())
|
specs->type = integer_type_node;
|
specs->type = integer_type_node;
|
else if (specs->saturating_p)
|
else if (specs->saturating_p)
|
{
|
{
|
if (specs->long_long_p)
|
if (specs->long_long_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? sat_unsigned_long_long_fract_type_node
|
? sat_unsigned_long_long_fract_type_node
|
: sat_long_long_fract_type_node;
|
: sat_long_long_fract_type_node;
|
else if (specs->long_p)
|
else if (specs->long_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? sat_unsigned_long_fract_type_node
|
? sat_unsigned_long_fract_type_node
|
: sat_long_fract_type_node;
|
: sat_long_fract_type_node;
|
else if (specs->short_p)
|
else if (specs->short_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? sat_unsigned_short_fract_type_node
|
? sat_unsigned_short_fract_type_node
|
: sat_short_fract_type_node;
|
: sat_short_fract_type_node;
|
else
|
else
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? sat_unsigned_fract_type_node
|
? sat_unsigned_fract_type_node
|
: sat_fract_type_node;
|
: sat_fract_type_node;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (specs->long_long_p)
|
if (specs->long_long_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? unsigned_long_long_fract_type_node
|
? unsigned_long_long_fract_type_node
|
: long_long_fract_type_node;
|
: long_long_fract_type_node;
|
else if (specs->long_p)
|
else if (specs->long_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? unsigned_long_fract_type_node
|
? unsigned_long_fract_type_node
|
: long_fract_type_node;
|
: long_fract_type_node;
|
else if (specs->short_p)
|
else if (specs->short_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? unsigned_short_fract_type_node
|
? unsigned_short_fract_type_node
|
: short_fract_type_node;
|
: short_fract_type_node;
|
else
|
else
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? unsigned_fract_type_node
|
? unsigned_fract_type_node
|
: fract_type_node;
|
: fract_type_node;
|
}
|
}
|
break;
|
break;
|
case cts_accum:
|
case cts_accum:
|
gcc_assert (!specs->complex_p);
|
gcc_assert (!specs->complex_p);
|
if (!targetm.fixed_point_supported_p ())
|
if (!targetm.fixed_point_supported_p ())
|
specs->type = integer_type_node;
|
specs->type = integer_type_node;
|
else if (specs->saturating_p)
|
else if (specs->saturating_p)
|
{
|
{
|
if (specs->long_long_p)
|
if (specs->long_long_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? sat_unsigned_long_long_accum_type_node
|
? sat_unsigned_long_long_accum_type_node
|
: sat_long_long_accum_type_node;
|
: sat_long_long_accum_type_node;
|
else if (specs->long_p)
|
else if (specs->long_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? sat_unsigned_long_accum_type_node
|
? sat_unsigned_long_accum_type_node
|
: sat_long_accum_type_node;
|
: sat_long_accum_type_node;
|
else if (specs->short_p)
|
else if (specs->short_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? sat_unsigned_short_accum_type_node
|
? sat_unsigned_short_accum_type_node
|
: sat_short_accum_type_node;
|
: sat_short_accum_type_node;
|
else
|
else
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? sat_unsigned_accum_type_node
|
? sat_unsigned_accum_type_node
|
: sat_accum_type_node;
|
: sat_accum_type_node;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (specs->long_long_p)
|
if (specs->long_long_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? unsigned_long_long_accum_type_node
|
? unsigned_long_long_accum_type_node
|
: long_long_accum_type_node;
|
: long_long_accum_type_node;
|
else if (specs->long_p)
|
else if (specs->long_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? unsigned_long_accum_type_node
|
? unsigned_long_accum_type_node
|
: long_accum_type_node;
|
: long_accum_type_node;
|
else if (specs->short_p)
|
else if (specs->short_p)
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? unsigned_short_accum_type_node
|
? unsigned_short_accum_type_node
|
: short_accum_type_node;
|
: short_accum_type_node;
|
else
|
else
|
specs->type = specs->unsigned_p
|
specs->type = specs->unsigned_p
|
? unsigned_accum_type_node
|
? unsigned_accum_type_node
|
: accum_type_node;
|
: accum_type_node;
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
return specs;
|
return specs;
|
}
|
}
|
|
|
/* A subroutine of c_write_global_declarations. Perform final processing
|
/* A subroutine of c_write_global_declarations. Perform final processing
|
on one file scope's declarations (or the external scope's declarations),
|
on one file scope's declarations (or the external scope's declarations),
|
GLOBALS. */
|
GLOBALS. */
|
|
|
static void
|
static void
|
c_write_global_declarations_1 (tree globals)
|
c_write_global_declarations_1 (tree globals)
|
{
|
{
|
tree decl;
|
tree decl;
|
bool reconsider;
|
bool reconsider;
|
|
|
/* Process the decls in the order they were written. */
|
/* Process the decls in the order they were written. */
|
for (decl = globals; decl; decl = TREE_CHAIN (decl))
|
for (decl = globals; decl; decl = TREE_CHAIN (decl))
|
{
|
{
|
/* Check for used but undefined static functions using the C
|
/* Check for used but undefined static functions using the C
|
standard's definition of "used", and set TREE_NO_WARNING so
|
standard's definition of "used", and set TREE_NO_WARNING so
|
that check_global_declarations doesn't repeat the check. */
|
that check_global_declarations doesn't repeat the check. */
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
&& DECL_INITIAL (decl) == 0
|
&& DECL_INITIAL (decl) == 0
|
&& DECL_EXTERNAL (decl)
|
&& DECL_EXTERNAL (decl)
|
&& !TREE_PUBLIC (decl)
|
&& !TREE_PUBLIC (decl)
|
&& C_DECL_USED (decl))
|
&& C_DECL_USED (decl))
|
{
|
{
|
pedwarn (input_location, 0, "%q+F used but never defined", decl);
|
pedwarn (input_location, 0, "%q+F used but never defined", decl);
|
TREE_NO_WARNING (decl) = 1;
|
TREE_NO_WARNING (decl) = 1;
|
}
|
}
|
|
|
wrapup_global_declaration_1 (decl);
|
wrapup_global_declaration_1 (decl);
|
}
|
}
|
|
|
do
|
do
|
{
|
{
|
reconsider = false;
|
reconsider = false;
|
for (decl = globals; decl; decl = TREE_CHAIN (decl))
|
for (decl = globals; decl; decl = TREE_CHAIN (decl))
|
reconsider |= wrapup_global_declaration_2 (decl);
|
reconsider |= wrapup_global_declaration_2 (decl);
|
}
|
}
|
while (reconsider);
|
while (reconsider);
|
|
|
for (decl = globals; decl; decl = TREE_CHAIN (decl))
|
for (decl = globals; decl; decl = TREE_CHAIN (decl))
|
check_global_declaration_1 (decl);
|
check_global_declaration_1 (decl);
|
}
|
}
|
|
|
/* A subroutine of c_write_global_declarations Emit debug information for each
|
/* A subroutine of c_write_global_declarations Emit debug information for each
|
of the declarations in GLOBALS. */
|
of the declarations in GLOBALS. */
|
|
|
static void
|
static void
|
c_write_global_declarations_2 (tree globals)
|
c_write_global_declarations_2 (tree globals)
|
{
|
{
|
tree decl;
|
tree decl;
|
|
|
for (decl = globals; decl ; decl = TREE_CHAIN (decl))
|
for (decl = globals; decl ; decl = TREE_CHAIN (decl))
|
debug_hooks->global_decl (decl);
|
debug_hooks->global_decl (decl);
|
}
|
}
|
|
|
/* Preserve the external declarations scope across a garbage collect. */
|
/* Preserve the external declarations scope across a garbage collect. */
|
static GTY(()) tree ext_block;
|
static GTY(()) tree ext_block;
|
|
|
void
|
void
|
c_write_global_declarations (void)
|
c_write_global_declarations (void)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
/* We don't want to do this if generating a PCH. */
|
/* We don't want to do this if generating a PCH. */
|
if (pch_file)
|
if (pch_file)
|
return;
|
return;
|
|
|
/* Don't waste time on further processing if -fsyntax-only.
|
/* Don't waste time on further processing if -fsyntax-only.
|
Continue for warning and errors issued during lowering though. */
|
Continue for warning and errors issued during lowering though. */
|
if (flag_syntax_only)
|
if (flag_syntax_only)
|
return;
|
return;
|
|
|
/* Close the external scope. */
|
/* Close the external scope. */
|
ext_block = pop_scope ();
|
ext_block = pop_scope ();
|
external_scope = 0;
|
external_scope = 0;
|
gcc_assert (!current_scope);
|
gcc_assert (!current_scope);
|
|
|
if (ext_block)
|
if (ext_block)
|
{
|
{
|
tree tmp = BLOCK_VARS (ext_block);
|
tree tmp = BLOCK_VARS (ext_block);
|
int flags;
|
int flags;
|
FILE * stream = dump_begin (TDI_tu, &flags);
|
FILE * stream = dump_begin (TDI_tu, &flags);
|
if (stream && tmp)
|
if (stream && tmp)
|
{
|
{
|
dump_node (tmp, flags & ~TDF_SLIM, stream);
|
dump_node (tmp, flags & ~TDF_SLIM, stream);
|
dump_end (TDI_tu, stream);
|
dump_end (TDI_tu, stream);
|
}
|
}
|
}
|
}
|
|
|
/* Process all file scopes in this compilation, and the external_scope,
|
/* Process all file scopes in this compilation, and the external_scope,
|
through wrapup_global_declarations and check_global_declarations. */
|
through wrapup_global_declarations and check_global_declarations. */
|
for (t = all_translation_units; t; t = TREE_CHAIN (t))
|
for (t = all_translation_units; t; t = TREE_CHAIN (t))
|
c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
|
c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
|
c_write_global_declarations_1 (BLOCK_VARS (ext_block));
|
c_write_global_declarations_1 (BLOCK_VARS (ext_block));
|
|
|
/* We're done parsing; proceed to optimize and emit assembly.
|
/* We're done parsing; proceed to optimize and emit assembly.
|
FIXME: shouldn't be the front end's responsibility to call this. */
|
FIXME: shouldn't be the front end's responsibility to call this. */
|
cgraph_finalize_compilation_unit ();
|
cgraph_finalize_compilation_unit ();
|
|
|
/* After cgraph has had a chance to emit everything that's going to
|
/* After cgraph has had a chance to emit everything that's going to
|
be emitted, output debug information for globals. */
|
be emitted, output debug information for globals. */
|
if (errorcount == 0 && sorrycount == 0)
|
if (errorcount == 0 && sorrycount == 0)
|
{
|
{
|
timevar_push (TV_SYMOUT);
|
timevar_push (TV_SYMOUT);
|
for (t = all_translation_units; t; t = TREE_CHAIN (t))
|
for (t = all_translation_units; t; t = TREE_CHAIN (t))
|
c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
|
c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
|
c_write_global_declarations_2 (BLOCK_VARS (ext_block));
|
c_write_global_declarations_2 (BLOCK_VARS (ext_block));
|
timevar_pop (TV_SYMOUT);
|
timevar_pop (TV_SYMOUT);
|
}
|
}
|
|
|
ext_block = NULL;
|
ext_block = NULL;
|
}
|
}
|
|
|
#include "gt-c-decl.h"
|
#include "gt-c-decl.h"
|
|
|